use core::{borrow::BorrowMut, marker::PhantomData};
use super::{
ClauseTransition, NullOrder, NullOrdering, NullPosition, OrderByClause, OrderSubjects,
QueryBuilder, QuoteIdent, SubjectSlot, pinned_nulls,
};
use crate::{
OrderSignature, OrderTerm, TermName, Walk,
comparison::At,
query::{ColumnNotStored, OrderCapability, Unpushable, partition},
};
pub struct SqlOrder<'a, Db> {
terms: &'a [OrderTerm],
db: PhantomData<fn() -> Db>,
}
impl<'a, Db: NullOrder + OrderCapability> SqlOrder<'a, Db> {
pub fn new(terms: &'a [OrderTerm]) -> Result<Self, SqlOrderError> {
if terms.is_empty() {
return Err(SqlOrderError::Empty);
}
let partition = partition::<Db>(terms);
if let Some(refused) = partition.remainder().first() {
let term = refused.identity();
return Err(match partition.cause() {
Some(Unpushable::NotStored) => SqlOrderError::NotStored(ColumnNotStored::new(
term,
refused
.subject()
.absent_from()
.expect("a term refused as unstored names the dialect that has not got it"),
)),
Some(Unpushable::Repetition) => SqlOrderError::Repetition(term),
Some(Unpushable::CollectionTable) => SqlOrderError::CollectionTable(term),
Some(Unpushable::CollectionSemantics) => SqlOrderError::CollectionSemantics(term),
Some(Unpushable::CollectionShadow) => SqlOrderError::CollectionShadow(term),
_ => SqlOrderError::NullPosition(term),
});
}
Ok(Self {
terms,
db: PhantomData,
})
}
}
impl<'a, Db> SqlOrder<'a, Db> {
#[inline]
#[must_use]
pub const fn terms(&self) -> &'a [OrderTerm] {
self.terms
}
#[inline]
#[must_use]
pub fn signature(&self) -> OrderSignature {
OrderSignature::of(self.terms)
}
}
impl<'a, Db> SqlOrder<'a, Db>
where
Db: sqlx::Database + QuoteIdent + NullOrder,
{
pub fn push_order_by<S, QB>(
self,
builder: QueryBuilder<S, Db, QB>,
walk: Walk,
) -> QueryBuilder<OrderByClause, Db, QB>
where
S: ClauseTransition<OrderByClause>,
QB: BorrowMut<sqlx::QueryBuilder<Db>>,
{
let (first, rest) = self
.terms
.split_first()
.expect("`SqlOrder::new` refuses an order over no terms");
let mut builder = push_term::<Db, _, _>(builder, first, walk);
for term in rest {
builder = push_term::<Db, _, _>(builder, term, walk);
}
builder
}
}
impl<Db: sqlx::Database + NullOrder> SqlOrder<'_, Db> {
pub fn push_order_by_with<S, QB, Sub>(
self,
builder: QueryBuilder<S, Db, QB>,
walk: Walk,
at: At<'_>,
subjects: &Sub,
) -> QueryBuilder<OrderByClause, Db, QB>
where
S: ClauseTransition<OrderByClause>,
QB: BorrowMut<sqlx::QueryBuilder<Db>>,
Sub: OrderSubjects<Db> + ?Sized,
{
let mut builder =
push_subject_entry::<Db, _, _, Sub>(builder, self.terms, 0, 0, walk, at, subjects);
for leaf in 1..self.terms[0].width() {
builder =
push_subject_entry::<Db, _, _, Sub>(builder, self.terms, 0, leaf, walk, at, subjects);
}
for level in 1..self.terms.len() {
for leaf in 0..self.terms[level].width() {
builder =
push_subject_entry::<Db, _, _, Sub>(builder, self.terms, level, leaf, walk, at, subjects);
}
}
builder
}
}
fn push_subject_entry<Db, S, QB, Sub>(
builder: QueryBuilder<S, Db, QB>,
terms: &[OrderTerm],
level: usize,
leaf: usize,
walk: Walk,
at: At<'_>,
subjects: &Sub,
) -> QueryBuilder<OrderByClause, Db, QB>
where
Db: sqlx::Database + NullOrder,
S: ClauseTransition<OrderByClause>,
QB: BorrowMut<sqlx::QueryBuilder<Db>>,
Sub: OrderSubjects<Db> + ?Sized,
{
let term = &terms[level];
let direction = walk.direction(term.direction());
let shape = subjects.shape(terms, level);
builder.order_by_with(
|qb| subjects.push_entry(SubjectSlot::new(qb, shape), at, terms, level, leaf),
direction.is_descending(),
nulls::<Db>(term, walk),
)
}
fn push_term<Db, S, QB>(
builder: QueryBuilder<S, Db, QB>,
term: &OrderTerm,
walk: Walk,
) -> QueryBuilder<OrderByClause, Db, QB>
where
Db: sqlx::Database + QuoteIdent + NullOrder,
S: ClauseTransition<OrderByClause>,
QB: BorrowMut<sqlx::QueryBuilder<Db>>,
{
let direction = walk.direction(term.direction());
builder.order_by_nulls(
term.column(),
direction.is_descending(),
nulls::<Db>(term, walk),
)
}
fn nulls<Db: NullOrder>(term: &OrderTerm, walk: Walk) -> Option<NullPosition> {
if !term.is_nullable() || !matches!(Db::NULLS, NullOrdering::Explicit) {
return None;
}
Some(pinned_nulls(walk.direction(term.direction())))
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum SqlOrderError {
NotStored(ColumnNotStored),
Empty,
NullPosition(&'static TermName),
Repetition(&'static TermName),
CollectionTable(&'static TermName),
CollectionSemantics(&'static TermName),
CollectionShadow(&'static TermName),
}
impl core::fmt::Display for SqlOrderError {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
match self {
Self::Empty => f.write_str("an order over no terms has no spelling"),
Self::NotStored(why) => write!(f, "{why}"),
Self::NullPosition(term) => {
let term: &str = term;
write!(
f,
"`{term}` is nullable and this dialect cannot put NULL below every value"
)
}
Self::Repetition(term) => {
let term: &str = term;
write!(
f,
"`{term}` is named twice and this dialect's ordering holds one entry per subject"
)
}
Self::CollectionTable(term) => {
let term: &str = term;
write!(
f,
"`{term}` is a collection kept in a table of its own, so this row's ORDER BY has no \
column for it"
)
}
Self::CollectionSemantics(term) => {
let term: &str = term;
write!(
f,
"`{term}` is a collection, and this dialect does not order one element by element"
)
}
Self::CollectionShadow(term) => {
let term: &str = term;
write!(
f,
"`{term}` is a collection ordered through a companion column, and this dialect does not \
order a binary column bytewise"
)
}
}
}
}
impl core::error::Error for SqlOrderError {}
impl<Db> core::fmt::Debug for SqlOrder<'_, Db> {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.debug_struct("SqlOrder")
.field("terms", &self.terms)
.finish()
}
}
impl<Db> Clone for SqlOrder<'_, Db> {
#[inline]
fn clone(&self) -> Self {
*self
}
}
impl<Db> Copy for SqlOrder<'_, Db> {}
impl<Db> PartialEq for SqlOrder<'_, Db> {
#[inline]
fn eq(&self, other: &Self) -> bool {
self.terms == other.terms
}
}
#[cfg(test)]
mod tests;