@op-engineering/op-sqlite 2.0.8 → 2.0.11

package/README.md

@@ -16,7 +16,7 @@ Created by [@ospfranco](https://twitter.com/ospfranco). **Please consider Sponso
 
 ## Benchmarks
 
-You can find the [benchmarking code in the example app](https://github.com/OP-Engineering/op-sqlite/blob/main/example/src/Database.ts#L44). You should expect anywhere between a 5x to an 8x improvement over non-JSI packages, and now a 5x to 8x improvement over quick-sqlite and expo-sqlite. Loading a 300k record database (in milliseconds).
+You can find the [benchmarking code in the example app](https://github.com/OP-Engineering/op-sqlite/blob/main/example/src/Database.ts#L44). This is run using the `OP_SQLITE_PERF` flag which in turns disables some old and unused features of sqlite to squeeze the last drop of performance.
 
 ![benchmark](benchmark.png)
 
@@ -104,7 +104,7 @@ const largeDb = open({
 });
 ```
 
-# Speed
+# Performance
 
 op-sqlite is already the fastest solution it can be, but it doesn't mean you cannot tweak SQLite to be faster (at the cost of some disadvantages). One possible tweak is turning on [Memory Mapping](https://www.sqlite.org/mmap.html). It allows to read/write to/from the disk without going through the kernel. However, if your queries throw an error your application might crash.
 
@@ -129,6 +129,14 @@ If you use [prepared statements](#prepared-statements) plus memory mapping and s
 
 ![mmkv comparison](mmkv.png)
 
+# Perf flag
+
+You can turn on the performance flag to tweak all possible performance enhancing compilation flags, this greatly affects performance of sqlite itself
+
+```
+OP_SQLITE_PERF=1 npx pod-install
+```
+
 # SQLite Gotchas
 
 ## Strictness

package/cpp/bindings.cpp

@@ -35,10 +35,9 @@ bool invalidated = false;
 void clearState() {
   invalidated = true;
   // Will terminate all operations and database connections
-  sqliteCloseAll();
+  sqlite_close_all();
   // We then join all the threads before the context gets invalidated
   pool.restartPool();
-
   updateHooks.clear();
   commitHooks.clear();
   rollbackHooks.clear();
@@ -81,7 +80,7 @@ void install(jsi::Runtime &rt,
       }
     }
 
-    BridgeResult result = sqliteOpenDb(dbName, path);
+    BridgeResult result = sqlite_open(dbName, path);
 
     if (result.type == SQLiteError) {
       throw std::runtime_error(result.message);
@@ -115,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 =
-        sqliteAttachDb(dbName, tempDocPath, databaseToAttach, alias);
+        sqlite_attach(dbName, tempDocPath, databaseToAttach, alias);
 
     if (result.type == SQLiteError) {
       throw std::runtime_error(result.message);
@@ -137,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 = sqliteDetachDb(dbName, alias);
+    BridgeResult result = sqlite_detach(dbName, alias);
 
     if (result.type == SQLiteError) {
       throw jsi::JSError(rt, result.message.c_str());
@@ -158,7 +157,7 @@ void install(jsi::Runtime &rt,
 
     std::string dbName = args[0].asString(rt).utf8(rt);
 
-    BridgeResult result = sqliteCloseDb(dbName);
+    BridgeResult result = sqlite_close(dbName);
 
     if (result.type == SQLiteError) {
       throw jsi::JSError(rt, result.message.c_str());
@@ -190,7 +189,7 @@ void install(jsi::Runtime &rt,
       tempDocPath = tempDocPath + "/" + args[1].asString(rt).utf8(rt);
     }
 
-    BridgeResult result = sqliteRemoveDb(dbName, tempDocPath);
+    BridgeResult result = sqlite_remove(dbName, tempDocPath);
 
     if (result.type == SQLiteError) {
       throw std::runtime_error(result.message);
@@ -213,7 +212,7 @@ void install(jsi::Runtime &rt,
     std::shared_ptr<std::vector<SmartHostObject>> metadata =
         std::make_shared<std::vector<SmartHostObject>>();
 
-    auto status = sqliteExecute(dbName, query, &params, &results, metadata);
+    auto status = sqlite_execute(dbName, query, &params, &results, metadata);
 
     if (status.type == SQLiteError) {
       throw std::runtime_error(status.message);
@@ -249,7 +248,7 @@ void install(jsi::Runtime &rt,
               std::make_shared<std::vector<SmartHostObject>>();
 
           auto status =
-              sqliteExecute(dbName, query, &params, &results, metadata);
+              sqlite_execute(dbName, query, &params, &results, metadata);
 
           if (invalidated) {
             return;
@@ -422,9 +421,8 @@ void install(jsi::Runtime &rt,
 
   auto updateHook = HOSTFN("updateHook", 2) {
     if (sizeof(args) < 2) {
-      throw std::runtime_error(
-          "[op-sqlite][loadFileAsync] Incorrect parameters: "
-          "dbName and callback needed");
+      throw std::runtime_error("[op-sqlite][updateHook] Incorrect parameters: "
+                               "dbName and callback needed");
       return {};
     }
 
@@ -432,7 +430,7 @@ void install(jsi::Runtime &rt,
     auto callback = std::make_shared<jsi::Value>(rt, args[1]);
 
     if (callback->isUndefined() || callback->isNull()) {
-      unregisterUpdateHook(dbName);
+      sqlite_deregister_update_hook(dbName);
       return {};
     }
 
@@ -449,7 +447,7 @@ void install(jsi::Runtime &rt,
       if (operation != "DELETE") {
         std::string query = "SELECT * FROM " + tableName +
                             " where rowid = " + std::to_string(rowId) + ";";
-        sqliteExecute(dbName, query, &params, &results, metadata);
+        sqlite_execute(dbName, query, &params, &results, metadata);
       }
 
       invoker->invokeAsync(
@@ -474,23 +472,22 @@ void install(jsi::Runtime &rt,
           });
     };
 
-    registerUpdateHook(dbName, std::move(hook));
+    sqlite_register_update_hook(dbName, std::move(hook));
 
     return {};
   });
 
   auto commitHook = HOSTFN("commitHook", 2) {
     if (sizeof(args) < 2) {
-      throw std::runtime_error(
-          "[op-sqlite][loadFileAsync] Incorrect parameters: "
-          "dbName and callback needed");
+      throw std::runtime_error("[op-sqlite][commitHook] Incorrect parameters: "
+                               "dbName and callback needed");
       return {};
     }
 
     auto dbName = args[0].asString(rt).utf8(rt);
     auto callback = std::make_shared<jsi::Value>(rt, args[1]);
     if (callback->isUndefined() || callback->isNull()) {
-      unregisterCommitHook(dbName);
+      sqlite_deregister_commit_hook(dbName);
       return {};
     }
     commitHooks[dbName] = callback;
@@ -500,7 +497,7 @@ void install(jsi::Runtime &rt,
           [&rt, callback] { callback->asObject(rt).asFunction(rt).call(rt); });
     };
 
-    registerCommitHook(dbName, std::move(hook));
+    sqlite_register_commit_hook(dbName, std::move(hook));
 
     return {};
   });
@@ -508,7 +505,7 @@ void install(jsi::Runtime &rt,
   auto rollbackHook = HOSTFN("rollbackHook", 2) {
     if (sizeof(args) < 2) {
       throw std::runtime_error(
-          "[op-sqlite][loadFileAsync] Incorrect parameters: "
+          "[op-sqlite][rollbackHook] Incorrect parameters: "
           "dbName and callback needed");
       return {};
     }
@@ -517,7 +514,7 @@ void install(jsi::Runtime &rt,
     auto callback = std::make_shared<jsi::Value>(rt, args[1]);
 
     if (callback->isUndefined() || callback->isNull()) {
-      unregisterRollbackHook(dbName);
+      sqlite_deregister_rollback_hook(dbName);
       return {};
     }
     rollbackHooks[dbName] = callback;
@@ -527,7 +524,7 @@ void install(jsi::Runtime &rt,
           [&rt, callback] { callback->asObject(rt).asFunction(rt).call(rt); });
     };
 
-    registerRollbackHook(dbName, std::move(hook));
+    sqlite_register_rollback_hook(dbName, std::move(hook));
     return {};
   });
 

package/cpp/bridge.cpp

@@ -2,10 +2,8 @@
 #include "DumbHostObject.h"
 #include "SmartHostObject.h"
 #include "logs.h"
+#include "utils.h"
 #include <ctime>
-#include <sstream>
-#include <sys/stat.h>
-#include <unistd.h>
 #include <unordered_map>
 #include <variant>
 
@@ -31,63 +29,16 @@ std::unordered_map<std::string, std::function<void(std::string dbName)>>
         std::unordered_map<std::string,
                            std::function<void(std::string dbName)>>();
 
-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, '/')) {
-    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;
-}
-
-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 lastPath) {
   if (lastPath == ":memory:") {
     return lastPath;
   }
-  mkdir(lastPath.c_str());
+  mkdir(lastPath);
   return lastPath + "/" + dbName;
 }
 
-BridgeResult sqliteOpenDb(std::string const dbName,
-                          std::string const lastPath) {
+BridgeResult sqlite_open(std::string const &dbName,
+                         std::string const &lastPath) {
   std::string dbPath = get_db_path(dbName, lastPath);
 
   int sqlOpenFlags =
@@ -106,7 +57,7 @@ BridgeResult sqliteOpenDb(std::string const dbName,
   return BridgeResult{.type = SQLiteOk, .affectedRows = 0};
 }
 
-BridgeResult sqliteCloseDb(std::string const dbName) {
+BridgeResult sqlite_close(std::string const &dbName) {
 
   if (dbMap.count(dbName) == 0) {
     return {
@@ -126,10 +77,10 @@ BridgeResult sqliteCloseDb(std::string const dbName) {
   };
 }
 
-BridgeResult sqliteAttachDb(std::string const mainDBName,
-                            std::string const docPath,
-                            std::string const databaseToAttach,
-                            std::string const alias) {
+BridgeResult sqlite_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.
@@ -137,7 +88,7 @@ BridgeResult sqliteAttachDb(std::string const mainDBName,
   std::string dbPath = get_db_path(databaseToAttach, docPath);
   std::string statement = "ATTACH DATABASE '" + dbPath + "' AS " + alias;
 
-  BridgeResult result = sqliteExecuteLiteral(mainDBName, statement);
+  BridgeResult result = sqlite_execute_literal(mainDBName, statement);
 
   if (result.type == SQLiteError) {
     return {
@@ -151,14 +102,14 @@ BridgeResult sqliteAttachDb(std::string const mainDBName,
   };
 }
 
-BridgeResult sqliteDetachDb(std::string const mainDBName,
-                            std::string const alias) {
+BridgeResult sqlite_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 = sqliteExecuteLiteral(mainDBName, statement);
+  BridgeResult result = sqlite_execute_literal(mainDBName, statement);
   if (result.type == SQLiteError) {
     return BridgeResult{
         .type = SQLiteError,
@@ -171,10 +122,10 @@ BridgeResult sqliteDetachDb(std::string const mainDBName,
   };
 }
 
-BridgeResult sqliteRemoveDb(std::string const dbName,
-                            std::string const docPath) {
+BridgeResult sqlite_remove(std::string const &dbName,
+                           std::string const &docPath) {
   if (dbMap.count(dbName) == 1) {
-    BridgeResult closeResult = sqliteCloseDb(dbName);
+    BridgeResult closeResult = sqlite_close(dbName);
     if (closeResult.type == SQLiteError) {
       return closeResult;
     }
@@ -230,7 +181,7 @@ void sqlite_bind_statement(sqlite3_stmt *statement,
 }
 
 BridgeResult sqlite_execute_prepared_statement(
-    std::string const dbName, sqlite3_stmt *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()) {
@@ -368,7 +319,7 @@ BridgeResult sqlite_execute_prepared_statement(
           .insertId = static_cast<double>(latestInsertRowId)};
 }
 
-sqlite3_stmt *sqlite_prepare_statement(std::string const dbName,
+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");
@@ -392,10 +343,10 @@ sqlite3_stmt *sqlite_prepare_statement(std::string const dbName,
 }
 
 BridgeResult
-sqliteExecute(std::string const dbName, std::string const &query,
-              const std::vector<JSVariant> *params,
-              std::vector<DumbHostObject> *results,
-              std::shared_ptr<std::vector<SmartHostObject>> metadatas) {
+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) {
 
   if (dbMap.find(dbName) == dbMap.end()) {
     return {.type = SQLiteError,
@@ -427,7 +378,7 @@ sqliteExecute(std::string const dbName, std::string const &query,
           .message = "[op-sqlite] SQL statement error:" +
                      std::to_string(statementStatus) +
                      " description:" + std::string(message) +
-                     "see error codes: https://www.sqlite.org/rescode.html",
+                     ". See error codes: https://www.sqlite.org/rescode.html",
       };
     }
 
@@ -567,8 +518,8 @@ sqliteExecute(std::string const dbName, std::string const &query,
           .insertId = static_cast<double>(latestInsertRowId)};
 }
 
-BridgeResult sqliteExecuteLiteral(std::string const dbName,
-                                  std::string const &query) {
+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};
   }
@@ -621,7 +572,7 @@ BridgeResult sqliteExecuteLiteral(std::string const dbName,
   return {SQLiteOk, "", changedRowCount};
 }
 
-void sqliteCloseAll() {
+void sqlite_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
@@ -630,9 +581,12 @@ void sqliteCloseAll() {
     sqlite3_close_v2(x.second);
   }
   dbMap.clear();
+  updateCallbackMap.clear();
+  rollbackCallbackMap.clear();
+  commitCallbackMap.clear();
 }
 
-std::string operationToString(int operation_type) {
+std::string operation_to_string(int operation_type) {
   switch (operation_type) {
   case SQLITE_INSERT:
     return "INSERT";
@@ -652,12 +606,12 @@ void update_callback(void *dbName, int operation_type, char const *database,
                      char const *table, sqlite3_int64 rowid) {
   std::string &strDbName = *(static_cast<std::string *>(dbName));
   auto callback = updateCallbackMap[strDbName];
-  callback(strDbName, std::string(table), operationToString(operation_type),
+  callback(strDbName, std::string(table), operation_to_string(operation_type),
            static_cast<int>(rowid));
 }
 
-BridgeResult registerUpdateHook(
-    std::string const dbName,
+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) {
@@ -680,7 +634,7 @@ BridgeResult registerUpdateHook(
   return {SQLiteOk};
 }
 
-BridgeResult unregisterUpdateHook(std::string const dbName) {
+BridgeResult sqlite_deregister_update_hook(std::string const &dbName) {
   if (dbMap.count(dbName) == 0) {
     return {SQLiteError, "[op-sqlite] Database not opened: " + dbName};
   }
@@ -701,9 +655,9 @@ int commit_callback(void *dbName) {
   return 0;
 }
 
-BridgeResult
-registerCommitHook(std::string const dbName,
-                   std::function<void(std::string dbName)> const callback) {
+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};
   }
@@ -724,7 +678,7 @@ registerCommitHook(std::string const dbName,
   return {SQLiteOk};
 }
 
-BridgeResult unregisterCommitHook(std::string const dbName) {
+BridgeResult sqlite_deregister_commit_hook(std::string const &dbName) {
   if (dbMap.count(dbName) == 0) {
     return {SQLiteError, "[op-sqlite] Database not opened: " + dbName};
   }
@@ -742,9 +696,9 @@ void rollback_callback(void *dbName) {
   callback(strDbName);
 }
 
-BridgeResult
-registerRollbackHook(std::string const dbName,
-                     std::function<void(std::string dbName)> const callback) {
+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};
   }
@@ -765,7 +719,7 @@ registerRollbackHook(std::string const dbName,
   return {SQLiteOk};
 }
 
-BridgeResult unregisterRollbackHook(std::string const dbName) {
+BridgeResult sqlite_deregister_rollback_hook(std::string const &dbName) {
   if (dbMap.count(dbName) == 0) {
     return {SQLiteError, "[op-sqlite] Database not opened: " + dbName};
   }

package/cpp/bridge.h

@@ -12,54 +12,54 @@ namespace opsqlite {
 
 namespace jsi = facebook::jsi;
 
-BridgeResult sqliteOpenDb(std::string const dbName, std::string const dbPath);
+BridgeResult sqlite_open(std::string const &dbName, std::string const &dbPath);
 
-BridgeResult sqliteCloseDb(std::string const dbName);
+BridgeResult sqlite_close(std::string const &dbName);
 
-BridgeResult sqliteRemoveDb(std::string const dbName,
-                            std::string const docPath);
+BridgeResult sqlite_remove(std::string const &dbName,
+                           std::string const &docPath);
 
-BridgeResult sqliteAttachDb(std::string const mainDBName,
-                            std::string const docPath,
-                            std::string const databaseToAttach,
-                            std::string const alias);
+BridgeResult sqlite_attach(std::string const &mainDBName,
+                           std::string const &docPath,
+                           std::string const &databaseToAttach,
+                           std::string const &alias);
 
-BridgeResult sqliteDetachDb(std::string const mainDBName,
-                            std::string const alias);
+BridgeResult sqlite_detach(std::string const &mainDBName,
+                           std::string const &alias);
 
 BridgeResult
-sqliteExecute(std::string const dbName, std::string const &query,
-              const std::vector<JSVariant> *params,
-              std::vector<DumbHostObject> *results,
-              std::shared_ptr<std::vector<SmartHostObject>> metadatas);
+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 sqliteExecuteLiteral(std::string const dbName,
-                                  std::string const &query);
+BridgeResult sqlite_execute_literal(std::string const &dbName,
+                                    std::string const &query);
 
-void sqliteCloseAll();
+void sqlite_close_all();
 
-BridgeResult registerUpdateHook(
-    std::string const dbName,
+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 unregisterUpdateHook(std::string const dbName);
-BridgeResult
-registerCommitHook(std::string const dbName,
-                   std::function<void(std::string dbName)> const callback);
-BridgeResult unregisterCommitHook(std::string const dbName);
-BridgeResult
-registerRollbackHook(std::string const dbName,
-                     std::function<void(std::string dbName)> const callback);
-BridgeResult unregisterRollbackHook(std::string const dbName);
-
-sqlite3_stmt *sqlite_prepare_statement(std::string const dbName,
+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(
-    std::string const dbName, sqlite3_stmt *statement,
+    std::string const &dbName, sqlite3_stmt *statement,
     std::vector<DumbHostObject> *results,
     std::shared_ptr<std::vector<SmartHostObject>> metadatas);
 } // namespace opsqlite

package/cpp/sqlbatchexecutor.cpp

@@ -57,15 +57,15 @@ BatchResult sqliteExecuteBatch(std::string dbName,
 
   try {
     int affectedRows = 0;
-    sqliteExecuteLiteral(dbName, "BEGIN EXCLUSIVE TRANSACTION");
+    sqlite_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 = sqliteExecute(dbName, command.sql, command.params.get(),
-                                  nullptr, nullptr);
+      auto result = sqlite_execute(dbName, command.sql, command.params.get(),
+                                   nullptr, nullptr);
       if (result.type == SQLiteError) {
-        sqliteExecuteLiteral(dbName, "ROLLBACK");
+        sqlite_execute_literal(dbName, "ROLLBACK");
         return BatchResult{
             .type = SQLiteError,
             .message = result.message,
@@ -74,14 +74,14 @@ BatchResult sqliteExecuteBatch(std::string dbName,
         affectedRows += result.affectedRows;
       }
     }
-    sqliteExecuteLiteral(dbName, "COMMIT");
+    sqlite_execute_literal(dbName, "COMMIT");
     return BatchResult{
         .type = SQLiteOk,
         .affectedRows = affectedRows,
         .commands = static_cast<int>(commandCount),
     };
   } catch (std::exception &exc) {
-    sqliteExecuteLiteral(dbName, "ROLLBACK");
+    sqlite_execute_literal(dbName, "ROLLBACK");
     return BatchResult{
         .type = SQLiteError,
         .message = exc.what(),

package/cpp/utils.cpp

@@ -3,6 +3,9 @@
 #include "bridge.h"
 #include <fstream>
 #include <iostream>
+#include <sstream>
+#include <sys/stat.h>
+#include <unistd.h>
 
 namespace opsqlite {
 
@@ -191,12 +194,12 @@ BatchResult importSQLFile(std::string dbName, std::string fileLocation) {
     try {
       int affectedRows = 0;
       int commands = 0;
-      sqliteExecuteLiteral(dbName, "BEGIN EXCLUSIVE TRANSACTION");
+      sqlite_execute_literal(dbName, "BEGIN EXCLUSIVE TRANSACTION");
       while (std::getline(sqFile, line, '\n')) {
         if (!line.empty()) {
-          BridgeResult result = sqliteExecuteLiteral(dbName, line);
+          BridgeResult result = sqlite_execute_literal(dbName, line);
           if (result.type == SQLiteError) {
-            sqliteExecuteLiteral(dbName, "ROLLBACK");
+            sqlite_execute_literal(dbName, "ROLLBACK");
             sqFile.close();
             return {SQLiteError, result.message, 0, commands};
           } else {
@@ -206,11 +209,11 @@ BatchResult importSQLFile(std::string dbName, std::string fileLocation) {
         }
       }
       sqFile.close();
-      sqliteExecuteLiteral(dbName, "COMMIT");
+      sqlite_execute_literal(dbName, "COMMIT");
       return {SQLiteOk, "", affectedRows, commands};
     } catch (...) {
       sqFile.close();
-      sqliteExecuteLiteral(dbName, "ROLLBACK");
+      sqlite_execute_literal(dbName, "ROLLBACK");
       return {SQLiteError,
               "[op-sqlite][loadSQLFile] Unexpected error, transaction was "
               "rolledback",
@@ -221,4 +224,19 @@ BatchResult importSQLFile(std::string dbName, std::string fileLocation) {
   }
 }
 
+bool folder_exists(const std::string &foldername) {
+  struct stat buffer;
+  return (stat(foldername.c_str(), &buffer) == 0);
+}
+
+bool file_exists(const std::string &path) {
+  struct stat buffer;
+  return (stat(path.c_str(), &buffer) == 0);
+}
+
+int mkdir(std::string const &path) {
+  std::filesystem::create_directories(path);
+  return 0;
+}
+
 } // namespace opsqlite

package/cpp/utils.h

@@ -43,6 +43,12 @@ jsi::Value createResult(jsi::Runtime &rt, BridgeResult status,
 
 BatchResult importSQLFile(std::string dbName, std::string fileLocation);
 
+int mkdir(const std::string &path);
+
+bool folder_exists(const std::string &foldername);
+
+bool file_exists(const std::string &path);
+
 } // namespace opsqlite
 
 #endif /* utils_h */

package/op-sqlite.podspec

@@ -12,14 +12,14 @@ Pod::Spec.new do |s|
   s.license      = package["license"]
   s.authors      = package["author"]
 
-  s.platforms    = { :ios => "12.0", :osx => "10.13" }
+  s.platforms    = { :ios => "13.0", :osx => "10.15" }
   s.source       = { :git => "https://github.com/op-engineering/op-sqlite.git", :tag => "#{s.version}" }
 
   s.pod_target_xcconfig = {
     :GCC_PREPROCESSOR_DEFINITIONS => "HAVE_FULLFSYNC=1",
     :WARNING_CFLAGS => "-Wno-shorten-64-to-32 -Wno-comma -Wno-unreachable-code -Wno-conditional-uninitialized -Wno-deprecated-declarations",
     :USE_HEADERMAP => "No",
-    :CLANG_CXX_LANGUAGE_STANDARD => "c++17"
+    :CLANG_CXX_LANGUAGE_STANDARD => "c++17",
   }
   
   s.header_mappings_dir = "cpp"
@@ -37,5 +37,9 @@ Pod::Spec.new do |s|
     s.exclude_files = "cpp/sqlite3.c", "cpp/sqlite3.h"
     s.library = "sqlite3"
   end
+
+  if ENV['OP_SQLITE_PERF'] == '1' then
+    :OTHER_CFLAGS => '$(inherited) -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'
+  end
   
 end

package/package.json

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