Struct sqlx_sqlite::SqliteConnection

pub struct SqliteConnection { /* private fields */ }

A connection to an open Sqlite database.

Because SQLite is an in-process database accessed by blocking API calls, SQLx uses a background thread and communicates with it via channels to allow non-blocking access to the database.

Dropping this struct will signal the worker thread to quit and close the database, though if an error occurs there is no way to pass it back to the user this way.

You can explicitly call .close() to ensure the database is closed successfully or get an error otherwise.

Implementations

impl SqliteConnection

pub async fn lock_handle(&mut self) -> Result<LockedSqliteHandle<'_>, Error>

Lock the SQLite database handle out from the worker thread so direct SQLite API calls can be made safely.

Returns an error if the worker thread crashed.

Trait Implementations

impl<'c> Acquire<'c> for &'c mut SqliteConnection

type Database = Sqlite

type Connection = &'c mut <Sqlite as Database>::Connection

fn acquire(self) -> BoxFuture<'c, Result<Self::Connection, Error>>

fn begin(self) -> BoxFuture<'c, Result<Transaction<'c, Sqlite>, Error>>

impl Connection for SqliteConnection

fn ping(&mut self) -> BoxFuture<'_, Result<(), Error>>

Ensure the background worker thread is alive and accepting commands.

type Database = Sqlite

type Options = SqliteConnectOptions

fn close(self) -> BoxFuture<'static, Result<(), Error>>

Explicitly close this database connection.

fn begin( &mut self, ) -> BoxFuture<'_, Result<Transaction<'_, Self::Database>, Error>>

where Self: Sized,

Begin a new transaction or establish a savepoint within the active transaction.

fn cached_statements_size(&self) -> usize

The number of statements currently cached in the connection.

fn clear_cached_statements(&mut self) -> BoxFuture<'_, Result<(), Error>>

Removes all statements from the cache, closing them on the server if needed.

fn shrink_buffers(&mut self)

Restore any buffers in the connection to their default capacity, if possible.

fn transaction<'a, F, R, E>( &'a mut self, callback: F, ) -> Pin<Box<dyn Future<Output = Result<R, E>> + Send + 'a>>

where F: for<'c> FnOnce(&'c mut Transaction<'_, Self::Database>) -> Pin<Box<dyn Future<Output = Result<R, E>> + Send + 'c>> + 'a + for<'c> Send + for<'c> Sync, Self: Sized, R: Send, E: From<Error> + Send,

Execute the function inside a transaction.

fn connect( url: &str, ) -> Pin<Box<dyn Future<Output = Result<Self, Error>> + Send>>

where Self: Sized,

Establish a new database connection.

fn connect_with( options: &Self::Options, ) -> Pin<Box<dyn Future<Output = Result<Self, Error>> + Send + '_>>

where Self: Sized,

Establish a new database connection with the provided options.

impl Debug for SqliteConnection

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'c> Executor<'c> for &'c mut SqliteConnection

type Database = Sqlite

fn fetch_many<'e, 'q, E>( self, query: E, ) -> BoxStream<'e, Result<Either<SqliteQueryResult, SqliteRow>, Error>>

where E: Execute<'q, Self::Database> + 'q, 'c: 'e, 'q: 'e,

Execute multiple queries and return the generated results as a stream from each query, in a stream.

fn fetch_optional<'e, 'q, E>( self, query: E, ) -> BoxFuture<'e, Result<Option<SqliteRow>, Error>>

where E: Execute<'q, Self::Database> + 'q, 'c: 'e, 'q: 'e,

Execute the query and returns at most one row.

fn prepare_with<'e, 'q: 'e>( self, sql: &'q str, _parameters: &[SqliteTypeInfo], ) -> BoxFuture<'e, Result<SqliteStatement<'q>, Error>>

where 'c: 'e,

Prepare the SQL query, with parameter type information, to inspect the type information about its parameters and results.

fn execute<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Future<Output = Result<<Self::Database as Database>::QueryResult, Error>> + Send + 'e>>

where 'q: 'e, 'c: 'e, E: 'q + Execute<'q, Self::Database>,

Execute the query and return the total number of rows affected.

fn execute_many<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Stream<Item = Result<<Self::Database as Database>::QueryResult, Error>> + Send + 'e>>

where 'q: 'e, 'c: 'e, E: 'q + Execute<'q, Self::Database>,

Execute multiple queries and return the rows affected from each query, in a stream.

fn fetch<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Stream<Item = Result<<Self::Database as Database>::Row, Error>> + Send + 'e>>

where 'q: 'e, 'c: 'e, E: 'q + Execute<'q, Self::Database>,

Execute the query and return the generated results as a stream.

fn fetch_all<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Future<Output = Result<Vec<<Self::Database as Database>::Row>, Error>> + Send + 'e>>

where 'q: 'e, 'c: 'e, E: 'q + Execute<'q, Self::Database>,

Execute the query and return all the generated results, collected into a Vec.

fn fetch_one<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Future<Output = Result<<Self::Database as Database>::Row, Error>> + Send + 'e>>

where 'q: 'e, 'c: 'e, E: 'q + Execute<'q, Self::Database>,

Execute the query and returns exactly one row.

fn prepare<'e, 'q>( self, query: &'q str, ) -> Pin<Box<dyn Future<Output = Result<<Self::Database as Database>::Statement<'q>, Error>> + Send + 'e>>

where 'q: 'e, 'c: 'e,

Prepare the SQL query to inspect the type information of its parameters and results.