Optimize a few sync metadata queries

Sources/SQLiteData/CloudKit/CloudKitSharing.swift

@@ -110,9 +110,10 @@
         try await metadatabase.read { db in
           try SyncMetadata
             .where { $0.recordName.eq(recordName) }
+            .select { ($0.recordType, $0.recordName, $0.lastKnownServerRecord) }
             .fetchOne(db)
         } ?? nil
-      guard let metadata
+      guard let (recordType, recordName, lastKnownServerRecord) = metadata
       else {
         throw SharingError(
           recordTableName: T.tableName,
@@ -125,10 +126,10 @@
       }
 
       let rootRecord =
-        metadata.lastKnownServerRecord
+      lastKnownServerRecord
         ?? CKRecord(
-          recordType: metadata.recordType,
-          recordID: CKRecord.ID(recordName: metadata.recordName, zoneID: defaultZone.zoneID)
+          recordType: recordType,
+          recordID: CKRecord.ID(recordName: recordName, zoneID: defaultZone.zoneID)
         )
 
       var existingShare: CKShare? {

Sources/SQLiteData/CloudKit/SyncEngine.swift

@@ -923,53 +923,56 @@
       }
       let deletedRecordNames = deletedRecordIDs.map(\.recordName)
 
-      let (metadataOfDeletions, recordsWithRoot): ([SyncMetadata], [RecordWithRoot]) =
-        await withErrorReporting(.sqliteDataCloudKitFailure) {
-          try await metadatabase.read { db in
-            let metadataOfDeletions = try SyncMetadata.where {
-              $0.recordName.in(deletedRecordNames)
-            }
-            .fetchAll(db)
+      let (sharesToDelete, recordsWithRoot):
+        ([CKShare?], [(lastKnownServerRecord: CKRecord?, rootLastKnownServerRecord: CKRecord?)]) =
+          await withErrorReporting(.sqliteDataCloudKitFailure) {
+            try await metadatabase.read { db in
+              let sharesToDelete =
+                try SyncMetadata
+                .where { $0.isShared && $0.recordName.in(deletedRecordNames) }
+                .select(\.share)
+                .fetchAll(db)
 
-            let recordsWithRoot =
-              try With {
-                SyncMetadata
-                  .where { $0.parentRecordName.is(nil) && $0.recordName.in(deletedRecordNames) }
-                  .select {
-                    RecordWithRoot.Columns(
-                      parentRecordName: $0.parentRecordName,
-                      recordName: $0.recordName,
-                      lastKnownServerRecord: $0.lastKnownServerRecord,
-                      rootRecordName: $0.recordName,
-                      rootLastKnownServerRecord: $0.lastKnownServerRecord
+              let recordsWithRoot =
+                try With {
+                  SyncMetadata
+                    .where { $0.parentRecordName.is(nil) && $0.recordName.in(deletedRecordNames) }
+                    .select {
+                      RecordWithRoot.Columns(
+                        parentRecordName: $0.parentRecordName,
+                        recordName: $0.recordName,
+                        lastKnownServerRecord: $0.lastKnownServerRecord,
+                        rootRecordName: $0.recordName,
+                        rootLastKnownServerRecord: $0.lastKnownServerRecord
+                      )
+                    }
+                    .union(
+                      all: true,
+                      SyncMetadata
+                        .join(RecordWithRoot.all) { $1.recordName.is($0.parentRecordName) }
+                        .select { metadata, tree in
+                          RecordWithRoot.Columns(
+                            parentRecordName: metadata.parentRecordName,
+                            recordName: metadata.recordName,
+                            lastKnownServerRecord: metadata.lastKnownServerRecord,
+                            rootRecordName: tree.rootRecordName,
+                            rootLastKnownServerRecord: tree.lastKnownServerRecord
+                          )
+                        }
                     )
-                  }
-                  .union(
-                    all: true,
-                    SyncMetadata
-                      .join(RecordWithRoot.all) { $1.recordName.is($0.parentRecordName) }
-                      .select { metadata, tree in
-                        RecordWithRoot.Columns(
-                          parentRecordName: metadata.parentRecordName,
-                          recordName: metadata.recordName,
-                          lastKnownServerRecord: metadata.lastKnownServerRecord,
-                          rootRecordName: tree.rootRecordName,
-                          rootLastKnownServerRecord: tree.lastKnownServerRecord
-                        )
-                      }
-                  )
-              } query: {
-                RecordWithRoot
-                  .where { $0.recordName.in(deletedRecordNames) }
-              }
-              .fetchAll(db)
+                } query: {
+                  RecordWithRoot
+                    .where { $0.recordName.in(deletedRecordNames) }
+                    .select { ($0.lastKnownServerRecord, $0.rootLastKnownServerRecord) }
+                }
+                .fetchAll(db)
 
-            return (metadataOfDeletions, recordsWithRoot)
+              return (sharesToDelete, recordsWithRoot)
+            }
           }
-        }
-        ?? ([], [])
+          ?? ([], [])
 
-      let shareRecordIDsToDelete = metadataOfDeletions.compactMap(\.share?.recordID)
+      let shareRecordIDsToDelete = sharesToDelete.compactMap(\.?.recordID)
 
       for recordWithRoot in recordsWithRoot {
         guard
@@ -1873,8 +1876,8 @@
               throw SyncEngine.SchemaError(
                 reason: .uniquenessConstraint,
                 debugDescription: """
-                Uniqueness constraints are not supported for synchronized tables.
-                """
+                  Uniqueness constraints are not supported for synchronized tables.
+                  """
               )
             }
           }