Swift Core Data Batch Aggiornamento della creazione di record duplicati anziché sovrascrittura

Question

Sembra che il mio NSPredicate non funzioni durante l'aggiornamento dei record Core Data. Quando si effettua una richiesta di recupero, lo stesso NSPredicate funziona senza problemi.

Quando faccio uno Batch Update, crea solo nuovi record duplicati invece di sovrascrivere quelli esistenti come previsto. Perché oh perché?

Ecco il mio codice che fa l'aggiornamento:

let appDelegate = UIApplication.sharedApplication().delegate as AppDelegate 

lazy var managedObjectContext : NSManagedObjectContext? = { 
    if let managedObjectContext = self.appDelegate.managedObjectContext { 
     return managedObjectContext 
    } 
    else { 
     return nil 
    } 
    }() 

func doesMessageExist(id: String) -> Bool { 
    let fetchRequest = NSFetchRequest(entityName: "ChatMessage") 
    let predicate = NSPredicate(format: "id == %@", id) 
    fetchRequest.predicate = predicate 
    fetchRequest.fetchLimit = 1 

    let count = managedObjectContext!.countForFetchRequest(fetchRequest, error: nil) 
    return (count > 0) ? true : false 
} 

func updateMessage(chatMessage: ChatMessage) { 
    var batchRequest = NSBatchUpdateRequest(entityName: "ChatMessage") 

    if doesMessageExist(chatMessage.id) { 
     batchRequest.predicate = NSPredicate(format: "id == %@", chatMessage.id) 
    } 

    batchRequest.propertiesToUpdate = [ 
     "id" : chatMessage.id, 
     "senderUserId" : chatMessage.senderUserId, 
     "senderUsername" : chatMessage.senderUsername, 
     "receiverUserId" : chatMessage.receiverUserId, 
     "receiverUsername" : chatMessage.receiverUsername, 
     "messageType" : chatMessage.messageType, 
     "message" : chatMessage.message, 
     "timestamp" : chatMessage.timestamp 
    ] 

    batchRequest.resultType = .UpdatedObjectsCountResultType 
    var error : NSError? 
    var results = self.managedObjectContext!.executeRequest(batchRequest, error: &error) as NSBatchUpdateResult 
    if error == nil { 
     println("Update Message: \(chatMessage.id) \(results.result)") 
     appDelegate.saveContext() 
    } 
    else { 
     println("Update Message Error: \(error?.localizedDescription)") 
    } 
} 

Ecco il mio ChatMessage classe:

class ChatMessage: NSManagedObject { 

    @NSManaged var id: String 
    @NSManaged var message: String 
    @NSManaged var messageType: String 
    @NSManaged var receiverUserId: String 
    @NSManaged var receiverUsername: String 
    @NSManaged var senderUserId: String 
    @NSManaged var senderUsername: String 
    @NSManaged var timestamp: NSDate 

} 

Ecco i dati Nucleo pila a mio AppDelegate:

lazy var applicationDocumentsDirectory: NSURL = { 
    // The directory the application uses to store the Core Data store file. This code uses a directory named "com.walintukai.LFDate" in the application's documents Application Support directory. 
    let urls = NSFileManager.defaultManager().URLsForDirectory(.DocumentDirectory, inDomains: .UserDomainMask) 
    return urls[urls.count-1] as NSURL 
}() 

lazy var managedObjectModel: NSManagedObjectModel = { 
    // The managed object model for the application. This property is not optional. It is a fatal error for the application not to be able to find and load its model. 
    let modelURL = NSBundle.mainBundle().URLForResource("LFDate", withExtension: "momd")! 
    return NSManagedObjectModel(contentsOfURL: modelURL)! 
}() 

lazy var persistentStoreCoordinator: NSPersistentStoreCoordinator? = { 
    // The persistent store coordinator for the application. This implementation creates and return a coordinator, having added the store for the application to it. This property is optional since there are legitimate error conditions that could cause the creation of the store to fail. 
    // Create the coordinator and store 
    var coordinator: NSPersistentStoreCoordinator? = NSPersistentStoreCoordinator(managedObjectModel: self.managedObjectModel) 
    let url = self.applicationDocumentsDirectory.URLByAppendingPathComponent("LFDate.sqlite") 
    var error: NSError? = nil 
    var failureReason = "There was an error creating or loading the application's saved data." 
    if coordinator!.addPersistentStoreWithType(NSSQLiteStoreType, configuration: nil, URL: url, options: nil, error: &error) == nil { 
     coordinator = nil 
     // Report any error we got. 
     let dict = NSMutableDictionary() 
     dict[NSLocalizedDescriptionKey] = "Failed to initialize the application's saved data" 
     dict[NSLocalizedFailureReasonErrorKey] = failureReason 
     dict[NSUnderlyingErrorKey] = error 
     error = NSError(domain: "YOUR_ERROR_DOMAIN", code: 9999, userInfo: dict) 
     // Replace this with code to handle the error appropriately. 
     // abort() causes the application to generate a crash log and terminate. You should not use this function in a shipping application, although it may be useful during development. 
     NSLog("Unresolved error \(error), \(error!.userInfo)") 
     abort() 
    } 

    return coordinator 
}() 

lazy var managedObjectContext: NSManagedObjectContext? = { 
    // Returns the managed object context for the application (which is already bound to the persistent store coordinator for the application.) This property is optional since there are legitimate error conditions that could cause the creation of the context to fail. 
    let coordinator = self.persistentStoreCoordinator 
    if coordinator == nil { 
     return nil 
    } 
    var managedObjectContext = NSManagedObjectContext() 
    managedObjectContext.persistentStoreCoordinator = coordinator 
    managedObjectContext.mergePolicy = NSOverwriteMergePolicy 
    return managedObjectContext 
}() 

// MARK: - Core Data Saving support 

func saveContext() { 
    dispatch_async(dispatch_get_main_queue(),{ 
     if let moc = self.managedObjectContext { 
      var error: NSError? = nil 
      if moc.hasChanges && !moc.save(&error) { 
       // Replace this implementation with code to handle the error appropriately. 
       // abort() causes the application to generate a crash log and terminate. You should not use this function in a shipping application, although it may be useful during development. 
       NSLog("Database Save Error: \(error), \(error!.userInfo)") 
       abort() 
      } 
     } 
    }); 
} 

Answer 1

La tua funzione doesMessageExist è wron g.

Si verifica il conteggio per la richiesta di recupero non uguale a NSNotFound, che verrà eseguita solo in caso di errore. Se il messaggio non può essere trovato, restituirà zero, se può essere trovato, restituirà uno (o più, se si dispone di più oggetti con lo stesso ID).

Al momento il tuo codice dirà che il messaggio esiste sempre.

Nessuno del codice in questa domanda sta creando nuovi oggetti, a proposito, e executeRequest non è un metodo su NSManagedObjectContext, quindi dovresti probabilmente includere la tua implementazione nella domanda.

Answer 2

Purtroppo, non c'è documentazione per NSBatchUpdateRequest (vergogna su di te, Apple!). Ma le richieste di aggiornamento batch sono state coperte al WWDC 2014, sessione 225 (ecco lo ASCII transcript).

Nella sessione, viene menzionato che gli aggiornamenti batch bypassano NSManagedObjectContext e apportano modifiche direttamente nell'archivio permanente. Quindi, è necessario aggiornare gli oggetti da soli:

So if you're interested in updating your database en masse, setting a flag on a particular column for example, and then reflecting those changes in the UI, you're going to need to get the results or the Managed Object IDs back, so you can tell the object, tell the Managed Object Context to refresh the objects with those IDs.

È necessario specificare altro resultType per la richiesta dei lotti:

batchRequest.resultType = .UpdatedObjectIDsResultType 

E poi, dopo l'esecuzione di richiesta è necessario aggiornare gli oggetti utilizzando la matrice restituita di NSManagedObjectID (esempio di codice da Big Nerd Ranch, riscritto in Swift):

for objectsID in objectsIDs { 
    var error : NSError? = nil 
    if let object = context.existingObjectWithID(objectsID as NSManagedObjectID, error: &error) { 
     context.refreshObject(object, mergeChanges: true) 
    } 
} 

Answer 3

Prova questo codice per NSBatchUpdateRequest con duplicatin fuori g i record in swift3

func batchUpdate{ 
     let appDelegate = UIApplication.shared.delegate as! AppDelegate 
     let managedContext = appDelegate.managedObjectContext 
     let batchRequest = NSBatchUpdateRequest(entityName: "ENTITY_NAME") 
     batchRequest.propertiesToUpdate = [ "PROPERTY_NAME" : "CHANGE_VALUE`enter code here`"] 
     batchRequest.resultType = .updatedObjectIDsResultType 

     do{ 
      let objectIDs = try managedContext.execute(batchRequest) as! NSBatchUpdateResult 
      let objects = objectIDs.result as! [NSManagedObjectID] 

      objects.forEach({ objID in 
       let managedObject = managedContext.object(with: objID) 
       managedContext.refresh(managedObject, mergeChanges: false) 
      }) 
     } catch { 
     } 
}