Merge branch 'sql_loader'

# Conflicts:
#	cpp/react-native-quick-sqlite.cpp
#	src/index.ts

Author: Oscar Franco

cpp/SequelResult.h

@@ -28,3 +28,10 @@ struct SequelResult
   string message;
   jsi::Value value;
 };
+
+struct SequelLiteralUpdateResult
+{
+  ResultType type;
+  string message;
+  int affectedRows;
+};

cpp/react-native-quick-sqlite.cpp

@@ -14,6 +14,8 @@
 #include <vector>
 #include <iostream>
 #include <thread>
+#include <iostream>
+#include <fstream>
 
 using namespace std;
 using namespace facebook;
@@ -177,6 +179,7 @@ void installSequel(jsi::Runtime &rt, const char *docPath)
         return move(result.value);
       });
 
+  // Execute a batch of SQL queries in a transaction
   // Parameters can be: [[sql: string, arguments: any[] | arguments: any[][] ]]
   auto execSQLBatch = jsi::Function::createFromHostFunction(
       rt,
@@ -258,6 +261,60 @@ void installSequel(jsi::Runtime &rt, const char *docPath)
         res.setProperty(rt, "rowsAffected", jsi::Value(rowsAffected));
         return move(res);
       });
+           
+  // Load SQL File from disk
+  auto loadSQLFile = jsi::Function::createFromHostFunction(
+      rt,
+      jsi::PropNameID::forAscii(rt, "sequel_loadSQLFile"),
+      2,
+      [](jsi::Runtime &rt, const jsi::Value &thisValue, const jsi::Value *args, size_t count) -> jsi::Value
+      {
+        const string dbName = args[0].asString(rt).utf8(rt);
+        const string sqlFileName = args[1].asString(rt).utf8(rt);
+        
+        string line;
+        ifstream sqFile (sqlFileName);
+        if (sqFile.is_open())
+        {
+          try {
+            int affectedRows = 0;
+            int commands = 0;
+            sequel_execute_literal_update(dbName, "BEGIN TRANSACTION");
+            while ( std::getline (sqFile, line, '\n') )
+            {
+              if (!line.empty()) {
+                SequelLiteralUpdateResult result = sequel_execute_literal_update(dbName, line);
+                if( result.type == SequelResultError ) {
+                  sequel_execute_literal_update(dbName, "ROLLBACK");
+                  auto res = jsi::Object(rt);
+                  res.setProperty(rt, "status", jsi::Value(1));
+                  res.setProperty(rt, "message", jsi::String::createFromUtf8(rt, result.message.c_str()));
+                  sqFile.close();
+                  return move(res);
+                } else {
+                  affectedRows += result.affectedRows;
+                  commands++;
+                }
+              }
+            }
+            sqFile.close();
+            sequel_execute_literal_update(dbName, "COMMIT");
+            auto res = jsi::Object(rt);
+            res.setProperty(rt, "status", jsi::Value(0));
+            res.setProperty(rt, "rowsAffected", jsi::Value(affectedRows));
+            res.setProperty(rt, "commands", jsi::Value(commands));
+            return move(res);
+          } catch (...) {
+            sqFile.close();
+            sequel_execute_literal_update(dbName, "ROLLBACK");
+            jsi::detail::throwJSError(rt, "Unexpected error, transaction was rolledback");
+            return {};
+          }
+        } else {
+          jsi::detail::throwJSError(rt, "Unable to open file");
+          return {};
+        }
+      });
 
   // Async Execute SQL
   // auto asyncExecSQL = jsi::Function::createFromHostFunction(
@@ -292,18 +349,18 @@ void installSequel(jsi::Runtime &rt, const char *docPath)
   //       return promise;
   //     });
 
-  // Create final object that will be injected into the global object
+  // Global object
   jsi::Object module = jsi::Object(rt);
 
-  // Open/Close
+
+  // Callable properties
   module.setProperty(rt, "open", move(open));
   module.setProperty(rt, "close", move(close));
   //    module.setProperty(rt, "attach", move(attach));
   module.setProperty(rt, "delete", move(remove));
-
   module.setProperty(rt, "executeSql", move(execSQL));
   module.setProperty(rt, "executeSqlBatch", move(execSQLBatch));
-  
+  module.setProperty(rt, "loadSqlFile", move(loadSQLFile));
   // module.setProperty(rt, "backgroundExecuteSql", move(asyncExecSQL));
 
   rt.global().setProperty(rt, "sqlite", move(module));

cpp/sequel.cpp

@@ -429,3 +429,79 @@ SequelResult sequel_execute(jsi::Runtime &rt, string const dbName, string const
       "",
       move(res)};
 }
+
+SequelLiteralUpdateResult sequel_execute_literal_update(string const dbName, string const &query) 
+{
+  // Check if db connection is opened
+  if (dbMap.count(dbName) == 0)
+  {
+    return {
+        SequelResultError,
+        "[react-native-quick-sqlite] Database not opened: " + dbName,
+        0
+    };
+  }
+
+  sqlite3 *db = dbMap[dbName];
+
+  // SQLite statements need to be compiled before executed
+  sqlite3_stmt *statement;
+
+  // Compile and move result into statement memory spot
+  int statementStatus = sqlite3_prepare_v2(db, query.c_str(), -1, &statement, NULL);
+
+  if (statementStatus != SQLITE_OK) // statemnet is correct, bind the passed parameters
+  {
+    const char *message = sqlite3_errmsg(db);
+    return {
+        SequelResultError,
+        "[react-native-quick-sqlite] SQL execution error: " + string(message),
+        0
+    };
+  }
+  
+  bool isConsuming = true;
+  bool isFailed = false;
+
+  int result, i, count, column_type;
+  string column_name;
+
+  while (isConsuming)
+  {
+    result = sqlite3_step(statement);
+
+    switch (result)
+    {
+      case SQLITE_ROW:
+        isConsuming = true;
+        break;
+
+      case SQLITE_DONE:
+        isConsuming = false;
+        break;
+
+      default:
+        isFailed = true;
+        isConsuming = false;
+    }
+  }
+
+  sqlite3_finalize(statement);
+
+  if (isFailed)
+  {
+    const char *message = sqlite3_errmsg(db);
+    return {
+        SequelResultError,
+        "[react-native-quick-sqlite] SQL execution error: " + string(message),
+        0
+    };
+  }
+
+  int changedRowCount = sqlite3_changes(db);
+  return {
+      SequelResultOk,
+      "",
+      changedRowCount
+  };
+}

cpp/sequel.h

@@ -24,3 +24,5 @@ SequelResult sequel_remove(string const dbName, string const docPath);
 //SequelResult sequel_attach(string const &dbName);
 
 SequelResult sequel_execute(jsi::Runtime &rt, string const dbName, string const &query, jsi::Value const &params);
+
+SequelLiteralUpdateResult sequel_execute_literal_update(string const dbName, string const &query);

src/index.ts

@@ -51,6 +51,17 @@ interface BatchQueryResult {
   message?: string;
 }
 
+/**
+ * Result of loading a file and executing every line as a SQL command
+ * Similar to BatchQueryResult
+ */
+interface FileLoadResult {
+  rowsAffected?: number;
+  commands?: number;
+  message?: string;
+  status?: 0 | 1;
+}
+
 interface ISQLite {
   open: (dbName: string, location?: string) => any;
   close: (dbName: string) => any;
@@ -63,6 +74,7 @@ interface ISQLite {
     dbName: string,
     commands: SQLBatchParams[]
   ) => BatchQueryResult;
+  loadSqlFile: (dbName: string, location: string) => FileLoadResult;
   // backgroundExecuteSql: (dbName: string, query: string, params: any[]) => any;
 }
 
@@ -86,6 +98,10 @@ interface IDBConnection {
     callback?: (res: BatchQueryResult) => void
   ) => void;
   close: (ok: (res: any) => void, fail: (msg: string) => void) => void;
+  loadSqlFile: (
+    location: string,
+    callback: (result: FileLoadResult) => void
+  ) => void;
 }
 
 export const openDatabase = (
@@ -132,6 +148,15 @@ export const openDatabase = (
           fail(e);
         }
       },
+      loadSqlFile: (
+        location: string,
+        callback: (result: FileLoadResult) => void
+      ) => {
+        const result = sqlite.loadSqlFile(options.name, location);
+        if (callback) {
+          callback(result);
+        }
+      },
     };
 
     ok(connection);