use std::{
fmt,
str::FromStr,
time::{Duration, Instant},
};
use sqlx::{
ConnectOptions, Sqlite, SqlitePool, Transaction,
migrate::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> {
database_pool_options(&connect_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 {
database_pool_options(&connect_options, pool_config).connect_lazy_with(connect_options)
}
fn database_pool_options(
options: &SqliteConnectOptions,
config: SqlitePoolConfig,
) -> SqlitePoolOptions {
let transient = options.get_filename().as_os_str().is_empty()
|| options.get_filename() == std::path::Path::new(":memory:")
|| options
.get_filename()
.as_os_str()
.as_encoded_bytes()
.starts_with(b"file:")
|| options
.clone()
.filename("database")
.to_url_lossy()
.query_pairs()
.any(|(key, value)| key == "mode" && value == "memory");
let pool = pool_options(config);
if transient {
pool.max_connections(1)
.min_connections(1)
.idle_timeout(None)
.max_lifetime(None)
.test_before_acquire(false)
} else {
pool
}
}
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");
migrator
.run(&pool)
.await
.map_err(|source| SqliteBootstrapError::Migration {
diagnosis: diagnose_migration_error(&source),
source: Box::new(source),
})?;
}
Ok(pool)
}
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>;
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,
}
}