Merge pull request #43 from pointfreeco/improve-delete-efficiency

Improves efficiency of deleting many unsync'd records

Author: stephencelis

Sources/SharingGRDBCore/CloudKit/SyncEngine.swift

@@ -819,6 +819,51 @@
       deletions: [(recordID: CKRecord.ID, recordType: CKRecord.RecordType)] = [],
       syncEngine: any SyncEngineProtocol
     ) async {
+      let recordIDsByRecordType = OrderedDictionary(
+        grouping: deletions.sorted { lhs, rhs in
+          guard
+            let lhsIndex = tablesByOrder[lhs.recordType],
+            let rhsIndex = tablesByOrder[rhs.recordType]
+          else { return true }
+          return lhsIndex > rhsIndex
+        },
+        by: \.recordType
+      )
+        .mapValues { $0.map(\.recordID) }
+      for (recordType, recordIDs) in recordIDsByRecordType {
+        let recordPrimaryKeys = recordIDs.compactMap(\.recordPrimaryKey)
+        if let table = tablesByName[recordType] {
+          func open<T: PrimaryKeyedTable>(_: T.Type) {
+            withErrorReporting(.sqliteDataCloudKitFailure) {
+              try userDatabase.write { db in
+                try T
+                  .where {
+                    $0.primaryKey.in(
+                      recordPrimaryKeys.map { SQLQueryExpression("\(bind: $0)") }
+                    )
+                  }
+                  .delete()
+                  .execute(db)
+
+                try UnsyncedRecordID
+                  .findAll(recordIDs)
+                  .delete()
+                  .execute(db)
+              }
+            }
+          }
+          open(table)
+        } else if recordType == CKRecord.SystemType.share {
+          withErrorReporting {
+            for recordID in recordIDs {
+              try deleteShare(recordID: recordID)
+            }
+          }
+        } else {
+          // NB: Deleting a record from a table we do not currently recognize.
+        }
+      }
+
       let unsyncedRecords =
         await withErrorReporting(.sqliteDataCloudKitFailure) {
           var unsyncedRecordIDs = try await userDatabase.write { db in
@@ -833,9 +878,10 @@
           unsyncedRecordIDs.subtract(modificationRecordIDs)
           if !unsyncedRecordIDsToDelete.isEmpty {
             try await userDatabase.write { db in
-              for recordID in unsyncedRecordIDsToDelete {
-                try UnsyncedRecordID.find(recordID).delete().execute(db)
-              }
+              try UnsyncedRecordID
+                .findAll(unsyncedRecordIDsToDelete)
+                .delete()
+                .execute(db)
             }
           }
           let results = try await syncEngine.database.records(for: Array(unsyncedRecordIDs))
@@ -902,46 +948,6 @@
           }
         }
       }
-
-      let recordIDsByRecordType = OrderedDictionary(
-        grouping: deletions.sorted { lhs, rhs in
-          guard
-            let lhsIndex = tablesByOrder[lhs.recordType],
-            let rhsIndex = tablesByOrder[rhs.recordType]
-          else { return true }
-          return lhsIndex > rhsIndex
-        },
-        by: \.recordType
-      )
-      .mapValues { $0.map(\.recordID) }
-      for (recordType, recordIDs) in recordIDsByRecordType {
-        let recordPrimaryKeys = recordIDs.compactMap(\.recordPrimaryKey)
-        if let table = tablesByName[recordType] {
-          func open<T: PrimaryKeyedTable>(_: T.Type) {
-            withErrorReporting(.sqliteDataCloudKitFailure) {
-              try userDatabase.write { db in
-                try T
-                  .where {
-                    $0.primaryKey.in(
-                      recordPrimaryKeys.map { SQLQueryExpression("\(bind: $0)") }
-                    )
-                  }
-                  .delete()
-                  .execute(db)
-              }
-            }
-          }
-          open(table)
-        } else if recordType == CKRecord.SystemType.share {
-          withErrorReporting {
-            for recordID in recordIDs {
-              try deleteShare(recordID: recordID)
-            }
-          }
-        } else {
-          // NB: Deleting a record from a table we do not currently recognize.
-        }
-      }
     }
 
     package func handleSentRecordZoneChanges(

Sources/SharingGRDBCore/CloudKit/UnsyncedRecordID.swift

@@ -3,7 +3,7 @@
   import StructuredQueriesCore
 
   // @Table("\(String.sqliteDataCloudKitSchemaName)_unsyncedRecordIDs")
-package struct UnsyncedRecordID: Equatable {
+  package struct UnsyncedRecordID: Equatable {
     package let recordName: String
     package let zoneName: String
     package let ownerName: String
@@ -18,8 +18,22 @@ package struct UnsyncedRecordID: Equatable {
     package static func find(_ recordID: CKRecord.ID) -> Where<UnsyncedRecordID> {
       Self.where {
         $0.recordName.eq(recordID.recordName)
-        && $0.zoneName.eq(recordID.zoneID.zoneName)
-        && $0.ownerName.eq(recordID.zoneID.ownerName)
+          && $0.zoneName.eq(recordID.zoneID.zoneName)
+          && $0.ownerName.eq(recordID.zoneID.ownerName)
+      }
+    }
+    package static func findAll(_ recordIDs: some Collection<CKRecord.ID>) -> Where<UnsyncedRecordID> {
+      let condition: QueryFragment = recordIDs.map {
+        "(\(bind: $0.recordName), \(bind: $0.zoneID.zoneName), \(bind: $0.zoneID.ownerName))"
+      }
+      .joined(separator: ", ")
+      return Self.where {
+        SQLQueryExpression(
+          """
+          (\($0.recordName), \($0.zoneName), \($0.ownerName)) \
+          IN (\(condition))
+          """
+        )
       }
     }
   }