¿Eliminar/restablecer todas las entradas en Core Data?

StackOverflow https://stackoverflow.com/questions/1077810

Pregunta

¿Conoce alguna forma de eliminar todas las entradas almacenadas en Core Data?Mi esquema debería seguir siendo el mismo;Sólo quiero restablecerlo a blanco.

Editar

Estoy buscando hacer esto mediante programación para que un usuario pueda esencialmente presionar un reset botón.

¿Fue útil?

Solución

Aún puede eliminar el archivo mediante programación, utilizando el NSFileManager:. RemoveItemAtPath :: método 

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

A continuación, sólo tiene que añadir el almacén persistente hacia atrás para asegurarse de que se vuelve a crear correctamente.

La forma programática para iterar a través de cada entidad es tanto más lento y propenso a error. El uso de hacerlo de esa manera es si usted quiere borrar unas entidades y otras no. Sin embargo, usted todavía necesita para asegurarse de que conserve la integridad referencial o usted no será capaz de persistir los cambios.

Sólo la eliminación de la tienda y volver a crearlo es a la vez rápido y seguro, y sin duda se puede hacer mediante programación en tiempo de ejecución.

Actualización para iOS5 +

Con la introducción del almacenamiento binario externo (allowsExternalBinaryDataStorage o tienda en externa del archivo de registro) en iOS 5 y OS X 10.7, con solo borrar archivos apuntadas por storeURLs no es suficiente. Vas a dejar los archivos de registros externos atrás. Dado que el esquema de nombres de estos archivos de registro externo no es pública, no tengo una solución universal todavía. - an0 8 May '12 a las 23:00

Otros consejos

Puede eliminar el archivo de SQLite - pero elegir hacerlo purgando las tablas individualmente con unas funciones: 

- (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 que elegimos para hacerlo mesa por mesa es que me hace confirmo como lo estoy haciendo la programación que borrar el contenido de la tabla es sensible y no hay datos que preferiría mantener.

Hacerlo de esta voluntad es mucho más lento que acaba de borrar el archivo y voy a cambiar a un archivo de eliminar si este método lleva demasiado tiempo.

Actualización de soluciones para iOS 10 +

Uso NSBatchDeleteRequest para borrar todos los objetos de la entidad sin tener que cargarlos en la memoria o se puede recorrer a través de ellos. 

// create the delete request for the specified entity
let fetchRequest: NSFetchRequest<NSFetchRequestResult> = MyEntity.fetchRequest()
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 tiene que soportar iOS 9, consulte esta pregunta .

Fuentes:

He escrito un método clearStores que pasa a través de todas las tiendas y eliminarlo tanto desde el coordinador y el sistema de archivos (control de errores dejó a un 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 encarga de (entre otras cosas) la creación de la PersistentStore cuando es nula.

elimino todos los datos de los datos básicos en un evento de botón en una clase HomeViewController: En este artículo me ayudó tanto que pensé que podría contribuir. 

-(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 con el fin de llamar self.persistentStoreCoordinator declaré una propiedad en la vista de Controlador Principal. (No se preocupe por la managedObjectContext que utilizo para guardar y cargar.) 

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

A continuación, en el 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];

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)
        }
    }
}

[respuesta tardía en respuesta a una recompensa pidiendo respuestas más nuevos]

Mirando por encima de las respuestas anteriores,

  • Recogida y eliminación de todos los artículos, según lo sugerido por @Grouchal y otros, todavía es una solución eficaz y útil. Si usted tiene muy grandes almacenes de datos, entonces puede ser lento, pero todavía funciona muy bien.
  • La simple eliminación de la memoria de datos es, como se nota y @groundhog, ya no es eficaz. Es obsoleta incluso si no se utiliza el almacenamiento binario externo porque iOS 7 utiliza el modo WAL para meter en diario SQLite. Con el modo WAL puede haber (potencialmente grande) archivos de diario que se sientan alrededor de cualquier almacén persistente de Datos Básicos.

Pero hay una, diferente enfoque similar para retirar el almacén persistente que hace el trabajo. La clave es poner su archivo de almacén persistente en su propio subdirectorio que no contiene ninguna otra cosa. No se limite a pegarlo en el directorio de documentos (o donde sea), cree un nuevo subdirectorio sólo para el almacenamiento persistente. El contenido de ese directorio va a terminar siendo el archivo del almacén persistente, los archivos de diario, y los archivos binarios externos. Si desea bombardear todo el almacén de datos, eliminar ese directorio y desaparecerán.

Usted haría algo como esto cuando la configuración de su almacén 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...
}

A continuación, cuando se quería quitar el almacén, 

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

que elimina de forma recursiva tanto el subdirectorio de costumbre y todos los archivos de la base de datos en el mismo.

Esto sólo funciona si usted no tiene ya su almacén persistente en la misma carpeta que otros, datos importantes . Al igual que el directorio de documentos, lo que probablemente tiene otras cosas útiles en él. Si ese es su caso, usted podría conseguir el mismo efecto mediante la búsqueda de archivos que hacer que desee mantener y eliminar todo lo demás. Algo así 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 . Uno tiene que estar absolutamente seguro de que sabe cada archivo que desea guardar, porque de lo contrario podría eliminar datos importantes. Por otra parte, puede eliminar los archivos binarios externos sin conocer el nombre del archivo / directorio utilizado para almacenarlos.

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

- (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 hay en el gráfico de objetos).

Aquí se combina solución 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 quieres ir a la ruta de eliminar todos los objetos (que es mucho más simple que derribar la pila de datos básicos, pero menos eficiente), que se trata de una mejor aplicació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 aplicación aprovecha NSOperation para llevar a cabo la eliminación fuera del hilo principal y notificar la finalización. Es posible que desee emitir una notificación o algo dentro del bloque de terminación de la burbuja el estado de nuevo al hilo principal.

iOS 10 + Swift 3 solución: 

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<NSFetchRequestResult>(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 básicos y les despeja

Esta es una versión algo simplificada con menos llamadas a la libre AppDelegate y el último trozo de código que quedó fuera de la respuesta más valorados. También estaba recibiendo un error "almacenamiento persistente del objeto no es accesible desde el coordinador de este NSManagedObjectContext" por lo que sólo es necesario añadir que volver. 

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)
    }

A modo de referencia para guardar la búsqueda en otros lugares - recrear el almacén persistente después de borrar que se puede hacer con: 

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

Gracias por el puesto. Lo seguí y funcionó para mí. Pero tenía otra cuestión que no fue mencionado en ninguna de las respuestas. Así que no estoy seguro de si era sólo yo.

De todos modos, pensé que iba a publicar aquí el problema y mi forma de que lo resolvió.

Yo tenía unos pocos registros en la base de datos, quería purgar todo limpio antes de escribir nuevos datos en la base de datos, así que lo hice todo, incluyendo 

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

y luego se usa managedObjectContext acceder a la base de datos (se supone que estar vacío por ahora), de alguna manera los datos todavía estaba allí. Después de un tiempo de resolución de problemas, encontré que necesito para restablecer managedObject, managedObjectModel, y persistentStoreCoordinator <=>, antes de que yo utilizo para acceder a la <=> dabase. Ahora tengo una base de datos limpia a escribir.

Varias buenas respuestas a esta pregunta. He aquí una agradable concisa. Las dos primeras líneas borrar la base de datos SQLite. Entonces el para:. Bucle 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 se puede encontrar todos los nombres de entidad, y eliminarlos por su nombre. Es una versión más larga, pero funciona bien, de esa manera usted no tiene que trabajar con la tienda de persistencia 

 - (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" acaba de dar cualquiera de nombre de su entidad, sólo tenemos que averiguar la descripción entidad sus entidades están dentro. ValueForKey @ "nombre" devolverá todos los nombres de entidad. Por último, no se olvide de guardar.

La respuesta aceptada es correcta con la eliminación de URL por NSFileManager es correcto, pero como se indica en iOS 5+ edición, el almacén persistente no está representado por un solo archivo. Para tienda de SQLite es .sqlite *, * .sqlite-SHM y * .sqlite-wal ... afortunadamente ya IOS 7+ podemos utilizar el método

[NSPersistentStoreCoordinator + removeUbiquitousContentAndPersistentStoreAtURL: Opciones: Error:]

para cuidar de extracción, por lo que el código debe 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];

Funciona con todas las versiones. Pase nombre de la entidad y recorrer 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<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)")
    }
}

Aquí hay una versión que elimina todos los registros de cada mesa que tiene.

Swift 4 

static func resetDatabase() {
    do {
        try dataStore.persistentStoreCoordinator.managedObjectModel.entities.forEach { (entity) in
            if let name = entity.name {
                let fetch = NSFetchRequest<NSFetchRequestResult>(entityName: name)
                let request = NSBatchDeleteRequest(fetchRequest: fetch)
                try mainContext.execute(request)
            }
        }

        try mainContext.save()
    } catch {
        print("error resenting the database: \(error.localizedDescription)")
    }
}

Borrar el archivo de almacén persistente y configurar un nuevo coordinador almacén persistente?

Eliminar SQLite desde su fileURLPath y luego construir.

Suponiendo que esté usando MagicalRecord y tener un almacén de persistencia predeterminado:

No me gustan todas las soluciones que asumen que existen ciertos archivos y/o exigen ingresar los nombres o clases de las entidades.Esta es una forma segura y Swift(2) de eliminar todos los datos de todas las entidades.Después de eliminarlo, también se recreará una pila nueva (en realidad, no estoy seguro de cuán necesaria es esta parte).

Es bueno para situaciones de estilo "cerrar sesión" cuando desea eliminar todo pero tiene una tienda en funcionamiento 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 el bucle for (en mi aplicación agregué esta función para los probadores para que puedan borrar datos y realizar casos de prueba en lugar de eliminar e instalar 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 borrar todos los registros. 'Usuarios' es 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<NSFetchRequestResult>(entityName: "Users")
    let req = NSBatchDeleteRequest(fetchRequest: fetchReq)

    do {
        try managedObjectContext.execute(req)

    } catch {
        // Error Handling
    }   
}

IOS 10 y Swift 3

Si se asume que el nombre de la entidad es "Foto", y que se crea una clase CoreDataStack ... 

 func clearData() {
        do {            
            let context = CoreDataStack.sharedInstance.persistentContainer.viewContext
            let fetchRequest = NSFetchRequest<NSFetchRequestResult>(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 de cómo utilizar CoreData y cómo utilizar este método. https : //medium.com/compileswift/parsing-json-response-and-save-it-in-coredata-step-by-step-fb58fc6ce16f#.1tu6kt8qb

Otro método (aparte de una solicitud de eliminación por lotes) que uso a menudo (según los requisitos de la aplicación) es restablecer el almacén persistente.La implementación se ve así para iOS 10+ y Swift (suponiendo que tenga una clase CoreDataManager):

let persistentContainer: NSPersistentContainer = {
    let container = NSPersistentContainer(name: "<Data-Model-Name>“)
    container.loadPersistentStores(completionHandler: { (storeDescription, err) in
        if let err = err {
            fatalError("loading of store failed: \(err)")
        }
    })
    return container
}()

func resetPersistentStore() {

    if let persistentStore = persistentContainer.persistentStoreCoordinator.persistentStores.last {
        let storeURL = persistentContainer.persistentStoreCoordinator.url(for: persistentStore)

        do {
            try persistentContainer.persistentStoreCoordinator.destroyPersistentStore(at: storeURL, ofType: NSSQLiteStoreType, options: nil)
        } catch {
            print("failed to destroy persistent store:", error.localizedDescription)
        }

        do {
            try persistentContainer.persistentStoreCoordinator.addPersistentStore(ofType: NSSQLiteStoreType, configurationName: nil, at: storeURL, options: nil)
        } catch {
            print("failed to re-add persistent store:", error.localizedDescription)
        }
    }

}

Una ventaja de este método es que es más sencillo, especialmente cuando tiene una gran cantidad de registros de datos para numerosas entidades en sus datos principales.En cuyo caso, una solicitud de eliminación por lotes consumiría mucha memoria.

ya está todo lo que esto parezca complicado. Usted puede enviar su NSManagedObjectContext el método de reset

Licenciado bajo: CC-BY-SA con atribución
No afiliado a StackOverflow
scroll top