react-native-nitro-sqlite 9.6.0 → 9.8.0

package/cpp/operations.cpp

@@ -7,68 +7,131 @@
 #include <cmath>
 #include <ctime>
 #include <iostream>
+#include <limits>
 #include <map>
+#include <memory>
+#include <mutex>
 #include <optional>
 #include <sqlite3.h>
 #include <sstream>
 #include <unistd.h>
 
+#ifdef NITRO_SQLITE_VEC
+// Angle-bracket so it resolves via -I (CocoaPods intercepts quoted includes).
+#include <registerVectorExtensions.hpp>
+#endif
+
 using namespace facebook;
 using namespace margelo::nitro;
 using namespace margelo::nitro::rnnitrosqlite;
 
 namespace margelo::rnnitrosqlite {
 
-std::map<std::string, sqlite3*> dbMap = std::map<std::string, sqlite3*>();
+static constexpr double kInt64MinAsDouble = static_cast<double>(std::numeric_limits<int64_t>::min());
+static constexpr double kInt64UpperBoundAsDouble = -kInt64MinAsDouble;
+
+namespace {
+
+  std::map<std::string, SQLiteConnectionPtr> dbMap;
+  std::mutex dbMapMutex;
+  std::mutex dbLifecycleMutex;
+
+} // namespace
+
+SQLiteConnection::SQLiteConnection(std::string connectionName, sqlite3* database) : name(std::move(connectionName)), database(database) {}
+
+SQLiteConnection::~SQLiteConnection() {
+  close();
+}
+
+void SQLiteConnection::close() noexcept {
+  std::lock_guard lock(mutex);
+  if (database == nullptr) {
+    return;
+  }
+
+  sqlite3_close_v2(database);
+  database = nullptr;
+}
 
 void sqliteOpenDb(const std::string& dbName, const std::string& docPath) {
+  std::lock_guard lifecycleLock(dbLifecycleMutex);
+  {
+    std::lock_guard lock(dbMapMutex);
+    if (dbMap.contains(dbName)) {
+      throw NitroSQLiteException::DatabaseAlreadyOpen(dbName);
+    }
+  }
+
+#ifdef NITRO_SQLITE_VEC
+  // Register before opening so the connection exposes vec0 + vec_*.
+  margelo::rnnitrosqlitevec::registerVectorExtensions();
+#endif
+
   std::string dbPath = get_db_path(dbName, docPath);
 
   int sqlOpenFlags = SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_FULLMUTEX;
 
-  sqlite3* db;
-  int exit = 0;
-  exit = sqlite3_open_v2(dbPath.c_str(), &db, sqlOpenFlags, nullptr);
+  sqlite3* rawDatabase = nullptr;
+  const int openStatus = sqlite3_open_v2(dbPath.c_str(), &rawDatabase, sqlOpenFlags, nullptr);
+  std::unique_ptr<sqlite3, decltype(&sqlite3_close_v2)> database(rawDatabase, sqlite3_close_v2);
+
+  if (openStatus != SQLITE_OK) {
+    const std::string errorMessage = rawDatabase == nullptr ? sqlite3_errstr(openStatus) : sqlite3_errmsg(rawDatabase);
+    throw NitroSQLiteException(NitroSQLiteExceptionType::DatabaseCannotBeOpened, errorMessage);
+  }
 
-  if (exit != SQLITE_OK) {
-    throw NitroSQLiteException(NitroSQLiteExceptionType::DatabaseCannotBeOpened, sqlite3_errmsg(db));
-  } else {
-    dbMap[dbName] = db;
+  auto connection = std::make_shared<SQLiteConnection>(dbName, database.get());
+  database.release();
+  {
+    std::lock_guard lock(dbMapMutex);
+    const bool inserted = dbMap.emplace(dbName, connection).second;
+    if (!inserted) {
+      throw NitroSQLiteException::DatabaseAlreadyOpen(dbName);
+    }
   }
 }
 
 void sqliteCloseDb(const std::string& dbName) {
+  std::lock_guard lifecycleLock(dbLifecycleMutex);
+  SQLiteConnectionPtr connection;
+  {
+    std::lock_guard lock(dbMapMutex);
+    auto iterator = dbMap.find(dbName);
+    if (iterator == dbMap.end()) {
+      throw NitroSQLiteException::DatabaseNotOpen(dbName);
+    }
 
-  if (dbMap.count(dbName) == 0) {
-    throw NitroSQLiteException::DatabaseNotOpen(dbName);
+    connection = std::move(iterator->second);
+    dbMap.erase(iterator);
   }
 
-  sqlite3* db = dbMap[dbName];
-
-  sqlite3_close_v2(db);
-
-  dbMap.erase(dbName);
+  connection->close();
 }
 
 void sqliteCloseAll() {
-  for (auto const& x : dbMap) {
-    // In certain cases, this will return SQLITE_OK, mark the database connection as an unusable "zombie",
-    // and deallocate the connection later.
-    sqlite3_close_v2(x.second);
+  std::lock_guard lifecycleLock(dbLifecycleMutex);
+  std::map<std::string, SQLiteConnectionPtr> connections;
+  {
+    std::lock_guard lock(dbMapMutex);
+    connections.swap(dbMap);
+  }
+
+  for (const auto& [_, connection] : connections) {
+    connection->close();
   }
-  dbMap.clear();
 }
 
 void sqliteAttachDb(const std::string& mainDBName, const std::string& docPath, const std::string& databaseToAttach,
                     const std::string& alias) {
   /**
-   * There is no need to check if mainDBName is opened because sqliteExecuteLiteral will do that.
+   * There is no need to check if mainDBName is opened because sqliteExecuteCommand will do that.
    * */
   std::string dbPath = get_db_path(databaseToAttach, docPath);
   std::string statement = "ATTACH DATABASE '" + dbPath + "' AS " + alias;
 
   try {
-    sqliteExecuteLiteral(mainDBName, statement);
+    sqliteExecuteCommand(mainDBName, statement);
   } catch (NitroSQLiteException& e) {
     throw NitroSQLiteException(NitroSQLiteExceptionType::UnableToAttachToDatabase,
                                mainDBName + " was unable to attach another database: " + std::string(e.what()));
@@ -77,12 +140,12 @@ void sqliteAttachDb(const std::string& mainDBName, const std::string& docPath, c
 
 void sqliteDetachDb(const std::string& mainDBName, const std::string& alias) {
   /**
-   * There is no need to check if mainDBName is opened because sqliteExecuteLiteral will do that.
+   * There is no need to check if mainDBName is opened because sqliteExecuteCommand will do that.
    * */
   std::string statement = "DETACH DATABASE " + alias;
 
   try {
-    sqliteExecuteLiteral(mainDBName, statement);
+    sqliteExecuteCommand(mainDBName, statement);
   } catch (NitroSQLiteException& e) {
     throw NitroSQLiteException(NitroSQLiteExceptionType::UnableToAttachToDatabase,
                                mainDBName + " was unable to detach database: " + std::string(e.what()));
@@ -90,15 +153,26 @@ void sqliteDetachDb(const std::string& mainDBName, const std::string& alias) {
 }
 
 void sqliteRemoveDb(const std::string& dbName, const std::string& docPath) {
-  if (dbMap.count(dbName) == 1) {
-    sqliteCloseDb(dbName);
-  }
-
-  std::string dbFilePath = get_db_path(dbName, docPath);
+  std::lock_guard lifecycleLock(dbLifecycleMutex);
+  const std::string dbFilePath = get_db_path(dbName, docPath);
   if (!file_exists(dbFilePath)) {
     throw NitroSQLiteException::DatabaseFileNotFound(dbFilePath);
   }
 
+  SQLiteConnectionPtr connection;
+  {
+    std::lock_guard lock(dbMapMutex);
+    auto iterator = dbMap.find(dbName);
+    if (iterator != dbMap.end()) {
+      connection = std::move(iterator->second);
+      dbMap.erase(iterator);
+    }
+  }
+
+  if (connection) {
+    connection->close();
+  }
+
   remove(dbFilePath.c_str());
 }
 
@@ -111,7 +185,13 @@ void bindStatement(sqlite3_stmt* statement, const SQLiteQueryParams& values) {
     } else if (std::holds_alternative<bool>(value)) {
       sqlite3_bind_int(statement, sqliteIndex, std::get<bool>(value));
     } else if (std::holds_alternative<double>(value)) {
-      sqlite3_bind_double(statement, sqliteIndex, std::get<double>(value));
+      // Bind whole numbers as INTEGER so vec0 rowid/pk/partition (which reject REAL) work; SQLite still coerces to REAL for REAL columns.
+      double doubleValue = std::get<double>(value);
+      if (std::trunc(doubleValue) == doubleValue && doubleValue >= kInt64MinAsDouble && doubleValue < kInt64UpperBoundAsDouble) {
+        sqlite3_bind_int64(statement, sqliteIndex, static_cast<sqlite3_int64>(doubleValue));
+      } else {
+        sqlite3_bind_double(statement, sqliteIndex, doubleValue);
+      }
     } else if (std::holds_alternative<std::string>(value)) {
       const auto stringValue = std::get<std::string>(value);
       sqlite3_bind_text(statement, sqliteIndex, stringValue.c_str(), stringValue.length(), SQLITE_TRANSIENT);
@@ -122,173 +202,157 @@ void bindStatement(sqlite3_stmt* statement, const SQLiteQueryParams& values) {
   }
 }
 
-std::shared_ptr<HybridNitroSQLiteQueryResult> sqliteExecute(const std::string& dbName, const std::string& query,
-                                                            const std::optional<SQLiteQueryParams>& params) {
-  if (dbMap.count(dbName) == 0) {
-    throw NitroSQLiteException::DatabaseNotOpen(dbName);
-  }
+namespace {
 
-  auto db = dbMap[dbName];
+  struct SQLiteStatementFinalizer {
+    void operator()(sqlite3_stmt* statement) const noexcept {
+      if (statement != nullptr) {
+        sqlite3_finalize(statement);
+      }
+    }
+  };
+
+  using SQLiteStatement = std::unique_ptr<sqlite3_stmt, SQLiteStatementFinalizer>;
+
+  SQLiteStatement prepareStatement(sqlite3* db, const std::string& query, const std::optional<SQLiteQueryParams>& params) {
+    sqlite3_stmt* rawStatement = nullptr;
+    int statementStatus = sqlite3_prepare_v2(db, query.c_str(), -1, &rawStatement, nullptr);
+    SQLiteStatement statement(rawStatement);
+
+    if (statementStatus != SQLITE_OK) {
+      throw NitroSQLiteException::SqlExecution(sqlite3_errmsg(db));
+    }
 
-  sqlite3_stmt* statement;
-  int statementStatus = sqlite3_prepare_v2(db, query.c_str(), -1, &statement, NULL);
-  if (statementStatus == SQLITE_OK) // statement is correct, bind the passed parameters
-  {
     if (params) {
-      bindStatement(statement, *params);
+      bindStatement(statement.get(), *params);
     }
-  } else {
-    throw NitroSQLiteException::SqlExecution(sqlite3_errmsg(db));
+
+    return statement;
   }
 
-  auto isConsuming = true;
-  auto isFailed = false;
+  template <typename OnRow>
+  void consumeStatement(sqlite3* db, sqlite3_stmt* statement, OnRow&& onRow) {
+    while (true) {
+      int result = sqlite3_step(statement);
 
-  int result, i, count, column_type;
-  std::string column_name;
-  ColumnType column_declared_type;
-  SQLiteQueryResultRow row;
-  SQLiteQueryResults results;
-  std::optional<SQLiteQueryTableMetadata> metadata = std::nullopt;
+      if (result == SQLITE_ROW) {
+        onRow(statement);
+        continue;
+      }
 
-  while (isConsuming) {
-    result = sqlite3_step(statement);
-
-    switch (result) {
-      case SQLITE_ROW:
-        i = 0;
-        row = std::unordered_map<std::string, SQLiteValue>();
-        count = sqlite3_column_count(statement);
-
-        while (i < count) {
-          column_type = sqlite3_column_type(statement, i);
-          column_name = sqlite3_column_name(statement, i);
-          switch (column_type) {
-
-            case SQLITE_INTEGER: {
-              auto column_value = sqlite3_column_double(statement, i);
-              row[column_name] = column_value;
-              break;
-            }
-            case SQLITE_FLOAT: {
-              auto column_value = sqlite3_column_double(statement, i);
-              row[column_name] = column_value;
-              break;
-            }
-            case SQLITE_TEXT: {
-              auto column_value = reinterpret_cast<const char*>(sqlite3_column_text(statement, i));
-              sqlite3_column_bytes(statement, i);
-              row[column_name] = column_value;
-              break;
-            }
-            case SQLITE_BLOB: {
-              int blob_size = sqlite3_column_bytes(statement, i);
-              const void* blob = sqlite3_column_blob(statement, i);
-              // Copy the SQLite BLOB into a new native ArrayBuffer.
-              // This avoids manual memory management and unsafe pointer handling.
-              if (blob_size > 0) {
-                const auto* blob_data = reinterpret_cast<const uint8_t*>(blob);
-                row[column_name] = ArrayBuffer::copy(blob_data, static_cast<size_t>(blob_size));
-              } else {
-                // Represent empty BLOBs as an empty, but valid, ArrayBuffer.
-                row[column_name] = ArrayBuffer::allocate(0);
-              }
-              break;
-            }
-            case SQLITE_NULL:
-              // Intentionally left blank to switch to default case
-            default:
-              row[column_name] = NullType::null;
-              break;
-          }
-          i++;
-        }
-        results.push_back(std::move(row));
-        break;
-      case SQLITE_DONE:
-        i = 0;
-        count = sqlite3_column_count(statement);
-        while (i < count) {
-          column_name = sqlite3_column_name(statement, i);
-          const char* tp = sqlite3_column_decltype(statement, i);
-          column_declared_type = mapSQLiteTypeToColumnType(tp);
-          auto columnMeta = NitroSQLiteQueryColumnMetadata(std::move(column_name), std::move(column_declared_type), i);
-
-          if (!metadata) {
-            metadata = std::make_optional<SQLiteQueryTableMetadata>();
-          }
-          metadata->insert({column_name, columnMeta});
-          i++;
-        }
-        isConsuming = false;
-        break;
-      default:
-        isFailed = true;
-        isConsuming = false;
+      if (result == SQLITE_DONE) {
+        return;
+      }
+
+      throw NitroSQLiteException::SqlExecution(sqlite3_errmsg(db));
     }
   }
 
-  sqlite3_finalize(statement);
+} // namespace
 
-  if (isFailed) {
-    throw NitroSQLiteException::SqlExecution(sqlite3_errmsg(db));
+SQLiteConnectionPtr sqliteGetOpenDatabase(const std::string& dbName) {
+  std::lock_guard lock(dbMapMutex);
+  auto iterator = dbMap.find(dbName);
+  if (iterator == dbMap.end()) {
+    throw NitroSQLiteException::DatabaseNotOpen(dbName);
   }
 
-  int rowsAffected = sqlite3_changes(db);
-  long long latestInsertRowId = sqlite3_last_insert_rowid(db);
-  return std::make_shared<HybridNitroSQLiteQueryResult>(results, static_cast<double>(latestInsertRowId), rowsAffected, metadata);
+  return iterator->second;
 }
 
-SQLiteOperationResult sqliteExecuteLiteral(const std::string& dbName, const std::string& query) {
-  // Check if db connection is opened
-  if (dbMap.count(dbName) == 0) {
-    throw NitroSQLiteException::DatabaseNotOpen(dbName);
+std::shared_ptr<HybridNitroSQLiteQueryResult> sqliteExecute(const std::string& dbName, const std::string& query,
+                                                            const std::optional<SQLiteQueryParams>& params) {
+  return sqliteExecute(sqliteGetOpenDatabase(dbName), query, params);
+}
+
+std::shared_ptr<HybridNitroSQLiteQueryResult> sqliteExecute(const SQLiteConnectionPtr& connection, const std::string& query,
+                                                            const std::optional<SQLiteQueryParams>& params) {
+  std::lock_guard lock(connection->mutex);
+  sqlite3* db = connection->database;
+  if (db == nullptr) {
+    throw NitroSQLiteException::DatabaseNotOpen(connection->name);
   }
 
-  sqlite3* db = dbMap[dbName];
+  auto statement = prepareStatement(db, query, params);
+  SQLiteQueryResults results;
 
-  // SQLite statements need to be compiled before executed
-  sqlite3_stmt* statement;
+  consumeStatement(db, statement.get(), [&](sqlite3_stmt* currentStatement) {
+    SQLiteQueryResultRow row;
+    int count = sqlite3_column_count(currentStatement);
+
+    for (int i = 0; i < count; i++) {
+      int columnType = sqlite3_column_type(currentStatement, i);
+      std::string columnName = sqlite3_column_name(currentStatement, i);
+
+      switch (columnType) {
+        case SQLITE_INTEGER:
+        case SQLITE_FLOAT:
+          row[columnName] = sqlite3_column_double(currentStatement, i);
+          break;
+        case SQLITE_TEXT: {
+          auto columnValue = reinterpret_cast<const char*>(sqlite3_column_text(currentStatement, i));
+          row[columnName] = columnValue;
+          break;
+        }
+        case SQLITE_BLOB: {
+          int blobSize = sqlite3_column_bytes(currentStatement, i);
+          const void* blob = sqlite3_column_blob(currentStatement, i);
+          if (blobSize > 0) {
+            const auto* blobData = reinterpret_cast<const uint8_t*>(blob);
+            row[columnName] = ArrayBuffer::copy(blobData, static_cast<size_t>(blobSize));
+          } else {
+            row[columnName] = ArrayBuffer::allocate(0);
+          }
+          break;
+        }
+        case SQLITE_NULL:
+        default:
+          row[columnName] = NullType::null;
+          break;
+      }
+    }
 
-  // Compile and move result into statement memory spot
-  int statementStatus = sqlite3_prepare_v2(db, query.c_str(), -1, &statement, NULL);
+    results.push_back(std::move(row));
+  });
 
-  if (statementStatus != SQLITE_OK) // statemnet is correct, bind the passed parameters
-  {
-    throw NitroSQLiteException::SqlExecution(sqlite3_errmsg(db));
+  std::optional<SQLiteQueryTableMetadata> metadata = std::nullopt;
+  int count = sqlite3_column_count(statement.get());
+  for (int i = 0; i < count; i++) {
+    std::string columnName = sqlite3_column_name(statement.get(), i);
+    ColumnType columnDeclaredType = mapSQLiteTypeToColumnType(sqlite3_column_decltype(statement.get(), i));
+    auto columnMeta = NitroSQLiteQueryColumnMetadata(columnName, std::move(columnDeclaredType), i);
+
+    if (!metadata) {
+      metadata = std::make_optional<SQLiteQueryTableMetadata>();
+    }
+    metadata->insert({columnName, std::move(columnMeta)});
   }
 
-  bool isConsuming = true;
-  bool isFailed = false;
-
-  int result;
-  std::string column_name;
-
-  while (isConsuming) {
-    result = sqlite3_step(statement);
-
-    switch (result) {
-      case SQLITE_ROW:
-        isConsuming = true;
-        break;
+  int rowsAffected = sqlite3_changes(db);
+  long long latestInsertRowId = sqlite3_last_insert_rowid(db);
+  return std::make_shared<HybridNitroSQLiteQueryResult>(std::move(results), static_cast<double>(latestInsertRowId), rowsAffected,
+                                                        std::move(metadata));
+}
 
-      case SQLITE_DONE:
-        isConsuming = false;
-        break;
+SQLiteOperationResult sqliteExecuteCommand(const std::string& dbName, const std::string& query,
+                                           const std::optional<SQLiteQueryParams>& params) {
+  return sqliteExecuteCommand(sqliteGetOpenDatabase(dbName), query, params);
+}
 
-      default:
-        isFailed = true;
-        isConsuming = false;
-    }
+SQLiteOperationResult sqliteExecuteCommand(const SQLiteConnectionPtr& connection, const std::string& query,
+                                           const std::optional<SQLiteQueryParams>& params) {
+  std::lock_guard lock(connection->mutex);
+  sqlite3* db = connection->database;
+  if (db == nullptr) {
+    throw NitroSQLiteException::DatabaseNotOpen(connection->name);
   }
 
-  sqlite3_finalize(statement);
+  auto statement = prepareStatement(db, query, params);
+  bool isReadOnly = sqlite3_stmt_readonly(statement.get()) != 0;
 
-  if (isFailed) {
-    throw NitroSQLiteException::SqlExecution(sqlite3_errmsg(db));
-  }
+  consumeStatement(db, statement.get(), [](sqlite3_stmt*) {});
 
-  return {.rowsAffected = sqlite3_changes(db)};
+  return {.rowsAffected = isReadOnly ? 0 : sqlite3_changes(db)};
 }
 
 } // namespace margelo::rnnitrosqlite

package/cpp/operations.hpp

@@ -2,9 +2,32 @@
 
 #include "hybridObjects/HybridNitroSQLiteQueryResult.hpp"
 #include "types.hpp"
+#include <memory>
+#include <mutex>
+#include <sqlite3.h>
+#include <string>
 
 namespace margelo::rnnitrosqlite {
 
+// Calls against one connection are serialized by `mutex`. Separate connections
+// intentionally remain independent, so SQLITE_THREADSAFE=0 still requires the
+// caller to serialize SQLite calls globally.
+struct SQLiteConnection final {
+  SQLiteConnection(std::string name, sqlite3* database);
+  ~SQLiteConnection();
+
+  SQLiteConnection(const SQLiteConnection&) = delete;
+  SQLiteConnection& operator=(const SQLiteConnection&) = delete;
+
+  void close() noexcept;
+
+  const std::string name;
+  sqlite3* database;
+  std::recursive_mutex mutex;
+};
+
+using SQLiteConnectionPtr = std::shared_ptr<SQLiteConnection>;
+
 void sqliteOpenDb(const std::string& dbName, const std::string& docPath);
 
 void sqliteCloseDb(const std::string& dbName);
@@ -16,10 +39,17 @@ void sqliteAttachDb(const std::string& mainDBName, const std::string& docPath, c
 
 void sqliteDetachDb(const std::string& mainDBName, const std::string& alias);
 
+SQLiteConnectionPtr sqliteGetOpenDatabase(const std::string& dbName);
+
 std::shared_ptr<HybridNitroSQLiteQueryResult> sqliteExecute(const std::string& dbName, const std::string& query,
                                                             const std::optional<SQLiteQueryParams>& params);
+std::shared_ptr<HybridNitroSQLiteQueryResult> sqliteExecute(const SQLiteConnectionPtr& connection, const std::string& query,
+                                                            const std::optional<SQLiteQueryParams>& params);
 
-SQLiteOperationResult sqliteExecuteLiteral(const std::string& dbName, const std::string& query);
+SQLiteOperationResult sqliteExecuteCommand(const std::string& dbName, const std::string& query,
+                                           const std::optional<SQLiteQueryParams>& params = std::nullopt);
+SQLiteOperationResult sqliteExecuteCommand(const SQLiteConnectionPtr& connection, const std::string& query,
+                                           const std::optional<SQLiteQueryParams>& params = std::nullopt);
 
 void sqliteCloseAll();
 

package/cpp/sqliteExecuteBatch.cpp

@@ -33,6 +33,11 @@ std::vector<BatchQuery> batchParamsToCommands(const std::vector<BatchQueryComman
 }
 
 SQLiteOperationResult sqliteExecuteBatch(const std::string& dbName, const std::vector<BatchQuery>& commands) {
+  return sqliteExecuteBatch(sqliteGetOpenDatabase(dbName), commands);
+}
+
+SQLiteOperationResult sqliteExecuteBatch(const SQLiteConnectionPtr& connection, const std::vector<BatchQuery>& commands) {
+  std::lock_guard lock(connection->mutex);
   size_t commandCount = commands.size();
   if (commandCount <= 0) {
     throw NitroSQLiteException(NitroSQLiteExceptionType::NoBatchCommandsProvided, "No SQL batch commands provided");
@@ -40,28 +45,24 @@ SQLiteOperationResult sqliteExecuteBatch(const std::string& dbName, const std::v
 
   try {
     int rowsAffected = 0;
-    sqliteExecuteLiteral(dbName, "BEGIN EXCLUSIVE TRANSACTION");
-    for (int i = 0; i < commandCount; i++) {
-      const auto command = commands.at(i);
-
-      // We do not provide a datas tructure to receive query data because we don't need/want to handle this results in a batch execution
-      auto results = SQLiteQueryResults();
-      auto metadata = std::optional<SQLiteQueryTableMetadata>(std::nullopt);
-      try {
-        auto result = sqliteExecute(dbName, command.sql, command.params);
-        rowsAffected += result->getRowsAffected();
-      } catch (NitroSQLiteException& e) {
-        sqliteExecuteLiteral(dbName, "ROLLBACK");
-        throw e;
-      }
+    sqliteExecuteCommand(connection, "BEGIN EXCLUSIVE TRANSACTION");
+    for (const auto& command : commands) {
+      auto result = sqliteExecuteCommand(connection, command.sql, command.params);
+      rowsAffected += result.rowsAffected;
     }
-    sqliteExecuteLiteral(dbName, "COMMIT");
+
+    sqliteExecuteCommand(connection, "COMMIT");
     return {
         .rowsAffected = rowsAffected,
         .commands = (int)commandCount,
     };
   } catch (NitroSQLiteException& e) {
-    sqliteExecuteLiteral(dbName, "ROLLBACK");
+    // Roll back exactly once; a failed ROLLBACK must not mask the original error.
+    try {
+      sqliteExecuteCommand(connection, "ROLLBACK");
+    } catch (...) {
+      // ignore — surface the original error below
+    }
     throw e;
   }
 }

package/cpp/sqliteExecuteBatch.hpp

@@ -5,12 +5,15 @@
 
 #include "BatchQueryCommand.hpp"
 #include "types.hpp"
+#include <memory>
 
 using namespace facebook;
 using namespace margelo::nitro;
 
 namespace margelo::rnnitrosqlite {
 
+struct SQLiteConnection;
+
 struct BatchQuery {
   std::string sql;
   std::optional<SQLiteQueryParams> params;
@@ -26,5 +29,6 @@ std::vector<BatchQuery> batchParamsToCommands(const std::vector<BatchQueryComman
  * Execute a batch of commands in a exclusive transaction
  */
 SQLiteOperationResult sqliteExecuteBatch(const std::string& dbName, const std::vector<BatchQuery>& commands);
+SQLiteOperationResult sqliteExecuteBatch(const std::shared_ptr<SQLiteConnection>& connection, const std::vector<BatchQuery>& commands);
 
 } // namespace margelo::rnnitrosqlite

package/ios/OnLoad.mm

@@ -30,9 +30,32 @@ using namespace margelo::nitro::rnnitrosqlite;
 
     documentPath = [storeUrl path];
   } else {
-    // Get iOS app's document directory (to safely store database .sqlite3 file)
-    NSArray *paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, true);
-    documentPath = [paths objectAtIndex:0];
+    NSString *databaseLocation = [[NSBundle mainBundle] objectForInfoDictionaryKey:@"RNNitroSQLite_DatabaseLocation"];
+
+    if ([databaseLocation isEqualToString:@"ApplicationSupport"]) {
+      // Library/Application Support is persistent, backed up, and never exposed to the user
+      // via the Files app (unlike the Documents directory, which becomes user-visible when
+      // the app enables file sharing).
+      NSArray *paths = NSSearchPathForDirectoriesInDomains(NSApplicationSupportDirectory, NSUserDomainMask, true);
+      documentPath = [paths objectAtIndex:0];
+
+      NSFileManager *fileManager = [NSFileManager defaultManager];
+      if (![fileManager fileExistsAtPath:documentPath]) {
+        [fileManager createDirectoryAtPath:documentPath withIntermediateDirectories:YES attributes:nil error:nil];
+      }
+
+      // Databases created before this option was enabled still live in Documents; each one is
+      // moved over when it is opened (see HybridNitroSQLite::open).
+      NSString *documentsDirectory = [NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, true) objectAtIndex:0];
+      HybridNitroSQLite::migrationDocPath = [documentsDirectory UTF8String];
+    } else {
+      if (databaseLocation != nil && ![databaseLocation isEqualToString:@"Documents"]) {
+        NSLog(@"Invalid RNNitroSQLite_DatabaseLocation value provided (%@). Supported values are \"Documents\" and \"ApplicationSupport\". Falling back to \"Documents\".", databaseLocation);
+      }
+      // Get iOS app's document directory (to safely store database .sqlite3 file)
+      NSArray *paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, true);
+      documentPath = [paths objectAtIndex:0];
+    }
   }
 
   HybridNitroSQLite::docPath = [documentPath UTF8String];