Core Data - Complete Reset - The right way

Completely reset, delete, destroy Core Data database and get a clean state without having to iterate through all objects or persistent stores.

The Problem

How is it usually done?

We can do better

Summary

The Problem

Occasionally, you just want to start fresh, and you can do that by completely wiping-out everything in your database. And yes, Core Data complete reset (delete/destroy) can in some instances and for some apps, be a useful approach. But be careful, you need to do it right!

There are numerous articles online on the topic of how to delete everything from Core Data. Most of the approaches require iteration through the persistent stores, and some also thought all objects stored in the database. This can be time-consuming and inefficient and make your job a bit harder than it should be. Additionally, these approaches might work, but not in every case. And every case is precisely what we want to cover. We want to make it right every time.

Let’s say you have an app that happens to store some data and in the development cycle it came to a change on one of the properties in your data model object.

Until now, you had:

let updatedAt: Date

and now you might have:

let isUpdated: Bool

Your app is live, but you check only a fresh app install and do not bother with checking migration case. After all, you already implemented a backup solution in case migration fails. You just wipe out the complete database and fetch everything fresh. The backend is already sending you a new Boolean value, you updated your Model and life is good.

But it is not all sunshine and roses for your old users. For them, the app crashes on launch. But why?

How is it usually done?

You probably have a similar code somewhere in your code base

func delete(entityName: String) {
        
        let fetchRequest = NSFetchRequest<NSFetchRequestResult>(entityName: entityName)
        let batchDeleteRequest = NSBatchDeleteRequest(fetchRequest: fetchRequest)
        _ = try? self.container.viewContext.execute(batchDeleteRequest)
}

Or something like this

func destroy() {
        
        let coordinator = self.container.persistentStoreCoordinator
        
        coordinator.persistentStores.compactMap { $0.url }.forEach {
            try? coordinator.destroyPersistentStore(at: $0, type: .sqlite)
        }
}

This might work as expected in normal circumstances, but it will let you down when most needed. The problem with these approaches is that they rely on persistent stores being loaded, and that is precisely what does NOT happen when migration fails. The array of persistentStores will be empty and wiping out the database content will not be executed. The same will also be the case with batchDeleteRequest. All this leaving you with angry users. Their best chance to get it all up and working again is to delete and reinstall the app.

We can do better

If we come to the point where loadPersistentStores yields and error, we also get a chance to make the best of it. We can delete all existing entries from the database that might have led to the corrupted state and start with a clean state.

How?

Apple provides us with error and description in the completion block. The description can be used to get the url of the store. This leaves us with a simple task of calling destroyPersistentStore with the provided url.

If an error is encountered on loadPersistentStores you simply unwrap the url from the description and use it as a parameter to call destroyPersistentStore. Make sure to recreate the store upon destroy to ensure uninterrupted flow and avoid a crash.

    func load() {
        
        self.container.loadPersistentStores { description, error in
            
            if let error, let url = description.url {
                
                let coordinator = self.container.persistentStoreCoordinator
                
                // Destroy
                try? coordinator.destroyPersistentStore(at: url, type: .sqlite)
                
                // Re-create
                _ =  try? coordinator.addPersistentStore(type: .sqlite, at: url)
            }
        }
    }

What is nice about this approach, it will work in other cases that might cause errors while creating a CoreData stack. 🥳

Summary

That is it! CoreData framework in XCode and Swift is a powerful tool that can do a lot of good when applied well. Needless to say, I am not advocating wiping out the database on every model change as a sustainable approach but rather as a safe backup option. Correctly implementing a database reset can provide a clean state and a bit of clarity when facing database-related issues.

17032024.1