Struct sqlx::SqliteConnection

pub struct SqliteConnection { /* private fields */ }

Available on crate feature sqlite only.

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
) -> Pin<Box<dyn Future<Output = Result<<&'c mut SqliteConnection as Acquire<'c>>::Connection, Error>> + Send + 'c, Global>>

fn begin(
    self
) -> Pin<Box<dyn Future<Output = Result<Transaction<'c, Sqlite>, Error>> + Send + 'c, Global>>

impl Connection for SqliteConnection

fn ping(
    &mut self
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send, Global>>

Ensure the background worker thread is alive and accepting commands.

type Database = Sqlite

type Options = SqliteConnectOptions

fn close(
    self
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'static, Global>>

Explicitly close this database connection.

fn begin(
    &mut self
) -> Pin<Box<dyn Future<Output = Result<Transaction<'_, <SqliteConnection as Connection>::Database>, Error>> + Send, Global>> where
    SqliteConnection: 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
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send, Global>>

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

fn transaction<'a, F, R, E>(
    &'a mut self,
    callback: F
) -> Pin<Box<dyn Future<Output = Result<R, E>> + Send + 'a, Global>> where
    F: 'a + for<'c> FnOnce(&'c mut Transaction<'_, Self::Database>) -> Pin<Box<dyn Future<Output = Result<R, E>> + Send + 'c, Global>> + Send + Sync,
    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 + 'static, Global>>

Establish a new database connection.

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

Establish a new database connection with the provided options.

impl Debug for SqliteConnection

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

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
) -> Pin<Box<dyn Stream<Item = Result<Either<SqliteQueryResult, SqliteRow>, Error>> + Send + 'e, Global>> where
    'q: 'e,
    'c: 'e,
    E: 'q + Execute<'q, <&'c mut SqliteConnection as Executor<'c>>::Database>, 

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
) -> Pin<Box<dyn Future<Output = Result<Option<SqliteRow>, Error>> + Send + 'e, Global>> where
    'q: 'e,
    'c: 'e,
    E: 'q + Execute<'q, <&'c mut SqliteConnection as Executor<'c>>::Database>, 

Execute the query and returns at most one row.

fn prepare_with<'e, 'q>(
    self,
    sql: &'q str,
    _parameters: &[SqliteTypeInfo]
) -> Pin<Box<dyn Future<Output = Result<SqliteStatement<'q>, Error>> + Send + 'e, Global>> where
    'q: 'e,
    '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, Global>> 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, Global>> 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, Global>> 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, Global>, Error>> + Send + 'e, Global>> 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, Global>> 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 HasStatement<'q>>::Statement, Error>> + Send + 'e, Global>> where
    'q: 'e,
    'c: 'e, 

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

impl From<SqliteConnection> for AnyConnection

fn from(conn: SqliteConnection) -> AnyConnection

Converts to this type from the input type.

impl Migrate for SqliteConnection

fn ensure_migrations_table(
    &mut self
) -> Pin<Box<dyn Future<Output = Result<(), MigrateError>> + Send, Global>>

fn version(
    &mut self
) -> Pin<Box<dyn Future<Output = Result<Option<(i64, bool)>, MigrateError>> + Send, Global>>

👎 Deprecated

fn dirty_version(
    &mut self
) -> Pin<Box<dyn Future<Output = Result<Option<i64>, MigrateError>> + Send, Global>>

fn list_applied_migrations(
    &mut self
) -> Pin<Box<dyn Future<Output = Result<Vec<AppliedMigration, Global>, MigrateError>> + Send, Global>>

fn lock(
    &mut self
) -> Pin<Box<dyn Future<Output = Result<(), MigrateError>> + Send, Global>>

fn unlock(
    &mut self
) -> Pin<Box<dyn Future<Output = Result<(), MigrateError>> + Send, Global>>

fn validate<'e, 'm>(
    &'e mut self,
    migration: &'m Migration
) -> Pin<Box<dyn Future<Output = Result<(), MigrateError>> + Send + 'm, Global>> where
    'e: 'm, 

👎 Deprecated

fn apply<'e, 'm>(
    &'e mut self,
    migration: &'m Migration
) -> Pin<Box<dyn Future<Output = Result<Duration, MigrateError>> + Send + 'm, Global>> where
    'e: 'm, 

fn revert<'e, 'm>(
    &'e mut self,
    migration: &'m Migration
) -> Pin<Box<dyn Future<Output = Result<Duration, MigrateError>> + Send + 'm, Global>> where
    'e: 'm,