expo-sqlite 58.0.9 → 58.0.11

package/ios/SQLiteModule.swift

@@ -2,8 +2,6 @@
 
 import ExpoModulesCore
 
-private typealias SQLiteColumnValues = [Any]
-private let SQLITE_TRANSIENT = unsafeBitCast(OpaquePointer(bitPattern: -1), to: sqlite3_destructor_type.self)
 private let MEMORY_DB_NAME = ":memory:"
 
 private let moduleQueue = DispatchQueue(label: "expo.module.sqlite.AsyncQueue", qos: .userInitiated, attributes: .concurrent)
@@ -172,37 +170,9 @@ public final class SQLiteModule: Module, @unchecked Sendable {
       }
     }
 
-    // MARK: - NativeStatement
-
-    Class(NativeStatement.self) {
-      // swiftlint:disable line_length
-
-      AsyncFunction("runAsync") { (statement: NativeStatement, database: NativeDatabase, bindParams: [String: Any], bindBlobParams: [String: ArrayBuffer], shouldPassAsArray: Bool) -> [String: Any] in
-        return try run(statement: statement, database: database, bindParams: bindParams, bindBlobParams: bindBlobParams, shouldPassAsArray: shouldPassAsArray)
-      }.runOnQueue(moduleQueue)
-      Function("runSync") { (statement: NativeStatement, database: NativeDatabase, bindParams: [String: Any], bindBlobParams: [String: ArrayBuffer], shouldPassAsArray: Bool) -> [String: Any] in
-        return try run(statement: statement, database: database, bindParams: bindParams, bindBlobParams: bindBlobParams, shouldPassAsArray: shouldPassAsArray)
-      }
-
-      // swiftlint:enable line_length
-
-      AsyncFunction("stepAsync") { (statement: NativeStatement, database: NativeDatabase) -> SQLiteColumnValues? in
-        return try step(statement: statement, database: database)
-      }.runOnQueue(moduleQueue)
-      Function("stepSync") { (statement: NativeStatement, database: NativeDatabase) -> SQLiteColumnValues? in
-        return try step(statement: statement, database: database)
-      }
-
-      AsyncFunction("getAllAsync") { (statement: NativeStatement, database: NativeDatabase) -> [SQLiteColumnValues] in
-        return try getAll(statement: statement, database: database)
-      }.runOnQueue(moduleQueue)
-      Function("getAllSync") { (statement: NativeStatement, database: NativeDatabase) -> [SQLiteColumnValues] in
-        return try getAll(statement: statement, database: database)
-      }
-    }
-
-    // MARK: - NativeSession
+    // MARK: - NativeStatement and NativeSession
 
+    NativeStatement._synthesizedClassDefinition()
     NativeSession._synthesizedClassDefinition()
   }
 
@@ -256,84 +226,6 @@ public final class SQLiteModule: Module, @unchecked Sendable {
     }
   }
 
-  // swiftlint:disable line_length
-
-  private func run(statement: NativeStatement, database: NativeDatabase, bindParams: [String: Any], bindBlobParams: [String: any AnyArrayBuffer], shouldPassAsArray: Bool) throws -> [String: Any] {
-    // The statement with parameter bindings is stateful,
-    // we have to guard with a critical section for thread safety.
-    return try statement.lock.withLock { _ -> [String: Any] in
-      try maybeThrowForFinalizedStatement(statement)
-      try maybeThrowForClosedDatabase(database)
-
-      exsqlite3_reset(statement.pointer)
-      exsqlite3_clear_bindings(statement.pointer)
-      for (key, param) in bindParams {
-        let index = try getBindParamIndex(statement: statement, key: key, shouldPassAsArray: shouldPassAsArray)
-        if index > 0 {
-          try bindStatementParam(statement: statement, with: param, at: index)
-        }
-      }
-      for (key, param) in bindBlobParams {
-        let index = try getBindParamIndex(statement: statement, key: key, shouldPassAsArray: shouldPassAsArray)
-        if index > 0 {
-          try bindStatementParam(statement: statement, with: param, at: index)
-        }
-      }
-
-      let ret = exsqlite3_step(statement.pointer)
-      if ret != SQLITE_ROW && ret != SQLITE_DONE {
-        throw SQLiteErrorException(convertSqlLiteErrorToString(database))
-      }
-      let firstRowValues: SQLiteColumnValues = (ret == SQLITE_ROW) ? try getColumnValues(statement: statement) : []
-      return [
-        "lastInsertRowId": Int(exsqlite3_last_insert_rowid(database.pointer)),
-        "changes": Int(exsqlite3_changes(database.pointer)),
-        "firstRowValues": firstRowValues
-      ]
-    }
-  }
-
-  // swiftlint:enable line_length
-
-  private func step(statement: NativeStatement, database: NativeDatabase) throws -> SQLiteColumnValues? {
-    // Guard the stateful statement, see `run` above.
-    return try statement.lock.withLock { _ -> SQLiteColumnValues? in
-      try maybeThrowForFinalizedStatement(statement)
-      try maybeThrowForClosedDatabase(database)
-
-      let ret = exsqlite3_step(statement.pointer)
-      if ret == SQLITE_ROW {
-        return try getColumnValues(statement: statement)
-      }
-      if ret != SQLITE_DONE {
-        throw SQLiteErrorException(convertSqlLiteErrorToString(database))
-      }
-      return nil
-    }
-  }
-
-  private func getAll(statement: NativeStatement, database: NativeDatabase) throws -> [SQLiteColumnValues] {
-    // Guard the stateful statement, see `run` above.
-    return try statement.lock.withLock { _ -> [SQLiteColumnValues] in
-      try maybeThrowForFinalizedStatement(statement)
-      try maybeThrowForClosedDatabase(database)
-
-      var columnValuesList: [SQLiteColumnValues] = []
-      while true {
-        let ret = exsqlite3_step(statement.pointer)
-        if ret == SQLITE_ROW {
-          columnValuesList.append(try getColumnValues(statement: statement))
-          continue
-        }
-        if ret == SQLITE_DONE {
-          break
-        }
-        throw SQLiteErrorException(convertSqlLiteErrorToString(database))
-      }
-      return columnValuesList
-    }
-  }
-
   private func convertSqlLiteErrorToString(_ db: NativeDatabase) -> String {
     return db.lastErrorMessage()
   }
@@ -429,7 +321,7 @@ public final class SQLiteModule: Module, @unchecked Sendable {
           databaseName: String(cString: UnsafePointer(databaseName)),
           databaseFilePath: String(cString: UnsafePointer(databaseFilePath)),
           tableName: String(cString: UnsafePointer(tableName)),
-          rowId: Int(rowId),
+          rowId: Double(rowId),
           typeId: SQLAction.fromCode(value: action)
         ))
       }
@@ -437,90 +329,10 @@ public final class SQLiteModule: Module, @unchecked Sendable {
     contextPair.toOpaque())
   }
 
-  private func getColumnValues(statement: NativeStatement) throws -> SQLiteColumnValues {
-    try maybeThrowForFinalizedStatement(statement)
-    let columnCount = Int(exsqlite3_column_count(statement.pointer))
-    var columnValues: SQLiteColumnValues = Array(repeating: 0, count: columnCount)
-    for i in 0..<columnCount {
-      columnValues[i] = try getColumnValue(statement: statement, at: Int32(i))
-    }
-    return columnValues
-  }
-
-  @inline(__always)
-  private func getColumnValue(statement: NativeStatement, at index: Int32) throws -> Any {
-    let instance = statement.pointer
-    let type = exsqlite3_column_type(instance, index)
-
-    switch type {
-    case SQLITE_INTEGER:
-      return exsqlite3_column_int64(instance, index)
-    case SQLITE_FLOAT:
-      return exsqlite3_column_double(instance, index)
-    case SQLITE_TEXT:
-      guard let text = exsqlite3_column_text(instance, index) else {
-        throw InvalidConvertibleException("Null text")
-      }
-      return String(cString: text)
-    case SQLITE_BLOB:
-      guard let blob = exsqlite3_column_blob(instance, index) else {
-        return ArrayBuffer(size: 0)
-      }
-      let size = exsqlite3_column_bytes(instance, index)
-      return ArrayBuffer.copy(of: blob, count: Int(size))
-    case SQLITE_NULL:
-      return NSNull()
-    default:
-      throw InvalidConvertibleException("Unsupported column type: \(type)")
-    }
-  }
-
-  private func bindStatementParam(statement: NativeStatement, with param: Any, at index: Int32) throws {
-    let instance = statement.pointer
-    switch param {
-    case Optional<Any>.none:
-      exsqlite3_bind_null(instance, index)
-    case _ as NSNull:
-      exsqlite3_bind_null(instance, index)
-    case let param as Int64:
-      exsqlite3_bind_int64(instance, index, Int64(param))
-    case let param as Double:
-      exsqlite3_bind_double(instance, index, param)
-    case let param as String:
-      exsqlite3_bind_text(instance, index, param, -1, SQLITE_TRANSIENT)
-    case let param as any AnyArrayBuffer:
-      _ = param.withUnsafeBytes {
-        exsqlite3_bind_blob(instance, index, $0.baseAddress, Int32(param.byteLength), SQLITE_TRANSIENT)
-      }
-    case let param as Bool:
-      exsqlite3_bind_int(instance, index, param ? 1 : 0)
-    default:
-      throw InvalidConvertibleException("Unsupported parameter type: \(type(of: param))")
-    }
-  }
-
   private func maybeThrowForClosedDatabase(_ database: NativeDatabase) throws {
     try database.ensureOpen()
   }
 
-  private func maybeThrowForFinalizedStatement(_ statement: NativeStatement) throws {
-    try statement.ensureNotFinalized()
-  }
-
-  @inline(__always)
-  private func getBindParamIndex(statement: NativeStatement, key: String, shouldPassAsArray: Bool) throws -> Int32 {
-    let index: Int32
-    if shouldPassAsArray {
-      guard let intKey = Int32(key) else {
-        throw InvalidBindParameterException()
-      }
-      index = intKey + 1
-    } else {
-      index = exsqlite3_bind_parameter_index(statement.pointer, key.cString(using: .utf8))
-    }
-    return index
-  }
-
   // MARK: - cachedDatabases managements
 
   private func addCachedDatabase(_ database: NativeDatabase) {

package/ios/SQLiteResult.swift

@@ -0,0 +1,31 @@
+// Copyright 2026-present 650 Industries. All rights reserved.
+
+// Capture a statement's error while SQLite's recursive connection mutex still protects it.
+// A different statement can otherwise replace both errcode and errmsg before we report the failure.
+internal func sqliteErrorMessage(for db: OpaquePointer?, code: Int32) -> String {
+  let message = String(cString: exsqlite3_errmsg(db), encoding: .utf8) ?? ""
+  return "Error code \(code): \(message)"
+}
+
+internal func withSQLiteDatabaseLock<T>(for db: OpaquePointer?, _ operation: () throws -> T) rethrows -> T {
+  let mutex = exsqlite3_db_mutex(db)
+  exsqlite3_mutex_enter(mutex)
+  defer { exsqlite3_mutex_leave(mutex) }
+  return try operation()
+}
+
+internal func sqliteErrorMessage(for db: OpaquePointer?) -> String {
+  return withSQLiteDatabaseLock(for: db) {
+    return sqliteErrorMessage(for: db, code: exsqlite3_errcode(db))
+  }
+}
+
+internal func sqliteResult(for db: OpaquePointer?, _ operation: () -> Int32) -> (code: Int32, message: String?) {
+  return withSQLiteDatabaseLock(for: db) {
+    let code = operation()
+    guard code != SQLITE_OK && code != SQLITE_ROW && code != SQLITE_DONE else {
+      return (code, nil)
+    }
+    return (code, sqliteErrorMessage(for: db, code: code))
+  }
+}

package/ios/Tests/NativeStatementJavaScriptTests.swift

@@ -0,0 +1,124 @@
+// Copyright 2015-present 650 Industries. All rights reserved.
+
+import Testing
+
+@testable import ExpoModulesCore
+@testable import ExpoSQLite
+
+/// Calls the statement members from JavaScript, so the bind parameters and the column values go
+/// through the `SQLiteBindValue` and `SQLiteColumnValue` conversions and the result has the shape `src/` reads.
+@Suite("NativeStatement from JavaScript")
+@JavaScriptActor
+struct NativeStatementJavaScriptTests {
+  let appContext: AppContext
+  let runtime: ExpoRuntime
+
+  init() throws {
+    appContext = AppContext.create()
+    runtime = try appContext.runtime
+    appContext.moduleRegistry.register(
+      holder: ModuleHolder(appContext: appContext, module: SQLiteModule(appContext: appContext), name: "ExpoSQLite")
+    )
+    _ = try runtime.eval(
+      """
+      var NativeStatement = expo.modules.ExpoSQLite.NativeStatement;
+      var db = new expo.modules.ExpoSQLite.NativeDatabase(':memory:', { useNewConnection: true });
+      db.initSync();
+      db.execSync('CREATE TABLE t (id INTEGER PRIMARY KEY NOT NULL, value TEXT)');
+      function prepare(source) {
+        var statement = new NativeStatement();
+        db.prepareSync(statement, source);
+        return statement;
+      }
+      """
+    )
+  }
+
+  @Test
+  func `run decodes each parameter type and encodes each column type`() throws {
+    let result = try runtime.eval(
+      """
+      (function () {
+        var statement = prepare('SELECT ?, ?, ?, ?, ?, typeof(?), ?');
+        var result = statement.runSync(db, { 0: 7, 1: 1.5, 2: 'text', 3: true, 4: null, 5: 7 }, { 6: new Uint8Array([1, 2, 3]) }, true);
+        var values = result.firstRowValues;
+        return JSON.stringify({
+          values: values.slice(0, 6),
+          blobIsArrayBuffer: values[6] instanceof ArrayBuffer,
+          blob: Array.from(new Uint8Array(values[6])),
+        });
+      })()
+      """
+    )
+    // Numbers bind as doubles, as they did through the type-erased path, so `typeof` reports `real`.
+    #expect(try result.asString() == #"{"values":[7,1.5,"text",1,null,"real"],"blobIsArrayBuffer":true,"blob":[1,2,3]}"#)
+  }
+
+  @Test
+  func `run reports the last insert row id and the changes`() throws {
+    let result = try runtime.eval(
+      """
+      (function () {
+        var statement = prepare('INSERT INTO t (id, value) VALUES ($id, $value)');
+        var result = statement.runSync(db, { $id: 42, $value: 'answer' }, {}, false);
+        return JSON.stringify([result.lastInsertRowId, result.changes, result.firstRowValues]);
+      })()
+      """
+    )
+    #expect(try result.asString() == "[42,1,[]]")
+  }
+
+  @Test
+  func `run reports a last insert row id above 2^53 as a number`() throws {
+    let result = try runtime.eval(
+      """
+      (function () {
+        db.execSync('INSERT INTO t (id, value) VALUES (9007199254740993, "big")');
+        var statement = prepare('SELECT 1');
+        var result = statement.runSync(db, {}, {}, true);
+        return typeof result.lastInsertRowId + ' ' + result.lastInsertRowId;
+      })()
+      """
+    )
+    // Above 2^53 the number loses precision, as integer columns do, but it must not throw. The rowid is
+    // connection-wide, so a throw here would make every later run on the connection fail too.
+    #expect(try result.asString() == "number 9007199254740992")
+  }
+
+  @Test
+  func `step and getAll return rows of column values`() throws {
+    let result = try runtime.eval(
+      """
+      (function () {
+        db.execSync("INSERT INTO t (id, value) VALUES (1, 'one'), (2, NULL)");
+        var statement = prepare('SELECT id, value FROM t ORDER BY id');
+        var stepped = [statement.stepSync(db), statement.stepSync(db), statement.stepSync(db)];
+        statement.resetSync(db);
+        return JSON.stringify({ stepped: stepped, all: statement.getAllSync(db) });
+      })()
+      """
+    )
+    #expect(try result.asString() == #"{"stepped":[[1,"one"],[2,null],null],"all":[[1,"one"],[2,null]]}"#)
+  }
+
+  @Test
+  func `run binds a bigint as an integer`() throws {
+    let result = try runtime.eval(
+      """
+      (function () {
+        var result = prepare('SELECT ?, typeof(?)').runSync(db, { 0: 9007199254740993n, 1: 7n }, {}, true);
+        return JSON.stringify(result.firstRowValues);
+      })()
+      """
+    )
+    // The column comes back as a number, like every integer column, so it loses precision above 2^53.
+    #expect(try result.asString() == #"[9007199254740992,"integer"]"#)
+  }
+
+  @Test
+  func `run rejects a parameter of an unsupported type`() throws {
+    #expect(throws: (any Error).self) {
+      try runtime.eval("prepare('SELECT ?').runSync(db, { 0: Symbol('nope') }, {}, true)")
+    }
+  }
+}

package/ios/Tests/NativeStatementTests.swift

@@ -87,4 +87,126 @@ final class NativeStatementTests {
     try await statement.finalizeAsync(database: database)
     #expect(statement.isFinalized)
   }
+
+  @Test
+  func `run binds positional parameters and reports the changes`() throws {
+    let statement = prepare("INSERT INTO test (id, value) VALUES (?, ?)")
+    let result = try statement.runSync(
+      database: database,
+      bindParams: ["0": .double(3), "1": .text("three")],
+      bindBlobParams: [:],
+      shouldPassAsArray: true
+    )
+    #expect(result.lastInsertRowId == 3)
+    #expect(result.changes == 1)
+    #expect(result.firstRowValues.isEmpty)
+    #expect(selectValue(id: 3) == "three")
+  }
+
+  @Test
+  func `run binds named parameters`() throws {
+    let statement = prepare("INSERT INTO test (id, value) VALUES ($id, $value)")
+    _ = try statement.runSync(
+      database: database,
+      bindParams: ["$id": .double(4), "$value": .text("four")],
+      bindBlobParams: [:],
+      shouldPassAsArray: false
+    )
+    #expect(selectValue(id: 4) == "four")
+  }
+
+  @Test
+  func `run returns the values of the first row`() throws {
+    let statement = prepare("SELECT id, value FROM test WHERE id = ?")
+    let result = try statement.runSync(
+      database: database,
+      bindParams: ["0": .double(2)],
+      bindBlobParams: [:],
+      shouldPassAsArray: true
+    )
+    #expect(result.firstRowValues == [.double(2), .text("two")])
+  }
+
+  @Test
+  func `run binds blob and null parameters`() throws {
+    let statement = prepare("SELECT ?, ?, typeof(?)")
+    let bytes: [UInt8] = [1, 2, 3]
+    let result = try statement.runSync(
+      database: database,
+      bindParams: ["1": nil, "2": nil],
+      bindBlobParams: ["0": ArrayBuffer.copy(of: bytes, count: bytes.count)],
+      shouldPassAsArray: true
+    )
+    #expect(result.firstRowValues.count == 3)
+    #expect(blobBytes(result.firstRowValues[0]) == [1, 2, 3])
+    #expect(result.firstRowValues[1] == nil)
+    #expect(result.firstRowValues[2] == .text("null"))
+  }
+
+  @Test
+  func `step returns one row at a time and nil once done`() throws {
+    let statement = prepare("SELECT id FROM test ORDER BY id")
+    #expect(try statement.stepSync(database: database) == [.double(1)])
+    #expect(try statement.stepSync(database: database) == [.double(2)])
+    #expect(try statement.stepSync(database: database) == nil)
+  }
+
+  @Test
+  func `getAll returns every row with each storage class`() throws {
+    let statement = prepare("SELECT id, value, 1.5, NULL FROM test ORDER BY id")
+    let rows = try statement.getAllSync(database: database)
+    #expect(rows == [
+      [.double(1), .text("one"), .double(1.5), nil],
+      [.double(2), .text("two"), .double(1.5), nil]
+    ])
+  }
+
+  @Test
+  func `run, step and getAll throw once the statement is finalized`() throws {
+    let statement = prepare("SELECT id FROM test")
+    try statement.finalizeSync(database: database)
+    #expect(throws: AccessClosedResourceException.self) {
+      try statement.runSync(database: database, bindParams: [:], bindBlobParams: [:], shouldPassAsArray: true)
+    }
+    #expect(throws: AccessClosedResourceException.self) {
+      try statement.stepSync(database: database)
+    }
+    #expect(throws: AccessClosedResourceException.self) {
+      try statement.getAllSync(database: database)
+    }
+  }
+
+  @Test
+  func `async run, step and getAll run the same operations`() async throws {
+    let statement = prepare("SELECT id FROM test WHERE id >= ? ORDER BY id")
+    let result = try await statement.runAsync(
+      database: database,
+      bindParams: ["0": .double(1)],
+      bindBlobParams: [:],
+      shouldPassAsArray: true
+    )
+    #expect(result.firstRowValues == [.double(1)])
+    #expect(try await statement.stepAsync(database: database) == [.double(2)])
+    #expect(try await statement.stepAsync(database: database) == nil)
+    try statement.resetSync(database: database)
+    #expect(try await statement.getAllAsync(database: database) == [[.double(1)], [.double(2)]])
+  }
+
+  private func selectValue(id: Int32) -> String? {
+    var statement: OpaquePointer?
+    exsqlite3_prepare_v2(database.pointer, "SELECT value FROM test WHERE id = ?", -1, &statement, nil)
+    defer { exsqlite3_finalize(statement) }
+    exsqlite3_bind_int(statement, 1, id)
+    guard exsqlite3_step(statement) == SQLITE_ROW, let text = exsqlite3_column_text(statement, 0) else {
+      return nil
+    }
+    return String(cString: text)
+  }
+
+  private func blobBytes(_ value: SQLiteColumnValue?) -> [UInt8]? {
+    guard case .blob(let buffer)? = value else {
+      return nil
+    }
+    return buffer.withUnsafeBytes { Array($0) }
+  }
 }

package/ios/Tests/SQLiteModuleTests.swift

@@ -1,8 +1,8 @@
 // Copyright 2015-present 650 Industries. All rights reserved.
 
-import ExpoModulesCore
 import Testing
 
+@testable import ExpoModulesCore
 @testable import ExpoSQLite
 
 /// Exercises the module-level surface: the constants JavaScript reads, the change-event payload shape
@@ -47,6 +47,23 @@ struct SQLiteModuleTests {
     #expect(module.hasListeners == false)
   }
 
+  @Test
+  func `database change event encodes a row id above 2^53 as a number`() throws {
+    let appContext = AppContext.create()
+    let runtime = try appContext.runtime
+    let event = DatabaseChangeEvent(
+      databaseName: "main",
+      databaseFilePath: "/tmp/test.db",
+      tableName: "test",
+      rowId: 9007199254740993,
+      typeId: .insert
+    )
+    // Above 2^53 the number loses precision, like integer columns do, but encoding must not fail: a
+    // payload that fails to encode drops the `onDatabaseChange` event.
+    let encoded = try DatabaseChangeEvent.encode(event, in: runtime)
+    #expect(encoded.getObject().getProperty("rowId").getDouble() == 9007199254740992)
+  }
+
   @Test
   func `database change event carries the fields JavaScript reads`() {
     let event = DatabaseChangeEvent(

package/ios/Tests/test_ErrorReporting.swift

@@ -0,0 +1,25 @@
+// Copyright 2026-present 650 Industries. All rights reserved.
+
+import Testing
+
+@testable import ExpoSQLite
+
+@Suite("SQLite error reporting")
+struct SQLiteErrorReportingTests {
+  @Test
+  func `captures the operation code and detail before another statement changes the connection error`() throws {
+    var db: OpaquePointer?
+    #expect(exsqlite3_open(":memory:", &db) == SQLITE_OK)
+    defer { exsqlite3_close(db) }
+    #expect(exsqlite3_exec(db, "CREATE TABLE item(id INTEGER PRIMARY KEY); INSERT INTO item VALUES (1)", nil, nil, nil) == SQLITE_OK)
+    var statement: OpaquePointer?
+    #expect(exsqlite3_prepare_v2(db, "INSERT INTO item VALUES (1)", -1, &statement, nil) == SQLITE_OK)
+    let execution = sqliteResult(for: db) { exsqlite3_step(statement) }
+    let cleanup = sqliteResult(for: db) { exsqlite3_finalize(statement) }
+    #expect(exsqlite3_exec(db, "SELECT 1", nil, nil, nil) == SQLITE_OK)
+    #expect(execution.code == SQLITE_CONSTRAINT)
+    #expect(cleanup.code == SQLITE_CONSTRAINT)
+    #expect(execution.message == "Error code 19: UNIQUE constraint failed: item.id")
+    #expect(cleanup.message == execution.message)
+  }
+}

package/ios/Tests/test_StatementCleanup.swift

@@ -81,4 +81,73 @@ struct StatementCleanupTests {
       #expect(statement.pointer == nil)
     }
   }
+
+  @Test
+  @JavaScriptActor
+  func `run, step and getAll reject a statement that a failed close finalized`() throws {
+    let appContext = AppContext.create()
+    let module = SQLiteModule(appContext: appContext)
+    var pointer: OpaquePointer?
+    var destination: OpaquePointer?
+    #expect(exsqlite3_open(":memory:", &pointer) == SQLITE_OK)
+    #expect(exsqlite3_open(":memory:", &destination) == SQLITE_OK)
+    let database = NativeDatabase(pointer, databasePath: ":memory:", openOptions: OpenDatabaseOptions())
+    defer {
+      if !database.isClosed { try? module.closeDatabase(database) }
+      exsqlite3_close(destination)
+    }
+
+    let statement = NativeStatement()
+    try database.prepareSync(statement: statement, source: "SELECT ? AS value")
+
+    // The pending backup makes the close fail after it has finalized the statement, as above.
+    let backup = try #require(exsqlite3_backup_init(destination, "main", pointer, "main"))
+    defer { exsqlite3_backup_finish(backup) }
+    #expect(throws: SQLiteErrorException.self) { try module.closeDatabase(database) }
+    try #require(statement.isFinalized)
+    #expect(statement.pointer == nil)
+
+    #expect(throws: AccessClosedResourceException.self) {
+      try statement.runSync(database: database, bindParams: ["0": .double(1)], bindBlobParams: [:], shouldPassAsArray: true)
+    }
+    #expect(throws: AccessClosedResourceException.self) { try statement.stepSync(database: database) }
+    #expect(throws: AccessClosedResourceException.self) { try statement.getAllSync(database: database) }
+  }
+
+  @Test
+  func `getAll during close either reads the rows or rejects the finalized statement`() async throws {
+    let appContext = AppContext.create()
+    let module = SQLiteModule(appContext: appContext)
+    for _ in 0..<50 {
+      var pointer: OpaquePointer?
+      #expect(exsqlite3_open(":memory:", &pointer) == SQLITE_OK)
+      let database = NativeDatabase(pointer, databasePath: ":memory:", openOptions: OpenDatabaseOptions())
+      defer {
+        if !database.isClosed { try? module.closeDatabase(database) }
+      }
+      let statement = NativeStatement()
+      try await database.prepareAsync(statement: statement, source: "SELECT 1 AS value UNION ALL SELECT 2")
+      await withTaskGroup(of: Void.self) { group in
+        group.addTask {
+          do {
+            let rows = try await statement.getAllAsync(database: database)
+            #expect(rows == [[.double(1)], [.double(2)]])
+          } catch is AccessClosedResourceException {
+            // Close finalized the statement first.
+          } catch {
+            Issue.record(error)
+          }
+        }
+        group.addTask {
+          do {
+            try module.closeDatabase(database)
+          } catch {
+            Issue.record(error)
+          }
+        }
+      }
+      #expect(database.isClosed)
+      #expect(statement.isFinalized)
+    }
+  }
 }

package/local-maven-repo/host/exp/exponent/expo.modules.sqlite/58.0.11/expo.modules.sqlite-58.0.11-sources.jar.md5

@@ -0,0 +1 @@
+5f6d9bf8e746dacc0378eead6be4ea33

package/local-maven-repo/host/exp/exponent/expo.modules.sqlite/58.0.11/expo.modules.sqlite-58.0.11-sources.jar.sha1

@@ -0,0 +1 @@
+257a7ae7ca2f46a064622513d9ce08b515877773

package/local-maven-repo/host/exp/exponent/expo.modules.sqlite/58.0.11/expo.modules.sqlite-58.0.11-sources.jar.sha256

@@ -0,0 +1 @@
+e4feeb357b13c3da0d6690deff9aab2186a7874185369a06c55fa6da992fdc9c

package/local-maven-repo/host/exp/exponent/expo.modules.sqlite/58.0.11/expo.modules.sqlite-58.0.11-sources.jar.sha512

@@ -0,0 +1 @@
+93ce18d06cc3125618ca50503fd5b7f6d7407b05e931ddf6381fa7e70d8b41c6719c65a433fafa28626a12335b6e9f9a5e4cd05036f715e7a5b01c94047fddf7

package/local-maven-repo/host/exp/exponent/expo.modules.sqlite/58.0.11/expo.modules.sqlite-58.0.11.aar.md5

@@ -0,0 +1 @@
+91c6e3c5043af7233d9dc78dccd8b0a9

package/local-maven-repo/host/exp/exponent/expo.modules.sqlite/58.0.11/expo.modules.sqlite-58.0.11.aar.sha1

@@ -0,0 +1 @@
+63ce3f0e1b020dae031364283a1159bcdd8be178

package/local-maven-repo/host/exp/exponent/expo.modules.sqlite/58.0.11/expo.modules.sqlite-58.0.11.aar.sha256

@@ -0,0 +1 @@
+0832753b21e57b16e425e77702b1f0fdcb2cf1a6614c5a5bc0721f92bf3fb60c

package/local-maven-repo/host/exp/exponent/expo.modules.sqlite/58.0.11/expo.modules.sqlite-58.0.11.aar.sha512

@@ -0,0 +1 @@
+fe5e05c035e8a3b493952282f2a26f117cf856664daf52600e32e532e1767da7a0636626289a4a99fcd50afabbe4f558d8015e0a2df8f4ced1b5eaeea59e216a