Supprimer/réinitialiser toutes les entrées dans Core Data?
Connaissez-vous un moyen de supprimer toutes les entrées stockées dans Core Data? Mon schéma devrait rester le même; Je veux juste le réinitialiser à blanc.
Modifier
Je cherche à le faire par programme afin qu'un utilisateur puisse appuyer sur un bouton reset.
Vous pouvez toujours supprimer le fichier par programme, à l'aide de la méthode NSFileManager: removeItemAtPath ::.
NSPersistentStore *store = ...;
NSError *error;
NSURL *storeURL = store.URL;
NSPersistentStoreCoordinator *storeCoordinator = ...;
[storeCoordinator removePersistentStore:store error:&error];
[[NSFileManager defaultManager] removeItemAtPath:storeURL.path error:&error];
Ensuite, ajoutez simplement le magasin persistant pour vous assurer qu'il est recréé correctement.
La méthode de programmation pour itérer à travers chaque entité est à la fois plus lente et sujette aux erreurs. Pour ce faire, vous pouvez supprimer certaines entités et pas d’autres. Cependant, vous devez toujours vous assurer de conserver l'intégrité référentielle, sinon vous ne pourrez pas conserver vos modifications.
Le simple fait de supprimer le magasin et de le recréer est à la fois rapide et sûr, et peut certainement être effectué par programmation au moment de l'exécution.
Mise à jour pour iOS5 +
Avec l'introduction du stockage binaire externe (allowExternalBinaryDataStorage ou Stocker dans un fichier d'enregistrement externe) sous iOS 5 et OS X 10.7, la suppression des fichiers pointés par storeURL ne suffit plus. Vous laisserez les fichiers d'enregistrement externes derrière. Étant donné que le schéma de nommage de ces fichiers d'enregistrement externes n'est pas public, je n'ai pas encore de solution universelle. - an0 le 8 mai 12 à 23:00
Vous pouvez supprimer le fichier SQLite - 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 que cela me permet de confirmer, lors de ma programmation, que la suppression du contenu de la table est judicieuse et qu'il n'y a pas de données que je préférerais conserver.
Faire cela va beaucoup plus lentement que simplement supprimer le fichier et je changerai pour un fichier supprimer si cette méthode prend trop de temps.
Solution mise à jour pour iOS 9+
Utilisez NSBatchDeleteRequest pour supprimer tous les objets de l'entité sans avoir à les charger en mémoire ou à les parcourir.
// 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 devez prendre en charge iOS 9, consultez cette question .
Sources:
- Données de base: moyen le plus rapide de supprimer toutes les instances d'une entité (inclut du code Objective-C)
- Nouveautés des données de base (vidéo WWDC 2015)
- Nouveautés de base de données (Vidéo WWDC 2016)
- Comment utiliser les données de base dans iOS 10
- Nouveautés de Core Data Swift 3.0
J'ai écrit une méthode clearStores qui parcourt chaque magasin et le supprime du coordinateur et du système de fichiers (gestion des erreurs laissée 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 se trouve dans une classe coreDataHelper qui prend en charge, entre autres choses, la création du persistentStore quand il est nul.
Je supprime toutes les données des données de base sur un bouton Event dans une classe HomeViewController: Cet article m'a tant aidé que j'ai pensé que je contribuerais.
-(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, j’ai déclaré une propriété dans le contrôleur Home View. (Ne vous inquiétez pas du managedObjectContext que j'utilise pour enregistrer et charger.)
@property (nonatomic, retain) NSManagedObjectContext * managedObjectContext;
@property (nonatomic, retain) NSPersistentStoreCoordinator * persistentStoreCoordinator;
Ensuite, dans AppDelegate ApplicationDidFinishLaunching juste en dessous de la création d'un HomeViewController, j'ai:
homeViewController = [[HomeViewController alloc] initWithNibName:@"HomeViewController" bundle:nil];
homeViewController.managedObjectContext = self.managedObjectContext;
homeViewController.persistentStoreCoordinator = self.persistentStoreCoordinator;
MagicalRecord rend cela très facile.
[MyCoreDataObject MR_truncateAll];
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)
}
}
}
[Réponse tardive en réponse à une prime demandant de nouvelles réponses]
En regardant les réponses précédentes,
- Récupérer et supprimer tous les éléments, comme suggéré par @Grouchal et d'autres, reste une solution efficace et utile. Si vous avez de très grands magasins de données, cela peut être lent, mais cela fonctionne toujours très bien.
- Le simple fait de supprimer le magasin de données n’est plus efficace, comme le notent @groundhog. Il est obsolète même si vous n'utilisez pas de stockage binaire externe car iOS 7 utilise le mode WAL pour la journalisation SQLite. En mode WAL, il peut y avoir des fichiers de journal (potentiellement volumineux) pour tout magasin persistant Core Data.
Mais il existe une approche différente et similaire pour supprimer le magasin persistant qui fonctionne. La clé est de placer votre fichier de stockage persistant dans son propre sous-répertoire qui ne contient rien d'autre. Ne collez pas simplement dans le répertoire de documents (ou ailleurs), 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 journaux et les fichiers binaires externes. Si vous souhaitez supprimer l'intégralité du magasin de données, supprimez ce répertoire et ils disparaîtront tous.
Vous feriez quelque chose comme ceci lors de la configuration 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, quand vous vouliez supprimer le magasin,
[[NSFileManager defaultManager] removeItemAtURL:storeDirectoryURL error:nil];
Cela supprime de manière récursive le sous-répertoire personnalisé et tous les fichiers Core Data qu’il contient.
Cela ne fonctionne que si votre magasin persistant n'est pas déjà dans le même dossier que d'autres données importantes. Comme le répertoire de documents, qui contient probablement d'autres éléments utiles. Si tel est votre cas, vous pouvez obtenir le même effet en recherchant les fichiers que vous voulez conserver et en supprimant 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 de connaître tous les fichiers que vous souhaitez conserver, sinon vous risquez de supprimer des données importantes. D'autre part, vous pouvez supprimer les fichiers binaires externes sans connaître le nom du fichier/répertoire utilisé pour les stocker.
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 souhaitez supprimer tous les objets et ne souhaitez pas supprimer les fichiers de sauvegarde, 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, cela peut être très lent (cela dépend du nombre d'objets dans votre graphe d'objets).
Si vous voulez aller sur 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), il s'agit d'une meilleure implémentation:
- (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 tire parti de NSOperation pour supprimer le thread principal et notifier la fin du processus. Vous souhaiterez peut-être émettre une notification ou quelque chose dans le bloc d'achèvement afin d'afficher l'état dans le thread principal.
solution iOS 10 + 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()
}
}
}
Parcourt toutes les entités de données de base et les efface
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)
}
Voici une version quelque peu simplifiée avec moins d'appels à AppDelegate self et le dernier bit de code laissé en dehors de la réponse la mieux notée. De plus, le message d'erreur suivant: "Le magasin persistant de l'objet n'est pas accessible à partir du coordinateur de ce NSManagedObjectContext" a simplement dû être rajouté.
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];
}
Merci pour le post. Je l'ai suivi et cela a fonctionné pour moi. Mais j’ai eu un autre problème qui n’a été mentionné dans aucune des réponses. Je ne suis donc pas sûr que ce soit juste moi.
Quoi qu'il en soit, je pensais poster ici le problème et ma solution qui le résolvait.
J'avais quelques enregistrements dans la base de données, je voulais tout nettoyer avant d'écrire de nouvelles données dans la base de données, alors j'ai tout fait, y compris
[[NSFileManager defaultManager] removeItemAtURL:storeURL error:&error];
et ensuite utilisé managedObjectContext pour accéder à la base de données (supposé être vide maintenant), les données étaient toujours là. Après un certain temps de dépannage, j'ai constaté que je devais 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 vierge pour écrire.
Plusieurs bonnes réponses à cette question. Voici un joli concis. Les deux premières lignes suppriment la base de données sqlite. Ensuite, la boucle for: supprime tout objet 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];
}
Comme référence rapide pour sauvegarder la recherche ailleurs - recréer le magasin persistant après sa suppression peut être fait avec:
if (![persistentStoreCoordinator addPersistentStoreWithType:NSSQLiteStoreType configuration:nil URL:storeURL options:nil error:&error]) {
// do something with the error
}
La réponse acceptée est correcte avec la suppression de l'URL par NSFileManager, mais comme indiqué dans iOS 5+, 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: error:]
prendre en charge la suppression, le code doit donc ressembler à 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];
vous pouvez également trouver tous les noms d'entité et les supprimer par nom. C'est une version plus longue mais fonctionne bien, de cette façon vous n'avez pas à travailler avec le 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", indiquez simplement le nom de votre entité, il suffit de connaître 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 de sauvegarder.
Une autre méthode (en dehors d'une demande de suppression de lot) que j'utilise souvent (en fonction des exigences de l'application) consiste à réinitialiser le magasin persistant. L'implémentation ressemble à ceci pour iOS 10+ et Swift (en supposant que vous ayez 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’elle est plus simple, surtout lorsque 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 de lot demanderait beaucoup de mémoire.
Utilisez ceci
+(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];
}
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)")
}
}
Supprimer le fichier de stockage persistant et configurer un nouveau coordinateur de magasin persistant?
J'ai pris le code de Grouchal et pour l'accélérer, j'ai utilisé l'énumération avec le mode concurrent (NSEnumerationConcurrent), il est devenu un peu plus rapide que la boucle for (dans mon application, j'ai ajouté cette fonctionnalité pour que les testeurs puissent effacer les données et faire des tests plutôt que de les 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);
}
}
En supposant que vous utilisez MagicalRecord et que vous disposiez d'un magasin de persistance par défaut:
Je n'aime pas toutes les solutions qui supposent que certains fichiers existent et/ou exigent la saisie des noms d'entités ou des classes. Ceci est un moyen sûr, Swift (2), de supprimer toutes les données de toutes les entités. Après la suppression, une nouvelle pile sera également recréée (je ne suis pas sûr de la nécessité de cette partie).
C'est le bon sens pour les situations de style "déconnexion" lorsque vous voulez tout supprimer mais qu'un magasin et un moc fonctionnent pour obtenir de nouvelles données (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)
}
}
}
iOS 10 et Swift 3
En supposant que le nom de votre 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 sur l’utilisation de CoreData et de cette méthode . https://medium.com/compileswift/parsing-json-response-and-save-it-in-coredata-step- étape par étape-fb58fc6ce16f # .1tu6kt8qb
Fonctionne avec toutes les versions. Transmettez le nom de l’entité et parcourez-le pour supprimer toutes les entrées et enregistrer 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)")
}
}
voici ma version de Swift3 pour supprimer tous les enregistrements. "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
}
}
Supprimez sqlite de votre fileURLPath, puis générez.