@op-engineering/op-sqlite 6.0.2-beta1 → 6.0.2-beta3

package/android/CMakeLists.txt

@@ -9,6 +9,7 @@ set (BUILD_DIR ${CMAKE_SOURCE_DIR}/build)
  include_directories(
    ../cpp
    ../cpp/sqlcipher
+   ../cpp/libsql
  )
 
 add_definitions(
@@ -18,29 +19,18 @@ add_definitions(
 add_library(
   ${PACKAGE_NAME}
   SHARED
-  ../cpp/bridge.cpp
-  ../cpp/bridge.h
   ../cpp/bindings.cpp
-  ../cpp/bindings.h
-  ../cpp/utils.h
   ../cpp/utils.cpp
-  ../cpp/ThreadPool.h
   ../cpp/ThreadPool.cpp
-  ../cpp/sqlbatchexecutor.h
-  ../cpp/sqlbatchexecutor.cpp
   ../cpp/SmartHostObject.cpp
-  ../cpp/SmartHostObject.h
-  ../cpp/PreparedStatementHostObject.h
   ../cpp/PreparedStatementHostObject.cpp
   ../cpp/DumbHostObject.cpp
-  ../cpp/DumbHostObject.h
-  ../cpp/macros.h
-  ../cpp/types.h
+  ../cpp/DBHostObject.cpp
   cpp-adapter.cpp
 )
 
 if (USE_SQLCIPHER)
-  target_sources(${PACKAGE_NAME} PRIVATE ../cpp/sqlcipher/sqlite3.h ../cpp/sqlcipher/sqlite3.c)
+  target_sources(${PACKAGE_NAME} PRIVATE ../cpp/sqlcipher/sqlite3.h ../cpp/sqlcipher/sqlite3.c ../cpp/bridge.cpp ../cpp/bridge.h)
 
   add_definitions(
     -DOP_SQLITE_USE_SQLCIPHER=1
@@ -49,8 +39,14 @@ if (USE_SQLCIPHER)
   )
   
   find_package(openssl REQUIRED CONFIG)
+elseif (USE_LIBSQL)
+  target_sources(${PACKAGE_NAME} PRIVATE ../cpp/libsql/bridge.cpp)
+  
+  add_definitions(
+    -DOP_SQLITE_USE_LIBSQL=1
+  )
 else()
- target_sources(${PACKAGE_NAME} PRIVATE ../cpp/sqlite3.h ../cpp/sqlite3.c)
+ target_sources(${PACKAGE_NAME} PRIVATE ../cpp/sqlite3.h ../cpp/sqlite3.c ../cpp/bridge.cpp ../cpp/bridge.h)
 endif()
 
 if (USE_CRSQLITE)
@@ -81,7 +77,22 @@ if (USE_SQLCIPHER)
     android
     openssl::crypto
   )
-else()
+elseif (USE_LIBSQL)
+  cmake_path(SET LIBSQL ${CMAKE_CURRENT_SOURCE_DIR}/jniLibs/${ANDROID_ABI}/libsql_experimental.a NORMALIZE)
+  add_library(libsql STATIC IMPORTED)
+  set_target_properties(libsql PROPERTIES IMPORTED_LOCATION ${LIBSQL})
+
+  target_link_libraries(
+    ${PACKAGE_NAME}
+    ${LOG_LIB}
+    fbjni::fbjni
+    ReactAndroid::jsi
+    ReactAndroid::turbomodulejsijni
+    ReactAndroid::react_nativemodule_core
+    android
+    libsql
+  )
+else ()
   target_link_libraries(
     ${PACKAGE_NAME}
     ${LOG_LIB}

package/android/build.gradle

@@ -28,6 +28,7 @@ def isNewArchitectureEnabled() {
 }
 
 def useSQLCipher = false
+def useLibsql = false
 def useCRSQLite = false
 def performanceMode = "0"
 def sqliteFlags = ""
@@ -43,10 +44,13 @@ if(opsqliteConfig) {
   performanceMode = opsqliteConfig["performanceMode"] ? opsqliteConfig["performanceMode"] : ""
   sqliteFlags = opsqliteConfig["sqliteFlags"] ? opsqliteConfig["sqliteFlags"] : ""
   enableFTS5 = opsqliteConfig["fts5"]
+  useLibsql = opsqliteConfig["libsql"]
 }
 
 if(useSQLCipher) {
   println "[OP-SQLITE] using SQLCipher 🔒"
+} else if(useLibsql) {
+  println "[OP-SQLITE] using libsql 📦"
 } else {
   println "[OP-SQLITE] using Vanilla SQLite"
 }
@@ -117,6 +121,10 @@ android {
               cFlags += "-DOP_SQLITE_USE_SQLCIPHER=1"
               cppFlags += "-DOP_SQLITE_USE_SQLCIPHER=1"
             }
+            if(useLibsql) {
+              cFlags += "-DOP_SQLITE_USE_LIBSQL=1"
+              cppFlags += "-DOP_SQLITE_USE_LIBSQL=1"
+            }
             if(useCRSQLite) {
               cFlags += "-DOP_SQLITE_USE_CRSQLITE=1"
               cppFlags += "-DOP_SQLITE_USE_CRSQLITE=1"
@@ -136,7 +144,8 @@ android {
             arguments "-DANDROID_STL=c++_shared",
               "-DSQLITE_FLAGS='$sqliteFlags'",
               "-DUSE_SQLCIPHER=${useSQLCipher ? 1 : 0}",
-              "-DUSE_CRSQLITE=${useCRSQLite ? 1 : 0}"
+              "-DUSE_CRSQLITE=${useCRSQLite ? 1 : 0}",
+              "-DUSE_LIBSQL=${useLibsql ? 1 : 0}"
             abiFilters (*reactNativeArchitectures())
         }
     }

package/android/cpp-adapter.cpp

@@ -6,6 +6,10 @@
 #include <jsi/jsi.h>
 #include <typeinfo>
 
+namespace jsi = facebook::jsi;
+namespace react = facebook::react;
+namespace jni = facebook::jni;
+
 // This file is not using raw jni but rather fbjni, do not change how the native
 // functions are registered
 // https://github.com/facebookincubator/fbjni/blob/main/docs/quickref.md

package/cpp/DBHostObject.cpp

@@ -1,8 +1,11 @@
 #include "DBHostObject.h"
 #include "PreparedStatementHostObject.h"
+#if OP_SQLITE_USE_LIBSQL
+#include "libsql/bridge.h"
+#else
 #include "bridge.h"
+#endif
 #include "macros.h"
-#include "sqlbatchexecutor.h"
 #include "utils.h"
 #include <iostream>
 
@@ -11,6 +14,7 @@ namespace opsqlite {
 namespace jsi = facebook::jsi;
 namespace react = facebook::react;
 
+#ifndef OP_SQLITE_USE_LIBSQL
 void DBHostObject::auto_register_update_hook() {
   if (update_hook_callback == nullptr && reactive_queries.size() == 0 &&
       has_update_hook_registered) {
@@ -61,18 +65,35 @@ void DBHostObject::auto_register_update_hook() {
     for (const auto &query_ptr : reactive_queries) {
 
       auto query = query_ptr.get();
-      if (query->tables.size() == 0) {
+      if (query->discriminators.size() == 0) {
         continue;
       }
 
-      if (std::find(query->tables.begin(), query->tables.end(), table_name) ==
-          query->tables.end()) {
-        continue;
+      bool shouldFire = false;
+
+      for (const auto &discriminator : query->discriminators) {
+        if (discriminator.table != table_name) {
+          continue;
+        }
+
+        // Table has matched
+
+        // If no ids are specified, then we should fire
+        if (discriminator.ids.size() == 0) {
+          shouldFire = true;
+          break;
+        } else { // If ids are specified, then we should check if the rowId
+                 // matches
+          for (const auto &discrimator_id : discriminator.ids) {
+            if (rowId == discrimator_id) {
+              shouldFire = true;
+              break;
+            }
+          }
+        }
       }
 
-      if (query->rowIds.size() > 0 &&
-          std::find(query->rowIds.begin(), query->rowIds.end(), rowId) ==
-              query->rowIds.end()) {
+      if (!shouldFire) {
         continue;
       }
 
@@ -80,8 +101,8 @@ void DBHostObject::auto_register_update_hook() {
       std::shared_ptr<std::vector<SmartHostObject>> metadata =
           std::make_shared<std::vector<SmartHostObject>>();
 
-      auto status = opsqlite_execute(dbName, query->query, &query->args,
-                                     &results, metadata);
+      auto status = opsqlite_execute_prepared_statement(db_name, query->stmt,
+                                                        &results, metadata);
 
       if (status.type == SQLiteError) {
         jsCallInvoker->invokeAsync(
@@ -114,6 +135,7 @@ void DBHostObject::auto_register_update_hook() {
   opsqlite_register_update_hook(db_name, std::move(hook));
   has_update_hook_registered = true;
 }
+#endif
 
 DBHostObject::DBHostObject(jsi::Runtime &rt, std::string &base_path,
                            std::shared_ptr<react::CallInvoker> jsCallInvoker,
@@ -127,6 +149,8 @@ DBHostObject::DBHostObject(jsi::Runtime &rt, std::string &base_path,
 #ifdef OP_SQLITE_USE_SQLCIPHER
   BridgeResult result =
       opsqlite_open(db_name, path, crsqlite_path, encryption_key);
+#elif OP_SQLITE_USE_LIBSQL
+  BridgeResult result = opsqlite_libsql_open(db_name, path);
 #else
   BridgeResult result = opsqlite_open(db_name, path, crsqlite_path);
 #endif
@@ -159,9 +183,13 @@ DBHostObject::DBHostObject(jsi::Runtime &rt, std::string &base_path,
     std::string dbName = args[0].asString(rt).utf8(rt);
     std::string databaseToAttach = args[1].asString(rt).utf8(rt);
     std::string alias = args[2].asString(rt).utf8(rt);
+#ifdef OP_SQLITE_USE_LIBSQL
+    BridgeResult result =
+        opsqlite_libsql_attach(dbName, tempDocPath, databaseToAttach, alias);
+#else
     BridgeResult result =
         opsqlite_attach(dbName, tempDocPath, databaseToAttach, alias);
-
+#endif
     if (result.type == SQLiteError) {
       throw std::runtime_error(result.message);
     }
@@ -182,7 +210,11 @@ DBHostObject::DBHostObject(jsi::Runtime &rt, std::string &base_path,
 
     std::string dbName = args[0].asString(rt).utf8(rt);
     std::string alias = args[1].asString(rt).utf8(rt);
+#ifdef OP_SQLITE_USE_LIBSQL
+    BridgeResult result = opsqlite_libsql_detach(dbName, alias);
+#else
     BridgeResult result = opsqlite_detach(dbName, alias);
+#endif
 
     if (result.type == SQLiteError) {
       throw jsi::JSError(rt, result.message.c_str());
@@ -192,7 +224,11 @@ DBHostObject::DBHostObject(jsi::Runtime &rt, std::string &base_path,
   });
 
   auto close = HOSTFN("close", 0) {
+#ifdef OP_SQLITE_USE_LIBSQL
+    BridgeResult result = opsqlite_libsql_close(db_name);
+#else
     BridgeResult result = opsqlite_close(db_name);
+#endif
 
     if (result.type == SQLiteError) {
       throw jsi::JSError(rt, result.message.c_str());
@@ -224,7 +260,11 @@ DBHostObject::DBHostObject(jsi::Runtime &rt, std::string &base_path,
       }
     }
 
+#ifdef OP_SQLITE_USE_LIBSQL
+    BridgeResult result = opsqlite_libsql_remove(db_name, path);
+#else
     BridgeResult result = opsqlite_remove(db_name, path);
+#endif
 
     if (result.type == SQLiteError) {
       throw std::runtime_error(result.message);
@@ -246,7 +286,12 @@ DBHostObject::DBHostObject(jsi::Runtime &rt, std::string &base_path,
     std::shared_ptr<std::vector<SmartHostObject>> metadata =
         std::make_shared<std::vector<SmartHostObject>>();
 
+#ifdef OP_SQLITE_USE_LIBSQL
+    auto status =
+        opsqlite_libsql_execute(db_name, query, &params, &results, metadata);
+#else
     auto status = opsqlite_execute(db_name, query, &params, &results, metadata);
+#endif
 
     if (status.type == SQLiteError) {
       throw std::runtime_error(status.message);
@@ -266,7 +311,7 @@ DBHostObject::DBHostObject(jsi::Runtime &rt, std::string &base_path,
     }
 
     auto promiseCtr = rt.global().getPropertyAsFunction(rt, "Promise");
-    auto promise = promiseCtr.callAsConstructor(rt, HOSTFN("executor", 2) {
+     auto promise = promiseCtr.callAsConstructor(rt, HOSTFN("executor", 2) {
       auto resolve = std::make_shared<jsi::Value>(rt, args[0]);
       auto reject = std::make_shared<jsi::Value>(rt, args[1]);
 
@@ -275,7 +320,12 @@ DBHostObject::DBHostObject(jsi::Runtime &rt, std::string &base_path,
         try {
           std::vector<std::vector<JSVariant>> results;
 
+#ifdef OP_SQLITE_USE_LIBSQL
+          auto status =
+              opsqlite_libsql_execute_raw(db_name, query, &params, &results);
+#else
           auto status = opsqlite_execute_raw(db_name, query, &params, &results);
+#endif
           //
           //            if (invalidated) {
           //              return;
@@ -308,13 +358,12 @@ DBHostObject::DBHostObject(jsi::Runtime &rt, std::string &base_path,
       thread_pool->queueWork(task);
 
       return {};
-    }));
+     }));
 
-    return promise;
+     return promise;
   });
 
   auto execute_async = HOSTFN("executeAsync", 2) {
-
     const std::string query = args[0].asString(rt).utf8(rt);
     std::vector<JSVariant> params;
 
@@ -334,9 +383,13 @@ DBHostObject::DBHostObject(jsi::Runtime &rt, std::string &base_path,
           std::vector<DumbHostObject> results;
           std::shared_ptr<std::vector<SmartHostObject>> metadata =
               std::make_shared<std::vector<SmartHostObject>>();
-
+#ifdef OP_SQLITE_USE_LIBSQL
+          auto status = opsqlite_libsql_execute(db_name, query, &params,
+                                                &results, metadata);
+#else
           auto status =
               opsqlite_execute(db_name, query, &params, &results, metadata);
+#endif
 
           //            if (invalidated) {
           //              return;
@@ -391,9 +444,13 @@ DBHostObject::DBHostObject(jsi::Runtime &rt, std::string &base_path,
     }
     const jsi::Array &batchParams = params.asObject(rt).asArray(rt);
     std::vector<BatchArguments> commands;
-    toBatchArguments(rt, batchParams, &commands);
+    to_batch_arguments(rt, batchParams, &commands);
 
-    auto batchResult = sqliteExecuteBatch(db_name, &commands);
+#ifdef OP_SQLITE_USE_LIBSQL
+    auto batchResult = opsqlite_libsql_execute_batch(db_name, &commands);
+#else
+    auto batchResult = opsqlite_execute_batch(db_name, &commands);
+#endif
     if (batchResult.type == SQLiteOk) {
       auto res = jsi::Object(rt);
       res.setProperty(rt, "rowsAffected", jsi::Value(batchResult.affectedRows));
@@ -422,10 +479,10 @@ DBHostObject::DBHostObject(jsi::Runtime &rt, std::string &base_path,
     const jsi::Array &batchParams = params.asObject(rt).asArray(rt);
 
     std::vector<BatchArguments> commands;
-    toBatchArguments(rt, batchParams, &commands);
+    to_batch_arguments(rt, batchParams, &commands);
 
     auto promiseCtr = rt.global().getPropertyAsFunction(rt, "Promise");
-    auto promise = promiseCtr.callAsConstructor(rt, HOSTFN("executor", 2) {
+     auto promise = promiseCtr.callAsConstructor(rt, HOSTFN("executor", 2) {
       auto resolve = std::make_shared<jsi::Value>(rt, args[0]);
       auto reject = std::make_shared<jsi::Value>(rt, args[1]);
 
@@ -434,7 +491,12 @@ DBHostObject::DBHostObject(jsi::Runtime &rt, std::string &base_path,
                        std::make_shared<std::vector<BatchArguments>>(commands),
                    resolve, reject]() {
         try {
-          auto batchResult = sqliteExecuteBatch(db_name, commands.get());
+#ifdef OP_SQLITE_USE_LIBSQL
+          auto batchResult =
+              opsqlite_libsql_execute_batch(db_name, commands.get());
+#else
+          auto batchResult = opsqlite_execute_batch(db_name, commands.get());
+#endif
           jsCallInvoker->invokeAsync([&rt, batchResult = std::move(batchResult),
                                       resolve, reject] {
             if (batchResult.type == SQLiteOk) {
@@ -457,11 +519,12 @@ DBHostObject::DBHostObject(jsi::Runtime &rt, std::string &base_path,
       thread_pool->queueWork(task);
 
       return {};
-           }));
+            }));
 
-    return promise;
+     return promise;
   });
 
+#ifndef OP_SQLITE_USE_LIBSQL
   auto load_file = HOSTFN("loadFile", 1) {
     if (sizeof(args) < 1) {
       throw std::runtime_error(
@@ -472,7 +535,8 @@ DBHostObject::DBHostObject(jsi::Runtime &rt, std::string &base_path,
     const std::string sqlFileName = args[0].asString(rt).utf8(rt);
 
     auto promiseCtr = rt.global().getPropertyAsFunction(rt, "Promise");
-    auto promise = promiseCtr.callAsConstructor(rt, HOSTFN("executor", 2) {
+        auto promise = promiseCtr.callAsConstructor(rt, HOSTFN("executor", 2)
+        {
       auto resolve = std::make_shared<jsi::Value>(rt, args[0]);
       auto reject = std::make_shared<jsi::Value>(rt, args[1]);
 
@@ -503,9 +567,9 @@ DBHostObject::DBHostObject(jsi::Runtime &rt, std::string &base_path,
       };
       thread_pool->queueWork(task);
       return {};
-           }));
+               }));
 
-    return promise;
+        return promise;
   });
 
   auto update_hook = HOSTFN("updateHook", 1) {
@@ -566,17 +630,6 @@ DBHostObject::DBHostObject(jsi::Runtime &rt, std::string &base_path,
     return {};
   });
 
-  auto prepare_statement = HOSTFN("prepareStatement", 1) {
-    auto query = args[0].asString(rt).utf8(rt);
-
-    sqlite3_stmt *statement = opsqlite_prepare_statement(db_name, query);
-
-    auto preparedStatementHostObject =
-        std::make_shared<PreparedStatementHostObject>(db_name, statement);
-
-    return jsi::Object::createFromHostObject(rt, preparedStatementHostObject);
-  });
-
   auto load_extension = HOSTFN("loadExtension", 1) {
     auto path = args[0].asString(rt).utf8(rt);
     std::string entry_point = "";
@@ -591,29 +644,6 @@ DBHostObject::DBHostObject(jsi::Runtime &rt, std::string &base_path,
     return {};
   });
 
-  auto get_db_path = HOSTFN("getDbPath", 1) {
-    std::string path = std::string(base_path);
-    if (count == 1 && !args[0].isUndefined() && !args[0].isNull()) {
-      if (!args[0].isString()) {
-        throw std::runtime_error(
-            "[op-sqlite][open] database location must be a string");
-      }
-
-      std::string lastPath = args[0].asString(rt).utf8(rt);
-
-      if (lastPath == ":memory:") {
-        path = ":memory:";
-      } else if (lastPath.rfind("/", 0) == 0) {
-        path = lastPath;
-      } else {
-        path = path + "/" + lastPath;
-      }
-    }
-
-    auto result = opsqlite_get_db_path(db_name, path);
-    return jsi::String::createFromUtf8(rt, result);
-  });
-
   auto reactive_execute = HOSTFN("reactiveExecute", 0) {
     auto query = args[0].asObject(rt);
     // if (!query.hasProperty(rt, "query") || !query.hasProperty(rt, "args")
@@ -628,23 +658,47 @@ DBHostObject::DBHostObject(jsi::Runtime &rt, std::string &base_path,
 
     const std::string query_str =
         query.getProperty(rt, "query").asString(rt).utf8(rt);
-    auto argsArray = query.getProperty(rt, "args");
-    auto tablesArray = query.getProperty(rt, "tables");
+    auto js_args = query.getProperty(rt, "args");
+    auto js_discriminators =
+        query.getProperty(rt, "fireOn").asObject(rt).asArray(rt);
+    auto variant_args = to_variant_vec(rt, js_args);
+
+    sqlite3_stmt *stmt = opsqlite_prepare_statement(db_name, query_str);
+    opsqlite_bind_statement(stmt, &variant_args);
 
     auto callback =
         std::make_shared<jsi::Value>(query.getProperty(rt, "callback"));
 
-    std::vector<JSVariant> query_args = to_variant_vec(rt, argsArray);
-    std::vector<std::string> tables = to_string_vec(rt, tablesArray);
-    std::vector<int> rowIds;
-    if (query.hasProperty(rt, "rowIds")) {
-      auto rowIdsArray = query.getProperty(rt, "rowIds");
-      rowIds = to_int_vec(rt, rowIdsArray);
+    // std::vector<JSVariant> query_args = to_variant_vec(rt, argsArray);
+    // std::vector<std::string> tables = to_string_vec(rt, tablesArray);
+    // std::vector<int> rowIds;
+    // if (query.hasProperty(rt, "rowIds")) {
+    //   auto rowIdsArray = query.getProperty(rt, "rowIds");
+    //   rowIds = to_int_vec(rt, rowIdsArray);
+    // }
+
+    std::vector<TableRowDiscriminator> discriminators;
+
+    for (size_t i = 0; i < js_discriminators.length(rt); i++) {
+      auto js_discriminator =
+          js_discriminators.getValueAtIndex(rt, i).asObject(rt);
+      std::string table =
+          js_discriminator.getProperty(rt, "table").asString(rt).utf8(rt);
+      std::vector<int> ids;
+      if (js_discriminator.hasProperty(rt, "ids")) {
+        auto js_ids =
+            js_discriminator.getProperty(rt, "ids").asObject(rt).asArray(rt);
+        for (size_t j = 0; j < js_ids.length(rt); j++) {
+          ids.push_back(
+              static_cast<int>(js_ids.getValueAtIndex(rt, j).asNumber()));
+        }
+      }
+      discriminators.push_back({table, ids});
     }
 
     std::shared_ptr<ReactiveQuery> reactiveQuery =
         std::make_shared<ReactiveQuery>(
-            ReactiveQuery{query_str, query_args, tables, rowIds, callback});
+            ReactiveQuery{stmt, discriminators, callback});
 
     reactive_queries.push_back(reactiveQuery);
 
@@ -663,6 +717,44 @@ DBHostObject::DBHostObject(jsi::Runtime &rt, std::string &base_path,
     return unsubscribe;
   });
 
+#endif
+
+  auto prepare_statement = HOSTFN("prepareStatement", 1) {
+    auto query = args[0].asString(rt).utf8(rt);
+#ifdef OP_SQLITE_USE_LIBSQL
+    libsql_stmt_t statement = opsqlite_libsql_prepare_statement(db_name, query);
+#else
+    sqlite3_stmt *statement = opsqlite_prepare_statement(db_name, query);
+#endif
+    auto preparedStatementHostObject =
+        std::make_shared<PreparedStatementHostObject>(db_name, statement);
+
+    return jsi::Object::createFromHostObject(rt, preparedStatementHostObject);
+  });
+
+  auto get_db_path = HOSTFN("getDbPath", 1) {
+    std::string path = std::string(base_path);
+    if (count == 1 && !args[0].isUndefined() && !args[0].isNull()) {
+      if (!args[0].isString()) {
+        throw std::runtime_error(
+            "[op-sqlite][open] database location must be a string");
+      }
+
+      std::string lastPath = args[0].asString(rt).utf8(rt);
+
+      if (lastPath == ":memory:") {
+        path = ":memory:";
+      } else if (lastPath.rfind("/", 0) == 0) {
+        path = lastPath;
+      } else {
+        path = path + "/" + lastPath;
+      }
+    }
+
+    auto result = opsqlite_get_db_path(db_name, path);
+    return jsi::String::createFromUtf8(rt, result);
+  });
+
   function_map["attach"] = std::move(attach);
   function_map["detach"] = std::move(detach);
   function_map["close"] = std::move(close);
@@ -672,14 +764,16 @@ DBHostObject::DBHostObject(jsi::Runtime &rt, std::string &base_path,
   function_map["delete"] = std::move(remove);
   function_map["executeBatch"] = std::move(execute_batch);
   function_map["executeBatchAsync"] = std::move(execute_batch_async);
+#ifndef OP_SQLITE_USE_LIBSQL
   function_map["loadFile"] = std::move(load_file);
   function_map["updateHook"] = std::move(update_hook);
   function_map["commitHook"] = std::move(commit_hook);
   function_map["rollbackHook"] = std::move(rollback_hook);
-  function_map["prepareStatement"] = std::move(prepare_statement);
   function_map["loadExtension"] = std::move(load_extension);
-  function_map["getDbPath"] = std::move(get_db_path);
   function_map["reactiveExecute"] = std::move(reactive_execute);
+#endif
+  function_map["prepareStatement"] = std::move(prepare_statement);
+  function_map["getDbPath"] = std::move(get_db_path);
 };
 
 std::vector<jsi::PropNameID> DBHostObject::getPropertyNames(jsi::Runtime &rt) {
@@ -719,6 +813,44 @@ jsi::Value DBHostObject::get(jsi::Runtime &rt,
   if (name == "executeBatchAsync") {
     return jsi::Value(rt, function_map["executeBatchAsync"]);
   }
+  if (name == "prepareStatement") {
+    return jsi::Value(rt, function_map["prepareStatement"]);
+  }
+  if (name == "getDbPath") {
+    return jsi::Value(rt, function_map["getDbPath"]);
+  }
+#ifdef OP_SQLITE_USE_LIBSQL
+  if (name == "loadFile") {
+    return HOSTFN("loadFile", 0) {
+      throw std::runtime_error("[op-sqlite] Load file not implemented");
+    });
+  }
+  if (name == "updateHook") {
+    return HOSTFN("updateHook", 0) {
+      throw std::runtime_error("[op-sqlite] Hooks not supported in libsql");
+    });
+  }
+  if (name == "commitHook") {
+    return HOSTFN("commitHook", 0) {
+      throw std::runtime_error("[op-sqlite] Hooks not supported in libsql");
+    });
+  }
+  if (name == "rollbackHook") {
+    return HOSTFN("rollbackHook", 0) {
+      throw std::runtime_error("[op-sqlite] Hooks not supported in libsql");
+    });
+  }
+  if (name == "loadExtension") {
+    return HOSTFN("loadExtension", 0) {
+      throw std::runtime_error("[op-sqlite] Hooks not supported in libsql");
+    });
+  }
+  if (name == "reactiveExecute") {
+    return HOSTFN("reactiveExecute", 0) {
+      throw std::runtime_error("[op-sqlite] Hooks not supported in libsql");
+    });
+  }
+#else
   if (name == "loadFile") {
     return jsi::Value(rt, function_map["loadFile"]);
   }
@@ -731,25 +863,20 @@ jsi::Value DBHostObject::get(jsi::Runtime &rt,
   if (name == "rollbackHook") {
     return jsi::Value(rt, function_map["rollbackHook"]);
   }
-  if (name == "prepareStatement") {
-    return jsi::Value(rt, function_map["prepareStatement"]);
-  }
   if (name == "loadExtension") {
     return jsi::Value(rt, function_map["loadExtension"]);
   }
-  if (name == "getDbPath") {
-    return jsi::Value(rt, function_map["getDbPath"]);
-  }
   if (name == "reactiveExecute") {
     return jsi::Value(rt, function_map["reactiveExecute"]);
   }
+#endif
 
   return {};
 }
 
-// void DBHostObject::set(jsi::Runtime &rt, const jsi::PropNameID &name,
-//                        const jsi::Value &value) {
-//   throw std::runtime_error("You cannot write to this object!");
-// }
+void DBHostObject::set(jsi::Runtime &rt, const jsi::PropNameID &name,
+                       const jsi::Value &value) {
+  throw std::runtime_error("You cannot write to this object!");
+}
 
 } // namespace opsqlite