vous pouvez supprimer le fichier sqllite - mais je choisis de le faire en purgeant les tables individuellement avec une fonction:

- (void) deleteAllObjects: (NSString *) entityDescription  {
    NSFetchRequest *fetchRequest = [[NSFetchRequest alloc] init];
    NSEntityDescription *entity = [NSEntityDescription entityForName:entityDescription inManagedObjectContext:_managedObjectContext];
    [fetchRequest setEntity:entity];

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


    for (NSManagedObject *managedObject in items) {
        [_managedObjectContext deleteObject:managedObject];
        DLog(@"%@ object deleted",entityDescription);
    }
    if (![_managedObjectContext save:&error]) {
        DLog(@"Error deleting %@ - error:%@",entityDescription,error);
    }

}

la raison pour laquelle j'ai choisi de le faire table par table est qu'il me fait confirmer comme je fais la programmation que la suppression du contenu de la table est raisonnable et il n'y a pas de données que je préférerais garder.

faire cela sera beaucoup plus lent que la suppression du fichier et je changerai à un fichier supprimer si je cette méthode prend trop de temps.

solution mise à jour pour iOS 9+

utiliser NSBatchDeleteRequest pour supprimer tous les objets de l'entité sans avoir à les charger en mémoire ou à les itérer.

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

ce code a été mis à jour pour iOS 10 et Swift 3. Si vous avez besoin de support iOS 9, Voir cette question .

Sources:

• de Base de Données: le moyen le plus Rapide pour supprimer toutes les instances d'une entité "151990920 (inclut le code Objective-C)
• Quoi de neuf dans la Base de Données (WWDC 2015 vidéo)
• Quoi de neuf dans la Base de Données (WWDC 2016 vidéo)
• comment utiliser les données de base dans iOS 10
• Quoi de neuf en données de base Swift 3.0

j'ai écrit une méthode clearStores qui passe par chaque magasin et la supprime à la fois du coordinateur et du système de fichiers (traitement des erreurs laissé de côté):

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;

cette méthode fait partie d'une classe coreDataHelper qui s'occupe (entre autres choses) de créer le persistentStore quand il est nul.

je supprime toutes les données des données de base sur un événement bouton dans une classe HomeViewController: Cet article m'a tellement aidé que j'ai pensé y contribuer.

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

}

notez que pour s'appeler soi-même.persistentStoreCoordinator i a déclaré une propriété dans le contrôleur Home View. (Ne vous inquiétez pas au sujet de la managedObjectContext que j'utilise pour la sauvegarde et le chargement.)

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

puis dans la demande D'autorisation a été Finishlaunching droit ci-dessous creating a home ViewController I have:

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

MagicalRecord rend cela très facile.

[MyCoreDataObject MR_truncateAll];

[réponse tardive en réponse à une prime demandant des réponses plus récentes]

la Recherche sur les réponses précédentes,

• récupérer et supprimer tous les articles, comme suggéré par @Grouchal et d'autres, est toujours une solution efficace et utile. Si vous avez de très grands magasins de données alors il pourrait être lent, mais il fonctionne toujours très bien.
• supprimer simplement la Data store est, comme vous et @groundhog notez, Non plus efficace. C'est obsolète même si vous n'utilisez pas de stockage binaire externe parce que iOS 7 utilise le mode WAL pour le journallage SQLite. Avec le mode WAL il peut y avoir des fichiers de journal (potentiellement grands) autour de n'importe quelle mémoire persistante de données de base.

mais il y a une approche différente et similaire pour enlever le magasin persistant qui fonctionne. La clé est de mettre votre fichier de stockage persistant dans son propre sous-répertoire qui ne contient pas quelque chose d'autre. Ne le mettez pas simplement dans le répertoire des documents (ou n'importe où), créez un nouveau sous-répertoire juste pour le magasin persistant. Le contenu de ce répertoire finira par être le fichier de stockage persistant, les fichiers de journal, et les fichiers binaires externes. Si vous voulez atomiser tout le magasin de données, supprimez ce répertoire et ils vont tous disparaître.

vous feriez quelque chose comme ça en mettant en place votre magasin persistant:

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

alors quand vous avez voulu enlever le magasin,

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

qui supprime récursivement à la fois le sous-répertoire personnalisé et tous les fichiers de données de base qu'il contient.

cela ne fonctionne que si vous n'avez pas déjà votre mémoire persistante dans le même dossier que d'autres données importantes . Comme le répertoire des documents, qui contient probablement d'autres documents utiles. Si c'est votre situation, vous pourriez obtenir le même effet en recherchant des fichiers que vous faire souhaitez conserver et supprimer tout ce qui reste. Quelque chose comme:

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

cette approche peut être sujette à erreur . Vous devez être absolument sûr que vous connaissez chaque fichier que vous voulez garder, parce que sinon vous pourriez supprimer des données importantes. D'un autre côté, vous pouvez supprimer les fichiers binaires externes sans réellement connaître le nom du fichier/répertoire utilisé pour les stocker.

iOS9+, Swift 2

supprimer tous les objets dans toutes les entités

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

si vous voulez supprimer tous les objets et ne voulez pas supprimer les fichiers de soutien, vous pouvez utiliser les méthodes suivantes:

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

attention, il peut être très lent (dépend de combien d'objets sont dans votre graphe d'objet).

Voici une solution combinée pour purger les données de base.

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

si vous voulez aller à la route supprimer tous les objets (ce qui est beaucoup plus simple que de détruire la pile de données de base, mais moins performant), que ce est une meilleure mise en œuvre:

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

cette implémentation utilise NSOperation pour effectuer la suppression hors du thread principal et notifier à l'achèvement. Vous pouvez vouloir émettre une notification ou quelque chose dans le bloc d'achèvement de bulle de l'état de retour au fil principal.

iOS 10 + Solution Swift 3:

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

itère à travers toutes les entités de données de base et les efface

Voici une version quelque peu simplifiée avec moins d'appels vers AppDelegate self et le dernier morceau de code qui a été omis de la réponse la mieux cotée. Aussi je recevais une erreur "le magasin persistant de L'objet n'est pas accessible à partir du coordinateur de NSManagedObjectContext" donc juste besoin d'ajouter que retour.

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

solution swift:

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

comme une référence rapide pour sauver la recherche ailleurs-recréer le magasin persistant après l'avoir supprimé peut être fait avec:

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

Merci pour le post. Je l'ai suivi et il a travaillé pour moi. Mais j'ai eu un autre problème qui n'a été mentionné dans aucune des réponses. Donc je ne suis pas sûr que ce soit juste moi.

de toute façon, je pensais poster ici le problème et ma façon de le résoudre.

j'avais quelques enregistrements dans la base de données, je voulais tout purger avant d'écrire de nouvelles données à la db, donc j'ai tout fait y compris

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

et ensuite utilisé managedObjectContext pour accéder à la base de données (censée être vide maintenant), les données étaient toujours là. Après un certain temps de dépannage, j'ai trouvé que je dois réinitialiser managedObjectContext , managedObject , managedObjectModel et persistentStoreCoordinator , avant d'utiliser managedObjectContext pour accéder à la base de données. Maintenant, j'ai une base de données à écrire.

Plusieurs bonnes réponses à cette question. Voici une belle concis. Les deux premières lignes suppriment la base de données sqlite. Ensuite, la boucle for: supprime tous les objets de la mémoire 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];
}

vous pouvez également trouver tous les noms d'entités, et les supprimer par leur nom. C'est une version plus longue mais fonctionne bien, de cette façon vous n'avez pas à travailler avec 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];
    }
}

pour "Any_Entity_Name", il suffit de donner le nom de votre entité, il suffit de comprendre la description de l'entité dans laquelle se trouvent vos entités. ValueForKey@ "name" renverra tous les noms d'entités. Enfin, n'oubliez pas d'enregistrer.

la réponse acceptée est correcte avec suppression de L'URL par NSFileManager est correcte, mais comme indiqué dans iOS 5+ edit, le magasin persistant n'est pas représenté par un seul fichier. Pour le magasin SQLite c'est *.sqlite,*.sqlite-shm et *.sqlite-wal ... heureusement depuis iOS 7+ Nous pouvons utiliser la méthode

[NSPersistentStoreCoordinator +removeUbiquitousContentAndPersistentstoreaturl:options:erreur:]

pour prendre soin de l'enlèvement, de sorte que le le code devrait être quelque chose comme ceci:

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

supprimer le fichier de stockage persistant et configurer un nouveau coordinateur de stockage persistant?

Supprimer sqlite à partir de votre fileURLPath et puis de construire.

en supposant que vous utilisez MagicalRecord et que vous avez un stock de persistance par défaut:

Je n'aime pas toutes les solutions qui supposent que certains fichiers existent et/ou demandent l'entrée des noms d'entités ou des classes. Il s'agit d'un moyen sûr Swift(2) pour supprimer toutes les données de toutes les entités. Après la suppression, il va recréer une nouvelle pile aussi (je ne suis pas vraiment sûr de la nécessité de cette partie).

c'est godo pour les situations de style "logout" quand vous vous voulez tout supprimer, mais avoir un magasin de travail et moc pour obtenir de nouvelles données dans (une fois que l'utilisateur se connecte...)

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

    }
}

utiliser cette

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

j'ai pris le code de Grouchal et pour l'accélérer j'ai utilisé l'énumération en mode concurrent ( NSEnumerationConcurrent ), il est devenu un peu plus rapide par rapport à la boucle (dans mon application j'ai ajouté cette fonctionnalité pour les testeurs afin qu'ils puissent Effacer les données et faire des testcases plutôt que supprimer et installer app)

- (void)resetObjects
{
    [self deleteAllObjectsInEntity:@"Entity1"];
    [self deleteAllObjectsInEntity:@"Entity2"];
    [self deleteAllObjectsInEntity:@"Entity3"];
    [self deleteAllObjectsInEntity:@"Entity4"];
}

-(void) deleteAllObjectsInEntity:(NSString*) entityName
{
    MainDataContext *coreDataContext = [MainDataContext sharedInstance];
    NSManagedObjectContext *currentContext = coreDataContext.managedObjectContext;
    NSFetchRequest *fetchRequest = [[NSFetchRequest alloc] init];
    NSEntityDescription *entity = [NSEntityDescription entityForName:entityName inManagedObjectContext:currentContext];
    [fetchRequest setEntity:entity];

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

    [items enumerateObjectsWithOptions:NSEnumerationConcurrent usingBlock:^(NSManagedObject * obj, NSUInteger idx, BOOL *stop) {
        [currentContext deleteObject:obj];
    }];


    if (![currentContext save:&error]) {
        NSLog(@"Error deleting %@ - error:%@",entityName,error);
    }
}

voici ma version swift3 pour supprimer tous les enregistrements. Les "utilisateurs" est le nom de l'entité

@IBAction func btnDelAll_touchupinside(_ sender: Any) {

    let appDelegate = UIApplication.shared.delegate as! AppDelegate
    let managedObjectContext = appDelegate.persistentContainer.viewContext

    let fetchReq = NSFetchRequest<NSFetchRequestResult>(entityName: "Users")
    let req = NSBatchDeleteRequest(fetchRequest: fetchReq)

    do {
        try managedObjectContext.execute(req)

    } catch {
        // Error Handling
    }   
}

fonctionne avec toutes les versions. Passer le nom de l'entité et parcourir pour supprimer toutes les entrées et enregistrez le contexte.

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 et Swift 3

en supposant que votre nom d'entité est "Photo", et que vous créez une 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{"151900920".map{context.delete("151900920")}}
                CoreDataStack.sharedInstance.saveContext()
            } catch let error {
                print("ERROR DELETING : \(error)")
            }
        }
    }

voici un bon tutoriel sur comment utiliser CoreData et comment utiliser cette méthode. https://medium.com/compileswift/parsing-json-response-and-save-it-in-coredata-step-by-step-fb58fc6ce16f#.1tu6kt8qb

Voici une version qui efface chaque enregistrement dans chaque table que vous avez.

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

vous faites tous paraître ça compliqué. Vous pouvez simplement envoyer votre NSManagedObjectContext la méthode de réinitialisation