將解析數據與coredata同步后，如何確定要刪除的對象？

Question

我已經成功編寫了代碼，以下載解析對象，獲取數據庫中的當前對象然后進行比較。

我的算法：

我遍歷解析對象並運行fetchrequest並比較其objectID。 如果什么也沒得到，我將為數據庫創建一個新對象。 否則，我然后查看數據庫中的ModifyDate和解析后的updatedAt，然后進行比較以查看是否需要設置新值。 這段代碼很棒。

編碼：

query.findObjectsInBackgroundWithBlock { (objects, error) -> Void in
    if error == nil {
        if let objects = objects {
            for object in objects {
                let object = object as! PFObject
                let name = object["name"] as! String
                let email = object["email"] as! String
                let subjectsTaught = object["subjectsTaught"] as [String: String]
                let category = object["category"] as! String
                let uniqueID = object.objectId!
                let modifiedDate = object.updatedAt!
                let fetchRequest2 = NSFetchRequest(entityName: "Teacher")
                fetchRequest2.predicate = NSPredicate(format: "uniqueID == %@", uniqueID)
                var error2: NSError?
                if let foundTeachers = self.managedObjectContext.executeFetchRequest(fetchRequest2, error: &error2) as? [Teacher] {
                    if foundTeachers.isEmpty == true {
                        let teacher = NSEntityDescription.insertNewObjectForEntityForName("Teacher", inManagedObjectContext: self.managedObjectContext) as! Teacher
                        teacher.name = name
                        teacher.email = email
                        teacher.subjectsTaught = subjectsTaught
                        teacher.category = category
                        teacher.uniqueID = uniqueID
                        teacher.modifiedDate = modifiedDate
                    } else {
                        if let teacher = foundTeachers.first {
                            let date1 = teacher.modifiedDate
                            let date2 = modifiedDate
                            let compareResult = date1.compare(date2)
                            if compareResult == NSComparisonResult.OrderedAscending {
                                teacher.setValue(name, forKey: "name")
                                teacher.setValue(email, forKey: "email")
                                teacher.setValue(subjectsTaught, forKey: "subjectsTaught")
                                teacher.setValue(category, forKey: "category")
                                teacher.setValue(modifiedDate, forKey: "modifiedDate")
                            }
                        }
                    }
                }
                var error: NSError?
                if !self.managedObjectContext.save(&error) {
                    println("Error \(error)")
                    abort()
                }
            }
        }

我的問題是我應該如何找出哪些對象不解析？ 我不想查詢數據庫中每個對象的解析，因為我認為這會占用大量網絡資源。

我是否應該一開始就對所有Teacher對象進行fetchrequest，並在遍歷解析對象時將其刪除？ 如果我還有物體，應該刪除那些物體嗎？

Answer 1

好吧，我知道該怎么辦。 最后，我首先為所有老師運行了一個fetchrequest，並將他們的名字附加到數組中。 在解析迭代過程中，我遍歷教師時從該列表中刪除了教師，最后，使用該列表從數據庫中刪除了教師。

        let fetchRequest = NSFetchRequest()
        fetchRequest.entity = NSEntityDescription.entityForName("Teacher", inManagedObjectContext: self.managedObjectContext)
        var error: NSError?
        var foundTeacherNames = [String]()
        if let foundTeachers = self.managedObjectContext.executeFetchRequest(fetchRequest, error: &error) as? [Teacher] {
            for teacher in foundTeachers {
                foundTeacherNames.append(teacher.name)
            }
        }
        //Find teachers in parse database
        let query = PFQuery(className: "TeacherList")
        query.findObjectsInBackgroundWithBlock { (objects, error) -> Void in
            if error == nil {
                if let objects = objects {
                    for object in objects {
                        let object = object as! PFObject
                        let name = object["name"] as! String
                        let email = object["email"] as! String
                        let subjectsTaught = object["subjectsTaught"] as! [String: String]
                        let category = object["category"] as! String
                        let uniqueID = object.objectId!
                        let modifiedDate = object.updatedAt!
                        let fetchRequest2 = NSFetchRequest(entityName: "Teacher")
                        fetchRequest2.predicate = NSPredicate(format: "uniqueID == %@", uniqueID)
                        var error2: NSError?
                        if let foundTeachers = self.managedObjectContext.executeFetchRequest(fetchRequest2, error: &error2) as? [Teacher] {
                            if foundTeachers.isEmpty == true {
                                let teacher = NSEntityDescription.insertNewObjectForEntityForName("Teacher", inManagedObjectContext: self.managedObjectContext) as! Teacher
                                teacher.name = name
                                teacher.email = email
                                teacher.subjectsTaught = subjectsTaught
                                teacher.category = category
                                teacher.uniqueID = uniqueID
                                teacher.modifiedDate = modifiedDate
                            } else {
                                if let teacher = foundTeachers.first {
                                    let date1 = teacher.modifiedDate
                                    let date2 = modifiedDate
                                    let compareResult = date1.compare(date2)
                                    if compareResult == NSComparisonResult.OrderedAscending {
                                        teacher.setValue(name, forKey: "name")
                                        teacher.setValue(email, forKey: "email")
                                        teacher.setValue(subjectsTaught, forKey: "subjectsTaught")
                                        teacher.setValue(category, forKey: "category")
                                        teacher.setValue(modifiedDate, forKey: "modifiedDate")
                                    }
                                }
                            }
                            if contains(foundTeacherNames, name) {
                                let i = find(foundTeacherNames, name)!
                                foundTeacherNames.removeAtIndex(i)
                            }
                        }
                        var error: NSError?
                        if !self.managedObjectContext.save(&error) {
                            println("Error \(error)")
                            abort()
                        }
                        if !foundTeacherNames.isEmpty {
                            for teacher in foundTeacherNames {
                                let request = NSFetchRequest(entityName: "Teacher")
                                request.predicate = NSPredicate(format: "name = %@", teacher)
                                if let fetchResults = self.managedObjectContext.executeFetchRequest(request, error: nil) as? [NSManagedObject] {
                                    if fetchResults.count != 0 {
                                        self.managedObjectContext.deleteObject(fetchResults[0])
                                    }
                                }

                            }
                        }

Answer 2

是的，最好的方法是獲取所有實體，然后檢查唯一的ID。 您可以使用鍵值編碼（或其Swift等效項，例如map ）來獲取您感興趣的ID。

let existingIDs = entitiesFromParse.map() { $0.uniqueID as? String }

然后，您可以檢查ID是否存在

let idExists = existingIDs.contains(idToCheck)

這比昂貴的多個獲取請求更好。