use core::marker::PhantomData;
use smol_bytes::Utf8BytesMut;
use super::{
BeginRead, SqlDialect, SqlQueryError,
snapshot::{close_read, open_read},
};
use crate::{
ComplexComparison, Cursor, CursorValue, FieldName, InterfaceArm, InterfaceKind, OrderTerm,
RecordAddress, TermName, Walk,
comparison::{
At, Backend,
sql::{
Carrier, QueryBuilder, SelectClause, SqlConjunction, SqlKeyset, SqlLoweringError, SqlOrder,
TermColumns, push_quoted_ident, push_quoted_scope,
},
},
interface::ID,
query::{DEFAULT_PAGE_SIZE, Edge, MAX_PAGE_SIZE, Page, partition},
};
pub trait SqlInterface<Db: Backend + sqlx::Database>: Sized + 'static {
type Kind: InterfaceKind;
type Row: 'static;
type Comparison: ComplexComparison<Db>;
type Value: Carrier<Db> + CursorValue + Clone;
type Order: Clone;
const ARMS: &'static [InterfaceArm<Self::Kind>];
const KIND: &'static FieldName = crate::interface::KIND;
const SOURCE: &'static FieldName = crate::interface::SOURCE;
const UNION: RecordAddress = RecordAddress::new(Self::SOURCE, &[ID]);
const KIND_TERM: OrderTerm = OrderTerm::new(
TermName::new("__ig_kind__"),
Self::KIND,
crate::OrderDirection::Asc,
);
fn address(kind: Self::Kind) -> RecordAddress;
#[inline]
fn table(kind: Self::Kind) -> &'static FieldName {
Self::address(kind).table()
}
#[inline]
fn arm(kind: Self::Kind) -> Option<&'static InterfaceArm<Self::Kind>> {
Self::ARMS.iter().find(|arm| arm.kind() == kind)
}
fn value(row: &Self::Row, term: &OrderTerm) -> Option<Self::Value>;
fn term(order: Self::Order) -> OrderTerm;
#[inline]
fn collection_conjuncts(filter: &Self::Comparison, kind: Self::Kind) -> usize {
let _ = (filter, kind);
0
}
#[inline]
fn collections<'q>(
filter: &'q Self::Comparison,
kind: Self::Kind,
at: At<'_>,
builder: <Db as Backend>::Builder<'q>,
) -> Result<<Db as Backend>::Builder<'q>, <Db as Backend>::Error> {
let _ = (filter, kind, at);
Ok(builder)
}
}
const ID_TERM: OrderTerm = OrderTerm::new(TermName::new("id"), ID, crate::OrderDirection::Asc);
#[must_use]
pub fn total_order<I, Db>(written: &[OrderTerm]) -> Vec<OrderTerm>
where
I: SqlInterface<Db>,
Db: Backend + sqlx::Database,
{
let tail = [I::KIND_TERM, ID_TERM];
let mut order: Vec<OrderTerm> = written
.iter()
.filter(|term| {
!tail
.iter()
.any(|held| held.column() == term.column() && held.leaf() == term.leaf())
})
.cloned()
.collect();
order.extend(tail);
order
}
fn arms<I, Db>() -> Utf8BytesMut
where
I: SqlInterface<Db>,
Db: SqlDialect,
{
let mut body = Utf8BytesMut::new();
for (at, arm) in I::ARMS.iter().enumerate() {
if at > 0 {
body.push_str(" UNION ALL ");
}
body.push_str("SELECT ");
for column in arm.columns() {
push_quoted_ident::<Db>(column.column(), &mut body);
body.push_str(" AS ");
push_quoted_ident::<Db>(column.field(), &mut body);
body.push_str(", ");
}
push_literal(arm.kind().as_str(), &mut body);
body.push_str(" AS ");
push_quoted_ident::<Db>(I::KIND, &mut body);
body.push_str(", ");
let address = I::address(arm.kind());
push_quoted_ident::<Db>(address_column(&address), &mut body);
body.push_str(" AS ");
push_quoted_ident::<Db>(ID, &mut body);
body.push_str(" FROM ");
push_quoted_ident::<Db>(address.table(), &mut body);
}
body
}
fn collections<'q, I, Db>(
filter: &'q I::Comparison,
mut conjunction: SqlConjunction<'q, Db>,
) -> Result<SqlConjunction<'q, Db>, SqlLoweringError>
where
I: SqlInterface<Db>,
Db: SqlDialect,
{
if I::ARMS
.iter()
.all(|arm| I::collection_conjuncts(filter, arm.kind()) == 0)
{
return Ok(conjunction);
}
let alias = I::SOURCE.as_str();
let out = conjunction.open();
out.push("(");
for (at, arm) in I::ARMS.iter().enumerate() {
if at > 0 {
out.push(" OR ");
}
out.push("(");
let mut gate = Utf8BytesMut::new();
push_quoted_scope::<Db>(alias, I::KIND, &mut gate);
gate.push_str(" = ");
push_literal(arm.kind().as_str(), &mut gate);
out.push(gate.as_str());
let address = I::address(arm.kind());
let group = SqlConjunction::with_lead(out, " AND ");
let group = I::collections(
filter,
arm.kind(),
At::aliased(&address, alias, &[ID]),
group,
)?;
let _ = group;
out.push(")");
}
out.push(")");
Ok(conjunction)
}
fn address_column(address: &RecordAddress) -> &'static FieldName {
address.keys().first().copied().unwrap_or(ID)
}
fn push_literal(value: &str, out: &mut Utf8BytesMut) {
out.push('\'');
for character in value.chars() {
if character == '\'' {
out.push('\'');
}
out.push(character);
}
out.push('\'');
}
pub fn union<I, Db>(
filter: Option<&I::Comparison>,
order: &SqlOrder<'_, Db>,
keyset: Option<&SqlKeyset<'_, I::Value, Db>>,
walk: Walk,
limit: Option<u32>,
) -> Result<sqlx::QueryBuilder<Db>, SqlQueryError>
where
I: SqlInterface<Db>,
Db: SqlDialect,
i64: sqlx::Type<Db>,
for<'t> i64: sqlx::Encode<'t, Db>,
{
let mut source = Utf8BytesMut::new();
source.push_str("( ");
source.push_str(arms::<I, Db>().as_str());
source.push_str(" ) AS ");
push_quoted_ident::<Db>(I::SOURCE, &mut source);
let mut builder = QueryBuilder::<SelectClause, Db>::select()
.push_field("*")
.from(source.as_str())
.begin_where();
{
let mut conjunction = SqlConjunction::new(builder.inner_mut());
if let Some(filter) = filter {
conjunction = filter.apply(At::new(&I::UNION), conjunction)?;
conjunction = collections::<I, Db>(filter, conjunction)?;
}
if let Some(keyset) = keyset {
conjunction = keyset.apply(At::new(&I::UNION), conjunction)?;
}
let _ = conjunction;
}
let builder = order.push_order_by_with(builder, walk, At::new(&I::UNION), &TermColumns);
Ok(match limit {
Some(limit) => builder.limit(u64::from(limit)).finalize(),
None => builder.finalize(),
})
}
#[must_use = "a query builder renders nothing until it is fetched"]
pub struct InterfaceFind<'a, I, Db, A>
where
I: SqlInterface<Db>,
Db: Backend + sqlx::Database,
{
executor: A,
filter: Option<&'a I::Comparison>,
}
#[must_use = "a query builder renders nothing until it is fetched"]
pub struct InterfaceOrdered<'a, I, Db, A>
where
I: SqlInterface<Db>,
Db: Backend + sqlx::Database,
{
find: InterfaceFind<'a, I, Db, A>,
order: Vec<OrderTerm>,
}
#[must_use = "a query builder renders nothing until it is fetched"]
pub struct InterfacePaging<'a, I, Db, A, S>
where
I: SqlInterface<Db>,
Db: Backend + sqlx::Database,
{
ordered: InterfaceOrdered<'a, I, Db, A>,
size: u32,
walk: Walk,
cursor: Option<&'a Cursor<I::Value>>,
state: PhantomData<fn() -> S>,
}
impl<'a, I, Db, A> InterfaceFind<'a, I, Db, A>
where
I: SqlInterface<Db>,
Db: Backend + sqlx::Database,
{
#[inline]
pub const fn new(executor: A) -> Self {
Self {
executor,
filter: None,
}
}
#[inline]
pub fn filter(mut self, filter: &'a I::Comparison) -> Self {
self.filter = Some(filter);
self
}
#[inline]
pub fn order(self, written: &[I::Order]) -> InterfaceOrdered<'a, I, Db, A> {
let terms: Vec<OrderTerm> = written
.iter()
.cloned()
.flat_map(|term| I::term(term).levels())
.collect();
InterfaceOrdered {
order: total_order::<I, Db>(&terms),
find: self,
}
}
}
impl<'a, I, Db, A> InterfaceOrdered<'a, I, Db, A>
where
I: SqlInterface<Db>,
Db: Backend + sqlx::Database,
{
#[inline]
pub fn first(self, first: u32) -> InterfacePaging<'a, I, Db, A, super::Forward> {
self.page(first, Walk::Forward)
}
#[inline]
pub fn last(self, last: u32) -> InterfacePaging<'a, I, Db, A, super::Backward> {
self.page(last, Walk::Backward)
}
#[inline]
pub fn after(
self,
cursor: &'a Cursor<I::Value>,
) -> InterfacePaging<'a, I, Db, A, super::Positioned> {
self.first(DEFAULT_PAGE_SIZE).after(cursor)
}
#[inline]
pub fn before(
self,
cursor: &'a Cursor<I::Value>,
) -> InterfacePaging<'a, I, Db, A, super::Positioned> {
self.last(DEFAULT_PAGE_SIZE).before(cursor)
}
fn page<S>(self, size: u32, walk: Walk) -> InterfacePaging<'a, I, Db, A, S> {
InterfacePaging {
ordered: self,
size: size.min(MAX_PAGE_SIZE),
walk,
cursor: None,
state: PhantomData,
}
}
}
impl<'a, I, Db, A> InterfacePaging<'a, I, Db, A, super::Forward>
where
I: SqlInterface<Db>,
Db: Backend + sqlx::Database,
{
#[inline]
pub fn after(
self,
cursor: &'a Cursor<I::Value>,
) -> InterfacePaging<'a, I, Db, A, super::Positioned> {
self.at(cursor)
}
}
impl<'a, I, Db, A> InterfacePaging<'a, I, Db, A, super::Backward>
where
I: SqlInterface<Db>,
Db: Backend + sqlx::Database,
{
#[inline]
pub fn before(
self,
cursor: &'a Cursor<I::Value>,
) -> InterfacePaging<'a, I, Db, A, super::Positioned> {
self.at(cursor)
}
}
impl<'a, I, Db, A, S> InterfacePaging<'a, I, Db, A, S>
where
I: SqlInterface<Db>,
Db: Backend + sqlx::Database,
{
#[inline]
#[must_use]
pub const fn size(&self) -> u32 {
self.size
}
#[inline]
const fn window(&self) -> u32 {
self.size.saturating_add(1)
}
fn at(self, cursor: &'a Cursor<I::Value>) -> InterfacePaging<'a, I, Db, A, super::Positioned> {
InterfacePaging {
ordered: self.ordered,
size: self.size,
walk: self.walk,
cursor: Some(cursor),
state: PhantomData,
}
}
}
async fn edges<I, Db>(
conn: &mut Db::Connection,
statement: &mut sqlx::QueryBuilder<Db>,
terms: &[OrderTerm],
size: usize,
) -> Result<(Vec<Edge<I::Row, I::Value>>, bool), SqlQueryError>
where
I: SqlInterface<Db>,
I::Row: for<'r> sqlx::FromRow<'r, Db::Row>,
Db: SqlDialect,
for<'e> &'e mut Db::Connection: sqlx::Executor<'e, Database = Db>,
Db::Arguments: sqlx::IntoArguments<Db>,
{
let mut raw = sqlx::Executor::fetch_all(&mut *conn, statement.build()).await?;
let more = raw.len() > size;
raw.truncate(size);
let mut edges = Vec::with_capacity(raw.len());
for row in &raw {
let decoded = <I::Row as sqlx::FromRow<'_, Db::Row>>::from_row(row)?;
let values: Vec<Option<I::Value>> = terms.iter().map(|term| I::value(&decoded, term)).collect();
edges.push(Edge::new(decoded, Cursor::at(terms, values)));
}
Ok((edges, more))
}
impl<'a, I, Db, A, S> InterfacePaging<'a, I, Db, A, S>
where
I: SqlInterface<Db>,
I::Row: for<'r> sqlx::FromRow<'r, Db::Row>,
Db: SqlDialect,
i64: sqlx::Type<Db>,
for<'t> i64: sqlx::Encode<'t, Db>,
for<'e> &'e mut Db::Connection: sqlx::Executor<'e, Database = Db>,
Db::Arguments: sqlx::IntoArguments<Db>,
{
pub async fn fetch<'c>(self) -> Result<Page<I::Row, I::Value>, SqlQueryError>
where
A: sqlx::Acquire<'c, Database = Db> + BeginRead,
{
let window = self.window();
let written = self.ordered.order;
let terms = partition::<Db>(&written).paging::<Db>()?;
let order = SqlOrder::<Db>::new(terms)?;
let keyset = self
.cursor
.map(|cursor| SqlKeyset::resume(order, cursor, self.walk))
.transpose()?;
let mut statement = union::<I, Db>(
self.ordered.find.filter,
&order,
keyset.as_ref(),
self.walk,
Some(window),
)?;
let mut held = self.ordered.find.executor.acquire().await?;
let conn = &mut *held;
let opened = open_read::<Db, A>(conn).await?;
let fetched = edges::<I, Db>(conn, &mut statement, terms, self.size as usize).await;
close_read::<Db>(conn, opened, fetched.is_ok()).await?;
let (mut edges, more) = fetched?;
let resumed = self.cursor.is_some();
if matches!(self.walk, Walk::Backward) {
edges.reverse();
}
Ok(match self.walk {
Walk::Forward => Page::new(edges, more, resumed),
Walk::Backward => Page::new(edges, resumed, more),
})
}
}
#[cfg(test)]
mod tests;