核心数据:删除实体的所有实例的最快方法

我使用Core Data在本地持久化Web服务调用的结果。web服务返回完整的对象模型，比如说，“Cars”——可能有2000辆车(我不能让web服务返回小于1辆或ALL辆的任何东西。

下次打开应用程序时，我希望通过再次调用所有汽车的Web服务来刷新Core Data持久化副本，但是为了防止重复，我需要首先清除本地缓存中的所有数据。

是否有一种更快的方法来清除管理对象上下文中特定实体的所有实例(例如，类型为“CAR”的所有实体)，或者我需要查询它们调用，然后遍历结果删除每个，然后保存?

理想情况下，我可以说删除实体所在的所有地方等等。

189259 次浏览
小开

为什么不将接收到的数据与现有缓存一起折叠呢?否则它就不是真正的“刷新”，而是“重新开始”，你也可以删除SQLLite文件并重新开始(假设你没有持久化其他数据)。

小开
最佳答案

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
}

objective - c

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


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

关于批量删除的更多信息可以在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
小开

这是一个类似的问题在这里，有人建议设置一个关系删除规则，这样你只需要删除一个对象。因此，如果您已经或可以创建一个与汽车具有多对关系的实体，并将删除规则设置为级联，当您删除更高的实体时，所有的汽车也将被删除。这可以节省一些处理时间，因为您不必执行加载所有汽车的步骤。在更大的数据集中，这可能是绝对必要的。

小开

更干净和通用一点:添加这个方法:

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

一个很好的答案已经贴出来了，这只是一个推荐!

一个好方法是在NSManagedObject中添加一个类别，并像我做的那样实现一个方法:

头文件(例如NSManagedObject+Ext.h)

@interface NSManagedObject (Logic)


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


@end

代码文件:(例如NSManagedObject+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];

一个更干净的impl(作为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"];
小开

如果实体包含很多条目，最好的方法是这样，因为它节省内存

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

迅速:

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

对于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版本，照顾iOS 9和以前的版本以及。我还介绍了错误处理:

让appDelegate: appDelegate = UIApplication.sharedApplication().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)")
}
}
小开

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
}
小开

在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)")
}
}
小开

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

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解决方案与iOS 9 'NSBatchDeleteRequest'和回退到早期的iOS版本，作为'NSManagedObjectContext'的扩展实现。苹果引用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) }
}
}
}
}
小开

重置斯威夫特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")
}
}
小开

斯威夫特3。X和斯威夫特4。X，简单。只修改YourTable

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

在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.0时，使用NSBatchDeleteRequest删除多条记录。如果是后台线程，执行NSManagedObjectContext save，否则使用NSFetchRequest获取记录并删除for循环中的所有记录，删除完成后保存。

小开

Swift 4, iOS 12和Xcode 10更新

100%工作刚剪完&粘贴

只要把这个函数放在相关的类中，并在viewDidLoad()或任何地方或在一个函数或按钮下调用这个函数self.deleteData()，这样通过单击一个按钮，所有来自实体的数据都应该被删除，并替换“myEntity”作为你在核心数据中定义的实体

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)")
}
}
小开
< p > Swift 4, iOS 10+ < br > 静态函数，可以应用于任何实体删除其所有数据

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编辑:如果我们在同一个项目中使用多个目标，"Self.fetchRequest()"指令可能会导致问题。所以替换为NSFetchRequest(entityName: String(description: self))

小开

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

你必须在执行之后调用重置。如果不是，它将不会在表视图上更新。

小开

这段代码适用于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()
}
小开 
    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)
}
}
小开

快速清除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)")
}
}
}
小开

OOP方式，没有任何字符串作为实体名称 Swift 3+， Xcode 10+

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/catch块

    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
}
小开

上面的答案提供了一个关于如何删除&;car &;

然而，我想用这个答案来挑战这种方法本身:

1- SQLite CoreData是一个关系数据库。在这种情况下，如果没有任何关联，我建议不要使用CoreData，而改用文件系统，或者将数据保存在内存中。

2-在其他例子中，“;Car"实体有其他关系，因此CoreData，我建议不要有2000辆车作为根实体。相反，我会给它们一个父节点，比如“CarsRepository"实体。然后，您可以给"Car"实体，只需替换关系以在下载新车时指向它们。向关系中添加正确的删除规则可以确保模型的完整性。

小开

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静态方法批量删除实体

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

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

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

提交答案