Struct SqliteDatabase 

pub struct SqliteDatabase { /* private fields */ }

SQLite database with connection pooling for concurrent reads and optional exclusive writes.

Once the database is opened it can be used for read-only operations by calling read_pool(). Write operations are available by calling acquire_writer() which lazily initializes WAL mode on first use.

Example

use sqlx_sqlite_conn_mgr::SqliteDatabase;
use std::sync::Arc;

let db = SqliteDatabase::connect("test.db", None).await?;

// Use read_pool for SELECT queries (concurrent reads)
let rows = sqlx::query("SELECT * FROM users")
    .fetch_all(db.read_pool()?)
    .await?;

// Optionally acquire writer for INSERT/UPDATE/DELETE (exclusive)
let mut writer = db.acquire_writer().await?;
sqlx::query("INSERT INTO users (name) VALUES (?)")
    .bind("Alice")
    .execute(&mut *writer)
    .await?;

db.close().await?;

Implementations

impl SqliteDatabase

pub async fn connect( path: impl AsRef<Path>, custom_config: Option<SqliteDatabaseConfig>, ) -> Result<Arc<Self>>

Connect to a SQLite database

If the database is already connected, returns the existing connection. Multiple calls with the same path will return the same database instance.

The database is created if it doesn’t exist. WAL mode is enabled when acquire_writer() is first called.

Arguments

• path - Path to the SQLite database file (will be created if missing)
• custom_config - Optional custom configuration for connection pools. Pass None to use defaults (6 max read connections, 30 second idle timeout). Specify a custom configuration when the defaults don’t meet your requirements.

Examples

use sqlx_sqlite_conn_mgr::SqliteDatabase;
use std::sync::Arc;

// Connect with default configuration (recommended for most use cases)
let db = SqliteDatabase::connect("test.db", None).await?;

use sqlx_sqlite_conn_mgr::{SqliteDatabase, SqliteDatabaseConfig};
use std::sync::Arc;

// Customize configuration when defaults don't meet your requirements
let custom_config = SqliteDatabaseConfig {
   max_read_connections: 10,
   idle_timeout_secs: 60,
};
let db = SqliteDatabase::connect("test.db", Some(custom_config)).await?;

pub fn read_pool(&self) -> Result<&Pool<Sqlite>>

Get a reference to the connection pool for executing read queries

Use this for concurrent read operations. Multiple readers can access the pool simultaneously.

Example

use sqlx_sqlite_conn_mgr::SqliteDatabase;
use sqlx::query;
use std::sync::Arc;

let db = SqliteDatabase::connect("test.db", None).await?;
let result = query("SELECT * FROM users")
    .fetch_all(db.read_pool()?)
    .await?;

pub async fn acquire_writer(&self) -> Result<WriteGuard>

Acquire exclusive write access to the database

This method returns a WriteGuard that provides exclusive access to the single write connection. Only one writer can exist at a time.

On the first call, this method will enable WAL mode on the database. Subsequent calls reuse the same write connection.

Example

use sqlx_sqlite_conn_mgr::SqliteDatabase;
use sqlx::query;
use std::sync::Arc;

let db = SqliteDatabase::connect("test.db", None).await?;
let mut writer = db.acquire_writer().await?;
query("INSERT INTO users (name) VALUES (?)")
    .bind("Alice")
    .execute(&mut *writer)
    .await?;

pub async fn run_migrations(&self, migrator: &Migrator) -> Result<()>

Run database migrations using the provided migrator

This method runs all pending migrations from the provided Migrator. Migrations are executed using the write connection to ensure exclusive access. WAL mode is enabled automatically before running migrations.

SQLx tracks applied migrations in a _sqlx_migrations table, so calling this method multiple times is safe - already-applied migrations are skipped.

Arguments

• migrator - A reference to a Migrator containing the migrations to run. Typically created using sqlx::migrate!() macro.

Example

use sqlx_sqlite_conn_mgr::SqliteDatabase;

// sqlx::migrate! is evaluated at compile time
static MIGRATOR: sqlx::migrate::Migrator = sqlx::migrate!("./migrations");

let db = SqliteDatabase::connect("test.db", None).await?;
db.run_migrations(&MIGRATOR).await?;

pub async fn close(self: Arc<Self>) -> Result<()>

Close the database and clean up resources

This closes all connections in the pool and removes the database from the cache. After calling close, any operations on this database will return Error::DatabaseClosed.

Note: Takes Arc<Self> to consume ownership, preventing use-after-close at compile time. The registry stores Weak references, so when this Arc is dropped, the database is freed.

Example

use sqlx_sqlite_conn_mgr::SqliteDatabase;

let db = SqliteDatabase::connect("test.db", None).await?;
// ... use database ...
db.close().await?;

pub async fn remove(self: Arc<Self>) -> Result<()>

Close the database and delete all database files

This closes all connections and then deletes the database file, WAL file, and SHM file from disk. Use with caution!

Note: Takes Arc<Self> to consume ownership, preventing use-after-close at compile time. The registry stores Weak references, so when this Arc is dropped, the database is freed.

Example

use sqlx_sqlite_conn_mgr::SqliteDatabase;

let db = SqliteDatabase::connect("temp.db", None).await?;
// ... use database ...
db.remove().await?;

Trait Implementations

impl Debug for SqliteDatabase

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

Formats the value using the given formatter.