@photostructure/sqlite 0.0.1 → 0.2.1

package/src/upstream/node_sqlite.h

@@ -4,10 +4,12 @@
 #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
 #include "base_object.h"
+#include "lru_cache-inl.h"
 #include "node_mem.h"
 #include "sqlite3.h"
 #include "util.h"
 
+#include <list>
 #include <map>
 #include <unordered_set>
 
@@ -39,19 +41,86 @@ class DatabaseOpenConfiguration {
 
   inline int get_timeout() { return timeout_; }
 
+  inline void set_use_big_ints(bool flag) { use_big_ints_ = flag; }
+
+  inline bool get_use_big_ints() const { return use_big_ints_; }
+
+  inline void set_return_arrays(bool flag) { return_arrays_ = flag; }
+
+  inline bool get_return_arrays() const { return return_arrays_; }
+
+  inline void set_allow_bare_named_params(bool flag) {
+    allow_bare_named_params_ = flag;
+  }
+
+  inline bool get_allow_bare_named_params() const {
+    return allow_bare_named_params_;
+  }
+
+  inline void set_allow_unknown_named_params(bool flag) {
+    allow_unknown_named_params_ = flag;
+  }
+
+  inline bool get_allow_unknown_named_params() const {
+    return allow_unknown_named_params_;
+  }
+
+  inline void set_enable_defensive(bool flag) { defensive_ = flag; }
+
+  inline bool get_enable_defensive() const { return defensive_; }
+
  private:
   std::string location_;
   bool read_only_ = false;
   bool enable_foreign_keys_ = true;
   bool enable_dqs_ = false;
   int timeout_ = 0;
+  bool use_big_ints_ = false;
+  bool return_arrays_ = false;
+  bool allow_bare_named_params_ = true;
+  bool allow_unknown_named_params_ = false;
+  bool defensive_ = false;
 };
 
+class DatabaseSync;
+class StatementSyncIterator;
 class StatementSync;
 class BackupJob;
 
+class StatementExecutionHelper {
+ public:
+  static v8::MaybeLocal<v8::Value> All(Environment* env,
+                                       DatabaseSync* db,
+                                       sqlite3_stmt* stmt,
+                                       bool return_arrays,
+                                       bool use_big_ints);
+  static v8::MaybeLocal<v8::Object> Run(Environment* env,
+                                        DatabaseSync* db,
+                                        sqlite3_stmt* stmt,
+                                        bool use_big_ints);
+  static BaseObjectPtr<StatementSyncIterator> Iterate(
+      Environment* env, BaseObjectPtr<StatementSync> stmt);
+  static v8::MaybeLocal<v8::Value> ColumnToValue(Environment* env,
+                                                 sqlite3_stmt* stmt,
+                                                 const int column,
+                                                 bool use_big_ints);
+  static v8::MaybeLocal<v8::Name> ColumnNameToName(Environment* env,
+                                                   sqlite3_stmt* stmt,
+                                                   const int column);
+  static v8::MaybeLocal<v8::Value> Get(Environment* env,
+                                       DatabaseSync* db,
+                                       sqlite3_stmt* stmt,
+                                       bool return_arrays,
+                                       bool use_big_ints);
+};
+
 class DatabaseSync : public BaseObject {
  public:
+  enum InternalFields {
+    kAuthorizerCallback = BaseObject::kInternalFieldCount,
+    kInternalFieldCount
+  };
+
   DatabaseSync(Environment* env,
                v8::Local<v8::Object> object,
                DatabaseOpenConfiguration&& open_config,
@@ -64,8 +133,10 @@ class DatabaseSync : public BaseObject {
   static void IsTransactionGetter(
       const v8::FunctionCallbackInfo<v8::Value>& args);
   static void Close(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Dispose(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void Prepare(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void Exec(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void CreateTagStore(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void Location(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void CustomFunction(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void AggregateFunction(
@@ -74,13 +145,29 @@ class DatabaseSync : public BaseObject {
   static void ApplyChangeset(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void EnableLoadExtension(
       const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void EnableDefensive(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void LoadExtension(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void SetAuthorizer(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static int AuthorizerCallback(void* user_data,
+                                int action_code,
+                                const char* param1,
+                                const char* param2,
+                                const char* param3,
+                                const char* param4);
   void FinalizeStatements();
   void RemoveBackup(BackupJob* backup);
   void AddBackup(BackupJob* backup);
   void FinalizeBackups();
   void UntrackStatement(StatementSync* statement);
   bool IsOpen();
+  bool use_big_ints() const { return open_config_.get_use_big_ints(); }
+  bool return_arrays() const { return open_config_.get_return_arrays(); }
+  bool allow_bare_named_params() const {
+    return open_config_.get_allow_bare_named_params();
+  }
+  bool allow_unknown_named_params() const {
+    return open_config_.get_allow_unknown_named_params();
+  }
   sqlite3* Connection();
 
   // In some situations, such as when using custom functions, it is possible
@@ -109,6 +196,8 @@ class DatabaseSync : public BaseObject {
   std::unordered_set<StatementSync*> statements_;
 
   friend class Session;
+  friend class SQLTagStore;
+  friend class StatementExecutionHelper;
 };
 
 class StatementSync : public BaseObject {
@@ -137,6 +226,8 @@ class StatementSync : public BaseObject {
       const v8::FunctionCallbackInfo<v8::Value>& args);
   static void SetReadBigInts(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void SetReturnArrays(const v8::FunctionCallbackInfo<v8::Value>& args);
+  v8::MaybeLocal<v8::Value> ColumnToValue(const int column);
+  v8::MaybeLocal<v8::Name> ColumnNameToName(const int column);
   void Finalize();
   bool IsFinalized();
 
@@ -154,10 +245,10 @@ class StatementSync : public BaseObject {
   std::optional<std::map<std::string, std::string>> bare_named_params_;
   bool BindParams(const v8::FunctionCallbackInfo<v8::Value>& args);
   bool BindValue(const v8::Local<v8::Value>& value, const int index);
-  v8::MaybeLocal<v8::Value> ColumnToValue(const int column);
-  v8::MaybeLocal<v8::Name> ColumnNameToName(const int column);
 
   friend class StatementSyncIterator;
+  friend class SQLTagStore;
+  friend class StatementExecutionHelper;
 };
 
 class StatementSyncIterator : public BaseObject {
@@ -194,6 +285,7 @@ class Session : public BaseObject {
   template <Sqlite3ChangesetGenFunc sqliteChangesetFunc>
   static void Changeset(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void Close(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Dispose(const v8::FunctionCallbackInfo<v8::Value>& args);
   static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(
       Environment* env);
   static BaseObjectPtr<Session> Create(Environment* env,
@@ -210,6 +302,39 @@ class Session : public BaseObject {
   BaseObjectWeakPtr<DatabaseSync> database_;  // The Parent Database
 };
 
+class SQLTagStore : public BaseObject {
+ public:
+  SQLTagStore(Environment* env,
+              v8::Local<v8::Object> object,
+              BaseObjectWeakPtr<DatabaseSync> database,
+              int capacity);
+  ~SQLTagStore() override;
+  static BaseObjectPtr<SQLTagStore> Create(
+      Environment* env, BaseObjectWeakPtr<DatabaseSync> database, int capacity);
+  static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(
+      Environment* env);
+  static void All(const v8::FunctionCallbackInfo<v8::Value>& info);
+  static void Get(const v8::FunctionCallbackInfo<v8::Value>& info);
+  static void Iterate(const v8::FunctionCallbackInfo<v8::Value>& info);
+  static void Run(const v8::FunctionCallbackInfo<v8::Value>& info);
+  static void Size(const v8::FunctionCallbackInfo<v8::Value>& info);
+  static void Capacity(const v8::FunctionCallbackInfo<v8::Value>& info);
+  static void Reset(const v8::FunctionCallbackInfo<v8::Value>& info);
+  static void Clear(const v8::FunctionCallbackInfo<v8::Value>& info);
+  static void DatabaseGetter(const v8::FunctionCallbackInfo<v8::Value>& info);
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_MEMORY_INFO_NAME(SQLTagStore)
+  SET_SELF_SIZE(SQLTagStore)
+
+ private:
+  static BaseObjectPtr<StatementSync> PrepareStatement(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  BaseObjectWeakPtr<DatabaseSync> database_;
+  LRUCache<std::string, BaseObjectPtr<StatementSync>> sql_tags_;
+  int capacity_;
+  friend class StatementExecutionHelper;
+};
+
 class UserDefinedFunction {
  public:
   UserDefinedFunction(Environment* env,

package/src/upstream/sqlite.js

@@ -1,19 +1,6 @@
 'use strict';
-const {
-  SymbolDispose,
-} = primordials;
 const { emitExperimentalWarning } = require('internal/util');
-const binding = internalBinding('sqlite');
 
 emitExperimentalWarning('SQLite');
 
-// TODO(cjihrig): Move this to C++ once Symbol.dispose reaches Stage 4.
-binding.DatabaseSync.prototype[SymbolDispose] = function() {
-  try {
-    this.close();
-  } catch {
-    // Ignore errors.
-  }
-};
-
-module.exports = binding;
+module.exports = internalBinding('sqlite');