expo-sqlite 58.0.10 → 58.0.11

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 58.0.11
+
+### Patch Changes
+
+- [Internal] Bump `react-native-web` to `~0.21.4`. ([#51260](https://github.com/expo/expo/pull/51260) by [@zoontek](https://github.com/zoontek))
+- Preserve statement error codes and messages when queries run concurrently on Android and iOS, and format Android SQLite error codes as numbers. ([#51082](https://github.com/expo/expo/pull/51082) by [@savv](https://github.com/savv))
+- [Android] Migrate to the Expo Modules API 2.0. Reloading the app now closes the databases that are still open, and `lastInsertRowId` is no longer truncated to 32 bits. ([#51208](https://github.com/expo/expo/pull/51208) by [@lukmccall](https://github.com/lukmccall))
+
 ## 58.0.10
 
 ### Patch Changes

package/android/build.gradle

@@ -47,13 +47,17 @@ def reactNativeArchitectures() {
 }
 
 group = 'host.exp.exponent'
-version = '58.0.10'
+version = '58.0.11'
+
+expoModule {
+  v2 true
+}
 
 android {
   namespace "expo.modules.sqlite"
   defaultConfig {
     versionCode 18
-    versionName "58.0.10"
+    versionName "58.0.11"
     buildConfigField "boolean", "WITH_SQLITE_VEC", project.ext.WITH_SQLITE_VEC.toString()
 
     externalNativeBuild {

package/android/src/main/cpp/NativeDatabaseBinding.cpp

@@ -1,6 +1,7 @@
 // Copyright 2015-present 650 Industries. All rights reserved.
 
 #include "NativeDatabaseBinding.h"
+#include "SQLiteError.h"
 
 #include "Exceptions.h"
 
@@ -101,8 +102,15 @@ int NativeDatabaseBinding::sqlite3_prepare_v2(
     const std::string &source,
     jni::alias_ref<NativeStatementBinding::javaobject> statement) {
   NativeStatementBinding *cStatement = cthis(statement);
-  return ::exsqlite3_prepare_v2(db, source.c_str(), source.size(),
+  SQLiteDatabaseLock lock(db);
+  cStatement->db = db;
+  int ret = ::exsqlite3_prepare_v2(db, source.c_str(), source.size(),
                                 &cStatement->stmt, nullptr);
+  if (ret != SQLITE_OK) {
+    jni::throwNewJavaException(
+        SQLiteErrorException::create(sqliteErrorMessage(db, ret)).get());
+  }
+  return ret;
 }
 
 jni::local_ref<jni::JArrayByte>
@@ -173,13 +181,8 @@ int NativeDatabaseBinding::sqlite3_backup(
 }
 
 std::string NativeDatabaseBinding::convertSqlLiteErrorToSTLString() {
-  int code = exsqlite3_errcode(db);
-  const char *message = exsqlite3_errmsg(db);
-  std::string result("Error code ");
-  result += code;
-  result += ": ";
-  result += message;
-  return result;
+  SQLiteDatabaseLock lock(db);
+  return sqliteErrorMessage(db, exsqlite3_errcode(db));
 }
 
 jni::local_ref<jni::JString>

package/android/src/main/cpp/NativeStatementBinding.cpp

@@ -5,6 +5,7 @@
 
 #include <android/log.h>
 #include "Exceptions.h"
+#include "SQLiteError.h"
 
 namespace jni = facebook::jni;
 
@@ -34,6 +35,8 @@ void NativeStatementBinding::registerNatives() {
       makeNativeMethod("sqlite3_step", NativeStatementBinding::sqlite3_step),
       makeNativeMethod("bindStatementParam",
                        NativeStatementBinding::bindStatementParam),
+      makeNativeMethod("getLastErrorMessage",
+                       NativeStatementBinding::getLastErrorMessage),
       makeNativeMethod("getColumnNames",
                        NativeStatementBinding::getColumnNames),
       makeNativeMethod("getColumnValues",
@@ -59,14 +62,52 @@ std::string NativeStatementBinding::sqlite3_column_name(int index) {
 }
 
 int NativeStatementBinding::sqlite3_finalize() {
+  if (!stmt) {
+    lastErrorMessage.clear();
+    return SQLITE_OK;
+  }
+  if (!db) {
+    lastErrorMessage = sqliteErrorMessage(SQLITE_MISUSE);
+    return SQLITE_MISUSE;
+  }
+  SQLiteDatabaseLock lock(db);
   int ret = ::exsqlite3_finalize(stmt);
   stmt = nullptr;
+  lastErrorMessage = ret == SQLITE_OK ? "" : sqliteErrorMessage(db, ret);
   return ret;
 }
 
-int NativeStatementBinding::sqlite3_reset() { return ::exsqlite3_reset(stmt); }
+int NativeStatementBinding::sqlite3_reset() {
+  if (!stmt) {
+    lastErrorMessage.clear();
+    return SQLITE_OK;
+  }
+  if (!db) {
+    lastErrorMessage = sqliteErrorMessage(SQLITE_MISUSE);
+    return SQLITE_MISUSE;
+  }
+  SQLiteDatabaseLock lock(db);
+  int ret = ::exsqlite3_reset(stmt);
+  lastErrorMessage = ret == SQLITE_OK ? "" : sqliteErrorMessage(db, ret);
+  return ret;
+}
 
-int NativeStatementBinding::sqlite3_step() { return ::exsqlite3_step(stmt); }
+int NativeStatementBinding::sqlite3_step() {
+  if (!stmt || !db) {
+    lastErrorMessage = sqliteErrorMessage(SQLITE_MISUSE);
+    return SQLITE_MISUSE;
+  }
+  SQLiteDatabaseLock lock(db);
+  int ret = ::exsqlite3_step(stmt);
+  lastErrorMessage = ret == SQLITE_ROW || ret == SQLITE_DONE
+                         ? ""
+                         : sqliteErrorMessage(db, ret);
+  return ret;
+}
+
+std::string NativeStatementBinding::getLastErrorMessage() {
+  return lastErrorMessage;
+}
 
 int NativeStatementBinding::bindStatementParam(
     int index, jni::alias_ref<jni::JObject> param) {

package/android/src/main/cpp/NativeStatementBinding.h

@@ -30,6 +30,7 @@ public:
   int sqlite3_step();
 
   // helpers
+  std::string getLastErrorMessage();
   int bindStatementParam(int index, jni::alias_ref<jni::JObject> param);
   jni::local_ref<jni::JArrayList<jni::JString>> getColumnNames();
   jni::local_ref<jni::JArrayList<jni::JObject>> getColumnValues();
@@ -47,7 +48,9 @@ private:
   friend HybridBase;
   friend NativeDatabaseBinding;
 
+  sqlite3 *db = nullptr;
   exsqlite3_stmt *stmt = nullptr;
+  std::string lastErrorMessage;
 };
 
 } // namespace expo

package/android/src/main/cpp/SQLiteError.h

@@ -0,0 +1,34 @@
+// Copyright 2026-present 650 Industries. All rights reserved.
+
+#pragma once
+
+#include <string>
+#include "sqlite3.h"
+
+namespace expo {
+
+// Keep SQLite's connection error state stable until its message has been copied.
+// SQLite's database mutex is recursive, so the operation can acquire it internally too.
+class SQLiteDatabaseLock {
+public:
+  explicit SQLiteDatabaseLock(sqlite3 *db) : mutex(exsqlite3_db_mutex(db)) {
+    exsqlite3_mutex_enter(mutex);
+  }
+  ~SQLiteDatabaseLock() { exsqlite3_mutex_leave(mutex); }
+  SQLiteDatabaseLock(const SQLiteDatabaseLock &) = delete;
+  SQLiteDatabaseLock &operator=(const SQLiteDatabaseLock &) = delete;
+
+private:
+  exsqlite3_mutex *mutex;
+};
+
+// Call while holding SQLiteDatabaseLock; use the operation's returned code, not a later errcode().
+inline std::string sqliteErrorMessage(sqlite3 *db, int code) {
+  return "Error code " + std::to_string(code) + ": " + exsqlite3_errmsg(db);
+}
+
+inline std::string sqliteErrorMessage(int code) {
+  return "Error code " + std::to_string(code) + ": " + exsqlite3_errstr(code);
+}
+
+} // namespace expo

package/android/src/main/java/expo/modules/sqlite/DatabaseConnection.kt

@@ -0,0 +1,68 @@
+// Copyright 2015-present 650 Industries. All rights reserved.
+
+package expo.modules.sqlite
+
+import java.util.concurrent.atomic.AtomicInteger
+import java.util.concurrent.locks.ReentrantLock
+
+internal class DatabaseConnection(
+  val databasePath: String,
+  val openOptions: OpenDatabaseOptions
+) {
+  val ref = NativeDatabaseBinding()
+
+  @Volatile
+  var isClosed = false
+    private set
+
+  val closeLock = ReentrantLock()
+
+  val statementLifecycleLock = Any()
+  val statements = mutableListOf<NativeStatement>()
+
+  /** How many times JavaScript opened this connection without closing it yet. */
+  private val refCount = AtomicInteger(1)
+
+  /** How many `NativeDatabase` objects that use this connection JavaScript still holds. */
+  private var holders = 0
+  private var isBindingReleased = false
+
+  @Throws(AccessClosedResourceException::class)
+  fun maybeThrowForClosed() {
+    if (isClosed) {
+      throw AccessClosedResourceException()
+    }
+  }
+
+  fun addRef(): Int = refCount.incrementAndGet()
+
+  fun release(): Int = refCount.decrementAndGet()
+
+  @Synchronized
+  fun addHolder() {
+    holders++
+  }
+
+  /** JavaScript let go of a `NativeDatabase` that uses this connection. */
+  @Synchronized
+  fun removeHolder() {
+    holders--
+    releaseBindingIfUnused()
+  }
+
+  @Synchronized
+  fun markClosed() {
+    isClosed = true
+    releaseBindingIfUnused()
+  }
+
+  // The binding goes once the connection is closed and nothing in JavaScript can reach it. A
+  // connection JavaScript dropped while it was open stays usable, so it can still be reopened from
+  // the cache, or closed when the module is destroyed.
+  private fun releaseBindingIfUnused() {
+    if (isClosed && holders == 0 && !isBindingReleased) {
+      isBindingReleased = true
+      ref.close()
+    }
+  }
+}

package/android/src/main/java/expo/modules/sqlite/NativeDatabase.kt

@@ -2,38 +2,151 @@
 
 package expo.modules.sqlite
 
-import expo.modules.kotlin.sharedobjects.SharedRef
-import java.util.concurrent.atomic.AtomicInteger
-import java.util.concurrent.locks.ReentrantLock
+import io.github.expo.modules.v2.ExpoSharedObject
+import io.github.expo.modules.v2.JS
+import io.github.expo.modules.v2.SharedObject
+import io.github.expo.modules.v2.module
 
-internal class NativeDatabase(val databasePath: String, val openOptions: OpenDatabaseOptions) : SharedRef<NativeDatabaseBinding>(NativeDatabaseBinding()) {
-  var isClosed = false
-  val closeLock = ReentrantLock()
+/**
+ * A database JavaScript opened. Opening a database that is already open, without asking for a new
+ * connection, gives a new `NativeDatabase` over the same [DatabaseConnection], so the data and the
+ * open count are shared, as one cached object shared them before.
+ */
+@ExpoSharedObject
+internal class NativeDatabase @JS constructor(
+  databasePath: String,
+  options: OpenDatabaseOptions,
+  serializedData: ByteArray?
+) : SharedObject() {
+  private val module: SQLiteModule = context.module<SQLiteModule>()
+    ?: throw IllegalStateException(
+      "Cannot open the database because the ExpoSQLite module is not installed in this app. " +
+        "Rebuild the app after installing expo-sqlite."
+    )
 
-  // Protect statement registration and cleanup through the final close attempt.
-  // Running statements use their own locks, so interruption need not wait for them.
-  val statementLifecycleLock = Any()
-  val statements = mutableListOf<NativeStatement>()
-  private val refCount = AtomicInteger(1)
+  val connection: DatabaseConnection = module.openConnection(
+    databasePath,
+    options,
+    serializedData
+  )
+    .also {
+      it.addHolder()
+    }
 
-  internal fun addRef(): Int {
-    return refCount.incrementAndGet()
+  override fun sharedObjectDidRelease() {
+    super.sharedObjectDidRelease()
+    connection.removeHolder()
   }
 
-  internal fun release(): Int {
-    return refCount.decrementAndGet()
+  @JS
+  suspend fun initAsync(): Unit = io { module.initDb(connection) }
+
+  @JS
+  fun initSync() {
+    module.initDb(connection)
   }
 
-  override fun equals(other: Any?): Boolean {
-    return other is NativeDatabase && this.ref == other.ref
+  @JS
+  suspend fun isInTransactionAsync(): Boolean = io { isInTransaction() }
+
+  @JS
+  fun isInTransactionSync(): Boolean = isInTransaction()
+
+  @JS
+  suspend fun closeAsync(): Unit = io { module.closeDatabaseIfNeeded(connection) }
+
+  // Interrupt must reach SQLite immediately, without waiting for the running query's queue.
+  @JS
+  fun interruptSync() {
+    // Do not block the JS thread or touch a connection being closed on another thread.
+    if (!connection.closeLock.tryLock()) {
+      throw DatabaseClosingException()
+    }
+    try {
+      connection.maybeThrowForClosed()
+      connection.ref.sqlite3_interrupt()
+    } finally {
+      connection.closeLock.unlock()
+    }
   }
 
-  override fun hashCode(): Int {
-    return ref.hashCode()
+  @JS
+  fun closeSync(): Unit = module.closeDatabaseIfNeeded(connection)
+
+  @JS
+  suspend fun execAsync(source: String): Unit = io { exec(source) }
+
+  @JS
+  fun execSync(source: String): Unit = exec(source)
+
+  @JS
+  suspend fun serializeAsync(databaseName: String): ByteArray = io { serialize(databaseName) }
+
+  @JS
+  fun serializeSync(databaseName: String): ByteArray = serialize(databaseName)
+
+  @JS
+  suspend fun prepareAsync(statement: NativeStatement, source: String): Unit =
+    io { prepare(statement, source) }
+
+  @JS
+  fun prepareSync(statement: NativeStatement, source: String): Unit =
+    prepare(statement, source)
+
+  @JS
+  suspend fun createSessionAsync(session: NativeSession, dbName: String): Unit =
+    io { session.create(connection, dbName) }
+
+  @JS
+  fun createSessionSync(session: NativeSession, dbName: String): Unit =
+    session.create(connection, dbName)
+
+  @JS
+  suspend fun loadExtensionAsync(libPath: String, entryPoint: String?): Unit =
+    io { loadExtension(libPath, entryPoint) }
+
+  @JS
+  fun loadExtensionSync(libPath: String, entryPoint: String?): Unit =
+    loadExtension(libPath, entryPoint)
+
+  @Throws(AccessClosedResourceException::class)
+  private fun isInTransaction(): Boolean {
+    connection.maybeThrowForClosed()
+    return connection.ref.sqlite3_get_autocommit() == 0
   }
 
-  override fun sharedObjectDidRelease() {
-    super.sharedObjectDidRelease()
-    this.ref.close()
+  @Throws(AccessClosedResourceException::class, SQLiteErrorException::class)
+  private fun exec(source: String) {
+    connection.maybeThrowForClosed()
+    connection.ref.sqlite3_exec(source)
+  }
+
+  @Throws(AccessClosedResourceException::class, SQLiteErrorException::class)
+  private fun serialize(databaseName: String): ByteArray {
+    connection.maybeThrowForClosed()
+    return connection.ref.sqlite3_serialize(databaseName)
+  }
+
+  @Throws(AccessClosedResourceException::class, SQLiteErrorException::class)
+  private fun prepare(statement: NativeStatement, source: String) {
+    synchronized(connection.statementLifecycleLock) {
+      synchronized(statement) {
+        statement.maybeThrowForFinalized()
+        connection.maybeThrowForClosed()
+        connection.ref.sqlite3_prepare_v2(source, statement.ref)
+        statement.isPrepared = true
+        connection.statements.add(statement)
+      }
+    }
+  }
+
+  @Throws(AccessClosedResourceException::class, SQLiteErrorException::class)
+  private fun loadExtension(libPath: String, entryPoint: String?) {
+    connection.maybeThrowForClosed()
+    connection.ref.sqlite3_enable_load_extension(1)
+    val ret = connection.ref.sqlite3_load_extension(libPath, entryPoint ?: "")
+    if (ret != NativeDatabaseBinding.SQLITE_OK) {
+      throw SQLiteErrorException(connection.ref.convertSqlLiteErrorToString())
+    }
   }
 }

package/android/src/main/java/expo/modules/sqlite/NativeSession.kt

@@ -2,19 +2,139 @@
 
 package expo.modules.sqlite
 
-import expo.modules.kotlin.sharedobjects.SharedRef
+import io.github.expo.modules.v2.ExpoSharedObject
+import io.github.expo.modules.v2.JS
+import io.github.expo.modules.v2.SharedRef
 
-internal class NativeSession : SharedRef<NativeSessionBinding>(NativeSessionBinding()) {
+@ExpoSharedObject
+internal class NativeSession @JS constructor() : SharedRef<NativeSessionBinding>(NativeSessionBinding()) {
   override fun sharedObjectDidRelease() {
     super.sharedObjectDidRelease()
     this.ref.close()
   }
 
-  override fun equals(other: Any?): Boolean {
-    return other is NativeSession && this.ref == other.ref
+  // region JavaScript members
+
+  @JS
+  suspend fun attachAsync(database: NativeDatabase, table: String?) {
+    io { attach(database.connection, table) }
+  }
+
+  @JS
+  fun attachSync(database: NativeDatabase, table: String?) {
+    attach(database.connection, table)
+  }
+
+  @JS
+  suspend fun enableAsync(database: NativeDatabase, enabled: Boolean) {
+    io { enable(database.connection, enabled) }
+  }
+
+  @JS
+  fun enableSync(database: NativeDatabase, enabled: Boolean) {
+    enable(database.connection, enabled)
+  }
+
+  @JS
+  suspend fun closeAsync(database: NativeDatabase) {
+    io { close(database.connection) }
+  }
+
+  @JS
+  fun closeSync(database: NativeDatabase) {
+    close(database.connection)
+  }
+
+  @JS
+  suspend fun createChangesetAsync(database: NativeDatabase): ByteArray = io { createChangeset(database.connection) }
+
+  @JS
+  fun createChangesetSync(database: NativeDatabase): ByteArray = createChangeset(database.connection)
+
+  @JS
+  suspend fun createInvertedChangesetAsync(database: NativeDatabase): ByteArray =
+    io { createInvertedChangeset(database.connection) }
+
+  @JS
+  fun createInvertedChangesetSync(database: NativeDatabase): ByteArray = createInvertedChangeset(database.connection)
+
+  @JS
+  suspend fun applyChangesetAsync(database: NativeDatabase, changeset: ByteArray) {
+    io { applyChangeset(database.connection, changeset) }
+  }
+
+  @JS
+  fun applyChangesetSync(database: NativeDatabase, changeset: ByteArray) {
+    applyChangeset(database.connection, changeset)
+  }
+
+  @JS
+  suspend fun invertChangesetAsync(database: NativeDatabase, changeset: ByteArray): ByteArray =
+    io { invertChangeset(database.connection, changeset) }
+
+  @JS
+  fun invertChangesetSync(database: NativeDatabase, changeset: ByteArray): ByteArray =
+    invertChangeset(database.connection, changeset)
+
+  // endregion
+
+  @Throws(AccessClosedResourceException::class, SQLiteErrorException::class)
+  fun create(connection: DatabaseConnection, dbName: String) {
+    connection.maybeThrowForClosed()
+    if (ref.sqlite3session_create(connection.ref, dbName) != NativeDatabaseBinding.SQLITE_OK) {
+      throw SQLiteErrorException(connection.ref.convertSqlLiteErrorToString())
+    }
+  }
+
+  @Throws(AccessClosedResourceException::class, SQLiteErrorException::class)
+  private fun attach(connection: DatabaseConnection, table: String?) {
+    connection.maybeThrowForClosed()
+    if (ref.sqlite3session_attach(table) != NativeDatabaseBinding.SQLITE_OK) {
+      throw SQLiteErrorException(connection.ref.convertSqlLiteErrorToString())
+    }
+  }
+
+  @Throws(AccessClosedResourceException::class)
+  private fun enable(connection: DatabaseConnection, enabled: Boolean) {
+    connection.maybeThrowForClosed()
+    ref.sqlite3session_enable(enabled)
+  }
+
+  @Throws(AccessClosedResourceException::class)
+  private fun close(connection: DatabaseConnection) {
+    connection.maybeThrowForClosed()
+    ref.sqlite3session_delete()
+  }
+
+  @Throws(AccessClosedResourceException::class, SQLiteErrorException::class)
+  private fun createChangeset(connection: DatabaseConnection): ByteArray {
+    connection.maybeThrowForClosed()
+    val byteBuffer = ref.sqlite3session_changeset()
+      ?: throw SQLiteErrorException(connection.ref.convertSqlLiteErrorToString())
+    return byteBuffer.toByteArray()
+  }
+
+  @Throws(AccessClosedResourceException::class, SQLiteErrorException::class)
+  private fun createInvertedChangeset(connection: DatabaseConnection): ByteArray {
+    connection.maybeThrowForClosed()
+    val byteBuffer = ref.sqlite3session_changeset_inverted()
+      ?: throw SQLiteErrorException(connection.ref.convertSqlLiteErrorToString())
+    return byteBuffer.toByteArray()
+  }
+
+  @Throws(AccessClosedResourceException::class, SQLiteErrorException::class)
+  private fun applyChangeset(connection: DatabaseConnection, changeset: ByteArray) {
+    connection.maybeThrowForClosed()
+    if (ref.sqlite3changeset_apply(connection.ref, changeset.toDirectBuffer()) != NativeDatabaseBinding.SQLITE_OK) {
+      throw SQLiteErrorException(connection.ref.convertSqlLiteErrorToString())
+    }
   }
 
-  override fun hashCode(): Int {
-    return ref.hashCode()
+  @Throws(AccessClosedResourceException::class, SQLiteErrorException::class)
+  private fun invertChangeset(connection: DatabaseConnection, changeset: ByteArray): ByteArray {
+    connection.maybeThrowForClosed()
+    val byteBuffer = ref.sqlite3changeset_invert(changeset.toDirectBuffer())
+      ?: throw SQLiteErrorException(connection.ref.convertSqlLiteErrorToString())
+    return byteBuffer.toByteArray()
   }
 }