Struct InstrumentedSqliteConnection 

pub struct InstrumentedSqliteConnection { /* private fields */ }

Implementations

impl InstrumentedSqliteConnection

pub fn immediate_transaction<T, E, F>(&mut self, f: F) -> Result<T, E>

where F: FnOnce(&mut SqliteConnection) -> Result<T, E>, E: From<Error>,

pub fn exclusive_transaction<T, E, F>(&mut self, f: F) -> Result<T, E>

where F: FnOnce(&mut SqliteConnection) -> Result<T, E>, E: From<Error>,

Trait Implementations

impl Connection for InstrumentedSqliteConnection

type Backend = Sqlite

The backend this type connects to

type TransactionManager = AnsiTransactionManager

The transaction manager implementation used by this connection

fn establish( database_url: &str, ) -> ConnectionResult<InstrumentedSqliteConnection>

Establishes a new connection to the database

fn transaction<T, E, F>(&mut self, f: F) -> Result<T, E>

where F: FnOnce(&mut Self) -> Result<T, E>, E: From<Error>,

Executes the given function inside of a database transaction

fn execute_returning_count<T>(&mut self, source: &T) -> QueryResult<usize>

where T: QueryFragment<Sqlite> + QueryId,

Execute a single SQL statements given by a query and return number of affected rows

fn transaction_state(&mut self) -> &mut Self::TransactionManager

Get access to the current transaction state of this connection

fn instrumentation(&mut self) -> &mut dyn Instrumentation

Get the instrumentation instance stored in this connection

fn set_instrumentation(&mut self, instrumentation: impl Instrumentation)

Set a specific Instrumentation implementation for this connection

fn set_prepared_statement_cache_size(&mut self, cache_size: CacheSize)

Set the prepared statement cache size to CacheSize for this connection

fn begin_test_transaction(&mut self) -> Result<(), Error>

Creates a transaction that will never be committed. This is useful for tests. Panics if called while inside of a transaction or if called with a connection containing a broken transaction

fn test_transaction<T, E, F>(&mut self, f: F) -> T

where F: FnOnce(&mut Self) -> Result<T, E>, E: Debug,

Executes the given function inside a transaction, but does not commit it. Panics if the given function returns an error.

impl LoadConnection for InstrumentedSqliteConnection

type Cursor<'conn, 'query> = <SqliteConnection as LoadConnection>::Cursor<'conn, 'query> where Self: 'conn

The cursor type returned by LoadConnection::load

type Row<'conn, 'query> = <SqliteConnection as LoadConnection>::Row<'conn, 'query> where Self: 'conn

The row type used as Iterator::Item for the iterator implementation of LoadConnection::Cursor

fn load<'conn, 'query, T>( &'conn mut self, source: T, ) -> QueryResult<Self::Cursor<'conn, 'query>>

where T: Query + QueryFragment<Self::Backend> + QueryId + 'query, Self::Backend: QueryMetadata<T::SqlType>,

Executes a given query and returns any requested values

impl MigrationConnection for InstrumentedSqliteConnection

fn setup(&mut self) -> QueryResult<usize>

Setup the following table:

impl MultiConnectionHelper for InstrumentedSqliteConnection

fn to_any<'a>( lookup: &mut <Self::Backend as TypeMetadata>::MetadataLookup, ) -> &mut (dyn Any + 'a)

Convert the lookup type to any

fn from_any( lookup: &mut dyn Any, ) -> Option<&mut <Self::Backend as TypeMetadata>::MetadataLookup>

Get the lookup type from any

impl R2D2Connection for InstrumentedSqliteConnection

Available on crate feature r2d2 only.

fn ping(&mut self) -> QueryResult<()>

Check if a connection is still valid

fn is_broken(&mut self) -> bool

Checks if the connection is broken and should not be reused

impl SimpleConnection for InstrumentedSqliteConnection

fn batch_execute(&mut self, query: &str) -> QueryResult<()>

Execute multiple SQL statements within the same string.

impl<'b, Changes, Output> UpdateAndFetchResults<Changes, Output> for InstrumentedSqliteConnection

where Changes: Copy + Identifiable + AsChangeset<Target = <Changes as HasTable>::Table> + IntoUpdateTarget, Changes::Table: FindDsl<Changes::Id>, Update<Changes, Changes>: ExecuteDsl<SqliteConnection>, Find<Changes::Table, Changes::Id>: LoadQuery<'b, SqliteConnection, Output>, <Changes::Table as Table>::AllColumns: ValidGrouping<()>, <<Changes::Table as Table>::AllColumns as ValidGrouping<()>>::IsAggregate: MixedAggregates<No, Output = No>,

fn update_and_fetch(&mut self, changeset: Changes) -> QueryResult<Output>

See the traits documentation.

impl ConnectionSealed for InstrumentedSqliteConnection