#![cfg(any(feature = "sqlite", feature = "postgres", feature = "mysql"))]
use super::{SqlOrder, SqlOrderError};
use crate::{
FieldName, OrderDirection, OrderTerm, RecordAddress, TermName, Walk,
comparison::{
At,
sql::{
NullOrder, NullOrdering, OrderSubjects, QueryBuilder, QuoteIdent, SelectClause, SubjectShape,
SubjectSlot, TermColumns, quote_ident,
},
},
query::{
CollectionBoundary, CollectionOrdering, NullPlacement, OrderCapability, ShadowBoundary,
ShadowOrdering, TermRepetition,
},
};
const CREATED: &TermName = TermName::new("created_at");
const TITLE: &TermName = TermName::new("title");
const ID: &TermName = TermName::new("id");
const TAGS: &TermName = TermName::new("tags");
fn required() -> [OrderTerm; 2] {
[
OrderTerm::new(CREATED, FieldName::new("created_at"), OrderDirection::Desc),
OrderTerm::new(ID, FieldName::new("id"), OrderDirection::Asc),
]
}
fn optional() -> [OrderTerm; 3] {
[
OrderTerm::nullable(TITLE, FieldName::new("title"), OrderDirection::Asc),
OrderTerm::new(CREATED, FieldName::new("created_at"), OrderDirection::Desc),
OrderTerm::new(ID, FieldName::new("id"), OrderDirection::Asc),
]
}
fn ordered<Db>(terms: &[OrderTerm], walk: Walk) -> String
where
Db: sqlx::Database + QuoteIdent + NullOrder + OrderCapability,
{
let order = SqlOrder::<Db>::new(terms).expect("this order is renderable for this dialect");
order
.push_order_by(
QueryBuilder::<SelectClause, Db>::select()
.push_field("*")
.from("t"),
walk,
)
.finalize()
.into_string()
}
const ROW: RecordAddress = RecordAddress::new(FieldName::new("clip"), &[FieldName::new("id")]);
fn ordered_over<Db, S>(terms: &[OrderTerm], walk: Walk, subjects: &S) -> String
where
Db: sqlx::Database + NullOrder + OrderCapability,
S: OrderSubjects<Db>,
{
let order = SqlOrder::<Db>::new(terms).expect("this order is renderable for this dialect");
order
.push_order_by_with(
QueryBuilder::<SelectClause, Db>::select()
.push_field("*")
.from("t"),
walk,
At::new(&ROW),
subjects,
)
.finalize()
.into_string()
}
struct CoverTitle;
impl<Db: sqlx::Database + crate::Backend<Buffer: core::fmt::Display> + QuoteIdent> OrderSubjects<Db>
for CoverTitle
{
fn push_subject(&self, slot: SubjectSlot<'_, Db>, at: At<'_>, terms: &[OrderTerm], level: usize) {
if level > 0 {
TermColumns.push_subject(slot, at, terms, level);
return;
}
slot.write(|qb| {
qb.push("SELECT ");
qb.push(quote_ident::<Db>(FieldName::new("title")));
qb.push(" FROM ");
qb.push(quote_ident::<Db>(FieldName::new("keyframe")));
qb.push(" WHERE ");
qb.push(quote_ident::<Db>(FieldName::new("id")));
qb.push(" = ");
qb.push(quote_ident::<Db>(FieldName::new("cover_id")));
});
}
fn shape(&self, _: &[OrderTerm], level: usize) -> SubjectShape {
if level > 0 {
return SubjectShape::Column;
}
SubjectShape::SubSelect
}
}
#[test]
fn the_named_ordering_is_the_subject_seam_at_its_default() {
#[cfg(feature = "sqlite")]
for walk in [Walk::Forward, Walk::Backward] {
for terms in [&required()[..], &optional()[..]] {
assert_eq!(
ordered_over::<sqlx::Sqlite, _>(terms, walk, &TermColumns),
ordered::<sqlx::Sqlite>(terms, walk)
);
}
}
#[cfg(feature = "postgres")]
for walk in [Walk::Forward, Walk::Backward] {
for terms in [&required()[..], &optional()[..]] {
assert_eq!(
ordered_over::<sqlx::Postgres, _>(terms, walk, &TermColumns),
ordered::<sqlx::Postgres>(terms, walk)
);
}
}
#[cfg(feature = "mysql")]
for walk in [Walk::Forward, Walk::Backward] {
for terms in [&required()[..], &optional()[..]] {
assert_eq!(
ordered_over::<sqlx::MySql, _>(terms, walk, &TermColumns),
ordered::<sqlx::MySql>(terms, walk)
);
}
}
}
#[cfg(feature = "sqlite")]
#[test]
fn a_correlated_subquery_is_an_ordering_term_like_any_other() {
assert_eq!(
ordered_over::<sqlx::Sqlite, _>(&required(), Walk::Forward, &CoverTitle),
"SELECT * FROM t ORDER BY \
(SELECT \"title\" FROM \"keyframe\" WHERE \"id\" = \"cover_id\") DESC, \"id\" ASC"
);
}
#[cfg(feature = "postgres")]
#[test]
fn a_nested_term_takes_the_pinned_null_position_too() {
assert_eq!(
ordered_over::<sqlx::Postgres, _>(&optional(), Walk::Forward, &CoverTitle),
"SELECT * FROM t ORDER BY \
(SELECT \"title\" FROM \"keyframe\" WHERE \"id\" = \"cover_id\") ASC NULLS FIRST, \
\"created_at\" DESC, \"id\" ASC"
);
assert_eq!(
ordered_over::<sqlx::Postgres, _>(&optional(), Walk::Backward, &CoverTitle),
"SELECT * FROM t ORDER BY \
(SELECT \"title\" FROM \"keyframe\" WHERE \"id\" = \"cover_id\") DESC NULLS LAST, \
\"created_at\" ASC, \"id\" DESC"
);
}
#[cfg(feature = "sqlite")]
#[test]
fn one_subjects_value_serves_both_renderings() {
let subjects = CoverTitle;
assert_eq!(
ordered_over::<sqlx::Sqlite, _>(&required(), Walk::Forward, &&subjects),
ordered_over::<sqlx::Sqlite, _>(&required(), Walk::Forward, &subjects)
);
}
#[test]
fn the_dialects_that_already_agree_state_nothing() {
#[cfg(feature = "sqlite")]
{
assert_eq!(<sqlx::Sqlite as NullOrder>::NULLS, NullOrdering::Implicit);
assert_eq!(
ordered::<sqlx::Sqlite>(&optional(), Walk::Forward),
"SELECT * FROM t ORDER BY \"title\" ASC, \"created_at\" DESC, \"id\" ASC"
);
}
#[cfg(feature = "mysql")]
{
assert_eq!(<sqlx::MySql as NullOrder>::NULLS, NullOrdering::Implicit);
assert_eq!(
ordered::<sqlx::MySql>(&optional(), Walk::Forward),
"SELECT * FROM t ORDER BY `title` ASC, `created_at` DESC, `id` ASC"
);
}
}
#[cfg(feature = "postgres")]
#[test]
fn postgres_states_the_position_on_the_term() {
assert_eq!(<sqlx::Postgres as NullOrder>::NULLS, NullOrdering::Explicit);
assert_eq!(
ordered::<sqlx::Postgres>(&optional(), Walk::Forward),
"SELECT * FROM t ORDER BY \"title\" ASC NULLS FIRST, \"created_at\" DESC, \"id\" ASC"
);
}
#[cfg(feature = "postgres")]
#[test]
fn a_not_null_term_states_nothing_even_where_the_dialect_disagrees() {
assert_eq!(
ordered::<sqlx::Postgres>(&required(), Walk::Forward),
"SELECT * FROM t ORDER BY \"created_at\" DESC, \"id\" ASC"
);
}
#[cfg(feature = "sqlite")]
#[test]
fn a_backward_walk_inverts_every_term() {
assert_eq!(
ordered::<sqlx::Sqlite>(&required(), Walk::Backward),
"SELECT * FROM t ORDER BY \"created_at\" ASC, \"id\" DESC"
);
}
#[cfg(feature = "postgres")]
#[test]
fn the_pinned_position_inverts_with_the_walk() {
assert_eq!(
ordered::<sqlx::Postgres>(&optional(), Walk::Forward),
"SELECT * FROM t ORDER BY \"title\" ASC NULLS FIRST, \"created_at\" DESC, \"id\" ASC"
);
assert_eq!(
ordered::<sqlx::Postgres>(&optional(), Walk::Backward),
"SELECT * FROM t ORDER BY \"title\" DESC NULLS LAST, \"created_at\" ASC, \"id\" DESC"
);
}
#[cfg(feature = "sqlite")]
#[test]
fn a_column_is_bracketed_by_the_seam_that_already_brackets_one() {
let terms = [OrderTerm::new(
ID,
FieldName::new("a\"b"),
OrderDirection::Asc,
)];
assert_eq!(
ordered::<sqlx::Sqlite>(&terms, Walk::Forward),
"SELECT * FROM t ORDER BY \"a\"\"b\" ASC"
);
}
#[cfg(feature = "sqlite")]
#[test]
fn an_order_over_no_terms_is_refused() {
assert_eq!(
SqlOrder::<sqlx::Sqlite>::new(&[]).map(|order| order.terms().len()),
Err(SqlOrderError::Empty)
);
}
struct Placeless;
impl NullOrder for Placeless {
const NULLS: NullOrdering = NullOrdering::Inexpressible;
}
impl OrderCapability for Placeless {
const NULLS: NullPlacement = NullPlacement::of(<Self as NullOrder>::NULLS);
const REPEATED_TERMS: TermRepetition = TermRepetition::Admitted;
const COLLECTIONS: CollectionOrdering = CollectionOrdering::Divergent;
const COLLECTION_BOUNDARY: CollectionBoundary = CollectionBoundary::Unbindable;
const SHADOWS: ShadowOrdering = ShadowOrdering::Bytewise;
const SHADOW_BOUNDARY: ShadowBoundary = ShadowBoundary::Bindable;
}
#[test]
fn a_dialect_that_cannot_place_null_refuses_a_nullable_term() {
assert_eq!(
SqlOrder::<Placeless>::new(&optional()).map(|order| order.terms().len()),
Err(SqlOrderError::NullPosition(TITLE))
);
}
#[test]
fn a_dialect_that_cannot_place_null_still_orders_columns_that_hold_none() {
assert_eq!(
SqlOrder::<Placeless>::new(&required()).map(|order| order.terms().len()),
Ok(2)
);
}
#[cfg(all(feature = "sqlite", feature = "postgres"))]
#[test]
fn one_written_order_signs_alike_on_two_dialects() {
let terms = required();
let sqlite = SqlOrder::<sqlx::Sqlite>::new(&terms).expect("a renderable order");
let postgres = SqlOrder::<sqlx::Postgres>::new(&terms).expect("a renderable order");
assert_eq!(sqlite.signature(), postgres.signature());
}
#[test]
fn the_refusals_say_which_one_they_are() {
assert_eq!(
SqlOrderError::Empty.to_string(),
"an order over no terms has no spelling"
);
assert_eq!(
SqlOrderError::NullPosition(TITLE).to_string(),
"`title` is nullable and this dialect cannot put NULL below every value"
);
}
#[cfg(feature = "postgres")]
#[test]
fn postgres_orders_a_column_stored_collection_as_a_plain_term() {
let terms = [
OrderTerm::array(TAGS, FieldName::new("tags"), OrderDirection::Asc),
OrderTerm::new(ID, FieldName::new("id"), OrderDirection::Asc),
];
assert_eq!(
ordered::<sqlx::Postgres>(&terms, Walk::Forward),
r#"SELECT * FROM t ORDER BY "tags" ASC, "id" ASC"#
);
}
#[cfg(all(feature = "sqlite", feature = "mysql"))]
#[test]
fn the_json_dialects_refuse_a_column_stored_collection() {
let terms = [
OrderTerm::array(TAGS, FieldName::new("tags"), OrderDirection::Asc),
OrderTerm::new(ID, FieldName::new("id"), OrderDirection::Asc),
];
assert_eq!(
SqlOrder::<sqlx::Sqlite>::new(&terms).map(|order| order.terms().len()),
Err(SqlOrderError::CollectionSemantics(TAGS))
);
assert_eq!(
SqlOrder::<sqlx::MySql>::new(&terms).map(|order| order.terms().len()),
Err(SqlOrderError::CollectionSemantics(TAGS))
);
}
#[cfg(all(feature = "sqlite", feature = "postgres", feature = "mysql"))]
#[test]
fn every_dialect_refuses_an_edge_stored_collection() {
let terms = [
OrderTerm::edge(TAGS, FieldName::new("tags"), OrderDirection::Asc),
OrderTerm::new(ID, FieldName::new("id"), OrderDirection::Asc),
];
for refusal in [
SqlOrder::<sqlx::Postgres>::new(&terms).map(|order| order.terms().len()),
SqlOrder::<sqlx::Sqlite>::new(&terms).map(|order| order.terms().len()),
SqlOrder::<sqlx::MySql>::new(&terms).map(|order| order.terms().len()),
] {
assert_eq!(refusal, Err(SqlOrderError::CollectionTable(TAGS)));
}
}
#[test]
fn the_constructor_reports_whichever_capability_row_refused() {
let collection = [
OrderTerm::array(TAGS, FieldName::new("tags"), OrderDirection::Asc),
OrderTerm::new(ID, FieldName::new("id"), OrderDirection::Asc),
];
assert_eq!(
SqlOrder::<Placeless>::new(&collection).map(|order| order.terms().len()),
Err(SqlOrderError::CollectionSemantics(TAGS))
);
assert_eq!(
SqlOrder::<Placeless>::new(&optional()).map(|order| order.terms().len()),
Err(SqlOrderError::NullPosition(TITLE)),
"the nullability verdict is the same one the hand-written check used to give"
);
}
mod spanning {
use super::{ID, ROW, SqlOrder};
use crate::{
FieldName, OrderDirection, OrderTerm, TermName, Walk,
comparison::{
At,
sql::{NullOrder, QueryBuilder, SelectClause, TermColumns},
},
query::OrderCapability,
};
const AT: &TermName = TermName::new("at");
fn instant(direction: OrderDirection) -> [OrderTerm; 2] {
[
OrderTerm::spanning(
AT,
FieldName::new("at"),
<crate::Timestamp as crate::ColumnKind>::SEGMENTS,
<crate::Timestamp as crate::ColumnKind>::ORDER,
direction,
),
OrderTerm::new(ID, FieldName::new("id"), OrderDirection::Asc),
]
}
fn ordered<Db>(terms: &[OrderTerm], walk: Walk) -> String
where
Db: sqlx::Database + NullOrder + OrderCapability + crate::Backend<Buffer: core::fmt::Display>,
{
SqlOrder::<Db>::new(terms)
.expect("this order is renderable for this dialect")
.push_order_by_with(
QueryBuilder::<SelectClause, Db>::select()
.push_field("*")
.from("t"),
walk,
At::new(&ROW),
&TermColumns,
)
.finalize()
.into_string()
}
#[test]
fn a_composite_term_is_two_columns_wide() {
assert_eq!(instant(OrderDirection::Asc)[0].width(), 2);
assert_eq!(instant(OrderDirection::Asc)[1].width(), 1);
}
#[cfg(feature = "sqlite")]
#[test]
fn an_instant_orders_by_both_of_its_columns() {
assert_eq!(
ordered::<sqlx::Sqlite>(&instant(OrderDirection::Asc), Walk::Forward),
"SELECT * FROM t ORDER BY \"at_secs\" ASC, \"at_nanos\" ASC, \"id\" ASC"
);
assert_eq!(
ordered::<sqlx::Sqlite>(&instant(OrderDirection::Desc), Walk::Forward),
"SELECT * FROM t ORDER BY \"at_secs\" DESC, \"at_nanos\" DESC, \"id\" ASC"
);
}
#[cfg(feature = "sqlite")]
#[test]
fn a_backward_walk_inverts_the_whole_subject() {
assert_eq!(
ordered::<sqlx::Sqlite>(&instant(OrderDirection::Asc), Walk::Backward),
"SELECT * FROM t ORDER BY \"at_secs\" DESC, \"at_nanos\" DESC, \"id\" DESC"
);
}
#[cfg(feature = "postgres")]
#[test]
fn the_postgres_entries_are_the_same_two() {
assert_eq!(
ordered::<sqlx::Postgres>(&instant(OrderDirection::Asc), Walk::Forward),
"SELECT * FROM t ORDER BY \"at_secs\" ASC, \"at_nanos\" ASC, \"id\" ASC"
);
}
#[cfg(feature = "mysql")]
#[test]
fn the_mysql_entries_bracket_with_backticks() {
assert_eq!(
ordered::<sqlx::MySql>(&instant(OrderDirection::Desc), Walk::Forward),
"SELECT * FROM t ORDER BY `at_secs` DESC, `at_nanos` DESC, `id` ASC"
);
}
}