@op-engineering/op-sqlite 2.0.20 → 3.0.0

package/cpp/PreparedStatementHostObject.cpp

@@ -1,10 +1,3 @@
-//
-//  PreparedStatementHostObject.cpp
-//  op-sqlite
-//
-//  Created by Oscar Franco on 5/12/23.
-//
-
 #include "PreparedStatementHostObject.h"
 #include "bridge.h"
 #include "macros.h"
@@ -31,7 +24,7 @@ jsi::Value PreparedStatementHostObject::get(jsi::Runtime &rt,
 
   if (name == "bind") {
     return HOSTFN("bind", 1) {
-      if (_statement == NULL) {
+      if (_statement == nullptr) {
         throw std::runtime_error("statement has been freed");
       }
 
@@ -46,7 +39,7 @@ jsi::Value PreparedStatementHostObject::get(jsi::Runtime &rt,
 
   if (name == "execute") {
     return HOSTFN("execute", 1) {
-      if (_statement == NULL) {
+      if (_statement == nullptr) {
         throw std::runtime_error("statement has been freed");
       }
       std::vector<DumbHostObject> results;
@@ -69,9 +62,9 @@ jsi::Value PreparedStatementHostObject::get(jsi::Runtime &rt,
 }
 
 PreparedStatementHostObject::~PreparedStatementHostObject() {
-  if (_statement != NULL) {
+  if (_statement != nullptr) {
     sqlite3_finalize(_statement);
-    _statement = NULL;
+    _statement = nullptr;
   }
 }
 

package/cpp/bindings.cpp

@@ -8,7 +8,6 @@
 #include "sqlbatchexecutor.h"
 #include "utils.h"
 #include <iostream>
-#include <sqlite3.h>
 #include <string>
 #include <unordered_map>
 #include <vector>
@@ -55,32 +54,50 @@ void install(jsi::Runtime &rt,
       throw std::runtime_error("[op-sqlite][open] database name is required");
     }
 
-    if (!args[0].isString()) {
-      throw std::runtime_error(
-          "[op-sqlite][open] database name must be a string");
-    }
-
-    std::string dbName = args[0].asString(rt).utf8(rt);
+    jsi::Object options = args[0].asObject(rt);
+    std::string dbName = options.getProperty(rt, "name").asString(rt).utf8(rt);
     std::string path = std::string(basePath);
+    std::string location;
+    std::string encryptionKey;
 
-    if (count > 1 && !args[1].isUndefined() && !args[1].isNull()) {
-      if (!args[1].isString()) {
-        throw std::runtime_error(
-            "[op-sqlite][open] database location must be a string");
-      }
+    if (options.hasProperty(rt, "location")) {
+      location = options.getProperty(rt, "location").asString(rt).utf8(rt);
+    }
 
-      std::string lastPath = args[1].asString(rt).utf8(rt);
+    if (options.hasProperty(rt, "encryptionKey")) {
+      encryptionKey =
+          options.getProperty(rt, "encryptionKey").asString(rt).utf8(rt);
+    }
 
-      if (lastPath == ":memory:") {
+#ifdef OP_SQLITE_USE_SQLCIPHER
+    if (encryptionKey.empty()) {
+      throw std::runtime_error(
+          "[OP SQLite] using SQLCipher encryption key is required");
+    }
+//      TODO(osp) find a way to display the yellow box from c++
+#else
+    // if (!encryptionKey.empty()) {
+    //   //  RCTLogWarn(@"Your message")
+    //   throw std::runtime_error("[OP SQLite] SQLCipher is not enabled, "
+    //                            "encryption key is not allowed");
+    // }
+#endif
+
+    if (!location.empty()) {
+      if (location == ":memory:") {
         path = ":memory:";
-      } else if (lastPath.rfind("/", 0) == 0) {
-        path = lastPath;
+      } else if (location.rfind("/", 0) == 0) {
+        path = location;
       } else {
-        path = path + "/" + lastPath;
+        path = path + "/" + location;
       }
     }
 
+#ifdef OP_SQLITE_USE_SQLCIPHER
+    BridgeResult result = opsqlite_open(dbName, path, encryptionKey);
+#else
     BridgeResult result = opsqlite_open(dbName, path);
+#endif
 
     if (result.type == SQLiteError) {
       throw std::runtime_error(result.message);

package/cpp/bridge.cpp

@@ -41,9 +41,15 @@ std::string get_db_path(std::string const &db_name,
   return location + "/" + db_name;
 }
 
+#ifdef OP_SQLITE_USE_SQLCIPHER
 BridgeResult opsqlite_open(std::string const &dbName,
-                           std::string const &lastPath) {
-  std::string dbPath = get_db_path(dbName, lastPath);
+                           std::string const &last_path,
+                           std::string const &encryptionKey) {
+#else
+BridgeResult opsqlite_open(std::string const &dbName,
+                           std::string const &last_path) {
+#endif
+  std::string dbPath = get_db_path(dbName, last_path);
 
   int sqlOpenFlags =
       SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_FULLMUTEX;
@@ -57,7 +63,12 @@ BridgeResult opsqlite_open(std::string const &dbName,
   }
 
   dbMap[dbName] = db;
-
+#ifdef OP_SQLITE_USE_SQLCIPHER
+  auto encryptionResult =
+      opsqlite_execute(dbName, "PRAGMA key = '" + encryptionKey + "'", nullptr,
+                       nullptr, nullptr);
+  LOGD("Encrypting database");
+#endif
   return BridgeResult{.type = SQLiteOk, .affectedRows = 0};
 }
 
@@ -80,14 +91,11 @@ 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.
-   * */
   std::string dbPath = get_db_path(databaseToAttach, docPath);
   std::string statement = "ATTACH DATABASE '" + dbPath + "' AS " + alias;
 
-  BridgeResult result = opsqlite_execute_literal(mainDBName, statement);
+  BridgeResult result =
+      opsqlite_execute(mainDBName, statement, nullptr, nullptr, nullptr);
 
   if (result.type == SQLiteError) {
     return {
@@ -103,12 +111,9 @@ BridgeResult opsqlite_attach(std::string const &mainDBName,
 
 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 = opsqlite_execute_literal(mainDBName, statement);
+  BridgeResult result =
+      opsqlite_execute(mainDBName, statement, nullptr, nullptr, nullptr);
   if (result.type == SQLiteError) {
     return BridgeResult{
         .type = SQLiteError,
@@ -327,7 +332,7 @@ sqlite3_stmt *opsqlite_prepare_statement(std::string const &dbName,
 
   if (statementStatus == SQLITE_ERROR) {
     const char *message = sqlite3_errmsg(db);
-    throw std::runtime_error("[op-sqlite] SQL statement error: " +
+    throw std::runtime_error("[op-sqlite] SQL prepare statement error: " +
                              std::string(message));
   }
 
@@ -365,15 +370,15 @@ opsqlite_execute(std::string const &dbName, std::string const &query,
       const char *message = sqlite3_errmsg(db);
       return {
           .type = SQLiteError,
-          .message = "[op-sqlite] SQL statement error:" +
-                     std::to_string(statementStatus) +
-                     " description:" + std::string(message) +
+          .message = "[op-sqlite] SQL statement error on opsqlite_execute:\n" +
+                     std::to_string(statementStatus) + " description:\n" +
+                     std::string(message) +
                      ". See error codes: https://www.sqlite.org/rescode.html",
       };
     }
 
-    // The statement did not fail to parse but there is nothing to do, just skip
-    // to the end
+    // The statement did not fail to parse but there is nothing to do, just
+    // skip to the end
     if (statement == NULL) {
       continue;
     }
@@ -508,8 +513,8 @@ opsqlite_execute(std::string const &dbName, std::string const &query,
           .insertId = static_cast<double>(latestInsertRowId)};
 }
 
-/// Executes returning data in raw arrays, a small performance optimization for
-/// certain use cases
+/// 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,
@@ -526,7 +531,7 @@ opsqlite_execute_raw(std::string const &dbName, std::string const &query,
   bool isConsuming = true;
   bool isFailed = false;
 
-  int result = SQLITE_OK;
+  int step = SQLITE_OK;
 
   do {
     const char *queryStr =
@@ -546,8 +551,8 @@ opsqlite_execute_raw(std::string const &dbName, std::string const &query,
       };
     }
 
-    // The statement did not fail to parse but there is nothing to do, just skip
-    // to the end
+    // The statement did not fail to parse but there is nothing to do, just
+    // skip to the end
     if (statement == NULL) {
       continue;
     }
@@ -562,13 +567,14 @@ opsqlite_execute_raw(std::string const &dbName, std::string const &query,
     std::string column_name, column_declared_type;
 
     while (isConsuming) {
-      result = sqlite3_step(statement);
+      step = sqlite3_step(statement);
 
-      switch (result) {
+      switch (step) {
       case SQLITE_ROW: {
-        if (results == NULL) {
+        if (results == nullptr) {
           break;
         }
+
         std::vector<JSVariant> row;
 
         i = 0;
@@ -616,7 +622,8 @@ opsqlite_execute_raw(std::string const &dbName, std::string const &query,
           }
 
           case SQLITE_NULL:
-            // Intentionally left blank
+            row.push_back(JSVariant(nullptr));
+            break;
 
           default:
             row.push_back(JSVariant(nullptr));
@@ -649,7 +656,7 @@ opsqlite_execute_raw(std::string const &dbName, std::string const &query,
 
     return {.type = SQLiteError,
             .message =
-                "[op-sqlite] SQLite error code: " + std::to_string(result) +
+                "[op-sqlite] SQLite error code: " + std::to_string(step) +
                 ", description: " + std::string(errorMessage) +
                 ".\nSee SQLite error codes reference: "
                 "https://www.sqlite.org/rescode.html"};
@@ -663,64 +670,10 @@ opsqlite_execute_raw(std::string const &dbName, std::string const &query,
           .insertId = static_cast<double>(latestInsertRowId)};
 }
 
-/// 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;
-
-  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 statement 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) {
-    case SQLITE_ROW:
-      isConsuming = true;
-      break;
-
-    case SQLITE_DONE:
-      isConsuming = false;
-      break;
-
-    default:
-      isFailed = true;
-      isConsuming = false;
-    }
-  }
-
-  sqlite3_finalize(statement);
-
-  if (isFailed) {
-    const char *message = sqlite3_errmsg(db);
-    return {SQLiteError,
-            "[op-sqlite] SQL execution error: " + std::string(message), 0};
-  }
-
-  int changedRowCount = sqlite3_changes(db);
-  return {SQLiteOk, "", changedRowCount};
-}
-
 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
+    // Interrupt will make all pending operations to fail with
+    // SQLITE_INTERRUPT The ongoing work from threads will then fail ASAP
     sqlite3_interrupt(x.second);
     // Each DB connection can then be safely interrupted
     sqlite3_close_v2(x.second);

package/cpp/bridge.h

@@ -19,8 +19,13 @@ typedef std::function<void(std::string dbName, std::string tableName,
 typedef std::function<void(std::string dbName)> CommitCallback;
 typedef std::function<void(std::string dbName)> RollbackCallback;
 
+#ifdef OP_SQLITE_USE_SQLCIPHER
+BridgeResult opsqlite_open(std::string const &dbName, std::string const &dbPath,
+                           std::string const &encryptionKey);
+#else
 BridgeResult opsqlite_open(std::string const &dbName,
                            std::string const &dbPath);
+#endif
 
 BridgeResult opsqlite_close(std::string const &dbName);
 
@@ -46,9 +51,6 @@ BridgeResult opsqlite_execute_raw(std::string const &dbName,
                                   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,

package/cpp/sqlbatchexecutor.cpp

@@ -57,7 +57,8 @@ BatchResult sqliteExecuteBatch(std::string dbName,
 
   try {
     int affectedRows = 0;
-    opsqlite_execute_literal(dbName, "BEGIN EXCLUSIVE TRANSACTION");
+    opsqlite_execute(dbName, "BEGIN EXCLUSIVE TRANSACTION", nullptr, nullptr,
+                     nullptr);
     for (int i = 0; i < commandCount; i++) {
       auto command = commands->at(i);
       // We do not provide a datastructure to receive query data because we
@@ -65,7 +66,7 @@ BatchResult sqliteExecuteBatch(std::string dbName,
       auto result = opsqlite_execute(dbName, command.sql, command.params.get(),
                                      nullptr, nullptr);
       if (result.type == SQLiteError) {
-        opsqlite_execute_literal(dbName, "ROLLBACK");
+        opsqlite_execute(dbName, "ROLLBACK", nullptr, nullptr, nullptr);
         return BatchResult{
             .type = SQLiteError,
             .message = result.message,
@@ -74,14 +75,14 @@ BatchResult sqliteExecuteBatch(std::string dbName,
         affectedRows += result.affectedRows;
       }
     }
-    opsqlite_execute_literal(dbName, "COMMIT");
+    opsqlite_execute(dbName, "COMMIT", nullptr, nullptr, nullptr);
     return BatchResult{
         .type = SQLiteOk,
         .affectedRows = affectedRows,
         .commands = static_cast<int>(commandCount),
     };
   } catch (std::exception &exc) {
-    opsqlite_execute_literal(dbName, "ROLLBACK");
+    opsqlite_execute(dbName, "ROLLBACK", nullptr, nullptr, nullptr);
     return BatchResult{
         .type = SQLiteError,
         .message = exc.what(),