sqlite: set thread mode to multi threaded

Author: geeksilva97

deps/sqlite/sqlite.gyp

@@ -25,6 +25,7 @@
         'SQLITE_ENABLE_RBU',
         'SQLITE_ENABLE_RTREE',
         'SQLITE_ENABLE_SESSION',
+        'SQLITE_THREADSAFE=2',
       ],
       'include_dirs': ['.'],
       'sources': [

deps/sqlite/unofficial.gni

@@ -19,6 +19,7 @@ template("sqlite_gn_build") {
       "SQLITE_ENABLE_RBU",
       "SQLITE_ENABLE_RTREE",
       "SQLITE_ENABLE_SESSION",
+      "SQLITE_THREADSAFE=2",
     ]
   }
 

src/node_sqlite.cc

@@ -474,6 +474,7 @@ class SQLiteAsyncTask : public ThreadPoolWork {
       after_(result_, resolver);
       Finalize();
     }
+    db_->ProcessNextAsyncTask();
   }
 
   void Finalize() { db_->RemoveAsyncTask(this); }
@@ -745,6 +746,25 @@ void Database::RemoveAsyncTask(ThreadPoolWork* async_task) {
   async_tasks_.erase(async_task);
 }
 
+void Database::ScheduleAsyncTask(ThreadPoolWork* work) {
+  if (has_running_task_) {
+    task_queue_.push(work);
+  } else {
+    has_running_task_ = true;
+    work->ScheduleWork();
+  }
+}
+
+void Database::ProcessNextAsyncTask() {
+  if (task_queue_.empty()) {
+    has_running_task_ = false;
+  } else {
+    ThreadPoolWork* next_work = task_queue_.front();
+    task_queue_.pop();
+    next_work->ScheduleWork();
+  }
+}
+
 void Database::DeleteSessions() {
   // all attached sessions need to be deleted before the database is closed
   // https://www.sqlite.org/session/sqlite3session_create.html
@@ -1234,8 +1254,8 @@ Local<Promise::Resolver> MakeSQLiteAsyncWork(
   }
 
   auto* work = new SQLiteAsyncTask<T>(env, db, resolver, task, after);
-  work->ScheduleWork();
   db->AddAsyncTask(work);
+  db->ScheduleAsyncTask(work);
   return resolver;
 }
 
@@ -2609,6 +2629,8 @@ MaybeLocal<Promise::Resolver> StatementAsyncExecutionHelper::Get(
   Database* db = stmt->db_.get();
   auto task = [stmt]() -> std::tuple<int, int> {
     int r = sqlite3_step(stmt->statement_);
+    std::cout << "In Get Task\n";
+    std::cout << "Step result: " << r << "\n";
     if (r != SQLITE_ROW && r != SQLITE_DONE) {
       return std::make_tuple(r, 0);
     }
@@ -2619,6 +2641,10 @@ MaybeLocal<Promise::Resolver> StatementAsyncExecutionHelper::Get(
                                Local<Promise::Resolver> resolver) {
     Isolate* isolate = env->isolate();
     auto [r, num_cols] = task_result;
+
+    std::cout << "After Get\n";
+    std::cout << "r: " << r << ", num_cols: " << num_cols << "\n";
+
     if (r == SQLITE_DONE) {
       resolver->Resolve(env->context(), Undefined(isolate)).FromJust();
       return;

src/node_sqlite.h

@@ -12,6 +12,7 @@
 
 #include <list>
 #include <map>
+#include <queue>
 #include <unordered_set>
 
 namespace node {
@@ -194,6 +195,8 @@ class Database : public BaseObject {
   void AddBackup(BackupJob* backup);
   void AddAsyncTask(ThreadPoolWork* async_task);
   void RemoveAsyncTask(ThreadPoolWork* async_task);
+  void ScheduleAsyncTask(ThreadPoolWork* async_task);
+  void ProcessNextAsyncTask();
   void FinalizeBackups();
   void UntrackStatement(Statement* statement);
   bool IsOpen();
@@ -230,6 +233,8 @@ class Database : public BaseObject {
   bool ignore_next_sqlite_error_;
 
   std::set<ThreadPoolWork*> async_tasks_;
+  std::queue<ThreadPoolWork*> task_queue_;
+  bool has_running_task_ = false;
   std::set<BackupJob*> backups_;
   std::set<sqlite3_session*> sessions_;
   std::unordered_set<Statement*> statements_;