react-native-nitro-sqlite 9.8.1 → 10.0.0

package/src/types.ts

@@ -1,104 +1,218 @@
 import type { NitroSQLiteQueryResult } from './specs/NitroSQLiteQueryResult.nitro'
 
+/** Options for `open()` and `NitroSQLite.open()`. */
 export interface NitroSQLiteConnectionOptions {
+  /** Database file name. Only one managed connection may use a name at a time. */
   name: string
+  /** Directory relative to the platform's database directory. */
   location?: string
+  /**
+   * Choose a connection to the database file. The default connection is addressed
+   * by `name`, so opening it twice throws. Each `independent` connection has its
+   * own native handle and operation queue and can share a file with other connections.
+   * Defaults to `'default'`.
+   */
+  connection?: 'default' | 'independent'
+  /**
+   * Open an existing database without write access. Opening fails if the file does
+   * not exist. A read-only connection cannot write, attach, or delete a database.
+   * Defaults to `false`.
+   */
+  readOnly?: boolean
 }
 
+/** A managed connection bound to one database name. Do not use it after closing or deleting it. */
 export interface NitroSQLiteConnection {
+  /** Close the connection. Throws if a queued operation is running or pending. */
   close(): void
+  /** Delete the database file and end this connection. Throws if the connection is busy.
+   * This also closes the native handle if it is open.
+   */
   delete(): void
+  /** Attach another database under `alias` for queries against this connection.
+   * @param dbNameToAttach File name of the database to attach.
+   * @param alias SQL schema name for the attached database.
+   * @param location Directory relative to the platform database directory.
+   */
   attach(dbNameToAttach: string, alias: string, location?: string): void
+  /** Detach the database identified by `alias`.
+   * @param alias SQL schema name used when attaching the database.
+   */
   detach(alias: string): void
+  /** Run a callback in a queued transaction. The callback must use `tx` for database work.
+   * It commits on success and rolls back on error unless explicitly finalized.
+   * Awaiting another queued operation for this database inside the callback deadlocks.
+   * Synchronous connection methods throw while this transaction is active.
+   * @param transactionCallback Async callback receiving the transaction handle.
+   * @returns The callback's result after the transaction finishes.
+   */
   transaction: <Result = void>(
     transactionCallback: (tx: Transaction) => Promise<Result>,
   ) => Promise<Result>
+  /** Execute one SQL statement synchronously. Throws while the connection is busy. */
   execute: ExecuteQuery
+  /** Queue one SQL statement and resolve with its result. */
   executeAsync: ExecuteAsyncQuery
+  /**
+   * Prepare one SQL statement on this connection for repeated execution.
+   * Finalize the returned statement before closing the connection.
+   * @param query SQL statement with optional positional placeholders.
+   */
+  prepare(query: string): PreparedStatement
+  /** Execute commands in one exclusive transaction. Throws while the connection is busy.
+   * @param commands SQL commands and optional parameter sets.
+   * @returns Total affected row count.
+   */
   executeBatch(commands: BatchQueryCommand[]): BatchQueryResult
+  /** Queue commands in one exclusive transaction.
+   * @param commands SQL commands and optional parameter sets.
+   * @returns A promise of the total affected row count.
+   */
   executeBatchAsync(commands: BatchQueryCommand[]): Promise<BatchQueryResult>
+  /** Execute one non-empty SQL command per file line in an exclusive transaction.
+   * `location` is a path to the SQL file; multi-line statements are unsupported.
+   * @param location Path to the SQL file.
+   * @returns Number of executed commands and affected rows.
+   */
   loadFile(location: string): FileLoadResult
+  /** Queue the file import and resolve with its command and row counts.
+   * @param location Path to the SQL file.
+   */
   loadFileAsync(location: string): Promise<FileLoadResult>
 }
 
+/** SQLite value categories reported in query column metadata. */
 export enum ColumnType {
+  /** Boolean declaration. */
   BOOLEAN,
+  /** Floating point declaration. */
   NUMBER,
+  /** Integer declaration. */
   INT64,
+  /** Text declaration. */
   TEXT,
+  /** Blob declaration. */
   ARRAY_BUFFER,
+  /** Missing or unrecognized declaration. */
   NULL_VALUE,
 }
 
+/** Values accepted by bound SQL parameters and returned in result rows. */
 export type SQLiteValue = boolean | number | string | ArrayBuffer | null
 
+/** Positional values for SQL placeholders. */
 export type SQLiteQueryParams = SQLiteValue[]
 
+/** A row keyed by result column names. */
 export type QueryResultRow = Record<string, SQLiteValue>
 
+/** Query result with a row adapter for TypeORM-style consumers. */
 export type QueryResult<Row extends QueryResultRow = QueryResultRow> =
   NitroSQLiteQueryResult & {
-    /** Query results in a row format for TypeORM compatibility */
+    /** Query rows in a TypeORM-compatible collection. */
     rows: NitroSQLiteQueryResultRows<Row>
   }
 
+/** Indexable view of query rows. */
 export type NitroSQLiteQueryResultRows<
   Row extends Record<string, SQLiteValue> = Record<string, SQLiteValue>,
 > = {
-  /** Raw array with all dataset */
+  /** All returned rows. */
   _array: Row[]
 
-  /** The lengh of the dataset */
+  /** Number of returned rows. */
   length: number
 
-  /** A convenience function to acess the index based the row object
-   * @param idx the row index
-   * @returns the row structure identified by column names
+  /** Get a row by zero-based index; returns `undefined` when out of range.
+   * @param idx Row index.
    */
   item: (idx: number) => Row | undefined
 }
 
+/** Execute one SQL statement synchronously and return its typed rows.
+ * @param query SQL statement with optional positional placeholders.
+ * @param params Values bound to the placeholders.
+ */
 export type ExecuteQuery = <Row extends QueryResultRow = QueryResultRow>(
   query: string,
   params?: SQLiteValue[],
 ) => QueryResult<Row>
 
+/** Queue one SQL statement and resolve with its typed rows.
+ * @param query SQL statement with optional positional placeholders.
+ * @param params Values bound to the placeholders.
+ */
 export type ExecuteAsyncQuery = <Row extends QueryResultRow = QueryResultRow>(
   query: string,
   params?: SQLiteQueryParams,
 ) => Promise<QueryResult<Row>>
 
+/**
+ * A reusable SQL statement bound to the connection that prepared it. Each
+ * execution resets the statement and its bindings before applying new values.
+ * Finalize it before closing the connection.
+ */
+export interface PreparedStatement {
+  /** Whether `finalize()` has released the native statement. */
+  readonly isFinalized: boolean
+  /** Execute on the calling thread. Throws if the statement is finalized, its connection is closed, or the managed connection is busy. */
+  execute: ExecutePreparedStatement
+  /** Queue execution on a background thread and resolve with the query result. */
+  executeAsync: ExecutePreparedStatementAsync
+  /** Release the native statement. Calling this more than once is safe. */
+  finalize(): void
+}
+
+/**
+ * Execute a prepared statement with optional positional values and return typed rows.
+ * Each call replaces the previous parameter bindings.
+ * @param params Values bound to the statement's positional placeholders.
+ */
+export type ExecutePreparedStatement = <
+  Row extends QueryResultRow = QueryResultRow,
+>(
+  params?: SQLiteQueryParams,
+) => QueryResult<Row>
+
+/**
+ * Queue a prepared statement execution and resolve with typed rows. Calls on the
+ * same managed connection run in queue order.
+ * @param params Values bound to the statement's positional placeholders.
+ */
+export type ExecutePreparedStatementAsync = <
+  Row extends QueryResultRow = QueryResultRow,
+>(
+  params?: SQLiteQueryParams,
+) => Promise<QueryResult<Row>>
+
+/** Handle valid only while its transaction callback is active. */
 export interface Transaction {
+  /** Commit now. Further operations on this transaction throw. */
   commit(): NitroSQLiteQueryResult
+  /** Roll back now. Further operations on this transaction throw. */
   rollback(): NitroSQLiteQueryResult
+  /** Execute within this transaction on the calling thread. */
   execute: ExecuteQuery
+  /** Execute within this transaction on a background thread. */
   executeAsync: ExecuteAsyncQuery
 }
 
-/**
- * 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.
- */
+/** One command in a batch. A nested `params` array repeats the query for each parameter set. */
 export interface BatchQueryCommand {
+  /** SQL statement to execute. */
   query: string
+  /** One parameter set, or several sets for repeated execution. */
   params?: SQLiteQueryParams | SQLiteQueryParams[]
 }
 
-/**
- * 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
- */
+/** Result of a committed SQL batch. Errors are thrown rather than returned here. */
 export interface BatchQueryResult {
+  /** Total number of rows changed by the batch. */
   rowsAffected?: number
 }
 
-/**
- * Result of loading a file and executing every line as a SQL command
- * Similar to BatchQueryResult
- */
+/** Result of importing a SQL file in one transaction. */
 export interface FileLoadResult extends BatchQueryResult {
+  /** Number of non-empty lines executed as SQL commands. */
   commands?: number
 }

package/cpp/operations.cpp

@@ -1,358 +0,0 @@
-#include "operations.hpp"
-#include "NitroSQLiteException.hpp"
-#include "hybridObjects/HybridNitroSQLiteQueryResult.hpp"
-#include "logs.hpp"
-#include "utils.hpp"
-#include <NitroModules/ArrayBuffer.hpp>
-#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 {
-
-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* 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);
-  }
-
-  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);
-    }
-
-    connection = std::move(iterator->second);
-    dbMap.erase(iterator);
-  }
-
-  connection->close();
-}
-
-void sqliteCloseAll() {
-  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();
-  }
-}
-
-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) {
-  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());
-}
-
-void bindStatement(sqlite3_stmt* statement, const SQLiteQueryParams& values) {
-  for (int valueIndex = 0; valueIndex < values.size(); valueIndex++) {
-    int sqliteIndex = valueIndex + 1;
-    SQLiteValue value = values.at(valueIndex);
-    if (std::holds_alternative<NullType>(value)) {
-      sqlite3_bind_null(statement, sqliteIndex);
-    } else if (std::holds_alternative<bool>(value)) {
-      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) {
-        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);
-    } else if (std::holds_alternative<std::shared_ptr<ArrayBuffer>>(value)) {
-      const auto arrayBufferValue = std::get<std::shared_ptr<ArrayBuffer>>(value);
-      sqlite3_bind_blob(statement, sqliteIndex, arrayBufferValue->data(), arrayBufferValue->size(), SQLITE_STATIC);
-    }
-  }
-}
-
-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));
-    }
-
-    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));
-    }
-  }
-
-} // namespace
-
-SQLiteConnectionPtr sqliteGetOpenDatabase(const std::string& dbName) {
-  std::lock_guard lock(dbMapMutex);
-  auto iterator = dbMap.find(dbName);
-  if (iterator == dbMap.end()) {
-    throw NitroSQLiteException::DatabaseNotOpen(dbName);
-  }
-
-  return iterator->second;
-}
-
-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);
-  SQLiteQueryResults results;
-
-  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;
-      }
-    }
-
-    results.push_back(std::move(row));
-  });
-
-  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)});
-  }
-
-  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));
-}
-
-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)};
-}
-
-} // namespace margelo::rnnitrosqlite

package/cpp/operations.hpp

@@ -1,56 +0,0 @@
-#pragma once
-
-#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);
-
-void sqliteRemoveDb(const std::string& dbName, const std::string& docPath);
-
-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);
-
-void sqliteCloseAll();
-
-} // namespace margelo::rnnitrosqlite