Migrating from SwiftData to SQLiteData When to Switch ┌─────────────────────────────────────────────────────────┐ │ Should I switch from SwiftData to SQLiteData? │ ├─────────────────────────────────────────────────────────┤ │ │ │ Performance problems with 10k+ records? │ │ YES → SQLiteData (10-50x faster for large datasets) │ │ │ │ Need CloudKit record SHARING (not just sync)? │ │ YES → SQLiteData (SwiftData cannot share records) │ │ │ │ Complex queries across multiple tables? │ │ YES → SQLiteData + raw GRDB when needed │ │ │ │ Need Sendable models for Swift 6 concurrency? │ │ YES → SQLiteData (value types, not classes) │ │ │ │ Testing @Model classes is painful? │ │ YES → SQLiteData (pure structs, easy to mock) │ │ │ │ Happy with SwiftData for simple CRUD? │ │ YES → Stay with SwiftData (simpler for basic apps) │ │ │ └─────────────────────────────────────────────────────────┘

Pattern Equivalents SwiftData SQLiteData @Model class Item @Table nonisolated struct Item @Attribute(.unique) @Column(primaryKey: true) or SQL UNIQUE @Relationship var tags: [Tag] var tagIDs: [Tag.ID] + join query @Query var items: [Item] @FetchAll var items: [Item] @Query(sort: .title) @FetchAll(Item.order(by: .title)) @Query(filter: #Predicate { $0.isActive }) @FetchAll(Item.where(.isActive)) @Environment(.modelContext) @Dependency(.defaultDatabase) context.insert(item) Item.insert { Item.Draft(...) }.execute(db) context.delete(item) Item.find(id).delete().execute(db) try context.save() Automatic in database.write { } block ModelContainer(for:) prepareDependencies { $0.defaultDatabase = } Code Example

SwiftData (Before)

import SwiftData

@Model class Task { var id: UUID var title: String var isCompleted: Bool var project: Project?

init(title: String) {
    self.id = UUID()
    self.title = title
    self.isCompleted = false
}

}

struct TaskListView: View { @Environment(.modelContext) private var context @Query(sort: .title) private var tasks: [Task]

var body: some View {
    List(tasks) { task in
        Text(task.title)
    }
}

func addTask(_ title: String) {
    let task = Task(title: title)
    context.insert(task)
}

func deleteTask(_ task: Task) {
    context.delete(task)
}

}

SQLiteData (After)

import SQLiteData

@Table nonisolated struct Task: Identifiable { let id: UUID var title = "" var isCompleted = false var projectID: Project.ID? }

struct TaskListView: View { @Dependency(.defaultDatabase) var database @FetchAll(Task.order(by: .title)) var tasks

var body: some View {
    List(tasks) { task in
        Text(task.title)
    }
}

func addTask(_ title: String) {
    try database.write { db in
        try Task.insert {
            Task.Draft(title: title)
        }
        .execute(db)
    }
}

func deleteTask(_ task: Task) {
    try database.write { db in
        try Task.find(task.id).delete().execute(db)
    }
}

}

Key differences:

class → struct with nonisolated @Model → @Table @Query → @FetchAll @Environment(.modelContext) → @Dependency(.defaultDatabase) Implicit save → Explicit database.write { } block Direct init → .Draft type for inserts @Relationship → Explicit foreign key + join CloudKit Sharing (SwiftData Can't Do This)

SwiftData supports CloudKit sync but NOT sharing. SQLiteData is the only Apple-native option for record sharing.

// 1. Setup SyncEngine with sharing prepareDependencies { $0.defaultDatabase = try! appDatabase() $0.defaultSyncEngine = try SyncEngine( for: $0.defaultDatabase, tables: Task.self, Project.self ) }

// 2. Share a record @Dependency(.defaultSyncEngine) var syncEngine @State var sharedRecord: SharedRecord?

func shareProject(_ project: Project) async throws { sharedRecord = try await syncEngine.share(record: project) { share in share[CKShare.SystemFieldKey.title] = "Join my project!" } }

// 3. Present native sharing UI .sheet(item: $sharedRecord) { record in CloudSharingView(sharedRecord: record) }

Sharing enables: Collaborative lists, shared workspaces, family sharing, team features.

Performance Comparison Operation SwiftData SQLiteData Improvement Insert 50k records ~4 minutes ~45 seconds 5x Query 10k with predicate ~2 seconds ~50ms 40x Memory (10k objects) ~80MB ~20MB 4x smaller Cold launch (large DB) ~3 seconds ~200ms 15x

Benchmarks approximate, vary by device and data shape.

Gradual Migration Strategy

You don't have to migrate everything at once:

Add SQLiteData for new features — Keep SwiftData for existing simple CRUD Migrate one model at a time — Start with the performance bottleneck Use separate databases initially — SQLiteData for heavy data/sharing, SwiftData for preferences Consolidate if needed — Or keep hybrid if it works Common Gotchas Relationships → Foreign Keys // SwiftData: implicit relationship @Relationship var tasks: [Task]

// SQLiteData: explicit column + query // In child: var projectID: Project.ID // To fetch: Task.where { $0.projectID == project.id }

Cascade Deletes // SwiftData: @Relationship(deleteRule: .cascade)

// SQLiteData: Define in SQL schema // "REFERENCES parent(id) ON DELETE CASCADE"

No Automatic Inverse // SwiftData: @Relationship(inverse: \Task.project)

// SQLiteData: Query both directions manually let tasks = Task.where { $0.projectID == project.id } let project = Project.find(task.projectID)

Related Skills:

axiom-sqlitedata — Full SQLiteData API reference axiom-swiftdata — SwiftData patterns if staying with Apple's framework axiom-grdb — Raw GRDB for complex queries

History: See git log for changes

axiom-sqlitedata-migration

安装