@op-engineering/op-sqlite 2.0.16 → 2.0.18

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!**.
 
@@ -127,9 +127,9 @@ db.execute('PRAGMA journal_mode = MEMORY;'); // or OFF
 
 If you use [prepared statements](#prepared-statements) are useful to reduce the time of critical queries.
 
-# Perf flag
+# Perf flags
 
-You can turn on the performance flag to tweak all possible performance enhancing compilation flags, this greatly affects performance of sqlite itself:
+You can turn on the performance flag to tweak all possible performance enhancing compilation flags, this greatly affects performance of sqlite itself. Be aware this disables thread safety, you should only uses transactions (which operate based on a mutex in JS side) to avoid any issues.
 
 ```sh
 # For iOS install pods with the following env variable, you can also just an export like on Android
@@ -147,6 +147,14 @@ If correctly set you should see the following output in your console
 OP-SQLITE performance mode enabled! 🚀
 ```
 
+If you want to keep SQLite thread safety based on mutexes, you can use OP_SQLITE_PERF=2. This flag will enable the general compilation flags, except DSQLITE_THREADSAFE=0.
+If correctly set you should see the following output in your console
+
+```sh
+OP-SQLITE (thread safe) performance mode enabled! 🚀
+```
+
+Here you can read more about [SQLite Thread Safe](https://www.sqlite.org/threadsafe.html)
 # SQLite Gotchas
 
 ## Strictness
@@ -408,7 +416,7 @@ References: [Attach](https://www.sqlite.org/lang_attach.html) - [Detach](https:/
 ```ts
 db.attach('mainDatabase', 'statistics', 'stats', '../databases');
 
-const res = db.executeSql(
+const res = db.execute(
   'mainDatabase',
   'SELECT * FROM some_table_from_mainschema a INNER JOIN stats.some_table b on a.id_column = b.id_column'
 );
@@ -502,7 +510,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 +561,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/android/build.gradle

@@ -80,6 +80,10 @@ android {
               println "OP-SQLITE performance mode enabled! 🚀"
               cFlags "-DSQLITE_DQS=0", "-DSQLITE_THREADSAFE=0", "-DSQLITE_DEFAULT_MEMSTATUS=0", "-DSQLITE_DEFAULT_WAL_SYNCHRONOUS=1", "-DSQLITE_LIKE_DOESNT_MATCH_BLOBS=1", "-DSQLITE_MAX_EXPR_DEPTH=0", "-DSQLITE_OMIT_DEPRECATED=1", "-DSQLITE_OMIT_PROGRESS_CALLBACK=1", "-DSQLITE_OMIT_SHARED_CACHE=1", "-DSQLITE_USE_ALLOCA=1"
             }
+            if(System.getenv("OP_SQLITE_PERF") == '2') {
+              println "OP-SQLITE (thread safe) performance mode enabled! 🚀"
+              cFlags "-DSQLITE_DQS=0", "-DSQLITE_THREADSAFE=1", "-DSQLITE_DEFAULT_MEMSTATUS=0", "-DSQLITE_DEFAULT_WAL_SYNCHRONOUS=1", "-DSQLITE_LIKE_DOESNT_MATCH_BLOBS=1", "-DSQLITE_MAX_EXPR_DEPTH=0", "-DSQLITE_OMIT_DEPRECATED=1", "-DSQLITE_OMIT_PROGRESS_CALLBACK=1", "-DSQLITE_OMIT_SHARED_CACHE=1", "-DSQLITE_USE_ALLOCA=1"
+            }
             cppFlags "-O2", "-fexceptions", "-frtti", "-std=c++1y", "-DONANDROID"
             abiFilters 'x86', 'x86_64', 'armeabi-v7a', 'arm64-v8a'
             arguments '-DANDROID_STL=c++_shared',

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;
@@ -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;
@@ -410,18 +410,20 @@ void install(jsi::Runtime &rt,
                    resolve, reject]() {
         try {
           auto batchResult = sqliteExecuteBatch(dbName, commands.get());
-          invoker->invokeAsync(
-              [&rt, batchResult = std::move(batchResult), resolve, reject] {
-                if (batchResult.type == SQLiteOk) {
-                  auto res = jsi::Object(rt);
-                  res.setProperty(rt, "rowsAffected",
-                                  jsi::Value(batchResult.affectedRows));
-                  resolve->asObject(rt).asFunction(rt).call(rt, std::move(res));
-                } else {
-                  // TODO replace with reject
-                  throw jsi::JSError(rt, batchResult.message);
-                }
-              });
+          invoker->invokeAsync([&rt, batchResult = std::move(batchResult),
+                                resolve, reject] {
+            if (batchResult.type == SQLiteOk) {
+              auto res = jsi::Object(rt);
+              res.setProperty(rt, "rowsAffected",
+                              jsi::Value(batchResult.affectedRows));
+              resolve->asObject(rt).asFunction(rt).call(rt, std::move(res));
+            } else {
+              auto errorCtr = rt.global().getPropertyAsFunction(rt, "Error");
+              auto error = errorCtr.callAsConstructor(
+                  rt, jsi::String::createFromUtf8(rt, batchResult.message));
+              reject->asObject(rt).asFunction(rt).call(rt, error);
+            }
+          });
         } catch (std::exception &exc) {
           invoker->invokeAsync(
               [&rt, reject, &exc] { throw jsi::JSError(rt, exc.what()); });
@@ -438,7 +440,7 @@ void install(jsi::Runtime &rt,
   auto load_file = HOSTFN("loadFile", 2) {
     if (sizeof(args) < 2) {
       throw std::runtime_error(
-          "[op-sqlite][loadFileAsync] Incorrect parameter count");
+          "[op-sqlite][loadFile] Incorrect parameter count");
       return {};
     }
 
@@ -454,18 +456,21 @@ void install(jsi::Runtime &rt,
         try {
           const auto importResult = importSQLFile(dbName, sqlFileName);
 
-          invoker->invokeAsync(
-              [&rt, result = std::move(importResult), resolve, reject] {
-                if (result.type == SQLiteOk) {
-                  auto res = jsi::Object(rt);
-                  res.setProperty(rt, "rowsAffected",
-                                  jsi::Value(result.affectedRows));
-                  res.setProperty(rt, "commands", jsi::Value(result.commands));
-                  resolve->asObject(rt).asFunction(rt).call(rt, std::move(res));
-                } else {
-                  throw jsi::JSError(rt, result.message);
-                }
-              });
+          invoker->invokeAsync([&rt, result = std::move(importResult), resolve,
+                                reject] {
+            if (result.type == SQLiteOk) {
+              auto res = jsi::Object(rt);
+              res.setProperty(rt, "rowsAffected",
+                              jsi::Value(result.affectedRows));
+              res.setProperty(rt, "commands", jsi::Value(result.commands));
+              resolve->asObject(rt).asFunction(rt).call(rt, std::move(res));
+            } else {
+              auto errorCtr = rt.global().getPropertyAsFunction(rt, "Error");
+              auto error = errorCtr.callAsConstructor(
+                  rt, jsi::String::createFromUtf8(rt, result.message));
+              reject->asObject(rt).asFunction(rt).call(rt, error);
+            }
+          });
         } catch (std::exception &exc) {
           invoker->invokeAsync(
               [&rt, err = exc.what(), reject] { throw jsi::JSError(rt, err); });
@@ -489,7 +494,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 {};
     }
 
@@ -501,12 +506,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(
@@ -531,7 +535,7 @@ void install(jsi::Runtime &rt,
           });
     };
 
-    sqlite_register_update_hook(dbName, std::move(hook));
+    opsqlite_register_update_hook(dbName, std::move(hook));
 
     return {};
   });
@@ -546,7 +550,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;
@@ -556,7 +560,7 @@ 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 {};
   });
@@ -573,7 +577,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;
@@ -583,7 +587,7 @@ 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 {};
   });
 
@@ -591,7 +595,7 @@ void install(jsi::Runtime &rt,
     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);
@@ -607,7 +611,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);
     }