Löschen / Zurücksetzen aller Einträge in Core Data?

Question

Kennen Sie irgendeine Weise alle Einträge in Core Data gespeichert zu löschen? Mein Schema soll gleich bleiben; Ich möchte es einfach leer zurückgesetzt werden.

---

Bearbeiten

Ich suche diese programmatisch zu tun, so dass ein Benutzer im Wesentlichen kann einen reset Knopf drücken.

Answer 1

Sie können immer noch die Datei programmatisch löschen, mit dem NSFileManager. RemoveItemAtPath :: Methode

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

Dann einfach den persistenten Speicher wieder hinzufügen richtig, um sicherzustellen, wird es neu erstellt werden.

Der programmatische Weg durch jede Einheit zur Iteration ist sowohl langsamer und fehleranfällig. Die Verwendung dafür, dass die Art und Weise zu tun ist, wenn Sie einige Einheiten und andere nicht löschen möchten. Allerdings müssen Sie noch sicherstellen, dass Sie behalten referentielle Integrität oder Sie werden die Änderungen nicht anhalten können, zu.

Entfernen Sie einfach den Laden und neu es sowohl schnell als auch sicher ist, und kann sicherlich programmatisch zur Laufzeit durchgeführt werden.

Update für iOS5 +

Mit der Einführung von externen binären Speicher (allowsExternalBinaryDataStorage oder Speichern in Datei External Record) in iOS 5 und OS X 10.7, einfach Dateien von storeURLs darauf zu löschen ist nicht genug. Hier finden Sie die externe Aufnahmedateien hinter sich lassen. Da das Namensschema dieser externen Aufzeichnungsdateien nicht öffentlich ist, habe ich nicht eine universelle Lösung vor. - AN0 8. Mai '12 um 23:00 Uhr

Answer 2

Sie können die SQLite-Datei löschen - aber ich wählen, um es zu tun, indem Sie die Tabellen individuell mit Funktionen Spülen:

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

}

Der Grund, warum ich wählte es durch Tabelle Tabelle zu tun, ist, dass es mir macht bestätigen, wie ich die Programmierung mache, dass die Inhalte der Tabelle zu löschen sinnvoll ist, und es gibt keine Daten, die ich würde lieber halten.

Doing it dieser Wille ist viel langsamer als nur die Datei zu löschen, und ich werde in eine Datei löschen ändern, wenn ich diese Methode zu lange dauert.

Answer 3

Aktualisiert Lösung für iOS 10 +

Verwenden NSBatchDeleteRequest alle Objekte in der Einheit zu löschen, ohne sie in den Speicher laden zu müssen oder durchlaufen sie.

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

Dieser Code wurde für iOS 10 und Swift aktualisiert 3. Wenn Sie iOS 9 unterstützen müssen, finden Sie unter diese Frage .

Quellen:

• Core Data: Schnellster Weg, um alle Instanzen einer Entität löschen (mit Objective-C-Code)
• Was ist neu in Core Data (WWDC 2015 Video)
• Was ist neu in Core Data (WWDC 2016 Video)
• So verwenden Kern Daten in iOS 10
• Was ist neu in Kern Daten Swift 3.0

Answer 4

Ich habe eine clearStores Methode geschrieben, die durch jeden Laden geht und es sowohl vom Koordinator löschen und das Dateisystem (Fehlerbehandlung beiseite gelassen):

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;

Diese Methode ist in einer coreDataHelper Klasse, die Pflege von (unter anderem) die Schaffung der PersistentStore nimmt, wenn es gleich Null ist.

Answer 5

Ich entferne alle Daten von Kerndaten auf einer Schaltfläche Ereignis in einer HomeViewController Klasse: Dieser Artikel hat mir geholfen, so viel ich dachte, ich würde bei.

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

}

Beachten Sie, dass, um self.persistentStoreCoordinator zu nennen ich eine Unterkunft im Home-View-Controller erklärt. (Keine Sorge über die managedObjectContext, dass ich zum Speichern und Laden verwenden.)

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

Dann in der AppDelegate ApplicationDidFinishLaunching rechts unten die Schaffung eines HomeViewController ich habe:

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

Answer 6

MagicalRecord macht dies sehr einfach.

[MyCoreDataObject MR_truncateAll];

Answer 7

iOS9 +, Swift 2

Löschen Sie alle Objekte in allen Unternehmen

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 8

[Späte Antwort in Reaktion auf eine Prämie für neuere Antworten zu fragen]

Mit Blick auf frühere Antworten,

• Fetching und alle Elemente zu löschen, wie von @Grouchal und anderen vorgeschlagen, ist immer noch eine effektive und sinnvolle Lösung. Wenn Sie sehr große Datenspeicher haben, dann könnte es langsam sein, aber es funktioniert immer noch sehr gut.
• Sie einfach das Entfernen der Datenspeicher ist, wie Sie und @groundhog Note, nicht mehr wirksam. Es ist veraltet , auch wenn Sie keine externen binären Speicher verwenden Sie da iOS 7 verwendet WAL-Modus für SQLite Journaling. Mit WAL-Modus für jeden Core Data persistenter Speicher da sein (möglicherweise große) Journaldateien herumsitzen kann.

Aber es ist eine andere, ähnliche Vorgehensweise für den permanenten Speicher zu entfernen, die Arbeit macht. Der Schlüssel ist, Ihre persistente Speicher Datei in einem eigenen Unterverzeichnis zu setzen, die nichts anderes enthalten. Nicht nur in dem Dokumentenverzeichnis-Stick (oder wo auch immer), ein neues Unterverzeichnis nur für den persistenten Speicher erstellen. Der Inhalt dieses Verzeichnis wird sein die persistente Speicher-Datei, die Journaldateien und die externen binären Dateien landen. Wenn Sie den gesamten Datenspeicher nuke möchten, das Verzeichnis löschen und sie werden alle verschwinden.

Sie würden etwas tun, wenn Ihre persistenten Speicher einrichten:

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

Dann, wenn Sie wollen den Laden entfernen,

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

Das entfernt rekursiv sowohl die benutzerdefinierte Unterverzeichnis und alle Kerndaten enthaltenen Dateien.

Dies funktioniert nur, wenn Sie nicht bereits haben Ihre persistenten Speicher in dem gleichen Ordner wie andere, wichtige Daten . Wie das Dokumentenverzeichnis, das wahrscheinlich andere nützliche Sachen drin hat. Wenn das Ihre Situation, könnte man den gleichen Effekt durch die Suche nach Dateien, die Sie wollen halten und zu entfernen alles andere. So etwas wie:

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

Dieser Ansatz kann fehleranfällig sein. Man muss absolut sicher sein, dass Sie wissen, alle Datei, die Sie behalten wollen, denn sonst könnten Sie wichtige Daten entfernen. Auf der anderen Seite können Sie die externen binären Dateien, ohne wirklich zu wissen, um die Datei / Verzeichnisnamen verwendet entfernen Sie sie speichern.

Answer 9

Wenn Sie alle Objekte löschen möchten, und wollen nicht die Backing-Dateien löschen, können Sie folgende Methoden verwenden:

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

Beachten Sie, dass es sehr langsam sein kann (hängt davon ab, wie viele Objekte in Ihrem Objekt Grafik).

Answer 10

Hier wird kombinierte Lösung zum Spülen 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]);
        }
    }  
}

Answer 11

Wenn Sie möchten, gehen die alle Objekte Route löschen (das ist viel einfacher als die Core Data Stapel abzureißen, aber weniger performant), als dies ist eine bessere Umsetzung:

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

Diese Implementierung nutzt NSOperation die Löschung aus dem Haupt-Thread und teilen nach Abschluss durchzuführen. Sie können den Status zurück an den Hauptthread eine Benachrichtigung oder etwas im Abschluss Block Blase emittieren wollen.

Answer 12

iOS 10 + Swift 3 Lösung:

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

Iteriert durch alle Kerndateneinheiten und löscht sie

Answer 13

Hier ist eine etwas vereinfachte Version mit weniger Anrufen AppDelegate selbst und das letzte Stück Code, der aus der am besten bewerteten Antwort gelassen. Ich war auch ein Fehler bekommen „Objekt der persistenten Speicher ist nicht erreichbar von diesem NSManagedObjectContext Koordinator“ dass wieder so brauchte nur hinzuzufügen.

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 14

rasche Lösung:

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 15

Als schnelle Referenz an anderer Stelle speichern Suche - Neuerstellung des persistenten Speichers nach dem Löschen es mit getan werden kann:

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

Answer 16

Danke für den Beitrag. Ich folgte ihm und es funktionierte für mich. Aber ich hatte ein anderes Problem, das nicht in einem der Antworten erwähnt wurde. So bin ich nicht sicher, ob ich es war einfach.

Wie auch immer, dachte, ich würde hier das Problem, und meine Art und Weise veröffentlichen, die es zu lösen.

ich in der Datenbank ein paar Aufzeichnungen hatte, wollte ich alles reinigen sauber, bevor neue Daten an die DB schreiben, also tat ich alles, einschließlich

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

und dann verwendete managedObjectContext Zugriff auf die Datenbank (sollte jetzt leer sein), irgendwie waren die Daten immer noch da. Nach einer gewissen Zeit der Fehlersuche, fand ich, dass ich brauche managedObjectContext, managedObject, managedObjectModel zurückgesetzt und persistentStoreCoordinator, bevor ich managedObjectContext verwenden, um die dabase zuzugreifen. Jetzt habe ich eine saubere Datenbank zu schreiben.

Answer 17

Einige gute Antworten auf diese Frage. Hier ist eine schöne prägnante ein. Die ersten beiden Zeilen die SQLite-Datenbank löschen. Dann wird die für:. Schleife löscht alle Objekte im managedObjectContext Speicher

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 18

Sie können auch alle Entitätsnamen, finden und löschen Sie sie mit Namen. Es ist eine längere Version, aber funktioniert gut, auf diese Weise Sie nicht mit persistenten Speicher arbeiten

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

für „Any_Entity_Name“ gibt nur irgendein Ihr Namen des Unternehmens, wir müssen nur die Entität Beschreibung herauszufinden, Ihre Einheiten innerhalb sind. ValueForKey @ „name“ wird wieder alle Entitätsnamen. Schließlich nicht speichern vergessen.

Answer 19

Die akzeptierte Antwort richtig ist URL durch NSFileManager mit dem Entfernen ist richtig, aber wie in iOS 5 + bearbeiten erwähnte, ist der persistente Speicher nicht nur durch eine Datei repräsentiert. Für SQLite Geschäft es ist * .sqlite, * .sqlite-shm und * .sqlite-wal ... zum Glück seit iOS 7+ können wir Methode verwenden

[NSPersistentStoreCoordinator + RemoveUbiquitousContentAndPersistentStoreAtURL: Optionen: Fehler:]

kümmern Entfernung, so sollte der Code so etwas wie diese:

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 20

Arbeiten mit allen Versionen. Pass Entitätsname und durchläuft alle Einträge zu löschen und den Kontext speichern.

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 21

Hier ist eine Version, die jeden Datensatz in jeder Tabelle löscht Sie haben.

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 22

Löschen Sie den persistenten Speicher-Datei und das Einrichten eines neuen persistenten Speicher Koordinator?

Answer 23

Löschen SQLite von Ihrem fileURLPath und dann bauen.

Answer 24

Angenommen, Sie MagicalRecord verwenden und einen Standard-persistenten Speicher haben:

Ich mag es nicht alle Lösungen, die bestimmte Dateien übernehmen zu existieren und / oder fordern die Entitäten Namen oder Klassen eingeben. Dies ist ein Swift (2), sicherer Weg, um alle Daten von allen Einheiten zu löschen. Nach dem Löschen wird es zu einem neuen Stapel neu (ich bin eigentlich nicht sicher, wie bereits Local dieser Teil ist).

Es ist godo für „logout“ Stil Situationen, in denen Sie alles löschen möchten, haben aber eine Arbeitsspeicher und moc, um neue Daten in zu erhalten (wenn der Benutzer anmeldet ...)

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 25

Verwenden Sie diese

+(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 26

habe ich Grouchal des Code und es zu beschleunigen Ich benutzen Aufzählung bei gleichzeitigem Modus (NSEnumerationConcurrent), ist es ein bisschen schneller bekam für Schleife im Vergleich zu (in meinem app ich diese Funktion für Tester hinzugefügt, so dass sie Daten löschen und tun können Testfälle anstatt sie löschen und App installieren)

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

hier meine swift3 Version für alle Datensätze löschen. ‚Benutzer‘ ist Entitätsname

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

iOS 10 und Swift 3

Unter der Annahme, dass Ihr Unternehmen den Namen „Photo“, und dass Sie eine CoreDataStack Klasse erstellen ...

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

Hier ist ein gutes Tutorial, wie Coredata zu verwenden und wie diese Methode zu verwenden. https : //medium.com/compileswift/parsing-json-response-and-save-it-in-coredata-step-by-step-fb58fc6ce16f#.1tu6kt8qb

Answer 29

Eine andere Methode (abgesehen von einer Lösch Batch Anfrage) ich oft verwenden (basierend auf App-Anforderung) ist für den permanenten Speicher zurückgesetzt werden. Die Implementierung sieht wie folgt für iOS 10+ und Swift (vorausgesetzt, Sie eine CoreDataManager Klasse):

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

}

Ein Vorteil dieser Methode ist, dass es besonders einfacher ist, wenn Sie Lasten des Datensatz für zahlreiche Entitäten in Ihren Kerndaten haben. In diesem Fall wird ein Löschstapelanfragespeicherintensiv sein würde.

Answer 30

Sie alle machen dies scheint kompliziert. Sie können Ihre NSManagedObjectContext die Reset-Methode nur senden