CoreStore

The default DataStack instance to be used. If defaultStack is not set before the first time accessed, a default-configured DataStack will be created.

The CoreStoreLogger instance to be used. The default logger is an instance of a DefaultLogger.

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

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

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

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

Asynchronously adds a CloudStorage to the defaultStack. Migrations are also initiated by default.

guard let storage = ICloudStore(
    ubiquitousContentName: "MyAppCloudData",
    ubiquitousContentTransactionLogsSubdirectory: "logs/config1",
    ubiquitousContainerID: "iCloud.com.mycompany.myapp.containername",
    ubiquitousPeerToken: "9614d658014f4151a95d8048fb717cf0",
    configuration: "Config1",
    cloudStorageOptions: .recreateLocalStoreOnModelMismatch
) else {
    // iCloud is not available on the device
    return
}
let migrationProgress = dataStack.addStorage(
    storage,
    completion: { result in
        switch result {
        case .success(let storage): // ...
        case .failure(let error): // ...
        }
    }
)

Migrates a local storage to match the defaultStack‘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 defaultStack‘s managed object model version.

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

Using the defaultStack, 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.

Using the defaultStack, 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 = CoreStore.monitorList(
    From<MyPersonEntity>()
        .where(\.age > 18)
        .orderBy(.ascending(\.age))
)

Using the defaultStack, 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.

Using the defaultStack, 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.

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

Using the defaultStack, 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.

Using the defaultStack, 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 = CoreStore.monitorSectionedList(
    From<MyPersonEntity>()
        .sectionBy(\.age, { "\($0!) years old" })
        .where(\.age > 18)
        .orderBy(.ascending(\.age))
)

Using the defaultStack, 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.

Using the defaultStack, 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.

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

Using the defaultStack, fetches the DynamicObject instance in the DataStack‘s context from a reference created from a transaction or from a different managed object context.

Using the defaultStack, fetches the DynamicObject instance in the DataStack‘s context from an NSManagedObjectID.

Using the defaultStack, fetches the DynamicObject instances in the DataStack‘s context from references created from a transaction or from a different managed object context.

Using the defaultStack, fetches the DynamicObject instances in the DataStack‘s context from a list of NSManagedObjectID.

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

Using the defaultStack, 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 = CoreStore.fetchOne(
    From<MyPersonEntity>()
        .where(\.age > 18)
        .orderBy(.ascending(\.age))
)

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

Using the defaultStack, 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 = CoreStore.fetchAll(
    From<MyPersonEntity>()
        .where(\.age > 18)
        .orderBy(.ascending(\.age))
)

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

Using the defaultStack, 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 = CoreStore.fetchCount(
    From<MyPersonEntity>()
        .where(\.age > 18)
        .orderBy(.ascending(\.age))
)

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

Using the defaultStack, 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 = CoreStore.fetchObjectID(
    From<MyPersonEntity>()
        .where(\.age > 18)
        .orderBy(.ascending(\.age))
)

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

Using the defaultStack, 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 = transaction.fetchObjectIDs(
    From<MyPersonEntity>()
        .where(\.age > 18)
        .orderBy(.ascending(\.age))
)

Using the defaultStack, 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.

Using the defaultStack, 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 = CoreStore.queryValue(
    From<MyPersonEntity>()
        .select(Int.self, .average(\.age))
        .where(\.age > 18)
)

Using the defaultStack, 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.

Using the defaultStack, 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 = CoreStore.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."
}

Returns the defaultStack‘s model version. The version string is the same as the name of a version-specific .xcdatamodeld file or CoreStoreSchema.

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

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

Returns the NSEntityDescription for the specified NSManagedObject subclass from defaultStack‘s model.

Returns the NSEntityDescription for the specified CoreStoreObject subclass from defaultStack‘s model.

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

try CoreStore.addStorageAndWait()

Adds a StorageInterface to the defaultStack and blocks until completion.

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

Adds a LocalStorage to the defaultStack and blocks until completion.

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

Adds a CloudStorage to the defaultStack and blocks until completion.

guard let storage = ICloudStore(
    ubiquitousContentName: "MyAppCloudData",
    ubiquitousContentTransactionLogsSubdirectory: "logs/config1",
    ubiquitousContainerID: "iCloud.com.mycompany.myapp.containername",
    ubiquitousPeerToken: "9614d658014f4151a95d8048fb717cf0",
    configuration: "Config1",
    cloudStorageOptions: .recreateLocalStoreOnModelMismatch
) else {
    // iCloud is not available on the device
    return
}
try CoreStore.addStorageAndWait(storage)

Using the defaultStack, 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.

Using the defaultStack, 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.

Using the defaultStack, 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.

Using the defaultStack, 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.

• prameter supportsUndo: undo(), redo(), and rollback() methods are only available when this parameter is true, otherwise those method will raise an exception. Defaults to false. Note that turning on Undo support may heavily impact performance especially on iOS or watchOS where memory is limited.

Refreshes all registered objects NSManagedObjects or CoreStoreObjects in the defaultStack.