핵심 데이터:엔티티의 모든 인스턴스를 삭제하는 가장 빠른 방법

핵심 데이터:엔티티의 모든 인스턴스를 삭제하는 가장 빠른 방법

핵심 데이터를 사용하여 웹 서비스 호출 결과를 로컬로 보존하고 있습니다.웹 서비스는 예를 들어 "Cars"와 같은 전체 개체 모델을 반환합니다(Web Service가 1대 또는 모든 차량을 반환하도록 할 수 없습니다).

다음 번에 응용 프로그램을 열 때 모든 자동차의 웹 서비스에 다시 호출하여 핵심 데이터 영구 복사본을 새로 고치고 싶지만, 중복을 방지하려면 먼저 로컬 캐시의 모든 데이터를 삭제해야 합니다.

관리 대상 오브젝트 컨텍스트에서 특정 엔티티의 모든 인스턴스(예를 들어 "CAR" 유형의 모든 엔티티)를 삭제하거나 콜을 쿼리하고 결과를 반복하여 삭제한 후 저장할 수 있는 더 빠른 방법이 있습니까?

이상적으로는 엔티티가 있는 곳을 모두 삭제하라고 말할 수 있습니다.

iOS 9 이후:

는 iOS 9라는 새로운 했습니다.NSBatchDeleteRequest이를 통해 술어와 일치하는 개체를 메모리에 로드하지 않고도 쉽게 삭제할 수 있습니다.사용 방법은 다음과 같습니다.

스위프트 5

let fetchRequest: NSFetchRequest<NSFetchRequestResult> = NSFetchRequest(entityName: "Car")
let deleteRequest = NSBatchDeleteRequest(fetchRequest: fetchRequest)

do {
    try myPersistentStoreCoordinator.execute(deleteRequest, with: myContext)
} catch let error as NSError {
    // TODO: handle the error
}

목표-C

NSFetchRequest *request = [[NSFetchRequest alloc] initWithEntityName:@"Car"];
NSBatchDeleteRequest *delete = [[NSBatchDeleteRequest alloc] initWithFetchRequest:request];

NSError *deleteError = nil;
[myPersistentStoreCoordinator executeRequest:delete withContext:myContext error:&deleteError];

배치 삭제에 대한 자세한 내용은 WWDC 2015의 "핵심 데이터의 새로운 기능" 세션(약 14:10부터)을 참조하십시오.

iOS 8 이전 버전:

모두 가져와 모두 삭제:

NSFetchRequest *allCars = [[NSFetchRequest alloc] init];
[allCars setEntity:[NSEntityDescription entityForName:@"Car" inManagedObjectContext:myContext]];
[allCars setIncludesPropertyValues:NO]; //only fetch the managedObjectID

NSError *error = nil;
NSArray *cars = [myContext executeFetchRequest:allCars error:&error];
[allCars release];
//error handling goes here
for (NSManagedObject *car in cars) {
  [myContext deleteObject:car];
}
NSError *saveError = nil;
[myContext save:&saveError];
//more error handling here

Swift 3에서 엔티티 리셋:

func resetAllRecords(in entity : String) // entity = Your_Entity_Name
    {

        let context = ( UIApplication.shared.delegate as! AppDelegate ).persistentContainer.viewContext
        let deleteFetch = NSFetchRequest<NSFetchRequestResult>(entityName: entity)
        let deleteRequest = NSBatchDeleteRequest(fetchRequest: deleteFetch)
        do
        {
            try context.execute(deleteRequest)
            try context.save()
        }
        catch
        {
            print ("There was an error")
        }
    }

조금 더 깔끔하고 범용 :다음 방법을 추가합니다.

- (void)deleteAllEntities:(NSString *)nameEntity
{
    NSFetchRequest *fetchRequest = [[NSFetchRequest alloc] initWithEntityName:nameEntity];
    [fetchRequest setIncludesPropertyValues:NO]; //only fetch the managedObjectID

    NSError *error;
    NSArray *fetchedObjects = [theContext executeFetchRequest:fetchRequest error:&error];
    for (NSManagedObject *object in fetchedObjects)
    {
        [theContext deleteObject:object];
    }

    error = nil;
    [theContext save:&error];
}

Swift 2.0의 경우:

class func clearCoreData(entity:String) {
  let fetchRequest = NSFetchRequest()
  fetchRequest.entity = NSEntityDescription.entityForName(entity, inManagedObjectContext: moc!)
  fetchRequest.includesPropertyValues = false
  do {
    if let results = try moc!.executeFetchRequest(fetchRequest) as? [NSManagedObject] {
      for result in results {
        moc!.deleteObject(result)
      }

      try moc!.save()
    }
  } catch {
    LOG.debug("failed to clear core data")
  }
}

Swift 4, iOS 12 및 Xcode 10 업데이트

100% 기능하는 컷 앤 페이스트

이 함수를 이 를 이 함수로 .self.deleteData()viewDidLoad()하고 핵심 할 수 기능 합니다.

func deleteData() {
    let appDel:AppDelegate = (UIApplication.shared.delegate as! AppDelegate)
    let context:NSManagedObjectContext = appDel.persistentContainer.viewContext
    let fetchRequest = NSFetchRequest<NSFetchRequestResult>(entityName: "myEntity")
    fetchRequest.returnsObjectsAsFaults = false         
    do {
        let results = try context.fetch(fetchRequest)
        for managedObject in results {
            if let managedObjectData: NSManagedObject = managedObject as? NSManagedObject {
                context.delete(managedObjectData)
            }
        }
    } catch let error as NSError {
        print("Deleted all my data in myEntity error : \(error) \(error.userInfo)")
    }
}

이 질문은 여기서와 유사한 질문으로, 다른 사용자가 하나의 개체만 삭제하도록 관계 삭제 규칙을 설정할 것을 제안했습니다.따라서 차와 대 다의 관계를 가진 엔티티를 가지고 있거나 만들 수 있으며 상위 엔티티를 삭제할 때 삭제 규칙을 계단식으로 설정하면 모든 차도 삭제됩니다.이렇게 하면 모든 차량 적재와 관련된 단계를 수행할 필요가 없으므로 처리 시간이 다소 절약될 수 있습니다.더 큰 데이터 집합에서는 이것이 절대적으로 필요할 수 있습니다.

신속:

let fetchRequest = NSFetchRequest()
fetchRequest.entity = NSEntityDescription.entityForName(entityName, inManagedObjectContext: context)
fetchRequest.includesPropertyValues = false

var error:NSError?
if let results = context.executeFetchRequest(fetchRequest, error: &error) as? [NSManagedObject] {
    for result in results {
        context.deleteObject(result)
    }

    var error:NSError?
    if context.save(&error) {
        // do something after save

    } else if let error = error {
        println(error.userInfo)
    }

} else if let error = error {
    println("error: \(error)")
}

좋은 답변이 이미 게시되어 있습니다. 이는 권장 사항일 뿐입니다.

것 요.NSManagedObject하다

파일 헤헤예예 （ ） :NSManagedObject+Ext.h)

@interface NSManagedObject (Logic)

+ (void) deleteAllFromEntity:(NSString*) entityName;

@end

---

코드 파일: (NSManaged Object+Ext 등).m)

@implementation NSManagedObject (Logic)

+ (void) deleteAllFromEntity:(NSString *)entityName {
    NSManagedObjectContext *managedObjectContext = [AppDelegate managedObjectContext];
    NSFetchRequest * allRecords = [[NSFetchRequest alloc] init];
    [allRecords setEntity:[NSEntityDescription entityForName:entityName inManagedObjectContext:managedObjectContext]];
    [allRecords setIncludesPropertyValues:NO];
    NSError * error = nil;
    NSArray * result = [managedObjectContext executeFetchRequest:allRecords error:&error];
    for (NSManagedObject * profile in result) {
        [managedObjectContext deleteObject:profile];
    }
    NSError *saveError = nil;
    [managedObjectContext save:&saveError];
}

@end

managedObjectContext를 앱 위임자로부터 가져오거나 모든 앱 위임장소에서 가져오기만 하면 됩니다.

나중에 다음과 같이 사용할 수 있습니다.

[NSManagedObject deleteAllFromEntity:@"EntityName"];

또한 entityname 파라미터를 삭제하고 clazzname에서 이름을 얻는 것도 최적화할 수 있습니다.사용으로 이어집니다.

[ClazzName deleteAllFromEntity];

---

보다 깨끗한 의미(NSManagedObjectContext 카테고리):

@implementation NSManagedObjectContext (Logic)

- (void) deleteAllFromEntity:(NSString *)entityName {
    NSFetchRequest * allRecords = [[NSFetchRequest alloc] init];
    [allRecords setEntity:[NSEntityDescription entityForName:entityName inManagedObjectContext:self]];
    [allRecords setIncludesPropertyValues:NO];
    NSError * error = nil;
    NSArray * result = [self executeFetchRequest:allRecords error:&error];
    for (NSManagedObject * profile in result) {
        [self deleteObject:profile];
    }
    NSError *saveError = nil;
    [self save:&saveError];
}

@end

사용방법:

[managedObjectContext deleteAllFromEntity:@"EntityName"];

iOS 10 이후

모든 버전에서 작동합니다.엔티티 이름을 전달하고 ~를 반복하여 모든 엔트리를 삭제하고 컨텍스트를 저장합니다.

func deleteData(entityToFetch: String, completion: @escaping(_ returned: Bool) ->()) {
        let context = NSManagedObjectContext()
        context = your 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)")
        }
    }

Swift 3.X 및 Swift 4.X, Easy way.테이블만 변경

    let fetchRequest = NSFetchRequest<NSFetchRequestResult>(entityName: "YourTable")
    fetchRequest.returnsObjectsAsFaults = false

    do
    {
        let results = try context.fetch(fetchRequest)
        for managedObject in results
        {
            let managedObjectData:NSManagedObject = managedObject as! NSManagedObject
            context.delete(managedObjectData)
        }
    } catch let error as NSError {
        print("Detele all my data in \(entity) error : \(error) \(error.userInfo)")
    }

4, Swift 4, iOS 10
할 수 있도록 할 수 있는 함수

protocol NSManagedObjectHelper {
}
extension NSManagedObject: NSManagedObjectHelper {
}
extension NSManagedObjectHelper where Self: NSManagedObject {
    static func removeAllObjectsInContext(_ managedContext: NSManagedObjectContext) {
        let request: NSFetchRequest = NSFetchRequest(entityName: String(describing: self))
        let deleteRequest = NSBatchDeleteRequest(fetchRequest: request)
        do {
            deleteRequest.resultType = .resultTypeObjectIDs//to clear objects from memory
            let result = try managedContext.execute(deleteRequest) as? NSBatchDeleteResult
            if let objectIDArray = result?.result as? [NSManagedObjectID] {
                let changes = [NSDeletedObjectsKey : objectIDArray]
                /*By calling mergeChangesFromRemoteContextSave, all of the NSManagedObjectContext instances that are referenced will be notified that the list of entities referenced with the NSManagedObjectID array have been deleted and that the objects in memory are stale. This causes the referenced NSManagedObjectContext instances to remove any objects in memory that are loaded which match the NSManagedObjectID instances in the array.*/
                NSManagedObjectContext.mergeChanges(fromRemoteContextSave: changes, into: [managedContext])
            }
            try managedContext.save()
        } catch let error {
            print(error)
        }
    }
}

'룸'은 엔티티입니다.

Room.removeAllObjectsInContext(self.persistentContainer.viewContext)

20191025년 편집: '본인'fetchRequest() 명령은 동일한 프로젝트에서 여러 대상을 사용하는 경우 문제를 일으킬 수 있습니다.NSFetchRequest(entityName:문자열(설명: 자기)

Dave Delong의 답변을 연장합니다.

iOS9 및 이전 버전을 지원하는 스위프트 버전.또, 이 에러 처리에 대해서도 설명했습니다.

appDelegate 허용:AppDelegate = UIApplication.shared Application().delegate as!AppDelegate

    let fetchRequest = NSFetchRequest(entityName: "Car")
    if #available(iOS 9.0, *) {
        let delete = NSBatchDeleteRequest(fetchRequest: fetchRequest)
        do {
            try appDelegate.persistentStoreCoordinator.executeRequest(delete, withContext: appDelegate.managedObjectContext)
        } catch let error as NSError {
            print("Error occured while deleting: \(error)")
        }
    } else {
        // Fallback on earlier versions
        let carRequest = NSFetchRequest()
        carRequest.entity = NSEntityDescription.entityForName("Cars", inManagedObjectContext: appDelegate.managedObjectContext)
        carRequest.includesPropertyValues = false

        do {
            let cars: NSArray = try appDelegate.managedObjectContext.executeFetchRequest(carRequest)

            for car in cars {
                appDelegate.managedObjectContext.delete(car)
            }

            try appDelegate.managedObjectContext.save()

        } catch let error as NSError {
            print("Error occured while fetching or saving: \(error)")
        }
    }

DB의 모든 오브젝트 빠른 삭제:

func purgeAllData() {
    let uniqueNames = persistentContainer.managedObjectModel.entities.compactMap({ $0.name })

    uniqueNames.forEach { (name) in
      let fetchRequest = NSFetchRequest<NSFetchRequestResult>(entityName: name)
       let batchDeleteRequest = NSBatchDeleteRequest(fetchRequest: fetchRequest)
         do {
        try persistentContainer.viewContext.execute(batchDeleteRequest)
      } catch {
        let nserror = error as NSError
        fatalError("Unresolved error \(nserror), \(nserror.userInfo)")
      }
   }
 }

Swift4+ 및 Xcode 10+ 아래 코드를 사용하여 엔티티에서 모든 레코드를 삭제합니다.

func deleteAllRecords(entity : String) {

        let managedContext = CoreDataManager.sharedManager.persistentContainer.viewContext //your context
        let deleteFetch = NSFetchRequest<NSFetchRequestResult>(entityName: entity)
        let deleteRequest = NSBatchDeleteRequest(fetchRequest: deleteFetch)
        
        do {
            try managedContext.execute(deleteRequest)
            try managedContext.save()
        } catch {
            print ("There was an error")
        }
    }

사용방법

self.deleteEntityData(entity: "YOUR_ENTITY_NAME")

기존 캐시와 함께 수신한 데이터를 폴딩하면 어떨까요?그렇지 않으면 '새로 고침'이 아니라 '다시 시작'이므로 SQLLite 파일을 삭제/삭제하고 다시 시작하는 것이 좋습니다(다른 데이터도 유지하지 않는 것으로 가정).

엔티티가 Swift 3+, Xcode 10+로 명명되는 문자열이 없는 OOP 방식

func batchDelete<T>(in context: NSManagedObjectContext, fetchRequest: NSFetchRequest<T>) throws {
    guard let request = fetchRequest as? NSFetchRequest<NSFetchRequestResult> else {
        throw ErrorService.defaultError
    }
    let batchDeleteRequest = NSBatchDeleteRequest(fetchRequest: request)
    do {
        try context.execute(batchDeleteRequest)
    } catch {
        throw error
    }
}

그럼 do/disclock을 클릭합니다.

    let fetchRequest: NSFetchRequest<YourEntity> = YourEntity.fetchRequest()
    do {
        let data = try context.fetch(fetchRequest)
        if data.count > 0 {
            try self.batchDelete(in: context, fetchRequest: fetchRequest)
        }
    } catch {
        // throw error
    }

엔티티가 많은 엔트리를 포함하는 경우 메모리를 절약하기 때문에 가장 좋은 방법은 다음과 같습니다.

 - (void)deleteAll:(NSManagedObjectContext *)managedObjectContext entityName:(NSString *)entityName
{
    NSFetchRequest *fetchRequest = [[NSFetchRequest alloc] init];
    [managedObjectContext setUndoManager:nil];
    NSEntityDescription *entity = [NSEntityDescription entityForName:entityName inManagedObjectContext:managedObjectContext];
    [fetchRequest setEntity:entity];
    [fetchRequest setIncludesPropertyValues:NO];
    [fetchRequest setFetchLimit:100]; // you can change this number if you want
    NSError *error;
    NSArray *items = [managedObjectContext executeFetchRequest:fetchRequest error:&error];
    while ([items count] > 0) {
        @autoreleasepool {
            for (NSManagedObject *item in items) {
                [managedObjectContext deleteObject:item];
            }
            if (![managedObjectContext save:&error]) {
                NSLog(@"Error deleting %@ - error:%@",self.entityName, error);
            }
        }
        items = [managedObjectContext executeFetchRequest:fetchRequest error:&error];
    }
}

Swift 3.0의 경우

 func deleteAllRecords() {
        //delete all data
        let context = appDelegate.persistentContainer.viewContext

        let deleteFetch = NSFetchRequest<NSFetchRequestResult>(entityName: "YourClassName")
        let deleteRequest = NSBatchDeleteRequest(fetchRequest: deleteFetch)

        do {
            try context.execute(deleteRequest)
            try context.save()
        } catch {
            print ("There was an error")
        }
    }

이 코드는 iOS 9 이하에서 사용할 수 있습니다.

class func deleteAllRecords(in entity : String) // entity = Your_Entity_Name
    {

        let context = CoreDataStack.getContext() // Note:- Replace your context here with CoreDataStack.getContext()
        let deleteFetch = NSFetchRequest<NSFetchRequestResult>(entityName: entity)
        if #available(iOS 9, *)
        {
            let deleteRequest = NSBatchDeleteRequest(fetchRequest: deleteFetch)
            do
            {
                try context.execute(deleteRequest)
                try context.save()
            }
            catch
            {
                print("There was an error:\(error)")
            }
        }
        else
        {
            do{
                let deleteRequest = try context.fetch(deleteFetch)
                for anItem in deleteRequest {
                    context.delete(anItem as! NSManagedObject)
                }
            }
            catch
            {
                print("There was an error:\(error)")
            }
        }
        CoreDataStack.saveContext() // Note:- Replace your savecontext here with CoreDataStack.saveContext()
    }

iOS 9.0 이후:

NSBatchDeleteRequest코어 데이터 내의 레코드를 삭제하기 위해 사용합니다.엔티티에서 모든 레코드를 삭제하는 데 걸리는 시간이 단축되고 매우 빠르게 작동합니다.은 필요하다.NSFetchRequest논쟁 중에엔티티에서 모든 레코드를 삭제하려면 해당 엔티티를 사용할 수 있습니다.

let manageObject:NSManagedObjectContext = appDelegateObject.managedObjectContext

let fetchRequest = NSFetchRequest(entityName: “EnityName”)

let deleteRequest = NSBatchDeleteRequest(fetchRequest: fetchRequest)

let persistCor:NSPersistentStoreCoordinator = appDelegateObject.persistentObject
 do {
        try persistCor.executeRequest(deleteRequest, withContext: manageObject)
        try manageObject.save()
    } catch {
        print(error?.localizedDescription)
    }

SwiftUI

엔티티에서 인스턴스를 가져오고 루프하여 모든 인스턴스를 삭제합니다.

@Environment(\.managedObjectContext) var moc
    
@FetchRequest(sortDescriptors: []) var wizards: FetchedResults<Wizard>

var body: some View {
    VStack {
        List() { }

        Button("Delete all") {
            for wizard in wizards {
                moc.delete(wizard)
            }
            
            if moc.hasChanges {
                try? moc.save()
            }
        }
    }
}

Dave Delongs의 Swift 2.0의 답변이 마음에 들지 않았다(iOS 9).

하지만 이것은 효과가 있었다.

let fetchRequest = NSFetchRequest(entityName: "Car")
let deleteRequest = NSBatchDeleteRequest(fetchRequest: fetchRequest)

    do {
        try managedObjectContext.executeRequest(deleteRequest)
        try managedObjectContext.save()
    }
    catch let error as NSError {
       // Handle error
    }

iOS 9 'NSBatchDeleteRequest'를 탑재한 Swift 3 솔루션과 NSManagedObjectContext에서 확장으로 구현된 이전 iOS 버전으로 폴백합니다.Apple 레퍼런스 https://developer.apple.com/library/content/featuredarticles/CoreData_Batch_Guide/BatchDeletes/BatchDeletes.html

extension NSManagedObjectContext {
    func batchDeleteEntities<T: NSManagedObject>(ofType type: T.Type) throws {
        let fetchRequest = NSFetchRequest<NSFetchRequestResult>(entityName: String(describing: type.self))
        if #available(iOS 9.0, *) {
            let request = NSBatchDeleteRequest(fetchRequest: fetchRequest)
            let result = try execute(request) as? NSBatchDeleteResult
            if let objectIDArray = result?.result as? [NSManagedObjectID] {
                let changes = [NSDeletedObjectsKey: objectIDArray]
                NSManagedObjectContext.mergeChanges(fromRemoteContextSave: changes, into: [self])
            }
        } else {
            fetchRequest.includesPropertyValues = false
            let results = try fetch(fetchRequest)
            if let actualResults = results as? [NSManagedObject], !actualResults.isEmpty {
                actualResults.forEach { delete($0) }
            }
        }
    }
}

최소 iOS가 9.0인 경우 NSBatchDeleteRequest를 사용하여 여러 레코드를 삭제합니다.백그라운드 스레드의 경우 NSManagedObjectContext 저장을 실행합니다.그렇지 않으면 NSFetchRequest를 사용하여 레코드를 가져오고 모든 레코드를 삭제한 후 루프를 위해에 있는 모든 레코드를 삭제하고 삭제한 후 저장을 수행합니다.

(iOS 11.3 및 Swift 4.1의 경우)

let fetchRequest = NSFetchRequest<NSFetchRequestResult>(entityName: entityName)
        let batchDeleteRequest = NSBatchDeleteRequest(fetchRequest: fetchRequest )
        batchDeleteRequest.resultType = .resultTypeCount
        do {
            let batchDeleteResult = try dataController.viewContext.execute(batchDeleteRequest) as! NSBatchDeleteResult
            print("The batch delete request has deleted \(batchDeleteResult.result!) records.")
            dataController.viewContext.reset() // reset managed object context (need it for working)
        } catch {
            let updateError = error as NSError
            print("\(updateError), \(updateError.userInfo)")
        }

실행 후 리셋을 호출해야 합니다.그렇지 않으면 테이블 뷰에서 업데이트되지 않습니다.

    func deleteAll(entityName: String) {

    let fetchRequest = NSFetchRequest<NSFetchRequestResult>(entityName: entityName)
    let deleteRequest = NSBatchDeleteRequest(fetchRequest: fetchRequest)
    deleteRequest.resultType = .resultTypeObjectIDs
    guard let context = self.container?.viewContext
        else { print("error in deleteAll")
            return }

    do {
        let result = try context.execute(deleteRequest) as? NSBatchDeleteResult
        let objectIDArray = result?.result as? [NSManagedObjectID]
        let changes: [AnyHashable : Any] = [NSDeletedObjectsKey : objectIDArray as Any]
        NSManagedObjectContext.mergeChanges(fromRemoteContextSave: changes, into: [context])
    } catch {
        print(error.localizedDescription)
    }
}

위의 답변은 "자동차"를 삭제하는 방법에 대한 좋은 통찰력을 제공합니다.

그러나 접근 방식 자체에 이의를 제기하기 위해 다음과 같은 답변을 원합니다.

1- SQLite Core Data는 관계형 데이터베이스입니다.이 경우 관련성이 없는 경우에는 Core Data를 사용하지 말고 파일 시스템을 사용하거나 메모리에 저장해 두는 것이 좋습니다.

2- 다른 예에서는 "자동차" 엔티티가 다른 관계, 즉 코어데이터가 있는 경우 2000대의 자동차를 루트 엔티티로 하지 말 것을 조언합니다.대신 'Car Repository' 엔티티라고 합시다.그런 다음 "자동차" 엔티티에 일대다 관계를 부여하고, 다운로드 시 새 차를 가리키도록 관계를 대체할 수 있습니다.올바른 삭제 규칙을 관계에 추가하면 모델의 무결성이 보장됩니다.

NSBatch Delete Request(NSBatchDeleteRequest Swift 5.5 및 Xcode 13.2

는 메모리에 로드하지 않고 SQLite 영속 저장소의 개체를 삭제합니다.영구 저장소에서 적용된 변경 내용은 현재 메모리에 있는 개체에 반영되지 않습니다.

배치 삭제가 실행된 후 영구 저장소에서 삭제된 메모리 내의 개체를 모두 제거하십시오.

다음 중 몇 가지 편리한 확장 방법을 나타냅니다.batchDeleteRequest

extension NSManagedObject {
    
    private static var entityName: String {
        return String(describing: self)
    }
    
    static func fetchRequest<Self>(
        with predicate: NSPredicate? = nil,
        configureBlock: ((NSFetchRequest<Self>) -> Void)? = nil
    ) -> NSFetchRequest<Self> where Self: NSFetchRequestResult {
        let request = NSFetchRequest<Self>(entityName: entityName)
        request.predicate = predicate
        configureBlock?(request)
        return request
    }
    
    static func batchDelete(with fetchRequest: NSFetchRequest<NSFetchRequestResult>,
                            in context: NSManagedObjectContext) {
        let batchDeteleRequest = NSBatchDeleteRequest(fetchRequest: fetchRequest)
        batchDeteleRequest.resultType = .resultTypeObjectIDs
        do {
            if let fetchResult = try context.execute(batchDeteleRequest) as? NSBatchDeleteResult,
               let deletedManagedObjectIds = fetchResult.result as? [NSManagedObjectID], !deletedManagedObjectIds.isEmpty {
                let changes = [NSDeletedObjectsKey: deletedManagedObjectIds]
                NSManagedObjectContext.mergeChanges(fromRemoteContextSave: changes, into: [context])
            }
        } catch {
            print("Error while executing batchDeleteRequest: \(error.localizedDescription)")
        }
    }
}

예:fetchRequest를 전달하여 batchDelete static 메서드를 호출하여 엔티티를 일괄 삭제할 수 있습니다.

class Entity: NSManagedObject {
    @NSManaged var name: String?
    @NSManaged var value: String?
}

extension Entity {
    
    static func executeBatchDelete(in context: NSManagedObjectContext) {
        let predicate = NSPredicate(format: "\(#keyPath(Entity.value)) == %@)", "abc")
        let deleteRequest: NSFetchRequest<NSFetchRequestResult> = Entity.fetchRequest(with: predicate)
        Entity.batchDelete(with: deleteRequest, in: context)
    }
}

Swift 2.0의 경우:

func deleteAllData(entity: String)
{
    let appDelegate = UIApplication.sharedApplication().delegate as! AppDelegate
    let managedContext = appDelegate.managedObjectContext
    let fetchRequest = NSFetchRequest(entityName: entity)
    fetchRequest.returnsObjectsAsFaults = false

    do 
    {
        let results = try managedContext.executeFetchRequest(fetchRequest)
        for managedObject in results
        {
            let managedObjectData:NSManagedObject = managedObject as! NSManagedObject
            managedContext.deleteObject(managedObjectData)
        }
    } catch let error as NSError {
        print("Detele all data in \(entity) error : \(error) \(error.userInfo)")
    }
}

언급URL : https://stackoverflow.com/questions/1383598/core-data-quickest-way-to-delete-all-instances-of-an-entity