Core Data のすべてのエントリを削除/リセットしますか?

https://stackoverflow.com/questions/1077810

21-08-2019
|

質問

Core Data に保存されているすべてのエントリを削除する方法をご存知ですか?私のスキーマは変わらないはずです。空白にリセットしたいだけです。

編集

ユーザーが本質的に reset ボタン。

解決

あなたはまだNSFileManager使用して、プログラムでファイルを削除することができます。removeItemAtPath ::メソッドを

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

すると、ちょうどそれが適切に再作成されていることを確認するために戻って永続ストアを追加します。

各エンティティを反復処理するためのプログラム方法は、遅く、誤差を生じやすいの両方です。あなたには、いくつかのエンティティではなく他人を削除したい場合はそのように行うための使用です。しかし、あなたはまだあなたが参照整合性を維持するか、あなたの変更を保持することができませんことを確認する必要があります。

ただ、ストアを削除し、それを再作成すると、高速かつ安全であり、そして確かに、実行時にプログラム的に行うことができます。

iOS5を+のための更新の

（外部録音ファイルのallowsExternalBinaryDataStorageまたはストア）外部バイナリストレージの導入によりiOSの5とOS X 10.7で、単にstoreURLsが指すファイルを削除するだけでは十分ではありません。あなたは、外部の記録ファイルを背後に残しておきます。これらの外部記録ファイルの命名方式が公開されていないので、私はまだ普遍的解決策を持っていません。 - AN0 23:00 5月8日'12

他のヒント

あなたはSQLiteのファイルを削除することができます - しかし、私は、機能を個別にテーブルをパージすることによってそれを行うことを選択します：

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

}

私はテーブルでそれをテーブルを行うことを選んだ理由は、私はテーブルの内容を削除することは賢明であると私はむしろ続けるだろうデータが存在しないことを、プログラミングをやっているよう確認なることです。

この意志は単にファイルを削除するよりもはるかに遅く、私はこの方法では時間がかかりすぎる。

私は削除したファイルに変更されますそれをやって

iOS 10以降向けの更新されたソリューション

使用 NSBatchDeleteRequest エンティティ内のすべてのオブジェクトを、メモリにロードしたり繰り返し処理したりすることなく削除できます。

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

このコードは iOS 10 および Swift 3 用に更新されました。iOS 9 をサポートする必要がある場合は、次を参照してください。この質問.

出典:

コアデータ:エンティティのすべてのインスタンスを削除する最も簡単な方法 (Objective-C コードを含む)
コアデータの新機能 (WWDC 2015 ビデオ)
コアデータの新機能 (WWDC 2016 ビデオ)
iOS 10でコアデータを使用する方法
Core Data Swift 3.0 の新機能

私は（エラー処理はさておき左）すべてのストアを経由clearStores方法を書かれており、両方のコーディネーターとファイルシステムから削除しました：

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;

この方法では、それがnilだときpersistentStoreを作成する（とりわけ）の世話をするcoreDataHelperクラスの内部にあります。

私はHomeViewControllerクラスのボタンイベントのコアデータからすべてのデータを削除します。この記事では、そんなに私が貢献するはずと考えた私を助けてくれます。

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

}

self.persistentStoreCoordinatorを呼び出すために、私はホームビューコントローラにプロパティを宣言したことに注意してください。（私は保存と読み込みに使用managedObjectContext心配しないでください。）

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

次にAppDelegate ApplicationDidFinishLaunchingの右私が持っているHomeViewControllerを作成する以下ます：

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

MagicalRecord に、これは非常に簡単になります。

[MyCoreDataObject MR_truncateAll];

iOS9 +、スイフト2

すべてのエンティティ内のすべてのオブジェクトを削除します。

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

[新たな回答を求める報奨金に応じて回答が遅れました]

以前の回答を見てみると、

@Grouchal などが提案しているように、すべての項目を取得して削除することは、依然として効果的で有用な解決策です。非常に大規模なデータストアがある場合は速度が遅くなる可能性がありますが、それでも非常にうまく機能します。
あなたと @groundhog が指摘しているように、単にデータストアを削除するだけでは効果がなくなりました。時代遅れです 外部バイナリストレージを使用しない場合でも iOS 7 では SQLite ジャーナリングに WAL モードが使用されるためです。WAL モードでは、Core Data 永続ストアに (潜在的に大きな) ジャーナルファイルが存在する可能性があります。

ただし、機能する永続ストアを削除するには、別の同様のアプローチがあります。重要なのは、永続ストアファイルを、他には何も含まない独自のサブディレクトリに置くことです。これを単にドキュメントディレクトリ (または任意の場所) に貼り付けるのではなく、永続ストア専用の新しいサブディレクトリを作成します。そのディレクトリの内容は、最終的に永続ストアファイル、ジャーナルファイル、および外部バイナリファイルになります。データストア全体を無効にしたい場合は、そのディレクトリを削除すると、すべて消えます。

永続ストアを設定するときは、次のようなことを行います。

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

次に、ストアを削除したいときは、

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

これにより、カスタムサブディレクトリとその中のすべてのコアデータファイルの両方が再帰的に削除されます。

これは、他の重要なデータと同じフォルダーに永続ストアが存在していない場合にのみ機能します。. 。ドキュメントディレクトリと同様に、おそらく他にも便利なものが含まれています。そのような状況であれば、必要なファイルを探すことで同じ効果が得られる可能性があります。する他のものはすべて削除して保持したいと考えています。何かのようなもの：

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

このアプローチではエラーが発生しやすい可能性があります. 。自分が知っていると絶対に確信しなければならない毎そうしないと重要なデータが削除される可能性があるため、保存しておきたいファイルを選択してください。一方、外部バイナリファイルを保存するために使用されたファイル/ディレクトリ名を実際に知らなくても、外部バイナリファイルを削除できます。

あなたはすべてのオブジェクトを削除すると、バッキングファイルを削除したくない場合は、次の方法を使用することができます：

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

（あなたのオブジェクトグラフ内のオブジェクトの数によって異なり）、それは非常に遅くなることがありますので注意してください。

ここでコアデータをパージするためのソリューションが組み合わされます。

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

あなたは、これはより高度な実装であるよりも、削除するすべてのオブジェクトの（コアデータ・スタックを解体よりもはるかに簡単ですが、あまりパフォーマンスの）ルートを移動したい場合：

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

この実装は、メインスレッドのオフ削除を実行し、完了時に通知するNSOperationを活用します。あなたは戻ってメインスレッドにバブルに完了ブロック内の状態を通知か何かを放出する場合があります。

iOSの10 +スウィフト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()
        }
    }
}

コアデータエンティティのすべてを反復処理をし、それらをクリアします。

ここでAppDelegateの自己とトップクラスの答えのうち、残っていたコードの最後のビットに少ない呼び出しでやや単純化したバージョンです。また、私はちょうどその背中を追加するために必要な「オブジェクトの永続ストアがこのNSManagedObjectContextのコーディネーターから到達可能ではありません」エラーを取得しました。

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

迅速な解決策ます：

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

他の場所で検索保存するクイックリファレンスとして - それはで行うことができます削除した後永続ストアを再現ます：

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

投稿ありがとうございます。私はそれに従いました、そしてそれは私にとってはうまくいきました。しかし、どの返信にも記載されていない別の問題がありました。だから、それが私だけなのかどうかはわかりません。

とにかく、問題とそれを解決した私の方法をここに投稿したいと思いました。

データベースにいくつかのレコードがあったので、新しいデータをデータベースに書き込む前にすべてをきれいにパージしたかったので、以下をすべて実行しました

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

そして使用しました managedObjectContext データベース (すでに空になっているはずです) にアクセスしようとしましたが、どういうわけかデータがまだそこにありました。しばらくトラブルシューティングを行った後、リセットする必要があることがわかりました managedObjectContext, managedObject, managedObjectModel そしてpersistentStoreCoordinator, 、使用する前に managedObjectContext データベースにアクセスします。これで、書き込むためのクリーンなデータベースができました。

この質問に対するいくつかの良い答えを。ここでは素敵な簡潔な一つです。最初の2行はSQLiteデータベースを削除します。その後のために：ループ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];
}

あなたはまた、すべてのエンティティ名を見つけ、名前でそれらを削除することができます。その長いバージョンが、あなたはいけないその方法は、永続ストア

と仕事をしなければならない、うまく動作

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

「Any_Entity_Name」については自分のエンティティの名前のいずれかを与え、私たちはあなたのエンティティが内にあるエンティティの説明を把握する必要があります。 ValueForKey @「名前」すべてのエンティティ名を返します。最後に、保存することを忘れていけない。

受け入れられた答えは正しいです。NSFileManager による URL の削除は正しいですが、iOS 5 以降の編集で述べたように、永続ストアは 1 つのファイルだけで表されません。SQLite ストアの場合は、*.sqlite、*.sqlite-shm、および *.sqlite-wal です。幸いなことに、iOS 7以降ではメソッドを使用できます

nspersistentStoreCoordinator +removeUbiquitousContentandPersistStoreaturl：オプション：エラー：

削除を処理するため、コードは次のようになります。

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

すべてのバージョンで動作します。エンティティ名を渡すと、すべてのエントリを削除するには、反復処理とコンテキストを保存します。

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

ここであなたが持っているすべてのテーブル内のすべてのレコードを削除したバージョンです。

のスイフト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)")
    }
}

新しい永続ストアコーディネータの永続的ストアファイルと設定を削除しますか？

あなたのfileURLPathからのsqliteを削除してビルドします。

あなたはMagicalRecordを使用して、デフォルトの永続ストアを持っていると仮定します：

私は、特定のファイルが存在し、および/またはエンティティの名前やクラスに入る要求すると仮定し、すべてのソリューションを好きではありません。これは、すべてのエンティティからのすべてのデータを削除するにはスウィフト（2）、安全な方法です。削除した後、それはあまりにも（私は実際にこの部分がどのようにneccesseryのように確認していない）新鮮なスタックを再作成します。

あなたは（ユーザーがログイン一度...）

で新しいデータを取得するために、すべてを削除しても、作業ストアとMOCを持っているしたい場合、

これは、「ログアウト」スタイルの状況に合同です

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

    }
}

この

を使用します

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

彼らはデータを消去し、テストケースを実行できるように、私のアプリでは、私はテスターのためにこの機能を追加した（私はGrouchalのコードを取り、それをスピードアップするために、私は並行モード（NSEnumerationConcurrent）と列挙を使用し、それが少し速く比較するforループですではなく、削除してアプリをインストール）

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

すべてのレコードを削除するための

ここに私のswift3バージョン。「ユーザー」は、エンティティ名です。

@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とスウィフト3

あなたのエンティティ名が「写真」であると仮定すると、あなたは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)")
            }
        }
    }

ここでは良いCoreDataを使用する方法のチュートリアルとどのようにこのメソッドを使用することがあります。 HTTPS ：//medium.com/compileswift/parsing-json-response-and-save-it-in-coredata-step-by-step-fb58fc6ce16f#.1tu6kt8qbする

（離れ削除バッチリクエストから）Iは、頻繁に使用するもう一つの方法は、（アプリケーションの要件に基づいて）永続ストアをリセットすることです。実装は、（あなたがCoreDataManagerクラスを持っていると仮定した場合）のiOS 10+とスウィフトのためにこのようになります：

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

}

この方法の利点の一つは、それはあなたがあなたのコアデータで数多くのエンティティのデータレコードの負荷を持っている場合は特に、より直接的であるということです。その場合には、削除バッチ要求は、メモリを大量になります。

あなたはこのすべてが複雑に思える作っています。あなたは自分のNSManagedObjectContext resetメソッドを送信することができます。

ライセンス： CC-BY-SA と帰属

所属していません StackOverflow