wake-up-neo.com

Alle Einträge in Core Data löschen/zurücksetzen?

Kennen Sie eine Möglichkeit, alle in Core Data gespeicherten Einträge zu löschen? Mein Schema sollte gleich bleiben. Ich möchte es nur auf leer setzen.


Bearbeiten

Ich versuche, dies programmgesteuert zu tun, so dass ein Benutzer im Wesentlichen eine reset-Taste drücken kann.

224
Michael Grinich

Sie können die Datei weiterhin programmgesteuert mit der NSFileManager: removeItemAtPath :: -Methode löschen.

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

Fügen Sie dann einfach den permanenten Speicher wieder hinzu, um sicherzustellen, dass er ordnungsgemäß wiederhergestellt wird.

Der programmatische Weg zum Durchlaufen jeder Entität ist sowohl langsamer als auch fehleranfällig. Auf diese Weise können Sie einige Entitäten löschen, andere jedoch nicht. Sie müssen jedoch weiterhin sicherstellen, dass Sie die referentielle Integrität beibehalten, oder Sie können Ihre Änderungen nicht beibehalten.

Das Löschen und Wiederherstellen des Speichers ist sowohl schnell als auch sicher und kann sicherlich zur Laufzeit programmgesteuert durchgeführt werden.

Update für iOS5 +

Mit der Einführung des externen binären Speichers (erlaubtExternalBinaryDataStorage oder In externer Datensatzdatei speichern) in iOS 5 und OS X 10.7 reicht es nicht aus, Dateien zu löschen, auf die storeURLs zeigen. Sie lassen die externen Aufzeichnungsdateien zurück. Da das Benennungsschema dieser externen Datensatzdateien nicht öffentlich ist, habe ich noch keine universelle Lösung. - an0 8. Mai 12 um 23:00 Uhr

196
groundhog

Sie können die SQLite-Datei löschen - ich entscheide mich dafür, indem Sie die Tabellen einzeln mit einer Funktion löschen:

- (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, aus dem ich mich für Tabelle für Tabelle entschieden habe, besteht darin, dass ich mich bei der Programmierung dazu bekennen muss, dass das Löschen des Tabelleninhalts sinnvoll ist und es keine Daten gibt, die ich lieber behalten möchte.

Wenn Sie dies tun, ist dies viel langsamer als das Löschen der Datei. Wenn ich diese Methode zu lange dauert, werde ich in eine Datei löschen.

139
Grouchal

Aktualisierte Lösung für iOS 9+

Verwenden Sie NSBatchDeleteRequest, um alle Objekte in der Entität zu löschen, ohne sie in den Speicher laden oder durchlaufen zu müssen.

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

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

Quellen: 

49
Suragch

Ich habe eine clearStores-Methode geschrieben, die jeden Speicher durchläuft und sowohl aus dem Koordinator als auch aus dem Dateisystem löscht (Fehlerbehandlung beiseite)

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 befindet sich in einer coreDataHelper-Klasse, die sich (unter anderem) um die Erstellung des persistenten Speichers kümmert, wenn er null ist. 

36
samvermette

Ich entferne alle Daten aus den Kerndaten eines Schaltflächenereignisses in einer HomeViewController-Klasse: Dieser Artikel hat mir so sehr geholfen, dass ich dachte, dass ich dazu beitragen würde.

-(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 ich zum Aufrufen von self.persistentStoreCoordinator eine Eigenschaft im Home View Controller deklariert habe. (Machen Sie sich keine Sorgen über den managedObjectContext, den ich zum Speichern und Laden verwenden.)

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

Dann in AppDelegate ApplicationDidFinishLaunching direkt unter dem Erstellen eines HomeViewControllers habe ich:

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

MagicalRecord macht dies sehr einfach.

[MyCoreDataObject MR_truncateAll];
21
Brian King

iOS9 +, Swift 2

Löschen Sie alle Objekte in allen Entitäten

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)
        }
    }
}
16
Andres Wang

[Verspätete Antwort auf eine Bounty, die nach neueren Antworten fragt]

Frühere Antworten durchsehen,

  • Das Abrufen und Löschen aller Elemente, wie von @Grouchal und anderen vorgeschlagen, ist weiterhin eine effektive und nützliche Lösung. Wenn Sie über sehr große Datenspeicher verfügen, ist der Vorgang möglicherweise langsam, funktioniert jedoch weiterhin sehr gut.
  • Das einfache Entfernen des Datenspeichers ist, wie Sie und @groundhog feststellen, nicht mehr wirksam. Es ist veraltet auch wenn Sie keinen externen Binärspeicher verwenden, da iOS 7 den WAL-Modus für SQLite-Journalling verwendet. Im WAL-Modus befinden sich möglicherweise (möglicherweise große) Journaldateien für einen beliebigen persistenten Core Data-Speicher.

Es gibt jedoch einen anderen, ähnlichen Ansatz zum Entfernen des permanenten Speichers, der funktioniert. Der Schlüssel ist, Ihre persistente Speicherdatei in einem eigenen Unterverzeichnis abzulegen, das nichts anderes enthält. Stecken Sie es nicht einfach in das Dokumentenverzeichnis (oder wo auch immer), sondern erstellen Sie ein neues Unterverzeichnis nur für den persistenten Speicher. Der Inhalt dieses Verzeichnisses ist die persistente Speicherdatei, die Journaldateien und die externen Binärdateien. Wenn Sie den gesamten Datenspeicher löschen möchten, löschen Sie dieses Verzeichnis, und alle verschwinden.

Sie würden so etwas tun, wenn Sie Ihren 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 den Laden entfernen wollten,

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

Dadurch werden sowohl das benutzerdefinierte Unterverzeichnis als auch alle darin enthaltenen Core Data-Dateien rekursiv entfernt.

Dies funktioniert nur, wenn Sie Ihren persistenten Speicher nicht bereits im selben Ordner wie andere wichtige Daten haben.. Wie das Dokumentenverzeichnis, in dem sich wahrscheinlich noch andere nützliche Dinge befinden. Wenn das Ihre Situation ist, können Sie den gleichen Effekt erzielen, indem Sie nach Dateien suchen, die Sie tun behalten und alles andere entfernen möchten. 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. Sie müssen absolut sicher sein, dass Sie jede Datei kennen, die Sie behalten möchten, da Sie sonst möglicherweise wichtige Daten entfernen. Andererseits können Sie die externen Binärdateien entfernen, ohne den zum Speichern verwendeten Datei-/Verzeichnisnamen zu kennen.

13
Tom Harrington

Hier ist eine kombinierte Lösung zum Löschen von Kerndaten.

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

Wenn Sie alle Objekte löschen möchten und die Sicherungsdateien nicht löschen möchten, können Sie die folgenden 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 (abhängig von der Anzahl der Objekte in Ihrem Objektdiagramm).

10
Marián Černý

Wenn Sie die Route zum Löschen aller Objekte verwenden möchten (was viel einfacher ist, als den Core Data-Stack abzureißen, aber weniger performant), ist dies eine bessere Implementierung:

- (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, um den Löschvorgang aus dem Haupt-Thread durchzuführen und nach Abschluss zu benachrichtigen. Möglicherweise möchten Sie eine Benachrichtigung oder etwas innerhalb des Beendigungsblocks ausgeben, um den Status zum Hauptthread zurückzublasen.

6
Blake Watters

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

Durchläuft alle Kerndatenelemente und löscht sie

5
KVISH

Schnelle 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)
    }
4
János

Hier ist eine etwas vereinfachte Version mit weniger Aufrufen von AppDelegate self und dem letzten Code, der von der Antwort mit der höchsten Bewertung ausgeschlossen wurde. Ich habe auch eine Fehlermeldung erhalten, dass der permanente Speicher des Objekts vom Koordinator von NSManagedObjectContext nicht erreichbar ist.

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];
}
4
Alberto Lopez

Danke für die post Ich folgte dem und es funktionierte für mich. Ich hatte jedoch ein anderes Problem, das in keiner der Antworten erwähnt wurde. Ich bin mir also nicht sicher, ob es nur ich war. 

Ich dachte, ich würde hier das Problem und meinen Weg, der es gelöst hat, hier posten.

Ich hatte ein paar Datensätze in der Datenbank, ich wollte alles bereinigen, bevor neue Daten in die Datenbank geschrieben wurden, also habe ich alles inklusive gemacht 

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

und benutzte dann managedObjectContext, um auf die Datenbank zuzugreifen (die jetzt leer sein sollte), irgendwie waren die Daten noch vorhanden. Nach einiger Zeit der Fehlerbehebung habe ich festgestellt, dass ich managedObjectContext, managedObject, managedObjectModel und persistentStoreCoordinator zurücksetzen muss, bevor ich mit managedObjectContext auf die Datenbank zugreifen kann. Jetzt habe ich eine saubere Datenbank zum Schreiben. 

3
DanielZ

Einige gute Antworten auf diese Frage. Hier ist ein schönes kurzes. Die ersten beiden Zeilen löschen die SQLite-Datenbank. Dann löscht die for: -Schleife alle Objekte im Speicher von 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];
}
3
adamek

Als schnelle Referenz, um die Suche an anderer Stelle zu speichern. Das Wiederherstellen des persistenten Speichers nach dem Löschen kann wie folgt durchgeführt werden:

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

Die akzeptierte Antwort ist korrekt. Das Entfernen der URL durch NSFileManager ist korrekt. Wie in iOS 5+ Bearbeiten angegeben, wird der persistente Speicher jedoch nicht nur in einer Datei dargestellt. Für den SQLite-Shop sind * .sqlite, * .sqlite-shm und * .sqlite-wal ... glücklicherweise können wir seit iOS 7+ die Methode verwenden 

[NSPersistentStoreCoordinator + RemoveUbiquitousContentAndPersistentStoreAtURL: Optionen: Fehler:]

um das Entfernen zu verhindern, sollte der Code etwa so aussehen:

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

sie können auch alle Entitätsnamen finden und nach Namen löschen. Es ist eine längere Version, funktioniert aber gut. Auf diese Weise müssen Sie nicht mit dem Persistenzspeicher 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];
    }
}

bei "Any_Entity_Name" geben Sie einfach einen beliebigen Namen Ihrer Entität an. Wir müssen nur die Entitätsbeschreibung ermitteln, in der sich Ihre Entitäten befinden. ValueForKey @ "name" gibt alle Entitätsnamen zurück. Vergiss nicht zu speichern.

2
Chris Lin

Eine andere Methode (abgesehen von einer Anforderung zum Löschen eines Stapels), die ich häufig verwende (basierend auf der App-Anforderung), ist das Zurücksetzen des beständigen Speichers. Die Implementierung sieht für iOS 10+ und Swift so aus (vorausgesetzt, Sie haben 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 sie einfacher ist, insbesondere wenn Ihre Kerndaten eine Vielzahl von Datensätzen enthalten. In diesem Fall wäre eine Anforderung zum Löschen eines Stapels speicherintensiv.

0

Benutze das

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

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

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

Löschen Sie die persistente Speicherdatei und richten Sie einen neuen permanenten Speicherkoordinator ein.

0
Hunter

Ich habe Grouchals Code genommen und zur Beschleunigung die Enumeration mit dem gleichzeitigen Modus (NSEnumerationConcurrent) verwendet. Er wurde etwas schneller als bei der Schleife (in meiner App habe ich diese Funktion für Tester hinzugefügt, damit sie Daten löschen und Testfälle ausführen können, anstatt sie zu löschen App installieren und 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);
    }
}
0
anoop4real

Angenommen, Sie verwenden MagicalRecord und verfügen über einen Standard-Persistenzspeicher:

Ich mag nicht alle Lösungen, die davon ausgehen, dass bestimmte Dateien existieren und/oder die Eingabe der Namen oder Klassen der Entitäten verlangen. Dies ist eine schnelle Methode (2), um alle Daten aus allen Entitäten zu löschen. Nach dem Löschen wird auch ein neuer Stapel erstellt (ich bin mir eigentlich nicht sicher, wie wichtig dieses Teil ist). 

Es ist ein Godo für "Logout" -Situationen, in denen Sie alles löschen möchten, aber einen Arbeitsspeicher und einen Moc haben, um neue Daten zu erhalten (sobald sich 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)
        }

    }
}
0
Aviel Gross

iOS 10 und Swift 3

Angenommen, Ihr Entitätsname lautet "Foto" und Sie erstellen eine CoreDataStack-Klasse ...

 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 finden Sie ein gutes Tutorial zur Verwendung von CoreData und zur Verwendung dieser Methode . https://medium.com/compileswift/parsing-json-response-and-save-it-in-coredata-step- by-step-fb58fc6ce16f # .1tu6kt8qb

0
James Rochabrun

Funktioniert mit allen Versionen. Übergeben Sie den Entitätsnamen und iterieren Sie, um alle Einträge zu löschen und den Kontext zu 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)")
    }
}
0
Karun Kumar

hier meine Swift3-Version zum Löschen aller Datensätze. 'Benutzer' ist der 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
    }   
}
0
Kursat Turkay

Löschen Sie sqlite aus Ihrem fileURLPath und erstellen Sie dann.

0
Jai