react-native-nitro-sqlite 9.6.0 → 9.8.0

package/RNNitroSQLite.podspec

@@ -1,11 +1,48 @@
 require "json"
 
 package = JSON.parse(File.read(File.join(__dir__, "package.json")))
-folly_compiler_flags = '-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1'
+app_package_json_path = File.expand_path("../package.json", Pod::Config.instance.installation_root)
+app_package = File.exist?(app_package_json_path) ? JSON.parse(File.read(app_package_json_path)) : {}
+app_config = app_package.fetch("nitroSQLite", {})
+
+unless app_config.is_a?(Hash)
+  raise "nitroSQLite in package.json must be an object"
+end
+
+if ENV.key?("NITRO_SQLITE_THREADSAFE")
+  thread_safe_value = ENV["NITRO_SQLITE_THREADSAFE"]
+  unless %w[true false 1 0].include?(thread_safe_value)
+    raise "NITRO_SQLITE_THREADSAFE must be true, false, 1, or 0"
+  end
+
+  sqlite_threadsafe = %w[true 1].include?(thread_safe_value) ? "1" : "0"
+else
+  thread_safe_value = app_config.fetch("threadSafe", true)
+  unless [true, false].include?(thread_safe_value)
+    raise "nitroSQLite.threadSafe in package.json must be true or false"
+  end
+
+  sqlite_threadsafe = thread_safe_value ? "1" : "0"
+end
+
+if ENV.key?("NITRO_SQLITE_PERFORMANCE_MODE")
+  performance_mode_value = ENV["NITRO_SQLITE_PERFORMANCE_MODE"]
+  unless %w[true false 1 0].include?(performance_mode_value)
+    raise "NITRO_SQLITE_PERFORMANCE_MODE must be true, false, 1, or 0"
+  end
+
+  performance_mode = %w[true 1].include?(performance_mode_value)
+else
+  performance_mode = app_config.fetch("performanceMode", true)
 
-# TODO: Should be customizable in package.json.
-# Used to create comparable benchmark results
-performance_mode = 1
+  unless [true, false].include?(performance_mode)
+    raise "nitroSQLite.performanceMode in package.json must be true or false"
+  end
+end
+folly_compiler_flags = '-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1'
+log_message = lambda do |message|
+  puts "\e[34m#{message}\e[0m"
+end
 
 Pod::Spec.new do |s|
   s.name         = "RNNitroSQLite"
@@ -17,6 +54,10 @@ Pod::Spec.new do |s|
   s.platforms    = { :ios => min_ios_version_supported, :visionos => "1.0" }
   s.source       = { :git => "https://github.com/margelo/react-native-nitro-sqlite.git", :tag => "#{s.version}" }
 
+  # Opt-in vector search (NITRO_SQLITE_VEC=1); the companion pod compiles the sources.
+  nitro_sqlite_vec = ENV['NITRO_SQLITE_VEC'] == '1'
+  nitro_sqlite_vec_cpp = File.expand_path(File.join(__dir__, "..", "react-native-nitro-sqlite-vec", "cpp"))
+
   s.source_files = [
     # Implementation (Swift)
     "ios/**/*.{swift}",
@@ -26,17 +67,24 @@ Pod::Spec.new do |s|
     "cpp/**/*.{h,hpp,c,cpp}"
   ]
 
+  inherited_cflags = '$(inherited)'
+  optimized_cflags = '-DSQLITE_DQS=0 -DSQLITE_DEFAULT_MEMSTATUS=0 -DSQLITE_DEFAULT_WAL_SYNCHRONOUS=1 -DSQLITE_LIKE_DOESNT_MATCH_BLOBS=1 -DSQLITE_MAX_EXPR_DEPTH=0 -DSQLITE_OMIT_DEPRECATED=1 -DSQLITE_OMIT_PROGRESS_CALLBACK=1 -DSQLITE_OMIT_SHARED_CACHE=1 -DSQLITE_USE_ALLOCA=1'
+
+  log_message.call("SQLite thread safety: SQLITE_THREADSAFE=#{sqlite_threadsafe}")
+  log_message.call("SQLite performance mode: #{performance_mode ? "enabled" : "disabled"}")
+  performance_cflags = performance_mode ? " #{optimized_cflags}" : ""
+  other_cflags = "#{inherited_cflags}#{performance_cflags} -DSQLITE_THREADSAFE=#{sqlite_threadsafe} "
+
   s.pod_target_xcconfig = {
     :GCC_PREPROCESSOR_DEFINITIONS => "HAVE_FULLFSYNC=1",
     :WARNING_CFLAGS => "-Wno-shorten-64-to-32 -Wno-comma -Wno-unreachable-code -Wno-conditional-uninitialized -Wno-deprecated-declarations",
     'CLANG_CXX_LANGUAGE_STANDARD' => 'c++20',
     'CLANG_CXX_LIBRARY' => 'libc++',
     'DEFINES_MODULE' => 'YES',
-    "HEADER_SEARCH_PATHS" => [
-      "${PODS_ROOT}/RCT-Folly",
-    ],
-    "GCC_PREPROCESSOR_DEFINITIONS" => "$(inherited) FOLLY_NO_CONFIG FOLLY_CFG_NO_COROUTINES",
+    "HEADER_SEARCH_PATHS" => "\"${PODS_ROOT}/RCT-Folly\"" + (nitro_sqlite_vec ? " \"#{nitro_sqlite_vec_cpp}\"" : ""),
+    "GCC_PREPROCESSOR_DEFINITIONS" => "$(inherited) FOLLY_NO_CONFIG FOLLY_CFG_NO_COROUTINES" + (nitro_sqlite_vec ? " NITRO_SQLITE_VEC=1" : ""),
     "OTHER_CPLUSPLUSFLAGS" => folly_compiler_flags,
+    "OTHER_CFLAGS" => other_cflags,
   }
 
   load 'nitrogen/generated/ios/RNNitroSQLite+autolinking.rb'
@@ -44,18 +92,6 @@ Pod::Spec.new do |s|
 
   install_modules_dependencies(s)
 
-  optimizedCflags = '$(inherited) -DSQLITE_DQS=0 -DSQLITE_DEFAULT_MEMSTATUS=0 -DSQLITE_DEFAULT_WAL_SYNCHRONOUS=1 -DSQLITE_LIKE_DOESNT_MATCH_BLOBS=1 -DSQLITE_MAX_EXPR_DEPTH=0 -DSQLITE_OMIT_DEPRECATED=1 -DSQLITE_OMIT_PROGRESS_CALLBACK=1 -DSQLITE_OMIT_SHARED_CACHE=1 -DSQLITE_USE_ALLOCA=1'
-
-  if performance_mode == '1' then
-    log_message.call("Thread unsafe (1) performance mode enabled. Use only transactions! 🚀🚀")
-    xcconfig[:OTHER_CFLAGS] = optimizedCflags + ' -DSQLITE_THREADSAFE=0 '
-  end
-
-  if performance_mode == '2' then
-    log_message.call("Thread safe (2) performance mode enabled 🚀")
-    xcconfig[:OTHER_CFLAGS] = optimizedCflags + ' -DSQLITE_THREADSAFE=1 '
-  end
-
   if ENV['NITRO_SQLITE_USE_PHONE_VERSION'] == '1' then
     s.exclude_files = "cpp/sqlite/sqlite3.c", "cpp/sqlite/sqlite3.h"
     s.library = "sqlite3"

package/android/CMakeLists.txt

@@ -29,6 +29,21 @@ include_directories(
   src/main/cpp
 )
 
+# Opt-in: compile the companion's sqlite-vec into this library (shared single sqlite3).
+if(NITRO_SQLITE_VEC)
+  message(STATUS "[react-native-nitro-sqlite] vector search ENABLED (sqlite-vec from ${NITRO_SQLITE_VEC_CPP_DIR})")
+  set(NITRO_SQLITE_VEC_SOURCES
+    "${NITRO_SQLITE_VEC_CPP_DIR}/sqlite-vec/sqlite-vec.c"
+    "${NITRO_SQLITE_VEC_CPP_DIR}/registerVectorExtensions.cpp"
+  )
+  target_sources(${CMAKE_PROJECT_NAME} PRIVATE ${NITRO_SQLITE_VEC_SOURCES})
+  # SQLITE_CORE: link against our bundled sqlite3; SQLITE_VEC_STATIC: drop Windows dllexport.
+  set_source_files_properties(${NITRO_SQLITE_VEC_SOURCES}
+    PROPERTIES COMPILE_DEFINITIONS "SQLITE_CORE;SQLITE_VEC_STATIC")
+  target_include_directories(${CMAKE_PROJECT_NAME} PRIVATE "${NITRO_SQLITE_VEC_CPP_DIR}")
+  target_compile_definitions(${CMAKE_PROJECT_NAME} PRIVATE NITRO_SQLITE_VEC)
+endif()
+
 set_target_properties(
   ${CMAKE_PROJECT_NAME} PROPERTIES
   CXX_STANDARD ${CMAKE_CXX_STANDARD}

package/android/build.gradle

@@ -75,6 +75,18 @@ def REACT_NATIVE_MINOR_VERSION = REACT_NATIVE_VERSION.startsWith("0.0.0-") ? 100
 
 def SQLITE_FLAGS = rootProject.properties['nitroSqliteFlags']
 
+// Opt-in: resolve the companion's cpp dir so CMake compiles its sqlite-vec into this library.
+def NITRO_SQLITE_VEC_ENABLED = (rootProject.findProperty('nitroSqliteVec') ?: 'false').toString() == 'true'
+def NITRO_SQLITE_VEC_CPP_DIR = ''
+if (NITRO_SQLITE_VEC_ENABLED) {
+  try {
+    def vecPkgJson = ["node", "--print", "require.resolve('react-native-nitro-sqlite-vec/package.json')"].execute(null, rootDir).text.trim()
+    NITRO_SQLITE_VEC_CPP_DIR = new File(new File(vecPkgJson).parentFile, "cpp").absolutePath
+  } catch (Exception e) {
+    throw new GradleException("[react-native-nitro-sqlite] nitroSqliteVec=true but 'react-native-nitro-sqlite-vec' could not be resolved. Install it in your app (e.g. `bun add react-native-nitro-sqlite-vec`).")
+  }
+}
+
 apply plugin: "com.android.library"
 apply plugin: "kotlin-android"
 
@@ -111,6 +123,8 @@ android {
           "-DANDROID_TOOLCHAIN=clang",
           "-DREACT_NATIVE_MINOR_VERSION=${REACT_NATIVE_MINOR_VERSION}",
           "-DSQLITE_FLAGS='${SQLITE_FLAGS ? SQLITE_FLAGS : ''}'",
+          "-DNITRO_SQLITE_VEC=${NITRO_SQLITE_VEC_ENABLED ? 'ON' : 'OFF'}",
+          "-DNITRO_SQLITE_VEC_CPP_DIR=${NITRO_SQLITE_VEC_CPP_DIR}",
           "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON"
         abiFilters (*reactNativeArchitectures())
       }

package/cpp/NitroSQLiteException.hpp

@@ -46,6 +46,11 @@ public:
     return this->_exceptionString.c_str();
   }
 
+  static NitroSQLiteException DatabaseAlreadyOpen(const std::string& dbName) {
+    return NitroSQLiteException(NitroSQLiteExceptionType::DatabaseCannotBeOpened,
+                                "Database " + dbName + " is already open. There is already a connection to the database.");
+  }
+
   static NitroSQLiteException DatabaseNotOpen(const std::string& dbName) {
     return NitroSQLiteException(NitroSQLiteExceptionType::UnableToAttachToDatabase, dbName + " is not open");
   }

package/cpp/databaseMigration.cpp

@@ -0,0 +1,123 @@
+#include "databaseMigration.hpp"
+#include "logs.hpp"
+#include <array>
+#include <system_error>
+
+namespace margelo::nitro::rnnitrosqlite {
+
+namespace fs = std::filesystem;
+
+namespace {
+
+  constexpr std::size_t kDatabaseFileCount = 4;
+  using DatabaseFiles = std::array<std::string, kDatabaseFileCount>;
+
+  DatabaseFiles getDatabaseFiles(const std::string& dbName);
+  bool copyDatabaseFiles(const DatabaseFiles& files, const fs::path& fromDirectory, const fs::path& toDirectory);
+  void removeAuxiliaryDatabaseFiles(const DatabaseFiles& files, const fs::path& directory);
+
+} // namespace
+
+fs::path migrateDatabase(const std::string& dbName, const fs::path& fromDirectory, const fs::path& toDirectory) {
+  const auto files = getDatabaseFiles(dbName);
+  std::error_code ec;
+  const bool sourceExists = fs::exists(fromDirectory / dbName, ec);
+
+  if (ec) {
+    LOGW("Failed to inspect database %s in its old location: %s", dbName.c_str(), ec.message().c_str());
+    return fromDirectory;
+  }
+
+  if (!sourceExists) {
+    // A completed migration may have been interrupted after deleting the database but before
+    // deleting its journals. The destination is already authoritative in that state.
+    removeAuxiliaryDatabaseFiles(files, fromDirectory);
+    return toDirectory;
+  }
+
+  // A database in the old directory is the live copy. Clear every database generation file at
+  // the destination before copying so SQLite never pairs the source with a stale journal.
+  if (!removeDatabaseFiles(dbName, toDirectory)) {
+    return fromDirectory;
+  }
+
+  fs::create_directories(toDirectory, ec);
+  if (ec) {
+    LOGW("Failed to create database migration directory %s: %s", toDirectory.string().c_str(), ec.message().c_str());
+    return fromDirectory;
+  }
+
+  if (!copyDatabaseFiles(files, fromDirectory, toDirectory)) {
+    return fromDirectory;
+  }
+
+  // Delete the database first. If this fails, every source journal must remain beside it so the
+  // caller can safely keep using the old location. Leftover journals after a successful database
+  // deletion are harmless and are removed on the next migration attempt.
+  if (!fs::remove(fromDirectory / dbName, ec) || ec) {
+    LOGW("Failed to remove migrated database %s from its old location: %s", dbName.c_str(), ec.message().c_str());
+    return fromDirectory;
+  }
+
+  removeAuxiliaryDatabaseFiles(files, fromDirectory);
+  return toDirectory;
+}
+
+bool removeDatabaseFiles(const std::string& dbName, const fs::path& directory) {
+  const auto files = getDatabaseFiles(dbName);
+
+  for (const auto& file : files) {
+    std::error_code ec;
+    fs::remove(directory / file, ec);
+    if (ec) {
+      LOGW("Failed to remove database file %s: %s", file.c_str(), ec.message().c_str());
+      return false;
+    }
+  }
+
+  return true;
+}
+
+namespace {
+
+  DatabaseFiles getDatabaseFiles(const std::string& dbName) {
+    return {dbName, dbName + "-journal", dbName + "-wal", dbName + "-shm"};
+  }
+
+  bool copyDatabaseFiles(const DatabaseFiles& files, const fs::path& fromDirectory, const fs::path& toDirectory) {
+    for (const auto& file : files) {
+      std::error_code ec;
+      const bool sourceExists = fs::exists(fromDirectory / file, ec);
+
+      if (ec) {
+        LOGW("Failed to inspect database file %s: %s", file.c_str(), ec.message().c_str());
+        return false;
+      }
+
+      if (!sourceExists) {
+        continue;
+      }
+
+      if (!fs::copy_file(fromDirectory / file, toDirectory / file, ec) || ec) {
+        LOGW("Failed to migrate database file %s: %s", file.c_str(), ec.message().c_str());
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  void removeAuxiliaryDatabaseFiles(const DatabaseFiles& files, const fs::path& directory) {
+    for (std::size_t index = 1; index < files.size(); index++) {
+      const auto& file = files[index];
+      std::error_code ec;
+      fs::remove(directory / file, ec);
+      if (ec) {
+        LOGW("Failed to remove database file %s: %s", file.c_str(), ec.message().c_str());
+      }
+    }
+  }
+
+} // namespace
+
+} // namespace margelo::nitro::rnnitrosqlite

package/cpp/databaseMigration.hpp

@@ -0,0 +1,13 @@
+#pragma once
+
+#include <filesystem>
+#include <string>
+
+namespace margelo::nitro::rnnitrosqlite {
+
+std::filesystem::path migrateDatabase(const std::string& dbName, const std::filesystem::path& fromDirectory,
+                                      const std::filesystem::path& toDirectory);
+
+bool removeDatabaseFiles(const std::string& dbName, const std::filesystem::path& directory);
+
+} // namespace margelo::nitro::rnnitrosqlite

package/cpp/hybridObjects/HybridNitroSQLite.cpp

@@ -1,11 +1,14 @@
 #include "HybridNitroSQLite.hpp"
 #include "HybridNitroSQLiteQueryResult.hpp"
 #include "NitroSQLiteException.hpp"
+#include "databaseMigration.hpp"
 #include "importSqlFile.hpp"
 #include "logs.hpp"
 #include "macros.hpp"
 #include "operations.hpp"
 #include "sqliteExecuteBatch.hpp"
+#include <exception>
+#include <filesystem>
 #include <iostream>
 #include <map>
 #include <optional>
@@ -65,8 +68,26 @@ const std::string getDocPath(const std::optional<std::string>& location) {
   return tempDocPath;
 }
 
+const std::string getOldDocPath(const std::optional<std::string>& location) {
+  std::string oldDocPath = HybridNitroSQLite::migrationDocPath;
+  if (location) {
+    oldDocPath = oldDocPath + "/" + *location;
+  }
+
+  return oldDocPath;
+}
+
+const std::string getMigratedDocPath(const std::string& dbName, const std::optional<std::string>& location) {
+  const auto currentDocPath = getDocPath(location);
+  if (HybridNitroSQLite::migrationDocPath.empty()) {
+    return currentDocPath;
+  }
+
+  return migrateDatabase(dbName, getOldDocPath(location), currentDocPath).string();
+}
+
 void HybridNitroSQLite::open(const std::string& dbName, const std::optional<std::string>& location) {
-  const auto docPath = getDocPath(location);
+  const auto docPath = getMigratedDocPath(dbName, location);
   sqliteOpenDb(dbName, docPath);
 }
 
@@ -75,18 +96,28 @@ void HybridNitroSQLite::close(const std::string& dbName) {
 };
 
 void HybridNitroSQLite::drop(const std::string& dbName, const std::optional<std::string>& location) {
-  const auto docPath = getDocPath(location);
-  sqliteRemoveDb(dbName, docPath);
+  const auto currentDocPath = getDocPath(location);
+  if (migrationDocPath.empty()) {
+    sqliteRemoveDb(dbName, currentDocPath);
+    return;
+  }
+
+  const auto oldDocPath = getOldDocPath(location);
+  std::error_code ec;
+  const bool oldDatabaseExists = std::filesystem::exists(std::filesystem::path(oldDocPath) / dbName, ec);
+  if (ec) {
+    LOGW("Failed to inspect database %s in its old location: %s", dbName.c_str(), ec.message().c_str());
+  }
+
+  sqliteRemoveDb(dbName, oldDatabaseExists || ec ? oldDocPath : currentDocPath);
+  removeDatabaseFiles(dbName, oldDocPath);
+  removeDatabaseFiles(dbName, currentDocPath);
 };
 
 void HybridNitroSQLite::attach(const std::string& mainDbName, const std::string& dbNameToAttach, const std::string& alias,
                                const std::optional<std::string>& location) {
-  std::string tempDocPath = std::string(docPath);
-  if (location) {
-    tempDocPath = tempDocPath + "/" + *location;
-  }
-
-  sqliteAttachDb(mainDbName, tempDocPath, dbNameToAttach, alias);
+  const auto attachedDocPath = getMigratedDocPath(dbNameToAttach, location);
+  sqliteAttachDb(mainDbName, attachedDocPath, dbNameToAttach, alias);
 };
 
 void HybridNitroSQLite::detach(const std::string& mainDbName, const std::string& alias) {
@@ -101,10 +132,16 @@ std::shared_ptr<HybridNitroSQLiteQueryResultSpec> HybridNitroSQLite::execute(con
 std::shared_ptr<Promise<std::shared_ptr<HybridNitroSQLiteQueryResultSpec>>>
 HybridNitroSQLite::executeAsync(const std::string& dbName, const std::string& query, const std::optional<SQLiteQueryParams>& params) {
   const auto copiedParams = copyArrayBufferParamsForBackground(params);
+  SQLiteConnectionPtr connection;
+  try {
+    connection = sqliteGetOpenDatabase(dbName);
+  } catch (...) {
+    return Promise<std::shared_ptr<HybridNitroSQLiteQueryResultSpec>>::rejected(std::current_exception());
+  }
 
   return Promise<std::shared_ptr<HybridNitroSQLiteQueryResultSpec>>::async(
-      [=, this]() -> std::shared_ptr<HybridNitroSQLiteQueryResultSpec> {
-        auto result = sqliteExecute(dbName, query, copiedParams);
+      [connection, query, copiedParams]() -> std::shared_ptr<HybridNitroSQLiteQueryResultSpec> {
+        auto result = sqliteExecute(connection, query, copiedParams);
         return result;
       });
 };
@@ -122,9 +159,15 @@ std::shared_ptr<Promise<BatchQueryResult>> HybridNitroSQLite::executeBatchAsync(
   // ArrayBuffers into native buffers before going off-thread.
   const auto commands = batchParamsToCommands(batchParams);
   const auto copiedCommands = copyArrayBufferParamsForBackground(commands);
+  SQLiteConnectionPtr connection;
+  try {
+    connection = sqliteGetOpenDatabase(dbName);
+  } catch (...) {
+    return Promise<BatchQueryResult>::rejected(std::current_exception());
+  }
 
-  return Promise<BatchQueryResult>::async([=, this]() -> BatchQueryResult {
-    auto result = sqliteExecuteBatch(dbName, copiedCommands);
+  return Promise<BatchQueryResult>::async([connection, copiedCommands]() -> BatchQueryResult {
+    auto result = sqliteExecuteBatch(connection, copiedCommands);
     return BatchQueryResult(result.rowsAffected);
   });
 };
@@ -135,9 +178,15 @@ FileLoadResult HybridNitroSQLite::loadFile(const std::string& dbName, const std:
 };
 
 std::shared_ptr<Promise<FileLoadResult>> HybridNitroSQLite::loadFileAsync(const std::string& dbName, const std::string& location) {
-  return Promise<FileLoadResult>::async([=, this]() -> FileLoadResult {
-    auto result = loadFile(dbName, location);
-    return result;
+  SQLiteConnectionPtr connection;
+  try {
+    connection = sqliteGetOpenDatabase(dbName);
+  } catch (...) {
+    return Promise<FileLoadResult>::rejected(std::current_exception());
+  }
+  return Promise<FileLoadResult>::async([connection, location]() -> FileLoadResult {
+    const auto result = importSqlFile(connection, location);
+    return FileLoadResult(result.commands, result.rowsAffected);
   });
 };
 

package/cpp/hybridObjects/HybridNitroSQLite.hpp

@@ -14,6 +14,10 @@ public:
 
 public:
   static std::string docPath;
+  // Directory databases were stored in by previous app versions, when the platform layer has
+  // relocated docPath (e.g. iOS with RNNitroSQLite_DatabaseLocation set to "ApplicationSupport").
+  // When non-empty, databases found there are resolved as they are opened, attached, or dropped.
+  static std::string migrationDocPath;
 
 public:
   // Methods
@@ -43,5 +47,6 @@ public:
 };
 
 inline std::string HybridNitroSQLite::docPath = "";
+inline std::string HybridNitroSQLite::migrationDocPath = "";
 
 } // namespace margelo::nitro::rnnitrosqlite

package/cpp/hybridObjects/HybridNitroSQLiteQueryResult.cpp

@@ -10,6 +10,8 @@ namespace margelo::nitro::rnnitrosqlite {
 
 namespace {
 
+  constexpr size_t nodePadding = 24;
+
   /**
    * Compute the approximate external memory size of a single result row.
    * This includes:
@@ -18,8 +20,7 @@ namespace {
    */
   size_t getRowExternalMemorySize(const SQLiteQueryResultRow& row) {
     size_t bucketMemory = row.bucket_count() * sizeof(void*);
-    constexpr size_t nodePadding = 24;
-    size_t nodesMemory = row.size() * (sizeof(std::pair<std::string, SQLiteValue>) * nodePadding);
+    size_t nodesMemory = row.size() * (sizeof(std::pair<std::string, SQLiteValue>) + nodePadding);
     return bucketMemory + nodesMemory;
   }
 
@@ -49,10 +50,10 @@ namespace {
    * - Metadata contents, especially the `name` string on each metadata entry.
    */
   size_t getMetadataExternalMemorySize(const SQLiteQueryTableMetadata& metadata) {
-    size_t size = 0;
+    size_t size = metadata.bucket_count() * sizeof(void*);
+    size += metadata.size() * (sizeof(SQLiteQueryTableMetadata::value_type) + nodePadding);
 
     for (const auto& [columnName, columnMeta] : metadata) {
-
       size += columnName.capacity();
       size += columnMeta.name.capacity();
     }

package/cpp/hybridObjects/HybridNitroSQLiteQueryResult.hpp

@@ -13,7 +13,7 @@ public:
   HybridNitroSQLiteQueryResult() : HybridObject(TAG) {}
   HybridNitroSQLiteQueryResult(SQLiteQueryResults results, std::optional<double> insertId, double rowsAffected,
                                std::optional<SQLiteQueryTableMetadata> metadata)
-      : HybridObject(TAG), _insertId(insertId), _rowsAffected(rowsAffected), _results(std::move(results)), _metadata(metadata) {}
+      : HybridObject(TAG), _insertId(insertId), _rowsAffected(rowsAffected), _results(std::move(results)), _metadata(std::move(metadata)) {}
 
 private:
   std::optional<double> _insertId;

package/cpp/importSqlFile.cpp

@@ -11,21 +11,26 @@
 namespace margelo::rnnitrosqlite {
 
 SQLiteOperationResult importSqlFile(const std::string& dbName, const std::string& fileLocation) {
+  return importSqlFile(sqliteGetOpenDatabase(dbName), fileLocation);
+}
+
+SQLiteOperationResult importSqlFile(const SQLiteConnectionPtr& connection, const std::string& fileLocation) {
+  std::lock_guard lock(connection->mutex);
   std::string line;
   std::ifstream sqFile(fileLocation);
   if (sqFile.is_open()) {
     try {
       int rowsAffected = 0;
       int commands = 0;
-      sqliteExecuteLiteral(dbName, "BEGIN EXCLUSIVE TRANSACTION");
+      sqliteExecuteCommand(connection, "BEGIN EXCLUSIVE TRANSACTION");
       while (std::getline(sqFile, line, '\n')) {
         if (!line.empty()) {
           try {
-            SQLiteOperationResult result = sqliteExecuteLiteral(dbName, line);
+            SQLiteOperationResult result = sqliteExecuteCommand(connection, line);
             rowsAffected += result.rowsAffected;
             commands++;
           } catch (NitroSQLiteException& e) {
-            sqliteExecuteLiteral(dbName, "ROLLBACK");
+            sqliteExecuteCommand(connection, "ROLLBACK");
             sqFile.close();
             throw NitroSQLiteException::CouldNotLoadFile(fileLocation, "Transaction was rolled back");
           }
@@ -33,11 +38,11 @@ SQLiteOperationResult importSqlFile(const std::string& dbName, const std::string
       }
 
       sqFile.close();
-      sqliteExecuteLiteral(dbName, "COMMIT");
+      sqliteExecuteCommand(connection, "COMMIT");
       return {.rowsAffected = rowsAffected, .commands = commands};
     } catch (...) {
       sqFile.close();
-      sqliteExecuteLiteral(dbName, "ROLLBACK");
+      sqliteExecuteCommand(connection, "ROLLBACK");
       throw NitroSQLiteException(NitroSQLiteExceptionType::UnknownError, "Unexpected error. Transaction was rolled back");
     }
   } else {

package/cpp/importSqlFile.hpp

@@ -7,9 +7,13 @@
 #pragma once
 
 #include "types.hpp"
+#include <memory>
 
 namespace margelo::rnnitrosqlite {
 
+struct SQLiteConnection;
+
 SQLiteOperationResult importSqlFile(const std::string& dbName, const std::string& fileLocation);
+SQLiteOperationResult importSqlFile(const std::shared_ptr<SQLiteConnection>& connection, const std::string& fileLocation);
 
-}
+} // namespace margelo::rnnitrosqlite