Getting Started with SwiftData

Photo by Kevin Ku on Unsplash

There are lot of frameworks introduces on WWDC23. SwiftData is one of them. SwiftData designs to persist data using Swift code. You can query and filter data and it’s easily integrate with SwiftUI. It’s very easy to use with widgets and CloudKit. First and foremost, we will see how we can create models using SwiftData.

How to create Models with Swift?

We can create models using Swift @Model macro. Using @Model macro we can define schema with code and add functionality to model types.

It’s similar to declaring a class in Swift.

class Person {
  var id: Int
  var name: String
  var hobbies: [Hobby]
}

Add @Model to Person class and schema is generated.

import SwiftData

@Model
class Person {
  var id: Int
  var name: String
  var hobbies: [Hobby]
}

• Attributes inferred from properties
• Supports basic value types like Int, String and float
• Supports complex value types like Struct, Enum, Codable etc.

We can add additional meta data to properties.

• @Model modifies all stored property of class
• You can control how properties are inferred and you can set clear constraints like @Attribute(.unique) or @Relationship
• Using @Transient we can exclude properties

import SwiftData

@Model
class Person {
  @Attribute(.unique) var id: Int
  var name: String
  @Relationship(.cascade) var hobbies: [Hobby]
}

Linking Models with your App

We can use SwiftUI view and scene modifiers to setup container.

import SwiftUI
import SwiftData

@main
struct SocialApp: App {

    var body: some Scene {
        WindowGroup {
            ContentView()
        }
        .modelContainer(for: 
          [Person.self, 
           Hobby.self])
    }
}

Accessing Data

With model defined and the modelContainer inject into the environment you can access database entites.

import SwiftData
import SwiftUI

@Query var person: [Person]
var body: some View {
 List(person) { person in
  NavigationLink(person.name, destination: PersonView(person))
 }
}

Adding and deleting data from database

Likewise Coredata you need to access the store’s context to perform add or delete operations. Once you have context then you can perform adding operations using context.insert() and delete objects using context.delete()

import SwiftData
import SwiftUI

@Environment(.\modelContext) private var context
@Query var person: [Person]

var body: some View {
NavigationView {
 List(person) { person in
  NavigationLink(person.name, destination: PersonView(person))
 }
.onDelete(perform: deletePerson)
}
}
.toolbar {
      ToolbarItem(placement: .navigationBarTrailing) {
        EditButton()
      }
      ToolbarItem {
        Button(action: addPerson) {
          Label("Add Person", systemImage: "plus")
        }
      }
    }
  }

private func addPerson() {
    withAnimation {
      let newPerson = Person("New Person")
        context.insert(newPerson)
    }
  }

  private func deletePerson(offsets: IndexSet) {
    withAnimation {
      for index in offsets {
        context.delete(person[index])
      }
    }
  }
}

Conclusion

SwiftData makes it very easy to persist data using simple code. You can use CoreData and SwiftData in same app. To find out more WWDC23 has set of videos on SwiftData:

• Meet SwiftData
• Build an app with SwiftData
• Migrate to SwiftData
• Model your schema with SwiftData
• Dive deeper into SwiftData

Don’t hesitate to [contact me](mailto: gurjitsinghpt@gmail.com) if you have any questions or queries. Follow me on twitter @gurjitpt for any updates.

Thanks!