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

package/cpp/libsql/bridge.cpp

@@ -49,21 +49,19 @@ BridgeResult opsqlite_libsql_open_sync(std::string const &name,
                                        int sync_interval) {
   std::string path = opsqlite_get_db_path(name, base_path);
 
-  int status = 0;
+  int status;
   libsql_database_t db;
   libsql_connection_t c;
-  const char *err = NULL;
-
-    libsql_config config = {
-        .db_path = path.c_str(),
-        .primary_url = url.c_str(),
-        .auth_token = auth_token.c_str(),
-        .read_your_writes = '1',
-        .encryption_key = nullptr,
-        .sync_interval = sync_interval,
-        .with_webpki = '1'
-    };
-    status = libsql_open_sync_with_config(config, &db, &err);
+  const char *err = nullptr;
+
+  libsql_config config = {.db_path = path.c_str(),
+                          .primary_url = url.c_str(),
+                          .auth_token = auth_token.c_str(),
+                          .read_your_writes = '1',
+                          .encryption_key = nullptr,
+                          .sync_interval = sync_interval,
+                          .with_webpki = '1'};
+  status = libsql_open_sync_with_config(config, &db, &err);
   if (status != 0) {
     return {.type = SQLiteError, .message = err};
   }
@@ -84,10 +82,10 @@ BridgeResult opsqlite_libsql_open(std::string const &name,
                                   std::string const &crsqlitePath) {
   std::string path = opsqlite_get_db_path(name, last_path);
 
-  int status = 0;
+  int status;
   libsql_database_t db;
   libsql_connection_t c;
-  const char *err = NULL;
+  const char *err = nullptr;
 
   status = libsql_open_file(path.c_str(), &db, &err);
 
@@ -105,7 +103,8 @@ BridgeResult opsqlite_libsql_open(std::string const &name,
   const char *errMsg;
   const char *crsqliteEntryPoint = "sqlite3_crsqlite_init";
 
-  status = libsql_load_extension(c, crsqlitePath.c_str(), crsqliteEntryPoint, &errMsg);
+  status = libsql_load_extension(c, crsqlitePath.c_str(), crsqliteEntryPoint,
+                                 &errMsg);
 
   if (status != 0) {
     return {.type = SQLiteError, .message = errMsg};
@@ -121,10 +120,10 @@ BridgeResult opsqlite_libsql_open(std::string const &name,
 
 BridgeResult opsqlite_libsql_open_remote(std::string const &url,
                                          std::string const &auth_token) {
-  int status = 0;
+  int status;
   libsql_database_t db;
   libsql_connection_t c;
-  const char *err = NULL;
+  const char *err = nullptr;
 
   status = libsql_open_remote_with_webpki(url.c_str(), auth_token.c_str(), &db,
                                           &err);
@@ -176,8 +175,7 @@ BridgeResult opsqlite_libsql_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_libsql_execute(mainDBName, statement, nullptr, nullptr, nullptr);
+  BridgeResult result = opsqlite_libsql_execute(mainDBName, statement, nullptr);
 
   if (result.type == SQLiteError) {
     return {
@@ -194,8 +192,7 @@ BridgeResult opsqlite_libsql_attach(std::string const &mainDBName,
 BridgeResult opsqlite_libsql_detach(std::string const &mainDBName,
                                     std::string const &alias) {
   std::string statement = "DETACH DATABASE " + alias;
-  BridgeResult result =
-      opsqlite_libsql_execute(mainDBName, statement, nullptr, nullptr, nullptr);
+  BridgeResult result = opsqlite_libsql_execute(mainDBName, statement, nullptr);
   if (result.type == SQLiteError) {
     return BridgeResult{
         .type = SQLiteError,
@@ -212,7 +209,7 @@ BridgeResult opsqlite_libsql_sync(std::string const &name) {
   check_db_open(name);
 
   auto db = db_map[name].db;
-  const char *err = NULL;
+  const char *err = nullptr;
 
   int status = libsql_sync(db, &err);
 
@@ -254,23 +251,30 @@ void opsqlite_libsql_bind_statement(libsql_stmt_t statement,
   for (int ii = 0; ii < size; ii++) {
     int index = ii + 1;
     JSVariant value = values->at(ii);
+    int status;
 
-    if (std::holds_alternative<bool>(value)) {
-      libsql_bind_int(statement, index, std::get<int>(value), &err);
-    } else if (std::holds_alternative<int>(value)) {
-      libsql_bind_int(statement, index, std::get<int>(value), &err);
+    if (std::holds_alternative<bool>(value) ||
+        std::holds_alternative<int>(value)) {
+      status = libsql_bind_int(statement, index, std::get<int>(value), &err);
     } else if (std::holds_alternative<long long>(value)) {
-      libsql_bind_int(statement, index, std::get<long long>(value), &err);
+      status =
+          libsql_bind_int(statement, index, std::get<long long>(value), &err);
     } else if (std::holds_alternative<double>(value)) {
-      libsql_bind_float(statement, index, std::get<double>(value), &err);
+      status =
+          libsql_bind_float(statement, index, std::get<double>(value), &err);
     } else if (std::holds_alternative<std::string>(value)) {
       std::string str = std::get<std::string>(value);
-      libsql_bind_string(statement, index, str.c_str(), &err);
+      status = libsql_bind_string(statement, index, str.c_str(), &err);
     } else if (std::holds_alternative<ArrayBuffer>(value)) {
       ArrayBuffer buffer = std::get<ArrayBuffer>(value);
-      libsql_bind_blob(statement, index, buffer.data.get(), buffer.size, &err);
+      status = libsql_bind_blob(statement, index, buffer.data.get(),
+                                static_cast<int>(buffer.size), &err);
     } else {
-      libsql_bind_null(statement, index, &err);
+      status = libsql_bind_null(statement, index, &err);
+    }
+
+    if (status != 0) {
+      throw std::runtime_error(err);
     }
   }
 }
@@ -278,7 +282,7 @@ void opsqlite_libsql_bind_statement(libsql_stmt_t statement,
 BridgeResult opsqlite_libsql_execute_prepared_statement(
     std::string const &name, libsql_stmt_t stmt,
     std::vector<DumbHostObject> *results,
-    std::shared_ptr<std::vector<SmartHostObject>> metadatas) {
+    const std::shared_ptr<std::vector<SmartHostObject>> &metadatas) {
 
   check_db_open(name);
 
@@ -286,12 +290,8 @@ BridgeResult opsqlite_libsql_execute_prepared_statement(
   libsql_rows_t rows;
   libsql_row_t row;
 
-  int status = 0;
-  const char *err = NULL;
-
-  if (status != 0) {
-    return {.type = SQLiteError, .message = err};
-  }
+  int status;
+  const char *err = nullptr;
 
   status = libsql_query_stmt(stmt, &rows, &err);
 
@@ -319,39 +319,39 @@ BridgeResult opsqlite_libsql_execute_prepared_statement(
       case LIBSQL_INT:
         long long int_value;
         status = libsql_get_int(row, col, &int_value, &err);
-        row_host_object.values.push_back(JSVariant(int_value));
+        row_host_object.values.emplace_back(int_value);
         break;
 
       case LIBSQL_FLOAT:
         double float_value;
         status = libsql_get_float(row, col, &float_value, &err);
-        row_host_object.values.push_back(JSVariant(float_value));
+        row_host_object.values.emplace_back(float_value);
         break;
 
       case LIBSQL_TEXT:
         const char *text_value;
         status = libsql_get_string(row, col, &text_value, &err);
-        row_host_object.values.push_back(JSVariant(text_value));
+        row_host_object.values.emplace_back(text_value);
         break;
 
       case LIBSQL_BLOB: {
         blob value_blob;
         libsql_get_blob(row, col, &value_blob, &err);
-        uint8_t *data = new uint8_t[value_blob.len];
+        auto *data = new uint8_t[value_blob.len];
         // You cannot share raw memory between native and JS
         // always copy the data
         memcpy(data, value_blob.ptr, value_blob.len);
         libsql_free_blob(value_blob);
-        row_host_object.values.push_back(JSVariant(
+        row_host_object.values.emplace_back(
             ArrayBuffer{.data = std::shared_ptr<uint8_t>{data},
-                        .size = static_cast<size_t>(value_blob.len)}));
+                        .size = static_cast<size_t>(value_blob.len)});
         break;
       }
 
       case LIBSQL_NULL:
         // intentional fall-through
       default:
-        row_host_object.values.push_back(JSVariant(nullptr));
+        row_host_object.values.emplace_back(nullptr);
         break;
       }
 
@@ -366,9 +366,9 @@ BridgeResult opsqlite_libsql_execute_prepared_statement(
         status = libsql_column_name(rows, col, &col_name, &err);
 
         auto metadata = SmartHostObject();
-        metadata.fields.push_back(std::make_pair("name", col_name));
-        metadata.fields.push_back(std::make_pair("index", col));
-        metadata.fields.push_back(std::make_pair("type", "UNKNOWN"));
+        metadata.fields.emplace_back("name", col_name);
+        metadata.fields.emplace_back("index", col);
+        metadata.fields.emplace_back("type", "UNKNOWN");
         //                  metadata.fields.push_back(
         //                      std::make_pair("type", type == -1 ? "UNKNOWN" :
         //                      type));
@@ -382,7 +382,7 @@ BridgeResult opsqlite_libsql_execute_prepared_statement(
     }
 
     metadata_set = true;
-    err = NULL;
+    err = nullptr;
   }
 
   if (status != 0) {
@@ -391,13 +391,13 @@ BridgeResult opsqlite_libsql_execute_prepared_statement(
 
   libsql_free_rows(rows);
 
-  int changes = libsql_changes(c);
+  unsigned long long changes = libsql_changes(c);
   long long insert_row_id = libsql_last_insert_rowid(c);
 
   libsql_reset_stmt(stmt, &err);
 
   return {.type = SQLiteOk,
-          .affectedRows = changes,
+          .affectedRows = static_cast<int>(changes),
           .insertId = static_cast<double>(insert_row_id)};
 }
 
@@ -420,11 +420,132 @@ libsql_stmt_t opsqlite_libsql_prepare_statement(std::string const &name,
   return stmt;
 }
 
-/// Base execution function, returns HostObjects to the JS environment
-BridgeResult opsqlite_libsql_execute(
+BridgeResult opsqlite_libsql_execute(std::string const &name,
+                                     std::string const &query,
+                                     const std::vector<JSVariant> *params) {
+
+  check_db_open(name);
+
+  std::vector<std::string> column_names;
+  std::vector<std::vector<JSVariant>> out_rows;
+  std::vector<JSVariant> out_row;
+  libsql_connection_t c = db_map[name].c;
+  libsql_rows_t rows;
+  libsql_row_t row;
+  libsql_stmt_t stmt;
+  int status;
+  const char *err = nullptr;
+
+  status = libsql_prepare(c, query.c_str(), &stmt, &err);
+
+  if (status != 0) {
+    return {.type = SQLiteError, .message = err};
+  }
+
+  if (params != nullptr && !params->empty()) {
+    opsqlite_libsql_bind_statement(stmt, params);
+  }
+
+  status = libsql_query_stmt(stmt, &rows, &err);
+
+  if (status != 0) {
+    return {.type = SQLiteError, .message = err};
+  }
+
+  // Get the column names on the first pass
+  int column_count = libsql_column_count(rows);
+  const char *col_name;
+
+  for (int i = 0; i < column_count; i++) {
+    status = libsql_column_name(rows, i, &col_name, &err);
+    if (status != 0) {
+      throw std::runtime_error(err);
+    }
+    column_names.emplace_back(col_name);
+  }
+
+  long long int_value;
+  double float_value;
+  const char *text_value;
+  blob blob_value;
+
+  status = libsql_next_row(rows, &row, &err);
+  while (status == 0) {
+    out_row = std::vector<JSVariant>();
+
+    if (!err && !row) {
+      break;
+    }
+
+    for (int col = 0; col < column_count; col++) {
+      int type;
+
+      libsql_column_type(rows, row, col, &type, &err);
+
+      switch (type) {
+      case LIBSQL_INT:
+        status = libsql_get_int(row, col, &int_value, &err);
+        out_row.emplace_back(int_value);
+        break;
+
+      case LIBSQL_FLOAT:
+        status = libsql_get_float(row, col, &float_value, &err);
+        out_row.emplace_back(float_value);
+        break;
+
+      case LIBSQL_TEXT:
+
+        status = libsql_get_string(row, col, &text_value, &err);
+        out_row.emplace_back(text_value);
+        break;
+
+      case LIBSQL_BLOB: {
+        libsql_get_blob(row, col, &blob_value, &err);
+        auto data = new uint8_t[blob_value.len];
+        // You cannot share raw memory between native and JS
+        // always copy the data
+        memcpy(data, blob_value.ptr, blob_value.len);
+        libsql_free_blob(blob_value);
+        out_row.emplace_back(
+            ArrayBuffer{.data = std::shared_ptr<uint8_t>{data},
+                        .size = static_cast<size_t>(blob_value.len)});
+        break;
+      }
+
+      case LIBSQL_NULL:
+        // intentional fall-through
+      default:
+        out_row.emplace_back(nullptr);
+        break;
+      }
+
+      if (status != 0) {
+        throw std::runtime_error(err);
+      }
+    }
+
+    out_rows.emplace_back(out_row);
+    err = nullptr;
+    status = libsql_next_row(rows, &row, &err);
+  }
+
+  libsql_free_rows(rows);
+  libsql_free_stmt(stmt);
+
+  unsigned long long changes = libsql_changes(c);
+  long long insert_row_id = libsql_last_insert_rowid(c);
+
+  return {.type = SQLiteOk,
+          .affectedRows = static_cast<int>(changes),
+          .insertId = static_cast<double>(insert_row_id),
+          .rows = std::move(out_rows),
+          .column_names = std::move(column_names)};
+}
+
+BridgeResult opsqlite_libsql_execute_with_host_objects(
     std::string const &name, std::string const &query,
     const std::vector<JSVariant> *params, std::vector<DumbHostObject> *results,
-    std::shared_ptr<std::vector<SmartHostObject>> metadatas) {
+    const std::shared_ptr<std::vector<SmartHostObject>> &metadatas) {
 
   check_db_open(name);
 
@@ -432,8 +553,8 @@ BridgeResult opsqlite_libsql_execute(
   libsql_rows_t rows;
   libsql_row_t row;
   libsql_stmt_t stmt;
-  int status = 0;
-  const char *err = NULL;
+  int status;
+  const char *err = nullptr;
 
   status = libsql_prepare(c, query.c_str(), &stmt, &err);
 
@@ -441,7 +562,7 @@ BridgeResult opsqlite_libsql_execute(
     return {.type = SQLiteError, .message = err};
   }
 
-  if (params != nullptr && params->size() > 0) {
+  if (params != nullptr && !params->empty()) {
     opsqlite_libsql_bind_statement(stmt, params);
   }
 
@@ -471,45 +592,45 @@ BridgeResult opsqlite_libsql_execute(
       case LIBSQL_INT:
         long long int_value;
         status = libsql_get_int(row, col, &int_value, &err);
-        row_host_object.values.push_back(JSVariant(int_value));
+        row_host_object.values.emplace_back(int_value);
         break;
 
       case LIBSQL_FLOAT:
         double float_value;
         status = libsql_get_float(row, col, &float_value, &err);
-        row_host_object.values.push_back(JSVariant(float_value));
+        row_host_object.values.emplace_back(float_value);
         break;
 
       case LIBSQL_TEXT:
         const char *text_value;
         status = libsql_get_string(row, col, &text_value, &err);
-        row_host_object.values.push_back(JSVariant(text_value));
+        row_host_object.values.emplace_back(text_value);
         break;
 
       case LIBSQL_BLOB: {
         blob value_blob;
         libsql_get_blob(row, col, &value_blob, &err);
-        uint8_t *data = new uint8_t[value_blob.len];
+        auto *data = new uint8_t[value_blob.len];
         // You cannot share raw memory between native and JS
         // always copy the data
         memcpy(data, value_blob.ptr, value_blob.len);
         libsql_free_blob(value_blob);
-        row_host_object.values.push_back(JSVariant(
+        row_host_object.values.emplace_back(
             ArrayBuffer{.data = std::shared_ptr<uint8_t>{data},
-                        .size = static_cast<size_t>(value_blob.len)}));
+                        .size = static_cast<size_t>(value_blob.len)});
         break;
       }
 
       case LIBSQL_NULL:
         // intentional fall-through
       default:
-        row_host_object.values.push_back(JSVariant(nullptr));
+        row_host_object.values.emplace_back(nullptr);
         break;
       }
 
       if (status != 0) {
         fprintf(stderr, "%s\n", err);
-        throw std::runtime_error("libsql error");
+        throw std::runtime_error(err);
       }
 
       // On the first interation through the columns, set the metadata
@@ -518,9 +639,9 @@ BridgeResult opsqlite_libsql_execute(
         status = libsql_column_name(rows, col, &col_name, &err);
 
         auto metadata = SmartHostObject();
-        metadata.fields.push_back(std::make_pair("name", col_name));
-        metadata.fields.push_back(std::make_pair("index", col));
-        metadata.fields.push_back(std::make_pair("type", "UNKNOWN"));
+        metadata.fields.emplace_back("name", col_name);
+        metadata.fields.emplace_back("index", col);
+        metadata.fields.emplace_back("type", "UNKNOWN");
         //                  metadata.fields.push_back(
         //                      std::make_pair("type", type == -1 ? "UNKNOWN" :
         //                      type));
@@ -534,7 +655,7 @@ BridgeResult opsqlite_libsql_execute(
     }
 
     metadata_set = true;
-    err = NULL;
+    err = nullptr;
   }
 
   if (status != 0) {
@@ -544,11 +665,11 @@ BridgeResult opsqlite_libsql_execute(
   libsql_free_rows(rows);
   libsql_free_stmt(stmt);
 
-  int changes = libsql_changes(c);
+  unsigned long long changes = libsql_changes(c);
   long long insert_row_id = libsql_last_insert_rowid(c);
 
   return {.type = SQLiteOk,
-          .affectedRows = changes,
+          .affectedRows = static_cast<int>(changes),
           .insertId = static_cast<double>(insert_row_id)};
 }
 
@@ -565,8 +686,8 @@ opsqlite_libsql_execute_raw(std::string const &name, std::string const &query,
   libsql_rows_t rows;
   libsql_row_t row;
   libsql_stmt_t stmt;
-  int status = 0;
-  const char *err = NULL;
+  int status;
+  const char *err = nullptr;
 
   status = libsql_prepare(c, query.c_str(), &stmt, &err);
 
@@ -574,7 +695,7 @@ opsqlite_libsql_execute_raw(std::string const &name, std::string const &query,
     return {.type = SQLiteError, .message = err};
   }
 
-  if (params != nullptr && params->size() > 0) {
+  if (params != nullptr && !params->empty()) {
     opsqlite_libsql_bind_statement(stmt, params);
   }
 
@@ -602,39 +723,39 @@ opsqlite_libsql_execute_raw(std::string const &name, std::string const &query,
       case LIBSQL_INT:
         long long int_value;
         status = libsql_get_int(row, col, &int_value, &err);
-        row_vector.push_back(JSVariant(int_value));
+        row_vector.emplace_back(int_value);
         break;
 
       case LIBSQL_FLOAT:
         double float_value;
         status = libsql_get_float(row, col, &float_value, &err);
-        row_vector.push_back(JSVariant(float_value));
+        row_vector.emplace_back(float_value);
         break;
 
       case LIBSQL_TEXT:
         const char *text_value;
         status = libsql_get_string(row, col, &text_value, &err);
-        row_vector.push_back(JSVariant(text_value));
+        row_vector.emplace_back(text_value);
         break;
 
       case LIBSQL_BLOB: {
         blob value_blob;
         libsql_get_blob(row, col, &value_blob, &err);
-        uint8_t *data = new uint8_t[value_blob.len];
+        auto *data = new uint8_t[value_blob.len];
         // You cannot share raw memory between native and JS
         // always copy the data
         memcpy(data, value_blob.ptr, value_blob.len);
         libsql_free_blob(value_blob);
-        row_vector.push_back(JSVariant(
+        row_vector.emplace_back(
             ArrayBuffer{.data = std::shared_ptr<uint8_t>{data},
-                        .size = static_cast<size_t>(value_blob.len)}));
+                        .size = static_cast<size_t>(value_blob.len)});
         break;
       }
 
       case LIBSQL_NULL:
         // intentional fall-through
       default:
-        row_vector.push_back(JSVariant(nullptr));
+        row_vector.emplace_back(nullptr);
         break;
       }
 
@@ -648,7 +769,7 @@ opsqlite_libsql_execute_raw(std::string const &name, std::string const &query,
       results->push_back(row_vector);
     }
 
-    err = NULL;
+    err = nullptr;
   }
 
   if (status != 0) {
@@ -658,11 +779,11 @@ opsqlite_libsql_execute_raw(std::string const &name, std::string const &query,
   libsql_free_rows(rows);
   libsql_free_stmt(stmt);
 
-  int changes = libsql_changes(c);
+  unsigned long long changes = libsql_changes(c);
   long long insert_row_id = libsql_last_insert_rowid(c);
 
   return {.type = SQLiteOk,
-          .affectedRows = changes,
+          .affectedRows = static_cast<int>(changes),
           .insertId = static_cast<double>(insert_row_id)};
 }
 
@@ -679,16 +800,15 @@ opsqlite_libsql_execute_batch(std::string const &name,
 
   try {
     int affectedRows = 0;
-    opsqlite_libsql_execute(name, "BEGIN EXCLUSIVE TRANSACTION", nullptr,
-                            nullptr, nullptr);
+    opsqlite_libsql_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_libsql_execute(
-          name, command.sql, command.params.get(), nullptr, nullptr);
+      auto result =
+          opsqlite_libsql_execute(name, command.sql, command.params.get());
       if (result.type == SQLiteError) {
-        opsqlite_libsql_execute(name, "ROLLBACK", nullptr, nullptr, nullptr);
+        opsqlite_libsql_execute(name, "ROLLBACK", nullptr);
         return BatchResult{
             .type = SQLiteError,
             .message = result.message,
@@ -697,14 +817,14 @@ opsqlite_libsql_execute_batch(std::string const &name,
         affectedRows += result.affectedRows;
       }
     }
-    opsqlite_libsql_execute(name, "COMMIT", nullptr, nullptr, nullptr);
+    opsqlite_libsql_execute(name, "COMMIT", nullptr);
     return BatchResult{
         .type = SQLiteOk,
         .affectedRows = affectedRows,
         .commands = static_cast<int>(commandCount),
     };
   } catch (std::exception &exc) {
-    opsqlite_libsql_execute(name, "ROLLBACK", nullptr, nullptr, nullptr);
+    opsqlite_libsql_execute(name, "ROLLBACK", nullptr);
     return BatchResult{
         .type = SQLiteError,
         .message = exc.what(),

package/cpp/libsql/bridge.h

@@ -57,8 +57,12 @@ BridgeResult opsqlite_libsql_sync(std::string const &name);
 
 BridgeResult opsqlite_libsql_execute(
     std::string const &name, std::string const &query,
-    const std::vector<JSVariant> *params, std::vector<DumbHostObject> *results,
-    std::shared_ptr<std::vector<SmartHostObject>> metadatas);
+    const std::vector<JSVariant> *params);
+
+    BridgeResult opsqlite_libsql_execute_with_host_objects(
+            std::string const &name, std::string const &query,
+            const std::vector<JSVariant> *params, std::vector<DumbHostObject> *results,
+            const std::shared_ptr<std::vector<SmartHostObject>>& metadatas);
 
 BridgeResult
 opsqlite_libsql_execute_raw(std::string const &dbName, std::string const &query,
@@ -80,6 +84,6 @@ void opsqlite_libsql_bind_statement(libsql_stmt_t stmt,
 BridgeResult opsqlite_libsql_execute_prepared_statement(
     std::string const &name, libsql_stmt_t stmt,
     std::vector<DumbHostObject> *results,
-    std::shared_ptr<std::vector<SmartHostObject>> metadatas);
+    const std::shared_ptr<std::vector<SmartHostObject>>& metadatas);
 
 } // namespace opsqlite

package/cpp/macros.h

@@ -1,11 +1,11 @@
 #ifndef macros_h
 #define macros_h
 
-#define HOSTFN(name, basecount)                                                \
+#define HOSTFN(name)                                                           \
 jsi::Function::createFromHostFunction( \
 rt, \
 jsi::PropNameID::forAscii(rt, name), \
-basecount, \
+0, \
 [=](jsi::Runtime &rt, const jsi::Value &thisValue, const jsi::Value *args, size_t count) -> jsi::Value
 
 #endif /* macros_h */

package/cpp/types.h

@@ -4,6 +4,15 @@
 #include <memory>
 #include <string>
 #include <variant>
+#include <vector>
+
+struct ArrayBuffer {
+  std::shared_ptr<uint8_t> data;
+  size_t size;
+};
+
+using JSVariant = std::variant<nullptr_t, bool, int, double, long, long long,
+                               std::string, ArrayBuffer>;
 
 enum ResultType { SQLiteOk, SQLiteError };
 
@@ -12,6 +21,8 @@ struct BridgeResult {
   std::string message;
   int affectedRows;
   double insertId;
+  std::vector<std::vector<JSVariant>> rows;
+  std::vector<std::string> column_names;
 };
 
 struct BatchResult {
@@ -21,14 +32,6 @@ struct BatchResult {
   int commands;
 };
 
-struct ArrayBuffer {
-  std::shared_ptr<uint8_t> data;
-  size_t size;
-};
-
-using JSVariant = std::variant<nullptr_t, bool, int, double, long, long long,
-                               std::string, ArrayBuffer>;
-
 struct BatchArguments {
   std::string sql;
   std::shared_ptr<std::vector<JSVariant>> params;