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

package/cpp/DBHostObject.h

@@ -2,6 +2,7 @@
 #define DBHostObject_h
 
 #include "ThreadPool.h"
+#include "sqlite3.h"
 #include "types.h"
 #include <ReactCommon/CallInvoker.h>
 #include <any>
@@ -14,11 +15,14 @@ namespace opsqlite {
 namespace jsi = facebook::jsi;
 namespace react = facebook::react;
 
+struct TableRowDiscriminator {
+  std::string table;
+  std::vector<int> ids;
+};
+
 struct ReactiveQuery {
-  std::string query;
-  std::vector<JSVariant> args;
-  std::vector<std::string> tables;
-  std::vector<int> rowIds;
+  sqlite3_stmt *stmt;
+  std::vector<TableRowDiscriminator> discriminators;
   std::shared_ptr<jsi::Value> callback;
 };
 
@@ -31,8 +35,9 @@ public:
                std::string &encryption_key);
 
   std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt);
-
   jsi::Value get(jsi::Runtime &rt, const jsi::PropNameID &propNameID);
+  void set(jsi::Runtime &rt, const jsi::PropNameID &name,
+           const jsi::Value &value);
 
   void auto_register_update_hook();
 

package/cpp/PreparedStatementHostObject.cpp

@@ -1,5 +1,9 @@
 #include "PreparedStatementHostObject.h"
+#if OP_SQLITE_USE_LIBSQL
+#include "libsql/bridge.h"
+#else
 #include "bridge.h"
+#endif
 #include "macros.h"
 #include "utils.h"
 
@@ -7,10 +11,6 @@ namespace opsqlite {
 
 namespace jsi = facebook::jsi;
 
-PreparedStatementHostObject::PreparedStatementHostObject(
-    std::string dbName, sqlite3_stmt *statementPtr)
-    : _dbName(dbName), _statement(statementPtr) {}
-
 std::vector<jsi::PropNameID>
 PreparedStatementHostObject::getPropertyNames(jsi::Runtime &rt) {
   std::vector<jsi::PropNameID> keys;
@@ -24,14 +24,17 @@ jsi::Value PreparedStatementHostObject::get(jsi::Runtime &rt,
 
   if (name == "bind") {
     return HOSTFN("bind", 1) {
-      if (_statement == nullptr) {
+      if (_stmt == nullptr) {
         throw std::runtime_error("statement has been freed");
       }
 
       const jsi::Value &js_params = args[0];
       std::vector<JSVariant> params = to_variant_vec(rt, js_params);
-
-      opsqlite_bind_statement(_statement, &params);
+#ifdef OP_SQLITE_USE_LIBSQL
+      opsqlite_libsql_bind_statement(_stmt, &params);
+#else
+      opsqlite_bind_statement(_stmt, &params);
+#endif
 
       return {};
     });
@@ -39,16 +42,20 @@ jsi::Value PreparedStatementHostObject::get(jsi::Runtime &rt,
 
   if (name == "execute") {
     return HOSTFN("execute", 1) {
-      if (_statement == nullptr) {
+      if (_stmt == nullptr) {
         throw std::runtime_error("statement has been freed");
       }
 
       std::vector<DumbHostObject> results;
       std::shared_ptr<std::vector<SmartHostObject>> metadata =
           std::make_shared<std::vector<SmartHostObject>>();
-
-      auto status = opsqlite_execute_prepared_statement(_dbName, _statement,
-                                                        &results, metadata);
+#ifdef OP_SQLITE_USE_LIBSQL
+      auto status = opsqlite_libsql_execute_prepared_statement(
+          _name, _stmt, &results, metadata);
+#else
+      auto status =
+          opsqlite_execute_prepared_statement(_name, _stmt, &results, metadata);
+#endif
 
       if (status.type == SQLiteError) {
         throw std::runtime_error(status.message);
@@ -63,10 +70,17 @@ jsi::Value PreparedStatementHostObject::get(jsi::Runtime &rt,
 }
 
 PreparedStatementHostObject::~PreparedStatementHostObject() {
-  if (_statement != nullptr) {
-    sqlite3_finalize(_statement);
-    _statement = nullptr;
+#ifdef OP_SQLITE_USE_LIBSQL
+  if (_stmt != nullptr) {
+    libsql_free_stmt(_stmt);
+    _stmt = nullptr;
+  }
+#else
+  if (_stmt != nullptr) {
+    sqlite3_finalize(_stmt);
+    _stmt = nullptr;
   }
+#endif
 }
 
 } // namespace opsqlite

package/cpp/PreparedStatementHostObject.h

@@ -1,16 +1,12 @@
-//
-//  PreparedStatementHostObject.hpp
-//  op-sqlite
-//
-//  Created by Oscar Franco on 5/12/23.
-//
-
-#ifndef PreparedStatementHostObject_h
-#define PreparedStatementHostObject_h
+#pragma once
 
 #include <jsi/jsi.h>
 #include <memory>
+#ifdef OP_SQLITE_USE_LIBSQL
+#include "libsql.h"
+#else
 #include <sqlite3.h>
+#endif
 #include <string>
 
 namespace opsqlite {
@@ -18,7 +14,13 @@ namespace jsi = facebook::jsi;
 
 class PreparedStatementHostObject : public jsi::HostObject {
 public:
-  PreparedStatementHostObject(std::string dbName, sqlite3_stmt *statement);
+#ifdef OP_SQLITE_USE_LIBSQL
+  PreparedStatementHostObject(std::string name, libsql_stmt_t stmt)
+      : _name(name), _stmt(stmt){};
+#else
+  PreparedStatementHostObject(std::string name, sqlite3_stmt *stmt)
+      : _name(name), _stmt(stmt){};
+#endif
   virtual ~PreparedStatementHostObject();
 
   std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt);
@@ -26,11 +28,13 @@ public:
   jsi::Value get(jsi::Runtime &rt, const jsi::PropNameID &propNameID);
 
 private:
-  std::string _dbName;
+  std::string _name;
+#ifdef OP_SQLITE_USE_LIBSQL
+  libsql_stmt_t _stmt;
+#else
   // This shouldn't be de-allocated until sqlite3_finalize is called on it
-  sqlite3_stmt *_statement;
+  sqlite3_stmt *_stmt;
+#endif
 };
 
 } // namespace opsqlite
-
-#endif /* PreparedStatementHostObject_hpp */

package/cpp/bindings.cpp

@@ -1,12 +1,14 @@
 #include "bindings.h"
 #include "DBHostObject.h"
 #include "DumbHostObject.h"
-#include "PreparedStatementHostObject.h"
 #include "ThreadPool.h"
+#ifdef OP_SQLITE_USE_LIBSQL
+#include "libsql/bridge.h"
+#else
 #include "bridge.h"
+#endif
 #include "logs.h"
 #include "macros.h"
-#include "sqlbatchexecutor.h"
 #include "utils.h"
 #include <iostream>
 #include <string>
@@ -21,12 +23,6 @@ std::string basePath;
 std::string crsqlitePath;
 std::shared_ptr<react::CallInvoker> invoker;
 std::shared_ptr<ThreadPool> thread_pool = std::make_shared<ThreadPool>();
-// std::unordered_map<std::string, std::shared_ptr<jsi::Value>> updateHooks =
-//     std::unordered_map<std::string, std::shared_ptr<jsi::Value>>();
-// std::unordered_map<std::string, std::shared_ptr<jsi::Value>> commitHooks =
-//     std::unordered_map<std::string, std::shared_ptr<jsi::Value>>();
-// std::unordered_map<std::string, std::shared_ptr<jsi::Value>> rollbackHooks =
-//     std::unordered_map<std::string, std::shared_ptr<jsi::Value>>();
 
 // React native will try to clean the module on JS context invalidation
 // (CodePush/Hot Reload) The clearState function is called and we use this flag
@@ -36,12 +32,9 @@ bool invalidated = false;
 void clearState() {
   invalidated = true;
   // Will terminate all operations and database connections
-  opsqlite_close_all();
+  //  opsqlite_close_all();
   // We then join all the threads before the context gets invalidated
   thread_pool->restartPool();
-  //  updateHooks.clear();
-  //  commitHooks.clear();
-  //  rollbackHooks.clear();
 }
 
 void install(jsi::Runtime &rt,
@@ -104,9 +97,18 @@ void install(jsi::Runtime &rt,
 #endif
   });
 
+  auto is_libsql = HOSTFN("isLibsql", 0) {
+#ifdef OP_SQLITE_USE_LIBSQL
+    return true;
+#else
+    return false;
+#endif
+  });
+
   jsi::Object module = jsi::Object(rt);
   module.setProperty(rt, "open", std::move(open));
   module.setProperty(rt, "isSQLCipher", std::move(is_sqlcipher));
+  module.setProperty(rt, "isLibsql", std::move(is_libsql));
 
   rt.global().setProperty(rt, "__OPSQLiteProxy", std::move(module));
 }

package/cpp/bindings.h

@@ -1,3 +1,5 @@
+#pragma once
+
 #include <ReactCommon/CallInvoker.h>
 #include <jsi/jsi.h>
 #include <jsi/jsilib.h>

package/cpp/bridge.cpp

@@ -867,4 +867,49 @@ BridgeResult opsqlite_load_extension(std::string const &db_name,
 #endif
 }
 
+BatchResult opsqlite_execute_batch(std::string dbName,
+                                   std::vector<BatchArguments> *commands) {
+  size_t commandCount = commands->size();
+  if (commandCount <= 0) {
+    return BatchResult{
+        .type = SQLiteError,
+        .message = "No SQL commands provided",
+    };
+  }
+
+  try {
+    int affectedRows = 0;
+    opsqlite_execute(dbName, "BEGIN EXCLUSIVE TRANSACTION", nullptr, nullptr,
+                     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);
+      if (result.type == SQLiteError) {
+        opsqlite_execute(dbName, "ROLLBACK", nullptr, nullptr, nullptr);
+        return BatchResult{
+            .type = SQLiteError,
+            .message = result.message,
+        };
+      } else {
+        affectedRows += result.affectedRows;
+      }
+    }
+    opsqlite_execute(dbName, "COMMIT", nullptr, nullptr, nullptr);
+    return BatchResult{
+        .type = SQLiteOk,
+        .affectedRows = affectedRows,
+        .commands = static_cast<int>(commandCount),
+    };
+  } catch (std::exception &exc) {
+    opsqlite_execute(dbName, "ROLLBACK", nullptr, nullptr, nullptr);
+    return BatchResult{
+        .type = SQLiteError,
+        .message = exc.what(),
+    };
+  }
+}
+
 } // namespace opsqlite

package/cpp/bridge.h

@@ -50,6 +50,9 @@ opsqlite_execute(std::string const &dbName, std::string const &query,
                  std::vector<DumbHostObject> *results,
                  std::shared_ptr<std::vector<SmartHostObject>> metadatas);
 
+BatchResult opsqlite_execute_batch(std::string dbName,
+                                   std::vector<BatchArguments> *commands);
+
 BridgeResult opsqlite_execute_raw(std::string const &dbName,
                                   std::string const &query,
                                   const std::vector<JSVariant> *params,