Struct BorrowedSqliteConnection 

pub struct BorrowedSqliteConnection { /* private fields */ }

Available on crate feature __sqlite-shared only.

A borrowed SQLite connection

This type is provided to various hook functions called by SQLite internally It mostly acts as &mut SqliteConnection with the additional constraint that you cannot move out/replace the inner connection handle

Any hook (update, commit, rollback, progress, wal, busy handler, authorizer, trace, collation needed) is reset after the closure that gets this connection type as argument ends. This specifically means that any hook registered during [register_auto_extension] won’t trigger later

Implementations

impl BorrowedSqliteConnection

pub unsafe fn inner_mut(&mut self) -> &mut SqliteConnection

Get access to the underlying SqliteConnection

Safety

• You are not allowed to move the connection out of the provided reference or otherwise replace the connection

Trait Implementations

impl Connection for BorrowedSqliteConnection

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<Self>

Establishes a new connection to the database

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

where T: QueryFragment<Self::Backend> + QueryId,

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

fn transaction_state( &mut self, ) -> &mut <Self::TransactionManager as TransactionManager<Self>>::TransactionStateData

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, size: CacheSize)

Set the prepared statement cache size to CacheSize for this connection

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 begin_test_transaction(&mut self) -> QueryResult<()>

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 ConnectionSealed for BorrowedSqliteConnection

impl Drop for BorrowedSqliteConnection

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl LoadConnection for BorrowedSqliteConnection

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 SimpleConnection for BorrowedSqliteConnection

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

Execute multiple SQL statements within the same string.