use core::marker::PhantomData;
use smol_bytes::Utf8Bytes;
use crate::{
IdColumn, StoredAs, Timestamp,
drive::registry::{RetireOrigin, RootKey},
};
use super::{Landing, RetiredRow, RetiredStore, RetiredStoreError, RetiredTable, UnnameableFamily};
pub trait RetiredSql: sqlx::Database {
const SECOND: &'static str;
const NANOSECOND: &'static str;
const ORIGIN: &'static str;
const FLAG: &'static str;
#[must_use]
fn quote(identifier: &str) -> String;
#[must_use]
fn placeholder(at: usize) -> String;
#[must_use]
fn upsert(root: &str, origin: &str) -> String;
}
#[derive(Debug, Clone, PartialEq, Eq)]
struct Statements {
create: String,
record: String,
erase: String,
roll: String,
}
impl Statements {
fn render<Db: RetiredSql>(table: &RetiredTable, root_word: &str) -> Self {
let name = Db::quote(table.name());
let root = Db::quote(RetiredTable::ROOT);
let second = Db::quote(RetiredTable::RETIRED_SECOND);
let nanosecond = Db::quote(RetiredTable::RETIRED_NANOSECOND);
let origin = Db::quote(RetiredTable::ORIGIN);
let late_tails = Db::quote(RetiredTable::LATE_TAILS);
let columns = format!("{root}, {second}, {nanosecond}, {origin}, {late_tails}");
let binds = (1..=5).map(Db::placeholder).collect::<Vec<_>>().join(", ");
Self {
create: format!(
"CREATE TABLE IF NOT EXISTS {name} ({root} {root_word} NOT NULL, {second} {second_word} \
NOT NULL, {nanosecond} {nanosecond_word} NOT NULL, {origin} {origin_word} NOT NULL, \
{late_tails} {flag_word} NOT NULL, PRIMARY KEY ({root}))",
second_word = Db::SECOND,
nanosecond_word = Db::NANOSECOND,
origin_word = Db::ORIGIN,
flag_word = Db::FLAG,
),
record: format!(
"INSERT INTO {name} ({columns}) VALUES ({binds}) {upsert}",
upsert = Db::upsert(&root, &origin),
),
erase: format!(
"DELETE FROM {name} WHERE {root} = {one}",
one = Db::placeholder(1),
),
roll: format!("SELECT {columns} FROM {name}"),
}
}
}
pub struct SqlRetired<Db: sqlx::Database, Root> {
pool: sqlx::Pool<Db>,
table: RetiredTable,
statements: Statements,
root: PhantomData<fn() -> Root>,
}
impl<Db: sqlx::Database, Root> core::fmt::Debug for SqlRetired<Db, Root> {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.debug_struct("SqlRetired")
.field("table", &self.table.name())
.finish_non_exhaustive()
}
}
impl<Db: sqlx::Database, Root> Clone for SqlRetired<Db, Root> {
fn clone(&self) -> Self {
Self {
pool: self.pool.clone(),
table: self.table.clone(),
statements: self.statements.clone(),
root: PhantomData,
}
}
}
impl<Db, Root> SqlRetired<Db, Root>
where
Db: RetiredSql,
Root: IdColumn<Db>,
<Root as IdColumn<Db>>::Stored: StoredAs<Db>,
{
pub fn new(pool: sqlx::Pool<Db>, family: impl Into<Utf8Bytes>) -> Result<Self, UnnameableFamily> {
let table = RetiredTable::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,
statements,
root: PhantomData,
})
}
#[inline]
#[must_use]
pub const fn table(&self) -> &RetiredTable {
&self.table
}
#[inline]
#[must_use]
pub fn create_statement(&self) -> &str {
&self.statements.create
}
#[inline]
#[must_use]
pub fn record_statement(&self) -> &str {
&self.statements.record
}
#[inline]
#[must_use]
pub fn erase_statement(&self) -> &str {
&self.statements.erase
}
#[inline]
#[must_use]
pub fn roll_statement(&self) -> &str {
&self.statements.roll
}
}
macro_rules! sql_ledger {
(
$db:ty, $feature:literal, {
second: $second:literal,
nanosecond: $nanosecond:literal,
origin: $origin:literal,
flag: $flag:literal,
quote: $quote:expr,
placeholder: $placeholder:expr,
upsert: $upsert:expr,
}
) => {
#[cfg(feature = $feature)]
#[cfg_attr(docsrs, doc(cfg(feature = $feature)))]
impl RetiredSql for $db {
const SECOND: &'static str = $second;
const NANOSECOND: &'static str = $nanosecond;
const ORIGIN: &'static str = $origin;
const FLAG: &'static str = $flag;
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 upsert(root: &str, origin: &str) -> String {
#[allow(clippy::redundant_closure_call)]
($upsert)(root, origin)
}
}
#[cfg(feature = $feature)]
#[cfg_attr(docsrs, doc(cfg(feature = $feature)))]
impl<Root> RetiredStore<Root> for SqlRetired<$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) -> Landing<'_, ()> {
Box::pin(async move {
sqlx::query(sqlx::AssertSqlSafe(self.statements.create.clone()))
.execute(&self.pool)
.await
.map(|_created| ())
.map_err(|source| RetiredStoreError::new("ready", self.table.named(), source))
})
}
fn record<'a>(&'a self, row: &'a RetiredRow<Root>) -> Landing<'a, ()> {
Box::pin(async move {
sqlx::query(sqlx::AssertSqlSafe(self.statements.record.clone()))
.bind(row.key().to_stored())
.bind(row.at().as_second())
.bind(row.at().subsec_nanosecond())
.bind(row.origin().as_str().to_owned())
.bind(row.late_tails())
.execute(&self.pool)
.await
.map(|_written| ())
.map_err(|source| RetiredStoreError::new("record", self.table.named(), source))
})
}
fn erase<'a>(&'a self, key: &'a Root) -> Landing<'a, ()> {
Box::pin(async move {
sqlx::query(sqlx::AssertSqlSafe(self.statements.erase.clone()))
.bind(key.to_stored())
.execute(&self.pool)
.await
.map(|_gone| ())
.map_err(|source| RetiredStoreError::new("erase", self.table.named(), source))
})
}
fn roll(&self) -> Landing<'_, Vec<RetiredRow<Root>>> {
Box::pin(async move {
let rows = sqlx::query(sqlx::AssertSqlSafe(self.statements.roll.clone()))
.fetch_all(&self.pool)
.await
.map_err(|source| RetiredStoreError::new("roll", self.table.named(), source))?;
rows.into_iter().map(|row| self.read_row(&row)).collect()
})
}
}
#[cfg(feature = $feature)]
impl<Root> SqlRetired<$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<RetiredRow<Root>, RetiredStoreError> {
use sqlx::Row as _;
let refuse =
|source: sqlx::Error| RetiredStoreError::new("roll", self.table.named(), source);
let stored: <Root as IdColumn<$db>>::Stored =
row.try_get(RetiredTable::ROOT).map_err(refuse)?;
let key = Root::from_stored(stored)
.map_err(|refusal| refuse(sqlx::Error::Decode(Box::new(refusal))))?;
let second: i64 = row.try_get(RetiredTable::RETIRED_SECOND).map_err(refuse)?;
let nanosecond: i32 = row
.try_get(RetiredTable::RETIRED_NANOSECOND)
.map_err(refuse)?;
let at = Timestamp::from_parts(second, nanosecond)
.map_err(|refusal| refuse(sqlx::Error::Decode(Box::new(refusal))))?;
let origin: String = row.try_get(RetiredTable::ORIGIN).map_err(refuse)?;
let late_tails: bool = row.try_get(RetiredTable::LATE_TAILS).map_err(refuse)?;
Ok(RetiredRow::new(
key,
at,
RetireOrigin::from(origin),
late_tails,
))
}
}
};
}
sql_ledger!(sqlx::Sqlite, "sqlite", {
second: "INTEGER",
nanosecond: "INTEGER",
origin: "TEXT",
flag: "INTEGER",
quote: |identifier: &str| format!("\"{identifier}\""),
placeholder: |_at: usize| "?".to_owned(),
upsert: |root: &str, origin: &str| {
format!("ON CONFLICT ({root}) DO UPDATE SET {origin} = excluded.{origin}")
},
});
sql_ledger!(sqlx::Postgres, "postgres", {
second: "bigint",
nanosecond: "integer",
origin: "text",
flag: "boolean",
quote: |identifier: &str| format!("\"{identifier}\""),
placeholder: |at: usize| format!("${at}"),
upsert: |root: &str, origin: &str| {
format!("ON CONFLICT ({root}) DO UPDATE SET {origin} = EXCLUDED.{origin}")
},
});
sql_ledger!(sqlx::MySql, "mysql", {
second: "bigint",
nanosecond: "int",
origin: "varchar(255)",
flag: "tinyint(1)",
quote: |identifier: &str| format!("`{identifier}`"),
placeholder: |_at: usize| "?".to_owned(),
upsert: |_root: &str, origin: &str| format!("ON DUPLICATE KEY UPDATE {origin} = VALUES({origin})"),
});