Working with Core Data

import CoreData

class CoreDataManager {
    static let shared = CoreDataManager()
    
    lazy var persistentContainer: NSPersistentContainer = {
        let container = NSPersistentContainer(name: "MyModel")
        container.loadPersistentStores { _, error in
            if let error = error {
                fatalError("Core Data error: \(error)")
            }
        }
        return container
    }()
    
    var context: NSManagedObjectContext {
        return persistentContainer.viewContext
    }
}

import CoreData

let model = NSManagedObjectModel()
let entity = NSEntityDescription()
entity.name = "Person"
entity.managedObjectClassName = "Person"

let nameAttribute = NSAttributeDescription()
nameAttribute.name = "name"
nameAttribute.attributeType = .stringAttributeType
nameAttribute.isOptional = false

let ageAttribute = NSAttributeDescription()
ageAttribute.name = "age"
ageAttribute.attributeType = .integer16AttributeType
ageAttribute.isOptional = true

entity.properties = [nameAttribute, ageAttribute]
model.entities = [entity]

let persistentContainer = NSPersistentContainer(name: "MyModel", managedObjectModel: model)

let context = NSManagedObjectContext(concurrencyType: .mainQueueConcurrencyType)
context.persistentStoreCoordinator = persistentStoreCoordinator

let fetchRequest = NSFetchRequest<NSManagedObject>(entityName: "Person")
do {
    let results = try context.fetch(fetchRequest)
    for person in results {
        print(person.value(forKey: "name") as? String ?? "")
    }
} catch {
    print("Fetch failed: \(error)")
}

do {
    try context.save()
    print("Changes saved successfully")
} catch {
    print("Save failed: \(error)")
}

import CoreData

let entity = NSEntityDescription()
entity.name = "Person"
entity.managedObjectClassName = "Person"

let nameAttribute = NSAttributeDescription()
nameAttribute.name = "name"
nameAttribute.attributeType = .stringAttributeType
nameAttribute.isOptional = false

let ageAttribute = NSAttributeDescription()
ageAttribute.name = "age"
ageAttribute.attributeType = .integer16AttributeType
ageAttribute.isOptional = true

entity.attributes = [nameAttribute, ageAttribute]

let managedObjectModel = NSManagedObjectModel()
managedObjectModel.entities = [entity]

let fetchRequest = NSFetchRequest<NSManagedObject>(entityName: "Person")
let context = persistentContainer.viewContext
let results = try context.fetch(fetchRequest)

let fetchRequest = NSFetchRequest<Person>(entityName: "Person")
fetchRequest.predicate = NSPredicate(format: "name CONTAINS[cd] %@", "John")
let context = persistentContainer.viewContext
let results = try context.fetch(fetchRequest)

let fetchRequest = NSFetchRequest<Person>(entityName: "Person")
fetchRequest.sortDescriptors = [NSSortDescriptor(key: "age", ascending: false)]
let context = persistentContainer.viewContext
let results = try context.fetch(fetchRequest)

let context = persistentContainer.viewContext
let fetchRequest: NSFetchRequest<Employee> = Employee.fetchRequest()
let predicate = NSPredicate(format: "department.name == %@", "Engineering")
fetchRequest.predicate = predicate

do {
    let employees = try context.fetch(fetchRequest)
    print("Found \(employees.count) employees")
} catch {
    print("Fetch failed: \(error)")
}

let searchTerm = "john"
let predicate = NSPredicate(format: "name CONTAINS[cd] %@", searchTerm)

let fetchRequest: NSFetchRequest<Employee> = Employee.fetchRequest()
fetchRequest.predicate = predicate

let request = NSFetchRequest<Employee>()
request.sortDescriptors = [NSSortDescriptor(key: "name", ascending: true)]

let sortDescriptors = [
    NSSortDescriptor(key: "department", ascending: true),
    NSSortDescriptor(key: "name", ascending: false)
]
request.sortDescriptors = sortDescriptors

let context = persistentContainer.viewContext
let fetchRequest: NSFetchRequest<Person> = Person.fetchRequest()
fetchRequest.predicate = NSPredicate(format: "name == %@", "John")

do {
    let results = try context.fetch(fetchRequest)
    if let person = results.first {
        person.name = "John Smith"
        try context.save()
    }
} catch {
    print("Failed to update person: \(error)")
}

class PersonTableViewController: UITableViewController {
    lazy var fetchedResultsController: NSFetchedResultsController<Person> = {
        let fetchRequest: NSFetchRequest<Person> = Person.fetchRequest()
        fetchRequest.sortDescriptors = [NSSortDescriptor(key: "name", ascending: true)]
        
        let frc = NSFetchedResultsController(
            fetchRequest: fetchRequest,
            managedObjectContext: context,
            sectionNameKeyPath: nil,
            cacheName: nil
        )
        frc.delegate = self
        return frc
    }()
    
    func updatePerson(_ person: Person) {
        person.name = "Updated Name"
        do {
            try context.save()
        } catch {
            print("Save error: \(error)")
        }
    }
}

let managedObjectContext = persistentContainer.viewContext
let person = NSEntityDescription.entity(forName: "Person", in: managedObjectContext)!
let personObject = NSManagedObject(entity: person, insertInto: managedObjectContext)

// Delete the object
managedObjectContext.delete(personObject)

let fetchRequest = NSFetchRequest<NSManagedObject>(entityName: "Person")
let persons = try! managedObjectContext.fetch(fetchRequest)

managedObjectContext.deleteObjects(persons)

let context = persistentContainer.viewContext
context.insertedObjects // Check for new objects
context.updatedObjects // Check for updated objects
context.deletedObjects // Check for deleted objects

do {
    try context.save()
    print("Changes saved successfully")
} catch {
    print("Failed to save context: \(error)")
}

let context = persistentContainer.newBackgroundContext()
let entity = NSEntityDescription.entity(forName: "Person", in: context)
let values = [
    ["name": "Alice", "age": 30],
    ["name": "Bob", "age": 25]
]

let insertRequest = NSBatchInsertRequest(entity: entity!, values: values)
try context.execute(insertRequest)

let context = persistentContainer.newBackgroundContext()
let entity = NSEntityDescription.entity(forName: "Person", in: context)
let updateRequest = NSBatchUpdateRequest(entity: entity!, propertiesToUpdate: ["age": 35])
try context.execute(updateRequest)

let context = persistentContainer.newBackgroundContext()
let fetchRequest = NSFetchRequest<NSFetchRequestResult>(entityName: "Person")
fetchRequest.predicate = NSPredicate(format: "age < 20")

let deleteRequest = NSBatchDeleteRequest(fetchRequest: fetchRequest)
try context.execute(deleteRequest)

let backgroundContext = NSManagedObjectContext(concurrencyType: .privateQueueConcurrencyType)
backgroundContext.parent = mainContext

backgroundContext.perform {
    // Perform changes here
    do {
        try backgroundContext.save()
        mainContext.perform {
            try? mainContext.save() // Save parent context on main thread
        }
    } catch {
        print("Error saving background context: \(error)")
    }
}