Getting Started with SwiftData

Posted on 07 Jul 2023 . 2 min read

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.

@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])
      }
    }
  }
}

The bottom line

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:

Don’t hesitate to contact me if you have any questions or queries. Follow me on twitter @gurjitpt for any updates.

Thanks!

Share this article

Written By

Generic placeholder image

Gurjit Singh

I’m Computer Science graduate and an iOS Engineer who writes about Swift and iOS development. Follow me for more updates:

Discover articles by topics

SwiftUI Class Struct Networking XCode NSCache Enum Optionals Property Observers Closures Guard Reviews StoreKit App Store Algorithms Testing Operators Protocol Extensions Weak Unowned SwiftData WWDC23 GCD API Admob SwiftLint Lottie Foreach Objective-C UIKit NavigationSplitView