expo-sqlite 58.0.9 → 58.0.10

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 58.0.10
+
+### Patch Changes
+
+- [iOS] Speed up binding parameters and reading rows by converting them through typed values instead of `Any`. Reading rows is up to about 3.3 times faster and inserts up to about 2.8 times faster in the native benchmarks.
+
+  A `bigint` bind parameter now binds as a 64-bit integer instead of `NULL`. It still reads back as a number, with the same precision loss above 2^53 as other integer columns.
+
+  `onDatabaseChange` no longer drops the event for a row id above 2^53.
+
+  ([#50894](https://github.com/expo/expo/pull/50894) by [@tsapeta](https://github.com/tsapeta))
+
 ## 58.0.9
 
 ### Patch Changes

package/android/build.gradle

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

package/ios/Benchmarks/JavaScriptBenchmarks.swift

@@ -177,6 +177,71 @@ extension Benchmarks {
     }
   }
 
+  /// `SQLiteDatabase.runSync(source, { $name: value })`: named parameters resolve their index through
+  /// `sqlite3_bind_parameter_index` instead of the array position.
+  @Test
+  func `JS: insert with named parameters`() async throws {
+    try await sqliteBenchmarkCase { appContext in
+      let runtime = try prepareRuntime(appContext)
+      _ = try runtime.eval(
+        """
+        var insert = new NativeStatement();
+        db.prepareSync(insert, 'INSERT INTO t (int_value, real_value, text_value, null_value) VALUES ($i, $r, $t, $n)');
+        """
+      )
+      let run = try driver(
+        runtime,
+        "insert.runSync(db, { $i: i, $r: 1.5, $t: 'row', $n: null }, {}, false);"
+      )
+      try benchmark("JS: runSync insert with 4 named parameters", runtime: runtime) { iterations in
+        _ = try run.call(arguments: iterations)
+      }
+    }
+  }
+
+  /// `SQLiteDatabase.runSync(source, [blob])`: the blob goes through the separate blob parameters.
+  @Test
+  func `JS: insert with a blob parameter`() async throws {
+    try await sqliteBenchmarkCase { appContext in
+      let runtime = try prepareRuntime(appContext)
+      _ = try runtime.eval(
+        """
+        var insert = new NativeStatement();
+        db.prepareSync(insert, 'INSERT INTO blobs (data) VALUES (?)');
+        var blob = new Uint8Array(1024);
+        """
+      )
+      let run = try driver(runtime, "insert.runSync(db, {}, { 0: blob }, true);")
+      try benchmark("JS: runSync insert with a 1 KiB blob parameter", runtime: runtime) { iterations in
+        _ = try run.call(arguments: iterations)
+      }
+    }
+  }
+
+  /// `SQLiteStatement.executeSync(...)` iterated row by row: one native call per row.
+  @Test
+  func `JS: step through 100 rows`() async throws {
+    try await sqliteBenchmarkCase { appContext in
+      let runtime = try prepareRuntime(appContext)
+      _ = try runtime.eval(
+        """
+        var cursor = new NativeStatement();
+        db.prepareSync(cursor, 'SELECT \(BenchmarkSchema.selectColumns) FROM t WHERE id <= 100');
+        """
+      )
+      let run = try driver(
+        runtime,
+        """
+        cursor.resetSync(db);
+        while (cursor.stepSync(db) != null) {}
+        """
+      )
+      try benchmark("JS: stepSync through 100 rows", runtime: runtime) { iterations in
+        _ = try run.call(arguments: iterations)
+      }
+    }
+  }
+
   @Test
   func `JS: column names of a prepared statement`() async throws {
     try await sqliteBenchmarkCase { appContext in

package/ios/DatabaseChangeEvent.swift

@@ -8,8 +8,9 @@ struct DatabaseChangeEvent {
   var databaseName: String
   var databaseFilePath: String
   var tableName: String
-  // `Int` rather than SQLite's `Int64`: a 64-bit integer encodes as a JavaScript BigInt, and JavaScript
-  // reads the row id as a number.
-  var rowId: Int
+  // A `Double` rather than SQLite's `Int64` or an `Int`: JavaScript reads the row id as a number, an
+  // `Int64` would encode as a BigInt, and an `Int` throws above 2^53, which would drop the event. Above
+  // 2^53 it loses precision, like integer columns do.
+  var rowId: Double
   var typeId: SQLAction
 }

package/ios/NativeStatement.swift

@@ -57,6 +57,46 @@ final class NativeStatement: SharedObject, @unchecked Sendable {
     try finalize(database: database)
   }
 
+  @JS(.concurrent)
+  func runAsync(
+    database: NativeDatabase,
+    bindParams: [String: SQLiteBindValue?],
+    bindBlobParams: [String: ArrayBuffer],
+    shouldPassAsArray: Bool
+  ) async throws -> SQLiteRunResult {
+    return try run(database: database, bindParams: bindParams, bindBlobParams: bindBlobParams, shouldPassAsArray: shouldPassAsArray)
+  }
+
+  @JS
+  func runSync(
+    database: NativeDatabase,
+    bindParams: [String: SQLiteBindValue?],
+    bindBlobParams: [String: ArrayBuffer],
+    shouldPassAsArray: Bool
+  ) throws -> SQLiteRunResult {
+    return try run(database: database, bindParams: bindParams, bindBlobParams: bindBlobParams, shouldPassAsArray: shouldPassAsArray)
+  }
+
+  @JS(.concurrent)
+  func stepAsync(database: NativeDatabase) async throws -> [SQLiteColumnValue?]? {
+    return try step(database: database)
+  }
+
+  @JS
+  func stepSync(database: NativeDatabase) throws -> [SQLiteColumnValue?]? {
+    return try step(database: database)
+  }
+
+  @JS(.concurrent)
+  func getAllAsync(database: NativeDatabase) async throws -> [[SQLiteColumnValue?]] {
+    return try getAll(database: database)
+  }
+
+  @JS
+  func getAllSync(database: NativeDatabase) throws -> [[SQLiteColumnValue?]] {
+    return try getAll(database: database)
+  }
+
   // MARK: - Implementation shared by the sync and async members
 
   private func reset(database: NativeDatabase) throws {
@@ -99,6 +139,122 @@ final class NativeStatement: SharedObject, @unchecked Sendable {
       }
     }
   }
+
+  private func run(
+    database: NativeDatabase,
+    bindParams: [String: SQLiteBindValue?],
+    bindBlobParams: [String: ArrayBuffer],
+    shouldPassAsArray: Bool
+  ) throws -> SQLiteRunResult {
+    return try lock.withLock { _ in
+      try ensureNotFinalized()
+      try database.ensureOpen()
+
+      exsqlite3_reset(pointer)
+      exsqlite3_clear_bindings(pointer)
+      for (key, param) in bindParams {
+        let index = try bindParamIndex(for: key, shouldPassAsArray: shouldPassAsArray)
+        guard index > 0 else {
+          continue
+        }
+        if let param {
+          param.bind(to: pointer, at: index)
+        } else {
+          exsqlite3_bind_null(pointer, index)
+        }
+      }
+      for (key, param) in bindBlobParams {
+        let index = try bindParamIndex(for: key, shouldPassAsArray: shouldPassAsArray)
+        if index > 0 {
+          SQLiteBindValue.blob(param).bind(to: pointer, at: index)
+        }
+      }
+
+      let ret = exsqlite3_step(pointer)
+      if ret != SQLITE_ROW && ret != SQLITE_DONE {
+        throw SQLiteErrorException(database.lastErrorMessage())
+      }
+      return SQLiteRunResult(
+        lastInsertRowId: Double(exsqlite3_last_insert_rowid(database.pointer)),
+        changes: Int(exsqlite3_changes(database.pointer)),
+        firstRowValues: ret == SQLITE_ROW ? try columnValues() : []
+      )
+    }
+  }
+
+  private func step(database: NativeDatabase) throws -> [SQLiteColumnValue?]? {
+    return try lock.withLock { _ in
+      try ensureNotFinalized()
+      try database.ensureOpen()
+
+      let ret = exsqlite3_step(pointer)
+      if ret == SQLITE_ROW {
+        return try columnValues()
+      }
+      if ret != SQLITE_DONE {
+        throw SQLiteErrorException(database.lastErrorMessage())
+      }
+      return nil
+    }
+  }
+
+  private func getAll(database: NativeDatabase) throws -> [[SQLiteColumnValue?]] {
+    return try lock.withLock { _ in
+      try ensureNotFinalized()
+      try database.ensureOpen()
+
+      var rows: [[SQLiteColumnValue?]] = []
+      while true {
+        let ret = exsqlite3_step(pointer)
+        if ret == SQLITE_ROW {
+          rows.append(try columnValues())
+          continue
+        }
+        if ret == SQLITE_DONE {
+          break
+        }
+        throw SQLiteErrorException(database.lastErrorMessage())
+      }
+      return rows
+    }
+  }
+
+  /// The values of the current row. Call it inside `lock`, after a step that returned `SQLITE_ROW`.
+  private func columnValues() throws -> [SQLiteColumnValue?] {
+    let columnCount = exsqlite3_column_count(pointer)
+    var values: [SQLiteColumnValue?] = []
+    values.reserveCapacity(Int(columnCount))
+    for index in 0..<columnCount {
+      values.append(try SQLiteColumnValue.read(from: pointer, column: index))
+    }
+    return values
+  }
+
+  /// The 1-based SQLite index of a bind parameter: an array position for positional parameters, or the
+  /// index of the named parameter otherwise. Zero means the statement has no such parameter.
+  private func bindParamIndex(for key: String, shouldPassAsArray: Bool) throws -> Int32 {
+    if shouldPassAsArray {
+      guard let position = Int32(key) else {
+        throw InvalidBindParameterException()
+      }
+      return position + 1
+    }
+    return exsqlite3_bind_parameter_index(pointer, key)
+  }
+}
+
+/// The result of `NativeStatement.run`: the effect of the statement and the values of the first row
+/// it returned, if any.
+@Record
+struct SQLiteRunResult {
+  // A `Double` rather than SQLite's `Int64` or an `Int`: JavaScript reads the row id as a number, an
+  // `Int64` would encode as a BigInt, and an `Int` throws above 2^53. The row id is connection-wide, so a
+  // throw would also fail every later run on the connection. Above 2^53 it loses precision, like integer
+  // columns do.
+  var lastInsertRowId: Double
+  // `sqlite3_changes` returns a 32-bit count, which always fits a JavaScript number.
+  var changes: Int
+  var firstRowValues: [SQLiteColumnValue?]
 }
 
 // `==` lives in an extension: an operator declared inside a type that carries a member-attribute macro

package/ios/SQLiteBindValue.swift

@@ -0,0 +1,39 @@
+// Copyright 2015-present 650 Industries. All rights reserved.
+
+import ExpoModulesCore
+
+/// A bind parameter as it comes from JavaScript: `number | string | boolean | bigint | ArrayBuffer`.
+/// `null` arrives as `nil` of the optional around it.
+///
+/// A union decodes its cases in declaration order and the first match wins, so `double` goes first:
+/// the `Int64` decode accepts any number and rounds it, which would turn `1.5` into `2`. Ordered after
+/// `double`, `integer` only matches a `bigint`.
+@Union
+enum SQLiteBindValue: Sendable {
+  case double(Double)
+  case text(String)
+  case boolean(Bool)
+  case integer(Int64)
+  case blob(ArrayBuffer)
+
+  /// Binds the value to the parameter at `index` of `statement`.
+  @inline(__always)
+  func bind(to statement: OpaquePointer?, at index: Int32) {
+    switch self {
+    case .double(let value):
+      exsqlite3_bind_double(statement, index, value)
+    case .text(let value):
+      exsqlite3_bind_text(statement, index, value, -1, SQLITE_TRANSIENT)
+    case .boolean(let value):
+      exsqlite3_bind_int(statement, index, value ? 1 : 0)
+    case .integer(let value):
+      exsqlite3_bind_int64(statement, index, value)
+    case .blob(let value):
+      _ = value.withUnsafeBytes {
+        exsqlite3_bind_blob(statement, index, $0.baseAddress, Int32(value.byteLength), SQLITE_TRANSIENT)
+      }
+    }
+  }
+}
+
+private let SQLITE_TRANSIENT = unsafeBitCast(OpaquePointer(bitPattern: -1), to: sqlite3_destructor_type.self)

package/ios/SQLiteColumnValue.swift

@@ -0,0 +1,54 @@
+// Copyright 2015-present 650 Industries. All rights reserved.
+
+import ExpoModulesCore
+
+/// A column value as it goes to JavaScript: `number | string | ArrayBuffer`. `NULL` goes as `nil` of
+/// the optional around it.
+///
+/// `INTEGER` columns are read as `double`, so they reach JavaScript as a number, not a `bigint`. That
+/// loses precision above 2^53, as the type-erased conversion did before.
+@Union
+enum SQLiteColumnValue: Sendable, Equatable {
+  case double(Double)
+  case text(String)
+  case blob(ArrayBuffer)
+
+  /// Reads the value of the column at `index` in the current row of `statement`, or `nil` for `NULL`.
+  @inline(__always)
+  static func read(from statement: OpaquePointer?, column index: Int32) throws -> SQLiteColumnValue? {
+    switch exsqlite3_column_type(statement, index) {
+    case SQLITE_INTEGER:
+      return .double(Double(exsqlite3_column_int64(statement, index)))
+    case SQLITE_FLOAT:
+      return .double(exsqlite3_column_double(statement, index))
+    case SQLITE_TEXT:
+      guard let text = exsqlite3_column_text(statement, index) else {
+        throw InvalidConvertibleException("Null text")
+      }
+      return .text(String(cString: text))
+    case SQLITE_BLOB:
+      guard let blob = exsqlite3_column_blob(statement, index) else {
+        return .blob(ArrayBuffer(size: 0))
+      }
+      let size = exsqlite3_column_bytes(statement, index)
+      return .blob(ArrayBuffer.copy(of: blob, count: Int(size)))
+    case SQLITE_NULL:
+      return nil
+    case let type:
+      throw InvalidConvertibleException("Unsupported column type: \(type)")
+    }
+  }
+
+  static func == (lhs: SQLiteColumnValue, rhs: SQLiteColumnValue) -> Bool {
+    switch (lhs, rhs) {
+    case let (.double(lhs), .double(rhs)):
+      return lhs == rhs
+    case let (.text(lhs), .text(rhs)):
+      return lhs == rhs
+    case let (.blob(lhs), .blob(rhs)):
+      return lhs.withUnsafeBytes { lhs in rhs.withUnsafeBytes { rhs in lhs.elementsEqual(rhs) } }
+    default:
+      return false
+    }
+  }
+}

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/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_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.10/expo.modules.sqlite-58.0.10.aar.md5

@@ -0,0 +1 @@
+fad06d1b56a5b3ce76fff8218367c30e

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

@@ -0,0 +1 @@
+daaf8670dcbff2b9ab9410878e0a87e85eabad6f

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

@@ -0,0 +1 @@
+c4c90adee96c2308551babad7ac1fca8e3782ab14771b68933f1151a03436333

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

@@ -0,0 +1 @@
+8da2bcca001991403ad15af7ae5fe40b6f02cf613801c3c109fc64b0a25980c07019c47fca22cbfef180ce826225442d307fc3b4416cc29127fda0c3880c666c

package/local-maven-repo/host/exp/exponent/expo.modules.sqlite/{58.0.9/expo.modules.sqlite-58.0.9.module → 58.0.10/expo.modules.sqlite-58.0.10.module}

@@ -3,7 +3,7 @@
   "component": {
     "group": "host.exp.exponent",
     "module": "expo.modules.sqlite",
-    "version": "58.0.9",
+    "version": "58.0.10",
     "attributes": {
       "org.gradle.status": "release"
     }
@@ -24,13 +24,13 @@
       },
       "files": [
         {
-          "name": "expo.modules.sqlite-58.0.9.aar",
-          "url": "expo.modules.sqlite-58.0.9.aar",
-          "size": 3958907,
-          "sha512": "d3fbb6aad5541429fc0b0c3edb30d9e71f12636e9215617d2cb19750aecb36c4df1efc1bc5f84fb75f816d9db01c4ad9a0f08457d67ae892e2ebb59d3bd26246",
-          "sha256": "96b87814356fa93bcc9eb091c5b2f96f243fa661bd70740c352dae65cca23d8f",
-          "sha1": "3ef893dc3f6aec4bda329646065115814fd42d0a",
-          "md5": "0c582335d4a9a710a780e9e636dbc73a"
+          "name": "expo.modules.sqlite-58.0.10.aar",
+          "url": "expo.modules.sqlite-58.0.10.aar",
+          "size": 3958905,
+          "sha512": "8da2bcca001991403ad15af7ae5fe40b6f02cf613801c3c109fc64b0a25980c07019c47fca22cbfef180ce826225442d307fc3b4416cc29127fda0c3880c666c",
+          "sha256": "c4c90adee96c2308551babad7ac1fca8e3782ab14771b68933f1151a03436333",
+          "sha1": "daaf8670dcbff2b9ab9410878e0a87e85eabad6f",
+          "md5": "fad06d1b56a5b3ce76fff8218367c30e"
         }
       ]
     },
@@ -67,13 +67,13 @@
       ],
       "files": [
         {
-          "name": "expo.modules.sqlite-58.0.9.aar",
-          "url": "expo.modules.sqlite-58.0.9.aar",
-          "size": 3958907,
-          "sha512": "d3fbb6aad5541429fc0b0c3edb30d9e71f12636e9215617d2cb19750aecb36c4df1efc1bc5f84fb75f816d9db01c4ad9a0f08457d67ae892e2ebb59d3bd26246",
-          "sha256": "96b87814356fa93bcc9eb091c5b2f96f243fa661bd70740c352dae65cca23d8f",
-          "sha1": "3ef893dc3f6aec4bda329646065115814fd42d0a",
-          "md5": "0c582335d4a9a710a780e9e636dbc73a"
+          "name": "expo.modules.sqlite-58.0.10.aar",
+          "url": "expo.modules.sqlite-58.0.10.aar",
+          "size": 3958905,
+          "sha512": "8da2bcca001991403ad15af7ae5fe40b6f02cf613801c3c109fc64b0a25980c07019c47fca22cbfef180ce826225442d307fc3b4416cc29127fda0c3880c666c",
+          "sha256": "c4c90adee96c2308551babad7ac1fca8e3782ab14771b68933f1151a03436333",
+          "sha1": "daaf8670dcbff2b9ab9410878e0a87e85eabad6f",
+          "md5": "fad06d1b56a5b3ce76fff8218367c30e"
         }
       ]
     },
@@ -87,8 +87,8 @@
       },
       "files": [
         {
-          "name": "expo.modules.sqlite-58.0.9-sources.jar",
-          "url": "expo.modules.sqlite-58.0.9-sources.jar",
+          "name": "expo.modules.sqlite-58.0.10-sources.jar",
+          "url": "expo.modules.sqlite-58.0.10-sources.jar",
           "size": 12434,
           "sha512": "47d6b003042ef32b80e19b64fd015ffcfa159bb8f08971459211cd6ab971304da58dee6236c2be5319f606f9062d023530dcaa5c2e530bb17e42ab1465d5b95f",
           "sha256": "67dbdc88a1d7fc60c31092ad150a98a30d93d8ca82bbf869609890965425524d",

package/local-maven-repo/host/exp/exponent/expo.modules.sqlite/58.0.10/expo.modules.sqlite-58.0.10.module.md5

@@ -0,0 +1 @@
+ca75ac17a7818d5fc42a65c0840dfe04

package/local-maven-repo/host/exp/exponent/expo.modules.sqlite/58.0.10/expo.modules.sqlite-58.0.10.module.sha1

@@ -0,0 +1 @@
+c83619ccf6810e1e67de33d891531e884de12020

package/local-maven-repo/host/exp/exponent/expo.modules.sqlite/58.0.10/expo.modules.sqlite-58.0.10.module.sha256

@@ -0,0 +1 @@
+dfc2cb2d98cfef3bd6b5be8f805dd3444b34c4755dfc2f6ff0e0b653ba123cd3

package/local-maven-repo/host/exp/exponent/expo.modules.sqlite/58.0.10/expo.modules.sqlite-58.0.10.module.sha512

@@ -0,0 +1 @@
+73ae3ffc162990e89b804689ba3d929767b2619e57e56d78c277b4c772fd8cd284ff0cda1a1418342b5f21c68fd4538548ab273f38c390a31dbd5a6e8800143f

package/local-maven-repo/host/exp/exponent/expo.modules.sqlite/{58.0.9/expo.modules.sqlite-58.0.9.pom → 58.0.10/expo.modules.sqlite-58.0.10.pom}

@@ -9,7 +9,7 @@
   <modelVersion>4.0.0</modelVersion>
   <groupId>host.exp.exponent</groupId>
   <artifactId>expo.modules.sqlite</artifactId>
-  <version>58.0.9</version>
+  <version>58.0.10</version>
   <packaging>aar</packaging>
   <name>expo.modules.sqlite</name>
   <url>https://github.com/expo/expo</url>

package/local-maven-repo/host/exp/exponent/expo.modules.sqlite/58.0.10/expo.modules.sqlite-58.0.10.pom.md5

@@ -0,0 +1 @@
+92a9db327ca2c2ad57ff6a10c3ad05bd

package/local-maven-repo/host/exp/exponent/expo.modules.sqlite/58.0.10/expo.modules.sqlite-58.0.10.pom.sha1

@@ -0,0 +1 @@
+d104ae54dc9a284a629157c7f4bc6a76d4b1d5e3

package/local-maven-repo/host/exp/exponent/expo.modules.sqlite/58.0.10/expo.modules.sqlite-58.0.10.pom.sha256

@@ -0,0 +1 @@
+d46287f54d70926645728cdb6a436ad843ea632fbdf9274a29c6227de2e61532

package/local-maven-repo/host/exp/exponent/expo.modules.sqlite/58.0.10/expo.modules.sqlite-58.0.10.pom.sha512

@@ -0,0 +1 @@
+584fceef6dc748071a484a1cee817dbc73fc8ce8838fbcb29a1d429a2b8eb36d608d7acd3a17c10f8e35a78ded5064bc01bb839376dc11b59e5c82937a23f4bf

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-sqlite",
-  "version": "58.0.9",
+  "version": "58.0.10",
   "description": "Provides access to a database using SQLite (https://www.sqlite.org/). The database is persisted across restarts of your app.",
   "keywords": [
     "async-storage",
@@ -55,8 +55,8 @@
     "@types/jest": "^30.0.0",
     "@types/node": "^22.14.0",
     "@types/react": "~19.3.0",
-    "expo": "58.0.3",
-    "expo-module-scripts": "56.0.6",
+    "expo": "58.0.4",
+    "expo-module-scripts": "56.0.7",
     "react-error-boundary": "^4.0.11",
     "tar": "^7.5.22"
   },

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

@@ -1 +0,0 @@
-0c582335d4a9a710a780e9e636dbc73a

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

@@ -1 +0,0 @@
-3ef893dc3f6aec4bda329646065115814fd42d0a

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

@@ -1 +0,0 @@
-96b87814356fa93bcc9eb091c5b2f96f243fa661bd70740c352dae65cca23d8f

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

@@ -1 +0,0 @@
-d3fbb6aad5541429fc0b0c3edb30d9e71f12636e9215617d2cb19750aecb36c4df1efc1bc5f84fb75f816d9db01c4ad9a0f08457d67ae892e2ebb59d3bd26246

package/local-maven-repo/host/exp/exponent/expo.modules.sqlite/58.0.9/expo.modules.sqlite-58.0.9.module.md5

@@ -1 +0,0 @@
-027bb16e5aa93ebd85e027ee2f46126a

package/local-maven-repo/host/exp/exponent/expo.modules.sqlite/58.0.9/expo.modules.sqlite-58.0.9.module.sha1

@@ -1 +0,0 @@
-214b155b65fff08267e3c51f3c305d0a60393fcd

package/local-maven-repo/host/exp/exponent/expo.modules.sqlite/58.0.9/expo.modules.sqlite-58.0.9.module.sha256

@@ -1 +0,0 @@
-a1a758d13d8bfa0a508a0e8e76d619145bf6e9fed21e2793b4c3250c747ab0e2

package/local-maven-repo/host/exp/exponent/expo.modules.sqlite/58.0.9/expo.modules.sqlite-58.0.9.module.sha512

@@ -1 +0,0 @@
-edceb164c582da1e7acbb0d0e0b64074ef17bb2af5a95a63f0d37e2272b93e8be9802bae030c92050f7dc7b357aa14ccbfa864c78d3818301aec13fecb0b04b0

package/local-maven-repo/host/exp/exponent/expo.modules.sqlite/58.0.9/expo.modules.sqlite-58.0.9.pom.md5

@@ -1 +0,0 @@
-b2d62f1ac9414101b72082d1f7184972

package/local-maven-repo/host/exp/exponent/expo.modules.sqlite/58.0.9/expo.modules.sqlite-58.0.9.pom.sha1

@@ -1 +0,0 @@
-4966c5a227bb7b1cd816624a1c7490c2214b26fd

package/local-maven-repo/host/exp/exponent/expo.modules.sqlite/58.0.9/expo.modules.sqlite-58.0.9.pom.sha256

@@ -1 +0,0 @@
-2835028ead37c42578edaaa5b9c5f7610643bd86b825c6e099c90cbfdc764bd7

package/local-maven-repo/host/exp/exponent/expo.modules.sqlite/58.0.9/expo.modules.sqlite-58.0.9.pom.sha512

@@ -1 +0,0 @@
-f3a422c4b7869c9b5bc74f3d85670925330e84ea0af7dbc1366e13122238618d5615159ab2db6d2e5d1b6a489ea69c2eee6051a395a64d4b4f6c841dc4c4bc23