AI feedback, more tests

Author: simolus3

CHANGELOG.md

@@ -5,6 +5,9 @@
 * Add `opDataTyped` and `previousValuesTyped` to `CrudEntry`, providing typed values instead of strings.
 * Make `CrudBatch`, `CrudEntry` and `CrudTransaction` a concrete struct. Note that these can no longer be created in user code.
 * Remove the internal `withSession` API.
+* Remove internal dependency on the PowerSync Kotlin SDK. Going forward, the Swift SDK is implemented in Swift!
+* Breaking (for internal `SQLiteConnectionPoolProtocol` implementers): Make callbacks generic.
+* Breaking (for internal `SQLiteConnectionLease` implementers): Add methods to run statements.
 
 ## 1.13.1
 

Sources/PowerSync/Implementation/AsyncConnectionPool.swift

@@ -125,7 +125,7 @@ final class AsyncConnectionPool: SQLiteConnectionPoolProtocol {
         }
     }
 
-    func write<T>(onConnection: @escaping @Sendable (any SQLiteConnectionLease) throws -> T) async throws -> T{
+    func write<T>(onConnection: @escaping @Sendable (any SQLiteConnectionLease) throws -> T) async throws -> T {
         let pool = try await obtainInner()
         return try await pool.write { connection in
             try await runBlocking { try onConnection(connection) }

Sources/PowerSync/Implementation/sqlite3/NativeConnectionPool.swift

@@ -68,7 +68,7 @@ final class NativeConnectionPool: Sendable {
         return result
     }
 
-    func withAllConnections<T>(onConnection: (NativeConnectionLease, [NativeConnectionLease]) async throws -> T) async throws -> T{
+    func withAllConnections<T>(onConnection: (NativeConnectionLease, [NativeConnectionLease]) async throws -> T) async throws -> T {
         let write = try await writer.acquire(count: 1)
         let writeLease = write.acquiredItems[0].asLease()
         defer { dispatchWrites(lease: writeLease) }
@@ -134,6 +134,8 @@ struct RawSqliteConnection: ~Copyable {
     }
 }
 
+// We mark this as Sendable because it's only used in a mutex from `ConnectionLeaseContext`.
+// We can't generally assume SQLite connections to be thread-safe.
 struct NativeConnectionLease: SQLiteConnectionLease, @unchecked Sendable {
     let pointer: OpaquePointer
 

Sources/PowerSync/Implementation/sqlite3/NativeStatement.swift

@@ -37,7 +37,10 @@ struct NativeSqliteStatement: ~Copyable {
     }
 
     var columnNames: [String : Int] {
-        return resolvedColumnNames!
+        guard let resolvedColumnNames else {
+            fatalError("columnNames is only available after step()")
+        }
+        return resolvedColumnNames
     }
 
     borrowing func bindValues(_ parameters: [PowerSyncDataType?]) throws(PowerSyncError) {
@@ -79,17 +82,21 @@ struct NativeSqliteStatement: ~Copyable {
         case .double(let value):
             rc = sqlite3_bind_double(self.stmt, index, value)
         case .data(let value):
-            // Data object can be made up of multiple memory regions, so copy once.
-            let buffer = malloc(value.count)!
-            value.copyBytes(to: buffer.assumingMemoryBound(to: UInt8.self), count: value.count)
+            if value.count == 0 {
+                rc = sqlite3_bind_zeroblob(self.stmt, index, 0)
+            } else {
+                // Data object can be made up of multiple memory regions, so copy once.
+                let buffer = malloc(value.count)!
+                value.copyBytes(to: buffer.assumingMemoryBound(to: UInt8.self), count: value.count)
 
-            rc = sqlite3_bind_blob(
-                self.stmt,
-                index,
-                buffer,
-                Int32(value.count),
-                free,
-            )
+                rc = sqlite3_bind_blob(
+                    self.stmt,
+                    index,
+                    buffer,
+                    Int32(value.count),
+                    free,
+                )
+            }
         }
 
         if rc != 0 {

Tests/PowerSyncTests/Implementation/StatementTests.swift

@@ -0,0 +1,40 @@
+import Foundation
+@testable import PowerSync
+import Testing
+
+struct StatementTests {
+    @Test func bindValues() throws {
+        let connection = try DatabaseLocation.inMemory.openConnection(writer: true)
+        let lease = connection.asLease()
+        try lease.withIterator(
+            sql: "SELECT ?, ?, ?, ?, ?, ?, typeof(?), typeof(?)",
+            parameters: [
+                nil,
+                .bool(false),
+                .int32(32),
+                .int64(64),
+                .double(3.14),
+                .string("hello"),
+                .data(Data()),
+                .data(Data([1, 2, 3]))
+            ],
+            callback: { iterator in
+                var hadRow = false
+                try iterator.next { cursor in
+                    hadRow = true
+                    
+                    try #require(cursor.getStringOptional(index: 0) == nil)
+                    try #require(cursor.getBoolean(index: 1) == false)
+                    try #require(cursor.getInt(index: 2) == 32)
+                    try #require(cursor.getInt(index: 3) == 64)
+                    try #require(cursor.getDouble(index: 4) == 3.14)
+                    try #require(cursor.getString(index: 5) == "hello")
+                    try #require(cursor.getString(index: 6) == "blob")
+                    try #require(cursor.getString(index: 7) == "blob")
+                }
+
+                try #require(hadRow)
+            }
+        )
+    }
+}