Struct SqliteBackend 

pub struct SqliteBackend { /* private fields */ }

SQLite adapter executing compiled plans on a connection pool.

Writes from this backend and its clones (statements through execute, execute_raw and execute_script, transactions, and transactional schema changes) queue for one write slot instead of racing for SQLite’s file lock, while reads keep using the whole pool. A write sent through fetch_raw bypasses the queue.

Implementations

impl SqliteBackend

pub async fn connect(url: &str) -> Result<Self, BackendError>

Connect to url (e.g. sqlite::memory: or sqlite://app.db?mode=rwc).

SQLx enables foreign-key enforcement on every SQLite connection.

Errors

Returns BackendError::Connection if the pool cannot be created.

pub async fn connect_with( options: SqliteConnectOptions, pool: SqlitePoolOptions, ) -> Result<Self, BackendError>

Connect with explicit connection and pool options, for example to opt in to write-ahead logging:

let options: SqliteConnectOptions = "sqlite://app.db?mode=rwc".parse()?;
let db = SqliteBackend::connect_with(
    options.journal_mode(SqliteJournalMode::Wal),
    SqlitePoolOptions::new().max_connections(10),
)
.await?;

connect leaves the journal mode and synchronous at the SQLite defaults (a rollback journal, synced on every commit). WAL is recorded in the database file and does not work on network filesystems; synchronous = NORMAL with WAL can lose the most recent commits on power loss. An in-memory database needs a pool of one connection.

Errors

Returns BackendError::Connection if the pool cannot be created.

pub fn from_pool(pool: SqlitePool) -> Self

Wrap an existing pool.

pub fn group_commit(self, config: GroupCommit) -> Self

Opt in to group commit: concurrent execute calls outside a transaction share one transaction and one commit sync, each isolated by a savepoint and acknowledged only after the commit. See GroupCommit for what changes compared with one transaction per write. Raw statements, scripts and transactions are unaffected.

Call with_write_timeout first; the committer keeps the timeout it started with.

Panics

Outside a Tokio runtime, which runs the committer task.

pub fn with_write_timeout(self, wait: Duration) -> Self

How long a write waits for the write slot before failing with “database is locked”; five seconds by default, like SQLx’s busy timeout. Match it when configuring a different busy timeout.

The slot is shared with existing clones; only this handle’s wait changes.

Trait Implementations

impl Backend for SqliteBackend

fn read_parameter_count( &self, plan: &QueryPlan, ) -> Result<Option<usize>, OrmError>

Count compiled read parameters without database I/O.

fn begin<'life0, 'async_trait>( &'life0 self, isolation: Option<IsolationLevel>, ) -> Pin<Box<dyn Future<Output = Result<Box<dyn Transaction>, OrmError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Begin a transaction on a dedicated connection.

fn begin_schema<'life0, 'async_trait>( &'life0 self, transactional: bool, ) -> Pin<Box<dyn Future<Output = Result<Box<dyn Transaction>, OrmError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Connection for a schema migration.

impl Clone for SqliteBackend

fn clone(&self) -> SqliteBackend

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for SqliteBackend

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

Formats the value using the given formatter.

impl Executor for SqliteBackend

fn capabilities(&self) -> BackendCapabilities

Declared capabilities.

fn fetch<'life0, 'life1, 'async_trait>( &'life0 self, plan: &'life1 QueryPlan, ) -> Pin<Box<dyn Future<Output = Result<QueryResult, OrmError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Execute a read plan.

fn execute<'life0, 'life1, 'async_trait>( &'life0 self, plan: &'life1 WritePlan, ) -> Pin<Box<dyn Future<Output = Result<ExecResult, OrmError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Execute a write plan.

fn fetch_raw<'life0, 'life1, 'async_trait>( &'life0 self, sql: &'life1 str, params: Vec<Value>, ) -> Pin<Box<dyn Future<Output = Result<QueryResult, OrmError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Run raw SQL returning rows. params are bound, never interpolated.

fn execute_raw<'life0, 'life1, 'async_trait>( &'life0 self, sql: &'life1 str, params: Vec<Value>, ) -> Pin<Box<dyn Future<Output = Result<u64, OrmError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Run raw SQL returning the affected-row count. params are bound.

fn execute_script<'life0, 'life1, 'async_trait>( &'life0 self, sql: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<(), OrmError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Run a multi-statement script without parameters (DDL, migrations).