DatabaseWriter

Synchronously executes database updates in a protected dispatch queue, wrapped inside a transaction, and returns the result.

If the updates throw an error, the transaction is rollbacked and the error is rethrown.

Eventual concurrent database updates are postponed until the transaction has completed.

Eventual concurrent reads are guaranteed to not see any partial updates of the database until the transaction has completed.

This method is not reentrant.

Synchronously executes database updates in a protected dispatch queue, outside of any transaction, and returns the result.

Eventual concurrent database updates are postponed until the updates are completed.

Eventual concurrent reads may see partial updates unless you wrap them in a transaction.

This method is not reentrant.

Asynchronously executes database updates in a protected dispatch queue, wrapped inside a transaction.

If the updates throw an error, the transaction is rollbacked.

The completion closure is always called with the result of the database updates. Its arguments are a database connection and the result of the transaction. This result is a failure if the transaction could not be committed.

Eventual concurrent database updates are postponed until the transaction and the completion closure have completed.

Eventual concurrent reads are guaranteed to not see any partial updates of the database until the transaction has completed.

This method is not reentrant.

Asynchronously executes database updates in a protected dispatch queue, outside of any transaction.

Eventual concurrent reads may see partial updates unless you wrap them in a transaction.

Synchronously executes database updates in a protected dispatch queue, outside of any transaction, and returns the result.

Eventual concurrent database updates are postponed until the updates are completed.

Eventual concurrent reads may see partial updates unless you wrap them in a transaction.

This method is reentrant. It should be avoided because it fosters dangerous concurrency practices.

Concurrently executes a read-only block in a protected dispatch queue.

This method must be called from a writing dispatch queue, outside of any transaction. You’ll get a fatal error otherwise.

The block argument is guaranteed to see the database in the last committed state at the moment this method is called. Eventual concurrent database updates are not visible inside the block.

To access the fetched results, you call the wait() method of the returned future, on any dispatch queue.

In the example below, the number of players is fetched concurrently with the player insertion. Yet the future is guaranteed to return zero:

try writer.writeWithoutTransaction { db in
    // Delete all players
    try Player.deleteAll()

    // Count players concurrently
    let future = writer.concurrentRead { db in
        return try Player.fetchCount()
    }

    // Insert a player
    try Player(...).insert(db)

    // Guaranteed to be zero
    let count = try future.wait()
}

Add a transaction observer, so that it gets notified of database changes.

To remove the observer, use DatabaseReader.remove(transactionObserver:).

Erases the content of the database.

Rebuilds the database file, repacking it into a minimal amount of disk space.

See https://www.sqlite.org/lang_vacuum.html for more information.