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

package/cpp/bridge.cpp

@@ -51,12 +51,14 @@ std::string opsqlite_get_db_path(std::string const &db_name,
 #ifdef OP_SQLITE_USE_SQLCIPHER
 BridgeResult opsqlite_open(std::string const &dbName,
                            std::string const &last_path,
-                           std::string const &crsqlitePath,
+                           std::string const &crsqlite_path,
+                           std::string const &sqlite_vec_path,
                            std::string const &encryptionKey) {
 #else
 BridgeResult opsqlite_open(std::string const &dbName,
                            std::string const &last_path,
-                           std::string const &crsqlitePath) {
+                           std::string const &crsqlite_path,
+                           std::string const &sqlite_vec_path) {
 #endif
   std::string dbPath = opsqlite_get_db_path(dbName, last_path);
 
@@ -74,17 +76,18 @@ BridgeResult opsqlite_open(std::string const &dbName,
   dbMap[dbName] = db;
 
 #ifdef OP_SQLITE_USE_SQLCIPHER
-  opsqlite_execute(dbName, "PRAGMA key = '" + encryptionKey + "'", nullptr,
-                   nullptr, nullptr);
+  opsqlite_execute(dbName, "PRAGMA key = '" + encryptionKey + "'", nullptr);
 #endif
 
-#ifdef OP_SQLITE_USE_CRSQLITE
+  sqlite3_enable_load_extension(db, 1);
+
   char *errMsg;
-  const char *crsqliteEntryPoint = "sqlite3_crsqlite_init";
 
-  sqlite3_enable_load_extension(db, 1);
+#ifdef OP_SQLITE_USE_CRSQLITE
+  const char *crsqliteEntryPoint = "sqlite3_crsqlite_init";
 
-  sqlite3_load_extension(db, crsqlitePath.c_str(), crsqliteEntryPoint, &errMsg);
+  sqlite3_load_extension(db, crsqlite_path.c_str(), crsqliteEntryPoint,
+                         &errMsg);
 
   if (errMsg != nullptr) {
     return {.type = SQLiteError, .message = errMsg};
@@ -93,6 +96,19 @@ BridgeResult opsqlite_open(std::string const &dbName,
   }
 #endif
 
+#ifdef OP_SQLITE_USE_SQLITE_VEC
+  const char *vec_entry_point = "sqlite3_vec_init";
+
+  sqlite3_load_extension(db, sqlite_vec_path.c_str(), vec_entry_point, &errMsg);
+
+  if (errMsg != nullptr) {
+    return {.type = SQLiteError, .message = errMsg};
+  } else {
+    LOGI("Loaded sqlite-vec successfully");
+  }
+
+#endif
+
   return {.type = SQLiteOk, .affectedRows = 0};
 }
 
@@ -103,8 +119,7 @@ BridgeResult opsqlite_close(std::string const &dbName) {
   sqlite3 *db = dbMap[dbName];
 
 #ifdef OP_SQLITE_USE_CRSQLITE
-  opsqlite_execute(dbName, "select crsql_finalize();", nullptr, nullptr,
-                   nullptr);
+  opsqlite_execute(dbName, "select crsql_finalize();", nullptr);
 #endif
 
   sqlite3_close_v2(db);
@@ -123,8 +138,7 @@ BridgeResult opsqlite_attach(std::string const &mainDBName,
   std::string dbPath = opsqlite_get_db_path(databaseToAttach, docPath);
   std::string statement = "ATTACH DATABASE '" + dbPath + "' AS " + alias;
 
-  BridgeResult result =
-      opsqlite_execute(mainDBName, statement, nullptr, nullptr, nullptr);
+  BridgeResult result = opsqlite_execute(mainDBName, statement, nullptr);
 
   if (result.type == SQLiteError) {
     return {
@@ -141,8 +155,7 @@ BridgeResult opsqlite_attach(std::string const &mainDBName,
 BridgeResult opsqlite_detach(std::string const &mainDBName,
                              std::string const &alias) {
   std::string statement = "DETACH DATABASE " + alias;
-  BridgeResult result =
-      opsqlite_execute(mainDBName, statement, nullptr, nullptr, nullptr);
+  BridgeResult result = opsqlite_execute(mainDBName, statement, nullptr);
   if (result.type == SQLiteError) {
     return BridgeResult{
         .type = SQLiteError,
@@ -189,22 +202,22 @@ inline void opsqlite_bind_statement(sqlite3_stmt *statement,
     int sqIndex = ii + 1;
     JSVariant value = values->at(ii);
 
-    if (std::holds_alternative<bool>(value)) {
-      sqlite3_bind_int(statement, sqIndex, std::get<bool>(value));
-    } else if (std::holds_alternative<int>(value)) {
+    if (std::holds_alternative<bool>(value) ||
+        std::holds_alternative<int>(value)) {
       sqlite3_bind_int(statement, sqIndex, std::get<int>(value));
     } else if (std::holds_alternative<long long>(value)) {
-      sqlite3_bind_double(statement, sqIndex, std::get<long long>(value));
+      sqlite3_bind_double(statement, sqIndex,
+                          static_cast<double>(std::get<long long>(value)));
     } else if (std::holds_alternative<double>(value)) {
       sqlite3_bind_double(statement, sqIndex, std::get<double>(value));
     } else if (std::holds_alternative<std::string>(value)) {
       std::string str = std::get<std::string>(value);
-      sqlite3_bind_text(statement, sqIndex, str.c_str(), str.length(),
-                        SQLITE_TRANSIENT);
+      sqlite3_bind_text(statement, sqIndex, str.c_str(),
+                        static_cast<int>(str.length()), SQLITE_TRANSIENT);
     } else if (std::holds_alternative<ArrayBuffer>(value)) {
       ArrayBuffer buffer = std::get<ArrayBuffer>(value);
-      sqlite3_bind_blob(statement, sqIndex, buffer.data.get(), buffer.size,
-                        SQLITE_TRANSIENT);
+      sqlite3_bind_blob(statement, sqIndex, buffer.data.get(),
+                        static_cast<int>(buffer.size), SQLITE_TRANSIENT);
     } else {
       sqlite3_bind_null(statement, sqIndex);
     }
@@ -214,7 +227,7 @@ inline void opsqlite_bind_statement(sqlite3_stmt *statement,
 BridgeResult opsqlite_execute_prepared_statement(
     std::string const &dbName, sqlite3_stmt *statement,
     std::vector<DumbHostObject> *results,
-    std::shared_ptr<std::vector<SmartHostObject>> metadatas) {
+    std::shared_ptr<std::vector<SmartHostObject>> &metadatas) {
 
   check_db_open(dbName);
 
@@ -227,8 +240,6 @@ BridgeResult opsqlite_execute_prepared_statement(
 
   int result = SQLITE_OK;
 
-  isConsuming = true;
-
   int i, count, column_type;
   std::string column_name, column_declared_type;
 
@@ -237,7 +248,7 @@ BridgeResult opsqlite_execute_prepared_statement(
 
     switch (result) {
     case SQLITE_ROW: {
-      if (results == NULL) {
+      if (results == nullptr) {
         break;
       }
 
@@ -256,13 +267,13 @@ BridgeResult opsqlite_execute_prepared_statement(
            * only represent Integers up to 53 bits
            */
           double column_value = sqlite3_column_double(statement, i);
-          row.values.push_back(JSVariant(column_value));
+          row.values.emplace_back(column_value);
           break;
         }
 
         case SQLITE_FLOAT: {
           double column_value = sqlite3_column_double(statement, i);
-          row.values.push_back(JSVariant(column_value));
+          row.values.emplace_back(column_value);
           break;
         }
 
@@ -271,20 +282,20 @@ BridgeResult opsqlite_execute_prepared_statement(
               reinterpret_cast<const char *>(sqlite3_column_text(statement, i));
           int byteLen = sqlite3_column_bytes(statement, i);
           // Specify length too; in case string contains NULL in the middle
-          row.values.push_back(JSVariant(std::string(column_value, byteLen)));
+          row.values.emplace_back(std::string(column_value, byteLen));
           break;
         }
 
         case SQLITE_BLOB: {
           int blob_size = sqlite3_column_bytes(statement, i);
           const void *blob = sqlite3_column_blob(statement, i);
-          uint8_t *data = new uint8_t[blob_size];
+          auto *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.values.push_back(
-              JSVariant(ArrayBuffer{.data = std::shared_ptr<uint8_t>{data},
-                                    .size = static_cast<size_t>(blob_size)}));
+          row.values.emplace_back(
+              ArrayBuffer{.data = std::shared_ptr<uint8_t>{data},
+                          .size = static_cast<size_t>(blob_size)});
           break;
         }
 
@@ -292,14 +303,16 @@ BridgeResult opsqlite_execute_prepared_statement(
           // Intentionally left blank
 
         default:
-          row.values.push_back(JSVariant(nullptr));
+          row.values.emplace_back(nullptr);
           break;
         }
         i++;
       }
+
       if (results != nullptr) {
         results->push_back(row);
       }
+
       break;
     }
 
@@ -312,10 +325,10 @@ BridgeResult opsqlite_execute_prepared_statement(
           column_name = sqlite3_column_name(statement, i);
           const char *type = sqlite3_column_decltype(statement, i);
           auto metadata = SmartHostObject();
-          metadata.fields.push_back(std::make_pair("name", column_name));
-          metadata.fields.push_back(std::make_pair("index", i));
-          metadata.fields.push_back(
-              std::make_pair("type", type == NULL ? "UNKNOWN" : type));
+          metadata.fields.emplace_back("name", column_name);
+          metadata.fields.emplace_back("index", i);
+          metadata.fields.emplace_back("type",
+                                       type == nullptr ? "UNKNOWN" : type);
 
           metadatas->push_back(metadata);
           i++;
@@ -357,7 +370,8 @@ sqlite3_stmt *opsqlite_prepare_statement(std::string const &dbName,
 
   const char *queryStr = query.c_str();
 
-  int statementStatus = sqlite3_prepare_v2(db, queryStr, -1, &statement, NULL);
+  int statementStatus =
+      sqlite3_prepare_v2(db, queryStr, -1, &statement, nullptr);
 
   if (statementStatus == SQLITE_ERROR) {
     const char *message = sqlite3_errmsg(db);
@@ -368,12 +382,144 @@ sqlite3_stmt *opsqlite_prepare_statement(std::string const &dbName,
   return statement;
 }
 
+BridgeResult opsqlite_execute(std::string const &name, std::string const &query,
+                              const std::vector<JSVariant> *params) {
+  check_db_open(name);
+
+  sqlite3 *db = dbMap[name];
+
+  sqlite3_stmt *statement;
+  const char *errorMessage;
+  const char *remainingStatement = nullptr;
+
+  bool isFailed = false;
+  int step_result, current_column, column_count, column_type;
+  std::string column_name, column_declared_type;
+  std::vector<std::string> column_names;
+  std::vector<std::vector<JSVariant>> rows;
+  std::vector<JSVariant> row;
+
+  do {
+    const char *queryStr =
+        remainingStatement == nullptr ? query.c_str() : remainingStatement;
+
+    int statementStatus =
+        sqlite3_prepare_v2(db, queryStr, -1, &statement, &remainingStatement);
+
+    if (statementStatus != SQLITE_OK) {
+      errorMessage = sqlite3_errmsg(db);
+      return {.type = SQLiteError,
+              .message =
+                  "[op-sqlite] SQL prepare error: " + std::string(errorMessage),
+              .affectedRows = 0};
+    }
+
+    if (params != nullptr && !params->empty()) {
+      opsqlite_bind_statement(statement, params);
+    }
+
+    column_count = sqlite3_column_count(statement);
+    bool is_consuming = true;
+    // Do a first pass to get the column names
+    for (int i = 0; i < column_count; i++) {
+      column_name = sqlite3_column_name(statement, i);
+      column_names.push_back(column_name);
+    }
+
+    double double_value;
+    const char *string_value;
+    while (is_consuming) {
+      step_result = sqlite3_step(statement);
+
+      switch (step_result) {
+      case SQLITE_ROW:
+        current_column = 0;
+        row = std::vector<JSVariant>();
+        column_count = sqlite3_column_count(statement);
+
+        while (current_column < column_count) {
+          column_type = sqlite3_column_type(statement, current_column);
+
+          switch (column_type) {
+
+          case SQLITE_INTEGER:
+            // intentional fallthrough
+          case SQLITE_FLOAT: {
+            double_value = sqlite3_column_double(statement, current_column);
+            row.emplace_back(double_value);
+            break;
+          }
+
+          case SQLITE_TEXT: {
+            string_value = reinterpret_cast<const char *>(
+                sqlite3_column_text(statement, current_column));
+            int byteLen = sqlite3_column_bytes(statement, current_column);
+            // Specify length too; in case string contains NULL in the middle
+            row.emplace_back(std::string(string_value, byteLen));
+            break;
+          }
+
+          case SQLITE_BLOB: {
+            int blob_size = sqlite3_column_bytes(statement, current_column);
+            const void *blob = sqlite3_column_blob(statement, current_column);
+            auto *data = new uint8_t[blob_size];
+            memcpy(data, blob, blob_size);
+            row.emplace_back(
+                ArrayBuffer{.data = std::shared_ptr<uint8_t>{data},
+                            .size = static_cast<size_t>(blob_size)});
+            break;
+          }
+
+          case SQLITE_NULL:
+            // Intentionally left blank to switch to default case
+          default:
+            row.emplace_back(nullptr);
+            break;
+          }
+
+          current_column++;
+        }
+
+        rows.push_back(row);
+        break;
+
+      case SQLITE_DONE:
+        is_consuming = false;
+        break;
+
+      default:
+        isFailed = true;
+        is_consuming = false;
+      }
+    }
+
+    sqlite3_finalize(statement);
+  } while (remainingStatement != nullptr &&
+           strcmp(remainingStatement, "") != 0 && !isFailed);
+
+  if (isFailed) {
+    const char *message = sqlite3_errmsg(db);
+    return {.type = SQLiteError,
+            .message =
+                "[op-sqlite] SQL execution error: " + std::string(message),
+            .affectedRows = 0,
+            .insertId = 0};
+  }
+
+  int changedRowCount = sqlite3_changes(db);
+  long long latestInsertRowId = sqlite3_last_insert_rowid(db);
+  return {.type = SQLiteOk,
+          .affectedRows = changedRowCount,
+          .insertId = static_cast<double>(latestInsertRowId),
+          .rows = std::move(rows),
+          .column_names = std::move(column_names)};
+}
+
 /// Base execution function, returns HostObjects to the JS environment
-BridgeResult
-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) {
+BridgeResult opsqlite_execute_host_objects(
+    std::string const &dbName, std::string const &query,
+    const std::vector<JSVariant> *params, std::vector<DumbHostObject> *results,
+    std::shared_ptr<std::vector<SmartHostObject>> &metadatas) {
 
   check_db_open(dbName);
 
@@ -406,16 +552,14 @@ opsqlite_execute(std::string const &dbName, std::string const &query,
 
     // The statement did not fail to parse but there is nothing to do, just
     // skip to the end
-    if (statement == NULL) {
+    if (statement == nullptr) {
       continue;
     }
 
-    if (params != nullptr && params->size() > 0) {
+    if (params != nullptr && !params->empty()) {
       opsqlite_bind_statement(statement, params);
     }
 
-    isConsuming = true;
-
     int i, count, column_type;
     std::string column_name, column_declared_type;
 
@@ -424,7 +568,7 @@ opsqlite_execute(std::string const &dbName, std::string const &query,
 
       switch (result) {
       case SQLITE_ROW: {
-        if (results == NULL) {
+        if (results == nullptr) {
           break;
         }
 
@@ -443,13 +587,13 @@ opsqlite_execute(std::string const &dbName, std::string const &query,
              * only represent Integers up to 53 bits
              */
             double column_value = sqlite3_column_double(statement, i);
-            row.values.push_back(JSVariant(column_value));
+            row.values.emplace_back(column_value);
             break;
           }
 
           case SQLITE_FLOAT: {
             double column_value = sqlite3_column_double(statement, i);
-            row.values.push_back(JSVariant(column_value));
+            row.values.emplace_back(column_value);
             break;
           }
 
@@ -458,20 +602,20 @@ opsqlite_execute(std::string const &dbName, std::string const &query,
                 sqlite3_column_text(statement, i));
             int byteLen = sqlite3_column_bytes(statement, i);
             // Specify length too; in case string contains NULL in the middle
-            row.values.push_back(JSVariant(std::string(column_value, byteLen)));
+            row.values.emplace_back(std::string(column_value, byteLen));
             break;
           }
 
           case SQLITE_BLOB: {
             int blob_size = sqlite3_column_bytes(statement, i);
             const void *blob = sqlite3_column_blob(statement, i);
-            uint8_t *data = new uint8_t[blob_size];
+            auto *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.values.push_back(
-                JSVariant(ArrayBuffer{.data = std::shared_ptr<uint8_t>{data},
-                                      .size = static_cast<size_t>(blob_size)}));
+            row.values.emplace_back(
+                ArrayBuffer{.data = std::shared_ptr<uint8_t>{data},
+                            .size = static_cast<size_t>(blob_size)});
             break;
           }
 
@@ -479,7 +623,7 @@ opsqlite_execute(std::string const &dbName, std::string const &query,
             // Intentionally left blank
 
           default:
-            row.values.push_back(JSVariant(nullptr));
+            row.values.emplace_back(nullptr);
             break;
           }
           i++;
@@ -499,10 +643,10 @@ opsqlite_execute(std::string const &dbName, std::string const &query,
             column_name = sqlite3_column_name(statement, i);
             const char *type = sqlite3_column_decltype(statement, i);
             auto metadata = SmartHostObject();
-            metadata.fields.push_back(std::make_pair("name", column_name));
-            metadata.fields.push_back(std::make_pair("index", i));
-            metadata.fields.push_back(
-                std::make_pair("type", type == NULL ? "UNKNOWN" : type));
+            metadata.fields.emplace_back("name", column_name);
+            metadata.fields.emplace_back("index", i);
+            metadata.fields.emplace_back("type",
+                                         type == nullptr ? "UNKNOWN" : type);
 
             metadatas->push_back(metadata);
             i++;
@@ -519,8 +663,8 @@ opsqlite_execute(std::string const &dbName, std::string const &query,
     }
 
     sqlite3_finalize(statement);
-  } while (remainingStatement != NULL && strcmp(remainingStatement, "") != 0 &&
-           !isFailed);
+  } while (remainingStatement != nullptr &&
+           strcmp(remainingStatement, "") != 0 && !isFailed);
 
   if (isFailed) {
 
@@ -577,16 +721,14 @@ opsqlite_execute_raw(std::string const &dbName, std::string const &query,
 
     // The statement did not fail to parse but there is nothing to do, just
     // skip to the end
-    if (statement == NULL) {
+    if (statement == nullptr) {
       continue;
     }
 
-    if (params != nullptr && params->size() > 0) {
+    if (params != nullptr && !params->empty()) {
       opsqlite_bind_statement(statement, params);
     }
 
-    isConsuming = true;
-
     int i, count, column_type;
     std::string column_name, column_declared_type;
 
@@ -615,13 +757,13 @@ opsqlite_execute_raw(std::string const &dbName, std::string const &query,
              * only represent Integers up to 53 bits
              */
             double column_value = sqlite3_column_double(statement, i);
-            row.push_back(JSVariant(column_value));
+            row.emplace_back(column_value);
             break;
           }
 
           case SQLITE_FLOAT: {
             double column_value = sqlite3_column_double(statement, i);
-            row.push_back(JSVariant(column_value));
+            row.emplace_back(column_value);
             break;
           }
 
@@ -630,27 +772,25 @@ opsqlite_execute_raw(std::string const &dbName, std::string const &query,
                 sqlite3_column_text(statement, i));
             int byteLen = sqlite3_column_bytes(statement, i);
             // Specify length too; in case string contains NULL in the middle
-            row.push_back(JSVariant(std::string(column_value, byteLen)));
+            row.emplace_back(std::string(column_value, byteLen));
             break;
           }
 
           case SQLITE_BLOB: {
             int blob_size = sqlite3_column_bytes(statement, i);
             const void *blob = sqlite3_column_blob(statement, i);
-            uint8_t *data = new uint8_t[blob_size];
+            auto *data = new uint8_t[blob_size];
             memcpy(data, blob, blob_size);
-            row.push_back(
-                JSVariant(ArrayBuffer{.data = std::shared_ptr<uint8_t>{data},
-                                      .size = static_cast<size_t>(blob_size)}));
+            row.emplace_back(
+                ArrayBuffer{.data = std::shared_ptr<uint8_t>{data},
+                            .size = static_cast<size_t>(blob_size)});
             break;
           }
 
           case SQLITE_NULL:
-            row.push_back(JSVariant(nullptr));
-            break;
-
+            // intentional fallthrough
           default:
-            row.push_back(JSVariant(nullptr));
+            row.emplace_back(nullptr);
             break;
           }
           i++;
@@ -673,8 +813,8 @@ opsqlite_execute_raw(std::string const &dbName, std::string const &query,
     }
 
     sqlite3_finalize(statement);
-  } while (remainingStatement != NULL && strcmp(remainingStatement, "") != 0 &&
-           !isFailed);
+  } while (remainingStatement != nullptr &&
+           strcmp(remainingStatement, "") != 0 && !isFailed);
 
   if (isFailed) {
 
@@ -756,7 +896,7 @@ BridgeResult opsqlite_deregister_update_hook(std::string const &dbName) {
   sqlite3 *db = dbMap[dbName];
   updateCallbackMap.erase(dbName);
 
-  sqlite3_update_hook(db, NULL, NULL);
+  sqlite3_update_hook(db, nullptr, nullptr);
 
   return {SQLiteOk};
 }
@@ -794,7 +934,7 @@ BridgeResult opsqlite_deregister_commit_hook(std::string const &dbName) {
 
   sqlite3 *db = dbMap[dbName];
   commitCallbackMap.erase(dbName);
-  sqlite3_commit_hook(db, NULL, NULL);
+  sqlite3_commit_hook(db, nullptr, nullptr);
 
   return {SQLiteOk};
 }
@@ -831,7 +971,7 @@ BridgeResult opsqlite_deregister_rollback_hook(std::string const &dbName) {
   sqlite3 *db = dbMap[dbName];
   rollbackCallbackMap.erase(dbName);
 
-  sqlite3_rollback_hook(db, NULL, NULL);
+  sqlite3_rollback_hook(db, nullptr, nullptr);
 
   return {SQLiteOk};
 }
@@ -867,7 +1007,7 @@ BridgeResult opsqlite_load_extension(std::string const &db_name,
 #endif
 }
 
-BatchResult opsqlite_execute_batch(std::string dbName,
+BatchResult opsqlite_execute_batch(std::string &name,
                                    std::vector<BatchArguments> *commands) {
   size_t commandCount = commands->size();
   if (commandCount <= 0) {
@@ -879,16 +1019,14 @@ BatchResult opsqlite_execute_batch(std::string dbName,
 
   try {
     int affectedRows = 0;
-    opsqlite_execute(dbName, "BEGIN EXCLUSIVE TRANSACTION", nullptr, nullptr,
-                     nullptr);
+    opsqlite_execute(name, "BEGIN EXCLUSIVE TRANSACTION", nullptr);
     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 = opsqlite_execute(dbName, command.sql, command.params.get(),
-                                     nullptr, nullptr);
+      auto result = opsqlite_execute(name, command.sql, command.params.get());
       if (result.type == SQLiteError) {
-        opsqlite_execute(dbName, "ROLLBACK", nullptr, nullptr, nullptr);
+        opsqlite_execute(name, "ROLLBACK", nullptr);
         return BatchResult{
             .type = SQLiteError,
             .message = result.message,
@@ -897,14 +1035,14 @@ BatchResult opsqlite_execute_batch(std::string dbName,
         affectedRows += result.affectedRows;
       }
     }
-    opsqlite_execute(dbName, "COMMIT", nullptr, nullptr, nullptr);
+    opsqlite_execute(name, "COMMIT", nullptr);
     return BatchResult{
         .type = SQLiteOk,
         .affectedRows = affectedRows,
         .commands = static_cast<int>(commandCount),
     };
   } catch (std::exception &exc) {
-    opsqlite_execute(dbName, "ROLLBACK", nullptr, nullptr, nullptr);
+    opsqlite_execute(name, "ROLLBACK", nullptr);
     return BatchResult{
         .type = SQLiteError,
         .message = exc.what(),

package/cpp/bridge.h

@@ -24,11 +24,13 @@ std::string opsqlite_get_db_path(std::string const &db_name,
 
 #ifdef OP_SQLITE_USE_SQLCIPHER
 BridgeResult opsqlite_open(std::string const &dbName, std::string const &dbPath,
-                           std::string const &crsqlitePath,
+                           std::string const &crsqlite_path,
+                           std::string const &sqlite_vec_path,
                            std::string const &encryptionKey);
 #else
 BridgeResult opsqlite_open(std::string const &dbName, std::string const &dbPath,
-                           std::string const &crsqlitePath);
+                           std::string const &crsqlite_path,
+                           std::string const &sqlite_vec_path);
 #endif
 
 BridgeResult opsqlite_close(std::string const &dbName);
@@ -44,13 +46,15 @@ BridgeResult opsqlite_attach(std::string const &mainDBName,
 BridgeResult opsqlite_detach(std::string const &mainDBName,
                              std::string const &alias);
 
-BridgeResult
-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);
+BridgeResult opsqlite_execute(std::string const &name, std::string const &query,
+                              const std::vector<JSVariant> *params);
 
-BatchResult opsqlite_execute_batch(std::string dbName,
+BridgeResult opsqlite_execute_host_objects(
+    std::string const &dbName, std::string const &query,
+    const std::vector<JSVariant> *params, std::vector<DumbHostObject> *results,
+    std::shared_ptr<std::vector<SmartHostObject>> &metadatas);
+
+BatchResult opsqlite_execute_batch(std::string &name,
                                    std::vector<BatchArguments> *commands);
 
 BridgeResult opsqlite_execute_raw(std::string const &dbName,
@@ -79,7 +83,7 @@ void opsqlite_bind_statement(sqlite3_stmt *statement,
 BridgeResult opsqlite_execute_prepared_statement(
     std::string const &dbName, sqlite3_stmt *statement,
     std::vector<DumbHostObject> *results,
-    std::shared_ptr<std::vector<SmartHostObject>> metadatas);
+    std::shared_ptr<std::vector<SmartHostObject>> &metadatas);
 
 BridgeResult opsqlite_load_extension(std::string const &db_name,
                                      std::string &path,