Struct SqliteEngine 

pub struct SqliteEngine { /* private fields */ }

SQLite query engine backed by tokio_rusqlite.

Breaking changes (0.7)

SqliteEngine no longer has inherent query / query_one / query_opt methods that returned untyped RowData / serde_json::Value. It now implements prax_query::traits::QueryEngine, whose row-returning methods are generic over T: Model + FromRow and return typed models.

Migration:

• Replace engine.query(sql, params) with engine.query_many::<YourType>(sql, params).await?, where YourType carries #[derive(prax_orm::Model)] (which emits both Model and FromRow) or hand-written impl Model + impl FromRow.
• For ad-hoc typed queries without a full Model, bridge through crate::row_ref::SqliteRowRef::from_rusqlite inside a custom FromRow impl.
• For the legacy JSON-blob API, use crate::raw::SqliteRawEngine + crate::raw::SqliteJsonRow.
• To run side-effecting SQL that returns no rows, call prax_query::traits::QueryEngine::execute_raw.

See CHANGELOG.md for the full migration guide.

Transaction mode

SqliteEngine has two modes, controlled by tx_conn:

• Pool mode (tx_conn == None, default): each query acquires a fresh SqliteConnection from the pool and drops it after the call.
• Transaction mode (tx_conn == Some(..)): each query routes through the same tokio_rusqlite::Connection handle so the whole BEGIN…COMMIT block serialises onto the connection’s background thread in order. The Arc<SqliteConnection> keeps the pool permit alive for the transaction’s lifetime; dropping the last clone returns the connection to the idle pool.

Implementations

impl SqliteEngine

pub fn new(pool: SqlitePool) -> Self

Create a new engine with the given pool.

pub fn pool(&self) -> &SqlitePool

Get a reference to the connection pool.

Trait Implementations

impl Clone for SqliteEngine

fn clone(&self) -> SqliteEngine

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl QueryEngine for SqliteEngine

fn dialect(&self) -> &dyn SqlDialect

The SQL dialect this engine targets.

fn query_many<T: Model + FromRow + Send + 'static>( &self, sql: &str, params: Vec<FilterValue>, ) -> BoxFuture<'_, QueryResult<Vec<T>>>

Execute a SELECT query and return rows.

fn query_one<T: Model + FromRow + Send + 'static>( &self, sql: &str, params: Vec<FilterValue>, ) -> BoxFuture<'_, QueryResult<T>>

Execute a SELECT query expecting one result.

fn query_optional<T: Model + FromRow + Send + 'static>( &self, sql: &str, params: Vec<FilterValue>, ) -> BoxFuture<'_, QueryResult<Option<T>>>

Execute a SELECT query expecting zero or one result.

fn execute_insert<T: Model + FromRow + Send + 'static>( &self, sql: &str, params: Vec<FilterValue>, ) -> BoxFuture<'_, QueryResult<T>>

Execute an INSERT query and return the created row.

fn execute_update<T: Model + FromRow + Send + 'static>( &self, sql: &str, params: Vec<FilterValue>, ) -> BoxFuture<'_, QueryResult<Vec<T>>>

Execute an UPDATE query and return affected rows.

fn execute_delete( &self, sql: &str, params: Vec<FilterValue>, ) -> BoxFuture<'_, QueryResult<u64>>

Execute a DELETE query and return affected rows count.

fn execute_raw( &self, sql: &str, params: Vec<FilterValue>, ) -> BoxFuture<'_, QueryResult<u64>>

Execute a raw SQL query.

fn count( &self, sql: &str, params: Vec<FilterValue>, ) -> BoxFuture<'_, QueryResult<u64>>

Get a count of records.

fn aggregate_query( &self, sql: &str, params: Vec<FilterValue>, ) -> BoxFuture<'_, QueryResult<Vec<HashMap<String, FilterValue>>>>

Execute an aggregate query (COUNT/SUM/AVG/MIN/MAX/GROUP BY) and return one map of column name → crate::filter::FilterValue per result row.

fn transaction<'a, R, Fut, F>(&'a self, f: F) -> BoxFuture<'a, QueryResult<R>>

where F: FnOnce(Self) -> Fut + Send + 'a, Fut: Future<Output = QueryResult<R>> + Send + 'a, R: Send + 'a, Self: Clone,

Run the closure inside a transaction.

fn refresh_materialized_view( &self, view_name: &str, concurrently: bool, ) -> Pin<Box<dyn Future<Output = Result<(), QueryError>> + Send + '_>>

Refresh a materialized view.