How to avoid changing property values in an NSBatchInsertRequest?

Question

I have a simple Core Data entity Story that occasionally I update with the latest data from a network call. This network call sometimes updates many, many stories instances, so I run an NSBatchInsertRequest, shown below. (The other reason I'm using a batch insert is that many stories might need to be added to the persistent store.)

The problem is a user can have already marked a Story as a favorite. When they do that, I set story.isFavorite = true on the main thread and save viewContext.

However, when the batch insert occurs it overwrites story.isFavorite, setting it back to false, even though I'm using NSMergeByPropertyObjectTrumpMergePolicy on both the batch insert and view contexts. I am not touching story.isFavorite in the batch insert handler either so I don't expect that property to be overwritten.

I thought the benefit of a batch insert with this merge policy was to avoid first fetching + then manually updating changed properties + finally saving. What is the right way to avoid changing property values in an NSBatchInsertRequest?

Story

@objc(Story)
public class Story: NSManagedObject {

    @NSManaged public var title:       String?
    @NSManaged public var storyURL:    URL?
    @NSManaged public var updatedTime: Date?
    @NSManaged public var isFavorite:  Bool // <- the problem property
}

Batch insert

container.viewContext.mergePolicy = NSMergeByPropertyObjectTrumpMergePolicy
container.viewContext.automaticallyMergesChangesFromParent = false

let context = NSManagedObjectContext(concurrencyType: .privateQueueConcurrencyType)
context.parent = container.viewContext
context.mergePolicy = NSMergeByPropertyObjectTrumpMergePolicy

context.perform {

    let batchInsert = NSBatchInsertRequest(entity: Story.entity(), managedObjectHandler: { managedObject in
        let story         = managedObject as! Story
        let storyResponse = downloadedStories[I]

        // Update story with latest response data BUT don't modify story.isFavorite.

        story.title       = storyResponse.title
        story.storyURL    = storyResponse.storyURL
        story.updatedTime = storyResponse.updatedTime
        
        // ...
    })

    let result = try context.execute(batchInsert) as? NSBatchInsertResult
    if let insertedIDs = result?.result as? [NSManagedObjectID] {
        // Merge changes into parent context. Skip save() because not needed for batch insert.
        NSManagedObjectContext.mergeChanges(fromRemoteContextSave: [NSInsertedObjectsKey: insertedIDs], into: [container.viewContext])
    }
}

Edit

The Story entity does have a unique value constraint using attribute storyURL.

Update after Michael Tsai's answer

By making the Story entity attribute isFavorite a non-Optional Boolean without a default value (it was marked as Optional before, though I'm not sure it makes a difference here) and keeping the Use Scalar Type box checked, I can confirm that existing objects in the store will not be modified (at all) with this configuration of the batch insert context.

context.persistentStoreCoordinator = container.persistentStoreCoordinator

// HOWEVER, observe that regardless of the merge policy below,
// setting `context.parent = container.viewContext` will also
// overwrite the store data!

context.mergePolicy = NSMergeByPropertyStoreTrumpMergePolicy 
// NSMergeByPropertyObjectTrumpMergePolicy ignores objects in the store
// (which have the same unique constraint value, here equal `storyURL`)
// and overwrites all properties.

// To confirm that the batch insert operation does not modify
// existing Story instances (at all), first delete all instances where
// where isFavorite == false. Then load the all story data again and
// execute the NSBatchInsertRequest with this change to managedObjectHandler:

story.title = storyResponse.title + " (modified)"

You will see the missing stories get inserted back, this time with their titles having a suffix " (modified)"; but previously favorited stories do not get modified (basically, with this setup, the batch insert won't re-insert objects).

So the isFavorite property does not get overwritten BUT neither do any properties that should be changed (because they received a new title, for example).

Therefore, if you don't want your objects to get updated, but you want completely new objects to be inserted, you can use this approach.

However, if you are expecting your objects to require updates here are some alternatives:

• you may opt to run a separate update operation, maybe an NSBatchUpdateRequest after you run your batch insert in this way,
• or after the batch insert, you can update certain properties in a simple loop in a (possibly background/child) context without a batch operation, which could be fine if there isn't tons of data;
• lastly, you might be able to first batch insert new data to a temporary store before somehow manually merging your choice of properties with the new store, then delete the temporary store.
• A simpler approach: you could fetch the all properties you want to keep unchanged before you execute the batch insert (storing them in an dictionary keyed by your object's uniqueness constraint value), and then during the batch insert set the property again.
  • For this approach, you will want to use a different merge policy such as NSMergeByPropertyObjectTrumpMergePolicy so that the updated object gets re-inserted into the store (make sure to fetch all properties that you don't want to lose in advance of the batch insert)
• random idea: How to Save Data When Using One ManagedObjectContext and PersistentStoreCoordinator with Two Stores

Answer 1

I don't think it is actually possible to do a partial update with a batch insert request. It's hard to know for sure because I don't think any of this is documented except in WWDC sessions. When I first watched the 2019 session, I was excited because the presenter said:

Attributes that are optional or configured with default values can be omitted from the dictionary as well. In the case of updating an object with unique constraint, the existing values will not be changed.

I took this to mean that:

• You can omit values for new objects, and you'll get the defaults or NULL. That makes sense.
• If there's an existing object and you omit a value, that value will not the changed. So you can purposely omit values to do a partial update, i.e. update other values while leaving your isFavorite alone.

But, after writing code to test this and looking at the output from com.apple.CoreData.SQLDebug, what actually seems to happen with NSMergeByPropertyObjectTrumpMergePolicy is:

• If you omit a value that's required you get a validation error.
• If you omit a value that's optional, it updates the row to NULL. For a Bool property in Swift, this will become false.
• If you omit a value with a default value, it updates the row to the default.

This is a shame because it seems like partial updates could be implemented by having the ON CONFLICT clause only specify DO UPDATE SET for the attributes that you actually set. But (as of macOS 11) Core Data seems to always generate SQL to set all of the columns.

In summary, with batch inserts, NSMergeByPropertyObjectTrumpMergePolicy does not actually merge by property based on what's changed (like with a regular Core Data save). Rather, it either inserts a new row (if the object is absent) or overwrites all the columns but preserves the objectID (if the object was present).

NSMergeByPropertyStoreTrumpMergePolicy also doesn't merge by property. It just means to leave the stored object alone if it's already present.

Update (2021-06-24): I heard from DTS that Apple considers the current (iOS 14/macOS 11) behavior described above a bug, and that it should let you batch insert without changing omitted properties. The Radar number is 79747419.