use std::{
fmt,
str::FromStr,
time::{Duration, Instant},
};
use sqlx::{
Sqlite, SqlitePool, Transaction,
migrate::{MigrateError, Migrator},
sqlite::{
SqliteConnectOptions, SqliteJournalMode as SqlxJournalMode, SqlitePoolOptions,
SqliteSynchronous as SqlxSynchronous,
},
};
use super::{
config::{
SqliteBootstrapConfig, SqliteConnectionConfig, SqliteJournalMode, SqlitePoolConfig,
SqliteSynchronousMode,
},
diagnostics::{
SqliteBootstrapError, SqliteOperation, SqlitePoolError, diagnose_migration_error,
diagnose_pool_error,
},
};
pub fn connect_options(
config: &SqliteConnectionConfig,
) -> Result<SqliteConnectOptions, SqlitePoolError> {
let mut options = SqliteConnectOptions::from_str(&config.database_url)
.map_err(SqlitePoolError::Sqlx)?
.create_if_missing(config.create_if_missing)
.read_only(config.read_only)
.foreign_keys(config.foreign_keys)
.busy_timeout(config.busy_timeout)
.statement_cache_capacity(config.statement_cache_capacity);
if let Some(mode) = config.journal_mode {
options = options.journal_mode(sqlx_journal_mode(mode));
}
if let Some(mode) = config.synchronous {
options = options.synchronous(sqlx_synchronous_mode(mode));
}
Ok(options)
}
#[must_use]
pub fn pool_options(config: SqlitePoolConfig) -> SqlitePoolOptions {
SqlitePoolOptions::new()
.max_connections(config.max_connections)
.min_connections(config.min_connections)
.acquire_timeout(config.acquire_timeout)
.test_before_acquire(config.test_before_acquire)
.idle_timeout(config.idle_timeout)
.max_lifetime(config.max_lifetime)
}
pub async fn connect_pool(
connection_config: &SqliteConnectionConfig,
pool_config: SqlitePoolConfig,
) -> Result<SqlitePool, SqlitePoolError> {
let options = connect_options(connection_config)?;
connect_pool_with_options(options, pool_config).await
}
pub async fn connect_pool_with_options(
connect_options: SqliteConnectOptions,
pool_config: SqlitePoolConfig,
) -> Result<SqlitePool, SqlitePoolError> {
pool_options(pool_config)
.connect_with(connect_options)
.await
.map_err(SqlitePoolError::Sqlx)
}
pub fn connect_lazy_pool(
connection_config: &SqliteConnectionConfig,
pool_config: SqlitePoolConfig,
) -> Result<SqlitePool, SqlitePoolError> {
let options = connect_options(connection_config)?;
Ok(connect_lazy_pool_with_options(options, pool_config))
}
#[must_use]
pub fn connect_lazy_pool_with_options(
connect_options: SqliteConnectOptions,
pool_config: SqlitePoolConfig,
) -> SqlitePool {
pool_options(pool_config).connect_lazy_with(connect_options)
}
pub async fn bootstrap_database(
config: SqliteBootstrapConfig,
migrator: Option<&Migrator>,
) -> Result<SqlitePool, SqliteBootstrapError> {
let migrator = if config.migrate_on_startup {
Some(migrator.ok_or(SqliteBootstrapError::MissingMigrator)?)
} else {
None
};
let pool = connect_pool(&config.connection_config, config.pool_config)
.await
.map_err(|source| SqliteBootstrapError::Connect {
diagnosis: diagnose_pool_error(SqliteOperation::Connect, &source),
source: Box::new(source),
})?;
if let Some(migrator) = migrator {
tracing::info!("running SQLite database migrations");
run_migrations(&pool, migrator).await.map_err(|source| {
SqliteBootstrapError::Migration {
diagnosis: diagnose_migration_error(&source),
kind: crate::db::MigrationFailureKind::from_error(&source),
source: Box::new(source),
}
})?;
}
Ok(pool)
}
pub async fn run_migrations(pool: &SqlitePool, migrator: &Migrator) -> Result<(), MigrateError> {
migrator.run(pool).await
}
pub async fn ping_pool(pool: &SqlitePool) -> Result<(), sqlx::Error> {
sqlx::query("SELECT 1").execute(pool).await?;
Ok(())
}
pub async fn check_pool_health(pool: &SqlitePool) -> SqliteHealth {
let started = Instant::now();
match ping_pool(pool).await {
Ok(()) => SqliteHealth {
status: SqliteHealthStatus::Ready,
latency: started.elapsed(),
},
Err(_) => SqliteHealth {
status: SqliteHealthStatus::Unavailable,
latency: started.elapsed(),
},
}
}
pub(super) const SQLITE_HEALTH_ERROR: &str = "database health check failed";
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub enum SqliteHealthStatus {
Ready,
Unavailable,
}
#[derive(Clone, PartialEq, Eq)]
#[non_exhaustive]
pub struct SqliteHealth {
pub(super) status: SqliteHealthStatus,
pub(super) latency: Duration,
}
impl fmt::Debug for SqliteHealth {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("SqliteHealth")
.field("status", &self.status)
.field("latency", &self.latency)
.field("has_error", &!self.ready())
.finish()
}
}
impl SqliteHealth {
#[must_use]
pub const fn status(&self) -> SqliteHealthStatus {
self.status
}
#[must_use]
pub const fn latency(&self) -> Duration {
self.latency
}
#[must_use]
pub fn error(&self) -> Option<&str> {
(!self.ready()).then_some(SQLITE_HEALTH_ERROR)
}
#[must_use]
pub const fn ready(&self) -> bool {
matches!(self.status, SqliteHealthStatus::Ready)
}
}
pub type SqliteTransaction<'a> = Transaction<'a, Sqlite>;
pub async fn begin_transaction(pool: &SqlitePool) -> Result<SqliteTransaction<'_>, sqlx::Error> {
pool.begin().await
}
pub async fn commit_transaction(transaction: SqliteTransaction<'_>) -> Result<(), sqlx::Error> {
transaction.commit().await
}
pub async fn rollback_transaction(transaction: SqliteTransaction<'_>) -> Result<(), sqlx::Error> {
transaction.rollback().await
}
const fn sqlx_journal_mode(mode: SqliteJournalMode) -> SqlxJournalMode {
match mode {
SqliteJournalMode::Delete => SqlxJournalMode::Delete,
SqliteJournalMode::Truncate => SqlxJournalMode::Truncate,
SqliteJournalMode::Persist => SqlxJournalMode::Persist,
SqliteJournalMode::Memory => SqlxJournalMode::Memory,
SqliteJournalMode::Wal => SqlxJournalMode::Wal,
SqliteJournalMode::Off => SqlxJournalMode::Off,
}
}
const fn sqlx_synchronous_mode(mode: SqliteSynchronousMode) -> SqlxSynchronous {
match mode {
SqliteSynchronousMode::Off => SqlxSynchronous::Off,
SqliteSynchronousMode::Normal => SqlxSynchronous::Normal,
SqliteSynchronousMode::Full => SqlxSynchronous::Full,
SqliteSynchronousMode::Extra => SqlxSynchronous::Extra,
}
}