Apagar / Repor todas as entradas no Core Data?

https://stackoverflow.com/questions/1077810

21-08-2019
|

Pergunta

Você sabe de alguma maneira de eliminar todas as entradas armazenadas no Core Data? Meu esquema deve permanecer o mesmo; Eu só quero redefini-la em branco.

Editar

Eu estou procurando fazer isso por meio de programação para que um usuário pode essencialmente apertar um botão reset.

Solução

Você ainda pode excluir o arquivo programaticamente, usando o NSFileManager:. RemoveItemAtPath :: método

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

Em seguida, basta adicionar o armazenamento de costas persistente para garantir que ele é recriado corretamente.

A forma programática para iterar cada entidade é tanto mais lento e propenso a erros. O uso para fazê-lo dessa maneira é se você deseja excluir algumas entidades e outros não. No entanto, você ainda precisa ter certeza de que você manter a integridade referencial ou você não será capaz de persistir as alterações.

Apenas removendo a loja e recriá-lo é rápido e seguro, e certamente pode ser feito através de programação em tempo de execução.

Atualização para o iOS5 +

Com a introdução do armazenamento binário externo (allowsExternalBinaryDataStorage ou loja no arquivo de gravação externa) no iOS 5 e Mac OS X 10.7, arquivos simplesmente apagar apontado por storeURLs não é suficiente. Você vai deixar os arquivos de registro externas para trás. Uma vez que o esquema de nomeação desses arquivos de registro externas não é público, eu não tenho uma solução universal ainda. - an0 8 '12 de maio às 23:00

Outras dicas

Você pode excluir o arquivo SQLite - mas eu optar por fazê-lo, purgando as tabelas individualmente com uma série de funções:

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

}

A razão que eu escolhi para fazê-lo mesa por mesa é que faz me confirmar como eu estou fazendo a programação que a exclusão do conteúdo da tabela é sensível e não há dados que eu preferiria manter.

Fazendo dessa vontade é muito mais lento do que apenas apagar o arquivo e eu vou mudar para um arquivo excluir se este método leva muito tempo.

Atualizado Solução para iOS 10 +

Use NSBatchDeleteRequest para excluir todos os objetos na entidade sem ter que carregá-los na memória ou do iterate através deles.

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

Este código foi atualizado para iOS 10 e Swift 3. Se você precisar para apoiar iOS 9, veja esta questão .

Fontes:

Core Data: mais rápida maneira de excluir todas as instâncias de um entidade (inclui código Objective-C)
O que há de novo no Core Data (WWDC 2015 vídeo)
O que há de novo no Core Data (WWDC 2016 vídeo)
como usar Núcleo dados no iOS 10
O que há de novo no Núcleo dados Swift 3.0

Eu escrevi um método clearStores que passa por todas as lojas e excluí-lo tanto do coordenador e do sistema de arquivos (manipulação de erro deixada de lado):

NSArray *stores = [persistentStoreCoordinator persistentStores];

for(NSPersistentStore *store in stores) {
    [persistentStoreCoordinator removePersistentStore:store error:nil];
    [[NSFileManager defaultManager] removeItemAtPath:store.URL.path error:nil];
}

[persistentStoreCoordinator release], persistentStoreCoordinator = nil;

Este método é dentro de uma classe coreDataHelper que cuida de (entre outras coisas) a criação do PersistentStore quando é nula.

Eu remover todos os dados a partir de dados do núcleo em um evento de botão em uma classe HomeViewController: Este artigo ajudou-me tanto que eu pensei que eu iria contribuir.

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

}

Note-se que, a fim de chamar self.persistentStoreCoordinator I declarou uma propriedade no Lar View Controller. (Não se preocupe com o managedObjectContext que eu uso para salvar e carregar).

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

Em seguida, no AppDelegate applicationDidFinishLaunching logo abaixo criando um HomeViewController eu tenho:

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

MagicalRecord faz isso muito fácil.

[MyCoreDataObject MR_truncateAll];

iOS9 +, Swift 2

Excluir todos os objetos em todas as entidades

func clearCoreDataStore() {
    let entities = managedObjectModel.entities
    for entity in entities {
        let fetchRequest = NSFetchRequest(entityName: entity.name!)
        let deleteReqest = NSBatchDeleteRequest(fetchRequest: fetchRequest)
        do {
            try context.executeRequest(deleteReqest)
        } catch {
            print(error)
        }
    }
}

[resposta tardia em resposta a uma recompensa pedindo respostas mais recentes]

Olhando sobre respostas anteriores,

Buscando e excluir todos os itens, como sugerido por @Grouchal e outros, ainda é uma solução eficaz e útil. Se você tiver muito grandes armazenamentos de dados, então pode ser lento, mas ainda funciona muito bem.
Simplesmente remover o armazenamento de dados é, como você e nota @groundhog, não mais eficaz. É obsoleto mesmo se você não usar o armazenamento binário externo porque iOS 7 usa o modo WAL para SQLite journalling. Com o modo de WAL podem ser arquivos (potencialmente grande) Jornal sentados ao redor para qualquer armazenamento persistente Core Data.

Mas há uma abordagem diferente, semelhante ao remover o armazenamento persistente que faz o trabalho. A chave é colocar o seu arquivo de armazenamento persistente em sua própria sub-diretório que não contém qualquer outra coisa. Não basta colocá-lo no diretório de documentos (ou onde), criar uma nova sub-diretório apenas para o armazenamento persistente. O conteúdo desse diretório vai acabar sendo o arquivo persistente loja, os arquivos de diário, e os arquivos binários externos. Se você quiser detonar todo o armazenamento de dados, excluir o diretório e todos eles vão desaparecer.

Você faria algo como isso ao configurar seu armazenamento persistente:

NSURL *storeDirectoryURL = [[self applicationDocumentsDirectory] URLByAppendingPathComponent:@"persistent-store"];
if ([[NSFileManager defaultManager] createDirectoryAtURL:storeDirectoryURL
        withIntermediateDirectories:NO
        attributes:nil
        error:nil]) {
    NSURL *storeURL = [storeDirectoryURL URLByAppendingPathComponent:@"MyApp.sqlite"];
    // continue with storeURL as usual...
}

Então, quando você queria remover a loja,

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

que remove recursivamente ambos o costume sub-diretório e todos os arquivos de dados principais na mesma.

Isso só funciona se você não tiver o seu armazenamento persistente na mesma pasta como outros, dados importantes . Como o diretório de documentos, o que provavelmente tem outras coisas úteis nele. Se essa é a sua situação, você pode obter o mesmo efeito, procurando por arquivos que você não deseja manter e remover tudo o resto. Algo como:

NSString *docsDirectoryPath = [[self applicationDocumentsDirectory] path];
NSArray *docsDirectoryContents = [[NSFileManager defaultManager] contentsOfDirectoryAtPath:docsDirectoryPath error:nil];
for (NSString *docsDirectoryItem in docsDirectoryContents) {
    // Look at docsDirectoryItem. If it's something you want to keep, do nothing.
    // If it's something you don't recognize, remove it.
}

Esta abordagem pode ser propenso a erros . Você tem que estar absolutamente certo de que você sabe todas arquivo que você deseja manter, porque senão você pode remover dados importantes. Por outro lado, você pode remover os arquivos binários externos sem realmente saber o nome do arquivo / diretório usado para armazená-los.

Se você quiser excluir todos os objetos e não quer excluir os arquivos de apoio, você pode utilizar os seguintes métodos:

- (void)deleteAllObjectsInContext:(NSManagedObjectContext *)context
                       usingModel:(NSManagedObjectModel *)model
{
    NSArray *entities = model.entities;
    for (NSEntityDescription *entityDescription in entities) {
        [self deleteAllObjectsWithEntityName:entityDescription.name
                                   inContext:context];
    }
}

- (void)deleteAllObjectsWithEntityName:(NSString *)entityName
                             inContext:(NSManagedObjectContext *)context
{
    NSFetchRequest *fetchRequest =
        [NSFetchRequest fetchRequestWithEntityName:entityName];
    fetchRequest.includesPropertyValues = NO;
    fetchRequest.includesSubentities = NO;

    NSError *error;
    NSArray *items = [context executeFetchRequest:fetchRequest error:&error];

    for (NSManagedObject *managedObject in items) {
        [context deleteObject:managedObject];
        NSLog(@"Deleted %@", entityName);
    }
}

Tenha em atenção que pode ser muito lento (depende de quantos objetos estão em seu gráfico de objeto).

solução aqui é combinado para purgar 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 você quiser ir a excluir todos os objetos de rota (que é muito mais simples do que derrubar a pilha Core Data, mas menos eficaz), que esta é uma melhor implementação:

- (void)deleteAllManagedObjectsInModel:(NSManagedObjectModel *)managedObjectModel context:(NSManagedObjectContext *)managedObjectContext
{
    NSBlockOperation *operation = [NSBlockOperation blockOperationWithBlock:^{
        [managedObjectContext performBlockAndWait:^{
            for (NSEntityDescription *entity in managedObjectModel) {
                NSFetchRequest *fetchRequest = [NSFetchRequest new];
                [fetchRequest setEntity:entity];
                [fetchRequest setIncludesSubentities:NO];
                NSArray *objects = [managedObjectContext executeFetchRequest:fetchRequest error:nil];
                for (NSManagedObject *managedObject in objects) {
                    [managedObjectContext deleteObject:managedObject];
                }            
            }

            [managedObjectContext save:nil];
        }];
    }];
    [operation setCompletionBlock:^{
        // Do stuff once the truncation is complete
    }];
    [operation start];
}

Esta implementação aproveita NSOperation para realizar a eliminação fora da linha principal e notificar a conclusão. Você pode querer emitir uma notificação ou algo dentro do bloco conclusão a borbulhar o status de volta para o segmento principal.

iOS 10 + 3 Swift solução:

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

Itera através de todas as entidades de dados centrais e as limpa

Aqui está uma versão um pouco simplificada com menos chamadas para AppDelegate eu e o último pedaço de código que foi deixado de fora da resposta mais votados. Também eu estava recebendo um erro "armazenamento persistente do objeto não é acessível a partir de coordenador deste NSManagedObjectContext" tão só precisava acrescentar que volta.

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

solução rápida:

class func deleteAllManagedObjects() {

        let modelURL = NSBundle.mainBundle().URLForResource("some string", withExtension: "mom")
        let mom = NSManagedObjectModel(contentsOfURL: modelURL)

        for entityName in mom.entitiesByName.keys {
            let fr = NSFetchRequest(entityName: entityName as String)
            let a = Utility.managedObjectContext().executeFetchRequest(fr, error: nil) as [NSManagedObject]
            for mo in a {
                Utility.managedObjectContext().deleteObject(mo)
            }
        }

        Utility.managedObjectContext().save(nil)
    }

Como uma referência rápida para salvar procurando outro lugar - recriando o armazenamento persistente após a exclusão pode ser feito com:

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

Graças ao cargo. Segui-lo e ele trabalhou para mim. Mas eu tinha um outro problema que não foi mencionado em nenhuma das respostas. Então, eu não tenho certeza se era só eu.

De qualquer forma, pensei que eu ia postar aqui o problema e minha maneira que resolveu.

Eu tive alguns registros no banco de dados, eu queria purga tudo limpo antes de gravar novos dados para o db, então eu fiz tudo, incluindo

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

e managedObjectContext então usado para acessar o banco de dados (suposto ser vazia por agora), de alguma forma, os dados ainda estava lá. Depois de um tempo de resolução de problemas, eu descobri que eu preciso redefinir managedObjectContext, managedObject, managedObjectModel e persistentStoreCoordinator, antes de eu usar managedObjectContext para acessar o dabase. Agora eu tenho um banco de dados limpo para gravar.

Várias boas respostas para essa pergunta. Aqui está um bom concisa. As duas primeiras linhas excluir o banco de dados SQLite. Então o para:. Laço exclui quaisquer objetos na memória 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];
}

Você também pode encontrar todos os nomes de entidades, e excluí-los pelo nome. É uma versão mais longa, mas funciona bem, de que maneira você não tem que trabalhar com armazenamento de persistência

 - (void)clearCoreData
{
NSError *error;
NSEntityDescription *des = [NSEntityDescription entityForName:@"Any_Entity_Name" inManagedObjectContext:_managedObjectContext];
NSManagedObjectModel *model = [des managedObjectModel];
NSArray *entityNames = [[model entities] valueForKey:@"name"];

for (NSString *entityName in entityNames){

    NSFetchRequest *deleteAll = [NSFetchRequest fetchRequestWithEntityName:entityName];
    NSArray *matches = [self.database.managedObjectContext executeFetchRequest:deleteAll error:&error];

}
    if (matches.count > 0){
        for (id obj in matches){

            [_managedObjectContext deleteObject:obj];
        }
       [self.database.managedObjectContext save:&error];
    }
}

para "Any_Entity_Name" apenas dar qualquer um dos nome de sua entidade, só precisa descobrir a descrição entidade suas entidades estão dentro. ValueForKey @ "nome" irá retornar todos os nomes de entidades. Finalmente, não se esqueça de salvar.

A resposta aceita é correta com a remoção de URL por NSFileManager é correto, mas como indicado no iOS 5+ edição, o armazenamento persistente não é representado apenas por um arquivo. Para loja SQLite é * .sqlite, * .sqlite-shm e * .sqlite-wal ... felizmente desde iOS 7+ podemos usar o método

[NSPersistentStoreCoordinator + RemoveUbiquitousContentAndPersistentStoreAtURL: opções: error:]

cuidar de remoção, de modo que o código deve ser algo como isto:

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

Funciona com todas as versões. Passe nome da entidade e iterate através de apagar todas as entradas e salvar o contexto.

func deleteData(entityToFetch: String, completion: @escaping(_ returned: Bool) ->()) {
    var context = NSManagedObjectContext()
    if #available(iOS 10.0, *) {
        context = self.persistentContainer.viewContext
    } else {
        context = self.managedObjectContext
    }

    let fetchRequest = NSFetchRequest<NSFetchRequestResult>()
    fetchRequest.entity = NSEntityDescription.entity(forEntityName: entityToFetch, in: context)
    fetchRequest.includesPropertyValues = false
    do {
        let results = try context.fetch(fetchRequest) as! [NSManagedObject]
        for result in results {
            context.delete(result)
        }
        try context.save()
        completion(true)
    } catch {
        completion(false)
        print("fetch error -\(error.localizedDescription)")
    }
}

Aqui está uma versão que exclui todos os registros em cada mesa que você tem.

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

Excluir o arquivo de armazenamento persistente e configurar um novo coordenador armazenamento persistente?

sqlite Excluir do seu fileURLPath e então construir.

Assumindo que você está usando MagicalRecord e tem uma loja de persistência padrão:

Eu não gosto de todas as soluções que assumem determinados arquivos de existir e / ou demanda inserindo os nomes de entidades ou classes. Esta é uma Swift (2), forma segura de apagar todos os dados de todas as entidades. Depois de excluir que vai recriar uma nova pilha também (eu não sou realmente certo de como neccessery esta parte é).

É do godo de "logout" situações de estilo quando você quer tudo de exclusão, mas tem uma loja de trabalho e moc para obter novos dados (uma vez o usuário faz login ...)

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

    }
}

Use esta

+(NSArray *)fetchDataFromEntity:(NSString *)entityName context:(NSManagedObjectContext *)context
{
    NSFetchRequest * fetchRequest =[[NSFetchRequest alloc] init];
    NSEntityDescription * CategoriesEntity = [NSEntityDescription entityForName:entityName inManagedObjectContext:context];
    [fetchRequest setEntity:CategoriesEntity];

    NSError * error;
    NSInteger count = [context countForFetchRequest:fetchRequest error:&error];

    if (count && count>0) {

        NSArray * fetchedObjects = [context executeFetchRequest:fetchRequest error:&error];
        if (fetchedObjects && fetchedObjects.count>0) {

            return fetchedObjects;
        }else
            return nil;

    }
    else
        return nil;
}
+ (void)deleteObjectsOfArray:(NSMutableArray*)ary context:(NSManagedObjectContext *)context {
    for (NSManagedObject * obj in ary) {
        [context deleteObject:obj];
    }
    NSError *saveError = nil;
    [context save:&saveError];
}
+ (void)deleteEntity:(NSString *)entityName context:(NSManagedObjectContext *)context {
    NSArray *listArray = [self fetchDataFromEntity:entityName context:context];
    [self deleteObjectsOfArray:[NSMutableArray arrayWithArray:listArray] context:context];
}

Eu levei o código do Grouchal e acelerá-lo I enumeração usado com modo simultâneo (NSEnumerationConcurrent), ficou um pouco mais rápido em comparação com loop for (em meu aplicativo eu adicionei este recurso for Testers para que possam limpar os dados e fazer testcases em vez de aplicativo de exclusão e instalar)

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

aqui minha versão swift3 para excluir todos os registros. 'Usuários' é nome da entidade

@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

Assumindo que o seu nome da entidade é "Photo", e que você criar uma 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)")
            }
        }
    }

Aqui está um bom tutorial de como usar CoreData e como usar este método. https : //medium.com/compileswift/parsing-json-response-and-save-it-in-coredata-step-by-step-fb58fc6ce16f#.1tu6kt8qb

Um outro método (para além de uma solicitação de lote de exclusão) Costumo usar (com base na necessidade app) é redefinir o armazenamento persistente. Os olhares de implementação como este para iOS 10+ e Swift (supondo que você tenha uma 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)
        }
    }

}

Uma das vantagens deste método é que ele é mais simples, especialmente quando você tem um monte de registro de dados para várias entidades em seus dados essenciais. No caso em que uma solicitação de lote de exclusão seria muita memória.

você está todos fazendo isso parecer complicado. Você pode apenas enviar o seu NSManagedObjectContext o método de reposição

Licenciado em: CC-BY-SA com atribuição

Não afiliado a StackOverflow