@op-engineering/op-sqlite 2.0.15 → 2.0.17

package/README.md

@@ -6,7 +6,7 @@ yarn add @op-engineering/op-sqlite && npx pod-install
 
 OP-SQLite embeds the latest version of SQLite and provides a low-level API to execute SQL queries.
 
-**Current SQLite version: 3.44.0**
+**Current SQLite version: 3.45.1**
 
 Created by [@ospfranco](https://twitter.com/ospfranco). **Please consider sponsoring!**.
 
@@ -502,7 +502,7 @@ On iOS you can use the embedded SQLite, when running `pod-install` add an enviro
 OP_SQLITE_USE_PHONE_VERSION=1 npx pod-install
 ```
 
-On Android, it is not possible to link the OS SQLite. It is also a bad idea due to vendor changes, old android bugs, etc. Unfortunately, this means this library will add some megabytes to your app size.
+On Android, it is not possible to link the OS SQLite. It is also a bad idea due to vendor changes, old android bugs, etc. Unfortunately, this means this library will add some megabytes to your app size. Take note that the embedded version of SQLite does not support loading runtime extensions due to security concerns from apple.
 
 # Enable compile-time options
 
@@ -553,6 +553,24 @@ On iOS, the SQLite database can be placed in an app group, in order to make it a
 
 To use an app group, add the app group ID as the value for the `OPSQLite_AppGroup` key in your project's `Info.plist` file. You'll also need to configure the app group in your project settings. (Xcode -> Project Settings -> Signing & Capabilities -> Add Capability -> App Groups)
 
+## use_frameworks
+
+If you are using `use_frameworks` (because one of your dependencies requires e.g. firebase), you might get a linking error since the OS version will try to be linked instead of the version compiled directly from sources. In order to get around this you can add the following into your Podfile:
+
+```ruby
+  pre_install do |installer|
+    installer.pod_targets.each do |pod|
+      if pod.name.eql?('op-sqlite')
+        def pod.build_type
+          Pod::BuildType.static_library
+        end
+      end
+    end
+  end
+```
+
+It will change the type of library only for op-sqlite only to static. This should be fine as SQLite is compiled from sources, so no missing symbols should be there.
+
 # Contribute
 
 You need to have clang-format installed (`brew install clang-format`)

package/cpp/PreparedStatementHostObject.cpp

@@ -38,7 +38,7 @@ jsi::Value PreparedStatementHostObject::get(jsi::Runtime &rt,
       const jsi::Value &js_params = args[0];
       std::vector<JSVariant> params = toVariantVec(rt, js_params);
 
-      sqlite_bind_statement(_statement, &params);
+      opsqlite_bind_statement(_statement, &params);
 
       return {};
     });
@@ -53,8 +53,8 @@ jsi::Value PreparedStatementHostObject::get(jsi::Runtime &rt,
       std::shared_ptr<std::vector<SmartHostObject>> metadata =
           std::make_shared<std::vector<SmartHostObject>>();
 
-      auto status = sqlite_execute_prepared_statement(_dbName, _statement,
-                                                      &results, metadata);
+      auto status = opsqlite_execute_prepared_statement(_dbName, _statement,
+                                                        &results, metadata);
 
       if (status.type == SQLiteError) {
         throw std::runtime_error(status.message);

package/cpp/bindings.cpp

@@ -35,7 +35,7 @@ bool invalidated = false;
 void clearState() {
   invalidated = true;
   // Will terminate all operations and database connections
-  sqlite_close_all();
+  opsqlite_close_all();
   // We then join all the threads before the context gets invalidated
   pool.restartPool();
   updateHooks.clear();
@@ -80,7 +80,7 @@ void install(jsi::Runtime &rt,
       }
     }
 
-    BridgeResult result = sqlite_open(dbName, path);
+    BridgeResult result = opsqlite_open(dbName, path);
 
     if (result.type == SQLiteError) {
       throw std::runtime_error(result.message);
@@ -114,7 +114,7 @@ void install(jsi::Runtime &rt,
     std::string databaseToAttach = args[1].asString(rt).utf8(rt);
     std::string alias = args[2].asString(rt).utf8(rt);
     BridgeResult result =
-        sqlite_attach(dbName, tempDocPath, databaseToAttach, alias);
+        opsqlite_attach(dbName, tempDocPath, databaseToAttach, alias);
 
     if (result.type == SQLiteError) {
       throw std::runtime_error(result.message);
@@ -136,7 +136,7 @@ void install(jsi::Runtime &rt,
 
     std::string dbName = args[0].asString(rt).utf8(rt);
     std::string alias = args[1].asString(rt).utf8(rt);
-    BridgeResult result = sqlite_detach(dbName, alias);
+    BridgeResult result = opsqlite_detach(dbName, alias);
 
     if (result.type == SQLiteError) {
       throw jsi::JSError(rt, result.message.c_str());
@@ -157,7 +157,7 @@ void install(jsi::Runtime &rt,
 
     std::string dbName = args[0].asString(rt).utf8(rt);
 
-    BridgeResult result = sqlite_close(dbName);
+    BridgeResult result = opsqlite_close(dbName);
 
     if (result.type == SQLiteError) {
       throw jsi::JSError(rt, result.message.c_str());
@@ -189,7 +189,7 @@ void install(jsi::Runtime &rt,
       tempDocPath = tempDocPath + "/" + args[1].asString(rt).utf8(rt);
     }
 
-    BridgeResult result = sqlite_remove(dbName, tempDocPath);
+    BridgeResult result = opsqlite_remove(dbName, tempDocPath);
 
     if (result.type == SQLiteError) {
       throw std::runtime_error(result.message);
@@ -212,7 +212,7 @@ void install(jsi::Runtime &rt,
     std::shared_ptr<std::vector<SmartHostObject>> metadata =
         std::make_shared<std::vector<SmartHostObject>>();
 
-    auto status = sqlite_execute(dbName, query, &params, &results, metadata);
+    auto status = opsqlite_execute(dbName, query, &params, &results, metadata);
 
     if (status.type == SQLiteError) {
       throw std::runtime_error(status.message);
@@ -245,7 +245,7 @@ void install(jsi::Runtime &rt,
         try {
           std::vector<std::vector<JSVariant>> results;
 
-          auto status = sqlite_execute_raw(dbName, query, &params, &results);
+          auto status = opsqlite_execute_raw(dbName, query, &params, &results);
 
           if (invalidated) {
             return;
@@ -283,7 +283,7 @@ void install(jsi::Runtime &rt,
         return promise;
   });
 
-  auto executeAsync = HOSTFN("executeAsync", 3) {
+  auto execute_async = HOSTFN("executeAsync", 3) {
     if (count < 3) {
       throw std::runtime_error(
           "[op-sqlite][executeAsync] Incorrect arguments for executeAsync");
@@ -309,7 +309,7 @@ void install(jsi::Runtime &rt,
               std::make_shared<std::vector<SmartHostObject>>();
 
           auto status =
-              sqlite_execute(dbName, query, &params, &results, metadata);
+              opsqlite_execute(dbName, query, &params, &results, metadata);
 
           if (invalidated) {
             return;
@@ -351,9 +351,7 @@ void install(jsi::Runtime &rt,
     return promise;
   });
 
-  // Execute a batch of SQL queries in a transaction
-  // Parameters can be: [[sql: string, arguments: any[] | arguments: any[][] ]]
-  auto executeBatch = HOSTFN("executeBatch", 2) {
+  auto execute_batch = HOSTFN("executeBatch", 2) {
     if (sizeof(args) < 2) {
       throw std::runtime_error(
           "[op-sqlite][executeBatch] - Incorrect parameter count");
@@ -379,7 +377,7 @@ void install(jsi::Runtime &rt,
     }
   });
 
-  auto executeBatchAsync = HOSTFN("executeBatchAsync", 2) {
+  auto execute_batch_async = HOSTFN("executeBatchAsync", 2) {
     if (sizeof(args) < 2) {
       throw std::runtime_error(
           "[op-sqlite][executeAsyncBatch] Incorrect parameter count");
@@ -437,7 +435,7 @@ void install(jsi::Runtime &rt,
         return promise;
   });
 
-  auto loadFile = HOSTFN("loadFile", 2) {
+  auto load_file = HOSTFN("loadFile", 2) {
     if (sizeof(args) < 2) {
       throw std::runtime_error(
           "[op-sqlite][loadFileAsync] Incorrect parameter count");
@@ -480,7 +478,7 @@ void install(jsi::Runtime &rt,
         return promise;
   });
 
-  auto updateHook = HOSTFN("updateHook", 2) {
+  auto update_hook = HOSTFN("updateHook", 2) {
     if (sizeof(args) < 2) {
       throw std::runtime_error("[op-sqlite][updateHook] Incorrect parameters: "
                                "dbName and callback needed");
@@ -491,7 +489,7 @@ void install(jsi::Runtime &rt,
     auto callback = std::make_shared<jsi::Value>(rt, args[1]);
 
     if (callback->isUndefined() || callback->isNull()) {
-      sqlite_deregister_update_hook(dbName);
+      opsqlite_deregister_update_hook(dbName);
       return {};
     }
 
@@ -503,12 +501,11 @@ void install(jsi::Runtime &rt,
       std::vector<DumbHostObject> results;
       std::shared_ptr<std::vector<SmartHostObject>> metadata =
           std::make_shared<std::vector<SmartHostObject>>();
-      ;
 
       if (operation != "DELETE") {
         std::string query = "SELECT * FROM " + tableName +
                             " where rowid = " + std::to_string(rowId) + ";";
-        sqlite_execute(dbName, query, &params, &results, metadata);
+        opsqlite_execute(dbName, query, &params, &results, metadata);
       }
 
       invoker->invokeAsync(
@@ -533,12 +530,12 @@ void install(jsi::Runtime &rt,
           });
     };
 
-    sqlite_register_update_hook(dbName, std::move(hook));
+    opsqlite_register_update_hook(dbName, std::move(hook));
 
     return {};
   });
 
-  auto commitHook = HOSTFN("commitHook", 2) {
+  auto commit_hook = HOSTFN("commitHook", 2) {
     if (sizeof(args) < 2) {
       throw std::runtime_error("[op-sqlite][commitHook] Incorrect parameters: "
                                "dbName and callback needed");
@@ -548,7 +545,7 @@ void install(jsi::Runtime &rt,
     auto dbName = args[0].asString(rt).utf8(rt);
     auto callback = std::make_shared<jsi::Value>(rt, args[1]);
     if (callback->isUndefined() || callback->isNull()) {
-      sqlite_deregister_commit_hook(dbName);
+      opsqlite_deregister_commit_hook(dbName);
       return {};
     }
     commitHooks[dbName] = callback;
@@ -558,12 +555,12 @@ void install(jsi::Runtime &rt,
           [&rt, callback] { callback->asObject(rt).asFunction(rt).call(rt); });
     };
 
-    sqlite_register_commit_hook(dbName, std::move(hook));
+    opsqlite_register_commit_hook(dbName, std::move(hook));
 
     return {};
   });
 
-  auto rollbackHook = HOSTFN("rollbackHook", 2) {
+  auto rollback_hook = HOSTFN("rollbackHook", 2) {
     if (sizeof(args) < 2) {
       throw std::runtime_error(
           "[op-sqlite][rollbackHook] Incorrect parameters: "
@@ -575,7 +572,7 @@ void install(jsi::Runtime &rt,
     auto callback = std::make_shared<jsi::Value>(rt, args[1]);
 
     if (callback->isUndefined() || callback->isNull()) {
-      sqlite_deregister_rollback_hook(dbName);
+      opsqlite_deregister_rollback_hook(dbName);
       return {};
     }
     rollbackHooks[dbName] = callback;
@@ -585,15 +582,15 @@ void install(jsi::Runtime &rt,
           [&rt, callback] { callback->asObject(rt).asFunction(rt).call(rt); });
     };
 
-    sqlite_register_rollback_hook(dbName, std::move(hook));
+    opsqlite_register_rollback_hook(dbName, std::move(hook));
     return {};
   });
 
-  auto prepareStatement = HOSTFN("prepareStatement", 1) {
+  auto prepare_statement = HOSTFN("prepareStatement", 1) {
     auto dbName = args[0].asString(rt).utf8(rt);
     auto query = args[1].asString(rt).utf8(rt);
 
-    sqlite3_stmt *statement = sqlite_prepare_statement(dbName, query);
+    sqlite3_stmt *statement = opsqlite_prepare_statement(dbName, query);
 
     auto preparedStatementHostObject =
         std::make_shared<PreparedStatementHostObject>(dbName, statement);
@@ -609,7 +606,7 @@ void install(jsi::Runtime &rt,
       entryPoint = args[2].asString(rt).utf8(rt);
     }
 
-    auto result = sqlite_load_extension(db_name, path, entryPoint);
+    auto result = opsqlite_load_extension(db_name, path, entryPoint);
     if (result.type == SQLiteError) {
       throw std::runtime_error(result.message);
     }
@@ -624,14 +621,14 @@ void install(jsi::Runtime &rt,
   module.setProperty(rt, "detach", std::move(detach));
   module.setProperty(rt, "delete", std::move(remove));
   module.setProperty(rt, "execute", std::move(execute));
-  module.setProperty(rt, "executeAsync", std::move(executeAsync));
-  module.setProperty(rt, "executeBatch", std::move(executeBatch));
-  module.setProperty(rt, "executeBatchAsync", std::move(executeBatchAsync));
-  module.setProperty(rt, "loadFile", std::move(loadFile));
-  module.setProperty(rt, "updateHook", std::move(updateHook));
-  module.setProperty(rt, "commitHook", std::move(commitHook));
-  module.setProperty(rt, "rollbackHook", std::move(rollbackHook));
-  module.setProperty(rt, "prepareStatement", std::move(prepareStatement));
+  module.setProperty(rt, "executeAsync", std::move(execute_async));
+  module.setProperty(rt, "executeBatch", std::move(execute_batch));
+  module.setProperty(rt, "executeBatchAsync", std::move(execute_batch_async));
+  module.setProperty(rt, "loadFile", std::move(load_file));
+  module.setProperty(rt, "updateHook", std::move(update_hook));
+  module.setProperty(rt, "commitHook", std::move(commit_hook));
+  module.setProperty(rt, "rollbackHook", std::move(rollback_hook));
+  module.setProperty(rt, "prepareStatement", std::move(prepare_statement));
   module.setProperty(rt, "loadExtension", std::move(load_extension));
   module.setProperty(rt, "executeRawAsync", std::move(execute_raw_async));