@op-engineering/op-sqlite 2.0.7 → 2.0.9

package/README.md

@@ -119,10 +119,49 @@ const db = open({
 db.execute('PRAGMA mmap_size=268435456');
 ```
 
-If you use prepared statements plus memory mapping, you can get to inches of MMKV for the most performance critical queries, here is a simple example writing/reading a single value.
+You can also set journaling to memory (or even OFF if you are kinda crazy) to gain even more speed. Journaling is what allows SQLite to ROLLBACK statements and it is dangerous, so do it at your own risk
+
+```ts
+db.execute('PRAGMA journal_mode = MEMORY;'); // or OFF
+```
+
+If you use [prepared statements](#prepared-statements) plus memory mapping and set journaling to memory, you can get to inches of MMKV for the most performance critical queries, here is a simple example writing/reading a single value.
 
 ![mmkv comparison](mmkv.png)
 
+# SQLite Gotchas
+
+## Strictness
+
+It's important to notice SQLite unlike other databases by default does not strictly check for types, if you want true type safety when you declare your tables you need to use the `STRICT` keyword.
+
+```ts
+db.execute('CREATE TABLE Test (
+              id INT PRIMARY KEY,
+              name TEXT
+          ) STRICT;');
+```
+
+If you don't set it, SQLite will happily write whatever you insert in your table, independtly of the declared type.
+
+## Foreign constraints
+
+When SQLite evaluates your query and you have forgein key constraints, it keeps track of the satisfied relations via a counter. Once your statement finishes executing and the counter is not 0, it throws a foreign key constraint failed error. Unfortunately, this simple design means it is impossible to catch which foreign constraint is failed and you will receive a generic error. Nothing op-sqlite can do about it, it's a design flaw in SQLite.
+
+In order to catch foreign key errors, you also need to execute the pragma when you open your connection:
+
+```
+PRAGMA foreign_keys = true
+```
+
+## Error codes
+
+Sometimes you might be using valid SQL syntax for other engines or you might be doing something else wrong. The errors returned by op-sqlite contain the raw error code returned by SQLite and you should check [the reference](https://www.sqlite.org/rescode.html) for more detailed information.
+
+## Quirks
+
+See the [full list of SQLite quirks](https://www.sqlite.org/quirks.html).
+
 # API
 
 ```typescript

package/cpp/DumbHostObject.cpp

@@ -36,7 +36,35 @@ jsi::Value DumbHostObject::get(jsi::Runtime &rt,
     }
   }
 
+  for (auto pairField : ownValues) {
+    if (name == pairField.first) {
+      return toJSI(rt, pairField.second);
+    }
+  }
+
   return {};
 }
 
+void DumbHostObject::set(jsi::Runtime &rt, const jsi::PropNameID &name,
+                         const jsi::Value &value) {
+  auto key = name.utf8(rt);
+  auto fields = metadata.get();
+  for (int i = 0; i < fields->size(); i++) {
+    auto fieldName = std::get<std::string>(fields->at(i).fields[0].second);
+    if (fieldName == key) {
+      values[i] = toVariant(rt, value);
+      return;
+    }
+  }
+
+  for (auto pairField : ownValues) {
+    if (key == pairField.first) {
+      pairField.second = toVariant(rt, value);
+      return;
+    }
+  }
+
+  ownValues.push_back(std::make_pair(key, toVariant(rt, value)));
+}
+
 } // namespace opsqlite

package/cpp/DumbHostObject.h

@@ -23,9 +23,14 @@ public:
 
   jsi::Value get(jsi::Runtime &rt, const jsi::PropNameID &propNameID);
 
+  void set(jsi::Runtime &rt, const jsi::PropNameID &name,
+           const jsi::Value &value);
+
   std::vector<JSVariant> values;
 
   std::shared_ptr<std::vector<SmartHostObject>> metadata;
+
+  std::vector<std::pair<std::string, JSVariant>> ownValues;
 };
 
 } // namespace opsqlite

package/cpp/bindings.cpp

@@ -35,7 +35,7 @@ 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();
 
@@ -81,7 +81,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 +115,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 +137,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 +158,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 +190,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 +213,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 +249,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;
@@ -432,7 +432,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 +449,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,7 +474,7 @@ void install(jsi::Runtime &rt,
           });
     };
 
-    registerUpdateHook(dbName, std::move(hook));
+    sqlite_register_update_hook(dbName, std::move(hook));
 
     return {};
   });
@@ -490,7 +490,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()) {
-      unregisterCommitHook(dbName);
+      sqlite_deregister_commit_hook(dbName);
       return {};
     }
     commitHooks[dbName] = callback;
@@ -500,7 +500,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 {};
   });
@@ -517,7 +517,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 +527,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
@@ -632,7 +583,7 @@ void sqliteCloseAll() {
   dbMap.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 +603,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 +631,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 +652,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 +675,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 +693,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 +716,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 {
 
@@ -38,6 +41,49 @@ jsi::Value toJSI(jsi::Runtime &rt, JSVariant value) {
   return jsi::Value::null();
 }
 
+JSVariant toVariant(jsi::Runtime &rt, const jsi::Value &value) {
+  if (value.isNull() || value.isUndefined()) {
+    return JSVariant(nullptr);
+  } else if (value.isBool()) {
+    return JSVariant(value.getBool());
+  } else if (value.isNumber()) {
+    double doubleVal = value.asNumber();
+    int intVal = (int)doubleVal;
+    long long longVal = (long)doubleVal;
+    if (intVal == doubleVal) {
+      return JSVariant(intVal);
+    } else if (longVal == doubleVal) {
+      return JSVariant(longVal);
+    } else {
+      return JSVariant(doubleVal);
+    }
+  } else if (value.isString()) {
+    std::string strVal = value.asString(rt).utf8(rt);
+    return JSVariant(strVal);
+  } else if (value.isObject()) {
+    auto obj = value.asObject(rt);
+    if (obj.isArrayBuffer(rt)) {
+      auto buffer = obj.getArrayBuffer(rt);
+
+      uint8_t *data = new uint8_t[buffer.size(rt)];
+      // You cannot share raw memory between native and JS
+      // always copy the data
+      // see https://github.com/facebook/hermes/pull/419 and
+      // https://github.com/facebook/hermes/issues/564.
+      memcpy(data, buffer.data(rt), buffer.size(rt));
+
+      return JSVariant(ArrayBuffer{.data = std::shared_ptr<uint8_t>{data},
+                                   .size = buffer.size(rt)});
+    } else {
+      throw std::invalid_argument(
+          "Unknown JSI ArrayBuffer to variant value conversion, received "
+          "object instead of ArrayBuffer");
+    }
+  } else {
+    throw std::invalid_argument("Unknown JSI to variant value conversion");
+  }
+}
+
 std::vector<JSVariant> toVariantVec(jsi::Runtime &rt,
                                     jsi::Value const &params) {
   std::vector<JSVariant> res;
@@ -148,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 {
@@ -163,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",
@@ -178,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

@@ -33,6 +33,8 @@ struct BatchResult {
 
 jsi::Value toJSI(jsi::Runtime &rt, JSVariant value);
 
+JSVariant toVariant(jsi::Runtime &rt, jsi::Value const &value);
+
 std::vector<JSVariant> toVariantVec(jsi::Runtime &rt, jsi::Value const &args);
 
 jsi::Value createResult(jsi::Runtime &rt, BridgeResult status,
@@ -41,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@op-engineering/op-sqlite",
-  "version": "2.0.7",
+  "version": "2.0.9",
   "description": "Next generation SQLite for React Native",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",
@@ -26,7 +26,7 @@
     "typescript": "tsc --noEmit",
     "prepare": "bob build",
     "example": "yarn --cwd example",
-    "pods": "cd example && npx pod-install --quiet",
+    "pods": "cd example && yarn pods",
     "bootstrap": "yarn example && yarn && yarn pods",
     "bump": "./bump-version.sh"
   },
@@ -48,7 +48,7 @@
   "devDependencies": {
     "lefthook": "^1.5.5",
     "react": "18.2.0",
-    "react-native": "0.73.0",
+    "react-native": "0.73.1",
     "react-native-builder-bob": "^0.23.2",
     "typescript": "5.0.4"
   },