Możesz usunąć plik sqllite - ale ja wybieram to, czyszcząc tabele pojedynczo za pomocą funkcji:

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

}

Powodem, dla którego zdecydowałem się to zrobić tabela po tabeli, jest to, że pozwala mi to potwierdzić podczas programowania, że usuwanie zawartości tabeli jest rozsądne i nie ma danych, które wolałbym zachować.

Robienie tego będzie znacznie wolniejsze niż tylko usuwanie pliku i zmienię na plik usuń, jeśli ta metoda trwa zbyt długo.

Zaktualizowane rozwiązanie dla iOS 9 +

Użyj NSBatchDeleteRequest, Aby usunąć wszystkie obiekty w encji bez konieczności ładowania ich do pamięci lub iteracji przez nie.

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

Ten kod został zaktualizowany dla iOS 10 i Swift 3. Jeśli chcesz obsługiwać iOS 9, Zobacz to pytanie.

Źródła:

• Dane podstawowe: najszybszy sposób na usunięcie wszystkich instancji podmiotu (zawiera kod Objective-C)
• Co nowego w Core Dane (wideo WWDC 2015)
• Co nowego w Core Data (wideo WWDC 2016)
• Jak korzystać z podstawowych danych w iOS 10
• Co nowego w Core Data Swift 3.0

Napisałem metodę clearStores, która przechodzi przez każdy sklep i usuwa ją zarówno z koordynatora, jak i z systemu plików (pomijając obsługę błędów):

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;

Ta metoda znajduje się wewnątrz klasy coreDataHelper, która zajmuje się (między innymi) tworzeniem persistentStore, gdy jest zerowa.

Usuwam wszystkie dane z core data na zdarzeniu button w klasie HomeViewController: Ten artykuł pomógł mi tak bardzo, że pomyślałem, że się przyczynię.

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

}

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

Następnie w AppDelegate ApplicationDidFinishLaunching tuż poniżej tworząc HomeViewController mam:

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

MagicalRecord sprawia, że jest to bardzo proste.

[MyCoreDataObject MR_truncateAll];

[późna odpowiedź w odpowiedzi na pytanie o nowsze odpowiedzi]

Patrząc na wcześniejsze odpowiedzi,

• pobieranie i usuwanie wszystkich elementów, zgodnie z sugestiami @Grouchal i innych, jest nadal skutecznym i użytecznym rozwiązaniem. Jeśli masz bardzo duże zapasy danych, może to być powolne, ale nadal działa bardzo dobrze.
• samo usunięcie magazynu danych jest, jak zauważyłeś ty i @ świstak, już nie skuteczne. Jest przestarzały nawet jeśli nie używasz zewnętrznych binarnych storage ponieważ iOS 7 używa trybu WAL dla SQLite journaling. W trybie WAL mogą istnieć (potencjalnie duże) pliki dziennika dla dowolnego trwałego magazynu danych Core Data.

Ale jest inne, podobne podejście do usuwania trwałego sklepu, który działa. Kluczem jest umieszczenie pliku trwałego sklepu we własnym podkatalogu, który nie zawiera niczego innego. Nie umieszczaj go w katalogu dokumentów (lub gdziekolwiek), utwórz nowy podkatalog tylko dla trwały sklep. Zawartość tego katalogu stanie się trwałym plikiem magazynu, plikami dziennika i zewnętrznymi plikami binarnymi. Jeśli chcesz zniszczyć cały magazyn danych, usuń ten katalog, a wszystkie znikną.

Zrobiłbyś coś takiego przy zakładaniu sklepu:

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

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

Że rekurencyjnie usuwa zarówno podkatalog niestandardowy, jak i wszystkie podstawowe pliki danych w to.

Działa to tylko wtedy, gdy twój trwały magazyn nie znajduje się jeszcze w tym samym folderze co inne ważne dane. Jak katalog documents, który prawdopodobnie zawiera inne przydatne rzeczy. Jeśli taka jest Twoja sytuacja, możesz uzyskać ten sam efekt, szukając plików, które chcesz zachować i usuwając wszystko inne. Coś w stylu:

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

Takie podejście może być podatne na błędy . Musisz być absolutnie pewien, że wiesz każdy plik, który chcesz zachować, ponieważ w przeciwnym razie możesz usunąć ważne dane. Z drugiej strony, możesz usunąć zewnętrzne pliki binarne bez znajomości nazwy pliku / katalogu używanego do ich przechowywania.

IOS9+, Swift 2

Usuń wszystkie obiekty we wszystkich obiektach

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

Jeśli chcesz usunąć wszystkie obiekty i nie chcesz usuwać plików kopii zapasowych, możesz użyć następujących metod:

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

Uważaj, że może być bardzo powolny (zależy od tego, ile obiektów znajduje się na wykresie obiektów).

Oto połączone rozwiązanie do czyszczenia podstawowych danych.

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

Jeśli chcesz przejść trasę delete all objects (która jest znacznie prostsza niż wybieranie podstawowego stosu danych, ale mniej wydajna), to jest to lepsza implementacja:

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

Ta implementacja wykorzystuje NSOperation do usunięcia głównego wątku i powiadomienia o zakończeniu. Możesz wysłać powiadomienie lub coś w bloku zakończenia, aby przywrócić status do głównego wątku.

IOS 10 + Swift 3 Rozwiązanie:

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

Iteracja przez wszystkie podstawowe jednostki danych i czyszczenie ich

Oto nieco uproszczona wersja z mniejszą liczbą wywołań do AppDelegate self i ostatnim bitem kodu, który został pominięty z najwyżej ocenionej odpowiedzi. Otrzymywałem również błąd "trwały sklep obiektu nie jest osiągalny z koordynatora tego nsmanagedobjectcontext", więc po prostu musiałem dodać to z powrotem.

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

Szybkie rozwiązanie:

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

Jako szybkie odniesienie do zapisywania wyszukiwania w innym miejscu-odtworzenie trwałego sklepu po usunięciu można zrobić za pomocą:

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

Dzięki za post. Podążałem za nim i zadziałało na mnie. Ale miałem inny problem, który nie został wymieniony w żadnej z odpowiedzi. Więc nie jestem pewien, czy to tylko ja.

W każdym razie, pomyślałem, że zamieszczę tutaj problem i mój sposób, który go rozwiązał.

Miałem kilka rekordów w bazie danych, chciałem wyczyścić wszystko przed zapisaniem nowych danych do db, więc zrobiłem wszystko, w tym

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

A następnie użyto managedObjectContext, Aby uzyskać dostęp do bazy danych (ma być już pusta), w jakiś sposób dane wciąż tam były. Po chwili rozwiązywania problemów stwierdziłem, że muszę zresetować managedObjectContext, managedObject, managedObjectModel oraz persistentStoreCoordinator, zanim użyję managedObjectContext, Aby uzyskać dostęp do dabazy. Teraz mam czystą bazę danych do pisania.

Kilka dobrych odpowiedzi na to pytanie. Tu jest ładny zwięzły. Pierwsze dwie linie usuwają bazę danych sqlite. Następnie pętla for: usuwa wszystkie obiekty w pamięci 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];
}

Możesz również znaleźć wszystkie nazwy encji i usunąć je po nazwie. Jego dłuższa wersja, ale działa dobrze, w ten sposób nie musisz pracować z persistence store

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

Dla "Any_Entity_Name" wystarczy podać dowolną nazwę encji, musimy tylko ustalić opis encji, w której znajdują się Twoje encje. ValueForKey@"name" zwróci wszystkie nazwy encji. Wreszcie, nie zapomnij zapisać.

Zaakceptowana odpowiedź jest poprawna z usunięciem adresu URL przez NSFileManager jest poprawna, ale jak stwierdzono w iOS 5 + edit, trwały sklep nie jest reprezentowany tylko przez jeden plik. Dla sklepu SQLite to *.sqlite,*.sqlite-shm i *.sqlite-wal ... na szczęście od iOS 7+ możemy użyć metody

[NSPersistentStoreCoordinator + removeUbiquitousContentAndPersistentstoreaturl: options: error:]

Aby zadbać o usunięcie, więc kod powinien być mniej więcej taki:

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

Usunąć plik persistent store i skonfigurować nowy koordynator persistent store?

Usuń sqlite ze ścieżki pliku, a następnie zbuduj.

Zakładając, że używasz MagicalRecord i masz domyślny magazyn trwałości:

Nie lubię wszystkich rozwiązań, które zakładają istnienie pewnych plików i / lub wymagają wprowadzania nazw encji lub klas. Jest to szybki (2), bezpieczny sposób na usunięcie wszystkich danych ze wszystkich podmiotów. Po usunięciu odtworzy też świeży stos (nie jestem pewien, jak potrzebna jest ta część).

To godo dla sytuacji w stylu "Wyloguj", gdy chcesz usunąć wszystko, ale masz działający store i moc, aby uzyskać nowe dane (po zalogowaniu się użytkownika...)

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

    }
}

Użyj tego

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

Wziąłem Kod Grouchala i aby go przyspieszyć użyłem wyliczenia w trybie współbieżnym (NSEnumerationConcurrent), zrobiło się nieco szybciej w porównaniu do pętli for (w mojej aplikacji dodałem tę funkcję dla testerów, aby mogli wyczyścić dane i zrobić testcases zamiast usuwać i instalować aplikację)

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

Tutaj moja wersja swift3 do usunięcia wszystkich rekordów. "Użytkownicy" to nazwa podmiotu

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

Działa ze wszystkimi wersjami. Podaj nazwę encji i powtórz, aby usunąć wszystkie wpisy i zapisać kontekst.

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

IOS 10 i Swift 3

Zakładając, że Twoja nazwa encji to "zdjęcie" i że tworzysz klasę 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)")
            }
        }
    }

Oto dobry samouczek, Jak korzystać z CoreData i jak korzystać z tej metody. https://medium.com/compileswift/parsing-json-response-and-save-it-in-coredata-step-by-step-fb58fc6ce16f#.1tu6kt8qb

Oto wersja, która usuwa każdy rekord w każdej tabeli, którą masz.

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

Sprawiacie, że to wydaje się skomplikowane. Możesz po prostu wysłać nsmanagedobjectcontext metodę reset