Eliminare/reimpostare tutte le voci in Core Data?

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

Domanda

Conosci un modo per eliminare tutte le voci memorizzate in Core Data?Il mio schema dovrebbe rimanere lo stesso;Voglio solo reimpostarlo su vuoto.

Modificare

Sto cercando di farlo a livello di codice in modo che un utente possa essenzialmente premere a reset pulsante.

È stato utile?

Soluzione

È comunque possibile eliminare il file a livello di codice, utilizzando il NSFileManager:. RemoveItemAtPath :: metodo 

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

Poi, basta aggiungere l'archivio permanente di nuovo per assicurarsi che sia ricreato correttamente.

Il modo di programmazione per l'iterazione attraverso ogni entità sia più lento e soggetto a errori. L'uso per farlo in questo modo è che se si desidera eliminare alcune entità e non altri. Tuttavia è ancora necessario per essere sicuri di mantenere l'integrità referenziale o non sarà in grado di persistere le modifiche.

Basta rimuovere il negozio e ricreare è sia veloce e sicuro, e può certamente essere fatto programatically a tempo di esecuzione.

Aggiornamento per iOS5 +

Con l'introduzione di stoccaggio binario esterno (allowsExternalBinaryDataStorage o conservare in file di registrazione esterna) in iOS 5 e OS X 10.7, semplicemente cancellando i file puntati dai storeURLs non è sufficiente. Lascerai i files registrati esterni dietro. Dal momento che lo schema di denominazione di questi file di registrazione esterni non è pubblico, non ho ancora una soluzione universale. - an0 8 maggio '12 alle ore 23:00

Altri suggerimenti

È possibile eliminare il file SQLite - ma scegliere di farlo da spurgo le tabelle singolarmente con funzioni: 

- (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 ragione per cui ho scelto di farlo tavolo da tavolo è che mi fa confermo come sto facendo la programmazione che l'eliminazione del contenuto della tabella è ragionevole e non ci sono dati che avrei preferito continuare.

Facendo in questo volontà è molto più lento di appena l'eliminazione del file e cambierò in un file di eliminare se questo metodo richiede troppo tempo.

Aggiornamento Soluzione per iOS 10 +

Usa NSBatchDeleteRequest per eliminare tutti gli oggetti del soggetto senza doverli caricare in memoria o iterare attraverso di loro. 

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

Questo codice è stato aggiornato per iOS 10 e Swift 3. Se è necessario supportare iOS 9, vedere questa domanda .

Fonti:

Ho scritto un metodo clearStores che passa attraverso ogni negozio ed eliminarlo sia dal coordinatore e il filesystem (gestione degli errori lasciato da parte): 

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;

Questo metodo è all'interno di una classe coreDataHelper che si occupa di (tra le altre cose) la creazione del persistentStore quando è pari a zero.

I rimuovere tutti i dati provenienti da dati di base su un evento tasto in una classe HomeViewController: In questo articolo mi ha aiutato così tanto ho pensato di contribuire. 

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

}

Si noti che, al fine di richiamare self.persistentStoreCoordinator ho dichiarato una proprietà nella casa View Controller. (Non ti preoccupare il managedObjectContext che uso per salvataggio e il caricamento.) 

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

Poi nel AppDelegate applicationDidFinishLaunching proprio sotto la creazione di un HomeViewController ho: 

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

MagicalRecord rende questo molto facile. 

[MyCoreDataObject MR_truncateAll];

iOS9 +, Swift 2

Elimina tutti gli oggetti in tutte le entità 

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

[risposta ritardo in risposta ad una taglia per chiedere risposte più recenti]

Guardando oltre le risposte precedenti,

  • Recupero e l'eliminazione di tutti gli elementi, come suggerito da @Grouchal e altri, è ancora una soluzione efficace e utile. Se si dispone di grandi archivi di dati allora potrebbe essere lento, ma funziona ancora molto bene.
  • È sufficiente rimuovere l'archivio dati è, come si nota e @groundhog, non è più efficace. E 'obsoleto anche se non si utilizza archiviazione binario esterno perché iOS 7 utilizza la modalità WAL per SQLite journaling. Con la modalità WAL ci può essere (potenzialmente) di grandi file di giornale seduti intorno per qualsiasi archivio permanente Core Data.

Ma c'è un approccio diverso e simile alla rimozione della memoria permanente che fa il lavoro. La chiave è di mettere il vostro file di archivio permanente nella propria sotto-directory che non contiene niente altro. Non solo bastone nella directory documenti (o ovunque), creare una nuova sotto-directory solo per l'archivio permanente. Il contenuto di tale directory finirà per essere il file persistenti negozio, i file journal, ei file binari esterni. Se si vuole bombardare l'intero archivio dati, eliminare tale directory e saranno tutti scompaiono.

Si potrebbe fare qualcosa di simile quando si imposta il tuo archivio permanente: 

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

Poi, quando si voleva rimuovere l'archivio, 

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

Questo rimuove ricorsivamente sia il sub-directory personalizzata e tutti i file di Core Data in esso.

Questo funziona solo se non si dispone già di tuo negozio persistente nella stessa cartella di altri dati importanti, . Come la directory di documenti, che probabilmente ha altre cose utili in esso. Se questa è la vostra situazione, si potrebbe ottenere lo stesso effetto con la ricerca di file che si do vuole tenere e la rimozione di tutto il resto. Qualcosa di simile: 

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

Questo approccio può essere soggetto a errori . Hai avuto modo di essere assolutamente sicuri che si sa ogni file che si desidera conservare, perché altrimenti si potrebbe rimuovere i dati importanti. D'altra parte, è possibile rimuovere i file binari esterni senza in realtà conoscere il nome del file / directory utilizzata per la memorizzazione.

Se si desidera eliminare tutti gli oggetti e non vogliono eliminare i file di supporto, è possibile utilizzare i seguenti metodi: 

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

Attenzione che può essere molto lenta (dipende da quanti oggetti sono nel vostro oggetto grafico).

Qui si combina soluzione per l'eliminazione 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]);
        }
    }  
}

Se si vuole andare l'eliminare tutti gli oggetti percorso (che è molto più semplice di abbattere la pila Core Data, ma meno performante), che questo è un implementazione meglio: 

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

Questa implementazione sfrutta NSOperation per eseguire l'eliminazione iniziale del filo principale e notificare al termine. Si consiglia di emettere una notifica o qualcosa all'interno del blocco di completamento a bollire lo stato di nuovo al thread principale.

iOS 10 + Swift 3 soluzione: 

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

consente di scorrere tutte le entità di dati di base e li cancella

Ecco una versione un po 'semplificata con meno chiamate a AppDelegate sé e l'ultimo pezzo di codice che è stato lasciato fuori dalla top rated risposta. Anche io stavo ottenendo un errore "memoria permanente di oggetto non è raggiungibile da coordinatore di questo NSManagedObjectContext" così solo bisogno di aggiungere che indietro. 

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

soluzione rapida: 

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

come riferimento rapido per salvare la ricerca altrove - ricreare l'archivio permanente dopo l'eliminazione di esso può essere fatto con: 

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

Grazie per il post. Ho seguito e ha funzionato per me. Ma ho avuto un altro problema che non è stato menzionato in nessuna delle risposte. Quindi io non sono sicuro se è stato solo me.

In ogni caso, ho pensato di postare qui il problema e il mio modo che risolto.

Ho avuto qualche record nel database, ho voluto eliminare tutto pulito prima di scrivere nuovi dati al DB, così ho fatto tutto, compreso 

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

e poi utilizzato managedObjectContext per accedere al database (dovrebbe essere vuota ormai), in qualche modo i dati erano ancora lì. Dopo un po 'di risoluzione dei problemi, ho scoperto che ho bisogno di resettare managedObject, managedObjectModel, persistentStoreCoordinator e <=>, prima che io uso <=> per accedere al dabase. Ora ho un database pulito di scrivere.

Diverse buone risposte a questa domanda. Ecco una bella concisa. Le prime due righe eliminare il database SQLite. Poi il per:. Circuito cancella tutti gli oggetti nella 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];
}

si possono anche trovare tutti i nomi di entità, ed eliminarli in base al nome. La sua una versione più lunga, ma funziona bene, in questo modo non dovete lavorare con di persistenza 

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

per "Any_Entity_Name" basta dare uno qualsiasi del nome di vostra entità, abbiamo solo bisogno di capire la descrizione dell'entità tuoi entità sono all'interno. ValueForKey @ "nome" restituirà tutti i nomi delle entità. Infine, non dimenticate di salvare.

La risposta accettata è corretta con la rimozione di URL da NSFileManager è corretto, ma come detto in iOS 5+ modificare l'archivio permanente non è rappresentato solo da un unico file. Per negozio di SQLite è * .sqlite, * .sqlite-SHM e * .sqlite-wal ... per fortuna dal momento che iOS 7+ possiamo utilizzare il metodo

[NSPersistentStoreCoordinator + removeUbiquitousContentAndPersistentStoreAtURL: Opzioni: errore:]

per prendersi cura di rimozione, in modo che il codice dovrebbe essere qualcosa di simile: 

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

Funziona con tutte le versioni. Passare nome dell'entità e scorrere per eliminare tutte le voci e salvare il contesto. 

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

Ecco una versione che elimina ogni record in ogni tabella che hai.

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

Eliminare il file archivio permanente e messa a punto di un nuovo coordinatore persistente negozio?

Elimina SQLite dal fileURLPath e poi costruire.

Supponendo che si sta utilizzando MagicalRecord e dispone di un archivio predefinito di persistenza:

Non mi piacciono tutte le soluzioni che assumono alcuni file di esistere e / o richiedono l'inserimento dei nomi di enti o classi. Si tratta di una Swift (2), modo sicuro per cancellare tutti i dati da tutte le entità. Dopo l'eliminazione sarà ricreare una pila fresca troppo (non sono realmente sicuro di come neccessery questa parte è).

E 'godo per "logout" situazioni di stile quando si desidera cancellare tutto, ma hanno un negozio di lavoro e moc per ottenere nuovi dati (una volta che l'utente accede a ...) 

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

    }
}

Usa questo

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

ho preso il codice di Grouchal e per accelerarlo ho usato enumerazione con modalità simultanea (NSEnumerationConcurrent), ha ottenuto un po 'più veloce rispetto al ciclo for (nella mia app ho aggiunto questa funzione per i tester in modo che possano cancellare i dati e fare testcases piuttosto che cancellare e installare app) 

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

qui la mia versione swift3 per eliminare tutti i record. 'Gli utenti' è il nome dell'entità 

@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 e Swift 3

Supponendo che il tuo nome entità è "Foto", e che si crea una classe 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)")
            }
        }
    }

Ecco un buon tutorial su come utilizzare CoreData e come utilizzare questo metodo. https : //medium.com/compileswift/parsing-json-response-and-save-it-in-coredata-step-by-step-fb58fc6ce16f#.1tu6kt8qb

Un altro metodo (a parte una richiesta di eliminazione lotto) Io uso spesso (basato sul requisito app) è di ripristinare l'archivio permanente. L'implementazione si presenta così per iOS 10+ e Swift (supponendo di avere una classe 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)
        }
    }

}

Un vantaggio di questo metodo è che è più semplice soprattutto quando si hanno carichi di record di dati per numerosi enti nei dati fondamentali. Nel qual caso la richiesta lotto di eliminazione sarebbe intensivo di memoria.

siete tutti facendo questo sembrare complicato. Si può semplicemente inviare il vostro NSManagedObjectContext il metodo di ripristino

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top