Struct places::db::PlacesTransaction

pub struct PlacesTransaction<'conn>(PlacesTransactionRepr<'conn>);

High level transaction type which "does the right thing" for you. Construct one with PlacesDb::begin_transaction().

Implementations

impl<'conn> PlacesTransaction<'conn>

pub fn should_commit(&self) -> bool

Returns true if the current transaction should be committed at the earliest opportunity.

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

• For transactions on sync connnections: 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.
• For transactions on other connections: debug_assert!s, or logs a warning and does nothing.

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

Consumes and commits a PlacesTransaction transaction.

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

Consumes and attempst to roll back a PlacesTransaction. Note that if maybe_commit has been called, this may only roll back as far as that call.

Trait Implementations

impl<'conn> ConnExt for PlacesTransaction<'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 PlacesTransaction<'conn>

type Target = Connection

The resulting type after dereferencing.

fn deref(&self) -> &Connection

Dereferences the value.