Struct sql_support::UncheckedTransaction

pub struct UncheckedTransaction<'conn> {
    pub conn: &'conn Connection,
    pub started_at: Instant,
    pub finished: bool,
}

rusqlite, in an attempt to save us from ourselves, needs a mutable ref to a connection to start a transaction. That is a bit of a PITA in some cases, so we offer this as an alternative - but the responsibility of ensuring there are no concurrent transactions is on our head.

This is very similar to the rusqlite Transaction - it doesn't prevent against nested transactions but does allow you to use an immutable Connection.

Fields

conn: &'conn Connection

started_at: Instant

finished: bool

Implementations

impl<'conn> UncheckedTransaction<'conn>

pub fn new(
    conn: &'conn Connection,
    behavior: TransactionBehavior
) -> SqlResult<Self>

Begin a new unchecked transaction. Cannot be nested, but this is not enforced by Rust (hence 'unchecked') - however, it is enforced by SQLite; use a rusqlite savepoint for nested transactions.

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

Consumes and commits an unchecked transaction.

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

Consumes and rolls back an unchecked transaction.

fn rollback_(&mut self) -> SqlResult<()>

fn finish_(&mut self) -> SqlResult<()>

Trait Implementations

impl<'conn> ConnExt for UncheckedTransaction<'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) -> SqlResult<&Self> where
    T: ToSql,
    Self: Sized, 

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

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

Get a cached or uncached statement based on a flag.

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

Execute all the provided statements.

fn execute_cached<P>(&self, sql: &str, params: P) -> SqlResult<usize> where
    P: IntoIterator,
    P::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)]
) -> SqlResult<usize>

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: FromSql>(&self, sql: &str) -> SqlResult<T>

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

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

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
    Self: Sized,
    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
    Self: Sized,
    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
    Self: Sized,
    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
    Self: Sized,
    E: From<Error>,
    F: FnMut(&Row<'_>) -> Result<T, E>,
    Coll: FromIterator<T>, 

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
    Self: Sized,
    E: From<Error>,
    F: FnMut(&Row<'_>) -> Result<T, E>,
    Coll: FromIterator<T>, 

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
    Self: Sized,
    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) -> SqlResult<UncheckedTransaction<'_>>

fn unchecked_transaction_imm(&self) -> SqlResult<UncheckedTransaction<'_>>

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 UncheckedTransaction<'conn>

type Target = Connection

The resulting type after dereferencing.

fn deref(&self) -> &Connection

Dereferences the value.

impl<'conn> Drop for UncheckedTransaction<'conn>

fn drop(&mut self)

Executes the destructor for this type.