Use high-level GRDB APIs to run statements

Author: simolus3

Demos/GRDBDemo/GRDBDemo.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved

@@ -60,7 +60,7 @@ let package = Package(
         )
     ],
     dependencies: conditionalDependencies + [
-        .package(url: "https://github.com/groue/GRDB.swift.git", from: "7.9.0"),
+        .package(url: "https://github.com/groue/GRDB.swift.git", from: "7.11.0"),
         .package(url: "https://github.com/powersync-ja/CSQLite.git", exact: "3.51.2"),
         .package(url: "https://github.com/apple/swift-async-algorithms.git", from: "1.1.0"),
         .package(url: "https://github.com/apple/swift-collections.git", from: "1.4.0")

Package.resolved

@@ -1,3 +1,2 @@
 // The current version of the PowerSync Swift SDK. This should be updated to the latest version in `CHANGELOG.md` when a new version is released.
-let libraryVersion = "1.14.0"
-
+let libraryVersion = "1.14.1"

Package.swift

@@ -0,0 +1,32 @@
+import GRDB
+
+class AllWritesObserver: TransactionObserver {
+    private(set) var committedTables: Set<String> = []
+    private var uncomittedTables: Set<String> = []
+
+    var databaseEventObservationStrategy: DatabaseEventObservationStrategy {
+        var strategy = DatabaseEventObservationStrategy.default
+        // Don't filter on database event kind, so that we are
+        // notified of changes performed through the SQLite C API:
+        strategy.requiresDatabaseEventKind = false
+        return strategy
+    }
+
+    func observes(eventsOfKind eventKind: DatabaseEventKind) -> Bool {
+        // This will never be called since requiresDatabaseEventKind is false
+        true
+    }
+
+    func databaseDidChange(with event: DatabaseEvent) {
+        uncomittedTables.insert(event.tableName)
+    }
+
+    func databaseDidCommit(_ db: GRDB.Database) {
+        committedTables.formUnion(uncomittedTables)
+        uncomittedTables.removeAll()
+    }
+
+    func databaseDidRollback(_ db: GRDB.Database) {
+        uncomittedTables.removeAll()
+    }
+}

Sources/PowerSync/CurrentVersion.swift

@@ -17,4 +17,38 @@ final class GRDBConnectionLease: SQLiteConnectionLease {
         self.pointer = connection
         self.database = database
     }
-}
+
+    func execute(sql: String, parameters: [PowerSyncDataType?]) throws -> Int64 {
+        try database.execute(sql: sql, arguments: StatementArguments(parameters))
+        return Int64(database.changesCount)
+    }
+
+    func withIterator<T>(sql: String, parameters: [PowerSyncDataType?], callback: (any SQLiteStatementIteratorProtocol) throws -> T) throws -> T {
+        let statement = try database.makeStatement(sql: sql)
+        let rows = try Row.fetchCursor(statement, arguments: StatementArguments(parameters))
+        return try callback(RowIterator(rows: rows))
+    }
+}
+
+extension PowerSync.PowerSyncDataType: DatabaseValueConvertible {
+    public var databaseValue: GRDB.DatabaseValue {
+        switch self {
+        case .bool(let value):
+            return value.databaseValue
+        case .string(let value):
+            return value.databaseValue
+        case .int64(let value):
+            return value.databaseValue
+        case .int32(let value):
+            return value.databaseValue
+        case .double(let value):
+            return value.databaseValue
+        case .data(let value):
+            return value.databaseValue
+        }
+    }
+
+    public static func fromDatabaseValue(_ dbValue: GRDB.DatabaseValue) -> PowerSync.PowerSyncDataType? {
+        nil
+    }
+}

Sources/PowerSyncGRDB/Connections/AllWritesObserver.swift

@@ -52,17 +52,12 @@ actor GRDBConnectionPool: SQLiteConnectionPoolProtocol {
     ) async throws -> T {
         // Don't start an explicit transaction, we do this internally.
         let (result, updates) = try await pool.writeWithoutTransaction { database in
-            // This installs a temporary update hook, which breaks if GRDB had its own. Currently, we rely on
-            // GRDB only installing update hooks for statements that need it (see https://github.com/groue/GRDB.swift/blob/36e30a6f1ef10e4194f6af0cff90888526f0c115/GRDB/Core/TransactionObserver.swift#L266-L275),
-            // note that `statementObservations` is set in `statementWillExecute` and cleared after a statement
-            // has completed or failed.
-            // So since we have exclusive access to the write connection here, no GRDB-active statement can run and we
-            // can safely install our own hooks.
-            // In the future, we would like to use high-level GRDB APIs for this instead. However, we're blocked
-            // by https://github.com/groue/GRDB.swift/issues/1863 on that.
-            try collectWrites(db: database.sqliteConnection!) {
-                try onConnection(GRDBConnectionLease(database: database))
-            }
+            let observer = AllWritesObserver()
+            database.add(transactionObserver: observer)
+            defer { database.remove(transactionObserver: observer) }
+            
+            let result = try onConnection(GRDBConnectionLease(database: database))
+            return (result, observer.committedTables)
         }
 
         if !updates.isEmpty {

Sources/PowerSyncGRDB/Connections/GRDBConnectionLease.swift

@@ -0,0 +1,92 @@
+import GRDB
+import PowerSync
+
+final class RowIterator: PowerSync.SQLiteStatementIteratorProtocol {
+    let rows: RowCursor
+    var columnNames: [String: Int]? = nil
+    
+    init(rows: RowCursor) {
+        self.rows = rows
+    }
+
+    func next<T>(callback: (any SqlCursor) throws -> T) throws -> T? {
+        guard let row = try rows.next() else {
+            return nil
+        }
+        
+        return try callback(RowSqlCursor(columnNames: resolveColumnNames(), row: row))
+    }
+
+    private func resolveColumnNames() -> [String: Int] {
+        if let columnNames {
+            return columnNames
+        }
+        
+        var names: [String: Int] = [:]
+        for (i, name) in rows.columnNames.enumerated() {
+            names[name] = i
+        }
+        columnNames = names
+        return names
+    }
+}
+
+struct RowSqlCursor: PowerSync.SqlCursor {
+    let columnNames: [String: Int]
+    let row: Row
+    
+    private func checkNotNull(index: Int) throws(PowerSync.SqlCursorError) {
+        if row.hasNull(atIndex: index) {
+            throw .nullValueFound("\(index)")
+        }
+    }
+    
+    public func getBoolean(index: Int) throws(PowerSync.SqlCursorError) -> Bool {
+        try checkNotNull(index: index)
+        return row.self[index]
+    }
+    
+    public func getBooleanOptional(index: Int) -> Bool? {
+        return row.self[index]
+    }
+    
+    public func getDouble(index: Int) throws(PowerSync.SqlCursorError) -> Double {
+        try checkNotNull(index: index)
+        return row.self[index]
+    }
+    
+    public func getDoubleOptional(index: Int) -> Double? {
+        return row.self[index]
+    }
+    
+    public func getInt(index: Int) throws(PowerSync.SqlCursorError) -> Int {
+        try checkNotNull(index: index)
+        return row.self[index]
+    }
+
+    public func getIntOptional(index: Int) -> Int? {
+        return row.self[index]
+    }
+    
+    public func getInt64(index: Int) throws(PowerSync.SqlCursorError) -> Int64 {
+        try self.checkNotNull(index: index)
+        return row.self[index]
+    }
+    
+    public func getInt64Optional(index: Int) -> Int64? {
+        return row.self[index]
+    }
+    
+    public func getString(index: Int) throws(PowerSync.SqlCursorError) -> String {
+        try self.checkNotNull(index: index)
+        return row.self[index]
+    }
+    
+    public func getStringOptional(index: Int) -> String? {
+        return row.self[index]
+    }
+    
+    public var columnCount: Int {
+        row.count
+    }
+}