react-native-nitro-sqlite 9.8.1 → 10.0.0

package/cpp/NitroSQLiteOperations.cpp

@@ -0,0 +1,396 @@
+#include "NitroSQLiteOperations.hpp"
+#include "NitroSQLiteException.hpp"
+#include "NitroSQLiteLogs.hpp"
+#include "NitroSQLiteUtils.hpp"
+#include "hybridObjects/HybridNitroSQLiteQueryResult.hpp"
+#include <NitroModules/ArrayBuffer.hpp>
+#include <NitroModules/Promise.hpp>
+#include <cmath>
+#include <ctime>
+#include <exception>
+#include <iostream>
+#include <limits>
+#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 <NitroSQLiteVecRegisterVectorExtensions.hpp>
+#endif
+
+using namespace facebook;
+
+namespace margelo::nitro::rnnitrosqlite {
+
+static constexpr double kInt64MinAsDouble = static_cast<double>(std::numeric_limits<int64_t>::min());
+static constexpr double kInt64UpperBoundAsDouble = -kInt64MinAsDouble;
+
+void SQLiteConnection::enqueueAsync(std::function<void()> operation) {
+  std::lock_guard lock(asyncQueueMutex);
+  if (!asyncWorkerRunning) {
+    Promise<void>::async([connection = shared_from_this()] { connection->drainAsync(); });
+    asyncWorkerRunning = true;
+  }
+  asyncQueue.push(std::move(operation));
+}
+
+void SQLiteConnection::drainAsync() {
+  while (true) {
+    std::function<void()> operation;
+    {
+      std::lock_guard lock(asyncQueueMutex);
+      if (asyncQueue.empty()) {
+        asyncWorkerRunning = false;
+        return;
+      }
+      operation = std::move(asyncQueue.front());
+      asyncQueue.pop();
+    }
+    try {
+      operation();
+    } catch (const std::exception& error) {
+      LOGE("Async operation on database %s failed while settling its promise: %s", name.c_str(), error.what());
+    } catch (...) {
+      LOGE("Async operation on database %s failed while settling its promise", name.c_str());
+    }
+  }
+}
+
+void sqliteOpenDb(const std::string& dbName, const std::string& docPath, bool readOnly) {
+#ifdef NITRO_SQLITE_VEC
+  // Register before opening so the connection exposes vec0 + vec_*.
+  margelo::rnnitrosqlitevec::registerVectorExtensions();
+#endif
+  const std::string dbPath = readOnly ? docPath + "/" + dbName : get_db_path(dbName, docPath);
+  databaseConnections().open(dbName, dbPath, readOnly);
+}
+
+std::string sqliteOpenConnection(const std::string& dbName, const std::string& docPath, bool readOnly) {
+  if (sqlite3_threadsafe() == 0) {
+    throw NitroSQLiteException(NitroSQLiteExceptionType::DatabaseCannotBeOpened,
+                               "Independent connections require a thread-safe SQLite build");
+  }
+#ifdef NITRO_SQLITE_VEC
+  margelo::rnnitrosqlitevec::registerVectorExtensions();
+#endif
+  const std::string dbPath = readOnly ? docPath + "/" + dbName : get_db_path(dbName, docPath);
+  return databaseConnections().openIndependent(dbPath, readOnly);
+}
+
+void sqliteCloseDb(const std::string& dbName) {
+  databaseConnections().close(dbName);
+}
+
+void sqliteCloseAll() {
+  databaseConnections().closeAll();
+}
+
+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 sqliteExecuteCommand will do that.
+   * */
+  std::string dbPath = get_db_path(databaseToAttach, docPath);
+  std::string statement = "ATTACH DATABASE '" + dbPath + "' AS " + alias;
+
+  try {
+    sqliteExecuteCommand(mainDBName, statement);
+  } catch (NitroSQLiteException& e) {
+    throw NitroSQLiteException(NitroSQLiteExceptionType::UnableToAttachToDatabase,
+                               mainDBName + " was unable to attach another database: " + std::string(e.what()));
+  }
+}
+
+void sqliteDetachDb(const std::string& mainDBName, const std::string& alias) {
+  /**
+   * There is no need to check if mainDBName is opened because sqliteExecuteCommand will do that.
+   * */
+  std::string statement = "DETACH DATABASE " + alias;
+
+  try {
+    sqliteExecuteCommand(mainDBName, statement);
+  } catch (NitroSQLiteException& e) {
+    throw NitroSQLiteException(NitroSQLiteExceptionType::UnableToAttachToDatabase,
+                               mainDBName + " was unable to detach database: " + std::string(e.what()));
+  }
+}
+
+void sqliteRemoveDb(const std::string& dbName, const std::string& docPath, const std::optional<std::string>& connectionId,
+                    const std::optional<std::string>& otherDocPath) {
+  std::optional<std::filesystem::path> otherPath;
+  if (otherDocPath) {
+    otherPath = std::filesystem::path(*otherDocPath) / dbName;
+  }
+  databaseConnections().drop(dbName, std::filesystem::path(docPath) / dbName, connectionId, otherPath);
+}
+
+void bindStatement(sqlite3_stmt* statement, const SQLiteQueryParams& values) {
+  for (size_t valueIndex = 0; valueIndex < values.size(); valueIndex++) {
+    int sqliteIndex = valueIndex + 1;
+    const SQLiteValue& value = values.at(valueIndex);
+    int bindStatus = SQLITE_OK;
+
+    if (std::holds_alternative<NullType>(value)) {
+      bindStatus = sqlite3_bind_null(statement, sqliteIndex);
+    } else if (std::holds_alternative<bool>(value)) {
+      bindStatus = sqlite3_bind_int(statement, sqliteIndex, std::get<bool>(value));
+    } else if (std::holds_alternative<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) {
+        bindStatus = sqlite3_bind_int64(statement, sqliteIndex, static_cast<sqlite3_int64>(doubleValue));
+      } else {
+        bindStatus = sqlite3_bind_double(statement, sqliteIndex, doubleValue);
+      }
+    } else if (std::holds_alternative<std::string>(value)) {
+      const auto& stringValue = std::get<std::string>(value);
+      bindStatus = sqlite3_bind_text(statement, sqliteIndex, stringValue.c_str(), stringValue.length(), SQLITE_TRANSIENT);
+    } else if (std::holds_alternative<std::shared_ptr<ArrayBuffer>>(value)) {
+      const auto& arrayBufferValue = std::get<std::shared_ptr<ArrayBuffer>>(value);
+      bindStatus = sqlite3_bind_blob(statement, sqliteIndex, arrayBufferValue->data(), arrayBufferValue->size(), SQLITE_TRANSIENT);
+    }
+
+    if (bindStatus != SQLITE_OK) {
+      throw NitroSQLiteException::SqlExecution(sqlite3_errmsg(sqlite3_db_handle(statement)));
+    }
+  }
+}
+
+namespace {
+
+  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_prepare_v2 reports SQLITE_OK with a null statement when the query holds no SQL,
+    // such as an empty string or nothing but comments.
+    if (!statement) {
+      throw NitroSQLiteException::SqlExecution("Query does not contain any SQL statement");
+    }
+
+    if (params) {
+      bindStatement(statement.get(), *params);
+    }
+
+    return statement;
+  }
+
+  template <typename OnRow>
+  void consumeStatement(sqlite3* db, sqlite3_stmt* statement, OnRow&& onRow) {
+    while (true) {
+      int result = sqlite3_step(statement);
+
+      if (result == SQLITE_ROW) {
+        onRow(statement);
+        continue;
+      }
+
+      if (result == SQLITE_DONE) {
+        return;
+      }
+
+      throw NitroSQLiteException::SqlExecution(sqlite3_errmsg(db));
+    }
+  }
+
+  std::shared_ptr<HybridNitroSQLiteQueryResult> executeStatement(sqlite3* db, sqlite3_stmt* statement) {
+    SQLiteQueryResults results;
+
+    consumeStatement(db, statement, [&](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;
+        }
+      }
+
+      results.push_back(std::move(row));
+    });
+
+    std::optional<SQLiteQueryTableMetadata> metadata = std::nullopt;
+    int count = sqlite3_column_count(statement);
+    for (int i = 0; i < count; i++) {
+      std::string columnName = sqlite3_column_name(statement, i);
+      ColumnType columnDeclaredType = mapSQLiteTypeToColumnType(sqlite3_column_decltype(statement, i));
+      auto columnMeta = NitroSQLiteQueryColumnMetadata(columnName, std::move(columnDeclaredType), i);
+
+      if (!metadata) {
+        metadata = std::make_optional<SQLiteQueryTableMetadata>();
+      }
+      metadata->insert({columnName, std::move(columnMeta)});
+    }
+
+    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));
+  }
+
+} // namespace
+
+SQLiteConnectionPtr sqliteGetOpenDatabase(const std::string& dbName) {
+  return databaseConnections().get(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);
+  }
+
+  auto statement = prepareStatement(db, query, params);
+  return executeStatement(db, statement.get());
+}
+
+SQLiteOperationResult sqliteExecuteCommand(const std::string& dbName, const std::string& query,
+                                           const std::optional<SQLiteQueryParams>& params) {
+  return sqliteExecuteCommand(sqliteGetOpenDatabase(dbName), query, params);
+}
+
+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);
+  }
+
+  auto statement = prepareStatement(db, query, params);
+  bool isReadOnly = sqlite3_stmt_readonly(statement.get()) != 0;
+
+  consumeStatement(db, statement.get(), [](sqlite3_stmt*) {});
+
+  return {.rowsAffected = isReadOnly ? 0 : sqlite3_changes(db)};
+}
+
+struct SQLitePreparedStatement::State {
+  State(SQLiteConnectionPtr connection, SQLiteStatement statement) : connection(std::move(connection)), statement(std::move(statement)) {}
+
+  SQLiteConnectionPtr connection;
+  SQLiteStatement statement;
+  mutable std::mutex mutex;
+};
+
+SQLitePreparedStatement::SQLitePreparedStatement(std::shared_ptr<State> state) : _state(std::move(state)) {}
+
+SQLitePreparedStatement::~SQLitePreparedStatement() {
+  finalize();
+}
+
+std::shared_ptr<HybridNitroSQLiteQueryResult> SQLitePreparedStatement::execute(const std::optional<SQLiteQueryParams>& params) {
+  std::lock_guard lock(_state->mutex);
+  std::lock_guard connectionLock(_state->connection->mutex);
+
+  if (!_state->statement) {
+    throw NitroSQLiteException("Prepared statement has been finalized");
+  }
+
+  sqlite3* database = _state->connection->database;
+  if (database == nullptr) {
+    throw NitroSQLiteException("Prepared statement belongs to a closed database connection");
+  }
+
+  int resetStatus = sqlite3_reset(_state->statement.get());
+  if (resetStatus != SQLITE_OK) {
+    throw NitroSQLiteException::SqlExecution(sqlite3_errmsg(database));
+  }
+
+  int clearBindingsStatus = sqlite3_clear_bindings(_state->statement.get());
+  if (clearBindingsStatus != SQLITE_OK) {
+    throw NitroSQLiteException::SqlExecution(sqlite3_errmsg(database));
+  }
+
+  if (params) {
+    bindStatement(_state->statement.get(), *params);
+  }
+
+  try {
+    return executeStatement(database, _state->statement.get());
+  } catch (...) {
+    sqlite3_reset(_state->statement.get());
+    throw;
+  }
+}
+
+void SQLitePreparedStatement::finalize() {
+  std::lock_guard lock(_state->mutex);
+  std::lock_guard connectionLock(_state->connection->mutex);
+  _state->statement.reset();
+}
+
+bool SQLitePreparedStatement::isFinalized() const {
+  std::lock_guard lock(_state->mutex);
+  return !_state->statement;
+}
+
+size_t SQLitePreparedStatement::getExternalMemorySize() const noexcept {
+  return sizeof(*this) + sizeof(State);
+}
+
+std::shared_ptr<SQLitePreparedStatement> sqlitePrepare(const std::string& dbName, const std::string& query) {
+  auto connection = sqliteGetOpenDatabase(dbName);
+  std::lock_guard lock(connection->mutex);
+  if (connection->database == nullptr) {
+    throw NitroSQLiteException::DatabaseNotOpen(dbName);
+  }
+
+  auto statement = prepareStatement(connection->database, query, std::nullopt);
+  auto state = std::make_shared<SQLitePreparedStatement::State>(connection, std::move(statement));
+  return std::shared_ptr<SQLitePreparedStatement>(new SQLitePreparedStatement(std::move(state)));
+}
+
+} // namespace margelo::nitro::rnnitrosqlite

package/cpp/NitroSQLiteOperations.hpp

@@ -0,0 +1,72 @@
+#pragma once
+
+#include "NitroSQLiteDatabaseConnections.hpp"
+#include "hybridObjects/HybridNitroSQLiteQueryResult.hpp"
+#include <functional>
+#include <memory>
+#include <mutex>
+#include <queue>
+#include <sqlite3.h>
+#include <string>
+
+namespace margelo::nitro::rnnitrosqlite {
+
+/** Open the default connection by database name. Read-only mode requires an existing file. */
+void sqliteOpenDb(const std::string& dbName, const std::string& docPath, bool readOnly = false);
+
+/** Open a separate native handle and return its opaque connection ID. */
+std::string sqliteOpenConnection(const std::string& dbName, const std::string& docPath, bool readOnly = false);
+
+/** Prepared SQL statement bound to one native connection. */
+class SQLitePreparedStatement {
+public:
+  ~SQLitePreparedStatement();
+
+  /** Reset and execute with new bindings. Throws after finalization or connection closure. */
+  std::shared_ptr<HybridNitroSQLiteQueryResult> execute(const std::optional<SQLiteQueryParams>& params);
+  /** Release the native statement. Repeated calls are safe. */
+  void finalize();
+  /** Check whether the native statement has been released. */
+  bool isFinalized() const;
+  /** Report this object's native memory size to the Nitro runtime. */
+  size_t getExternalMemorySize() const noexcept;
+
+private:
+  struct State;
+
+  explicit SQLitePreparedStatement(std::shared_ptr<State> state);
+
+  std::shared_ptr<State> _state;
+
+  friend std::shared_ptr<SQLitePreparedStatement> sqlitePrepare(const std::string& dbName, const std::string& query);
+};
+
+void sqliteCloseDb(const std::string& dbName);
+
+/** Delete a database, optionally closing its independent connection first. */
+void sqliteRemoveDb(const std::string& dbName, const std::string& docPath, const std::optional<std::string>& connectionId = std::nullopt,
+                    const std::optional<std::string>& otherDocPath = std::nullopt);
+
+void sqliteAttachDb(const std::string& mainDBName, const std::string& docPath, const std::string& databaseToAttach,
+                    const std::string& alias);
+
+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 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);
+
+/** Prepare one SQL statement on an open default or independent connection. */
+std::shared_ptr<SQLitePreparedStatement> sqlitePrepare(const std::string& dbName, const std::string& query);
+
+void sqliteCloseAll();
+
+} // namespace margelo::nitro::rnnitrosqlite

package/cpp/{types.hpp → NitroSQLiteTypes.hpp}

@@ -5,12 +5,9 @@
 #include <NitroModules/ArrayBuffer.hpp>
 #include <string>
 
-using namespace margelo::nitro;
-using namespace margelo::nitro::rnnitrosqlite;
+namespace margelo::nitro::rnnitrosqlite {
 
-namespace margelo::rnnitrosqlite {
-
-using SQLiteValue = std::variant<nitro::NullType, bool, std::shared_ptr<ArrayBuffer>, std::string, double>;
+using SQLiteValue = std::variant<NullType, bool, std::shared_ptr<ArrayBuffer>, std::string, double>;
 using SQLiteQueryParams = std::vector<SQLiteValue>;
 using SQLiteQueryResultRow = std::unordered_map<std::string, SQLiteValue>;
 using SQLiteQueryResults = std::vector<SQLiteQueryResultRow>;
@@ -40,4 +37,4 @@ inline ColumnType mapSQLiteTypeToColumnType(const char* type) {
   }
 }
 
-} // namespace margelo::rnnitrosqlite
+} // namespace margelo::nitro::rnnitrosqlite

package/cpp/{utils.hpp → NitroSQLiteUtils.hpp}

@@ -3,7 +3,7 @@
 #include <string>
 #include <sys/stat.h>
 
-namespace margelo::rnnitrosqlite {
+namespace margelo::nitro::rnnitrosqlite {
 
 bool folder_exists(const std::string& foldername) {
   struct stat buffer;
@@ -57,4 +57,4 @@ std::string get_db_path(const std::string& dbName, const std::string& docPath) {
   return docPath + "/" + dbName;
 }
 
-} // namespace margelo::rnnitrosqlite
+} // namespace margelo::nitro::rnnitrosqlite