SwiftData双存储配置报错，如何实现独立数据存储？

我正在开发一款SwiftData应用，需要配置两个独立的SQLite数据存储：一个是预置并随应用分发的存储，另一个是用户运行应用时创建的存储。但在创建并保存数据项时，出现了如下错误：

Failed to save after place creation: The model configuration used to open the store is incompatible with the one that was used to create the store.

测试用模型代码 #

@Model
class Person: Identifiable {
    @Attribute(.unique) let id: UUID
    let name: String
    
    init(id: UUID = UUID(), name: String) {
        self.id = id
        self.name = name
    }
}

@Model
class Place: Identifiable {
    @Attribute(.unique) let id: UUID
    let name: String
    
    init(id: UUID = UUID(), name: String) {
        self.id = id
        self.name = name
    }
}

SwiftData初始化代码 #

@main
struct MultiStoreApp: App {
    
    var container: ModelContainer
    
    init() {
        let peopleStoreURL = URL.documentsDirectory.appending(path: "people.store")
        let placeStoreURL = URL.documentsDirectory.appending(path: "places.store")
        
        let peopleConfig = ModelConfiguration(schema: Schema([Person.self]), url: peopleStoreURL)
        let placesConfig = ModelConfiguration(schema: Schema([Place.self]), url: placeStoreURL)
        
        do {
            self.container = try ModelContainer(for: Person.self, Place.self, configurations: peopleConfig, placesConfig)
        } catch {
            fatalError("Failed to create model container: \(error.localizedDescription)")
        }
    }
    
    var body: some Scene {
        WindowGroup {
            ContentView()
                .modelContainer(container)
        }
    }
}

视图代码 #

struct ContentView: View {
    @Environment(\.modelContext) private var modelContext
    
    @Query var people: [Person]
    @Query var places: [Place]
    
    var body: some View {
        NavigationStack {
            List {
                Section("People") {
                    ForEach(people) { person in
                        VStack(alignment: .leading) {
                            Text(person.name)
                            Text(person.id.uuidString)
                                .font(.caption)
                        }
                    }
                }
                
                Section("Places") {
                    ForEach(places) { place in
                        VStack(alignment: .leading) {
                            Text(place.name)
                            Text(place.id.uuidString)
                                .font(.caption)
                        }
                    }
                }
            }
            
            GroupBox {
                HStack {
                    Button(action: {
                        let person = Person(name: "Person \(people.count)")
                        modelContext.insert(person)
                        do {
                            try modelContext.save()
                        } catch {
                            print("Failed to save after person creation: \(error.localizedDescription)")
                        }
                    }, label: {
                        Text("Add Person")
                    })
                    
                    Spacer()
                    
                    Button(action: {
                        let place = Place(name: "Place \(places.count)")
                        modelContext.insert(place)
                        do {
                            try modelContext.save()
                        } catch {
                            print("Failed to save after place creation: \(error.localizedDescription)")
                        }
                    }, label: {
                        Text("Add Place")
                    })
                }
            }
            .padding()
        }
    }
}

在干净的模拟器中运行应用时，只能添加一种类型的对象，添加另一种类型时就会触发上述错误。请问这种双存储需求是否可行？

解决方案 #

双存储需求完全可行，问题出在当前的配置方式上：

核心问题 #

默认的ModelContext会使用容器中的第一个配置（peopleConfig），当插入Place对象并尝试保存时，这个上下文会试图将Place写入people.store，而该存储的schema仅包含Person，从而导致兼容性错误。

修复步骤 #

为每个存储创建独立的ModelContext，明确指定对应的配置，并在视图中使用对应上下文操作不同类型的数据：

修改后的初始化代码

@main
struct MultiStoreApp: App {
    let container: ModelContainer
    // 为两个存储分别创建专属上下文
    let peopleContext: ModelContext
    let placesContext: ModelContext
    
    init() {
        let peopleStoreURL = URL.documentsDirectory.appending(path: "people.store")
        let placeStoreURL = URL.documentsDirectory.appending(path: "places.store")
        
        let peopleConfig = ModelConfiguration(schema: Schema([Person.self]), url: peopleStoreURL)
        let placesConfig = ModelConfiguration(schema: Schema([Place.self]), url: placeStoreURL)
        
        do {
            container = try ModelContainer(for: Person.self, Place.self, configurations: peopleConfig, placesConfig)
            // 明确指定配置创建上下文
            peopleContext = ModelContext(container, configuration: peopleConfig)
            placesContext = ModelContext(container, configuration: placesConfig)
        } catch {
            fatalError("Failed to create model container: \(error.localizedDescription)")
        }
    }
    
    var body: some Scene {
        WindowGroup {
            ContentView()
                // 将两个上下文通过自定义环境键传递给视图
                .environment(\.peopleContext, peopleContext)
                .environment(\.placesContext, placesContext)
                .modelContainer(container)
        }
    }
}

// 自定义环境键，用于传递不同存储的上下文
private struct PeopleContextKey: EnvironmentKey {
    static let defaultValue: ModelContext = ModelContext(ModelContainer())
}

private struct PlacesContextKey: EnvironmentKey {
    static let defaultValue: ModelContext = ModelContext(ModelContainer())
}

extension EnvironmentValues {
    var peopleContext: ModelContext {
        get { self[PeopleContextKey.self] }
        set { self[PeopleContextKey.self] = newValue }
    }
    
    var placesContext: ModelContext {
        get { self[PlacesContextKey.self] }
        set { self[PlacesContextKey.self] = newValue }
    }
}

修改后的视图代码

struct ContentView: View {
    // 通过自定义环境键获取对应存储的上下文
    @Environment(\.peopleContext) private var peopleContext
    @Environment(\.placesContext) private var placesContext
    
    // 查询时指定对应的上下文
    @Query(context: \.peopleContext) var people: [Person]
    @Query(context: \.placesContext) var places: [Place]
    
    var body: some View {
        NavigationStack {
            List {
                Section("People") {
                    ForEach(people) { person in
                        VStack(alignment: .leading) {
                            Text(person.name)
                            Text(person.id.uuidString)
                                .font(.caption)
                        }
                    }
                }
                
                Section("Places") {
                    ForEach(places) { place in
                        VStack(alignment: .leading) {
                            Text(place.name)
                            Text(place.id.uuidString)
                                .font(.caption)
                        }
                    }
                }
            }
            
            GroupBox {
                HStack {
                    Button(action: {
                        let person = Person(name: "Person \(people.count)")
                        peopleContext.insert(person)
                        do {
                            try peopleContext.save()
                        } catch {
                            print("Failed to save after person creation: \(error.localizedDescription)")
                        }
                    }, label: {
                        Text("Add Person")
                    })
                    
                    Spacer()
                    
                    Button(action: {
                        let place = Place(name: "Place \(places.count)")
                        placesContext.insert(place)
                        do {
                            try placesContext.save()
                        } catch {
                            print("Failed to save after place creation: \(error.localizedDescription)")
                        }
                    }, label: {
                        Text("Add Place")
                    })
                }
            }
            .padding()
        }
    }
}

额外说明 #

• 若需要处理预置存储（比如从App Bundle复制到Documents目录），可在初始化容器前添加复制逻辑，确保预置的存储文件存在于指定路径。
• 确保每个配置的schema仅包含对应存储需要的模型类型，避免跨存储的模型引用。

内容的提问来源于stack exchange，提问作者Keith Sharp