@op-engineering/op-sqlite 2.0.16 → 2.0.18

package/cpp/bridge.cpp

@@ -3,52 +3,56 @@
 #include "SmartHostObject.h"
 #include "logs.h"
 #include "utils.h"
-#include <ctime>
 #include <unordered_map>
 #include <variant>
 
 namespace opsqlite {
 
+/// Maps to hold the different objects
 std::unordered_map<std::string, sqlite3 *> dbMap =
     std::unordered_map<std::string, sqlite3 *>();
-std::unordered_map<std::string,
-                   std::function<void(std::string dbName, std::string tableName,
-                                      std::string operation, int rowId)>>
-    updateCallbackMap = std::unordered_map<
-        std::string,
-        std::function<void(std::string dbName, std::string tableName,
-                           std::string operation, int rowId)>>();
-
-std::unordered_map<std::string, std::function<void(std::string dbName)>>
-    commitCallbackMap =
-        std::unordered_map<std::string,
-                           std::function<void(std::string dbName)>>();
-
-std::unordered_map<std::string, std::function<void(std::string dbName)>>
-    rollbackCallbackMap =
-        std::unordered_map<std::string,
-                           std::function<void(std::string dbName)>>();
-
-std::string get_db_path(std::string const dbName, std::string const lastPath) {
-  if (lastPath == ":memory:") {
-    return lastPath;
+std::unordered_map<std::string, UpdateCallback> updateCallbackMap =
+    std::unordered_map<std::string, UpdateCallback>();
+
+std::unordered_map<std::string, CommitCallback> commitCallbackMap =
+    std::unordered_map<std::string, CommitCallback>();
+
+std::unordered_map<std::string, RollbackCallback> rollbackCallbackMap =
+    std::unordered_map<std::string, RollbackCallback>();
+
+inline void check_db_open(std::string const &db_name) {
+  if (dbMap.count(db_name) == 0) {
+    throw std::runtime_error("[OP-SQLite] DB is not open");
+  }
+}
+
+/// Start of api
+
+/// Returns the completely formed db path, but it also creates any sub-folders
+/// along the way
+std::string get_db_path(std::string const &db_name,
+                        std::string const &location) {
+
+  if (location == ":memory:") {
+    return location;
   }
-  mkdir(lastPath);
-  return lastPath + "/" + dbName;
+
+  mkdir(location);
+  return location + "/" + db_name;
 }
 
-BridgeResult sqlite_open(std::string const &dbName,
-                         std::string const &lastPath) {
+BridgeResult opsqlite_open(std::string const &dbName,
+                           std::string const &lastPath) {
   std::string dbPath = get_db_path(dbName, lastPath);
 
   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) {
+  int status = sqlite3_open_v2(dbPath.c_str(), &db, sqlOpenFlags, nullptr);
+
+  if (status != SQLITE_OK) {
     return {.type = SQLiteError, .message = sqlite3_errmsg(db)};
   }
 
@@ -57,14 +61,9 @@ BridgeResult sqlite_open(std::string const &dbName,
   return BridgeResult{.type = SQLiteOk, .affectedRows = 0};
 }
 
-BridgeResult sqlite_close(std::string const &dbName) {
+BridgeResult opsqlite_close(std::string const &dbName) {
 
-  if (dbMap.count(dbName) == 0) {
-    return {
-        .type = SQLiteError,
-        .message = dbName + " is not open",
-    };
-  }
+  check_db_open(dbName);
 
   sqlite3 *db = dbMap[dbName];
 
@@ -77,10 +76,10 @@ BridgeResult sqlite_close(std::string const &dbName) {
   };
 }
 
-BridgeResult sqlite_attach(std::string const &mainDBName,
-                           std::string const &docPath,
-                           std::string const &databaseToAttach,
-                           std::string const &alias) {
+BridgeResult opsqlite_attach(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.
@@ -88,7 +87,7 @@ BridgeResult sqlite_attach(std::string const &mainDBName,
   std::string dbPath = get_db_path(databaseToAttach, docPath);
   std::string statement = "ATTACH DATABASE '" + dbPath + "' AS " + alias;
 
-  BridgeResult result = sqlite_execute_literal(mainDBName, statement);
+  BridgeResult result = opsqlite_execute_literal(mainDBName, statement);
 
   if (result.type == SQLiteError) {
     return {
@@ -102,14 +101,14 @@ BridgeResult sqlite_attach(std::string const &mainDBName,
   };
 }
 
-BridgeResult sqlite_detach(std::string const &mainDBName,
-                           std::string const &alias) {
+BridgeResult opsqlite_detach(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 = sqlite_execute_literal(mainDBName, statement);
+  BridgeResult result = opsqlite_execute_literal(mainDBName, statement);
   if (result.type == SQLiteError) {
     return BridgeResult{
         .type = SQLiteError,
@@ -122,10 +121,10 @@ BridgeResult sqlite_detach(std::string const &mainDBName,
   };
 }
 
-BridgeResult sqlite_remove(std::string const &dbName,
-                           std::string const &docPath) {
+BridgeResult opsqlite_remove(std::string const &dbName,
+                             std::string const &docPath) {
   if (dbMap.count(dbName) == 1) {
-    BridgeResult closeResult = sqlite_close(dbName);
+    BridgeResult closeResult = opsqlite_close(dbName);
     if (closeResult.type == SQLiteError) {
       return closeResult;
     }
@@ -145,8 +144,8 @@ BridgeResult sqlite_remove(std::string const &dbName,
   };
 }
 
-inline void bindStatement(sqlite3_stmt *statement,
-                          const std::vector<JSVariant> *values) {
+inline void opsqlite_bind_statement(sqlite3_stmt *statement,
+                                    const std::vector<JSVariant> *values) {
   size_t size = values->size();
 
   for (int ii = 0; ii < size; ii++) {
@@ -175,19 +174,12 @@ inline void bindStatement(sqlite3_stmt *statement,
   }
 }
 
-void sqlite_bind_statement(sqlite3_stmt *statement,
-                           const std::vector<JSVariant> *params) {
-  bindStatement(statement, params);
-}
-
-BridgeResult sqlite_execute_prepared_statement(
+BridgeResult opsqlite_execute_prepared_statement(
     std::string const &dbName, sqlite3_stmt *statement,
     std::vector<DumbHostObject> *results,
     std::shared_ptr<std::vector<SmartHostObject>> metadatas) {
-  if (dbMap.find(dbName) == dbMap.end()) {
-    return {.type = SQLiteError,
-            .message = "[op-sqlite]: Database " + dbName + " is not open"};
-  }
+
+  check_db_open(dbName);
 
   sqlite3_reset(statement);
 
@@ -265,7 +257,7 @@ BridgeResult sqlite_execute_prepared_statement(
           // Intentionally left blank
 
         default:
-          row.values.push_back(JSVariant(NULL));
+          row.values.push_back(JSVariant(nullptr));
           break;
         }
         i++;
@@ -319,11 +311,9 @@ BridgeResult sqlite_execute_prepared_statement(
           .insertId = static_cast<double>(latestInsertRowId)};
 }
 
-sqlite3_stmt *sqlite_prepare_statement(std::string const &dbName,
-                                       std::string const &query) {
-  if (dbMap.find(dbName) == dbMap.end()) {
-    throw std::runtime_error("Database not opened");
-  }
+sqlite3_stmt *opsqlite_prepare_statement(std::string const &dbName,
+                                         std::string const &query) {
+  check_db_open(dbName);
 
   sqlite3 *db = dbMap[dbName];
 
@@ -342,16 +332,14 @@ sqlite3_stmt *sqlite_prepare_statement(std::string const &dbName,
   return statement;
 }
 
+/// Base execution function, returns HostObjects to the JS environment
 BridgeResult
-sqlite_execute(std::string const &dbName, std::string const &query,
-               const std::vector<JSVariant> *params,
-               std::vector<DumbHostObject> *results,
-               std::shared_ptr<std::vector<SmartHostObject>> metadatas) {
+opsqlite_execute(std::string const &dbName, std::string const &query,
+                 const std::vector<JSVariant> *params,
+                 std::vector<DumbHostObject> *results,
+                 std::shared_ptr<std::vector<SmartHostObject>> metadatas) {
 
-  if (dbMap.find(dbName) == dbMap.end()) {
-    return {.type = SQLiteError,
-            .message = "[op-sqlite]: Database " + dbName + " is not open"};
-  }
+  check_db_open(dbName);
 
   sqlite3 *db = dbMap[dbName];
 
@@ -389,7 +377,7 @@ sqlite_execute(std::string const &dbName, std::string const &query,
     }
 
     if (params != nullptr && params->size() > 0) {
-      bindStatement(statement, params);
+      opsqlite_bind_statement(statement, params);
     }
 
     isConsuming = true;
@@ -457,7 +445,7 @@ sqlite_execute(std::string const &dbName, std::string const &query,
             // Intentionally left blank
 
           default:
-            row.values.push_back(JSVariant(NULL));
+            row.values.push_back(JSVariant(nullptr));
             break;
           }
           i++;
@@ -518,15 +506,14 @@ sqlite_execute(std::string const &dbName, std::string const &query,
           .insertId = static_cast<double>(latestInsertRowId)};
 }
 
-BridgeResult sqlite_execute_raw(std::string const &dbName,
-                                std::string const &query,
-                                const std::vector<JSVariant> *params,
-                                std::vector<std::vector<JSVariant>> *results) {
+/// Executes returning data in raw arrays, a small performance optimization for
+/// certain use cases
+BridgeResult
+opsqlite_execute_raw(std::string const &dbName, std::string const &query,
+                     const std::vector<JSVariant> *params,
+                     std::vector<std::vector<JSVariant>> *results) {
 
-  if (dbMap.find(dbName) == dbMap.end()) {
-    return {.type = SQLiteError,
-            .message = "[op-sqlite]: Database " + dbName + " is not open"};
-  }
+  check_db_open(dbName);
 
   sqlite3 *db = dbMap[dbName];
 
@@ -564,7 +551,7 @@ BridgeResult sqlite_execute_raw(std::string const &dbName,
     }
 
     if (params != nullptr && params->size() > 0) {
-      bindStatement(statement, params);
+      opsqlite_bind_statement(statement, params);
     }
 
     isConsuming = true;
@@ -619,8 +606,6 @@ BridgeResult sqlite_execute_raw(std::string const &dbName,
             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.push_back(
                 JSVariant(ArrayBuffer{.data = std::shared_ptr<uint8_t>{data},
@@ -632,7 +617,7 @@ BridgeResult sqlite_execute_raw(std::string const &dbName,
             // Intentionally left blank
 
           default:
-            row.push_back(JSVariant(NULL));
+            row.push_back(JSVariant(nullptr));
             break;
           }
           i++;
@@ -676,11 +661,11 @@ BridgeResult sqlite_execute_raw(std::string const &dbName,
           .insertId = static_cast<double>(latestInsertRowId)};
 }
 
-BridgeResult sqlite_execute_literal(std::string const &dbName,
-                                    std::string const &query) {
-  if (dbMap.count(dbName) == 0) {
-    return {SQLiteError, "[op-sqlite] Database not opened: " + dbName};
-  }
+/// Executes without returning any results, Useful for performance critical
+/// operations
+BridgeResult opsqlite_execute_literal(std::string const &dbName,
+                                      std::string const &query) {
+  check_db_open(dbName);
 
   sqlite3 *db = dbMap[dbName];
   sqlite3_stmt *statement;
@@ -730,7 +715,7 @@ BridgeResult sqlite_execute_literal(std::string const &dbName,
   return {SQLiteOk, "", changedRowCount};
 }
 
-void sqlite_close_all() {
+void opsqlite_close_all() {
   for (auto const &x : dbMap) {
     // Interrupt will make all pending operations to fail with SQLITE_INTERRUPT
     // The ongoing work from threads will then fail ASAP
@@ -768,13 +753,9 @@ void update_callback(void *dbName, int operation_type, char const *database,
            static_cast<int>(rowid));
 }
 
-BridgeResult sqlite_register_update_hook(
-    std::string const &dbName,
-    std::function<void(std::string dbName, std::string tableName,
-                       std::string operation, int rowId)> const callback) {
-  if (dbMap.count(dbName) == 0) {
-    return {SQLiteError, "[op-sqlite] Database not opened: " + dbName};
-  }
+BridgeResult opsqlite_register_update_hook(std::string const &dbName,
+                                           UpdateCallback const callback) {
+  check_db_open(dbName);
 
   sqlite3 *db = dbMap[dbName];
   updateCallbackMap[dbName] = callback;
@@ -792,10 +773,8 @@ BridgeResult sqlite_register_update_hook(
   return {SQLiteOk};
 }
 
-BridgeResult sqlite_deregister_update_hook(std::string const &dbName) {
-  if (dbMap.count(dbName) == 0) {
-    return {SQLiteError, "[op-sqlite] Database not opened: " + dbName};
-  }
+BridgeResult opsqlite_deregister_update_hook(std::string const &dbName) {
+  check_db_open(dbName);
 
   sqlite3 *db = dbMap[dbName];
   updateCallbackMap.erase(dbName);
@@ -813,12 +792,9 @@ int commit_callback(void *dbName) {
   return 0;
 }
 
-BridgeResult sqlite_register_commit_hook(
-    std::string const &dbName,
-    std::function<void(std::string dbName)> const callback) {
-  if (dbMap.count(dbName) == 0) {
-    return {SQLiteError, "[op-sqlite] Database not opened: " + dbName};
-  }
+BridgeResult opsqlite_register_commit_hook(std::string const &dbName,
+                                           CommitCallback const callback) {
+  check_db_open(dbName);
 
   sqlite3 *db = dbMap[dbName];
   commitCallbackMap[dbName] = callback;
@@ -836,10 +812,8 @@ BridgeResult sqlite_register_commit_hook(
   return {SQLiteOk};
 }
 
-BridgeResult sqlite_deregister_commit_hook(std::string const &dbName) {
-  if (dbMap.count(dbName) == 0) {
-    return {SQLiteError, "[op-sqlite] Database not opened: " + dbName};
-  }
+BridgeResult opsqlite_deregister_commit_hook(std::string const &dbName) {
+  check_db_open(dbName);
 
   sqlite3 *db = dbMap[dbName];
   commitCallbackMap.erase(dbName);
@@ -854,12 +828,9 @@ void rollback_callback(void *dbName) {
   callback(strDbName);
 }
 
-BridgeResult sqlite_register_rollback_hook(
-    std::string const &dbName,
-    std::function<void(std::string dbName)> const callback) {
-  if (dbMap.count(dbName) == 0) {
-    return {SQLiteError, "[op-sqlite] Database not opened: " + dbName};
-  }
+BridgeResult opsqlite_register_rollback_hook(std::string const &dbName,
+                                             RollbackCallback const callback) {
+  check_db_open(dbName);
 
   sqlite3 *db = dbMap[dbName];
   rollbackCallbackMap[dbName] = callback;
@@ -877,10 +848,8 @@ BridgeResult sqlite_register_rollback_hook(
   return {SQLiteOk};
 }
 
-BridgeResult sqlite_deregister_rollback_hook(std::string const &dbName) {
-  if (dbMap.count(dbName) == 0) {
-    return {SQLiteError, "[op-sqlite] Database not opened: " + dbName};
-  }
+BridgeResult opsqlite_deregister_rollback_hook(std::string const &dbName) {
+  check_db_open(dbName);
 
   sqlite3 *db = dbMap[dbName];
   rollbackCallbackMap.erase(dbName);
@@ -890,11 +859,13 @@ BridgeResult sqlite_deregister_rollback_hook(std::string const &dbName) {
   return {SQLiteOk};
 }
 
-BridgeResult sqlite_load_extension(std::string &db_name, std::string &path,
-                                   std::string &entry_point) {
-  if (dbMap.count(db_name) == 0) {
-    return {SQLiteError, "[op-sqlite] Database not open"};
-  }
+BridgeResult opsqlite_load_extension(std::string &db_name, std::string &path,
+                                     std::string &entry_point) {
+#ifdef OP_SQLITE_USE_PHONE_VERSION
+  throw std::runtime_error(
+      "Embedded version of SQLite does not support loading extensions");
+#else
+  check_db_open(db_name);
 
   sqlite3 *db = dbMap[db_name];
   int loading_extensions_enabled = sqlite3_enable_load_extension(db, 1);
@@ -915,6 +886,7 @@ BridgeResult sqlite_load_extension(std::string &db_name, std::string &path,
     return {SQLiteError, std::string(error_message)};
   }
   return {SQLiteOk};
+#endif
 }
 
 } // namespace opsqlite

package/cpp/bridge.h

@@ -3,73 +3,77 @@
 
 #include "DumbHostObject.h"
 #include "SmartHostObject.h"
+#include "sqlite3.h"
 #include "types.h"
 #include "utils.h"
-#include <sqlite3.h>
 #include <vector>
 
 namespace opsqlite {
 
 namespace jsi = facebook::jsi;
 
-BridgeResult sqlite_open(std::string const &dbName, std::string const &dbPath);
+/// Convenience types to avoid super long types
+typedef std::function<void(std::string dbName, std::string tableName,
+                           std::string operation, int rowId)>
+    UpdateCallback;
+typedef std::function<void(std::string dbName)> CommitCallback;
+typedef std::function<void(std::string dbName)> RollbackCallback;
 
-BridgeResult sqlite_close(std::string const &dbName);
+BridgeResult opsqlite_open(std::string const &dbName,
+                           std::string const &dbPath);
 
-BridgeResult sqlite_remove(std::string const &dbName,
-                           std::string const &docPath);
+BridgeResult opsqlite_close(std::string const &dbName);
 
-BridgeResult sqlite_attach(std::string const &mainDBName,
-                           std::string const &docPath,
-                           std::string const &databaseToAttach,
-                           std::string const &alias);
+BridgeResult opsqlite_remove(std::string const &dbName,
+                             std::string const &docPath);
 
-BridgeResult sqlite_detach(std::string const &mainDBName,
-                           std::string const &alias);
+BridgeResult opsqlite_attach(std::string const &mainDBName,
+                             std::string const &docPath,
+                             std::string const &databaseToAttach,
+                             std::string const &alias);
+
+BridgeResult opsqlite_detach(std::string const &mainDBName,
+                             std::string const &alias);
 
 BridgeResult
-sqlite_execute(std::string const &dbName, std::string const &query,
-               const std::vector<JSVariant> *params,
-               std::vector<DumbHostObject> *results,
-               std::shared_ptr<std::vector<SmartHostObject>> metadatas);
-
-BridgeResult sqlite_execute_raw(std::string const &dbName,
-                                std::string const &query,
-                                const std::vector<JSVariant> *params,
-                                std::vector<std::vector<JSVariant>> *results);
-
-BridgeResult sqlite_execute_literal(std::string const &dbName,
-                                    std::string const &query);
-
-void sqlite_close_all();
-
-BridgeResult sqlite_register_update_hook(
-    std::string const &dbName,
-    std::function<void(std::string dbName, std::string tableName,
-                       std::string operation, int rowId)> const callback);
-BridgeResult sqlite_deregister_update_hook(std::string const &dbName);
-BridgeResult sqlite_register_commit_hook(
-    std::string const &dbName,
-    std::function<void(std::string dbName)> const callback);
-BridgeResult sqlite_deregister_commit_hook(std::string const &dbName);
-BridgeResult sqlite_register_rollback_hook(
-    std::string const &dbName,
-    std::function<void(std::string dbName)> const callback);
-BridgeResult sqlite_deregister_rollback_hook(std::string const &dbName);
-
-sqlite3_stmt *sqlite_prepare_statement(std::string const &dbName,
-                                       std::string const &query);
-
-void sqlite_bind_statement(sqlite3_stmt *statement,
-                           const std::vector<JSVariant> *params);
-
-BridgeResult sqlite_execute_prepared_statement(
+opsqlite_execute(std::string const &dbName, std::string const &query,
+                 const std::vector<JSVariant> *params,
+                 std::vector<DumbHostObject> *results,
+                 std::shared_ptr<std::vector<SmartHostObject>> metadatas);
+
+BridgeResult opsqlite_execute_raw(std::string const &dbName,
+                                  std::string const &query,
+                                  const std::vector<JSVariant> *params,
+                                  std::vector<std::vector<JSVariant>> *results);
+
+BridgeResult opsqlite_execute_literal(std::string const &dbName,
+                                      std::string const &query);
+
+void opsqlite_close_all();
+
+BridgeResult opsqlite_register_update_hook(std::string const &dbName,
+                                           UpdateCallback const callback);
+BridgeResult opsqlite_deregister_update_hook(std::string const &dbName);
+BridgeResult opsqlite_register_commit_hook(std::string const &dbName,
+                                           CommitCallback const callback);
+BridgeResult opsqlite_deregister_commit_hook(std::string const &dbName);
+BridgeResult opsqlite_register_rollback_hook(std::string const &dbName,
+                                             RollbackCallback const callback);
+BridgeResult opsqlite_deregister_rollback_hook(std::string const &dbName);
+
+sqlite3_stmt *opsqlite_prepare_statement(std::string const &dbName,
+                                         std::string const &query);
+
+void opsqlite_bind_statement(sqlite3_stmt *statement,
+                             const std::vector<JSVariant> *params);
+
+BridgeResult opsqlite_execute_prepared_statement(
     std::string const &dbName, sqlite3_stmt *statement,
     std::vector<DumbHostObject> *results,
     std::shared_ptr<std::vector<SmartHostObject>> metadatas);
 
-BridgeResult sqlite_load_extension(std::string &db_name, std::string &path,
-                                   std::string &entry_point);
+BridgeResult opsqlite_load_extension(std::string &db_name, std::string &path,
+                                     std::string &entry_point);
 
 } // namespace opsqlite
 

package/cpp/sqlbatchexecutor.cpp

@@ -57,15 +57,15 @@ BatchResult sqliteExecuteBatch(std::string dbName,
 
   try {
     int affectedRows = 0;
-    sqlite_execute_literal(dbName, "BEGIN EXCLUSIVE TRANSACTION");
+    opsqlite_execute_literal(dbName, "BEGIN EXCLUSIVE TRANSACTION");
     for (int i = 0; i < commandCount; i++) {
       auto command = commands->at(i);
       // We do not provide a datastructure to receive query data because we
       // don't need/want to handle this results in a batch execution
-      auto result = sqlite_execute(dbName, command.sql, command.params.get(),
-                                   nullptr, nullptr);
+      auto result = opsqlite_execute(dbName, command.sql, command.params.get(),
+                                     nullptr, nullptr);
       if (result.type == SQLiteError) {
-        sqlite_execute_literal(dbName, "ROLLBACK");
+        opsqlite_execute_literal(dbName, "ROLLBACK");
         return BatchResult{
             .type = SQLiteError,
             .message = result.message,
@@ -74,14 +74,14 @@ BatchResult sqliteExecuteBatch(std::string dbName,
         affectedRows += result.affectedRows;
       }
     }
-    sqlite_execute_literal(dbName, "COMMIT");
+    opsqlite_execute_literal(dbName, "COMMIT");
     return BatchResult{
         .type = SQLiteOk,
         .affectedRows = affectedRows,
         .commands = static_cast<int>(commandCount),
     };
   } catch (std::exception &exc) {
-    sqlite_execute_literal(dbName, "ROLLBACK");
+    opsqlite_execute_literal(dbName, "ROLLBACK");
     return BatchResult{
         .type = SQLiteError,
         .message = exc.what(),