# UnsafeDataTransaction

    public final class UnsafeDataTransaction : BaseDataTransaction

    extension UnsafeDataTransaction: CustomDebugStringConvertible, CoreStoreDebugStringConvertible

The `UnsafeDataTransaction` provides an interface for non-contiguous `NSManagedObject` or `CoreStoreObject` creates, updates, and deletes. This is useful for making temporary changes, such as partially filled forms. An unsafe transaction object should typically be only used from the main queue.

- `commit(_:)`

  Saves the transaction changes asynchronously. For an `UnsafeDataTransaction`, multiple commits are allowed, although it is the developer’s responsibility to ensure a reasonable leeway to prevent blocking the main thread.

  #### Declaration

  Swift

      public func commit(_ completion: @escaping (_ error: CoreStoreError?) -> Void)

  #### Parameters

  `completion` | the block executed after the save completes. Success or failure is reported by the optional `error` argument of the block.

- `commitAndWait()`

  Saves the transaction changes and waits for completion synchronously. For an `UnsafeDataTransaction`, multiple commits are allowed, although it is the developer’s responsibility to ensure a reasonable leeway to prevent blocking the main thread.

  Throws

  a `CoreStoreError` value indicating the failure.

  #### Declaration

  Swift

      public func commitAndWait() throws

- `rollback()`

  Rolls back the transaction.

  #### Declaration

  Swift

      public func rollback()

- `undo()`

  Undo’s the last change made to the transaction.

  #### Declaration

  Swift

      public func undo()

- `flush()`

  Immediately flushes all pending changes to the transaction’s observers. This is useful in conjunction with `ListMonitor`s and `ObjectMonitor`s created from `UnsafeDataTransaction`s used to manage temporary “scratch” data.

  Important

  Note that unlike `commit()`, `flush()` does not propagate/save updates to the `DataStack` and the persistent store. However, the flushed changes will be seen by children transactions created further from the current transaction (i.e. through `transaction.beginUnsafe()`)

  Throws

  an error thrown from `closure`, or an error thrown by Core Data (usually validation errors or conflict errors)

  #### Declaration

  Swift

      public func flush()

- `flush(closure:)`

  Flushes all pending changes to the transaction’s observers at the end of the `closure`‘s execution. This is useful in conjunction with `ListMonitor`s and `ObjectMonitor`s created from `UnsafeDataTransaction`s used to manage temporary “scratch” data.

  Important

  Note that unlike `commit()`, `flush()` does not propagate/save updates to the `DataStack` and the persistent store. However, the flushed changes will be seen by children transactions created further from the current transaction (i.e. through `transaction.beginUnsafe()`)

  Throws

  an error thrown from `closure`, or an error thrown by Core Data (usually validation errors or conflict errors)

  #### Declaration

  Swift

      public func flush(closure: () throws -> Void) rethrows

  #### Parameters

  `closure` | the closure where changes can be made prior to the flush

- `redo()`

  Redo’s the last undone change to the transaction.

  #### Declaration

  Swift

      public func redo()

- `beginUnsafe(supportsUndo:sourceIdentifier:)`

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

  #### Declaration

  Swift

      public func beginUnsafe(
          supportsUndo: Bool = false,
          sourceIdentifier: Any? = nil
      ) -> UnsafeDataTransaction

  #### Parameters

  `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.
  `sourceIdentifier` | an optional value that identifies the source of this transaction. This identifier will be passed to the change notifications and callers can use it for custom handling that depends on the source.

  #### Return Value

  an `UnsafeDataTransaction` instance where creates, updates, and deletes can be made.

### CustomDebugStringConvertible

- `debugDescription`

  #### Declaration

  Swift

      public var debugDescription: String { get }

### UnsafeDataTransaction

- `createFetchedResultsController(_:_:_:)`

  Utility for creating an `NSFetchedResultsController` from the `UnsafeDataTransaction`. This is useful when an `NSFetchedResultsController` is preferred over the overhead of `ListMonitor`s abstraction.

  Note

  It is the caller’s responsibility to call `performFetch()` on the created `NSFetchedResultsController`.

  #### Declaration

  Swift

      @nonobjc
      public func createFetchedResultsController<O>(_ from: From<O>, _ sectionBy: SectionBy<O>, _ fetchClauses: FetchClause...) -> NSFetchedResultsController<O> where O : NSManagedObject

  #### Parameters

  `from` | a `From` clause indicating the entity type
  `sectionBy` | a `SectionBy` clause indicating the keyPath for the attribute to use when sorting the list into sections
  `fetchClauses` | a series of `FetchClause` instances for fetching the object list. Accepts `Where`, `OrderBy`, and `Tweak` clauses.

  #### Return Value

  an `NSFetchedResultsController` that observes the `UnsafeDataTransaction`

- `createFetchedResultsController(_:_:_:)`

  Utility for creating an `NSFetchedResultsController` from the `UnsafeDataTransaction`. This is useful when an `NSFetchedResultsController` is preferred over the overhead of `ListMonitor`s abstraction.

  Note

  It is the caller’s responsibility to call `performFetch()` on the created `NSFetchedResultsController`.

  #### Declaration

  Swift

      @nonobjc
      public func createFetchedResultsController<O>(_ from: From<O>, _ sectionBy: SectionBy<O>, _ fetchClauses: [FetchClause]) -> NSFetchedResultsController<O> where O : NSManagedObject

  #### Parameters

  `from` | a `From` clause indicating the entity type
  `sectionBy` | a `SectionBy` clause indicating the keyPath for the attribute to use when sorting the list into sections
  `fetchClauses` | a series of `FetchClause` instances for fetching the object list. Accepts `Where`, `OrderBy`, and `Tweak` clauses.

  #### Return Value

  an `NSFetchedResultsController` that observes the `UnsafeDataTransaction`

- `createFetchedResultsController(_:_:)`

  Utility for creating an `NSFetchedResultsController` from the `UnsafeDataTransaction`. This is useful when an `NSFetchedResultsController` is preferred over the overhead of `ListMonitor`s abstraction.

  Note

  It is the caller’s responsibility to call `performFetch()` on the created `NSFetchedResultsController`.

  #### Declaration

  Swift

      @nonobjc
      public func createFetchedResultsController<O>(_ from: From<O>, _ fetchClauses: FetchClause...) -> NSFetchedResultsController<O> where O : NSManagedObject

  #### Parameters

  `from` | a `From` clause indicating the entity type
  `fetchClauses` | a series of `FetchClause` instances for fetching the object list. Accepts `Where`, `OrderBy`, and `Tweak` clauses.

  #### Return Value

  an `NSFetchedResultsController` that observes the `UnsafeDataTransaction`

- `createFetchedResultsController(_:_:)`

  Utility for creating an `NSFetchedResultsController` from the `UnsafeDataTransaction`. This is useful when an `NSFetchedResultsController` is preferred over the overhead of `ListMonitor`s abstraction.

  Note

  It is the caller’s responsibility to call `performFetch()` on the created `NSFetchedResultsController`.

  #### Declaration

  Swift

      @nonobjc
      public func createFetchedResultsController<O>(_ from: From<O>, _ fetchClauses: [FetchClause]) -> NSFetchedResultsController<O> where O : NSManagedObject

  #### Parameters

  `from` | a `From` clause indicating the entity type
  `fetchClauses` | a series of `FetchClause` instances for fetching the object list. Accepts `Where`, `OrderBy`, and `Tweak` clauses.

  #### Return Value

  an `NSFetchedResultsController` that observes the `UnsafeDataTransaction`

- `monitorObject(_:)`

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

  #### Declaration

  Swift

      public func monitorObject<O>(_ object: O) -> ObjectMonitor<O> where O : DynamicObject

  #### Parameters

  `object` | the `DynamicObject` to observe changes from

  #### Return Value

  an `ObjectMonitor` that monitors changes to `object`

- `monitorList(_:_:)`

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

  #### Declaration

  Swift

      public func monitorList<O>(_ from: From<O>, _ fetchClauses: FetchClause...) -> ListMonitor<O> where O : DynamicObject

  #### Parameters

  `from` | a `From` clause indicating the entity type
  `fetchClauses` | a series of `FetchClause` instances for fetching the object list. Accepts `Where`, `OrderBy`, and `Tweak` clauses.

  #### Return Value

  a `ListMonitor` instance that monitors changes to the list

- `monitorList(_:_:)`

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

  #### Declaration

  Swift

      public func monitorList<O>(_ from: From<O>, _ fetchClauses: [FetchClause]) -> ListMonitor<O> where O : DynamicObject

  #### Parameters

  `from` | a `From` clause indicating the entity type
  `fetchClauses` | a series of `FetchClause` instances for fetching the object list. Accepts `Where`, `OrderBy`, and `Tweak` clauses.

  #### Return Value

  a `ListMonitor` instance that monitors changes to the list

- `monitorList(_:)`

  Asynchronously creates a `ListMonitor` for a list of `DynamicObject`s 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.

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

  #### Declaration

  Swift

      public func monitorList<B>(_ clauseChain: B) -> ListMonitor<B.ObjectType> where B : FetchChainableBuilderType

  #### Parameters

  `createAsynchronously` | the closure that receives the created `ListMonitor` instance
  `clauseChain` | a `FetchChainableBuilderType` built from a chain of clauses

  #### Return Value

  a `ListMonitor` for a list of `DynamicObject`s that satisfy the specified `FetchChainableBuilderType`

- `monitorList(createAsynchronously:_:_:)`

  Asynchronously creates a `ListMonitor` for a list of `DynamicObject`s that satisfy the specified fetch clauses. Multiple `ListObserver`s 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.

  #### Declaration

  Swift

      public func monitorList<O>(createAsynchronously: @escaping (ListMonitor<O>) -> Void, _ from: From<O>, _ fetchClauses: FetchClause...) where O : DynamicObject

  #### Parameters

  `createAsynchronously` | the closure that receives the created `ListMonitor` instance
  `from` | a `From` clause indicating the entity type
  `fetchClauses` | a series of `FetchClause` instances for fetching the object list. Accepts `Where`, `OrderBy`, and `Tweak` clauses.

- `monitorList(createAsynchronously:_:_:)`

  Asynchronously creates a `ListMonitor` for a list of `DynamicObject`s that satisfy the specified fetch clauses. Multiple `ListObserver`s 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.

  #### Declaration

  Swift

      public func monitorList<O>(createAsynchronously: @escaping (ListMonitor<O>) -> Void, _ from: From<O>, _ fetchClauses: [FetchClause]) where O : DynamicObject

  #### Parameters

  `createAsynchronously` | the closure that receives the created `ListMonitor` instance
  `from` | a `From` clause indicating the entity type
  `fetchClauses` | a series of `FetchClause` instances for fetching the object list. Accepts `Where`, `OrderBy`, and `Tweak` clauses.

- `monitorList(createAsynchronously:_:)`

  Asynchronously creates a `ListMonitor` for a list of `DynamicObject`s 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))
      )

  #### Declaration

  Swift

      public func monitorList<B>(createAsynchronously: @escaping (ListMonitor<B.ObjectType>) -> Void, _ clauseChain: B) where B : FetchChainableBuilderType

  #### Parameters

  `createAsynchronously` | the closure that receives the created `ListMonitor` instance
  `clauseChain` | a `FetchChainableBuilderType` built from a chain of clauses

- `monitorSectionedList(_:_:_:)`

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

  #### Declaration

  Swift

      public func monitorSectionedList<O>(_ from: From<O>, _ sectionBy: SectionBy<O>, _ fetchClauses: FetchClause...) -> ListMonitor<O> where O : DynamicObject

  #### Parameters

  `from` | a `From` clause indicating the entity type
  `sectionBy` | a `SectionBy` clause indicating the keyPath for the attribute to use when sorting the list into sections.
  `fetchClauses` | a series of `FetchClause` instances for fetching the object list. Accepts `Where`, `OrderBy`, and `Tweak` clauses.

  #### Return Value

  a `ListMonitor` instance that monitors changes to the list

- `monitorSectionedList(_:_:_:)`

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

  #### Declaration

  Swift

      public func monitorSectionedList<O>(_ from: From<O>, _ sectionBy: SectionBy<O>, _ fetchClauses: [FetchClause]) -> ListMonitor<O> where O : DynamicObject

  #### Parameters

  `from` | a `From` clause indicating the entity type
  `sectionBy` | a `SectionBy` clause indicating the keyPath for the attribute to use when sorting the list into sections.
  `fetchClauses` | a series of `FetchClause` instances for fetching the object list. Accepts `Where`, `OrderBy`, and `Tweak` clauses.

  #### Return Value

  a `ListMonitor` instance that monitors changes to the list

- `monitorSectionedList(_:)`

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

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

  #### Declaration

  Swift

      public func monitorSectionedList<B>(_ clauseChain: B) -> ListMonitor<B.ObjectType> where B : SectionMonitorBuilderType

  #### Parameters

  `clauseChain` | a `SectionMonitorBuilderType` built from a chain of clauses

  #### Return Value

  a `ListMonitor` for a list of `DynamicObject`s that satisfy the specified `SectionMonitorBuilderType`

- `monitorSectionedList(createAsynchronously:_:_:_:)`

  Asynchronously creates a `ListMonitor` for a sectioned list of `DynamicObject`s that satisfy the specified fetch clauses. Multiple `ListObserver`s 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.

  #### Declaration

  Swift

      public func monitorSectionedList<O>(createAsynchronously: @escaping (ListMonitor<O>) -> Void, _ from: From<O>, _ sectionBy: SectionBy<O>, _ fetchClauses: FetchClause...) where O : DynamicObject

  #### Parameters

  `createAsynchronously` | the closure that receives the created `ListMonitor` instance
  `from` | a `From` clause indicating the entity type
  `sectionBy` | a `SectionBy` clause indicating the keyPath for the attribute to use when sorting the list into sections.
  `fetchClauses` | a series of `FetchClause` instances for fetching the object list. Accepts `Where`, `OrderBy`, and `Tweak` clauses.

- `monitorSectionedList(createAsynchronously:_:_:_:)`

  Asynchronously creates a `ListMonitor` for a sectioned list of `DynamicObject`s that satisfy the specified fetch clauses. Multiple `ListObserver`s 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.

  #### Declaration

  Swift

      public func monitorSectionedList<O>(createAsynchronously: @escaping (ListMonitor<O>) -> Void, _ from: From<O>, _ sectionBy: SectionBy<O>, _ fetchClauses: [FetchClause]) where O : DynamicObject

  #### Parameters

  `createAsynchronously` | the closure that receives the created `ListMonitor` instance
  `from` | a `From` clause indicating the entity type
  `sectionBy` | a `SectionBy` clause indicating the keyPath for the attribute to use when sorting the list into sections.
  `fetchClauses` | a series of `FetchClause` instances for fetching the object list. Accepts `Where`, `OrderBy`, and `Tweak` clauses.

- `monitorSectionedList(createAsynchronously:_:)`

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

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

  #### Declaration

  Swift

      public func monitorSectionedList<B>(createAsynchronously: @escaping (ListMonitor<B.ObjectType>) -> Void, _ clauseChain: B) where B : SectionMonitorBuilderType

  #### Parameters

  `createAsynchronously` | the closure that receives the created `ListMonitor` instance
  `clauseChain` | a `SectionMonitorBuilderType` built from a chain of clauses