Core Data Database Basics

# CHAPTER 21

Core Data Database Basics #

1. Introduction #

2. Learning Objectives #

• Understand the Core Data stack and the Data Model editor.

• Define a Core Data Entity and its Attributes.

• Use the @FetchRequest property wrapper to pull data directly into SwiftUI.

• Create and save new records to the database.

• Delete existing records from the database.

3. Setting Up Core Data #

The Persistence Controller: Xcode also generates a Persistence.swift file. This contains the NSPersistentCloudKitContainer, which is the engine that connects your code to the actual SQLite database living on the phone's hard drive.

4. Creating an Entity (The Schema) #

1. 1. Open the .xcdatamodeld file.

1. 2. Click "Add Entity" at the bottom. Name it Note.

1. 3. Under "Attributes", add a new attribute named title of type String.

1. 4. Add another attribute named timestamp of type Date.

*Xcode will automatically generate a Swift Class for Note behind the scenes. You never have to write the struct manually!*

5. Injecting the Database into the App #

@main
struct NotesApp: App {
    // 1. Grab the engine Xcode created for us
    let persistenceController = PersistenceController.shared

    var body: some Scene {
        WindowGroup {
            ContentView()
                // 2. Inject it into the environment!
                .environment(\.managedObjectContext, persistenceController.container.viewContext)
        }
    }
}

6. Reading Data: @FetchRequest #

import SwiftUI
import CoreData

struct ContentView: View {
    // 1. Access the database connection we injected earlier
    @Environment(\.managedObjectContext) private var viewContext

    // 2. The Fetch Request! Ask the database for all Notes, sorted by time.
    @FetchRequest(
        entity: Note.entity(),
        sortDescriptors: [NSSortDescriptor(keyPath: \Note.timestamp, ascending: false)]
    ) private var notes: FetchedResults<Note>

    var body: some View {
        List {
            // 3. Loop through the results exactly like a normal array!
            ForEach(notes) { note in
                // Note: Core Data strings are Optional by default! Use ??
                Text(note.title ?? "Untitled")
            }
        }
    }
}

7. Creating Data (Writing to the DB) #

func addNote(text: String) {
    // 1. Create a new empty record on the scratchpad
    let newNote = Note(context: viewContext)
    
    // 2. Fill it with data
    newNote.title = text
    newNote.timestamp = Date() // Current time
    
    // 3. Push the scratchpad to the permanent hard drive!
    do {
        try viewContext.save()
    } catch {
        print("Failed to save note: \(error)")
    }
}

8. Deleting Data #

// Triggered by a Swipe-to-Delete on the List
func deleteNotes(offsets: IndexSet) {
    // Find the exact notes the user swiped on
    for index in offsets {
        let noteToDelete = notes[index]
        // Tell the scratchpad to delete it
        viewContext.delete(noteToDelete)
    }
    
    // Save the changes to the hard drive!
    do {
        try viewContext.save()
    } catch {
        print("Failed to delete note: \(error)")
    }
}

9. Common Mistakes #

• Forgetting to Save: You can create 100 Note(context: viewContext) objects. They will even show up in the UI immediately because @FetchRequest monitors the scratchpad! But if you force-close the app without calling try viewContext.save(), all 100 notes will be permanently erased. You MUST commit the scratchpad to the hard drive!

10. Best Practices #

• SwiftData (The Future): In iOS 17 (2023), Apple introduced SwiftData, which is a modern, pure-Swift wrapper around Core Data. It replaces the visual .xcdatamodeld editor with simple @Model macros in code. While Core Data remains the absolute industry standard for legacy apps, SwiftData is the future of Apple persistence.

11. Exercises #

1. 1. In a visual .xcdatamodeld file, create an Entity named Task with a title (String) and isDone (Boolean).

1. 2. Write the @FetchRequest code to retrieve all Task entities.

12. Coding Challenges #

13. MCQ Quiz with Answers #

14. Interview Questions #

• Q: Contrast the specific use cases of UserDefaults versus Core Data. Why would attempting to use UserDefaults to store 5,000 complex, relational user objects be considered catastrophic architecture?

• Q: Explain the mechanical flow of creating and persisting a new Entity record using the NSManagedObjectContext. Why is the explicit .save() operation mandatory?

• Q: Describe how SwiftUI's @FetchRequest property wrapper integrates seamlessly with Core Data. What advantage does it provide over manual data fetching?

15. FAQs #

16. Summary #

17. Next Chapter Recommendation #