expo-sqlite 58.0.8 → 58.0.10

package/ios/SQLiteModule.swift

@@ -2,14 +2,12 @@
 
 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)
 
 // `@unchecked Sendable`: the `@JS(.concurrent)` members send the module off the JavaScript thread, which
-// Swift 6 mode allows only for a `Sendable` module. The mutable state is either guarded by `lockQueue` or
+// Swift 6 mode allows only for a `Sendable` module. The mutable state is either guarded by `cacheLock` or
 // only read off the JavaScript thread (`hasListeners`).
 @ExpoModule("ExpoSQLite")
 public final class SQLiteModule: Module, @unchecked Sendable {
@@ -17,7 +15,8 @@ public final class SQLiteModule: Module, @unchecked Sendable {
   // will release the pair when `closeDatabase` is called.
   private var contextPairs = [Unmanaged<AnyObject>]()
 
-  private static let lockQueue = DispatchQueue(label: "expo.modules.sqlite.lockQueue")
+  // Closing a cached connection also releases its update-hook context under this lock.
+  private static let cacheLock = NSRecursiveLock()
   private var cachedDatabases = [NativeDatabase]()
   private(set) var hasListeners = false
 
@@ -154,10 +153,7 @@ public final class SQLiteModule: Module, @unchecked Sendable {
       }
 
       AsyncFunction("closeAsync") { (database: NativeDatabase) in
-        try maybeThrowForClosedDatabase(database)
-        if let db = removeCachedDatabase(of: database) {
-          try closeDatabase(db)
-        }
+        try closeDatabaseIfNeeded(database)
       }.runOnQueue(moduleQueue)
       // Interrupt must reach SQLite immediately, without waiting for the running query's queue.
       Function("interruptSync") { (database: NativeDatabase) in
@@ -170,44 +166,13 @@ public final class SQLiteModule: Module, @unchecked Sendable {
         exsqlite3_interrupt(database.pointer)
       }
       Function("closeSync") { (database: NativeDatabase) in
-        try maybeThrowForClosedDatabase(database)
-        if let db = removeCachedDatabase(of: database) {
-          try closeDatabase(db)
-        }
+        try closeDatabaseIfNeeded(database)
       }
     }
 
-    // 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()
   }
 
@@ -261,98 +226,28 @@ 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] {
-    try maybeThrowForClosedDatabase(database)
-    try maybeThrowForFinalizedStatement(statement)
-
-    // 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
-      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? {
-    try maybeThrowForClosedDatabase(database)
-    try maybeThrowForFinalizedStatement(statement)
-
-    // Guard the stateful statement, see `run` above.
-    return try statement.lock.withLock { _ -> SQLiteColumnValues? in
-      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] {
-    try maybeThrowForClosedDatabase(database)
-    try maybeThrowForFinalizedStatement(statement)
-
-    // Guard the stateful statement, see `run` above.
-    return try statement.lock.withLock { _ -> [SQLiteColumnValues] in
-      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()
   }
 
-  private func closeDatabase(_ db: NativeDatabase) throws {
+  func closeDatabase(_ db: NativeDatabase) throws {
+    Self.cacheLock.lock()
+    defer { Self.cacheLock.unlock() }
     db.closeLock.lock()
     defer { db.closeLock.unlock() }
-    try maybeThrowForClosedDatabase(db)
+    db.statementLifecycleLock.lock()
+    defer { db.statementLifecycleLock.unlock() }
+    try db.ensureOpen()
     try maybeFinalizeAllStatements(db)
 
     let ret = exsqlite3_close(db.pointer)
+    // SQLITE_BUSY leaves the connection open, including its update hook.
+    if ret != SQLITE_OK {
+      throw SQLiteErrorException(convertSqlLiteErrorToString(db))
+    }
     db.isClosed = true
 
-    Self.lockQueue.sync {
+    Self.cacheLock.withLock {
       if let index = contextPairs.firstIndex(where: {
         guard let pair = $0.takeUnretainedValue() as? (SQLiteModule, NativeDatabase) else {
           return false
@@ -366,10 +261,6 @@ public final class SQLiteModule: Module, @unchecked Sendable {
         contextPairs.remove(at: index)
       }
     }
-
-    if ret != SQLITE_OK {
-      throw SQLiteErrorException(convertSqlLiteErrorToString(db))
-    }
   }
 
   private func deleteDatabase(databasePath: String) throws {
@@ -412,7 +303,7 @@ public final class SQLiteModule: Module, @unchecked Sendable {
 
   private func addUpdateHook(_ database: NativeDatabase) {
     let contextPair = Unmanaged.passRetained(((self, database) as AnyObject))
-    Self.lockQueue.sync {
+    Self.cacheLock.withLock {
       contextPairs.append(contextPair)
     }
     // swiftlint:disable:next multiline_arguments
@@ -430,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)
         ))
       }
@@ -438,114 +329,39 @@ 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) {
-    Self.lockQueue.sync {
+    Self.cacheLock.withLock {
       cachedDatabases.append(database)
     }
   }
 
-  @discardableResult
-  private func removeCachedDatabase(of database: NativeDatabase) -> NativeDatabase? {
-    return Self.lockQueue.sync {
+  private func closeDatabaseIfNeeded(_ database: NativeDatabase) throws {
+    try Self.cacheLock.withLock {
+      try maybeThrowForClosedDatabase(database)
       if let index = cachedDatabases.firstIndex(of: database) {
         let db = cachedDatabases[index]
         if db.release() == 0 {
+          do {
+            try closeDatabase(db)
+          } catch {
+            // Keep the connection cached and owned so callers can clean up and retry.
+            db.addRef()
+            throw error
+          }
           cachedDatabases.remove(at: index)
-          return db
         }
       }
-      return nil
     }
   }
 
   private func findCachedDatabase(where predicate: (NativeDatabase) -> Bool) -> NativeDatabase? {
-    return Self.lockQueue.sync {
+    return Self.cacheLock.withLock {
       if let database = cachedDatabases.first(where: predicate) {
         return database
       }
@@ -554,7 +370,7 @@ public final class SQLiteModule: Module, @unchecked Sendable {
   }
 
   private func removeAllCachedDatabases() -> [NativeDatabase] {
-    return Self.lockQueue.sync {
+    return Self.cacheLock.withLock {
       let databases = cachedDatabases
       cachedDatabases.removeAll()
       return databases
@@ -566,17 +382,14 @@ public final class SQLiteModule: Module, @unchecked Sendable {
     guard database.openOptions.finalizeUnusedStatementsBeforeClosing else {
       return
     }
-    var stmt: OpaquePointer? = exsqlite3_next_stmt(database.pointer, nil)
-    if stmt == nil {
-      return
-    }
-    while let currentStmt = stmt {
-      let nextStmt = exsqlite3_next_stmt(database.pointer, currentStmt)
-      let ret = exsqlite3_finalize(currentStmt)
-      if ret != SQLITE_OK {
-        ExpoModulesCore.log.warn("exsqlite3_finalize failed: \(convertSqlLiteErrorToString(database))")
+    // Finalize through the wrappers so even a failed close leaves them invalidated.
+    // Do not destroy SQLite-internal statements owned by concurrent exec/backup operations.
+    for statement in database.statements {
+      do {
+        try statement.finalize(database: database)
+      } catch {
+        ExpoModulesCore.log.warn("Finalizing a statement during close failed: \(error)")
       }
-      stmt = nextStmt
     }
   }
 }

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(