¿Borrar / Restablecer todas las entradas en Datos básicos?

¿Conoce alguna forma de eliminar todas las entradas almacenadas en Core Data? Mi esquema debe permanecer igual; Solo quiero restablecerlo en blanco.


Editar

Estoy buscando hacer esto programáticamente para que un usuario pueda básicamente presionar un botón de reset .

Todavía puede eliminar el archivo mediante progtwigción, utilizando el método NSFileManager: removeItemAtPath ::.

 NSPersistentStore *store = ...; NSError *error; NSURL *storeURL = store.URL; NSPersistentStoreCoordinator *storeCoordinator = ...; [storeCoordinator removePersistentStore:store error:&error]; [[NSFileManager defaultManager] removeItemAtPath:storeURL.path error:&error]; 

Luego, solo agregue la tienda persistente para asegurarse de que se recrea correctamente.

La forma programática para iterar a través de cada entidad es más lenta y propensa al error. El uso para hacerlo de esa manera es si desea eliminar algunas entidades y otras no. Sin embargo, aún necesita asegurarse de conservar la integridad referencial o no podrá mantener sus cambios.

Simplemente eliminar la tienda y volver a crearla es rápido y seguro, y ciertamente se puede hacer programáticamente en tiempo de ejecución.

Actualización para iOS5 +

Con la introducción del almacenamiento binario externo (allowExternalBinaryDataStorage o Store in External Record File) en iOS 5 y OS X 10.7, simplemente eliminar archivos apuntados por storeURLs no es suficiente. Dejarás atrás los archivos de registro externos. Como el esquema de nombres de estos archivos de registro externos no es público, todavía no tengo una solución universal. – an0 8 de mayo de 12 a 23:00

Puede eliminar el archivo sqllite, pero elijo hacerlo purgando las tablas individualmente con una función:

 - (void) deleteAllObjects: (NSString *) entityDescription { NSFetchRequest *fetchRequest = [[NSFetchRequest alloc] init]; NSEntityDescription *entity = [NSEntityDescription entityForName:entityDescription inManagedObjectContext:_managedObjectContext]; [fetchRequest setEntity:entity]; NSError *error; NSArray *items = [_managedObjectContext executeFetchRequest:fetchRequest error:&error]; [fetchRequest release]; for (NSManagedObject *managedObject in items) { [_managedObjectContext deleteObject:managedObject]; DLog(@"%@ object deleted",entityDescription); } if (![_managedObjectContext save:&error]) { DLog(@"Error deleting %@ - error:%@",entityDescription,error); } } 

La razón por la que elegí hacerlo tabla por tabla es que me hace confirmar, como lo estoy haciendo, que la eliminación de los contenidos de la tabla es sensata y que no hay datos que prefiera conservar.

Hacerlo será mucho más lento que simplemente borrar el archivo y cambiaré a un archivo eliminado si este método lleva demasiado tiempo.

Solución actualizada para iOS 9+

Use NSBatchDeleteRequest para borrar todos los objetos en la entidad sin tener que cargarlos en la memoria o iterar a través de ellos.

 // create the delete request for the specified entity let fetchRequest = NSFetchRequest(entityName: "MyEntity") let deleteRequest = NSBatchDeleteRequest(fetchRequest: fetchRequest) // get reference to the persistent container let persistentContainer = (UIApplication.shared.delegate as! AppDelegate).persistentContainer // perform the delete do { try persistentContainer.viewContext.execute(deleteRequest) } catch let error as NSError { print(error) } 

Este código se ha actualizado para iOS 10 y Swift 3. Si necesita admitir iOS 9, consulte esta pregunta .

Fuentes:

  • Datos principales: forma más rápida de eliminar todas las instancias de una entidad (incluye el código Objective-C)
  • Qué hay de nuevo en Core Data (WWDC 2015 video)
  • Qué hay de nuevo en Core Data (video WWDC 2016)
  • Cómo usar Core Data en iOS 10
  • Qué hay de nuevo en Core Data Swift 3.0

He escrito un método clearStores que recorre todas las tiendas y lo clearStores tanto del coordinador como del sistema de archivos (el manejo del error se deja de lado):

 NSArray *stores = [persistentStoreCoordinator persistentStores]; for(NSPersistentStore *store in stores) { [persistentStoreCoordinator removePersistentStore:store error:nil]; [[NSFileManager defaultManager] removeItemAtPath:store.URL.path error:nil]; } [persistentStoreCoordinator release], persistentStoreCoordinator = nil; 

Este método está dentro de una clase coreDataHelper que se ocupa (entre otras cosas) de la creación de persistentStore cuando es nula.

Elimino todos los datos de los datos centrales en un botón Evento en una clase HomeViewController: este artículo me ayudó tanto que pensé que contribuiría.

 -(IBAction)buttonReset:(id)sender { NSLog(@"buttonReset Pressed"); //Erase the persistent store from coordinator and also file manager. NSPersistentStore *store = [self.persistentStoreCoordinator.persistentStores lastObject]; NSError *error = nil; NSURL *storeURL = store.URL; [self.persistentStoreCoordinator removePersistentStore:store error:&error]; [[NSFileManager defaultManager] removeItemAtURL:storeURL error:&error]; NSLog(@"Data Reset"); //Make new persistent store for future saves (Taken From Above Answer) if (![self.persistentStoreCoordinator addPersistentStoreWithType:NSSQLiteStoreType configuration:nil URL:storeURL options:nil error:&error]) { // do something with the error } } 

Tenga en cuenta que para llamar a self.persistentStoreCoordinator declare una propiedad en el Controlador de la Vista de Inicio. (No se preocupe por managedObjectContext que uso para guardar y cargar).

 @property (nonatomic, retain) NSManagedObjectContext * managedObjectContext; @property (nonatomic, retain) NSPersistentStoreCoordinator * persistentStoreCoordinator; 

Luego en AppDelegate ApplicationDidFinishLaunching justo debajo de la creación de un HomeViewController tengo:

 homeViewController = [[HomeViewController alloc] initWithNibName:@"HomeViewController" bundle:nil]; homeViewController.managedObjectContext = self.managedObjectContext; homeViewController.persistentStoreCoordinator = self.persistentStoreCoordinator; 

MagicalRecord hace esto muy fácil.

 [MyCoreDataObject MR_truncateAll]; 

[Respuesta tardía en respuesta a una recompensa por nuevas respuestas]

Mirando las respuestas anteriores,

  • La recuperación y eliminación de todos los artículos, como lo sugieren @Grouchal y otros, sigue siendo una solución efectiva y útil. Si tiene grandes almacenes de datos, puede ser lento, pero aún funciona muy bien.
  • Simplemente eliminar el almacén de datos es, como usted y la nota @ groundhog, ya no son efectivos. Es obsoleto incluso si no usa almacenamiento binario externo porque iOS 7 usa el modo WAL para el diario SQLite. Con el modo WAL puede haber archivos de diario (potencialmente grandes) sentados para cualquier tienda persistente de Core Data.

Pero hay un enfoque diferente y similar para eliminar la tienda persistente que funciona. La clave es colocar su archivo de tienda persistente en su propio subdirectorio que no contenga nada más. No solo lo pegue en el directorio de documentos (o donde sea), cree un nuevo subdirectorio solo para la tienda persistente. El contenido de ese directorio terminará siendo el archivo de tienda persistente, los archivos de diario y los archivos binarios externos. Si quiere destruir todo el almacén de datos, elimine ese directorio y desaparecerán.

Haría algo como esto cuando configure su tienda persistente:

 NSURL *storeDirectoryURL = [[self applicationDocumentsDirectory] URLByAppendingPathComponent:@"persistent-store"]; if ([[NSFileManager defaultManager] createDirectoryAtURL:storeDirectoryURL withIntermediateDirectories:NO attributes:nil error:nil]) { NSURL *storeURL = [storeDirectoryURL URLByAppendingPathComponent:@"MyApp.sqlite"]; // continue with storeURL as usual... } 

Luego, cuando quisiste eliminar la tienda,

 [[NSFileManager defaultManager] removeItemAtURL:storeDirectoryURL error:nil]; 

Eso elimina de forma recursiva tanto el subdirectorio personalizado como todos los archivos de Core Data en él.

Esto solo funciona si aún no tiene su tienda persistente en la misma carpeta que otros datos importantes . Como el directorio de documentos, que probablemente tiene otras cosas útiles. Si esa es su situación, puede obtener el mismo efecto buscando archivos que desea conservar y eliminando todo lo demás. Algo como:

 NSString *docsDirectoryPath = [[self applicationDocumentsDirectory] path]; NSArray *docsDirectoryContents = [[NSFileManager defaultManager] contentsOfDirectoryAtPath:docsDirectoryPath error:nil]; for (NSString *docsDirectoryItem in docsDirectoryContents) { // Look at docsDirectoryItem. If it's something you want to keep, do nothing. // If it's something you don't recognize, remove it. } 

Este enfoque puede ser propenso a errores . Debe estar absolutamente seguro de que conoce todos los archivos que desea conservar, porque de lo contrario podría eliminar datos importantes. Por otro lado, puede eliminar los archivos binarios externos sin conocer realmente el nombre del archivo / directorio utilizado para almacenarlos.

iOS9 +, Swift 2

Eliminar todos los objetos en todas las entidades

 func clearCoreDataStore() { let entities = managedObjectModel.entities for entity in entities { let fetchRequest = NSFetchRequest(entityName: entity.name!) let deleteReqest = NSBatchDeleteRequest(fetchRequest: fetchRequest) do { try context.executeRequest(deleteReqest) } catch { print(error) } } } 

Si desea eliminar todos los objetos y no desea eliminar los archivos de respaldo, puede usar los siguientes métodos:

 - (void)deleteAllObjectsInContext:(NSManagedObjectContext *)context usingModel:(NSManagedObjectModel *)model { NSArray *entities = model.entities; for (NSEntityDescription *entityDescription in entities) { [self deleteAllObjectsWithEntityName:entityDescription.name inContext:context]; } } - (void)deleteAllObjectsWithEntityName:(NSString *)entityName inContext:(NSManagedObjectContext *)context { NSFetchRequest *fetchRequest = [NSFetchRequest fetchRequestWithEntityName:entityName]; fetchRequest.includesPropertyValues = NO; fetchRequest.includesSubentities = NO; NSError *error; NSArray *items = [context executeFetchRequest:fetchRequest error:&error]; for (NSManagedObject *managedObject in items) { [context deleteObject:managedObject]; NSLog(@"Deleted %@", entityName); } } 

Tenga en cuenta que puede ser muy lento (depende de cuántos objetos haya en su gráfico de objetos).

Aquí hay una solución combinada para purgar Core Data.

 - (void)deleteAllObjectsInCoreData { NSArray *allEntities = self.managedObjectModel.entities; for (NSEntityDescription *entityDescription in allEntities) { NSFetchRequest *fetchRequest = [[NSFetchRequest alloc] init]; [fetchRequest setEntity:entityDescription]; fetchRequest.includesPropertyValues = NO; fetchRequest.includesSubentities = NO; NSError *error; NSArray *items = [self.managedObjectContext executeFetchRequest:fetchRequest error:&error]; if (error) { NSLog(@"Error requesting items from Core Data: %@", [error localizedDescription]); } for (NSManagedObject *managedObject in items) { [self.managedObjectContext deleteObject:managedObject]; } if (![self.managedObjectContext save:&error]) { NSLog(@"Error deleting %@ - error:%@", entityDescription, [error localizedDescription]); } } } 

Si desea ir a la ruta de eliminar todos los objetos (que es mucho más simple que derribar la stack de Datos del núcleo, pero con menos rendimiento), esta es una mejor implementación:

 - (void)deleteAllManagedObjectsInModel:(NSManagedObjectModel *)managedObjectModel context:(NSManagedObjectContext *)managedObjectContext { NSBlockOperation *operation = [NSBlockOperation blockOperationWithBlock:^{ [managedObjectContext performBlockAndWait:^{ for (NSEntityDescription *entity in managedObjectModel) { NSFetchRequest *fetchRequest = [NSFetchRequest new]; [fetchRequest setEntity:entity]; [fetchRequest setIncludesSubentities:NO]; NSArray *objects = [managedObjectContext executeFetchRequest:fetchRequest error:nil]; for (NSManagedObject *managedObject in objects) { [managedObjectContext deleteObject:managedObject]; } } [managedObjectContext save:nil]; }]; }]; [operation setCompletionBlock:^{ // Do stuff once the truncation is complete }]; [operation start]; } 

Esta implementación aprovecha NSOperation para realizar la eliminación del hilo principal y notificar al finalizar. Es posible que desee emitir una notificación o algo dentro del bloque de finalización para volver a pasar el estado al hilo principal.

Aquí hay una versión algo simplificada con menos llamadas a AppDelegate y el último bit de código que quedó fuera de la respuesta mejor clasificada. También recibía un mensaje de error “El almacén persistente de Object no es accesible desde este coordinador de NSManagedObjectContext”, así que solo necesitaba volver a agregarlo.

 NSPersistentStoreCoordinator *storeCoordinator = [self persistentStoreCoordinator]; NSPersistentStore *store = [[storeCoordinator persistentStores] lastObject]; NSURL *storeURL = [[self applicationDocumentsDirectory] URLByAppendingPathComponent:@"dataModel"]; NSError *error; [storeCoordinator removePersistentStore:store error:&error]; [[NSFileManager defaultManager] removeItemAtPath:storeURL.path error:&error]; [_persistentStoreCoordinator addPersistentStoreWithType:NSSQLiteStoreType configuration:nil URL:storeURL options:nil error:&error]; if (storeCoordinator != nil) { _managedObjectContext = [[NSManagedObjectContext alloc] init]; [_managedObjectContext setPersistentStoreCoordinator:storeCoordinator]; } 

solución rápida:

 class func deleteAllManagedObjects() { let modelURL = NSBundle.mainBundle().URLForResource("some string", withExtension: "mom") let mom = NSManagedObjectModel(contentsOfURL: modelURL) for entityName in mom.entitiesByName.keys { let fr = NSFetchRequest(entityName: entityName as String) let a = Utility.managedObjectContext().executeFetchRequest(fr, error: nil) as [NSManagedObject] for mo in a { Utility.managedObjectContext().deleteObject(mo) } } Utility.managedObjectContext().save(nil) } 

Solución iOS 10 + Swift 3:

 func clearCoreDataStore() { let delegate = UIApplication.shared.delegate as! AppDelegate let context = delegate.persistentContainer.viewContext for i in 0...delegate.persistentContainer.managedObjectModel.entities.count-1 { let entity = delegate.persistentContainer.managedObjectModel.entities[i] do { let query = NSFetchRequest(entityName: entity.name!) let deleterequest = NSBatchDeleteRequest(fetchRequest: query) try context.execute(deleterequest) try context.save() } catch let error as NSError { print("Error: \(error.localizedDescription)") abort() } } } 

Itera a través de todas las entidades de datos centrales y las borra

Como referencia rápida para guardar la búsqueda en otra parte, la recreación de la tienda persistente después de eliminarla se puede hacer con:

 if (![persistentStoreCoordinator addPersistentStoreWithType:NSSQLiteStoreType configuration:nil URL:storeURL options:nil error:&error]) { // do something with the error } 

Gracias por la publicacion. Lo seguí y funcionó para mí. Pero tuve otro problema que no fue mencionado en ninguna de las respuestas. Entonces no estoy seguro de si era solo yo.

De todos modos, pensé en publicar aquí el problema y mi camino que lo resolvió.

Tenía algunos registros en la base de datos, quería purgar todo antes de escribir datos nuevos en el DB, así que hice todo lo que incluía

 [[NSFileManager defaultManager] removeItemAtURL:storeURL error:&error]; 

y luego utilizó managedObjectContext para acceder a la base de datos (se supone que ya está vacía), de alguna manera los datos aún estaban allí. Después de un tiempo de resolución de problemas, descubrí que necesito reiniciar managedObjectContext , managedObject , managedObjectModel y persistentStoreCoordinator , antes de usar managedObjectContext para acceder a la base de datos. Ahora tengo una base de datos limpia para escribir.

Varias buenas respuestas a esta pregunta. Aquí hay una bonita y concisa. Las dos primeras líneas eliminan la base de datos sqlite. Luego, el bucle for: elimina cualquier objeto en la memoria managedObjectContext.

 NSURL *storeURL = [[(FXYAppDelegate*)[[UIApplication sharedApplication] delegate] applicationDocumentsDirectory] URLByAppendingPathComponent:@"AppName.sqlite"]; [[NSFileManager defaultManager] removeItemAtURL:storeURL error:nil]; for (NSManagedObject *ct in [self.managedObjectContext registeredObjects]) { [self.managedObjectContext deleteObject:ct]; } 

también puede encontrar todos los nombres de las entidades y eliminarlos por su nombre. Es una versión más larga pero funciona bien, de esa manera no tienes que trabajar con persistence store

  - (void)clearCoreData { NSError *error; NSEntityDescription *des = [NSEntityDescription entityForName:@"Any_Entity_Name" inManagedObjectContext:_managedObjectContext]; NSManagedObjectModel *model = [des managedObjectModel]; NSArray *entityNames = [[model entities] valueForKey:@"name"]; for (NSString *entityName in entityNames){ NSFetchRequest *deleteAll = [NSFetchRequest fetchRequestWithEntityName:entityName]; NSArray *matches = [self.database.managedObjectContext executeFetchRequest:deleteAll error:&error]; } if (matches.count > 0){ for (id obj in matches){ [_managedObjectContext deleteObject:obj]; } [self.database.managedObjectContext save:&error]; } } 

para “Any_Entity_Name” simplemente ingrese el nombre de su entidad, solo necesitamos descubrir la descripción de la entidad en la que se encuentran sus entidades. ValueForKey @ “name” devolverá todos los nombres de las entidades. Finalmente, no te olvides de guardar.

La respuesta aceptada es correcta al eliminar URL mediante NSFileManager es correcta, pero como se indica en iOS 5+ edit, la tienda persistente no está representada solo por un archivo. Para la tienda SQLite es * .sqlite, * .sqlite-shm y * .sqlite-wal … afortunadamente desde iOS 7+ podemos usar el método

[NSPersistentStoreCoordinator + removeUbiquitousContentAndPersistentStoreAtURL: options: error:]

para encargarse de la eliminación, por lo que el código debería ser algo como esto:

 NSPersistentStore *store = ...; NSError *error; NSURL *storeURL = store.URL; NSString *storeName = ...; NSPersistentStoreCoordinator *storeCoordinator = ...; [storeCoordinator removePersistentStore:store error:&error]; [NSPersistentStoreCoordinator removeUbiquitousContentAndPersistentStoreAtURL:storeURL.path options:@{NSPersistentStoreUbiquitousContentNameKey: storeName} error:&error]; 

Elimine sqlite de su archivoURLPath y luego compile.

Suponiendo que está utilizando MagicalRecord y tiene un almacenamiento de persistencia predeterminado:

No me gustan todas las soluciones que asumen que existen ciertos archivos y / o exijo ingresar los nombres o clases de las entidades. Esta es una forma rápida y segura de eliminar todos los datos de todas las entidades. Después de eliminarlo, se volverá a crear una nueva stack (en realidad no estoy seguro de qué tan necesario es esta parte).

Es ideal para situaciones de estilo de “cierre de sesión” cuando quiere eliminar todo, pero tiene una tienda que funciona y un moc para obtener nuevos datos (una vez que el usuario inicia sesión …)

 extension NSManagedObject { class func dropAllData() { MagicalRecord.saveWithBlock({ context in for name in NSManagedObjectModel.MR_defaultManagedObjectModel().entitiesByName.keys { do { try self.deleteAll(name, context: context) } catch { print("⚠️ ✏️ Error when deleting \(name): \(error)") } } }) { done, err in MagicalRecord.cleanUp() MagicalRecord.setupCoreDataStackWithStoreNamed("myStoreName") } } private class func deleteAll(name: String, context ctx: NSManagedObjectContext) throws { let all = NSFetchRequest(entityName: name) all.includesPropertyValues = false let allObjs = try ctx.executeFetchRequest(all) for obj in allObjs { obj.MR_deleteEntityInContext(ctx) } } } 

Utilizar esta

 +(NSArray *)fetchDataFromEntity:(NSString *)entityName context:(NSManagedObjectContext *)context { NSFetchRequest * fetchRequest =[[NSFetchRequest alloc] init]; NSEntityDescription * CategoriesEntity = [NSEntityDescription entityForName:entityName inManagedObjectContext:context]; [fetchRequest setEntity:CategoriesEntity]; NSError * error; NSInteger count = [context countForFetchRequest:fetchRequest error:&error]; if (count && count>0) { NSArray * fetchedObjects = [context executeFetchRequest:fetchRequest error:&error]; if (fetchedObjects && fetchedObjects.count>0) { return fetchedObjects; }else return nil; } else return nil; } + (void)deleteObjectsOfArray:(NSMutableArray*)ary context:(NSManagedObjectContext *)context { for (NSManagedObject * obj in ary) { [context deleteObject:obj]; } NSError *saveError = nil; [context save:&saveError]; } + (void)deleteEntity:(NSString *)entityName context:(NSManagedObjectContext *)context { NSArray *listArray = [self fetchDataFromEntity:entityName context:context]; [self deleteObjectsOfArray:[NSMutableArray arrayWithArray:listArray] context:context]; } 

Tomé el código de Grouchal y para acelerarlo utilicé la enumeración con modo concurrente ( NSEnumerationConcurrent ), se volvió un poco más rápido en comparación con for loop (en mi aplicación agregué esta función para Testers para que puedan borrar datos y hacer testcases en lugar de borrar e instala la aplicación)

 - (void)resetObjects { [self deleteAllObjectsInEntity:@"Entity1"]; [self deleteAllObjectsInEntity:@"Entity2"]; [self deleteAllObjectsInEntity:@"Entity3"]; [self deleteAllObjectsInEntity:@"Entity4"]; } -(void) deleteAllObjectsInEntity:(NSString*) entityName { MainDataContext *coreDataContext = [MainDataContext sharedInstance]; NSManagedObjectContext *currentContext = coreDataContext.managedObjectContext; NSFetchRequest *fetchRequest = [[NSFetchRequest alloc] init]; NSEntityDescription *entity = [NSEntityDescription entityForName:entityName inManagedObjectContext:currentContext]; [fetchRequest setEntity:entity]; NSError *error; NSArray *items = [currentContext executeFetchRequest:fetchRequest error:&error]; [items enumerateObjectsWithOptions:NSEnumerationConcurrent usingBlock:^(NSManagedObject * obj, NSUInteger idx, BOOL *stop) { [currentContext deleteObject:obj]; }]; if (![currentContext save:&error]) { NSLog(@"Error deleting %@ - error:%@",entityName,error); } } 

aquí mi versión swift3 para eliminar todos los registros. ‘Usuarios’ es el nombre de la entidad

 @IBAction func btnDelAll_touchupinside(_ sender: Any) { let appDelegate = UIApplication.shared.delegate as! AppDelegate let managedObjectContext = appDelegate.persistentContainer.viewContext let fetchReq = NSFetchRequest(entityName: "Users") let req = NSBatchDeleteRequest(fetchRequest: fetchReq) do { try managedObjectContext.execute(req) } catch { // Error Handling } } 

Funciona con todas las versiones. Pase el nombre de la entidad e itere para eliminar todas las entradas y guardar el contexto.

 func deleteData(entityToFetch: String, completion: @escaping(_ returned: Bool) ->()) { var context = NSManagedObjectContext() if #available(iOS 10.0, *) { context = self.persistentContainer.viewContext } else { context = self.managedObjectContext } let fetchRequest = NSFetchRequest() 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)") } } 

iOS 10 y Swift 3

Suponiendo que el nombre de su entidad sea “Foto”, y que cree una clase CoreDataStack …

  func clearData() { do { let context = CoreDataStack.sharedInstance.persistentContainer.viewContext let fetchRequest = NSFetchRequest(entityName: "Photo") do { let objects = try context.fetch(fetchRequest) as? [NSManagedObject] _ = objects.map{$0.map{context.delete($0)}} CoreDataStack.sharedInstance.saveContext() } catch let error { print("ERROR DELETING : \(error)") } } } 

Aquí hay un buen tutorial sobre cómo usar CoreData y cómo usar este método. https://medium.com/compileswift/parsing-json-response-and-save-it-in-coredata-step-by-step-fb58fc6ce16f#.1tu6kt8qb

Aquí hay una versión que borra cada registro en cada tabla que tiene.

Swift 4

 static func resetDatabase() { do { try dataStore.persistentStoreCoordinator.managedObjectModel.entities.forEach { (entity) in if let name = entity.name { let fetch = NSFetchRequest(entityName: name) let request = NSBatchDeleteRequest(fetchRequest: fetch) try mainContext.execute(request) } } try mainContext.save() } catch { print("error resenting the database: \(error.localizedDescription)") } } 

¿Eliminar el archivo de tienda persistente y configurar un nuevo coordinador de tienda persistente?

todos están haciendo que esto parezca complicado. Puede enviar su NSManagedObjectContext al método de reinicio