CRUD operations with SwiftData in iOS Swift

Introduction

CRUD means Create, Read, Update, and Delete data. SwiftData helps you do these actions easily in your iOS apps.

You want to save user notes in your app.

You need to show a list of saved contacts.

You want users to edit their profile information.

You want to remove old or unwanted data from your app.

Syntax

iOS Swift

import SwiftData

// Define a model
@Model
class Item {
  var id: UUID
  var name: String

  init(id: UUID = UUID(), name: String) {
    self.id = id
    self.name = name
  }
}

// Create
let newItem = Item(name: "Example")
modelContext.insert(newItem)

// Read
let items = try modelContext.fetch(Item.self)

// Update
newItem.name = "Updated Name"
try modelContext.save()

// Delete
modelContext.delete(newItem)
try modelContext.save()

@Model marks your data class for SwiftData storage.

Use modelContext to manage data operations like insert, fetch, save, and delete.

Examples

Defines a Task model with an ID, title, and done status.

iOS Swift

@Model
class Task {
  var id: UUID
  var title: String
  var done: Bool

  init(id: UUID = UUID(), title: String, done: Bool = false) {
    self.id = id
    self.title = title
    self.done = done
  }
}

Creates and saves a new Task.

iOS Swift

let task = Task(title: "Buy milk")
modelContext.insert(task)
try modelContext.save()

Fetches all tasks and prints their titles.

iOS Swift

let tasks = try modelContext.fetch(Task.self)
for task in tasks {
  print(task.title)
}

Updates a task's done status and saves the change.

iOS Swift

task.done = true
try modelContext.save()

Sample App

This app lets you add notes, see them in a list, and delete them by swiping. It uses SwiftData to save notes automatically.

iOS Swift

import SwiftUI
import SwiftData

@Model
class Note {
  var id: UUID
  var content: String

  init(id: UUID = UUID(), content: String) {
    self.id = id
    self.content = content
  }
}

struct ContentView: View {
  @Environment(\.modelContext) private var modelContext
  @Query private var notes: [Note]
  @State private var newNote = ""

  var body: some View {
    VStack {
      TextField("New note", text: $newNote)
        .textFieldStyle(.roundedBorder)
        .padding()

      Button("Add Note") {
        let note = Note(content: newNote)
        modelContext.insert(note)
        try? modelContext.save()
        newNote = ""
      }
      .padding()

      List {
        ForEach(notes, id: \.id) { note in
          Text(note.content)
        }
        .onDelete { indexSet in
          for index in indexSet {
            let note = notes[index]
            modelContext.delete(note)
          }
          try? modelContext.save()
        }
      }
    }
    .padding()
  }
}

@main
struct NotesApp: App {
  var body: some Scene {
    WindowGroup {
      ContentView()
        .modelContainer(for: [Note.self])
    }
  }
}

Important Notes

Always save changes with try? modelContext.save() after insert, update, or delete.

Use @Query to automatically fetch and update your UI when data changes.

Handle errors in real apps; here we use try? for simplicity.

Summary

CRUD means Create, Read, Update, and Delete data.

SwiftData uses @Model classes and modelContext to manage data.

Use @Query to fetch data and keep your UI updated automatically.

Practice

1. What does the @Model attribute in SwiftData represent?

easy

A. A UI component for displaying lists

B. A data model class used to define entities for CRUD operations

C. A function to fetch data from the network

D. A SwiftUI view modifier for styling

Solution

1. Step 1: Understand the role of @Model

   The @Model attribute marks a class as a data model entity for SwiftData, enabling CRUD operations.

2. Step 2: Differentiate from UI and functions

   It is not related to UI components, network functions, or view modifiers.

3. Final Answer:

   A data model class used to define entities for CRUD operations -> Option B

4. Quick Check:

   @Model defines data entities = B [OK]

Hint: Remember @Model marks data classes, not UI or functions [OK]

Common Mistakes:

• Confusing @Model with UI components
• Thinking @Model fetches data
• Mixing @Model with view modifiers

2. Which of the following is the correct way to declare a SwiftData model class named Book with a title property of type String?

easy

A. @Model class Book { var title: String }

B. @Model struct Book { var title: String }

C. struct Book { var title: String }

D. class Book: ObservableObject { var title: String }

Solution

1. Step 1: Identify correct @Model usage

   SwiftData requires @Model on a class, not a struct, to define a data entity.

2. Step 2: Check class vs struct and attribute

   @Model class Book { var title: String } correctly uses @Model with a class and a property.

3. Final Answer:

   @Model class Book { var title: String } -> Option A

4. Quick Check:

   @Model + class + properties = D [OK]

Hint: Use @Model with class, not struct, for SwiftData models [OK]

Common Mistakes:

• Using struct instead of class for @Model
• Omitting @Model attribute
• Using ObservableObject instead of @Model

3. Given the following SwiftData code snippet, what will be the output when printing books.count after adding a new book?

struct ContentView: View {
  @Environment(\"modelContext\") private var modelContext
  @Query var books: [Book]

  var body: some View {
    Button(\"Add Book\") {
      let newBook = Book(title: \"SwiftData Basics\")
      modelContext.insert(newBook)
    }
    Text(\"Books count: \(books.count)\")
  }
}

medium

A. Books count: 0

B. Books count: 2

C. Books count: 1

D. Compilation error

Solution

1. Step 1: Understand @Query and modelContext.insert

   The @Query property fetches all Book entities. Inserting a new Book updates the data source.

2. Step 2: Check the effect of insertion on books.count

   After inserting one new Book, the count increases by 1, so it will be 1.

3. Final Answer:

   Books count: 1 -> Option C

4. Quick Check:

   Insert one book, count updates to 1 [OK]

Hint: Inserting updates @Query results immediately [OK]

Common Mistakes:

• Assuming count stays 0 after insert
• Expecting count to be 2 without adding twice
• Thinking code causes compile error

4. Identify the error in this SwiftData update code snippet:

func updateBookTitle(book: Book, newTitle: String) {
  book.title = newTitle
  modelContext.save()
}

medium

A. No error; code updates title correctly

B. Missing call to modelContext.insert(book)

C. book.title cannot be changed directly; must create new Book

D. modelContext.save() is not a valid method in SwiftData

Solution

1. Step 1: Check SwiftData update pattern

   In SwiftData, changes to model object properties are tracked automatically, but modelContext.save() is not a valid method to persist changes explicitly.

2. Step 2: Identify if there's an error

   Directly mutating book.title is correct, but calling modelContext.save() causes an error because the method does not exist.

3. Final Answer:

   modelContext.save() is not a valid method in SwiftData -> Option D

4. Quick Check:

   Property change tracked automatically; no save() method = A [OK]

Hint: SwiftData tracks changes automatically; no save() method needed [OK]

Common Mistakes:

• Thinking modelContext.save() exists
• Believing properties are immutable
• Confusing update with insert

5. You want to delete all Book objects with an empty title using SwiftData. Which code snippet correctly performs this operation?

hard

A. books.filter { $0.title.isEmpty }.forEach { modelContext.delete($0) }

B. for book in books where book.title.isEmpty { modelContext.delete(book) }

C. modelContext.deleteAll(Book.self, where: \"title == ''\")

D. modelContext.remove(books.filter { $0.title.isEmpty })

Solution

1. Step 1: Understand deletion in SwiftData

   To delete objects, you call modelContext.delete(object) for each object.

2. Step 2: Check each option for correctness

   books.filter { $0.title.isEmpty }.forEach { modelContext.delete($0) } filters books with empty titles and deletes each correctly. for book in books where book.title.isEmpty { modelContext.delete(book) } syntax is invalid in Swift. modelContext.deleteAll(Book.self, where: \"title == ''\") uses a non-existent method. modelContext.remove(books.filter { $0.title.isEmpty }) uses wrong method name.

3. Final Answer:

   books.filter { $0.title.isEmpty }.forEach { modelContext.delete($0) } -> Option A

4. Quick Check:

   Filter then delete each = A [OK]

Hint: Filter then delete each object individually [OK]

Common Mistakes:

• Using invalid for-in with where clause
• Calling non-existent deleteAll method
• Using wrong method name like remove