BaseDataTransaction

Indicates if the transaction has pending changes

Creates a new NSManagedObject or CoreStoreObject with the specified entity type.

Returns an editable proxy of a specified NSManagedObject or CoreStoreObject.

Returns an editable proxy of the object with the specified NSManagedObjectID.

Deletes the objects with the specified NSManagedObjectIDs.

Deletes the specified NSManagedObjects or CoreStoreObjects represented by series of ObjectRepresentations.

Deletes the specified NSManagedObjects or CoreStoreObjects represented by an ObjectRepresenation.

Refreshes all registered objects NSManagedObjects in the transaction.

Returns true if the object has any property values changed. This method should not be called after the commit() method was called.

Returns all pending DynamicObjects of the specified type that were inserted to the transaction. This method should not be called after the commit() method was called.

Returns all pending NSManagedObjectIDs that were inserted to the transaction. This method should not be called after the commit() method was called.

Returns all pending NSManagedObjectIDs of the specified type that were inserted to the transaction. This method should not be called after the commit() method was called.

Returns all pending DynamicObjects of the specified type that were updated in the transaction. This method should not be called after the commit() method was called.

Returns all pending NSManagedObjectIDs that were updated in the transaction. This method should not be called after the commit() method was called.

Returns all pending NSManagedObjectIDs of the specified type that were updated in the transaction. This method should not be called after the commit() method was called.

Returns all pending DynamicObjects of the specified type that were deleted from the transaction. This method should not be called after the commit() method was called.

Returns all pending NSManagedObjectIDs of the specified type that were deleted from the transaction. This method should not be called after the commit() method was called.

Returns all pending NSManagedObjectIDs of the specified type that were deleted from the transaction. This method should not be called after the commit() method was called.

An arbitrary value that identifies the source of this transaction. Callers of the transaction can provide this value through the DataStack.perform(...) methods.

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

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

Creates an ImportableObject by importing from the specified import source.

Updates an existing ImportableObject by importing values from the specified import source.

Creates multiple ImportableObjects by importing from the specified array of import sources.

Updates an existing ImportableUniqueObject or creates a new instance by importing from the specified import source.

Updates existing ImportableUniqueObjects or creates them by importing from the specified array of import sources. ImportableUniqueObject methods are called on the objects in the same order as they are in the sourceArray, and are returned in an array with that same order.

Deletes all DynamicObjects that satisfy the specified DeleteClauses. Accepts Where, OrderBy, and Tweak clauses.

Deletes all DynamicObjects that satisfy the specified DeleteClauses. Accepts Where, OrderBy, and Tweak clauses.

Deletes all DynamicObjects that satisfy the specified conditions.

transaction.deleteAll(From<Person>().where(\.age > 50))

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

Fetches the DynamicObject instance in the transaction’s context from an NSManagedObjectID.

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

Fetches the DynamicObject instances in the transaction’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 = transaction.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 = transaction.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 = transaction.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 = transaction.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 = transaction.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 or aggregates 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 = transaction.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.