Added a native method to provide transactional batch execution.

The idea is to avoid to many JSI Calls for large operations.

Author: EduFrazao

cpp/react-native-quick-sqlite.cpp

@@ -177,6 +177,88 @@ void installSequel(jsi::Runtime &rt, const char *docPath)
         return move(result.value);
       });
 
+  // Parameters can be: [[sql: string, arguments: any[] | arguments: any[][] ]]
+  auto execSQLBatch = jsi::Function::createFromHostFunction(
+      rt,
+      jsi::PropNameID::forAscii(rt, "sequel_execSQLBatch"),
+      2,
+      [](jsi::Runtime &rt, const jsi::Value &thisValue, const jsi::Value *args, size_t count) -> jsi::Value
+      {
+        if(sizeof(args) < 2) {
+          jsi::detail::throwJSError(rt, "[react-native-quick-sqlite][execSQLBatch] - Incorrect parameter count");
+          return {};
+        }
+        const string dbName = args[0].asString(rt).utf8(rt);
+        const jsi::Value &params = args[1];
+        if(params.isNull() || params.isUndefined()) 
+        {
+          jsi::detail::throwJSError(rt, "[react-native-quick-sqlite][execSQLBatch] - An array of SQL commands or parameters is needed");
+          return {};
+        }
+        int rowsAffected = 0;
+        const jsi::Array &batchParams = params.asObject(rt).asArray(rt);
+        try
+        {
+          sequel_execute(rt, dbName, "BEGIN TRANSACTION", jsi::Value::undefined());
+          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) {
+              sequel_execute(rt, dbName, "ROLLBACK", jsi::Value::undefined());
+              jsi::detail::throwJSError(rt, "[react-native-quick-sqlite][execSQLBatch] - No SQL Commands found");
+              return {};
+            }
+            const 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 are 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);
+                SequelResult result = sequel_execute(rt, dbName, query, p);
+                if (result.type == SequelResultError)
+                {
+                  sequel_execute(rt, dbName, "ROLLBACK", jsi::Value::undefined());
+                  auto res = jsi::Object(rt);
+                  res.setProperty(rt, "status", jsi::Value(1));
+                  res.setProperty(rt, "message", jsi::String::createFromUtf8(rt, result.message.c_str()));
+                  return move(res);
+                } else {
+                  if(result.value.getObject(rt).hasProperty(rt, jsi::PropNameID::forAscii(rt, "rowsAffected")))
+                  {
+                    rowsAffected += result.value.getObject(rt).getProperty(rt, jsi::PropNameID::forAscii(rt, "rowsAffected")).asNumber();
+                  }
+                }
+              }
+            } else {
+              SequelResult result = sequel_execute(rt, dbName, query, commandParams);
+              if (result.type == SequelResultError)
+              {
+                sequel_execute(rt, dbName, "ROLLBACK", jsi::Value::undefined());
+                auto res = jsi::Object(rt);
+                res.setProperty(rt, "status", jsi::Value(1));
+                res.setProperty(rt, "message", jsi::String::createFromUtf8(rt, result.message.c_str()));
+                return move(res);
+              } else {
+                if(result.value.getObject(rt).hasProperty(rt, jsi::PropNameID::forAscii(rt, "rowsAffected")))
+                {
+                  rowsAffected += result.value.getObject(rt).getProperty(rt, jsi::PropNameID::forAscii(rt, "rowsAffected")).asNumber();
+                }
+              }
+            }
+          }
+          sequel_execute(rt, dbName, "COMMIT", jsi::Value::undefined());
+        } catch (...) {
+          sequel_execute(rt, dbName, "ROLLBACK", jsi::Value::undefined());
+        }
+        auto res = jsi::Object(rt);
+        res.setProperty(rt, "status", jsi::Value(0));
+        res.setProperty(rt, "rowsAffected", jsi::Value(rowsAffected));
+        return move(res);
+      });
+
   // Async Execute SQL
   // auto asyncExecSQL = jsi::Function::createFromHostFunction(
   //     rt,
@@ -220,6 +302,8 @@ void installSequel(jsi::Runtime &rt, const char *docPath)
   module.setProperty(rt, "delete", move(remove));
 
   module.setProperty(rt, "executeSql", move(execSQL));
+  module.setProperty(rt, "executeSqlBatch", move(execSQLBatch));
+  
   // module.setProperty(rt, "backgroundExecuteSql", move(asyncExecSQL));
 
   rt.global().setProperty(rt, "sqlite", move(module));

src/index.ts

@@ -31,6 +31,26 @@ interface QueryResult {
     item: (idx: number) => any;
   };
 }
+
+/**
+ * Allows the execution of bulk of sql commands
+ * inside a transaction
+ * If a single query must be executed many times with different arguments, its preferred
+ * to declare it a single time, and use an array of array parameters.
+ */
+ type SQLBatchParams = [string, Array<any> | Array<Array<any>> | undefined];
+
+/**
+ * status: 0 or undefined for correct execution, 1 for error
+ * message: if status === 1, here you will find error description
+ * rowsAffected: Number of affected rows if status == 0
+ */
+interface BatchExecutionResult {
+  status?: 0 | 1;
+  rowsAffected?: number;
+  message?: string;
+}
+
 interface ISQLite {
   open: (dbName: string, location?: string) => any;
   close: (dbName: string) => any;
@@ -39,6 +59,10 @@ interface ISQLite {
     query: string,
     params: any[] | undefined
   ) => QueryResult;
+  executeSqlBatch: (
+    dbName: string,
+    commands: SQLBatchParams[]
+  ) => BatchExecutionResult;
   // backgroundExecuteSql: (dbName: string, query: string, params: any[]) => any;
 }
 
@@ -57,6 +81,7 @@ interface IDBConnection {
     ok: (res: QueryResult) => void,
     fail: (msg: string) => void
   ) => void;
+  executeSqlBatch: (commands: SQLBatchParams[], callback?: (res: BatchExecutionResult) => void) => void;
   close: (ok: (res: any) => void, fail: (msg: string) => void) => void;
 }
 
@@ -89,6 +114,10 @@ export const openDatabase = (
           fail(e);
         }
       },
+      executeSqlBatch: (commands: SQLBatchParams[], callback?: (res: BatchExecutionResult) => void) => {
+        const response = sqlite.executeSqlBatch(options.name, commands);
+        if (callback) callback(response);
+      },
       close: (ok: any, fail: any) => {
         try {
           sqlite.close(options.name);