expo-sqlite 58.0.7 → 58.0.9

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 58.0.9
+
+### Patch Changes
+
+- [Android][iOS] Fixed database closing failure with FTS ([#38168](https://github.com/expo/expo/issues/38168)). ([#50121](https://github.com/expo/expo/pull/50121) by [@savv](https://github.com/savv))
+
+## 58.0.8
+
+### Patch Changes
+
+- Bump precompiled artifacts due to ABI breakage in expo-modules-jsi@58.0.6. ([#50881](https://github.com/expo/expo/pull/50881) by [@kitten](https://github.com/kitten))
+
 ## 58.0.7
 
 ### Patch Changes

package/android/build.gradle

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

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

@@ -8,20 +8,12 @@ namespace jni = facebook::jni;
 
 namespace expo {
 
-namespace {
-
-constexpr char TAG[] = "expo-sqlite";
-
-} // namespace
-
 // static
 void NativeDatabaseBinding::registerNatives() {
   registerHybrid({
       makeNativeMethod("initHybrid", NativeDatabaseBinding::initHybrid),
       makeNativeMethod("sqlite3_changes",
                        NativeDatabaseBinding::sqlite3_changes),
-      makeNativeMethod("sqlite3_finalize_all_statement",
-                       NativeDatabaseBinding::sqlite3_finalize_all_statement),
       makeNativeMethod("sqlite3_close", NativeDatabaseBinding::sqlite3_close),
       makeNativeMethod("sqlite3_interrupt", NativeDatabaseBinding::sqlite3_interrupt),
       makeNativeMethod("sqlite3_db_filename",
@@ -52,20 +44,6 @@ void NativeDatabaseBinding::registerNatives() {
 
 int NativeDatabaseBinding::sqlite3_changes() { return ::exsqlite3_changes(db); }
 
-void NativeDatabaseBinding::sqlite3_finalize_all_statement() {
-  ::exsqlite3_stmt *stmt = ::exsqlite3_next_stmt(db, nullptr);
-  while (stmt) {
-    ::exsqlite3_stmt *nextStmt = ::exsqlite3_next_stmt(db, stmt);
-    int ret = ::exsqlite3_finalize(stmt);
-    if (ret != SQLITE_OK) {
-      std::string error = convertSqlLiteErrorToSTLString();
-      __android_log_print(ANDROID_LOG_WARN, TAG,
-                          "exsqlite3_finalize failed: %s", error.c_str());
-    }
-    stmt = nextStmt;
-  }
-}
-
 void NativeDatabaseBinding::sqlite3_interrupt() { ::exsqlite3_interrupt(db); }
 
 int NativeDatabaseBinding::sqlite3_close() {

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

@@ -21,7 +21,6 @@ public:
 
   // sqlite3 bindings
   int sqlite3_changes();
-  void sqlite3_finalize_all_statement();
   int sqlite3_close();
   void sqlite3_interrupt();
   std::string sqlite3_db_filename(const std::string &databaseName);

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

@@ -59,7 +59,9 @@ std::string NativeStatementBinding::sqlite3_column_name(int index) {
 }
 
 int NativeStatementBinding::sqlite3_finalize() {
-  return ::exsqlite3_finalize(stmt);
+  int ret = ::exsqlite3_finalize(stmt);
+  stmt = nullptr;
+  return ret;
 }
 
 int NativeStatementBinding::sqlite3_reset() { return ::exsqlite3_reset(stmt); }

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

@@ -47,7 +47,7 @@ private:
   friend HybridBase;
   friend NativeDatabaseBinding;
 
-  exsqlite3_stmt *stmt;
+  exsqlite3_stmt *stmt = nullptr;
 };
 
 } // namespace expo

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

@@ -9,6 +9,11 @@ import java.util.concurrent.locks.ReentrantLock
 internal class NativeDatabase(val databasePath: String, val openOptions: OpenDatabaseOptions) : SharedRef<NativeDatabaseBinding>(NativeDatabaseBinding()) {
   var isClosed = false
   val closeLock = ReentrantLock()
+
+  // 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)
 
   internal fun addRef(): Int {

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

@@ -44,7 +44,6 @@ internal class NativeDatabaseBinding : Closeable {
   // region sqlite3 bindings
 
   external fun sqlite3_changes(): Int
-  external fun sqlite3_finalize_all_statement()
   external fun sqlite3_close(): Int
   external fun sqlite3_interrupt()
   external fun sqlite3_db_filename(databaseName: String): String

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

@@ -8,10 +8,18 @@ import java.nio.ByteBuffer
 
 internal class NativeStatement : SharedRef<NativeStatementBinding>(NativeStatementBinding()) {
   var isFinalized = false
+  var isPrepared = false
+  var releasedByJavaScript = false
 
   override fun sharedObjectDidRelease() {
     super.sharedObjectDidRelease()
-    this.ref.close()
+    synchronized(this) {
+      if (isFinalized || !isPrepared) {
+        ref.close()
+      } else {
+        releasedByJavaScript = true
+      }
+    }
   }
 
   override fun equals(other: Any?): Boolean {

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

@@ -27,7 +27,13 @@ internal class InvalidConvertibleException(message: String) :
 
 @DoNotStrip
 internal class UnsupportedOperationException(message: String) :
-  CodedException(if (message.isNotEmpty()) "Unsupported operations: $message" else "Unsupported operations")
+  CodedException(
+    if (message.isNotEmpty()) {
+      "Unsupported operations: $message"
+    } else {
+      "Unsupported operations"
+    }
+  )
 
 internal class AccessClosedResourceException :
   CodedException("Access to closed resource")

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

@@ -141,11 +141,7 @@ class SQLiteModule : Module() {
       }
 
       AsyncFunction("closeAsync") { database: NativeDatabase ->
-        maybeThrowForClosedDatabase(database)
-        val db = removeCachedDatabase(database)
-        if (db != null) {
-          closeDatabase(db)
-        }
+        closeDatabaseIfNeeded(database)
       }.runOnQueue(moduleCoroutineScope)
       // Interrupt must reach SQLite immediately, without waiting for the running query's queue.
       Function("interruptSync") { database: NativeDatabase ->
@@ -161,11 +157,7 @@ class SQLiteModule : Module() {
         }
       }
       Function("closeSync") { database: NativeDatabase ->
-        maybeThrowForClosedDatabase(database)
-        val db = removeCachedDatabase(database)
-        if (db != null) {
-          closeDatabase(db)
-        }
+        closeDatabaseIfNeeded(database)
       }
 
       AsyncFunction("execAsync") { database: NativeDatabase, source: String ->
@@ -242,12 +234,16 @@ class SQLiteModule : Module() {
       }
 
       AsyncFunction("getColumnNamesAsync") { statement: NativeStatement ->
-        maybeThrowForFinalizedStatement(statement)
-        return@AsyncFunction statement.ref.getColumnNames()
+        synchronized(statement) {
+          maybeThrowForFinalizedStatement(statement)
+          return@AsyncFunction statement.ref.getColumnNames()
+        }
       }.runOnQueue(moduleCoroutineScope)
       Function("getColumnNamesSync") { statement: NativeStatement ->
-        maybeThrowForFinalizedStatement(statement)
-        return@Function statement.ref.getColumnNames()
+        synchronized(statement) {
+          maybeThrowForFinalizedStatement(statement)
+          return@Function statement.ref.getColumnNames()
+        }
       }
 
       AsyncFunction("finalizeAsync") { statement: NativeStatement, database: NativeDatabase ->
@@ -371,21 +367,27 @@ class SQLiteModule : Module() {
 
   @Throws(AccessClosedResourceException::class, SQLiteErrorException::class)
   private fun prepareStatement(database: NativeDatabase, statement: NativeStatement, source: String) {
-    maybeThrowForClosedDatabase(database)
-    maybeThrowForFinalizedStatement(statement)
-    if (database.ref.sqlite3_prepare_v2(source, statement.ref) != NativeDatabaseBinding.SQLITE_OK) {
-      throw SQLiteErrorException(database.ref.convertSqlLiteErrorToString())
+    synchronized(database.statementLifecycleLock) {
+      synchronized(statement) {
+        maybeThrowForFinalizedStatement(statement)
+        maybeThrowForClosedDatabase(database)
+        if (database.ref.sqlite3_prepare_v2(source, statement.ref) != NativeDatabaseBinding.SQLITE_OK) {
+          throw SQLiteErrorException(database.ref.convertSqlLiteErrorToString())
+        }
+        statement.isPrepared = true
+        database.statements.add(statement)
+      }
     }
   }
 
   @Throws(AccessClosedResourceException::class, SQLiteErrorException::class)
   private fun run(statement: NativeStatement, database: NativeDatabase, bindParams: Map<String, Any?>, bindBlobParams: Map<String, ArrayBuffer>, shouldPassAsArray: Boolean): Map<String, Any> {
-    maybeThrowForClosedDatabase(database)
-    maybeThrowForFinalizedStatement(statement)
-
     // The statement with parameter bindings is stateful,
     // we have to guard with a critical section for thread safety.
     synchronized(statement) {
+      maybeThrowForFinalizedStatement(statement)
+      maybeThrowForClosedDatabase(database)
+
       statement.ref.sqlite3_reset()
       statement.ref.sqlite3_clear_bindings()
       for ((key, param) in bindParams) {
@@ -429,11 +431,11 @@ class SQLiteModule : Module() {
 
   @Throws(AccessClosedResourceException::class, InvalidConvertibleException::class, SQLiteErrorException::class)
   private fun step(statement: NativeStatement, database: NativeDatabase): SQLiteColumnValues? {
-    maybeThrowForClosedDatabase(database)
-    maybeThrowForFinalizedStatement(statement)
-
     // Guard the stateful statement, see `run` above.
     synchronized(statement) {
+      maybeThrowForFinalizedStatement(statement)
+      maybeThrowForClosedDatabase(database)
+
       val ret = statement.ref.sqlite3_step()
       if (ret == NativeDatabaseBinding.SQLITE_ROW) {
         return statement.getTransformedColumnValues()
@@ -447,11 +449,11 @@ class SQLiteModule : Module() {
 
   @Throws(AccessClosedResourceException::class, InvalidConvertibleException::class, SQLiteErrorException::class)
   private fun getAll(statement: NativeStatement, database: NativeDatabase): List<SQLiteColumnValues> {
-    maybeThrowForClosedDatabase(database)
-    maybeThrowForFinalizedStatement(statement)
-
     // Guard the stateful statement, see `run` above.
     synchronized(statement) {
+      maybeThrowForFinalizedStatement(statement)
+      maybeThrowForClosedDatabase(database)
+
       val columnValuesList = mutableListOf<SQLiteColumnValues>()
       while (true) {
         val ret = statement.ref.sqlite3_step()
@@ -469,11 +471,11 @@ class SQLiteModule : Module() {
 
   @Throws(AccessClosedResourceException::class, SQLiteErrorException::class)
   private fun reset(statement: NativeStatement, database: NativeDatabase) {
-    maybeThrowForClosedDatabase(database)
-    maybeThrowForFinalizedStatement(statement)
-
     // Guard the stateful statement, see `run` above.
     synchronized(statement) {
+      maybeThrowForFinalizedStatement(statement)
+      maybeThrowForClosedDatabase(database)
+
       if (statement.ref.sqlite3_reset() != NativeDatabaseBinding.SQLITE_OK) {
         throw SQLiteErrorException(database.ref.convertSqlLiteErrorToString())
       }
@@ -482,15 +484,23 @@ class SQLiteModule : Module() {
 
   @Throws(AccessClosedResourceException::class, SQLiteErrorException::class)
   private fun finalize(statement: NativeStatement, database: NativeDatabase) {
-    maybeThrowForClosedDatabase(database)
-    maybeThrowForFinalizedStatement(statement)
+    synchronized(database.statementLifecycleLock) {
+      // Guard the stateful statement, see `run` above.
+      synchronized(statement) {
+        maybeThrowForFinalizedStatement(statement)
+        maybeThrowForClosedDatabase(database)
 
-    // Guard the stateful statement, see `run` above.
-    synchronized(statement) {
-      if (statement.ref.sqlite3_finalize() != NativeDatabaseBinding.SQLITE_OK) {
-        throw SQLiteErrorException(database.ref.convertSqlLiteErrorToString())
+        val ret = statement.ref.sqlite3_finalize()
+        // SQLite destroys the statement even when returning an earlier execution error.
+        statement.isFinalized = true
+        database.statements.removeAll { it === statement }
+        if (statement.releasedByJavaScript) {
+          statement.ref.close()
+        }
+        if (ret != NativeDatabaseBinding.SQLITE_OK) {
+          throw SQLiteErrorException(database.ref.convertSqlLiteErrorToString())
+        }
       }
-      statement.isFinalized = true
     }
   }
 
@@ -527,13 +537,15 @@ class SQLiteModule : Module() {
   private fun closeDatabase(database: NativeDatabase) {
     database.closeLock.lock()
     try {
-      maybeThrowForClosedDatabase(database)
-      maybeFinalizeAllStatements(database)
-      val ret = database.ref.sqlite3_close()
-      if (ret != NativeDatabaseBinding.SQLITE_OK) {
-        throw SQLiteErrorException(database.ref.convertSqlLiteErrorToString())
+      synchronized(database.statementLifecycleLock) {
+        maybeThrowForClosedDatabase(database)
+        maybeFinalizeAllStatements(database)
+        val ret = database.ref.sqlite3_close()
+        if (ret != NativeDatabaseBinding.SQLITE_OK) {
+          throw SQLiteErrorException(database.ref.convertSqlLiteErrorToString())
+        }
+        database.isClosed = true
       }
-      database.isClosed = true
     } finally {
       database.closeLock.unlock()
     }
@@ -587,16 +599,22 @@ class SQLiteModule : Module() {
   }
 
   @Synchronized
-  private fun removeCachedDatabase(database: NativeDatabase): NativeDatabase? {
+  private fun closeDatabaseIfNeeded(database: NativeDatabase) {
+    maybeThrowForClosedDatabase(database)
     val index = cachedDatabases.indexOf(database)
     if (index >= 0) {
       val db = cachedDatabases[index]
       if (db.release() == 0) {
+        try {
+          closeDatabase(db)
+        } catch (error: Exception) {
+          // Keep the connection cached and owned so callers can clean up and retry.
+          db.addRef()
+          throw error
+        }
         cachedDatabases.removeAt(index)
-        return db
       }
     }
-    return null
   }
 
   @Synchronized
@@ -615,12 +633,24 @@ class SQLiteModule : Module() {
 
   // region statements managements
 
-  @Synchronized
   private fun maybeFinalizeAllStatements(database: NativeDatabase) {
     if (!database.openOptions.finalizeUnusedStatementsBeforeClosing) {
       return
     }
-    database.ref.sqlite3_finalize_all_statement()
+    // Finalize through the wrappers so even a failed close leaves them invalidated.
+    // Do not destroy SQLite-internal statements owned by concurrent exec/backup operations.
+    var firstError: Exception? = null
+    for (statement in database.statements.toList()) {
+      try {
+        finalize(statement, database)
+      } catch (error: SQLiteErrorException) {
+        android.util.Log.w("expo-sqlite", "Finalizing a statement during close failed", error)
+      } catch (error: Exception) {
+        // A broken wrapper must not prevent cleanup of the remaining statements.
+        firstError = firstError ?: error
+      }
+    }
+    firstError?.let { throw it }
   }
 
   // endregion

package/dev-plugin-dist/+not-found.html

@@ -314,5 +314,5 @@ input::-webkit-search-cancel-button,input::-webkit-search-decoration,input::-web
 @keyframes r-imtty0{0%{opacity:0;}100%{opacity:1;}}
 @keyframes r-q67da2{0%{transform:translateX(-100%);}100%{transform:translateX(400%);}}
 @keyframes r-t2lo5v{0%{opacity:1;}100%{opacity:0;}}</style><script type="module">globalThis.__EXPO_ROUTER_HYDRATE__=true;</script><link rel="preload" href="/_expo/plugins/expo-sqlite/_expo/static/css/global-b1bdf830cdbd0ec4238cc5f230f99460.css" as="style">
-<link rel="stylesheet" href="/_expo/plugins/expo-sqlite/_expo/static/css/global-b1bdf830cdbd0ec4238cc5f230f99460.css"></head><body><div id="root"><div class="css-g5y9jx r-13awgt0"></div></div><script src="/_expo/plugins/expo-sqlite/_expo/static/js/web/__expo-metro-runtime-8c088df87a31e4e6accd81c554ec290d.js" defer></script><script src="/_expo/plugins/expo-sqlite/_expo/static/js/web/_layout-171413bc9bf8452e491f0d7713017a36.js" defer></script><script src="/_expo/plugins/expo-sqlite/_expo/static/js/web/__common-725582fc6bba7ccfc743bb9aba24f9bc.js" defer></script><script src="/_expo/plugins/expo-sqlite/_expo/static/js/web/entry-46e748b71acc826f94c91796cdf4bc28.js" defer></script>
+<link rel="stylesheet" href="/_expo/plugins/expo-sqlite/_expo/static/css/global-b1bdf830cdbd0ec4238cc5f230f99460.css"></head><body><div id="root"><div class="css-g5y9jx r-13awgt0"></div></div><script src="/_expo/plugins/expo-sqlite/_expo/static/js/web/__expo-metro-runtime-8c088df87a31e4e6accd81c554ec290d.js" defer></script><script src="/_expo/plugins/expo-sqlite/_expo/static/js/web/_layout-b2894030c1dfbd95b717a85901b6c271.js" defer></script><script src="/_expo/plugins/expo-sqlite/_expo/static/js/web/__common-9b94dd2fbdbb825a662f42cf8d2077ee.js" defer></script><script src="/_expo/plugins/expo-sqlite/_expo/static/js/web/entry-04fdb7d857a65c0ed638ef2d774a4b6e.js" defer></script>
 </body></html>