Struct SqlStore 

pub struct SqlStore<DB: Database> { /* private fields */ }

A typed SQL connection pool.

The underlying Pool remains available so applications retain SQLx’s compile-time checked queries. The wrapper standardizes pool configuration, health checks, and transaction creation.

Implementations

impl<DB: Database> SqlStore<DB>

pub fn from_pool(pool: Pool<DB>) -> Self

pub fn with_metrics(self, metrics: SqlStoreMetrics) -> Self

Installs metrics for operations run through the typed helper methods.

pub fn pool(&self) -> &Pool<DB>

pub async fn begin(&self) -> Result<Transaction<'static, DB>, Error>

pub async fn query<T, F, Fut>( &self, operation: &'static str, query: F, ) -> Result<T, SqlStoreError>

where F: FnOnce(Pool<DB>) -> Fut, Fut: Future<Output = Result<T, Error>>,

Runs a typed query closure with consistent metrics, tracing, and error conversion.

pub async fn query_one<T, F, Fut>( &self, operation: &'static str, entity: impl Into<String>, query: F, ) -> Result<T, SqlStoreError>

where F: FnOnce(Pool<DB>) -> Fut, Fut: Future<Output = Result<Option<T>, Error>>,

Runs an optional typed query and converts an absent row into SqlStoreError::NotFound.

pub async fn execute<T, F, Fut>( &self, operation: &'static str, execute: F, ) -> Result<T, SqlStoreError>

where F: FnOnce(Pool<DB>) -> Fut, Fut: Future<Output = Result<T, Error>>,

Runs a typed mutation closure with consistent metrics, tracing, and error conversion.

pub async fn bulk_insert<T, R, F, Fut>( &self, operation: &'static str, items: impl IntoIterator<Item = T>, batch_size: usize, insert_batch: F, ) -> Result<Vec<R>, SqlStoreError>

where F: FnMut(Pool<DB>, Vec<T>) -> Fut, Fut: Future<Output = Result<R, Error>>,

Inserts items in bounded batches using a database-specific typed SQLx closure.

The returned vector contains one result per batch. The helper intentionally leaves SQL construction to the caller because placeholder syntax and optimal multi-row statements differ across SQLite, PostgreSQL, and MySQL.

pub async fn close(&self)

impl SqlStore<Sqlite>

pub async fn connect_sqlite(config: SqlStoreConfig) -> Result<Self, Error>

Examples found in repository

examples/external_stores.rs (line 14)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let redis_url = env::var("REDIS_URL").unwrap_or_else(|_| "redis://127.0.0.1/".to_owned());
    let mongo_url =
        env::var("MONGODB_URI").unwrap_or_else(|_| "mongodb://127.0.0.1:27017".to_owned());
    let sqlite_url = env::var("DATABASE_URL").unwrap_or_else(|_| "sqlite::memory:".to_owned());

    let redis = RedisStore::new(RedisStoreConfig::new(redis_url))?;
    let sql = SqliteStore::connect_sqlite(SqlStoreConfig::new(sqlite_url)).await?;
    let mongo = MongoStore::connect(MongoStoreConfig::new(mongo_url, "rust_zero_example")).await?;

    redis.ping().await?;
    sql.health_check().await?;
    mongo.health_check().await?;
    println!("Redis, SQLite, and MongoDB are ready");
    Ok(())
}

pub async fn health_check(&self) -> Result<(), Error>

Examples found in repository

examples/external_stores.rs (line 18)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let redis_url = env::var("REDIS_URL").unwrap_or_else(|_| "redis://127.0.0.1/".to_owned());
    let mongo_url =
        env::var("MONGODB_URI").unwrap_or_else(|_| "mongodb://127.0.0.1:27017".to_owned());
    let sqlite_url = env::var("DATABASE_URL").unwrap_or_else(|_| "sqlite::memory:".to_owned());

    let redis = RedisStore::new(RedisStoreConfig::new(redis_url))?;
    let sql = SqliteStore::connect_sqlite(SqlStoreConfig::new(sqlite_url)).await?;
    let mongo = MongoStore::connect(MongoStoreConfig::new(mongo_url, "rust_zero_example")).await?;

    redis.ping().await?;
    sql.health_check().await?;
    mongo.health_check().await?;
    println!("Redis, SQLite, and MongoDB are ready");
    Ok(())
}

impl SqlStore<Postgres>

pub async fn connect_postgres(config: SqlStoreConfig) -> Result<Self, Error>

pub async fn health_check(&self) -> Result<(), Error>

impl SqlStore<MySql>

pub async fn connect_mysql(config: SqlStoreConfig) -> Result<Self, Error>

pub async fn health_check(&self) -> Result<(), Error>

Trait Implementations

impl<DB: Clone + Database> Clone for SqlStore<DB>

fn clone(&self) -> SqlStore<DB>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<DB: Database> Debug for SqlStore<DB>

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

Formats the value using the given formatter.