Trait RusqliteTransactionExt 

pub trait RusqliteTransactionExt {
    // Required methods
    fn bsql_exec_concurrent(&self, _: &dyn Bsql) -> Result<usize, DbError<IE>>;
    fn bsql_exec(&mut self, _: &dyn Bsql) -> Result<usize, DbError<IE>>;
    fn bsql_query_rows_concurrent<R, E>(
        &self,
        _: &dyn Bsql,
        _: impl FnOnce(Rows<'_>) -> Result<R, DbError<E>>,
    ) -> Result<R, DbError<E>>;
    fn bsql_insert(&mut self, _: &dyn Bsql) -> Result<RowId, DbError<IE>>;
    fn bsql_exec_1_affected(&mut self, _: &dyn Bsql) -> Result<(), DbError<IE>>;
    fn bsql_query_01<R>(
        &mut self,
        _: &dyn Bsql,
    ) -> Result<Option<R>, DbError<IE>>
       where R: FromSqlRow;
    fn bsql_query_1<R>(&mut self, _: &dyn Bsql) -> Result<R, DbError<IE>>
       where R: FromSqlRow;
    fn bsql_query_n_call<R, E>(
        &mut self,
        _: &dyn Bsql,
        _: impl FnMut(R) -> Result<(), E>,
    ) -> Result<(), DbError<E>>
       where R: FromSqlRow,
             E: From<InternalError>;
    fn bsql_query_n_map<R, V, RE>(
        &mut self,
        _: &dyn Bsql,
        _: impl FnMut(R) -> Result<V, RE>,
    ) -> Result<Vec<V>, DbError<RE>>
       where R: FromSqlRow,
             RE: From<InternalError>;
    fn bsql_query_n_vec<R>(
        &mut self,
        _: &dyn Bsql,
    ) -> Result<Vec<R>, DbError<IE>>
       where R: FromSqlRow;
}

Required Methods

fn bsql_exec_concurrent(&self, _: &dyn Bsql) -> Result<usize, DbError<IE>>

Like bsql_exec but takes &self

Caller must convince themselves the concurrency is fine. See https://sqlite.org/isolation.html “No Isolation Between Operations On The Same Database Connection”.

fn bsql_exec(&mut self, _: &dyn Bsql) -> Result<usize, DbError<IE>>

fn bsql_query_rows_concurrent<R, E>( &self, _: &dyn Bsql, _: impl FnOnce(Rows<'_>) -> Result<R, DbError<E>>, ) -> Result<R, DbError<E>>

Run a query concurrently, giving access to the Rows

See bsql_exec_concurrent

fn bsql_insert(&mut self, _: &dyn Bsql) -> Result<RowId, DbError<IE>>

fn bsql_exec_1_affected(&mut self, _: &dyn Bsql) -> Result<(), DbError<IE>>

fn bsql_query_01<R>(&mut self, _: &dyn Bsql) -> Result<Option<R>, DbError<IE>>

where R: FromSqlRow,

fn bsql_query_1<R>(&mut self, _: &dyn Bsql) -> Result<R, DbError<IE>>

where R: FromSqlRow,

fn bsql_query_n_call<R, E>( &mut self, _: &dyn Bsql, _: impl FnMut(R) -> Result<(), E>, ) -> Result<(), DbError<E>>

where R: FromSqlRow, E: From<InternalError>,

fn bsql_query_n_map<R, V, RE>( &mut self, _: &dyn Bsql, _: impl FnMut(R) -> Result<V, RE>, ) -> Result<Vec<V>, DbError<RE>>

where R: FromSqlRow, RE: From<InternalError>,

fn bsql_query_n_vec<R>(&mut self, _: &dyn Bsql) -> Result<Vec<R>, DbError<IE>>

where R: FromSqlRow,

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl RusqliteTransactionExt for Transaction<'_>

fn bsql_exec_concurrent(&self, bsql: &dyn Bsql) -> Result<usize, DbError<IE>>

fn bsql_exec(&mut self, bsql: &dyn Bsql) -> Result<usize, DbError<IE>>

fn bsql_query_rows_concurrent<R, E>( &self, bsql: &dyn Bsql, f: impl FnOnce(Rows<'_>) -> Result<R, DbError<E>>, ) -> Result<R, DbError<E>>

fn bsql_insert(&mut self, bsql: &dyn Bsql) -> Result<RowId, DbError<IE>>

fn bsql_exec_1_affected(&mut self, bsql: &dyn Bsql) -> Result<(), DbError<IE>>

fn bsql_query_01<R>( &mut self, bsql: &dyn Bsql, ) -> Result<Option<R>, DbError<IE>>

where R: FromSqlRow,

fn bsql_query_1<R>(&mut self, bsql: &dyn Bsql) -> Result<R, DbError<IE>>

where R: FromSqlRow,

fn bsql_query_n_call<R, E>( &mut self, bsql: &dyn Bsql, per_row: impl FnMut(R) -> Result<(), E>, ) -> Result<(), DbError<E>>

where R: FromSqlRow, E: From<InternalError>,

fn bsql_query_n_map<R, V, RE>( &mut self, bsql: &dyn Bsql, map: impl FnMut(R) -> Result<V, RE>, ) -> Result<Vec<V>, DbError<RE>>

where R: FromSqlRow, RE: From<InternalError>,

fn bsql_query_n_vec<R>( &mut self, bsql: &dyn Bsql, ) -> Result<Vec<R>, DbError<IE>>

where R: FromSqlRow,

Implementors