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.

It is a programmer error to call this method from another database access method:

try writer.write { db in
    // Raises a fatal error
    try writer.write { ... )
}

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.

It is a programmer error to call this method from another database access method:

try writer.write { db in
    // Raises a fatal error
    try writer.writeWithoutTransaction { ... )
}

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

Updates are guaranteed an exclusive access to the database. They wait until all pending writes and reads are completed. They postpone all other writes and reads until they are completed.

It is a programmer error to call this method from another database access method:

try writer.write { db in
    // Raises a fatal error
    try writer.barrierWriteWithoutTransaction { ... )
}

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

Updates are guaranteed an exclusive access to the database. They wait until all pending writes and reads are completed. They postpone all other writes and reads until they are completed.

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:).

Undocumented

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.

Creates a new database file at the specified path with a minimum amount of disk space.

Databases encrypted with SQLCipher are copied with the same password and configuration as the original database.

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

Creates a new database file at the specified path with a minimum amount of disk space. See https://www.sqlite.org/lang_vacuum.html#vacuuminto for more information.

Asynchronously executes database updates, wrapped inside a transaction, and returns the result.

Experimental

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

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

Asynchronously executes database updates, outside of any transaction, and returns the result.

Experimental

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

Asynchronously executes database updates, outside of any transaction, and returns the result.

Experimental

Updates are guaranteed an exclusive access to the database. They wait until all pending writes and reads are completed. They postpone all other writes and reads until they are completed.

Erases the content of the database.

Experimental

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

Experimental

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

Creates a new database file at the specified path with a minimum amount of disk space.

Experimental

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

Returns a Publisher that asynchronously writes into the database.

// DatabasePublishers.Write<Int>
let newPlayerCount = dbQueue.writePublisher { db -> Int in
    try Player(...).insert(db)
    return try Player.fetchCount(db)
}

Its value and completion are emitted on the main dispatch queue.

Returns a Publisher that asynchronously writes into the database.

// DatabasePublishers.Write<Int>
let newPlayerCount = dbQueue.writePublisher(
    receiveOn: DispatchQueue.global(),
    updates: { db -> Int in
        try Player(...).insert(db)
        return try Player.fetchCount(db)
    })

Its value and completion are emitted on scheduler.

Returns a Publisher that asynchronously writes into the database.

// DatabasePublishers.Write<Int>
let newPlayerCount = dbQueue.writePublisher(
    updates: { db in try Player(...).insert(db) }
    thenRead: { db, _ in try Player.fetchCount(db) })

Its value and completion are emitted on the main dispatch queue.

Returns a Publisher that asynchronously writes into the database.

// DatabasePublishers.Write<Int>
let newPlayerCount = dbQueue.writePublisher(
    receiveOn: DispatchQueue.global(),
    updates: { db in try Player(...).insert(db) }
    thenRead: { db, _ in try Player.fetchCount(db) })

Its value and completion are emitted on scheduler.