Core Data: Quickest way to delete all instances of an entity

Reset Entity in Swift 3 :

func resetAllRecords(in entity : String) // entity = Your_Entity_Name { let context = ( UIApplication.shared.delegate as! AppDelegate ).persistentContainer.viewContext let deleteFetch = NSFetchRequest<NSFetchRequestResult>(entityName: entity) let deleteRequest = NSBatchDeleteRequest(fetchRequest: deleteFetch) do { try context.execute(deleteRequest) try context.save() } catch { print ("There was an error") } } 

A little bit more cleaned and universal : Add this method :

- (void)deleteAllEntities:(NSString *)nameEntity { NSFetchRequest *fetchRequest = [[NSFetchRequest alloc] initWithEntityName:nameEntity]; [fetchRequest setIncludesPropertyValues:NO]; //only fetch the managedObjectID NSError *error; NSArray *fetchedObjects = [theContext executeFetchRequest:fetchRequest error:&error]; for (NSManagedObject *object in fetchedObjects) { [theContext deleteObject:object]; } error = nil; [theContext save:&error]; } 

For Swift 2.0:

class func clearCoreData(entity:String) { let fetchRequest = NSFetchRequest() fetchRequest.entity = NSEntityDescription.entityForName(entity, inManagedObjectContext: moc!) fetchRequest.includesPropertyValues = false do { if let results = try moc!.executeFetchRequest(fetchRequest) as? [NSManagedObject] { for result in results { moc!.deleteObject(result) } try moc!.save() } } catch { LOG.debug("failed to clear core data") } } 

Swift 4, iOS 12 and Xcode 10 Update

100% working just cut & paste

Just put this function in relevant class and call this function self.deleteData() in viewDidLoad() or anywhere or under a function or a button so that by clicking a button all the data from entity should be deleted and replace the "myEntity" as your entity that you have defined in your core data

func deleteData() { let appDel:AppDelegate = (UIApplication.shared.delegate as! AppDelegate) let context:NSManagedObjectContext = appDel.persistentContainer.viewContext let fetchRequest = NSFetchRequest<NSFetchRequestResult>(entityName: "myEntity") fetchRequest.returnsObjectsAsFaults = false do { let results = try context.fetch(fetchRequest) for managedObject in results { if let managedObjectData: NSManagedObject = managedObject as? NSManagedObject { context.delete(managedObjectData) } } } catch let error as NSError { print("Deleted all my data in myEntity error : \(error) \(error.userInfo)") } } 

This is a similar question to the one here and someone suggested setting up a relationship delete rule so you only have to delete one object. So if you have or can make an entity with a to-many relationship to the cars and set the delete rule to cascade when you delete the higher entity all the cars will be deleted as well. This may save some processing time since you don't have to do the steps involved with loading ALL the cars. In a larger data set this could be absolutely necessary.

Swift:

let fetchRequest = NSFetchRequest() fetchRequest.entity = NSEntityDescription.entityForName(entityName, inManagedObjectContext: context) fetchRequest.includesPropertyValues = false var error:NSError? if let results = context.executeFetchRequest(fetchRequest, error: &error) as? [NSManagedObject] { for result in results { context.deleteObject(result) } var error:NSError? if context.save(&error) { // do something after save } else if let error = error { println(error.userInfo) } } else if let error = error { println("error: \(error)") } 

A good answer was already posted, this is only a recommendation!

A good way would be to just add a category to NSManagedObject and implement a method like I did:

Header File (e.g. NSManagedObject+Ext.h)

@interface NSManagedObject (Logic) + (void) deleteAllFromEntity:(NSString*) entityName; @end 

Code File: (e.g. NSManagedObject+Ext.m)

@implementation NSManagedObject (Logic) + (void) deleteAllFromEntity:(NSString *)entityName { NSManagedObjectContext *managedObjectContext = [AppDelegate managedObjectContext]; NSFetchRequest * allRecords = [[NSFetchRequest alloc] init]; [allRecords setEntity:[NSEntityDescription entityForName:entityName inManagedObjectContext:managedObjectContext]]; [allRecords setIncludesPropertyValues:NO]; NSError * error = nil; NSArray * result = [managedObjectContext executeFetchRequest:allRecords error:&error]; for (NSManagedObject * profile in result) { [managedObjectContext deleteObject:profile]; } NSError *saveError = nil; [managedObjectContext save:&saveError]; } @end 

... the only thing you have to is to get the managedObjectContext from the app delegate, or where every you have it in ;)

afterwards you can use it like:

[NSManagedObject deleteAllFromEntity:@"EntityName"]; 

one further optimization could be that you remove the parameter for tha entityname and get the name instead from the clazzname. this would lead to the usage:

[ClazzName deleteAllFromEntity]; 

a more clean impl (as category to NSManagedObjectContext):

@implementation NSManagedObjectContext (Logic) - (void) deleteAllFromEntity:(NSString *)entityName { NSFetchRequest * allRecords = [[NSFetchRequest alloc] init]; [allRecords setEntity:[NSEntityDescription entityForName:entityName inManagedObjectContext:self]]; [allRecords setIncludesPropertyValues:NO]; NSError * error = nil; NSArray * result = [self executeFetchRequest:allRecords error:&error]; for (NSManagedObject * profile in result) { [self deleteObject:profile]; } NSError *saveError = nil; [self save:&saveError]; } @end 

The usage then:

[managedObjectContext deleteAllFromEntity:@"EntityName"]; 

iOS 10 and later

Works with all versions. Pass entity name and iterate through to delete all the entries and save the context.

func deleteData(entityToFetch: String, completion: @escaping(_ returned: Bool) ->()) { let context = NSManagedObjectContext() context = your managedObjectContext let fetchRequest = NSFetchRequest<NSFetchRequestResult>() fetchRequest.entity = NSEntityDescription.entity(forEntityName: entityToFetch, in: context) fetchRequest.includesPropertyValues = false do { let results = try context.fetch(fetchRequest) as! [NSManagedObject] for result in results { context.delete(result) } try context.save() completion(true) } catch { completion(false) print("fetch error -\(error.localizedDescription)") } } 

Swift 4, iOS 10+
Static function which can apply for any entity to remove all of its data

protocol NSManagedObjectHelper { } extension NSManagedObject: NSManagedObjectHelper { } extension NSManagedObjectHelper where Self: NSManagedObject { static func removeAllObjectsInContext(_ managedContext: NSManagedObjectContext) { let request: NSFetchRequest = NSFetchRequest(entityName: String(describing: self)) let deleteRequest = NSBatchDeleteRequest(fetchRequest: request) do { deleteRequest.resultType = .resultTypeObjectIDs//to clear objects from memory let result = try managedContext.execute(deleteRequest) as? NSBatchDeleteResult if let objectIDArray = result?.result as? [NSManagedObjectID] { let changes = [NSDeletedObjectsKey : objectIDArray] /*By calling mergeChangesFromRemoteContextSave, all of the NSManagedObjectContext instances that are referenced will be notified that the list of entities referenced with the NSManagedObjectID array have been deleted and that the objects in memory are stale. This causes the referenced NSManagedObjectContext instances to remove any objects in memory that are loaded which match the NSManagedObjectID instances in the array.*/ NSManagedObjectContext.mergeChanges(fromRemoteContextSave: changes, into: [managedContext]) } try managedContext.save() } catch let error { print(error) } } } 

'Room' is an entity

Room.removeAllObjectsInContext(self.persistentContainer.viewContext) 

Edited on 20191025: the "Self.fetchRequest()" instruction may cause issue if we use multiple target in same projects. So replaced with NSFetchRequest(entityName: String(describing: self))

Swift 3.X and Swift 4.X , Easy way. Change only YourTable

 let fetchRequest = NSFetchRequest<NSFetchRequestResult>(entityName: "YourTable") fetchRequest.returnsObjectsAsFaults = false do { let results = try context.fetch(fetchRequest) for managedObject in results { let managedObjectData:NSManagedObject = managedObject as! NSManagedObject context.delete(managedObjectData) } } catch let error as NSError { print("Detele all my data in \(entity) error : \(error) \(error.userInfo)") } 

Extending Dave Delong's answer.

Swift Version that takes care of iOS 9 and previous versions as well. I have also covered Error handling in this:

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

 let fetchRequest = NSFetchRequest(entityName: "Car") if #available(iOS 9.0, *) { let delete = NSBatchDeleteRequest(fetchRequest: fetchRequest) do { try appDelegate.persistentStoreCoordinator.executeRequest(delete, withContext: appDelegate.managedObjectContext) } catch let error as NSError { print("Error occured while deleting: \(error)") } } else { // Fallback on earlier versions let carRequest = NSFetchRequest() carRequest.entity = NSEntityDescription.entityForName("Cars", inManagedObjectContext: appDelegate.managedObjectContext) carRequest.includesPropertyValues = false do { let cars: NSArray = try appDelegate.managedObjectContext.executeFetchRequest(carRequest) for car in cars { appDelegate.managedObjectContext.delete(car) } try appDelegate.managedObjectContext.save() } catch let error as NSError { print("Error occured while fetching or saving: \(error)") } } 

quick purge of all objects in DB:

func purgeAllData() { let uniqueNames = persistentContainer.managedObjectModel.entities.compactMap({ $0.name }) uniqueNames.forEach { (name) in let fetchRequest = NSFetchRequest<NSFetchRequestResult>(entityName: name) let batchDeleteRequest = NSBatchDeleteRequest(fetchRequest: fetchRequest) do { try persistentContainer.viewContext.execute(batchDeleteRequest) } catch { let nserror = error as NSError fatalError("Unresolved error \(nserror), \(nserror.userInfo)") } } } 

SwiftUI

fetch instances from your entity, and loop to delete every one.

@Environment(\.managedObjectContext) var moc @FetchRequest(sortDescriptors: []) var wizards: FetchedResults<Wizard> var body: some View { VStack { List() { } Button("Delete all") { for wizard in wizards { moc.delete(wizard) } if moc.hasChanges { try? moc.save() } } } } 

Swift4+ and Xcode 10+ Use below code for delete all records from entity.

func deleteAllRecords(entity : String) { let managedContext = CoreDataManager.sharedManager.persistentContainer.viewContext //your context let deleteFetch = NSFetchRequest<NSFetchRequestResult>(entityName: entity) let deleteRequest = NSBatchDeleteRequest(fetchRequest: deleteFetch) do { try managedContext.execute(deleteRequest) try managedContext.save() } catch { print ("There was an error") } } 

How to use

self.deleteEntityData(entity: "YOUR_ENTITY_NAME") 

Why not fold in the data that you receive with the existing cache? Otherwise it's not really 'refreshing', it's 'starting again' and you might as well drop/delete the SQLLite file and start again (assuming you're not persisting other data as well).

the OOP way without any strings as entities names Swift 3+, Xcode 10+

func batchDelete<T>(in context: NSManagedObjectContext, fetchRequest: NSFetchRequest<T>) throws { guard let request = fetchRequest as? NSFetchRequest<NSFetchRequestResult> else { throw ErrorService.defaultError } let batchDeleteRequest = NSBatchDeleteRequest(fetchRequest: request) do { try context.execute(batchDeleteRequest) } catch { throw error } } 

then just call in do/catch block

 let fetchRequest: NSFetchRequest<YourEntity> = YourEntity.fetchRequest() do { let data = try context.fetch(fetchRequest) if data.count > 0 { try self.batchDelete(in: context, fetchRequest: fetchRequest) } } catch { // throw error } 

if the entity contains a lot of entries the best way is like this because it saves memory

 - (void)deleteAll:(NSManagedObjectContext *)managedObjectContext entityName:(NSString *)entityName { NSFetchRequest *fetchRequest = [[NSFetchRequest alloc] init]; [managedObjectContext setUndoManager:nil]; NSEntityDescription *entity = [NSEntityDescription entityForName:entityName inManagedObjectContext:managedObjectContext]; [fetchRequest setEntity:entity]; [fetchRequest setIncludesPropertyValues:NO]; [fetchRequest setFetchLimit:100]; // you can change this number if you want NSError *error; NSArray *items = [managedObjectContext executeFetchRequest:fetchRequest error:&error]; while ([items count] > 0) { @autoreleasepool { for (NSManagedObject *item in items) { [managedObjectContext deleteObject:item]; } if (![managedObjectContext save:&error]) { NSLog(@"Error deleting %@ - error:%@",self.entityName, error); } } items = [managedObjectContext executeFetchRequest:fetchRequest error:&error]; } } 

In Swift 3.0

 func deleteAllRecords() { //delete all data let context = appDelegate.persistentContainer.viewContext let deleteFetch = NSFetchRequest<NSFetchRequestResult>(entityName: "YourClassName") let deleteRequest = NSBatchDeleteRequest(fetchRequest: deleteFetch) do { try context.execute(deleteRequest) try context.save() } catch { print ("There was an error") } } 

This code will work for both iOS 9 and below

class func deleteAllRecords(in entity : String) // entity = Your_Entity_Name { let context = CoreDataStack.getContext() // Note:- Replace your context here with CoreDataStack.getContext() let deleteFetch = NSFetchRequest<NSFetchRequestResult>(entityName: entity) if #available(iOS 9, *) { let deleteRequest = NSBatchDeleteRequest(fetchRequest: deleteFetch) do { try context.execute(deleteRequest) try context.save() } catch { print("There was an error:\(error)") } } else { do{ let deleteRequest = try context.fetch(deleteFetch) for anItem in deleteRequest { context.delete(anItem as! NSManagedObject) } } catch { print("There was an error:\(error)") } } CoreDataStack.saveContext() // Note:- Replace your savecontext here with CoreDataStack.saveContext() } 

iOS 9.0 and Later :

NSBatchDeleteRequest is used to delete records in core data. It works very fast and takes less time to delete all records from an entity. It requires NSFetchRequest in argument. If you want to delete all records from an entity, you can use it and it works for me.

let manageObject:NSManagedObjectContext = appDelegateObject.managedObjectContext let fetchRequest = NSFetchRequest(entityName: “EnityName”) let deleteRequest = NSBatchDeleteRequest(fetchRequest: fetchRequest) let persistCor:NSPersistentStoreCoordinator = appDelegateObject.persistentObject do { try persistCor.executeRequest(deleteRequest, withContext: manageObject) try manageObject.save() } catch { print(error?.localizedDescription) } 

Dave Delongs's Swift 2.0 answer was crashing for me (in iOS 9)

But this worked:

let fetchRequest = NSFetchRequest(entityName: "Car") let deleteRequest = NSBatchDeleteRequest(fetchRequest: fetchRequest) do { try managedObjectContext.executeRequest(deleteRequest) try managedObjectContext.save() } catch let error as NSError { // Handle error } 

Swift 3 solution with iOS 9 'NSBatchDeleteRequest' and fallback to earlier iOS versions implemented as an extension on 'NSManagedObjectContext'. Apple reference https://developer.apple.com/library/content/featuredarticles/CoreData_Batch_Guide/BatchDeletes/BatchDeletes.html

extension NSManagedObjectContext { func batchDeleteEntities<T: NSManagedObject>(ofType type: T.Type) throws { let fetchRequest = NSFetchRequest<NSFetchRequestResult>(entityName: String(describing: type.self)) if #available(iOS 9.0, *) { let request = NSBatchDeleteRequest(fetchRequest: fetchRequest) let result = try execute(request) as? NSBatchDeleteResult if let objectIDArray = result?.result as? [NSManagedObjectID] { let changes = [NSDeletedObjectsKey: objectIDArray] NSManagedObjectContext.mergeChanges(fromRemoteContextSave: changes, into: [self]) } } else { fetchRequest.includesPropertyValues = false let results = try fetch(fetchRequest) if let actualResults = results as? [NSManagedObject], !actualResults.isEmpty { actualResults.forEach { delete($0) } } } } } 

Use NSBatchDeleteRequest to delete multiple records If Minimum iOS is 9.0. If background thread, execute NSManagedObjectContext save else use NSFetchRequest to get records and delete all records in for loop and Save once deletion done.

in iOS 11.3 and Swift 4.1

let fetchRequest = NSFetchRequest<NSFetchRequestResult>(entityName: entityName) let batchDeleteRequest = NSBatchDeleteRequest(fetchRequest: fetchRequest ) batchDeleteRequest.resultType = .resultTypeCount do { let batchDeleteResult = try dataController.viewContext.execute(batchDeleteRequest) as! NSBatchDeleteResult print("The batch delete request has deleted \(batchDeleteResult.result!) records.") dataController.viewContext.reset() // reset managed object context (need it for working) } catch { let updateError = error as NSError print("\(updateError), \(updateError.userInfo)") } 

you have to call reset after you do execute. If not, it will not update on the table view.

 func deleteAll(entityName: String) { let fetchRequest = NSFetchRequest<NSFetchRequestResult>(entityName: entityName) let deleteRequest = NSBatchDeleteRequest(fetchRequest: fetchRequest) deleteRequest.resultType = .resultTypeObjectIDs guard let context = self.container?.viewContext else { print("error in deleteAll") return } do { let result = try context.execute(deleteRequest) as? NSBatchDeleteResult let objectIDArray = result?.result as? [NSManagedObjectID] let changes: [AnyHashable : Any] = [NSDeletedObjectsKey : objectIDArray as Any] NSManagedObjectContext.mergeChanges(fromRemoteContextSave: changes, into: [context]) } catch { print(error.localizedDescription) } } 

The above answers give a good insight on how to delete the "Cars"

However, I want this answer to challenge the approach itself:

1- SQLite CoreData is a relational database. In this case, where there isn't any releation, I would advise against using CoreData and maybe using the file system instead, or keep things in memory.

2- In other examples, where "Car" entity have other relations, and therefore CoreData, I would advise against having 2000 cars as root entity. Instead I would give them a parent, let's say "CarsRepository" entity. Then you can give a one-to-many relationship to the "Car" entity, and just replace the relationship to point to the new cars when they are downloaded. Adding the right deletion rule to the relationships ensures the integrity of the model.

NSBatchDeleteRequest Swift 5.5 and Xcode 13.2

deletes the objects in the SQLite persistent store without loading into memory. The changes enacted on the persistent store are not reflected in the objects that are currently in memory.

After a batch delete has been executed, remove any objects in memory that has been deleted from the persistent store.

below are some handy extensions methods that perform the batchDeleteRequest

extension NSManagedObject { private static var entityName: String { return String(describing: self) } static func fetchRequest<Self>( with predicate: NSPredicate? = nil, configureBlock: ((NSFetchRequest<Self>) -> Void)? = nil ) -> NSFetchRequest<Self> where Self: NSFetchRequestResult { let request = NSFetchRequest<Self>(entityName: entityName) request.predicate = predicate configureBlock?(request) return request } static func batchDelete(with fetchRequest: NSFetchRequest<NSFetchRequestResult>, in context: NSManagedObjectContext) { let batchDeteleRequest = NSBatchDeleteRequest(fetchRequest: fetchRequest) batchDeteleRequest.resultType = .resultTypeObjectIDs do { if let fetchResult = try context.execute(batchDeteleRequest) as? NSBatchDeleteResult, let deletedManagedObjectIds = fetchResult.result as? [NSManagedObjectID], !deletedManagedObjectIds.isEmpty { let changes = [NSDeletedObjectsKey: deletedManagedObjectIds] NSManagedObjectContext.mergeChanges(fromRemoteContextSave: changes, into: [context]) } } catch { print("Error while executing batchDeleteRequest: \(error.localizedDescription)") } } } 

Example: We can batch delete the Entity by calling batchDelete static method by passing the fetchRequest

class Entity: NSManagedObject { @NSManaged var name: String? @NSManaged var value: String? } extension Entity { static func executeBatchDelete(in context: NSManagedObjectContext) { let predicate = NSPredicate(format: "\(#keyPath(Entity.value)) == %@)", "abc") let deleteRequest: NSFetchRequest<NSFetchRequestResult> = Entity.fetchRequest(with: predicate) Entity.batchDelete(with: deleteRequest, in: context) } } 

In Swift 2.0:

func deleteAllData(entity: String) { let appDelegate = UIApplication.sharedApplication().delegate as! AppDelegate let managedContext = appDelegate.managedObjectContext let fetchRequest = NSFetchRequest(entityName: entity) fetchRequest.returnsObjectsAsFaults = false do { let results = try managedContext.executeFetchRequest(fetchRequest) for managedObject in results { let managedObjectData:NSManagedObject = managedObject as! NSManagedObject managedContext.deleteObject(managedObjectData) } } catch let error as NSError { print("Detele all data in \(entity) error : \(error) \(error.userInfo)") } }