Struct places::db::tx::coop_transaction::ChunkedCoopTransaction

pub struct ChunkedCoopTransaction<'conn> {
    tx: UncheckedTransaction<'conn>,
    commit_after: Duration,
    coop: &'conn Mutex<()>,
}

This transaction is suitable for when a transaction is used purely for performance reasons rather than for data-integrity reasons, or when it's used for integrity but held longer than strictly necessary for performance reasons (ie, when it could be multiple transactions and still guarantee integrity.) Examples of this might be for performance when updating a larger number of rows, but data integrity concerns could be addressed by using multiple, smaller transactions.

You should regularly call .maybe_commit() as part of your processing, and if the current transaction has been open for greater than some duration the transaction will be committed and another one started. You should always call .commit() at the end. Note that there is no .rollback() method as it will be very difficult to work out what was previously commited and therefore what was rolled back - if you need to explicitly roll-back, this probably isn't what you should be using. Note that SQLite might rollback for its own reasons though.

Note that this can still be used for transactions which ensure data integrity. For example, if you are processing a large group of items, and each individual item requires multiple updates, you will probably want to ensure you call .maybe_commit() after every item rather than after each individual database update.

Fields

tx: UncheckedTransaction<'conn>

commit_after: Duration

coop: &'conn Mutex<()>

Implementations

impl<'conn> ChunkedCoopTransaction<'conn>

pub fn new(
    conn: &'conn Connection,
    commit_after: Duration,
    coop: &'conn Mutex<()>
) -> Result<Self>

Begin a new transaction which may be split into multiple transactions for performance reasons. Cannot be nested, but this is not enforced - however, it is enforced by SQLite; use a rusqlite savepoint for nested transactions.

pub fn should_commit(&self) -> bool

Returns true if the current transaction has been open for longer than the requested time, and should be committed; false otherwise. In most cases, there's no need to use this method, since maybe_commit() does so internally. It's exposed for consumers that need to run additional pre-commit logic, like cleaning up temp tables.

If this method returns true, it's guaranteed that maybe_commit() will commit the transaction.

pub fn maybe_commit(&mut self) -> Result<()>

Checks to see if we have held a transaction for longer than the requested time, and if so, commits the current transaction and opens another.

fn commit_and_start_new_tx(&mut self) -> Result<()>

pub fn commit(self) -> Result<()>

Consumes and commits a ChunkedCoopTransaction transaction.

pub fn rollback(self) -> Result<()>

Consumes and rolls a ChunkedCoopTransaction, but potentially only back to the last maybe_commit.

Trait Implementations

impl<'conn> ConnExt for ChunkedCoopTransaction<'conn>

fn conn(&self) -> &Connection

The method you need to implement to opt in to all of this.

fn set_pragma<T>(
    &self,
    pragma_name: &str,
    pragma_value: T
) -> Result<&Self, Error> where
    T: ToSql, 

Set the value of the pragma on the main database. Returns the same object, for chaining.

fn prepare_maybe_cached(
    &'conn self,
    sql: &str,
    cache: bool
) -> Result<MaybeCached<'conn>, Error>

Get a cached or uncached statement based on a flag.

fn execute_all(&self, stmts: &[&str]) -> Result<(), Error>

Execute all the provided statements.

fn execute_cached<P>(&self, sql: &str, params: P) -> Result<usize, Error> where
    P: IntoIterator,
    <P as IntoIterator>::Item: ToSql, 

Equivalent to Connection::execute_named but caches the statement so that subsequent calls to execute_cached will have improved performance.

fn execute_named_cached(
    &self,
    sql: &str,
    params: &[(&str, &dyn ToSql)]
) -> Result<usize, Error>

Equivalent to Connection::execute_named but caches the statement so that subsequent calls to execute_named_cached will have imprroved performance.

fn query_one<T>(&self, sql: &str) -> Result<T, Error> where
    T: FromSql, 

Execute a query that returns a single result column, and return that result.

fn try_query_one<T>(
    &self,
    sql: &str,
    params: &[(&str, &dyn ToSql)],
    cache: bool
) -> Result<Option<T>, Error> where
    T: FromSql, 

Execute a query that returns 0 or 1 result columns, returning None if there were no rows, or if the only result was NULL.

fn query_row_and_then_named<T, E, F>(
    &self,
    sql: &str,
    params: &[(&str, &dyn ToSql)],
    mapper: F,
    cache: bool
) -> Result<T, E> where
    E: From<Error>,
    F: FnOnce(&Row<'_>) -> Result<T, E>, 

Equivalent to rusqlite::Connection::query_row_and_then but allows use of named parameters, and allows passing a flag to indicate that it's cached.

fn query_rows_and_then_named<T, E, F>(
    &self,
    sql: &str,
    params: &[(&str, &dyn ToSql)],
    mapper: F
) -> Result<Vec<T>, E> where
    E: From<Error>,
    F: FnMut(&Row<'_>) -> Result<T, E>, 

Helper for when you'd like to get a Vec of all the rows returned by a query that takes named arguments. See also query_rows_and_then_named_cached.

fn query_rows_and_then_named_cached<T, E, F>(
    &self,
    sql: &str,
    params: &[(&str, &dyn ToSql)],
    mapper: F
) -> Result<Vec<T>, E> where
    E: From<Error>,
    F: FnMut(&Row<'_>) -> Result<T, E>, 

Helper for when you'd like to get a Vec of all the rows returned by a query that takes named arguments.

fn query_rows_into<Coll, T, E, F>(
    &self,
    sql: &str,
    params: &[(&str, &dyn ToSql)],
    mapper: F
) -> Result<Coll, E> where
    Coll: FromIterator<T>,
    E: From<Error>,
    F: FnMut(&Row<'_>) -> Result<T, E>, 

Like query_rows_and_then_named, but works if you want a non-Vec as a result. # Example: rust,no_run # use std::collections::HashSet; # use sql_support::ConnExt; # use rusqlite::Connection; fn get_visit_tombstones(conn: &Connection, id: i64) -> rusqlite::Result<HashSet<i64>> { Ok(conn.query_rows_into( "SELECT visit_date FROM moz_historyvisit_tombstones WHERE place_id = :place_id", &[(":place_id", &id)], |row| row.get::<_, i64>(0))?) } Note if the type isn't inferred, you'll have to do something gross like conn.query_rows_into::<HashSet<_>, _, _, _>(...).

fn query_rows_into_cached<Coll, T, E, F>(
    &self,
    sql: &str,
    params: &[(&str, &dyn ToSql)],
    mapper: F
) -> Result<Coll, E> where
    Coll: FromIterator<T>,
    E: From<Error>,
    F: FnMut(&Row<'_>) -> Result<T, E>, 

Same as query_rows_into, but caches the stmt if possible.

fn try_query_row<T, E, F>(
    &self,
    sql: &str,
    params: &[(&str, &dyn ToSql)],
    mapper: F,
    cache: bool
) -> Result<Option<T>, E> where
    E: From<Error>,
    F: FnOnce(&Row<'_>) -> Result<T, E>, 

Like query_row_and_then_named but returns None instead of erroring if no such row exists.

fn unchecked_transaction(&self) -> Result<UncheckedTransaction<'_>, Error>

fn unchecked_transaction_imm(&self) -> Result<UncheckedTransaction<'_>, Error>

Begin unchecked_transaction with TransactionBehavior::Immediate. Use when the first operation will be a read operation, that further writes depend on for correctness.

impl<'conn> Deref for ChunkedCoopTransaction<'conn>

type Target = Connection

The resulting type after dereferencing.

fn deref(&self) -> &Connection

Dereferences the value.