use core::{marker::PhantomData, num::NonZeroUsize};
use smol_bytes::Utf8Bytes;
use crate::{IdColumn, StoredAs, Timestamp, drive::registry::RootKey};
use super::{
Culled, CurrentRow, CurrentTable, Generational, GenerationsStore, GenerationsStoreError,
RUN_COLUMN, RunId, Scope, Turning, UnnameableTable,
};
pub trait GenerationsSql: sqlx::Database {
const SCOPE: &'static str;
const RUN: &'static str;
const SECOND: &'static str;
const NANOSECOND: &'static str;
#[must_use]
fn quote(identifier: &str) -> String;
#[must_use]
fn placeholder(at: usize) -> String;
#[must_use]
fn flip(root: &str, scope: &str, values: &[&str]) -> String;
}
#[must_use]
pub fn current_filter<Db: GenerationsSql>(
record: &str,
root_column: &str,
pointers: &CurrentTable,
scope_at: usize,
) -> String {
let record = Db::quote(record);
format!(
"{record}.{run_column} = (SELECT {run} FROM {table} WHERE {root} = {record}.{root_column} AND \
{scope} = {marker})",
run_column = Db::quote(RUN_COLUMN),
run = Db::quote(CurrentTable::RUN),
table = Db::quote(pointers.name()),
root = Db::quote(CurrentTable::ROOT),
root_column = Db::quote(root_column),
scope = Db::quote(CurrentTable::SCOPE),
marker = Db::placeholder(scope_at),
)
}
#[derive(Debug, Clone, PartialEq, Eq)]
struct Statements {
create: String,
point: String,
current: String,
roll: String,
}
impl Statements {
fn render<Db: GenerationsSql>(table: &CurrentTable, root_word: &str) -> Self {
let name = Db::quote(table.name());
let root = Db::quote(CurrentTable::ROOT);
let scope = Db::quote(CurrentTable::SCOPE);
let run = Db::quote(CurrentTable::RUN);
let second = Db::quote(CurrentTable::FLIPPED_SECOND);
let nanosecond = Db::quote(CurrentTable::FLIPPED_NANOSECOND);
let columns = format!("{root}, {scope}, {run}, {second}, {nanosecond}");
let binds = (1..=5).map(Db::placeholder).collect::<Vec<_>>().join(", ");
Self {
create: format!(
"CREATE TABLE IF NOT EXISTS {name} ({root} {root_word} NOT NULL, {scope} {scope_word} NOT \
NULL, {run} {run_word} NOT NULL, {second} {second_word} NOT NULL, {nanosecond} \
{nanosecond_word} NOT NULL, PRIMARY KEY ({root}, {scope}))",
scope_word = Db::SCOPE,
run_word = Db::RUN,
second_word = Db::SECOND,
nanosecond_word = Db::NANOSECOND,
),
point: format!(
"INSERT INTO {name} ({columns}) VALUES ({binds}) {flip}",
flip = Db::flip(&root, &scope, &[&run, &second, &nanosecond]),
),
current: format!(
"SELECT {run} FROM {name} WHERE {root} = {one} AND {scope} = {two}",
one = Db::placeholder(1),
two = Db::placeholder(2),
),
roll: format!("SELECT {columns} FROM {name}"),
}
}
}
fn sweep_statement<Db: GenerationsSql>(table: &Generational, keep: NonZeroUsize) -> String {
let name = Db::quote(table.table());
let root = Db::quote(table.root());
let run = Db::quote(RUN_COLUMN);
format!(
"DELETE FROM {name} WHERE {root} = {one} AND {run} < (SELECT MIN(r) FROM (SELECT DISTINCT {run} \
AS r FROM {name} WHERE {root} = {two} AND {run} <= {three} ORDER BY r DESC LIMIT {keep}) AS \
kept)",
one = Db::placeholder(1),
two = Db::placeholder(2),
three = Db::placeholder(3),
)
}
pub struct SqlGenerations<Db: sqlx::Database, Root> {
pool: sqlx::Pool<Db>,
table: CurrentTable,
roster: Vec<Generational>,
statements: Statements,
root: PhantomData<fn() -> Root>,
}
impl<Db: sqlx::Database, Root> core::fmt::Debug for SqlGenerations<Db, Root> {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.debug_struct("SqlGenerations")
.field("table", &self.table.name())
.field("roster", &self.roster.len())
.finish_non_exhaustive()
}
}
impl<Db: sqlx::Database, Root> Clone for SqlGenerations<Db, Root> {
fn clone(&self) -> Self {
Self {
pool: self.pool.clone(),
table: self.table.clone(),
roster: self.roster.clone(),
statements: self.statements.clone(),
root: PhantomData,
}
}
}
impl<Db, Root> SqlGenerations<Db, Root>
where
Db: GenerationsSql,
Root: IdColumn<Db>,
<Root as IdColumn<Db>>::Stored: StoredAs<Db>,
{
pub fn new(
pool: sqlx::Pool<Db>,
family: impl Into<Utf8Bytes>,
roster: Vec<Generational>,
) -> Result<Self, UnnameableTable> {
let table = CurrentTable::new(family)?;
let root_word = <<Root as IdColumn<Db>>::Stored as StoredAs<Db>>::WORDS
.first()
.expect("an id spans exactly one column, so its stored form has exactly one word");
let statements = Statements::render::<Db>(&table, root_word);
Ok(Self {
pool,
table,
roster,
statements,
root: PhantomData,
})
}
#[inline]
#[must_use]
pub const fn table(&self) -> &CurrentTable {
&self.table
}
#[inline]
#[must_use]
pub fn roster(&self) -> &[Generational] {
&self.roster
}
#[inline]
#[must_use]
pub fn create_statement(&self) -> &str {
&self.statements.create
}
#[inline]
#[must_use]
pub fn point_statement(&self) -> &str {
&self.statements.point
}
#[inline]
#[must_use]
pub fn current_statement(&self) -> &str {
&self.statements.current
}
#[inline]
#[must_use]
pub fn roll_statement(&self) -> &str {
&self.statements.roll
}
#[inline]
#[must_use]
pub fn sweep_statement(&self, table: &Generational, keep: NonZeroUsize) -> String {
sweep_statement::<Db>(table, keep)
}
}
macro_rules! sql_generations {
(
$db:ty, $feature:literal, {
scope: $scope:literal,
run: $run:literal,
second: $second:literal,
nanosecond: $nanosecond:literal,
quote: $quote:expr,
placeholder: $placeholder:expr,
flip: $flip:expr,
}
) => {
#[cfg(feature = $feature)]
#[cfg_attr(docsrs, doc(cfg(feature = $feature)))]
impl GenerationsSql for $db {
const SCOPE: &'static str = $scope;
const RUN: &'static str = $run;
const SECOND: &'static str = $second;
const NANOSECOND: &'static str = $nanosecond;
fn quote(identifier: &str) -> String {
#[allow(clippy::redundant_closure_call)]
($quote)(identifier)
}
fn placeholder(at: usize) -> String {
#[allow(clippy::redundant_closure_call)]
($placeholder)(at)
}
fn flip(root: &str, scope: &str, values: &[&str]) -> String {
#[allow(clippy::redundant_closure_call)]
($flip)(root, scope, values)
}
}
#[cfg(feature = $feature)]
#[cfg_attr(docsrs, doc(cfg(feature = $feature)))]
impl<Root> GenerationsStore<Root> for SqlGenerations<$db, Root>
where
Root: RootKey + IdColumn<$db>,
<Root as IdColumn<$db>>::Stored: StoredAs<$db>
+ sqlx::Type<$db>
+ for<'q> sqlx::Encode<'q, $db>
+ for<'r> sqlx::Decode<'r, $db>
+ Send
+ Unpin
+ 'static,
{
fn ready(&self) -> Turning<'_, ()> {
Box::pin(async move {
sqlx::query(sqlx::AssertSqlSafe(self.statements.create.clone()))
.execute(&self.pool)
.await
.map(|_created| ())
.map_err(|source| GenerationsStoreError::new("ready", self.table.named(), source))
})
}
fn point<'a>(&'a self, row: &'a CurrentRow<Root>) -> Turning<'a, ()> {
Box::pin(async move {
sqlx::query(sqlx::AssertSqlSafe(self.statements.point.clone()))
.bind(row.key().to_stored())
.bind(row.scope().as_str().to_owned())
.bind(row.run().as_i64())
.bind(row.at().as_second())
.bind(row.at().subsec_nanosecond())
.execute(&self.pool)
.await
.map(|_flipped| ())
.map_err(|source| GenerationsStoreError::new("point", self.table.named(), source))
})
}
fn current<'a>(&'a self, key: &'a Root, scope: &'a Scope) -> Turning<'a, Option<RunId>> {
Box::pin(async move {
use sqlx::Row as _;
let row = sqlx::query(sqlx::AssertSqlSafe(self.statements.current.clone()))
.bind(key.to_stored())
.bind(scope.as_str().to_owned())
.fetch_optional(&self.pool)
.await
.map_err(|source| GenerationsStoreError::new("current", self.table.named(), source))?;
row
.map(|row| {
row
.try_get::<i64, _>(CurrentTable::RUN)
.map(RunId::from_i64)
.map_err(|source| GenerationsStoreError::new("current", self.table.named(), source))
})
.transpose()
})
}
fn roll(&self) -> Turning<'_, Vec<CurrentRow<Root>>> {
Box::pin(async move {
let rows = sqlx::query(sqlx::AssertSqlSafe(self.statements.roll.clone()))
.fetch_all(&self.pool)
.await
.map_err(|source| GenerationsStoreError::new("roll", self.table.named(), source))?;
rows.into_iter().map(|row| self.read_row(&row)).collect()
})
}
fn sweep<'a>(
&'a self,
key: &'a Root,
current: RunId,
keep: NonZeroUsize,
) -> Turning<'a, Culled> {
Box::pin(async move {
let mut swept = Culled::default();
for table in &self.roster {
let statement = sweep_statement::<$db>(table, keep);
let done = sqlx::query(sqlx::AssertSqlSafe(statement))
.bind(key.to_stored())
.bind(key.to_stored())
.bind(current.as_i64())
.execute(&self.pool)
.await
.map_err(|source| {
GenerationsStoreError::new("sweep", table.table().to_owned(), source)
})?;
swept.tables += 1;
swept.rows += done.rows_affected();
}
Ok(swept)
})
}
}
#[cfg(feature = $feature)]
impl<Root> SqlGenerations<$db, Root>
where
Root: RootKey + IdColumn<$db>,
<Root as IdColumn<$db>>::Stored:
sqlx::Type<$db> + for<'r> sqlx::Decode<'r, $db> + Send + Unpin + 'static,
{
fn read_row(
&self,
row: &<$db as sqlx::Database>::Row,
) -> Result<CurrentRow<Root>, GenerationsStoreError> {
use sqlx::Row as _;
let refuse =
|source: sqlx::Error| GenerationsStoreError::new("roll", self.table.named(), source);
let stored: <Root as IdColumn<$db>>::Stored =
row.try_get(CurrentTable::ROOT).map_err(refuse)?;
let key = Root::from_stored(stored)
.map_err(|refusal| refuse(sqlx::Error::Decode(Box::new(refusal))))?;
let scope: String = row.try_get(CurrentTable::SCOPE).map_err(refuse)?;
let scope =
Scope::new(scope).map_err(|refusal| refuse(sqlx::Error::Decode(Box::new(refusal))))?;
let run: i64 = row.try_get(CurrentTable::RUN).map_err(refuse)?;
let second: i64 = row.try_get(CurrentTable::FLIPPED_SECOND).map_err(refuse)?;
let nanosecond: i32 = row
.try_get(CurrentTable::FLIPPED_NANOSECOND)
.map_err(refuse)?;
let at = Timestamp::from_parts(second, nanosecond)
.map_err(|refusal| refuse(sqlx::Error::Decode(Box::new(refusal))))?;
Ok(CurrentRow::new(key, scope, RunId::from_i64(run), at))
}
}
};
}
sql_generations!(sqlx::Sqlite, "sqlite", {
scope: "TEXT",
run: "INTEGER",
second: "INTEGER",
nanosecond: "INTEGER",
quote: |identifier: &str| format!("\"{identifier}\""),
placeholder: |_at: usize| "?".to_owned(),
flip: |root: &str, scope: &str, values: &[&str]| {
let sets = values
.iter()
.map(|value| format!("{value} = excluded.{value}"))
.collect::<Vec<_>>()
.join(", ");
format!("ON CONFLICT ({root}, {scope}) DO UPDATE SET {sets}")
},
});
sql_generations!(sqlx::Postgres, "postgres", {
scope: "text",
run: "bigint",
second: "bigint",
nanosecond: "integer",
quote: |identifier: &str| format!("\"{identifier}\""),
placeholder: |at: usize| format!("${at}"),
flip: |root: &str, scope: &str, values: &[&str]| {
let sets = values
.iter()
.map(|value| format!("{value} = EXCLUDED.{value}"))
.collect::<Vec<_>>()
.join(", ");
format!("ON CONFLICT ({root}, {scope}) DO UPDATE SET {sets}")
},
});
sql_generations!(sqlx::MySql, "mysql", {
scope: "varchar(255)",
run: "bigint",
second: "bigint",
nanosecond: "int",
quote: |identifier: &str| format!("`{identifier}`"),
placeholder: |_at: usize| "?".to_owned(),
flip: |_root: &str, _scope: &str, values: &[&str]| {
let sets = values
.iter()
.map(|value| format!("{value} = VALUES({value})"))
.collect::<Vec<_>>()
.join(", ");
format!("ON DUPLICATE KEY UPDATE {sets}")
},
});