@op-engineering/op-sqlite 1.0.9 → 1.0.11

package/cpp/ThreadPool.cpp

@@ -2,94 +2,129 @@
 
 namespace opsqlite {
 
-ThreadPool::ThreadPool() : done(false)
-{
-  // This returns the number of threads supported by the system. If the
-  // function can't figure out this information, it returns 0. 0 is not good,
-  // so we create at least 1
-  auto numberOfThreads = std::thread::hardware_concurrency();
-  if (numberOfThreads == 0)
-  {
-    numberOfThreads = 1;
-  }
-
-  for (unsigned i = 0; i < numberOfThreads; ++i)
-  {
-    // The threads will execute the private member `doWork`. Note that we need
-    // to pass a reference to the function (namespaced with the class name) as
-    // the first argument, and the current object as second argument
-    threads.push_back(std::thread(&ThreadPool::doWork, this));
-  }
-}
-
-// The destructor joins all the threads so the program can exit gracefully.
-// This will be executed if there is any exception (e.g. creating the threads)
-ThreadPool::~ThreadPool()
-{
-  // So threads know it's time to shut down
-  done = true;
-
-  // Wake up all the threads, so they can finish and be joined
-  workQueueConditionVariable.notify_all();
-  for (auto &thread : threads)
-  {
-    if (thread.joinable())
+    ThreadPool::ThreadPool() : done(false)
     {
-      thread.join();
+        // This returns the number of threads supported by the system. If the
+        // function can't figure out this information, it returns 0. 0 is not good,
+        // so we create at least 1
+        auto numberOfThreads = std::thread::hardware_concurrency();
+        if (numberOfThreads == 0)
+        {
+            numberOfThreads = 1;
+        }
+        
+        for (unsigned i = 0; i < numberOfThreads; ++i)
+        {
+            // The threads will execute the private member `doWork`. Note that we need
+            // to pass a reference to the function (namespaced with the class name) as
+            // the first argument, and the current object as second argument
+            threads.push_back(std::thread(&ThreadPool::doWork, this));
+        }
     }
-  }
-}
-
-// This function will be called by the server every time there is a request
-// that needs to be processed by the thread pool
-void ThreadPool::queueWork(std::function<void(void)> task)
-{
-  // Grab the mutex
-  std::lock_guard<std::mutex> g(workQueueMutex);
-
-  // Push the request to the queue
-  workQueue.push(task);
-
-  // Notify one thread that there are requests to process
-  workQueueConditionVariable.notify_one();
-}
-
-// Function used by the threads to grab work from the queue
-void ThreadPool::doWork()
-{
-  // Loop while the queue is not destructing
-  while (!done)
-  {
-    std::function<void(void)> task;
 
-    // Create a scope, so we don't lock the queue for longer than necessary
+    // The destructor joins all the threads so the program can exit gracefully.
+    // This will be executed if there is any exception (e.g. creating the threads)
+    ThreadPool::~ThreadPool()
     {
-      std::unique_lock<std::mutex> g(workQueueMutex);
-      workQueueConditionVariable.wait(g, [&]
-                                      {
-        // Only wake up if there are elements in the queue or the program is
-        // shutting down
-        return !workQueue.empty() || done; });
-
-      // If we are shutting down exit witout trying to process more work
-      if (done)
-      {
-        break;
-      }
+        // So threads know it's time to shut down
+        done = true;
+        
+        // Wake up all the threads, so they can finish and be joined
+        workQueueConditionVariable.notify_all();
+        
+        for (auto &thread : threads)
+        {
+            if (thread.joinable())
+            {
+                thread.join();
+            }
+        }
+        
+        threads.clear();
+    }
 
-      task = workQueue.front();
-      workQueue.pop();
+    // This function will be called by the server every time there is a request
+    // that needs to be processed by the thread pool
+    void ThreadPool::queueWork(std::function<void(void)> task)
+    {
+        // Grab the mutex
+        std::lock_guard<std::mutex> g(workQueueMutex);
+        
+        // Push the request to the queue
+        workQueue.push(task);
+        
+        // Notify one thread that there are requests to process
+        workQueueConditionVariable.notify_one();
     }
-    ++busy;
-    task();
-    --busy;
-  }
-}
 
-void ThreadPool::waitFinished() {
-  std::unique_lock<std::mutex> g(workQueueMutex);
-  workQueueConditionVariable.wait(g, [&]{ return workQueue.empty() && (busy == 0); });
-}
+    // Function used by the threads to grab work from the queue
+    void ThreadPool::doWork()
+    {
+        // Loop while the queue is not destructing
+        while (!done)
+        {
+            std::function<void(void)> task;
+            
+            // Create a scope, so we don't lock the queue for longer than necessary
+            {
+                std::unique_lock<std::mutex> g(workQueueMutex);
+                workQueueConditionVariable.wait(g, [&]
+                                                {
+                    // Only wake up if there are elements in the queue or the program is
+                    // shutting down
+                    return !workQueue.empty() || done; });
+                
+                // If we are shutting down exit witout trying to process more work
+                if (done)
+                {
+                    break;
+                }
+                
+                task = workQueue.front();
+                workQueue.pop();
+            }
+            ++busy;
+            task();
+            --busy;
+        }
+    }
 
+    void ThreadPool::waitFinished() {
+        std::unique_lock<std::mutex> g(workQueueMutex);
+        workQueueConditionVariable.wait(g, [&]{ return workQueue.empty() && (busy == 0); });
+    }
 
+    void ThreadPool::restartPool() {
+        // So threads know it's time to shut down
+        done = true;
+        
+        // Wake up all the threads, so they can finish and be joined
+        workQueueConditionVariable.notify_all();
+        
+        for (auto &thread : threads)
+        {
+            if (thread.joinable())
+            {
+                thread.join();
+            }
+        }
+        
+        threads.clear();
+        
+        auto numberOfThreads = std::thread::hardware_concurrency();
+        if (numberOfThreads == 0)
+        {
+            numberOfThreads = 1;
+        }
+        
+        for (unsigned i = 0; i < numberOfThreads; ++i)
+        {
+            // The threads will execute the private member `doWork`. Note that we need
+            // to pass a reference to the function (namespaced with the class name) as
+            // the first argument, and the current object as second argument
+            threads.push_back(std::thread(&ThreadPool::doWork, this));
+        }
+        
+        done = false;
+    }
 }

package/cpp/ThreadPool.h

@@ -13,32 +13,33 @@ namespace opsqlite {
 
 class ThreadPool {
 public:
-  ThreadPool();
-  ~ThreadPool();
-  void queueWork(std::function<void(void)> task);
-  void waitFinished();
-
+    ThreadPool();
+    ~ThreadPool();
+    void queueWork(std::function<void(void)> task);
+    void waitFinished();
+    void restartPool();
+    
 private:
-  unsigned int busy;
-  // This condition variable is used for the threads to wait until there is work
-  // to do
-  std::condition_variable_any workQueueConditionVariable;
-
-  // We store the threads in a vector, so we can later stop them gracefully
-  std::vector<std::thread> threads;
-
-  // Mutex to protect workQueue
-  std::mutex workQueueMutex;
-
-  // Queue of requests waiting to be processed
-  std::queue<std::function<void(void)>> workQueue;
-
-  // This will be set to true when the thread pool is shutting down. This tells
-  // the threads to stop looping and finish
-  bool done;
-
-  // Function used by the threads to grab work from the queue
-  void doWork();
+    unsigned int busy;
+    // This condition variable is used for the threads to wait until there is work
+    // to do
+    std::condition_variable_any workQueueConditionVariable;
+    
+    // We store the threads in a vector, so we can later stop them gracefully
+    std::vector<std::thread> threads;
+    
+    // Mutex to protect workQueue
+    std::mutex workQueueMutex;
+    
+    // Queue of requests waiting to be processed
+    std::queue<std::function<void(void)>> workQueue;
+    
+    // This will be set to true when the thread pool is shutting down. This tells
+    // the threads to stop looping and finish
+    bool done;
+    
+    // Function used by the threads to grab work from the queue
+    void doWork();
 };
 
 }

package/cpp/bindings.cpp

@@ -16,16 +16,19 @@ namespace jsi = facebook::jsi;
 
 std::string basePath;
 std::shared_ptr<react::CallInvoker> invoker;
-std::shared_ptr<ThreadPool> pool;
+ThreadPool pool;
+bool invalidated = false;
 
 void clearState() {
+    invalidated = true;
     sqliteCloseAll();
+    pool.restartPool();
 }
 
 void install(jsi::Runtime &rt, std::shared_ptr<react::CallInvoker> jsCallInvoker, const char *docPath)
 {
+    invalidated = false;
     basePath = std::string(docPath);
-    pool = std::make_shared<ThreadPool>();
     invoker = jsCallInvoker;
     
     auto open = HOSTFN("open", 3) {
@@ -227,21 +230,25 @@ void install(jsi::Runtime &rt, std::shared_ptr<react::CallInvoker> jsCallInvoker
         const jsi::Value &originalParams = args[2];
         
         std::vector<JSVariant> params = toVariantVec(rt, originalParams);
-        
+    
         auto promiseCtr = rt.global().getPropertyAsFunction(rt, "Promise");
         auto promise = promiseCtr.callAsConstructor(rt, HOSTFN("executor", 2) {
             auto resolve = std::make_shared<jsi::Value>(rt, args[0]);
             auto reject = std::make_shared<jsi::Value>(rt, args[1]);
             
             auto task =
-            [&rt, dbName, query, params = std::make_shared<std::vector<JSVariant>>(params), resolve, reject]()
+            [&rt, dbName, query, params = std::move(params), resolve, reject]()
             {
                 try
                 {
                     std::vector<DumbHostObject> results;
                     std::shared_ptr<std::vector<DynamicHostObject>> metadata = std::make_shared<std::vector<DynamicHostObject>>();;
                     
-                    auto status = sqliteExecute(dbName, query, params.get(), &results, metadata);
+                    auto status = sqliteExecute(dbName, query, &params, &results, metadata);
+                    
+                    if(invalidated) {
+                        return;
+                    }
                 
                     invoker->invokeAsync([&rt,
                                            results = std::make_shared<std::vector<DumbHostObject>>(results),
@@ -270,7 +277,7 @@ void install(jsi::Runtime &rt, std::shared_ptr<react::CallInvoker> jsCallInvoker
                 }
             };
             
-            pool->queueWork(task);
+            pool.queueWork(task);
             
             return {};
         }));
@@ -363,7 +370,7 @@ void install(jsi::Runtime &rt, std::shared_ptr<react::CallInvoker> jsCallInvoker
                     });
                 }
             };
-            pool->queueWork(task);
+            pool.queueWork(task);
             
             return {};
         }));
@@ -414,7 +421,7 @@ void install(jsi::Runtime &rt, std::shared_ptr<react::CallInvoker> jsCallInvoker
                     });
                 }
             };
-            pool->queueWork(task);
+            pool.queueWork(task);
             return {};
         }));
         

package/cpp/bridge.cpp

@@ -13,277 +13,427 @@
 
 namespace opsqlite {
 
-std::unordered_map<std::string, sqlite3 *> dbMap = std::unordered_map<std::string, sqlite3 *>();
+    std::unordered_map<std::string, sqlite3 *> dbMap = std::unordered_map<std::string, sqlite3 *>();
 
-bool folder_exists(const std::string &foldername)
-{
-    struct stat buffer;
-    return (stat(foldername.c_str(), &buffer) == 0);
-}
-
-/**
- * Portable wrapper for mkdir. Internally used by mkdir()
- * @param[in] path the full path of the directory to create.
- * @return zero on success, otherwise -1.
- */
-int _mkdir(const char *path)
-{
-#if _POSIX_C_SOURCE
-    return mkdir(path);
-#else
-    return mkdir(path, 0755); // not sure if this works on mac
-#endif
-}
-
-/**
- * Recursive, portable wrapper for mkdir.
- * @param[in] path the full path of the directory to create.
- * @return zero on success, otherwise -1.
- */
-int mkdir(const char *path)
-{
-    std::string current_level = "/";
-    std::string level;
-    std::stringstream ss(path);
-    // First line is empty because it starts with /User
-    getline(ss, level, '/');
-    // split path using slash as a separator
-    while (getline(ss, level, '/'))
+    bool folder_exists(const std::string &foldername)
     {
-        current_level += level; // append folder to the current level
-        // create current level
-        if (!folder_exists(current_level) && _mkdir(current_level.c_str()) != 0)
-            return -1;
-        
-        current_level += "/"; // don't forget to append a slash
+        struct stat buffer;
+        return (stat(foldername.c_str(), &buffer) == 0);
     }
-    
-    return 0;
-}
-
-inline bool file_exists(const std::string &path)
-{
-    struct stat buffer;
-    return (stat(path.c_str(), &buffer) == 0);
-}
-
-std::string get_db_path(std::string const dbName, std::string const docPath)
-{
-    mkdir(docPath.c_str());
-    return docPath + "/" + dbName;
-}
 
-BridgeResult sqliteOpenDb(std::string const dbName, std::string const docPath, bool memoryStorage)
-{
-    std::string dbPath = memoryStorage ? ":memory:" : get_db_path(dbName, docPath);
-    
-    int sqlOpenFlags = SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_FULLMUTEX;
-    
-    sqlite3 *db;
-    int exit = 0;
-    exit = sqlite3_open_v2(dbPath.c_str(), &db, sqlOpenFlags, nullptr);
-    
-    if (exit != SQLITE_OK)
+    /**
+     * Portable wrapper for mkdir. Internally used by mkdir()
+     * @param[in] path the full path of the directory to create.
+     * @return zero on success, otherwise -1.
+     */
+    int _mkdir(const char *path)
     {
-        return {
-            .type = SQLiteError,
-            .message = sqlite3_errmsg(db)
-        };
+    #if _POSIX_C_SOURCE
+        return mkdir(path);
+    #else
+        return mkdir(path, 0755); // not sure if this works on mac
+    #endif
     }
-    else
+
+    /**
+     * Recursive, portable wrapper for mkdir.
+     * @param[in] path the full path of the directory to create.
+     * @return zero on success, otherwise -1.
+     */
+    int mkdir(const char *path)
     {
-        dbMap[dbName] = db;
+        std::string current_level = "/";
+        std::string level;
+        std::stringstream ss(path);
+        // First line is empty because it starts with /User
+        getline(ss, level, '/');
+        // split path using slash as a separator
+        while (getline(ss, level, '/'))
+        {
+            current_level += level; // append folder to the current level
+            // create current level
+            if (!folder_exists(current_level) && _mkdir(current_level.c_str()) != 0)
+                return -1;
+            
+            current_level += "/"; // don't forget to append a slash
+        }
+        
+        return 0;
     }
-    
-    return BridgeResult{
-        .type = SQLiteOk,
-        .affectedRows = 0
-    };
-}
 
-BridgeResult sqliteCloseDb(std::string const dbName)
-{
-    
-    if (dbMap.count(dbName) == 0)
+    inline bool file_exists(const std::string &path)
     {
-        return {
-            .type = SQLiteError,
-            .message = dbName + " is not open",
-        };
+        struct stat buffer;
+        return (stat(path.c_str(), &buffer) == 0);
     }
-    
-    sqlite3 *db = dbMap[dbName];
-    
-    sqlite3_close_v2(db);
-    
-    dbMap.erase(dbName);
-    
-    return BridgeResult{
-        .type = SQLiteOk,
-    };
-}
 
-void sqliteCloseAll() {
-    for (auto const& x : dbMap) {
-        // In certain cases, this will return SQLITE_OK, mark the database connection as an unusable "zombie",
-        // and deallocate the connection later.
-        sqlite3_close_v2(x.second);
+    std::string get_db_path(std::string const dbName, std::string const docPath)
+    {
+        mkdir(docPath.c_str());
+        return docPath + "/" + dbName;
     }
-    dbMap.clear();
-}
 
-BridgeResult sqliteAttachDb(std::string const mainDBName, std::string const docPath, std::string const databaseToAttach, std::string const alias)
-{
-    /**
-     * There is no need to check if mainDBName is opened because sqliteExecuteLiteral will do that.
-     * */
-    std::string dbPath = get_db_path(databaseToAttach, docPath);
-    std::string statement = "ATTACH DATABASE '" + dbPath + "' AS " + alias;
-    
-    BridgeResult result = sqliteExecuteLiteral(mainDBName, statement);
-    
-    if (result.type == SQLiteError)
+    BridgeResult sqliteOpenDb(std::string const dbName, std::string const docPath, bool memoryStorage)
     {
-        return {
-            .type = SQLiteError,
-            .message = mainDBName + " was unable to attach another database: " + std::string(result.message),
+        std::string dbPath = memoryStorage ? ":memory:" : get_db_path(dbName, docPath);
+        
+        int sqlOpenFlags = SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_FULLMUTEX;
+        
+        sqlite3 *db;
+        int exit = 0;
+        exit = sqlite3_open_v2(dbPath.c_str(), &db, sqlOpenFlags, nullptr);
+        
+        if (exit != SQLITE_OK)
+        {
+            return {
+                .type = SQLiteError,
+                .message = sqlite3_errmsg(db)
+            };
+        }
+        else
+        {
+            dbMap[dbName] = db;
+        }
+        
+        return BridgeResult{
+            .type = SQLiteOk,
+            .affectedRows = 0
         };
     }
-    return {
-        .type = SQLiteOk,
-    };
-}
 
-BridgeResult sqliteDetachDb(std::string const mainDBName, std::string const alias)
-{
-    /**
-     * There is no need to check if mainDBName is opened because sqliteExecuteLiteral will do that.
-     * */
-    std::string statement = "DETACH DATABASE " + alias;
-    BridgeResult result = sqliteExecuteLiteral(mainDBName, statement);
-    if (result.type == SQLiteError)
+    BridgeResult sqliteCloseDb(std::string const dbName)
     {
+        
+        if (dbMap.count(dbName) == 0)
+        {
+            return {
+                .type = SQLiteError,
+                .message = dbName + " is not open",
+            };
+        }
+        
+        sqlite3 *db = dbMap[dbName];
+        
+        sqlite3_close_v2(db);
+        
+        dbMap.erase(dbName);
+        
         return BridgeResult{
-            .type = SQLiteError,
-            .message = mainDBName + "was unable to detach database: " + std::string(result.message),
+            .type = SQLiteOk,
         };
     }
-    return BridgeResult{
-        .type = SQLiteOk,
-    };
-}
 
-BridgeResult sqliteRemoveDb(std::string const dbName, std::string const docPath)
-{
-    if (dbMap.count(dbName) == 1)
+    BridgeResult sqliteAttachDb(std::string const mainDBName, std::string const docPath, std::string const databaseToAttach, std::string const alias)
     {
-        BridgeResult closeResult = sqliteCloseDb(dbName);
-        if (closeResult.type == SQLiteError)
+        /**
+         * There is no need to check if mainDBName is opened because sqliteExecuteLiteral will do that.
+         * */
+        std::string dbPath = get_db_path(databaseToAttach, docPath);
+        std::string statement = "ATTACH DATABASE '" + dbPath + "' AS " + alias;
+        
+        BridgeResult result = sqliteExecuteLiteral(mainDBName, statement);
+        
+        if (result.type == SQLiteError)
         {
-            return closeResult;
+            return {
+                .type = SQLiteError,
+                .message = mainDBName + " was unable to attach another database: " + std::string(result.message),
+            };
         }
-    }
-    
-    std::string dbPath = get_db_path(dbName, docPath);
-    
-    if (!file_exists(dbPath))
-    {
         return {
-            .type = SQLiteError,
-            .message = "[op-sqlite]: Database file not found" + dbPath
+            .type = SQLiteOk,
         };
     }
-    
-    remove(dbPath.c_str());
-    
-    return {
-        .type = SQLiteOk,
-    };
-}
 
-inline void bindStatement(sqlite3_stmt *statement, std::vector<JSVariant> *values)
-{
-    size_t size = values->size();
-    
-    for (int ii = 0; ii < size; ii++)
+    BridgeResult sqliteDetachDb(std::string const mainDBName, std::string const alias)
     {
-        int sqIndex = ii + 1;
-        JSVariant value = values->at(ii);
-        
-        if (std::holds_alternative<bool>(value))
+        /**
+         * There is no need to check if mainDBName is opened because sqliteExecuteLiteral will do that.
+         * */
+        std::string statement = "DETACH DATABASE " + alias;
+        BridgeResult result = sqliteExecuteLiteral(mainDBName, statement);
+        if (result.type == SQLiteError)
         {
-            sqlite3_bind_int(statement, sqIndex, std::get<bool>(value));
+            return BridgeResult{
+                .type = SQLiteError,
+                .message = mainDBName + "was unable to detach database: " + std::string(result.message),
+            };
         }
-        else if (std::holds_alternative<int>(value))
+        return BridgeResult{
+            .type = SQLiteOk,
+        };
+    }
+
+    BridgeResult sqliteRemoveDb(std::string const dbName, std::string const docPath)
+    {
+        if (dbMap.count(dbName) == 1)
         {
-            sqlite3_bind_int(statement, sqIndex, std::get<int>(value));
+            BridgeResult closeResult = sqliteCloseDb(dbName);
+            if (closeResult.type == SQLiteError)
+            {
+                return closeResult;
+            }
         }
-        else if (std::holds_alternative<long long>(value))
+        
+        std::string dbPath = get_db_path(dbName, docPath);
+        
+        if (!file_exists(dbPath))
         {
-            sqlite3_bind_double(statement, sqIndex, std::get<long long>(value));
+            return {
+                .type = SQLiteError,
+                .message = "[op-sqlite]: Database file not found" + dbPath
+            };
         }
-        else if (std::holds_alternative<double>(value))
+        
+        remove(dbPath.c_str());
+        
+        return {
+            .type = SQLiteOk,
+        };
+    }
+
+    inline void bindStatement(sqlite3_stmt *statement, const std::vector<JSVariant> *values)
+    {
+        size_t size = values->size();
+        
+        for (int ii = 0; ii < size; ii++)
         {
-            sqlite3_bind_double(statement, sqIndex, std::get<double>(value));
+            int sqIndex = ii + 1;
+            JSVariant value = values->at(ii);
+            
+            if (std::holds_alternative<bool>(value))
+            {
+                sqlite3_bind_int(statement, sqIndex, std::get<bool>(value));
+            }
+            else if (std::holds_alternative<int>(value))
+            {
+                sqlite3_bind_int(statement, sqIndex, std::get<int>(value));
+            }
+            else if (std::holds_alternative<long long>(value))
+            {
+                sqlite3_bind_double(statement, sqIndex, std::get<long long>(value));
+            }
+            else if (std::holds_alternative<double>(value))
+            {
+                sqlite3_bind_double(statement, sqIndex, std::get<double>(value));
+            }
+            else if (std::holds_alternative<std::string>(value))
+            {
+                std::string str = std::get<std::string>(value);
+                sqlite3_bind_text(statement, sqIndex, str.c_str(), str.length(), SQLITE_TRANSIENT);
+            }
+            else if(std::holds_alternative<ArrayBuffer>(value))
+            {
+                ArrayBuffer buffer = std::get<ArrayBuffer>(value);
+                sqlite3_bind_blob(statement, sqIndex, buffer.data.get(), buffer.size, SQLITE_STATIC);
+            } else {
+                sqlite3_bind_null(statement, sqIndex);
+            }
         }
-        else if (std::holds_alternative<std::string>(value))
+    }
+
+    BridgeResult sqliteExecute(std::string const dbName,
+                               std::string const &query,
+                               const std::vector<JSVariant> *params,
+                               std::vector<DumbHostObject> *results,
+                               std::shared_ptr<std::vector<DynamicHostObject>> metadatas)
+    {
+        
+        if (dbMap.find(dbName) == dbMap.end())
         {
-            std::string str = std::get<std::string>(value);
-            sqlite3_bind_text(statement, sqIndex, str.c_str(), str.length(), SQLITE_TRANSIENT);
+            return {
+                .type = SQLiteError,
+                .message = "[op-sqlite]: Database " + dbName + " is not open"
+            };
         }
-        else if(std::holds_alternative<ArrayBuffer>(value))
+        
+        sqlite3 *db = dbMap[dbName];
+        
+        sqlite3_stmt *statement;
+        const char *remainingStatement = nullptr;
+        
+        bool isConsuming = true;
+        bool isFailed = false;
+        
+        int result = SQLITE_OK;
+        
+        do {
+            const char *queryStr = remainingStatement == nullptr ? query.c_str() : remainingStatement;
+            
+            int statementStatus = sqlite3_prepare_v2(db, queryStr, -1, &statement, &remainingStatement);
+            
+            if (statementStatus == SQLITE_ERROR)
+            {
+                const char *message = sqlite3_errmsg(db);
+                return {
+                    .type = SQLiteError,
+                    .message = "[op-sqlite] SQL statement error: " + std::string(message),
+                };
+            }
+            
+            bindStatement(statement, params);
+            
+            isConsuming = true;
+            
+            int i, count, column_type;
+            std::string column_name, column_declared_type;
+            
+            while (isConsuming)
+            {
+                result = sqlite3_step(statement);
+                
+                switch (result)
+                {
+                    case SQLITE_ROW: {
+                        if(results == NULL)
+                        {
+                            break;
+                        }
+                        
+                        i = 0;
+                        DumbHostObject row = DumbHostObject(metadatas);
+                        
+                        count = sqlite3_column_count(statement);
+                        
+                        while (i < count)
+                        {
+                            column_type = sqlite3_column_type(statement, i);
+                            
+                            switch (column_type)
+                            {
+                                case SQLITE_INTEGER:
+                                {
+                                    /**
+                                     * Warning this will loose precision because JS can
+                                     * only represent Integers up to 53 bits
+                                     */
+                                    double column_value = sqlite3_column_double(statement, i);
+                                    row.values.push_back(JSVariant(column_value));
+                                    break;
+                                }
+                                    
+                                case SQLITE_FLOAT:
+                                {
+                                    double column_value = sqlite3_column_double(statement, i);
+                                    row.values.push_back(JSVariant(column_value));
+                                    break;
+                                }
+                                    
+                                case SQLITE_TEXT:
+                                {
+                                    const char *column_value = reinterpret_cast<const char *>(sqlite3_column_text(statement, i));
+                                    int byteLen = sqlite3_column_bytes(statement, i);
+                                    // Specify length too; in case string contains NULL in the middle
+                                    row.values.push_back(JSVariant(std::string(column_value, byteLen)));
+                                    break;
+                                }
+                                    
+                                case SQLITE_BLOB:
+                                {
+                                    int blob_size = sqlite3_column_bytes(statement, i);
+                                    const void *blob = sqlite3_column_blob(statement, i);
+                                    uint8_t *data = new uint8_t[blob_size];
+                                    // You cannot share raw memory between native and JS
+                                    // always copy the data
+                                    memcpy(data, blob, blob_size);
+                                    row.values.push_back(JSVariant(ArrayBuffer {
+                                        .data =  std::shared_ptr<uint8_t>{data},
+                                        .size =  static_cast<size_t>(blob_size)
+                                    }));
+                                    break;
+                                }
+                                    
+                                case SQLITE_NULL:
+                                    // Intentionally left blank
+                                    
+                                default:
+                                    row.values.push_back(JSVariant(NULL));
+                                    break;
+                            }
+                            i++;
+                        }
+                        results->push_back(row);
+                        break;
+                    }
+                        
+                    case SQLITE_DONE:
+                        i = 0;
+                        count = sqlite3_column_count(statement);
+                        
+                        while (i < count)
+                        {
+                            column_name = sqlite3_column_name(statement, i);
+                            const char *type = sqlite3_column_decltype(statement, i);
+                            auto metadata = DynamicHostObject();
+                            metadata.fields.push_back(std::make_pair("name", column_name));
+                            metadata.fields.push_back(std::make_pair("index", i));
+                            metadata.fields.push_back(std::make_pair("type", type));
+                            
+                            metadatas->push_back(metadata);
+                            i++;
+                        }
+                        
+                        isConsuming = false;
+                        break;
+                        
+                    default:
+                        isFailed = true;
+                        isConsuming = false;
+                }
+            }
+            
+            sqlite3_finalize(statement);
+        } while (remainingStatement != NULL && strcmp(remainingStatement, "") != 0 && !isFailed);
+        
+        
+        if (isFailed)
         {
-            ArrayBuffer buffer = std::get<ArrayBuffer>(value);
-            sqlite3_bind_blob(statement, sqIndex, buffer.data.get(), buffer.size, SQLITE_STATIC);
-        } else {
-            sqlite3_bind_null(statement, sqIndex);
+            const char *message = sqlite3_errmsg(db);
+            return {
+                .type = SQLiteError,
+                .message = "[op-sqlite] SQLite code: " + std::to_string(result) + " execution error: " + std::string(message)
+            };
         }
-    }
-}
-
-BridgeResult sqliteExecute(std::string const dbName,
-                           std::string const &query,
-                           std::vector<JSVariant> *params,
-                           std::vector<DumbHostObject> *results,
-                           std::shared_ptr<std::vector<DynamicHostObject>> metadatas)
-{
-    
-    if (dbMap.find(dbName) == dbMap.end())
-    {
+        
+        int changedRowCount = sqlite3_changes(db);
+        long long latestInsertRowId = sqlite3_last_insert_rowid(db);
+        
         return {
-            .type = SQLiteError,
-            .message = "[op-sqlite]: Database " + dbName + " is not open"
+            .type = SQLiteOk,
+            .affectedRows = changedRowCount,
+            .insertId = static_cast<double>(latestInsertRowId)
         };
     }
-    
-    sqlite3 *db = dbMap[dbName];
-    
-    sqlite3_stmt *statement;
-    const char *remainingStatement = nullptr;
-    
-    bool isConsuming = true;
-    bool isFailed = false;
-    
-    do {
-        const char *queryStr = remainingStatement == nullptr ? query.c_str() : remainingStatement;
+
+    BridgeResult sqliteExecuteLiteral(std::string const dbName, std::string const &query)
+    {
+        if (dbMap.count(dbName) == 0)
+        {
+            return {
+                SQLiteError,
+                "[op-sqlite] Database not opened: " + dbName
+            };
+        }
+        
+        sqlite3 *db = dbMap[dbName];
+        sqlite3_stmt *statement;
         
-        int statementStatus = sqlite3_prepare_v2(db, queryStr, -1, &statement, &remainingStatement);
+        int statementStatus = sqlite3_prepare_v2(db, query.c_str(), -1, &statement, NULL);
         
-        if (statementStatus == SQLITE_ERROR)
+        if (statementStatus != SQLITE_OK)
         {
             const char *message = sqlite3_errmsg(db);
             return {
-                .type = SQLiteError,
-                .message = "[op-sqlite] SQL execution error: " + std::string(message),
-            };
+                SQLiteError,
+                "[op-sqlite] SQL statement error: " + std::string(message),
+                0};
         }
         
-        bindStatement(statement, params);
-        
-        isConsuming = true;
+        bool isConsuming = true;
+        bool isFailed = false;
         
-        int result, i, count, column_type;
-        std::string column_name, column_declared_type;
+        int result;
+        std::string column_name;
         
         while (isConsuming)
         {
@@ -291,95 +441,11 @@ BridgeResult sqliteExecute(std::string const dbName,
             
             switch (result)
             {
-                case SQLITE_ROW: {
-                    if(results == NULL)
-                    {
-                        break;
-                    }
-                    
-                    i = 0;
-                    DumbHostObject row = DumbHostObject(metadatas);
-                    
-                    count = sqlite3_column_count(statement);
-                    
-                    while (i < count)
-                    {
-                        column_type = sqlite3_column_type(statement, i);
-                        
-                        switch (column_type)
-                        {
-                            case SQLITE_INTEGER:
-                            {
-                                /**
-                                 * Warning this will loose precision because JS can
-                                 * only represent Integers up to 53 bits
-                                 */
-                                double column_value = sqlite3_column_double(statement, i);
-                                row.values.push_back(JSVariant(column_value));
-                                break;
-                            }
-                                
-                            case SQLITE_FLOAT:
-                            {
-                                double column_value = sqlite3_column_double(statement, i);
-                                row.values.push_back(JSVariant(column_value));
-                                break;
-                            }
-                                
-                            case SQLITE_TEXT:
-                            {
-                                const char *column_value = reinterpret_cast<const char *>(sqlite3_column_text(statement, i));
-                                int byteLen = sqlite3_column_bytes(statement, i);
-                                // Specify length too; in case string contains NULL in the middle
-                                row.values.push_back(JSVariant(std::string(column_value, byteLen)));
-                                break;
-                            }
-                                
-                            case SQLITE_BLOB:
-                            {
-                                int blob_size = sqlite3_column_bytes(statement, i);
-                                const void *blob = sqlite3_column_blob(statement, i);
-                                uint8_t *data = new uint8_t[blob_size];
-                                // You cannot share raw memory between native and JS
-                                // always copy the data
-                                memcpy(data, blob, blob_size);
-                                row.values.push_back(JSVariant(ArrayBuffer {
-                                    .data =  std::shared_ptr<uint8_t>{data},
-                                    .size =  static_cast<size_t>(blob_size)
-                                }));
-                                break;
-                            }
-                                
-                            case SQLITE_NULL:
-                                // Intentionally left blank
-                                
-                            default:
-                                row.values.push_back(JSVariant(NULL));
-                                break;
-                        }
-                        i++;
-                    }
-                    results->push_back(row);
+                case SQLITE_ROW:
+                    isConsuming = true;
                     break;
-                }
                     
                 case SQLITE_DONE:
-                    i = 0;
-                    count = sqlite3_column_count(statement);
-                    
-                    while (i < count)
-                    {
-                        column_name = sqlite3_column_name(statement, i);
-                        const char *type = sqlite3_column_decltype(statement, i);
-                        auto metadata = DynamicHostObject();
-                        metadata.fields.push_back(std::make_pair("name", column_name));
-                        metadata.fields.push_back(std::make_pair("index", i));
-                        metadata.fields.push_back(std::make_pair("type", type));
-                        
-                        metadatas->push_back(metadata);
-                        i++;
-                    }
-                    
                     isConsuming = false;
                     break;
                     
@@ -390,96 +456,31 @@ BridgeResult sqliteExecute(std::string const dbName,
         }
         
         sqlite3_finalize(statement);
-    } while (strcmp(remainingStatement, "") != 0 && !isFailed);
-    
-    
-    if (isFailed)
-    {
-        const char *message = sqlite3_errmsg(db);
-        return {
-            .type = SQLiteError,
-            .message = "[op-sqlite] SQL execution error: " + std::string(message)
-        };
-    }
-    
-    int changedRowCount = sqlite3_changes(db);
-    long long latestInsertRowId = sqlite3_last_insert_rowid(db);
-    
-    return {
-        .type = SQLiteOk,
-        .affectedRows = changedRowCount,
-        .insertId = static_cast<double>(latestInsertRowId)
-    };
-}
-
-BridgeResult sqliteExecuteLiteral(std::string const dbName, std::string const &query)
-{
-    // Check if db connection is opened
-    if (dbMap.count(dbName) == 0)
-    {
-        return {
-            SQLiteError,
-            "[op-sqlite] Database not opened: " + dbName
-        };
-    }
-    
-    sqlite3 *db = dbMap[dbName];
-    sqlite3_stmt *statement;
-    
-    // Compile and move result into statement memory spot
-    int statementStatus = sqlite3_prepare_v2(db, query.c_str(), -1, &statement, NULL);
-    
-    if (statementStatus != SQLITE_OK)
-    {
-        const char *message = sqlite3_errmsg(db);
-        return {
-            SQLiteError,
-            "[op-sqlite] SQL execution error: " + std::string(message),
-            0};
-    }
-    
-    bool isConsuming = true;
-    bool isFailed = false;
-    
-    int result;
-    std::string column_name;
-    
-    while (isConsuming)
-    {
-        result = sqlite3_step(statement);
         
-        switch (result)
+        if (isFailed)
         {
-            case SQLITE_ROW:
-                isConsuming = true;
-                break;
-                
-            case SQLITE_DONE:
-                isConsuming = false;
-                break;
-                
-            default:
-                isFailed = true;
-                isConsuming = false;
+            const char *message = sqlite3_errmsg(db);
+            return {
+                SQLiteError,
+                "[op-sqlite] SQL execution error: " + std::string(message),
+                0};
         }
-    }
-    
-    sqlite3_finalize(statement);
-    
-    if (isFailed)
-    {
-        const char *message = sqlite3_errmsg(db);
+        
+        int changedRowCount = sqlite3_changes(db);
         return {
-            SQLiteError,
-            "[op-sqlite] SQL execution error: " + std::string(message),
-            0};
+            SQLiteOk,
+            "",
+            changedRowCount};
     }
-    
-    int changedRowCount = sqlite3_changes(db);
-    return {
-        SQLiteOk,
-        "",
-        changedRowCount};
-}
 
+    void sqliteCloseAll() {
+        for (auto const& x : dbMap) {
+            sqlite3_interrupt(x.second);
+            // In certain cases, this will return SQLITE_OK, mark the database connection as an unusable "zombie",
+            // and deallocate the connection later.
+            sqlite3_close_v2(x.second);
+        }
+        dbMap.clear();
+    }
+    
 }

package/cpp/bridge.h

@@ -23,7 +23,7 @@ BridgeResult sqliteDetachDb(std::string const mainDBName, std::string const alia
 
 BridgeResult sqliteExecute(std::string const dbName,
                            std::string const &query,
-                           std::vector<JSVariant> *values,
+                           const std::vector<JSVariant> *params,
                            std::vector<DumbHostObject> *results,
                            std::shared_ptr<std::vector<DynamicHostObject>> metadatas);
 

package/cpp/macros.h

@@ -8,9 +8,4 @@ jsi::PropNameID::forAscii(rt, name), \
 basecount, \
 [=](jsi::Runtime &rt, const jsi::Value &thisValue, const jsi::Value *args, size_t count) -> jsi::Value
 
-#define JSIFN(capture)                                         \
-capture(jsi::Runtime &runtime, const jsi::Value &thisValue, \
-const jsi::Value *arguments, size_t count)          \
-->jsi::Value
-
 #endif /* macros_h */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@op-engineering/op-sqlite",
-  "version": "1.0.9",
+  "version": "1.0.11",
   "description": "Next generation SQLite for React Native",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",