Supprimer / Réinitialiser toutes les entrées de base de données?

Question

Connaissez-vous un moyen de supprimer toutes les entrées stockées dans base de données? Mon schéma doit rester le même; Je veux juste remettre à vide.

---

Modifier

Je cherche à faire de sorte qu'un programme utilisateur peut essentiellement appuyer sur un bouton reset.

Answer 1

Vous pouvez toujours supprimer le fichier programme, en utilisant le NSFileManager:. :: removeItemAtPath méthode

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

Ensuite, ajoutez juste le magasin persistant de retour pour assurer sa recréation correctement.

Le moyen de programmation pour itérer à travers chaque entité est à la fois plus lente et sujette à des erreurs. L'utilisation de ce faire de cette façon est si vous voulez supprimer certaines entités et pas d'autres. Cependant, vous devez toujours vous assurer que vous conservez l'intégrité référentielle ou vous ne serez pas en mesure de persister vos modifications.

Il suffit de retirer le magasin et le recréer est à la fois rapide et sûr, et peut certainement être fait par programmation à l'exécution.

Mise à jour pour iOS5 +

Avec l'introduction du stockage binaire externe (allowsExternalBinaryDataStorage ou externe Stocker dans enregistrement du fichier) dans iOS 5 et Mac OS X 10.7, il suffit de supprimer les fichiers pointés par storeURLs ne suffit pas. Vous quitterez les fichiers d'enregistrement externes derrière. Étant donné que le schéma de nommage de ces fichiers d'enregistrement externes ne sont pas publiques, je n'ai pas encore de solution universelle. - an0 8 mai '12 à 23h00

Answer 2

Vous pouvez supprimer le fichier SQLite - mais je choisir de le faire en purgeant les tables individuellement avec les fonctions:

- (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 en table est que cela me fait confirme que je fais de la programmation que la suppression du contenu de la table est sensible et il n'y a pas de données que je préférais garder.

Faire de cette volonté est beaucoup plus lent que simplement supprimer le fichier et je vais changer un fichier supprimer si je cette méthode est trop longue.

Answer 3

Mise à jour Solution pour iOS 10 +

Utilisez pour supprimer tous les NSBatchDeleteRequest objets dans l'entité sans avoir à les charger dans la mémoire ou itérer à travers eux.

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

Ce code a été mis à jour pour iOS et 10 Swift 3. Si vous avez besoin pour soutenir iOS 9, voir cette question.

Sources:

• Core Data: meilleur moyen de supprimer toutes les instances d'une entité (inclut le code Objective-C)
• Quoi de neuf dans (WWDC 2015 vidéo) de base de données
• Quoi de neuf dans (WWDC 2016 vidéo) de base de données
• Comment utiliser Core Les données dans iOS 10
• Quoi de neuf dans base données Swift 3.0

Answer 4

J'ai écrit une méthode qui passe par clearStores chaque magasin et le supprimer à la fois du coordinateur et le système de fichiers (gestion 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 est dans une classe qui prend soin coreDataHelper de (entre autres) la création du PersistentStore quand il est nul.

Answer 5

supprimer toutes les données à partir des données de base sur un bouton de l'événement dans une classe HomeViewController: Cet article m'a tellement aidé que je pensais que je cotise.

-(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 appeler self.persistentStoreCoordinator je déclarais une propriété dans la maison View Controller. (Ne vous inquiétez pas du managedObjectContext que j'utiliser pour la sauvegarde et le chargement.)

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

Ensuite, dans le droit AppDelegate applicationDidFinishLaunching ci-dessous la création d'un HomeViewController je:

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

Answer 6

MagicalRecord fait cela très facile.

[MyCoreDataObject MR_truncateAll];

Answer 7

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

Answer 8

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

Recherche sur les réponses antérieures,

• Beau et supprimer tous les éléments, comme l'a suggéré @Grouchal et d'autres, est encore une solution efficace et utile. Si vous avez de très grands magasins de données alors il pourrait être lent, mais il fonctionne encore très bien.
• Il suffit de retirer le magasin de données est, comme vous et note @groundhog, ne sont plus efficaces. Il est obsolète même si vous n'utilisez le stockage binaire externe parce que iOS 7 utilise le mode WAL pour SQLite journalisé. Avec le mode WAL il peut y avoir des fichiers journaux (potentiellement importants) assis autour d'un magasin de données de base persistante.

Mais il y a une autre approche, semblable à enlever le magasin persistant qui fonctionne. La clé est de mettre votre fichier de stockage permanent dans son propre sous-répertoire qui ne contient rien d'autre. Ne vous contentez pas coller dans le répertoire des documents (ou ailleurs), créez un nouveau sous-répertoire juste pour le magasin persistant. Le contenu de ce répertoire finiront par être le fichier de stockage permanent, les fichiers journaux et les fichiers binaires externes. Si vous voulez atomiser l'intégralité de la banque de données, supprimez ce répertoire et ils vont tous disparaître.

Tu ferais quelque chose comme ça lors de la création de 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...
}

Ensuite, lorsque vous vouliez enlever le magasin,

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

Cela supprime récursive fois le sous-répertoire et tous les usages des fichiers de base de données en elle.

Cela ne fonctionne que si vous ne possédez pas déjà votre magasin persistant dans le même dossier que d'autres données importantes . Comme le répertoire des documents, ce qui a sans doute d'autres choses utiles en elle. Si tel est votre situation, vous pouvez obtenir le même effet en recherchant les fichiers que vous faire veulent garder et enlever tout le 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 aux erreurs . Vous devez être absolument sûr que vous savez chaque fichier vous voulez garder, car sinon vous risquez de supprimer des données importantes. D'autre part, vous pouvez supprimer les fichiers binaires externes sans connaître le nom de fichier / répertoire utilisé pour les stocker.

Answer 9

Si vous voulez supprimer tous les objets et ne veulent pas supprimer les fichiers de support, 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 qu'il peut être très lent (dépend du nombre d'objets dans votre objet graphique).

Answer 10

solution est combiné ici pour purger de base de données.

- (void)deleteAllObjectsInCoreData
{
    NSArray *allEntities = self.managedObjectModel.entities;
    for (NSEntityDescription *entityDescription in allEntities)
    {
        NSFetchRequest *fetchRequest = [[NSFetchRequest alloc] init];
        [fetchRequest setEntity:entityDescription];

        fetchRequest.includesPropertyValues = NO;
        fetchRequest.includesSubentities = NO;

        NSError *error;
        NSArray *items = [self.managedObjectContext executeFetchRequest:fetchRequest error:&error];

        if (error) {
                NSLog(@"Error requesting items from Core Data: %@", [error localizedDescription]);
            }

        for (NSManagedObject *managedObject in items) {
            [self.managedObjectContext deleteObject:managedObject];
        }

        if (![self.managedObjectContext save:&error]) {
            NSLog(@"Error deleting %@ - error:%@", entityDescription, [error localizedDescription]);
        }
    }  
}

Answer 11

Si vous voulez aller de la supprimer tous les parcours des objets (ce qui est beaucoup plus simple que démolissant la pile de données de base, mais moins performant), que cela 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 met à profit pour effectuer NSOperation la suppression hors du fil principal et notify à la fin. Vous pouvez émettre une notification ou quelque chose dans le bloc d'achèvement à bouillonner l'état au thread principal.

Answer 12

iOS 10 + 3 Swift solution:

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 toutes les entités de données de base et les efface

Answer 13

Voici une version quelque peu simplifiée avec moins d'appels à AppDelegate auto et le dernier morceau de code qui a été laissé sur la réponse les mieux notés. Je recevais aussi une erreur « magasin persistant de l'objet n'est pas accessible depuis le coordinateur de cette NSManagedObjectContext » donc juste besoin d'ajouter que le dos.

NSPersistentStoreCoordinator *storeCoordinator = [self persistentStoreCoordinator];
NSPersistentStore *store = [[storeCoordinator persistentStores] lastObject];
NSURL *storeURL = [[self applicationDocumentsDirectory] URLByAppendingPathComponent:@"dataModel"];
NSError *error;

[storeCoordinator removePersistentStore:store error:&error];
[[NSFileManager defaultManager] removeItemAtPath:storeURL.path error:&error];

[_persistentStoreCoordinator addPersistentStoreWithType:NSSQLiteStoreType configuration:nil URL:storeURL options:nil error:&error];

if (storeCoordinator != nil) {
    _managedObjectContext = [[NSManagedObjectContext alloc] init];
    [_managedObjectContext setPersistentStoreCoordinator:storeCoordinator];
}

Answer 14

solution rapide:

class func deleteAllManagedObjects() {

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

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

        Utility.managedObjectContext().save(nil)
    }

Answer 15

En tant que référence rapide pour sauvegarder la recherche ailleurs - recréer la boutique persistante après la suppression peut se faire avec:

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

Answer 16

Merci pour le poste. Je l'ai suivi et cela a fonctionné pour moi. Mais j'avais une autre question qui n'a pas été mentionné dans aucune des réponses. Donc, je ne sais pas si c'était juste moi.

Quoi qu'il en soit, je pensais poster ici le problème et mon chemin résolu.

J'ai eu quelques enregistrements dans la base de données, je voulais purger tout nettoyer avant d'écrire de nouvelles données à la DB, donc je l'ai fait tout, y compris

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

et ensuite utilisé pour accéder à la managedObjectContext base de données (supposée être vide maintenant), en quelque sorte les données était toujours là. Après un certain temps de dépannage, je trouve que je dois réinitialiser managedObject, managedObjectModel, et persistentStoreCoordinator <=>, avant de l'utiliser pour accéder au <=> dabase. Maintenant, j'ai une base de données propre à écrire.

Answer 17

Plusieurs bonnes réponses à cette question. Voici une belle un concise. Les deux premières lignes supprimer la base de données SQLite. Ensuite, le pour:. Boucle supprime tous les objets dans 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];
}

Answer 18

vous pouvez également trouver tous les noms d'entités et de les supprimer par son nom. Son une version plus longue, mais fonctionne bien, de cette façon vous ne devez pas travailler avec magasin de persistance

 - (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 » juste donner une de votre nom de l'entité, nous avons seulement besoin de comprendre la description de l'entité vos entités sont à l'intérieur. ValueForKey @ « nom » retournera tous les noms d'entités. Enfin, ne pas oublier d'enregistrer.

Answer 19

La réponse acceptée est correcte avec la suppression par URL NSFileManager est correcte, mais comme indiqué dans iOS 5+ modifier, le magasin persistant est pas représenté que par un seul fichier. Pour magasin SQLite il 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 code doit ê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];

Answer 20

Fonctionne avec toutes les versions. Passez le nom de l'entité et itérer 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)")
    }
}

Answer 21

Voici une version qui supprime tous les enregistrements de 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)")
    }
}

Answer 22

Supprimer le fichier de stockage permanent et installer un nouveau coordinateur de stockage permanent?

Answer 23

Supprimer sqlite de votre fileURLPath puis construire.

Answer 24

En supposant que vous utilisez et avez un MagicalRecord magasin de persistance par défaut:

Je n'aime pas toutes les solutions qui prennent en charge certains fichiers existent et / ou exigent la saisie des noms des entités ou des classes. Ceci est un Swift (2), sûr de supprimer toutes les données de toutes les entités. Après la suppression, il va recréer une nouvelle pile trop (je suis vraiment pas sûr de la façon dont neccessery cette partie est).

Il est Godo pour « déconnecter » situations de style quand vous voulez supprimer tout sauf un magasin de travail et moc pour obtenir de nouvelles données (une fois l'utilisateur ouvre une session dans ...)

extension NSManagedObject {

    class func dropAllData() {

        MagicalRecord.saveWithBlock({ context in

            for name in NSManagedObjectModel.MR_defaultManagedObjectModel().entitiesByName.keys {
                do { try self.deleteAll(name, context: context) }
                catch { print("⚠️ ✏️ Error when deleting \(name): \(error)") }
            }

            }) { done, err in
                MagicalRecord.cleanUp()
                MagicalRecord.setupCoreDataStackWithStoreNamed("myStoreName")
        }
    }

    private class func deleteAll(name: String, context ctx: NSManagedObjectContext) throws {
        let all = NSFetchRequest(entityName: name)
        all.includesPropertyValues = false

        let allObjs = try ctx.executeFetchRequest(all)
        for obj in allObjs {
            obj.MR_deleteEntityInContext(ctx)
        }

    }
}

Answer 25

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

Answer 26

Je pris le code de Grouchal et accélérer je énumération en mode simultané (NSEnumerationConcurrent), il a obtenu un peu plus rapide par rapport à boucle (dans mon application, j'ai ajouté cette fonctionnalité pour les testeurs afin qu'ils puissent effacer les données et faire testcases plutôt que supprimer et installer l'application)

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

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

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

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


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

Answer 27

ici ma version swift3 pour supprimer tous les enregistrements. est le nom de l'entité « utilisateur »

@IBAction func btnDelAll_touchupinside(_ sender: Any) {

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

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

    do {
        try managedObjectContext.execute(req)

    } catch {
        // Error Handling
    }   
}

Answer 28

iOS 10 et Swift 3

Si l'on suppose 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{$0.map{context.delete($0)}}
                CoreDataStack.sharedInstance.saveContext()
            } catch let error {
                print("ERROR DELETING : \(error)")
            }
        }
    }

Voici un bon tutoriel 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

Answer 29

Une autre méthode (à l'exception d'une demande de suppression par lots) J'utilise souvent (en fonction de besoins d'application) est de réinitialiser la mémoire persistante. La mise en œuvre ressemble à ceci pour iOS 10+ et Swift (en supposant que vous avez une 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)
        }
    }

}

L'un des avantages de cette méthode est qu'il est plus simple surtout quand vous avez des charges d'enregistrement de données pour de nombreuses entités dans vos données de base. Dans ce cas, une demande de suppression lot serait de mémoire.

Answer 30

vous êtes tous fait cela semble compliqué. Vous pouvez envoyer votre NSManagedObjectContext la méthode de réinitialisation