@op-engineering/op-sqlite 7.3.0 → 8.0.0-beta0

package/README.md

@@ -1,13 +1,21 @@
 ![benchmark](benchmark.png)
 
-**Current SQLite version: 3.45.1**
-
 Created by [@ospfranco](https://twitter.com/ospfranco). **Please consider sponsoring!**.
 
-# Docs
+OP-SQLite has grown large to cover a lot of plugins, sqlite versions and APIs. Please read the full documentation before opening an issue.
 
 [See the docs](https://ospfranco.notion.site/OP-SQLite-Documentation-a279a52102464d0cb13c3fa230d2f2dc?pvs=4)
 
+Some of the big and external (back-ends, out-of-tree features, plugins) supported features:
+
+- Vanilla sqlite ofc
+- Libsql is supported as a sqlite backend
+- SQLCipher is supported as a sqlite backend
+- FTS5 plugin
+- cr-sqlite plugin
+- sqlite-vec plugin
+- Reactive queries (currently with some issues, please donate)
+
 # License
 
 MIT License.

package/android/CMakeLists.txt

@@ -55,6 +55,12 @@ if (USE_CRSQLITE)
   )
 endif()
 
+if (USE_SQLITE_VEC)
+  add_definitions(
+    -DOP_SQLITE_USE_SQLITE_VEC=1
+  )
+endif()
+
 set_target_properties(
   ${PACKAGE_NAME} PROPERTIES
   CXX_STANDARD 20

package/android/build.gradle

@@ -33,6 +33,7 @@ def useCRSQLite = false
 def performanceMode = "0"
 def sqliteFlags = ""
 def enableFTS5 = false
+def useSqliteVec = false
 
 def packageJsonFile = new File("$rootDir/../package.json")
 def packageJson = new JsonSlurper().parseText(packageJsonFile.text)
@@ -41,6 +42,7 @@ def opsqliteConfig = packageJson["op-sqlite"]
 if(opsqliteConfig) {
   useSQLCipher = opsqliteConfig["sqlcipher"]
   useCRSQLite = opsqliteConfig["crsqlite"]
+  useSqliteVec = opsqliteConfig["sqliteVec"]
   performanceMode = opsqliteConfig["performanceMode"] ? opsqliteConfig["performanceMode"] : ""
   sqliteFlags = opsqliteConfig["sqliteFlags"] ? opsqliteConfig["sqliteFlags"] : ""
   enableFTS5 = opsqliteConfig["fts5"]
@@ -71,6 +73,10 @@ if(enableFTS5) {
   println "[OP-SQLITE] FTS5 enabled! 🔎"
 }
 
+if(useSqliteVec) {
+    println "[OP-SQLITE] Sqlite Vec enabled! ↗️"
+}
+
 if (isNewArchitectureEnabled()) {
     apply plugin: "com.facebook.react"
 }
@@ -138,6 +144,10 @@ android {
             if(enableFTS5) {
               cFlags += ["-DSQLITE_ENABLE_FTS4=1", "-DSQLITE_ENABLE_FTS3_PARENTHESIS=1", "-DSQLITE_ENABLE_FTS5=1"]
             }
+            if(useSqliteVec) {
+              cFlags += "-DOP_SQLITE_USE_SQLITE_VEC=1"
+              cppFlags += "-DOP_SQLITE_USE_SQLITE_VEC=1"
+            }
 
             cppFlags "-O2", "-fexceptions", "-frtti", "-std=c++1y", "-DONANDROID"
             abiFilters 'x86', 'x86_64', 'armeabi-v7a', 'arm64-v8a'
@@ -145,7 +155,8 @@ android {
               "-DSQLITE_FLAGS='$sqliteFlags'",
               "-DUSE_SQLCIPHER=${useSQLCipher ? 1 : 0}",
               "-DUSE_CRSQLITE=${useCRSQLite ? 1 : 0}",
-              "-DUSE_LIBSQL=${useLibsql ? 1 : 0}"
+              "-DUSE_LIBSQL=${useLibsql ? 1 : 0}",
+              "-DUSE_SQLITE_VEC=${useSqliteVec ? 1 : 0}"
             abiFilters (*reactNativeArchitectures())
         }
     }
@@ -214,4 +225,12 @@ tasks.whenTaskAdded { task ->
       task.dependsOn(it)
     }
   }
+}
+
+if (isNewArchitectureEnabled()) {
+  react {
+    jsRootDir = file("../src/")
+    libraryName = "opsqlite"
+    codegenJavaPackageName = "com.op.sqlite.example"
+  }
 }

package/android/cpp-adapter.cpp

@@ -33,7 +33,7 @@ private:
     std::string dbPathStr = dbPath->toStdString();
 
     opsqlite::install(*jsiRuntime, jsCallInvoker, dbPathStr.c_str(),
-                      "libcrsqlite");
+                      "libcrsqlite", "libsqlite_vec");
   }
 
   static void clearStateNativeJsi(jni::alias_ref<jni::JObject> thiz) {

package/cpp/DBHostObject.cpp

@@ -39,7 +39,7 @@ void DBHostObject::auto_register_update_hook() {
       if (operation != "DELETE") {
         std::string query = "SELECT * FROM " + table_name +
                             " where rowid = " + std::to_string(rowId) + ";";
-        opsqlite_execute(name, query, &params, &results, metadata);
+        opsqlite_execute_host_objects(name, query, &params, &results, metadata);
       }
 
       jsCallInvoker->invokeAsync(
@@ -57,7 +57,7 @@ void DBHostObject::auto_register_update_hook() {
               res.setProperty(
                   rt, "row",
                   jsi::Object::createFromHostObject(
-                      rt, std::make_shared<DumbHostObject>(results->at(0))));
+                      rt, std::make_shared<HostObject>(results->at(0))));
             }
 
             callback->asObject(rt).asFunction(rt).call(rt, res);
@@ -171,17 +171,19 @@ DBHostObject::DBHostObject(jsi::Runtime &rt, std::string &base_path,
                            std::shared_ptr<ThreadPool> thread_pool,
                            std::string &db_name, std::string &path,
                            std::string &crsqlite_path,
+                           std::string &sqlite_vec_path,
                            std::string &encryption_key)
     : base_path(base_path), jsCallInvoker(jsCallInvoker),
       thread_pool(thread_pool), db_name(db_name), rt(rt) {
 
 #ifdef OP_SQLITE_USE_SQLCIPHER
-  BridgeResult result =
-      opsqlite_open(db_name, path, crsqlite_path, encryption_key);
+  BridgeResult result = opsqlite_open(db_name, path, crsqlite_path,
+                                      sqlite_vec_path, encryption_key);
 #elif OP_SQLITE_USE_LIBSQL
   BridgeResult result = opsqlite_libsql_open(db_name, path, crsqlite_path);
 #else
-  BridgeResult result = opsqlite_open(db_name, path, crsqlite_path);
+  BridgeResult result =
+      opsqlite_open(db_name, path, crsqlite_path, sqlite_vec_path);
 #endif
 
   if (result.type == SQLiteError) {
@@ -192,7 +194,7 @@ DBHostObject::DBHostObject(jsi::Runtime &rt, std::string &base_path,
 };
 
 void DBHostObject::create_jsi_functions() {
-  auto attach = HOSTFN("attach", 4) {
+  auto attach = HOSTFN("attach") {
     if (count < 3) {
       throw jsi::JSError(rt,
                          "[op-sqlite][attach] Incorrect number of arguments");
@@ -230,7 +232,7 @@ void DBHostObject::create_jsi_functions() {
     return {};
   });
 
-  auto detach = HOSTFN("detach", 2) {
+  auto detach = HOSTFN("detach") {
     if (count < 2) {
       throw std::runtime_error(
           "[op-sqlite][detach] Incorrect number of arguments");
@@ -256,7 +258,7 @@ void DBHostObject::create_jsi_functions() {
     return {};
   });
 
-  auto close = HOSTFN("close", 0) {
+  auto close = HOSTFN("close") {
 #ifdef OP_SQLITE_USE_LIBSQL
     BridgeResult result = opsqlite_libsql_close(db_name);
 #else
@@ -270,8 +272,7 @@ void DBHostObject::create_jsi_functions() {
     return {};
   });
 
-  auto remove = HOSTFN("delete", 1) {
-
+  auto remove = HOSTFN("delete") {
     std::string path = std::string(base_path);
 
     if (count == 1 && !args[0].isUndefined() && !args[0].isNull()) {
@@ -306,7 +307,7 @@ void DBHostObject::create_jsi_functions() {
     return {};
   });
 
-  auto execute = HOSTFN("execute", 2) {
+  auto execute_raw = HOSTFN("executeRaw") {
     const std::string query = args[0].asString(rt).utf8(rt);
     std::vector<JSVariant> params;
 
@@ -315,59 +316,86 @@ void DBHostObject::create_jsi_functions() {
       params = to_variant_vec(rt, originalParams);
     }
 
-    std::vector<DumbHostObject> results;
-    std::shared_ptr<std::vector<SmartHostObject>> metadata =
-        std::make_shared<std::vector<SmartHostObject>>();
+    auto promiseCtr = rt.global().getPropertyAsFunction(rt, "Promise");
+    auto promise = promiseCtr.callAsConstructor(rt, HOSTFN("executor") {
+      auto resolve = std::make_shared<jsi::Value>(rt, args[0]);
+      auto reject = std::make_shared<jsi::Value>(rt, args[1]);
+
+      auto task = [&rt, this, query, params = std::move(params), resolve,
+                   reject, invoker = this->jsCallInvoker]() {
+        try {
+          std::vector<std::vector<JSVariant>> results;
 
 #ifdef OP_SQLITE_USE_LIBSQL
-    auto status =
-        opsqlite_libsql_execute(db_name, query, &params, &results, metadata);
+          auto status =
+              opsqlite_libsql_execute_raw(db_name, query, &params, &results);
 #else
-    auto status = opsqlite_execute(db_name, query, &params, &results, metadata);
+          auto status = opsqlite_execute_raw(db_name, query, &params, &results);
 #endif
 
-    if (status.type == SQLiteError) {
-      throw std::runtime_error(status.message);
-    }
+          invoker->invokeAsync([&rt, results = std::move(results),
+                                status = std::move(status), resolve, reject] {
+            if (status.type == SQLiteOk) {
+              auto jsiResult = create_raw_result(rt, status, &results);
+              resolve->asObject(rt).asFunction(rt).call(rt,
+                                                        std::move(jsiResult));
+            } else {
+              auto errorCtr = rt.global().getPropertyAsFunction(rt, "Error");
+              auto error = errorCtr.callAsConstructor(
+                  rt, jsi::String::createFromUtf8(rt, status.message));
+              reject->asObject(rt).asFunction(rt).call(rt, error);
+            }
+          });
+
+        } catch (std::exception &exc) {
+          invoker->invokeAsync([&rt, exc = std::move(exc), reject] {
+            auto errorCtr = rt.global().getPropertyAsFunction(rt, "Error");
+            auto error = errorCtr.callAsConstructor(
+                rt, jsi::String::createFromAscii(rt, exc.what()));
+            reject->asObject(rt).asFunction(rt).call(rt, error);
+          });
+        }
+      };
+
+      thread_pool->queueWork(task);
+
+      return {};
+     }));
 
-    auto jsiResult = createResult(rt, status, &results, metadata);
-    return jsiResult;
+    return promise;
   });
 
-  auto execute_raw_async = HOSTFN("executeRawAsync", 2) {
+  auto execute = HOSTFN("execute") {
     const std::string query = args[0].asString(rt).utf8(rt);
     std::vector<JSVariant> params;
 
     if (count == 2) {
-      const jsi::Value &originalParams = args[1];
-      params = to_variant_vec(rt, originalParams);
+      params = to_variant_vec(rt, args[1]);
     }
 
     auto promiseCtr = rt.global().getPropertyAsFunction(rt, "Promise");
-    auto promise = promiseCtr.callAsConstructor(rt, HOSTFN("executor", 2) {
+        auto promise = promiseCtr.callAsConstructor(rt, HOSTFN("executor") {
       auto resolve = std::make_shared<jsi::Value>(rt, args[0]);
       auto reject = std::make_shared<jsi::Value>(rt, args[1]);
 
       auto task = [&rt, this, query, params = std::move(params), resolve,
                    reject, invoker = this->jsCallInvoker]() {
         try {
-          std::vector<std::vector<JSVariant>> results;
 
 #ifdef OP_SQLITE_USE_LIBSQL
-          auto status =
-              opsqlite_libsql_execute_raw(db_name, query, &params, &results);
+          auto status = opsqlite_libsql_execute(db_name, query, &params);
 #else
-          auto status = opsqlite_execute_raw(db_name, query, &params, &results);
+          auto status = opsqlite_execute(db_name, query, &params);
 #endif
-          //
+
           //            if (invalidated) {
           //              return;
           //            }
 
-          invoker->invokeAsync([&rt, results = std::move(results),
-                                status = std::move(status), resolve, reject] {
+          invoker->invokeAsync([&rt, status = std::move(status), resolve,
+                                reject] {
             if (status.type == SQLiteOk) {
-              auto jsiResult = create_raw_result(rt, status, &results);
+              auto jsiResult = create_js_rows(rt, status);
               resolve->asObject(rt).asFunction(rt).call(rt,
                                                         std::move(jsiResult));
             } else {
@@ -379,8 +407,11 @@ void DBHostObject::create_jsi_functions() {
           });
 
         } catch (std::exception &exc) {
+          std::cout << "Exception executing function" << exc.what()
+                    << std::endl;
           invoker->invokeAsync([&rt, exc = std::move(exc), reject] {
             auto errorCtr = rt.global().getPropertyAsFunction(rt, "Error");
+            auto what = exc.what();
             auto error = errorCtr.callAsConstructor(
                 rt, jsi::String::createFromAscii(rt, exc.what()));
             reject->asObject(rt).asFunction(rt).call(rt, error);
@@ -391,12 +422,12 @@ void DBHostObject::create_jsi_functions() {
       thread_pool->queueWork(task);
 
       return {};
-     }));
+        }));
 
-    return promise;
+        return promise;
   });
 
-  auto execute_async = HOSTFN("executeAsync", 2) {
+  auto execute_with_host_objects = HOSTFN("executeWithHostObjects") {
     const std::string query = args[0].asString(rt).utf8(rt);
     std::vector<JSVariant> params;
 
@@ -406,7 +437,7 @@ void DBHostObject::create_jsi_functions() {
     }
 
     auto promiseCtr = rt.global().getPropertyAsFunction(rt, "Promise");
-    auto promise = promiseCtr.callAsConstructor(rt, HOSTFN("executor", 2) {
+    auto promise = promiseCtr.callAsConstructor(rt, HOSTFN("executor") {
       auto resolve = std::make_shared<jsi::Value>(rt, args[0]);
       auto reject = std::make_shared<jsi::Value>(rt, args[1]);
 
@@ -417,11 +448,11 @@ void DBHostObject::create_jsi_functions() {
           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);
+          auto status = opsqlite_libsql_execute_with_host_objects(
+              db_name, query, &params, &results, metadata);
 #else
-          auto status =
-              opsqlite_execute(db_name, query, &params, &results, metadata);
+          auto status = opsqlite_execute_host_objects(db_name, query, &params,
+                                                      &results, metadata);
 #endif
 
           //            if (invalidated) {
@@ -464,36 +495,7 @@ void DBHostObject::create_jsi_functions() {
     return promise;
   });
 
-  auto execute_batch = HOSTFN("executeBatch", 1) {
-    if (sizeof(args) < 1) {
-      throw std::runtime_error(
-          "[op-sqlite][executeBatch] - Incorrect parameter count");
-    }
-
-    const jsi::Value &params = args[0];
-    if (params.isNull() || params.isUndefined()) {
-      throw std::runtime_error("[op-sqlite][executeBatch] - An array of SQL "
-                               "commands or parameters is needed");
-    }
-    const jsi::Array &batchParams = params.asObject(rt).asArray(rt);
-    std::vector<BatchArguments> commands;
-    to_batch_arguments(rt, batchParams, &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));
-      return std::move(res);
-    } else {
-      throw std::runtime_error(batchResult.message);
-    }
-  });
-
-  auto execute_batch_async = HOSTFN("executeBatchAsync", 1) {
+  auto execute_batch = HOSTFN("executeBatch") {
     if (sizeof(args) < 1) {
       throw std::runtime_error(
           "[op-sqlite][executeAsyncBatch] Incorrect parameter count");
@@ -515,7 +517,7 @@ void DBHostObject::create_jsi_functions() {
     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") {
       auto resolve = std::make_shared<jsi::Value>(rt, args[0]);
       auto reject = std::make_shared<jsi::Value>(rt, args[1]);
 
@@ -558,17 +560,15 @@ void DBHostObject::create_jsi_functions() {
   });
 
 #ifdef OP_SQLITE_USE_LIBSQL
-  auto sync = HOSTFN("sync", 0) {
+  auto sync = HOSTFN("sync") {
     BridgeResult result = opsqlite_libsql_sync(db_name);
     if (result.type == SQLiteError) {
       throw std::runtime_error(result.message);
     }
     return {};
   });
-#endif
-
-#ifndef OP_SQLITE_USE_LIBSQL
-  auto load_file = HOSTFN("loadFile", 1) {
+#else
+  auto load_file = HOSTFN("loadFile") {
     if (sizeof(args) < 1) {
       throw std::runtime_error(
           "[op-sqlite][loadFile] Incorrect parameter count");
@@ -578,17 +578,17 @@ void DBHostObject::create_jsi_functions() {
     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")
         {
       auto resolve = std::make_shared<jsi::Value>(rt, args[0]);
       auto reject = std::make_shared<jsi::Value>(rt, args[1]);
 
       auto task = [&rt, this, sqlFileName, resolve, reject]() {
         try {
-          const auto importResult = importSQLFile(db_name, sqlFileName);
+          const auto result = importSQLFile(db_name, sqlFileName);
 
-          jsCallInvoker->invokeAsync([&rt, result = std::move(importResult),
-                                      resolve, reject] {
+          jsCallInvoker->invokeAsync([&rt, result = std::move(result), resolve,
+                                      reject] {
             if (result.type == SQLiteOk) {
               auto res = jsi::Object(rt);
               res.setProperty(rt, "rowsAffected",
@@ -614,7 +614,7 @@ void DBHostObject::create_jsi_functions() {
         return promise;
   });
 
-  auto update_hook = HOSTFN("updateHook", 1) {
+  auto update_hook = HOSTFN("updateHook") {
     auto callback = std::make_shared<jsi::Value>(rt, args[0]);
 
     if (callback->isUndefined() || callback->isNull()) {
@@ -626,7 +626,7 @@ void DBHostObject::create_jsi_functions() {
     return {};
   });
 
-  auto commit_hook = HOSTFN("commitHook", 1) {
+  auto commit_hook = HOSTFN("commitHook") {
     if (sizeof(args) < 1) {
       throw std::runtime_error("[op-sqlite][commitHook] callback needed");
       return {};
@@ -649,7 +649,7 @@ void DBHostObject::create_jsi_functions() {
     return {};
   });
 
-  auto rollback_hook = HOSTFN("rollbackHook", 1) {
+  auto rollback_hook = HOSTFN("rollbackHook") {
     if (sizeof(args) < 1) {
       throw std::runtime_error("[op-sqlite][rollbackHook] callback needed");
       return {};
@@ -672,7 +672,7 @@ void DBHostObject::create_jsi_functions() {
     return {};
   });
 
-  auto load_extension = HOSTFN("loadExtension", 1) {
+  auto load_extension = HOSTFN("loadExtension") {
     auto path = args[0].asString(rt).utf8(rt);
     std::string entry_point = "";
     if (count > 1 && args[1].isString()) {
@@ -686,7 +686,7 @@ void DBHostObject::create_jsi_functions() {
     return {};
   });
 
-  auto reactive_execute = HOSTFN("reactiveExecute", 0) {
+  auto reactive_execute = HOSTFN("reactiveExecute") {
     auto query = args[0].asObject(rt);
     // if (!query.hasProperty(rt, "query") || !query.hasProperty(rt, "args")
     // ||
@@ -746,7 +746,7 @@ void DBHostObject::create_jsi_functions() {
 
     auto_register_update_hook();
 
-    auto unsubscribe = HOSTFN("unsubscribe", 0) {
+    auto unsubscribe = HOSTFN("unsubscribe") {
       auto it = std::find(reactive_queries.begin(), reactive_queries.end(),
                           reactiveQuery);
       if (it != reactive_queries.end()) {
@@ -761,7 +761,7 @@ void DBHostObject::create_jsi_functions() {
 
 #endif
 
-  auto prepare_statement = HOSTFN("prepareStatement", 1) {
+  auto prepare_statement = HOSTFN("prepareStatement") {
     auto query = args[0].asString(rt).utf8(rt);
 #ifdef OP_SQLITE_USE_LIBSQL
     libsql_stmt_t statement = opsqlite_libsql_prepare_statement(db_name, query);
@@ -769,12 +769,13 @@ void DBHostObject::create_jsi_functions() {
     sqlite3_stmt *statement = opsqlite_prepare_statement(db_name, query);
 #endif
     auto preparedStatementHostObject =
-        std::make_shared<PreparedStatementHostObject>(db_name, statement);
+        std::make_shared<PreparedStatementHostObject>(
+            db_name, statement, jsCallInvoker, thread_pool);
 
     return jsi::Object::createFromHostObject(rt, preparedStatementHostObject);
   });
 
-  auto get_db_path = HOSTFN("getDbPath", 1) {
+  auto get_db_path = HOSTFN("getDbPath") {
     std::string path = std::string(base_path);
     if (count == 1 && !args[0].isUndefined() && !args[0].isNull()) {
       if (!args[0].isString()) {
@@ -800,12 +801,11 @@ void DBHostObject::create_jsi_functions() {
   function_map["attach"] = std::move(attach);
   function_map["detach"] = std::move(detach);
   function_map["close"] = std::move(close);
-  function_map["executeRawAsync"] = std::move(execute_raw_async);
   function_map["execute"] = std::move(execute);
-  function_map["executeAsync"] = std::move(execute_async);
+  function_map["executeRaw"] = std::move(execute_raw);
+  function_map["executeWithHostObjects"] = std::move(execute_with_host_objects);
   function_map["delete"] = std::move(remove);
   function_map["executeBatch"] = std::move(execute_batch);
-  function_map["executeBatchAsync"] = std::move(execute_batch_async);
   function_map["prepareStatement"] = std::move(prepare_statement);
   function_map["getDbPath"] = std::move(get_db_path);
 #ifdef OP_SQLITE_USE_LIBSQL
@@ -839,14 +839,14 @@ jsi::Value DBHostObject::get(jsi::Runtime &rt,
   if (name == "close") {
     return jsi::Value(rt, function_map["close"]);
   }
-  if (name == "executeRawAsync") {
-    return jsi::Value(rt, function_map["executeRawAsync"]);
+  if (name == "executeRaw") {
+    return jsi::Value(rt, function_map["executeRaw"]);
   }
   if (name == "execute") {
     return jsi::Value(rt, function_map["execute"]);
   }
-  if (name == "executeAsync") {
-    return jsi::Value(rt, function_map["executeAsync"]);
+  if (name == "executeWithHostObjects") {
+    return jsi::Value(rt, function_map["executeWithHostObjects"]);
   }
   if (name == "delete") {
     return jsi::Value(rt, function_map["delete"]);
@@ -854,9 +854,6 @@ jsi::Value DBHostObject::get(jsi::Runtime &rt,
   if (name == "executeBatch") {
     return jsi::Value(rt, function_map["executeBatch"]);
   }
-  if (name == "executeBatchAsync") {
-    return jsi::Value(rt, function_map["executeBatchAsync"]);
-  }
   if (name == "prepareStatement") {
     return jsi::Value(rt, function_map["prepareStatement"]);
   }
@@ -868,32 +865,32 @@ jsi::Value DBHostObject::get(jsi::Runtime &rt,
   }
 #ifdef OP_SQLITE_USE_LIBSQL
   if (name == "loadFile") {
-    return HOSTFN("loadFile", 0) {
+    return HOSTFN("loadFile") {
       throw std::runtime_error("[op-sqlite] Load file not implemented");
     });
   }
   if (name == "updateHook") {
-    return HOSTFN("updateHook", 0) {
+    return HOSTFN("updateHook") {
       throw std::runtime_error("[op-sqlite] Hooks not supported in libsql");
     });
   }
   if (name == "commitHook") {
-    return HOSTFN("commitHook", 0) {
+    return HOSTFN("commitHook") {
       throw std::runtime_error("[op-sqlite] Hooks not supported in libsql");
     });
   }
   if (name == "rollbackHook") {
-    return HOSTFN("rollbackHook", 0) {
+    return HOSTFN("rollbackHook") {
       throw std::runtime_error("[op-sqlite] Hooks not supported in libsql");
     });
   }
   if (name == "loadExtension") {
-    return HOSTFN("loadExtension", 0) {
+    return HOSTFN("loadExtension") {
       throw std::runtime_error("[op-sqlite] Hooks not supported in libsql");
     });
   }
   if (name == "reactiveExecute") {
-    return HOSTFN("reactiveExecute", 0) {
+    return HOSTFN("reactiveExecute") {
       throw std::runtime_error("[op-sqlite] Hooks not supported in libsql");
     });
   }

package/cpp/DBHostObject.h

@@ -32,7 +32,7 @@ public:
                std::shared_ptr<react::CallInvoker> js_call_invoker,
                std::shared_ptr<ThreadPool> thread_pool, std::string &db_name,
                std::string &path, std::string &crsqlite_path,
-               std::string &encryption_key);
+               std::string &sqlite_vec_path, std::string &encryption_key);
 
 #ifdef OP_SQLITE_USE_LIBSQL
   // Constructor for remoteOpen, purely for remote databases