iphone - guia - qgis manual

¿Borrar/restablecer todas las entradas en Core Data?

Question

¿Conoces alguna forma de eliminar todas las entradas almacenadas en Core Data? Mi esquema debe permanecer igual; Sólo quiero volver a ponerlo en blanco.

Editar

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

Answer 1

Solución actualizada para iOS 9+

Use NSBatchDeleteRequest para eliminar todos los objetos en la entidad sin tener que cargarlos en la memoria o iterarlos.

// create the delete request for the specified entity
let fetchRequest = NSFetchRequest<NSFetchRequestResult>(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 compatibilidad con iOS 9, consulte esta pregunta .

Fuentes:

• Datos básicos: la 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 (WWDC 2016 video)?
• Cómo usar Core Data en iOS 10
• Novedades en Core Data Swift 3.0

Answer 2

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

Answer 3

Aún puede eliminar el archivo mediante programació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, simplemente vuelva a agregar el almacén persistente para asegurarse de que se vuelva a crear correctamente.

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

Solo 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 grabación externos. Dado que el esquema de nombres de estos archivos de registro externos no es público, todavía no tengo una solución universal. - An0 de mayo 8 ''12 a las 23:00.

Answer 4

Aquí está la solución combinada para purgar los datos básicos.

- (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]);
        }
    }  
}

Answer 5

Aquí hay una versión que elimina todos los registros de 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<NSFetchRequestResult>(entityName: name)
                let request = NSBatchDeleteRequest(fetchRequest: fetch)
                try mainContext.execute(request)
            }
        }

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

Answer 6

Aquí hay una versión un tanto simplificada con menos llamadas a AppDelegate self y el último bit de código que se dejó fuera de la respuesta mejor calificada. También recibí un error "El almacén persistente del objeto no es accesible desde este coordinador de NSManagedObjectContext", así que solo era necesario 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];
}

Answer 7

Aquí mi versión swift3 para borrar 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<NSFetchRequestResult>(entityName: "Users")
    let req = NSBatchDeleteRequest(fetchRequest: fetchReq)

    do {
        try managedObjectContext.execute(req)

    } catch {
        // Error Handling
    }   
}

Answer 8

Como referencia rápida para guardar la búsqueda en otro lugar, la recreación del almacén persistente después de eliminarlo se puede hacer con:

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

Answer 9

Eliminé todos los datos de los datos principales en un botón Evento en una clase de 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, declaré una propiedad en el Home View Controller. (No te preocupes por el managedObjectContext que utilizo para guardar y cargar.)

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

Luego, en el AppDelegate ApplicationDidFinishLunching 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;

Answer 10

Elimine sqlite de su fileURLPath y luego compile.

Answer 11

Funciona con todas las versiones. Pase el nombre de la entidad y repítalo para borrar 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)")
    }
}

Answer 12

Gracias por la publicacion. Lo seguí y me funcionó. Pero tuve otro problema que no se mencionó en ninguna de las respuestas. Así que no estoy seguro de si era solo yo.

De todos modos, pensé en publicar aquí el problema y mi forma de resolverlo.

Tenía algunos registros en la base de datos, quería limpiar todo antes de escribir nuevos datos en la base de datos, así que hice todo, incluso

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

y luego usó 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, encontré que necesito restablecer 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.

Answer 13

He escrito un método de clearStores que recorre cada tienda y lo borro tanto del coordinador como del sistema de archivos (manejo de errores 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 se encuentra dentro de una clase coreDataHelper que se encarga de (entre otras cosas) crear PersistentStore cuando es nulo.

Answer 14

La respuesta aceptada es correcta, ya que la eliminación de URL por NSFileManager es correcta, pero como se indica en la edición de iOS 5+, 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: opciones: error:]

para cuidar de la eliminació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];

Answer 15

Puedes eliminar el archivo SQLite, pero elijo hacerlo purificando 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 mesa por mesa es que me hace confirmar, ya que estoy haciendo la programación de que eliminar los contenidos de la tabla es sensato y no hay datos que prefiero conservar.

Hacer esto es mucho más lento que simplemente eliminar el archivo y cambiaré a un archivo eliminado si este método demora demasiado.

Answer 16

Si desea eliminar todos los objetos y no desea eliminar los archivos de respaldo, puede utilizar 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).

Answer 17

Si desea ir a la ruta de eliminar todos los objetos (que es mucho más simple que arrancar la pila de Datos del Núcleo, pero con menos rendimiento), entonces 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 fuera del hilo principal y notificar al finalizar. Es posible que desee emitir una notificación o algo dentro del bloque de finalización para hacer que el estado vuelva al hilo principal.

Answer 18

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

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

Answer 19

Suponiendo que está utilizando MagicalRecord y tiene un almacén de persistencia predeterminado:

No me gustan todas las soluciones que suponen que ciertos archivos existen y / o exigen la introducción de nombres o clases de entidades. Esta es una manera segura y rápida de eliminar todos los datos de todas las entidades. Después de eliminarlo, también se volverá a crear una pila nueva (en realidad no estoy seguro de cuán necesaria es esta parte).

Es godo para las situaciones de estilo de "cierre de sesión" cuando desea eliminar todo pero tiene una tienda que funciona y 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)
        }

    }
}

Answer 20

También puede encontrar todos los nombres de entidades y eliminarlos por nombre. Es una versión más larga pero funciona bien, de esa manera no tienes que trabajar con el almacén 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" simplemente proporcione cualquiera de los nombres de su entidad, solo necesitamos averiguar la descripción de la entidad en la que se encuentran sus entidades. ValueForKey @ "nombre" devolverá todos los nombres de entidad. Por último, no te olvides de guardar.

Answer 21

Tomé el código de Grouchal y, para acelerarlo, utilicé la enumeración con el modo concurrente ( NSEnumerationConcurrent ), fue 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 hacer testcases en lugar de borrar 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);
    }
}

Answer 22

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];
}

Answer 23

Varias buenas respuestas a esta pregunta. Aquí hay una bonita 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];
}

Answer 24

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

Answer 25

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

Answer 26

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

Answer 27

MagicalRecord hace esto muy fácil.

[MyCoreDataObject MR_truncateAll];

Answer 28

[Respuesta tardía en respuesta a una recompensa que solicita respuestas más recientes]

Mirando las respuestas anteriores,

• La obtención y eliminación de todos los elementos, según lo sugerido por @Grouchal y otros, sigue siendo una solución efectiva y útil. Si tiene almacenes de datos muy grandes, puede ser lento, pero aún funciona muy bien.
• Simplemente eliminar el almacén de datos no es efectivo, como usted y @groundhog note. Es obsoleto incluso si no utiliza almacenamiento binario externo porque iOS 7 usa el modo WAL para el registro de SQLite. Con el modo WAL puede haber archivos de diario (potencialmente grandes) en cualquier almacén persistente de Core Data.

Pero hay un enfoque diferente y similar para eliminar el almacén persistente que sí 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 en cualquier lugar), cree un nuevo subdirectorio solo para el almacén persistente. El contenido de ese directorio terminará siendo el archivo de almacenamiento persistente, los archivos de diario y los archivos binarios externos. Si desea destruir todo el almacén de datos, elimine ese directorio y todos desaparecerán.

Harías algo como esto al configurar tu 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...
}

Entonces cuando querías quitar 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 almacén persistente en la misma carpeta que otros datos importantes . Como el directorio de documentos, que probablemente tiene otras cosas útiles en él. Si esa es su situación, puede obtener el mismo efecto buscando archivos que desea conservar y eliminar 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 cada archivo que desea conservar, ya que de lo contrario podría eliminar datos importantes. Por otro lado, puede eliminar los archivos binarios externos sin saber realmente el nombre del archivo / directorio utilizado para almacenarlos.

Answer 29

Todos ustedes hacen que esto parezca complicado. Simplemente puede enviar a su NSManagedObjectContext el método de reinicio