@op-engineering/op-sqlite 2.0.1 → 2.0.3

package/cpp/bridge.h

@@ -1,11 +1,12 @@
 #ifndef bridge_h
 #define bridge_h
 
-#include "utils.h"
-#include <vector>
-#include "DynamicHostObject.h"
 #include "DumbHostObject.h"
+#include "SmartHostObject.h"
 #include "types.h"
+#include "utils.h"
+#include <sqlite3.h>
+#include <vector>
 
 namespace opsqlite {
 
@@ -15,31 +16,52 @@ BridgeResult sqliteOpenDb(std::string const dbName, std::string const dbPath);
 
 BridgeResult sqliteCloseDb(std::string const dbName);
 
-BridgeResult sqliteRemoveDb(std::string const dbName, std::string const docPath);
+BridgeResult sqliteRemoveDb(std::string const dbName,
+                            std::string const docPath);
 
-BridgeResult sqliteAttachDb(std::string const mainDBName, std::string const docPath, std::string const databaseToAttach, std::string const alias);
+BridgeResult sqliteAttachDb(std::string const mainDBName,
+                            std::string const docPath,
+                            std::string const databaseToAttach,
+                            std::string const alias);
 
-BridgeResult sqliteDetachDb(std::string const mainDBName, std::string const alias);
+BridgeResult sqliteDetachDb(std::string const mainDBName,
+                            std::string const alias);
 
-BridgeResult sqliteExecute(std::string const dbName,
-                           std::string const &query,
-                           const std::vector<JSVariant> *params,
-                           std::vector<DumbHostObject> *results,
-                           std::shared_ptr<std::vector<DynamicHostObject>> metadatas);
+BridgeResult
+sqliteExecute(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 sqliteExecuteLiteral(std::string const dbName, std::string const &query);
+BridgeResult sqliteExecuteLiteral(std::string const dbName,
+                                  std::string const &query);
 
 void sqliteCloseAll();
 
-BridgeResult registerUpdateHook(std::string const dbName, 
-                                std::function<void (std::string dbName, std::string tableName, std::string operation, int rowId)> const callback);
+BridgeResult registerUpdateHook(
+    std::string const dbName,
+    std::function<void(std::string dbName, std::string tableName,
+                       std::string operation, int rowId)> const callback);
 BridgeResult unregisterUpdateHook(std::string const dbName);
-BridgeResult registerCommitHook(std::string const dbName,
-                                std::function<void (std::string dbName)> const callback);
+BridgeResult
+registerCommitHook(std::string const dbName,
+                   std::function<void(std::string dbName)> const callback);
 BridgeResult unregisterCommitHook(std::string const dbName);
-BridgeResult registerRollbackHook(std::string const dbName,
-                                  std::function<void (std::string dbName)> const callback);
+BridgeResult
+registerRollbackHook(std::string const dbName,
+                     std::function<void(std::string dbName)> const callback);
 BridgeResult unregisterRollbackHook(std::string const dbName);
-}
+
+sqlite3_stmt *sqlite_prepare_statement(std::string const dbName,
+                                       std::string const &query);
+
+void sqlite_bind_statement(sqlite3_stmt *statement,
+                           const std::vector<JSVariant> *params);
+
+BridgeResult sqlite_execute_prepared_statement(
+    std::string const dbName, sqlite3_stmt *statement,
+    std::vector<DumbHostObject> *results,
+    std::shared_ptr<std::vector<SmartHostObject>> metadatas);
+} // namespace opsqlite
 
 #endif /* bridge_h */

package/cpp/logs.h

@@ -12,27 +12,27 @@
 // LOGS NO ANDROID
 #include <stdio.h>
 #define LOG_TAG "op-sqlite"
-#define LOGV(...)      \
-  printf("  ");        \
-  printf(__VA_ARGS__); \
+#define LOGV(...)                                                              \
+  printf("  ");                                                                \
+  printf(__VA_ARGS__);                                                         \
   printf("\t -  <%s> \n", LOG_TAG);
-#define LOGD(...)      \
-  printf("  ");        \
-  printf(__VA_ARGS__); \
+#define LOGD(...)                                                              \
+  printf("  ");                                                                \
+  printf(__VA_ARGS__);                                                         \
   printf("\t -  <%s> \n", LOG_TAG);
-#define LOGI(...)      \
-  printf("  ");        \
-  printf(__VA_ARGS__); \
+#define LOGI(...)                                                              \
+  printf("  ");                                                                \
+  printf(__VA_ARGS__);                                                         \
   printf("\t -  <%s> \n", LOG_TAG);
-#define LOGW(...)          \
-  printf("  * Warning: "); \
-  printf(__VA_ARGS__);     \
+#define LOGW(...)                                                              \
+  printf("  * Warning: ");                                                     \
+  printf(__VA_ARGS__);                                                         \
   printf("\t -  <%s> \n", LOG_TAG);
-#define LOGE(...)           \
-  printf("  *** Error:  "); \
-  printf(__VA_ARGS__);      \
+#define LOGE(...)                                                              \
+  printf("  *** Error:  ");                                                    \
+  printf(__VA_ARGS__);                                                         \
   printf("\t -  <%s> \n", LOG_TAG);
-#define LOGSIMPLE(...) \
-  printf(" ");         \
+#define LOGSIMPLE(...)                                                         \
+  printf(" ");                                                                 \
   printf(__VA_ARGS__);
 #endif // ANDROID

package/cpp/macros.h

@@ -1,7 +1,7 @@
 #ifndef macros_h
 #define macros_h
 
-#define HOSTFN(name, basecount) \
+#define HOSTFN(name, basecount)                                                \
 jsi::Function::createFromHostFunction( \
 rt, \
 jsi::PropNameID::forAscii(rt, name), \

package/cpp/sqlbatchexecutor.cpp

@@ -6,89 +6,87 @@ namespace opsqlite {
  * Batch execution implementation
  */
 
-void toBatchArguments(jsi::Runtime &rt, jsi::Array const &batchParams, std::vector<BatchArguments> *commands)
-{
-    for (int i = 0; i < batchParams.length(rt); i++)
-    {
-        const jsi::Array &command = batchParams.getValueAtIndex(rt, i).asObject(rt).asArray(rt);
-        if (command.length(rt) == 0)
-        {
-            continue;
-        }
-        
-        const std::string query = command.getValueAtIndex(rt, 0).asString(rt).utf8(rt);
-        const jsi::Value &commandParams = command.length(rt) > 1 ? command.getValueAtIndex(rt, 1) : jsi::Value::undefined();
-        if (!commandParams.isUndefined() && commandParams.asObject(rt).isArray(rt) && commandParams.asObject(rt).asArray(rt).length(rt) > 0 && commandParams.asObject(rt).asArray(rt).getValueAtIndex(rt, 0).isObject())
-        {
-            // This arguments is an array of arrays, like a batch update of a single sql command.
-            const jsi::Array &batchUpdateParams = commandParams.asObject(rt).asArray(rt);
-            for (int x = 0; x < batchUpdateParams.length(rt); x++)
-            {
-                const jsi::Value &p = batchUpdateParams.getValueAtIndex(rt, x);
-                auto params = std::make_shared<std::vector<JSVariant>>(toVariantVec(rt, p));
-                commands->push_back({
-                    query,
-                    params
-                });
-            }
-        }
-        else
-        {
-            auto params = std::make_shared<std::vector<JSVariant>>(toVariantVec(rt, commandParams));
-            commands->push_back({
-                query,
-                params
-            });
-        }
+void toBatchArguments(jsi::Runtime &rt, jsi::Array const &batchParams,
+                      std::vector<BatchArguments> *commands) {
+  for (int i = 0; i < batchParams.length(rt); i++) {
+    const jsi::Array &command =
+        batchParams.getValueAtIndex(rt, i).asObject(rt).asArray(rt);
+    if (command.length(rt) == 0) {
+      continue;
     }
-}
 
-BatchResult sqliteExecuteBatch(std::string dbName, std::vector<BatchArguments> *commands)
-{
-    size_t commandCount = commands->size();
-    if(commandCount <= 0)
-    {
-        return BatchResult {
-            .type = SQLiteError,
-            .message = "No SQL commands provided",
-        };
+    const std::string query =
+        command.getValueAtIndex(rt, 0).asString(rt).utf8(rt);
+    const jsi::Value &commandParams = command.length(rt) > 1
+                                          ? command.getValueAtIndex(rt, 1)
+                                          : jsi::Value::undefined();
+    if (!commandParams.isUndefined() &&
+        commandParams.asObject(rt).isArray(rt) &&
+        commandParams.asObject(rt).asArray(rt).length(rt) > 0 &&
+        commandParams.asObject(rt)
+            .asArray(rt)
+            .getValueAtIndex(rt, 0)
+            .isObject()) {
+      // This arguments is an array of arrays, like a batch update of a single
+      // sql command.
+      const jsi::Array &batchUpdateParams =
+          commandParams.asObject(rt).asArray(rt);
+      for (int x = 0; x < batchUpdateParams.length(rt); x++) {
+        const jsi::Value &p = batchUpdateParams.getValueAtIndex(rt, x);
+        auto params =
+            std::make_shared<std::vector<JSVariant>>(toVariantVec(rt, p));
+        commands->push_back({query, params});
+      }
+    } else {
+      auto params = std::make_shared<std::vector<JSVariant>>(
+          toVariantVec(rt, commandParams));
+      commands->push_back({query, params});
     }
-    
-    try
-    {
-        int affectedRows = 0;
-        sqliteExecuteLiteral(dbName, "BEGIN EXCLUSIVE TRANSACTION");
-        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 = sqliteExecute(dbName, command.sql, command.params.get(), nullptr, nullptr);
-            if(result.type == SQLiteError)
-            {
-                sqliteExecuteLiteral(dbName, "ROLLBACK");
-                return BatchResult {
-                    .type = SQLiteError,
-                    .message = result.message,
-                };
-            } else
-            {
-                affectedRows += result.affectedRows;
-            }
-        }
-        sqliteExecuteLiteral(dbName, "COMMIT");
-        return BatchResult {
-            .type = SQLiteOk,
-            .affectedRows = affectedRows,
-            .commands = static_cast<int>(commandCount),
-        };
-    } catch(std::exception &exc)
-    {
+  }
+}
+
+BatchResult sqliteExecuteBatch(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;
+    sqliteExecuteLiteral(dbName, "BEGIN EXCLUSIVE TRANSACTION");
+    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 = sqliteExecute(dbName, command.sql, command.params.get(),
+                                  nullptr, nullptr);
+      if (result.type == SQLiteError) {
         sqliteExecuteLiteral(dbName, "ROLLBACK");
-        return BatchResult {
+        return BatchResult{
             .type = SQLiteError,
-            .message = exc.what(),
+            .message = result.message,
         };
+      } else {
+        affectedRows += result.affectedRows;
+      }
     }
+    sqliteExecuteLiteral(dbName, "COMMIT");
+    return BatchResult{
+        .type = SQLiteOk,
+        .affectedRows = affectedRows,
+        .commands = static_cast<int>(commandCount),
+    };
+  } catch (std::exception &exc) {
+    sqliteExecuteLiteral(dbName, "ROLLBACK");
+    return BatchResult{
+        .type = SQLiteError,
+        .message = exc.what(),
+    };
+  }
 }
 
-
-}
+} // namespace opsqlite

package/cpp/sqlbatchexecutor.h

@@ -1,9 +1,9 @@
 /**
  * SQL Batch execution implementation using default sqliteBridge implementation
-*/
-#include "utils.h"
+ */
 #include "bridge.h"
 #include "types.h"
+#include "utils.h"
 
 namespace opsqlite {
 
@@ -17,13 +17,14 @@ struct BatchArguments {
 /**
  * Local Helper method to translate JSI objects BatchArguments data structure
  * MUST be called in the JavaScript Thread
-*/
-void toBatchArguments(jsi::Runtime &rt, jsi::Array const &batchParams, std::vector<BatchArguments> *commands);
+ */
+void toBatchArguments(jsi::Runtime &rt, jsi::Array const &batchParams,
+                      std::vector<BatchArguments> *commands);
 
 /**
  * Execute a batch of commands in a exclusive transaction
-*/
-BatchResult sqliteExecuteBatch(std::string dbName, std::vector<BatchArguments> *commands);
-
-}
+ */
+BatchResult sqliteExecuteBatch(std::string dbName,
+                               std::vector<BatchArguments> *commands);
 
+} // namespace opsqlite