Struct sqlx_core::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 fn as_raw_handle(&mut self) -> *mut sqlite3

👎 Deprecated:

Unsynchronized access is unsafe. See documentation for details.

Returns the underlying sqlite3* connection handle.

Note

There is no synchronization using this method, beware that the background thread could be making SQLite API calls concurrent to use of this method.

You probably want to use .lock_handle() to ensure that the worker thread is not using the database concurrently.

pub fn create_collation(
    &mut self,
    name: &str,
    compare: impl Fn(&str, &str) -> Ordering + Send + Sync + 'static
) -> Result<(), Error>

👎 Deprecated:

Completes asynchronously. See documentation for details.

Apply a collation to the open database.

See SqliteConnectOptions::collation() for details.

Deprecated

Due to the rearchitecting of the SQLite driver, this method cannot actually function synchronously and return the result directly from sqlite3_create_collation_v2(), so it instead sends a message to the worker create the collation asynchronously. If an error occurs it will simply be logged.

Instead, you should specify the collation during the initial configuration with SqliteConnectOptions::collation(). Then, if the collation fails to apply it will return an error during the connection creation. When used with a Pool, this also ensures that the collation is applied to all connections automatically.

Or if necessary, you can call .lock_handle() and create the collation directly with LockedSqliteHandle::create_collation().

Error::WorkerCrashed may still be returned if we could not communicate with the worker.

Note that this may also block if the worker command channel is currently applying backpressure.

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 transaction<'a, F, R, E>(
    &'a mut self,
    callback: F
) -> BoxFuture<'a, Result<R, E>> where
    for<'c> F: FnOnce(&'c mut Transaction<'_, Self::Database>) -> BoxFuture<'c, Result<R, E>> + 'a + Send + Sync,
    Self: Sized,
    R: Send,
    E: From<Error> + Send, 

Execute the function inside a transaction.

fn connect(url: &str) -> BoxFuture<'static, Result<Self, Error>> where
    Self: Sized, 

Establish a new database connection.

fn connect_with(options: &Self::Options) -> BoxFuture<'_, Result<Self, Error>> 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, E: 'q>(
    self,
    query: E
) -> BoxStream<'e, Result<Either<SqliteQueryResult, SqliteRow>, Error>> where
    'c: 'e,
    E: Execute<'q, Self::Database>, 

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

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

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, E: 'q>(
    self,
    query: E
) -> BoxFuture<'e, Result<<Self::Database as Database>::QueryResult, Error>> where
    'c: 'e,
    E: Execute<'q, Self::Database>, 

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

fn execute_many<'e, 'q: 'e, E: 'q>(
    self,
    query: E
) -> BoxStream<'e, Result<<Self::Database as Database>::QueryResult, Error>> where
    'c: 'e,
    E: Execute<'q, Self::Database>, 

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

fn fetch<'e, 'q: 'e, E: 'q>(
    self,
    query: E
) -> BoxStream<'e, Result<<Self::Database as Database>::Row, Error>> where
    'c: 'e,
    E: Execute<'q, Self::Database>, 

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

fn fetch_all<'e, 'q: 'e, E: 'q>(
    self,
    query: E
) -> BoxFuture<'e, Result<Vec<<Self::Database as Database>::Row>, Error>> where
    'c: 'e,
    E: Execute<'q, Self::Database>, 

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

fn fetch_one<'e, 'q: 'e, E: 'q>(
    self,
    query: E
) -> BoxFuture<'e, Result<<Self::Database as Database>::Row, Error>> where
    'c: 'e,
    E: Execute<'q, Self::Database>, 

Execute the query and returns exactly one row.

fn prepare<'e, 'q: 'e>(
    self,
    query: &'q str
) -> BoxFuture<'e, Result<<Self::Database as HasStatement<'q>>::Statement, Error>> where
    'c: 'e, 

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

impl Migrate for SqliteConnection

fn ensure_migrations_table(&mut self) -> BoxFuture<'_, Result<(), MigrateError>>

fn version(
    &mut self
) -> BoxFuture<'_, Result<Option<(i64, bool)>, MigrateError>>

👎 Deprecated

fn dirty_version(&mut self) -> BoxFuture<'_, Result<Option<i64>, MigrateError>>

fn list_applied_migrations(
    &mut self
) -> BoxFuture<'_, Result<Vec<AppliedMigration>, MigrateError>>

fn lock(&mut self) -> BoxFuture<'_, Result<(), MigrateError>>

fn unlock(&mut self) -> BoxFuture<'_, Result<(), MigrateError>>

fn validate<'e: 'm, 'm>(
    &'e mut self,
    migration: &'m Migration
) -> BoxFuture<'m, Result<(), MigrateError>>

👎 Deprecated

fn apply<'e: 'm, 'm>(
    &'e mut self,
    migration: &'m Migration
) -> BoxFuture<'m, Result<Duration, MigrateError>>

fn revert<'e: 'm, 'm>(
    &'e mut self,
    migration: &'m Migration
) -> BoxFuture<'m, Result<Duration, MigrateError>>