DataStack

The resolved application name, used by the DataStack as the default Xcode model name (.xcdatamodel filename) if not explicitly provided.

Convenience initializer for DataStack that creates a SchemaHistory from the model with the specified modelName in the specified bundle.

Convenience initializer for DataStack that creates a SchemaHistory from a list of DynamicSchema versions.

CoreStoreDefaults.dataStack = DataStack(
    XcodeDataModelSchema(modelName: "MyModelV1"),
    CoreStoreSchema(
        modelVersion: "MyModelV2",
        entities: [
            Entity<Animal>("Animal"),
            Entity<Person>("Person")
        ]
    ),
    migrationChain: ["MyModelV1", "MyModelV2"]
)

Initializes a DataStack from a SchemaHistory instance.

CoreStoreDefaults.dataStack = DataStack(
    schemaHistory: SchemaHistory(
        XcodeDataModelSchema(modelName: "MyModelV1"),
        CoreStoreSchema(
            modelVersion: "MyModelV2",
            entities: [
                Entity<Animal>("Animal"),
                Entity<Person>("Person")
            ]
        ),
        migrationChain: ["MyModelV1", "MyModelV2"]
    )
)

Returns the DataStack‘s current model version. StorageInterfaces added to the stack will be migrated to this version.

Returns the DataStack‘s current model schema. StorageInterfaces added to the stack will be migrated to this version.

Returns the entity name-to-class type mapping from the DataStack‘s model.

Returns the entity name-to-class type mapping from the DataStack‘s model.

Returns the NSEntityDescription for the specified NSManagedObject subclass.

Returns the NSEntityDescription for the specified CoreStoreObject subclass.

Returns the NSManagedObjectID for the specified object URI if it exists in the persistent store.

Creates an SQLiteStore with default parameters and adds it to the stack. This method blocks until completion.

try dataStack.addStorageAndWait()

Adds a StorageInterface to the stack and blocks until completion.

try dataStack.addStorageAndWait(InMemoryStore(configuration: "Config1"))

Adds a LocalStorage to the stack and blocks until completion.

try dataStack.addStorageAndWait(SQLiteStore(configuration: "Config1"))

Prepares deinitializing the DataStack by removing all persistent stores. This is not necessary, but can help silence SQLite warnings when actively releasing and recreating DataStacks.

Prepares deinitializing the DataStack by removing all persistent stores. This is not necessary, but can help silence SQLite warnings when actively releasing and recreating DataStacks.

Allow external libraries to store custom data in the DataStack. App code should rarely have a need for this.

enum Static {
   static var myDataKey: Void?
}
CoreStoreDefaults.dataStack.userInfo[&Static.myDataKey] = myObject

Swift concurrency utilities for the DataStack are exposed through this namespace

Swift concurrency for the DataStack are exposed through this namespace. Extend this type if you need to add other async utilities for DataStack.

Creates an ObjectPublisher for the specified DynamicObject. Multiple objects may then register themselves to be notified when changes are made to the DynamicObject.

Creates an ObjectPublisher for a DynamicObject with the specified ObjectID. Multiple objects may then register themselves to be notified when changes are made to the DynamicObject.

Creates a ListPublisher that satisfy the specified FetchChainableBuilderType built from a chain of clauses.

let listPublisher = dataStack.listPublisher(
    From<MyPersonEntity>()
        .where(\.age > 18)
        .orderBy(.ascending(\.age))
)

Multiple objects may then register themselves to be notified when changes are made to the fetched results.

listPublisher.addObserver(self) { (listPublisher) in
    // handle changes
}

Creates a ListPublisher for a sectioned list that satisfy the specified FetchChainableBuilderType built from a chain of clauses.

let listPublisher = dataStack.listPublisher(
    From<MyPersonEntity>()
        .sectionBy(\.age, { "\($0!) years old" })
        .where(\.age > 18)
        .orderBy(.ascending(\.age))
)

Multiple objects may then register themselves to be notified when changes are made to the fetched results.

listPublisher.addObserver(self) { (listPublisher) in
    // handle changes
}

Creates a ListPublisher for the specified From and FetchClauses. Multiple objects may then register themselves to be notified when changes are made to the fetched results.

Creates a ListPublisher for the specified From and FetchClauses. Multiple objects may then register themselves to be notified when changes are made to the fetched results.

Creates a ListPublisher for a sectioned list that satisfy the fetch clauses. Multiple objects may then register themselves to be notified when changes are made to the fetched results.

Creates a ListPublisher for a sectioned list that satisfy the fetch clauses. Multiple objects may then register themselves to be notified when changes are made to the fetched results.

Asynchronously adds a StorageInterface to the stack. Migrations are also initiated by default.

dataStack.addStorage(
    InMemoryStore(configuration: "Config1"),
    completion: { result in
        switch result {
        case .success(let storage): // ...
        case .failure(let error): // ...
        }
    }
)

Asynchronously adds a LocalStorage to the stack. Migrations are also initiated by default.

let migrationProgress = dataStack.addStorage(
    SQLiteStore(fileName: "core_data.sqlite", configuration: "Config1"),
    completion: { result in
        switch result {
        case .success(let storage): // ...
        case .failure(let error): // ...
        }
    }
)

Migrates a local storage to match the DataStack‘s managed object model version. This method does NOT add the migrated store to the data stack.

Checks the migration steps required for the storage to match the DataStack‘s managed object model version.

Creates an ObjectMonitor for the specified DynamicObject. Multiple ObjectObservers may then register themselves to be notified when changes are made to the DynamicObject.

Creates a ListMonitor for a list of DynamicObjects that satisfy the specified fetch clauses. Multiple ListObservers may then register themselves to be notified when changes are made to the list.

Creates a ListMonitor for a list of DynamicObjects that satisfy the specified fetch clauses. Multiple ListObservers may then register themselves to be notified when changes are made to the list.

Creates a ListMonitor for a list of DynamicObjects that satisfy the specified FetchChainableBuilderType built from a chain of clauses.

let monitor = dataStack.monitorList(
    From<MyPersonEntity>()
        .where(\.age > 18)
        .orderBy(.ascending(\.age))
)

Asynchronously creates a ListMonitor for a list of DynamicObjects that satisfy the specified fetch clauses. Multiple ListObservers may then register themselves to be notified when changes are made to the list. Since NSFetchedResultsController greedily locks the persistent store on initial fetch, you may prefer this method instead of the synchronous counterpart to avoid deadlocks while background updates/saves are being executed.

Asynchronously creates a ListMonitor for a list of DynamicObjects that satisfy the specified fetch clauses. Multiple ListObservers may then register themselves to be notified when changes are made to the list. Since NSFetchedResultsController greedily locks the persistent store on initial fetch, you may prefer this method instead of the synchronous counterpart to avoid deadlocks while background updates/saves are being executed.

Asynchronously creates a ListMonitor for a list of DynamicObjects that satisfy the specified FetchChainableBuilderType built from a chain of clauses. Since NSFetchedResultsController greedily locks the persistent store on initial fetch, you may prefer this method instead of the synchronous counterpart to avoid deadlocks while background updates/saves are being executed.

dataStack.monitorList(
    createAsynchronously: { (monitor) in
        self.monitor = monitor
    },
    From<MyPersonEntity>()
        .where(\.age > 18)
        .orderBy(.ascending(\.age))
)

Creates a ListMonitor for a sectioned list of DynamicObjects that satisfy the specified fetch clauses. Multiple ListObservers may then register themselves to be notified when changes are made to the list.

Creates a ListMonitor for a sectioned list of DynamicObjects that satisfy the specified fetch clauses. Multiple ListObservers may then register themselves to be notified when changes are made to the list.

Creates a ListMonitor for a sectioned list of DynamicObjects that satisfy the specified SectionMonitorBuilderType built from a chain of clauses.

let monitor = dataStack.monitorSectionedList(
    From<MyPersonEntity>()
        .sectionBy(\.age, { "\($0!) years old" })
        .where(\.age > 18)
        .orderBy(.ascending(\.age))
)

Asynchronously creates a ListMonitor for a sectioned list of DynamicObjects that satisfy the specified fetch clauses. Multiple ListObservers may then register themselves to be notified when changes are made to the list. Since NSFetchedResultsController greedily locks the persistent store on initial fetch, you may prefer this method instead of the synchronous counterpart to avoid deadlocks while background updates/saves are being executed.

Asynchronously creates a ListMonitor for a sectioned list of DynamicObjects that satisfy the specified fetch clauses. Multiple ListObservers may then register themselves to be notified when changes are made to the list. Since NSFetchedResultsController greedily locks the persistent store on initial fetch, you may prefer this method instead of the synchronous counterpart to avoid deadlocks while background updates/saves are being executed.

Asynchronously creates a ListMonitor for a sectioned list of DynamicObjects that satisfy the specified SectionMonitorBuilderType built from a chain of clauses.

dataStack.monitorSectionedList(
    createAsynchronously: { (monitor) in
        self.monitor = monitor
    },
    From<MyPersonEntity>()
        .sectionBy(\.age, { "\($0!) years old" })
        .where(\.age > 18)
        .orderBy(.ascending(\.age))
)

Fetches the DynamicObject instance in the DataStack‘s context from a reference created from a transaction or from a different managed object context.

Fetches the DynamicObject instance in the DataStack‘s context from an NSManagedObjectID.

Fetches the DynamicObject instances in the DataStack‘s context from references created from a transaction or from a different managed object context.

Fetches the DynamicObject instances in the DataStack‘s context from a list of NSManagedObjectID.

Fetches the first DynamicObject instance that satisfies the specified FetchClauses. Accepts Where, OrderBy, and Tweak clauses.

Fetches the first DynamicObject instance that satisfies the specified FetchClauses. Accepts Where, OrderBy, and Tweak clauses.

Fetches the first DynamicObject instance that satisfies the specified FetchChainableBuilderType built from a chain of clauses.

let youngestTeen = dataStack.fetchOne(
    From<MyPersonEntity>()
        .where(\.age > 18)
        .orderBy(.ascending(\.age))
)

Fetches all DynamicObject instances that satisfy the specified FetchClauses. Accepts Where, OrderBy, and Tweak clauses.

Fetches all DynamicObject instances that satisfy the specified FetchClauses. Accepts Where, OrderBy, and Tweak clauses.

Fetches all DynamicObject instances that satisfy the specified FetchChainableBuilderType built from a chain of clauses.

let people = dataStack.fetchAll(
    From<MyPersonEntity>()
        .where(\.age > 18)
        .orderBy(.ascending(\.age))
)

Fetches the number of DynamicObjects that satisfy the specified FetchClauses. Accepts Where, OrderBy, and Tweak clauses.

Fetches the number of DynamicObjects that satisfy the specified FetchClauses. Accepts Where, OrderBy, and Tweak clauses.

Fetches the number of DynamicObjects that satisfy the specified FetchChainableBuilderType built from a chain of clauses.

let numberOfAdults = dataStack.fetchCount(
    From<MyPersonEntity>()
        .where(\.age > 18)
        .orderBy(.ascending(\.age))
)

Fetches the NSManagedObjectID for the first DynamicObject that satisfies the specified FetchClauses. Accepts Where, OrderBy, and Tweak clauses.

Fetches the NSManagedObjectID for the first DynamicObject that satisfies the specified FetchClauses. Accepts Where, OrderBy, and Tweak clauses.

Fetches the NSManagedObjectID for the first DynamicObject that satisfies the specified FetchChainableBuilderType built from a chain of clauses.

let youngestTeenID = dataStack.fetchObjectID(
    From<MyPersonEntity>()
        .where(\.age > 18)
        .orderBy(.ascending(\.age))
)

Fetches the NSManagedObjectID for all DynamicObjects that satisfy the specified FetchClauses. Accepts Where, OrderBy, and Tweak clauses.

Fetches the NSManagedObjectID for all DynamicObjects that satisfy the specified FetchClauses. Accepts Where, OrderBy, and Tweak clauses.

Fetches the NSManagedObjectID for all DynamicObjects that satisfy the specified FetchChainableBuilderType built from a chain of clauses.

let idsOfAdults = dataStack.fetchObjectIDs(
    From<MyPersonEntity>()
        .where(\.age > 18)
        .orderBy(.ascending(\.age))
)

Queries aggregate values as specified by the QueryClauses. Requires at least a Select clause, and optional Where, OrderBy, GroupBy, and Tweak clauses.

A “query” differs from a “fetch” in that it only retrieves values already stored in the persistent store. As such, values from unsaved transactions or contexts will not be incorporated in the query result.

Queries aggregate values as specified by the QueryClauses. Requires at least a Select clause, and optional Where, OrderBy, GroupBy, and Tweak clauses.

A “query” differs from a “fetch” in that it only retrieves values already stored in the persistent store. As such, values from unsaved transactions or contexts will not be incorporated in the query result.

Queries a property value or aggregate as specified by the QueryChainableBuilderType built from a chain of clauses.

A “query” differs from a “fetch” in that it only retrieves values already stored in the persistent store. As such, values from unsaved transactions or contexts will not be incorporated in the query result.

let averageAdultAge = dataStack.queryValue(
    From<MyPersonEntity>()
        .select(Int.self, .average(\.age))
        .where(\.age > 18)
)

Queries a dictionary of attribute values as specified by the QueryClauses. Requires at least a Select clause, and optional Where, OrderBy, GroupBy, and Tweak clauses.

A “query” differs from a “fetch” in that it only retrieves values already stored in the persistent store. As such, values from unsaved transactions or contexts will not be incorporated in the query result.

Queries a dictionary of attribute values as specified by the QueryClauses. Requires at least a Select clause, and optional Where, OrderBy, GroupBy, and Tweak clauses.

A “query” differs from a “fetch” in that it only retrieves values already stored in the persistent store. As such, values from unsaved transactions or contexts will not be incorporated in the query result.

Queries a dictionary of attribute values or as specified by the QueryChainableBuilderType built from a chain of clauses.

A “query” differs from a “fetch” in that it only retrieves values already stored in the persistent store. As such, values from unsaved transactions or contexts will not be incorporated in the query result.

let results = dataStack.queryAttributes(
    From<MyPersonEntity>()
        .select(
            NSDictionary.self,
            .attribute(\.age, as: "age"),
            .count(\.age, as: "numberOfPeople")
        )
        .groupBy(\.age)
)
for dictionary in results! {
    let age = dictionary["age"] as! Int
    let count = dictionary["numberOfPeople"] as! Int
    print("There are \(count) people who are \(age) years old."
}

The internal NSManagedObjectContext managed by this instance. Using this context directly should typically be avoided, and is provided by CoreStore only for extremely specialized cases.

Combine utilities for the DataStack are exposed through this namespace

Combine utilities for the DataStack are exposed through this namespace. Extend this type if you need to add other Combine Publisher utilities for DataStack.

Performs a transaction asynchronously where NSManagedObject or CoreStoreObject creates, updates, and deletes can be made. The changes are commited automatically after the task closure returns. On success, the value returned from closure will be the wrapped as .success(T) in the completion‘s Result<T>. Any errors thrown from inside the task will be reported as .failure(CoreStoreError). To cancel/rollback changes, call try transaction.cancel(), which throws a CoreStoreError.userCancelled.

Performs a transaction asynchronously where NSManagedObject or CoreStoreObject creates, updates, and deletes can be made. The changes are commited automatically after the task closure returns. On success, the value returned from closure will be the argument of the success closure. Any errors thrown from inside the task will be wrapped in a CoreStoreError and reported in the failure closure. To cancel/rollback changes, call try transaction.cancel(), which throws a CoreStoreError.userCancelled.

Performs a transaction synchronously where NSManagedObject or CoreStoreObject creates, updates, and deletes can be made. The changes are commited automatically after the task closure returns. On success, the value returned from closure will be the return value of perform(synchronous:). Any errors thrown from inside the task will be thrown from perform(synchronous:). To cancel/rollback changes, call try transaction.cancel(), which throws a CoreStoreError.userCancelled.

Begins a non-contiguous transaction where NSManagedObject or CoreStoreObject creates, updates, and deletes can be made. This is useful for making temporary changes, such as partially filled forms.

Refreshes all registered objects NSManagedObjects or CoreStoreObjects in the DataStack.

A Publisher that emits a ListSnapshot whenever changes occur in the ListPublisher.

Utility for creating an NSFetchedResultsController from the DataStack. This is useful when an NSFetchedResultsController is preferred over the overhead of ListMonitors abstraction.

Utility for creating an NSFetchedResultsController from a DataStack. This is useful when an NSFetchedResultsController is preferred over the overhead of ListMonitors abstraction.

Utility for creating an NSFetchedResultsController from the DataStack. This is useful when an NSFetchedResultsController is preferred over the overhead of ListMonitors abstraction.

Utility for creating an NSFetchedResultsController from the DataStack. This is useful when an NSFetchedResultsController is preferred over the overhead of ListMonitors abstraction.