@op-engineering/op-sqlite 2.0.16 → 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;
@@ -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;
@@ -489,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 {};
     }
 
@@ -501,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(
@@ -531,7 +530,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 +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;
@@ -556,7 +555,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 +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;
@@ -583,7 +582,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 +590,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 +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);
     }

package/cpp/bridge.cpp

@@ -3,52 +3,56 @@
 #include "SmartHostObject.h"
 #include "logs.h"
 #include "utils.h"
-#include <ctime>
 #include <unordered_map>
 #include <variant>
 
 namespace opsqlite {
 
+/// Maps to hold the different objects
 std::unordered_map<std::string, sqlite3 *> dbMap =
     std::unordered_map<std::string, sqlite3 *>();
-std::unordered_map<std::string,
-                   std::function<void(std::string dbName, std::string tableName,
-                                      std::string operation, int rowId)>>
-    updateCallbackMap = std::unordered_map<
-        std::string,
-        std::function<void(std::string dbName, std::string tableName,
-                           std::string operation, int rowId)>>();
-
-std::unordered_map<std::string, std::function<void(std::string dbName)>>
-    commitCallbackMap =
-        std::unordered_map<std::string,
-                           std::function<void(std::string dbName)>>();
-
-std::unordered_map<std::string, std::function<void(std::string dbName)>>
-    rollbackCallbackMap =
-        std::unordered_map<std::string,
-                           std::function<void(std::string dbName)>>();
-
-std::string get_db_path(std::string const dbName, std::string const lastPath) {
-  if (lastPath == ":memory:") {
-    return lastPath;
+std::unordered_map<std::string, UpdateCallback> updateCallbackMap =
+    std::unordered_map<std::string, UpdateCallback>();
+
+std::unordered_map<std::string, CommitCallback> commitCallbackMap =
+    std::unordered_map<std::string, CommitCallback>();
+
+std::unordered_map<std::string, RollbackCallback> rollbackCallbackMap =
+    std::unordered_map<std::string, RollbackCallback>();
+
+inline void check_db_open(std::string const &db_name) {
+  if (dbMap.count(db_name) == 0) {
+    throw std::runtime_error("[OP-SQLite] DB is not open");
+  }
+}
+
+/// Start of api
+
+/// Returns the completely formed db path, but it also creates any sub-folders
+/// along the way
+std::string get_db_path(std::string const &db_name,
+                        std::string const &location) {
+
+  if (location == ":memory:") {
+    return location;
   }
-  mkdir(lastPath);
-  return lastPath + "/" + dbName;
+
+  mkdir(location);
+  return location + "/" + db_name;
 }
 
-BridgeResult sqlite_open(std::string const &dbName,
-                         std::string const &lastPath) {
+BridgeResult opsqlite_open(std::string const &dbName,
+                           std::string const &lastPath) {
   std::string dbPath = get_db_path(dbName, lastPath);
 
   int sqlOpenFlags =
       SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_FULLMUTEX;
 
   sqlite3 *db;
-  int exit = 0;
-  exit = sqlite3_open_v2(dbPath.c_str(), &db, sqlOpenFlags, nullptr);
 
-  if (exit != SQLITE_OK) {
+  int status = sqlite3_open_v2(dbPath.c_str(), &db, sqlOpenFlags, nullptr);
+
+  if (status != SQLITE_OK) {
     return {.type = SQLiteError, .message = sqlite3_errmsg(db)};
   }
 
@@ -57,14 +61,9 @@ BridgeResult sqlite_open(std::string const &dbName,
   return BridgeResult{.type = SQLiteOk, .affectedRows = 0};
 }
 
-BridgeResult sqlite_close(std::string const &dbName) {
+BridgeResult opsqlite_close(std::string const &dbName) {
 
-  if (dbMap.count(dbName) == 0) {
-    return {
-        .type = SQLiteError,
-        .message = dbName + " is not open",
-    };
-  }
+  check_db_open(dbName);
 
   sqlite3 *db = dbMap[dbName];
 
@@ -77,10 +76,10 @@ BridgeResult sqlite_close(std::string const &dbName) {
   };
 }
 
-BridgeResult sqlite_attach(std::string const &mainDBName,
-                           std::string const &docPath,
-                           std::string const &databaseToAttach,
-                           std::string const &alias) {
+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.
@@ -88,7 +87,7 @@ BridgeResult sqlite_attach(std::string const &mainDBName,
   std::string dbPath = get_db_path(databaseToAttach, docPath);
   std::string statement = "ATTACH DATABASE '" + dbPath + "' AS " + alias;
 
-  BridgeResult result = sqlite_execute_literal(mainDBName, statement);
+  BridgeResult result = opsqlite_execute_literal(mainDBName, statement);
 
   if (result.type == SQLiteError) {
     return {
@@ -102,14 +101,14 @@ BridgeResult sqlite_attach(std::string const &mainDBName,
   };
 }
 
-BridgeResult sqlite_detach(std::string const &mainDBName,
-                           std::string const &alias) {
+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 = sqlite_execute_literal(mainDBName, statement);
+  BridgeResult result = opsqlite_execute_literal(mainDBName, statement);
   if (result.type == SQLiteError) {
     return BridgeResult{
         .type = SQLiteError,
@@ -122,10 +121,10 @@ BridgeResult sqlite_detach(std::string const &mainDBName,
   };
 }
 
-BridgeResult sqlite_remove(std::string const &dbName,
-                           std::string const &docPath) {
+BridgeResult opsqlite_remove(std::string const &dbName,
+                             std::string const &docPath) {
   if (dbMap.count(dbName) == 1) {
-    BridgeResult closeResult = sqlite_close(dbName);
+    BridgeResult closeResult = opsqlite_close(dbName);
     if (closeResult.type == SQLiteError) {
       return closeResult;
     }
@@ -145,8 +144,8 @@ BridgeResult sqlite_remove(std::string const &dbName,
   };
 }
 
-inline void bindStatement(sqlite3_stmt *statement,
-                          const std::vector<JSVariant> *values) {
+inline void opsqlite_bind_statement(sqlite3_stmt *statement,
+                                    const std::vector<JSVariant> *values) {
   size_t size = values->size();
 
   for (int ii = 0; ii < size; ii++) {
@@ -175,19 +174,12 @@ inline void bindStatement(sqlite3_stmt *statement,
   }
 }
 
-void sqlite_bind_statement(sqlite3_stmt *statement,
-                           const std::vector<JSVariant> *params) {
-  bindStatement(statement, params);
-}
-
-BridgeResult sqlite_execute_prepared_statement(
+BridgeResult opsqlite_execute_prepared_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()) {
-    return {.type = SQLiteError,
-            .message = "[op-sqlite]: Database " + dbName + " is not open"};
-  }
+
+  check_db_open(dbName);
 
   sqlite3_reset(statement);
 
@@ -319,11 +311,9 @@ BridgeResult sqlite_execute_prepared_statement(
           .insertId = static_cast<double>(latestInsertRowId)};
 }
 
-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");
-  }
+sqlite3_stmt *opsqlite_prepare_statement(std::string const &dbName,
+                                         std::string const &query) {
+  check_db_open(dbName);
 
   sqlite3 *db = dbMap[dbName];
 
@@ -342,16 +332,14 @@ sqlite3_stmt *sqlite_prepare_statement(std::string const &dbName,
   return statement;
 }
 
+/// Base execution function, returns HostObjects to the JS environment
 BridgeResult
-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) {
+opsqlite_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,
-            .message = "[op-sqlite]: Database " + dbName + " is not open"};
-  }
+  check_db_open(dbName);
 
   sqlite3 *db = dbMap[dbName];
 
@@ -389,7 +377,7 @@ sqlite_execute(std::string const &dbName, std::string const &query,
     }
 
     if (params != nullptr && params->size() > 0) {
-      bindStatement(statement, params);
+      opsqlite_bind_statement(statement, params);
     }
 
     isConsuming = true;
@@ -518,15 +506,14 @@ sqlite_execute(std::string const &dbName, std::string const &query,
           .insertId = static_cast<double>(latestInsertRowId)};
 }
 
-BridgeResult sqlite_execute_raw(std::string const &dbName,
-                                std::string const &query,
-                                const std::vector<JSVariant> *params,
-                                std::vector<std::vector<JSVariant>> *results) {
+/// 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,
+                     std::vector<std::vector<JSVariant>> *results) {
 
-  if (dbMap.find(dbName) == dbMap.end()) {
-    return {.type = SQLiteError,
-            .message = "[op-sqlite]: Database " + dbName + " is not open"};
-  }
+  check_db_open(dbName);
 
   sqlite3 *db = dbMap[dbName];
 
@@ -564,7 +551,7 @@ BridgeResult sqlite_execute_raw(std::string const &dbName,
     }
 
     if (params != nullptr && params->size() > 0) {
-      bindStatement(statement, params);
+      opsqlite_bind_statement(statement, params);
     }
 
     isConsuming = true;
@@ -619,8 +606,6 @@ BridgeResult sqlite_execute_raw(std::string const &dbName,
             int blob_size = sqlite3_column_bytes(statement, i);
             const void *blob = sqlite3_column_blob(statement, i);
             uint8_t *data = new uint8_t[blob_size];
-            // You cannot share raw memory between native and JS
-            // always copy the data
             memcpy(data, blob, blob_size);
             row.push_back(
                 JSVariant(ArrayBuffer{.data = std::shared_ptr<uint8_t>{data},
@@ -676,11 +661,11 @@ BridgeResult sqlite_execute_raw(std::string const &dbName,
           .insertId = static_cast<double>(latestInsertRowId)};
 }
 
-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};
-  }
+/// 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;
@@ -730,7 +715,7 @@ BridgeResult sqlite_execute_literal(std::string const &dbName,
   return {SQLiteOk, "", changedRowCount};
 }
 
-void sqlite_close_all() {
+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
@@ -768,13 +753,9 @@ void update_callback(void *dbName, int operation_type, char const *database,
            static_cast<int>(rowid));
 }
 
-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) {
-    return {SQLiteError, "[op-sqlite] Database not opened: " + dbName};
-  }
+BridgeResult opsqlite_register_update_hook(std::string const &dbName,
+                                           UpdateCallback const callback) {
+  check_db_open(dbName);
 
   sqlite3 *db = dbMap[dbName];
   updateCallbackMap[dbName] = callback;
@@ -792,10 +773,8 @@ BridgeResult sqlite_register_update_hook(
   return {SQLiteOk};
 }
 
-BridgeResult sqlite_deregister_update_hook(std::string const &dbName) {
-  if (dbMap.count(dbName) == 0) {
-    return {SQLiteError, "[op-sqlite] Database not opened: " + dbName};
-  }
+BridgeResult opsqlite_deregister_update_hook(std::string const &dbName) {
+  check_db_open(dbName);
 
   sqlite3 *db = dbMap[dbName];
   updateCallbackMap.erase(dbName);
@@ -813,12 +792,9 @@ int commit_callback(void *dbName) {
   return 0;
 }
 
-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};
-  }
+BridgeResult opsqlite_register_commit_hook(std::string const &dbName,
+                                           CommitCallback const callback) {
+  check_db_open(dbName);
 
   sqlite3 *db = dbMap[dbName];
   commitCallbackMap[dbName] = callback;
@@ -836,10 +812,8 @@ BridgeResult sqlite_register_commit_hook(
   return {SQLiteOk};
 }
 
-BridgeResult sqlite_deregister_commit_hook(std::string const &dbName) {
-  if (dbMap.count(dbName) == 0) {
-    return {SQLiteError, "[op-sqlite] Database not opened: " + dbName};
-  }
+BridgeResult opsqlite_deregister_commit_hook(std::string const &dbName) {
+  check_db_open(dbName);
 
   sqlite3 *db = dbMap[dbName];
   commitCallbackMap.erase(dbName);
@@ -854,12 +828,9 @@ void rollback_callback(void *dbName) {
   callback(strDbName);
 }
 
-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};
-  }
+BridgeResult opsqlite_register_rollback_hook(std::string const &dbName,
+                                             RollbackCallback const callback) {
+  check_db_open(dbName);
 
   sqlite3 *db = dbMap[dbName];
   rollbackCallbackMap[dbName] = callback;
@@ -877,10 +848,8 @@ BridgeResult sqlite_register_rollback_hook(
   return {SQLiteOk};
 }
 
-BridgeResult sqlite_deregister_rollback_hook(std::string const &dbName) {
-  if (dbMap.count(dbName) == 0) {
-    return {SQLiteError, "[op-sqlite] Database not opened: " + dbName};
-  }
+BridgeResult opsqlite_deregister_rollback_hook(std::string const &dbName) {
+  check_db_open(dbName);
 
   sqlite3 *db = dbMap[dbName];
   rollbackCallbackMap.erase(dbName);
@@ -890,11 +859,13 @@ BridgeResult sqlite_deregister_rollback_hook(std::string const &dbName) {
   return {SQLiteOk};
 }
 
-BridgeResult sqlite_load_extension(std::string &db_name, std::string &path,
-                                   std::string &entry_point) {
-  if (dbMap.count(db_name) == 0) {
-    return {SQLiteError, "[op-sqlite] Database not open"};
-  }
+BridgeResult opsqlite_load_extension(std::string &db_name, std::string &path,
+                                     std::string &entry_point) {
+#ifdef OP_SQLITE_USE_PHONE_VERSION
+  throw std::runtime_error(
+      "Embedded version of SQLite does not support loading extensions");
+#else
+  check_db_open(db_name);
 
   sqlite3 *db = dbMap[db_name];
   int loading_extensions_enabled = sqlite3_enable_load_extension(db, 1);
@@ -915,6 +886,7 @@ BridgeResult sqlite_load_extension(std::string &db_name, std::string &path,
     return {SQLiteError, std::string(error_message)};
   }
   return {SQLiteOk};
+#endif
 }
 
 } // namespace opsqlite