#[cfg(feature = "sqlite")]
mod sqlite {
use crate::{
At, FieldName, Timestamp,
comparison::sql::{
SqlCompositeEdgeComparison, SqlConjunction, SqlCountComparison, SqlLoweringError,
SqlScalarComparison,
tests::{ROW, render, render_at},
},
};
type Element = SqlScalarComparison<i64, sqlx::Sqlite>;
type Edge = SqlCompositeEdgeComparison<Timestamp, Element, sqlx::Sqlite>;
const SCOPE: &str = "EXISTS (SELECT 1 FROM ( SELECT \"p_stamps\".\"stamps_secs\" AS \
\"value_secs\", \"p_stamps\".\"stamps_nanos\" AS \"value_nanos\" FROM \
\"p_stamps\" WHERE \"p_stamps\".\"id\" = \"p\".\"id\" ) AS \
\"__ig_element_0__\"";
fn at(second: i64, nanosecond: i32) -> Timestamp {
Timestamp::from_parts(second, nanosecond).unwrap()
}
fn empty() -> Edge {
Edge::new()
}
#[test]
fn an_element_equality_names_every_segment() {
let mut comparison = empty();
comparison.has_element = Some(at(7, 250));
let (sql, binds) = render::<sqlx::Sqlite, _>("stamps", &comparison);
assert_eq!(
sql,
format!("{SCOPE} WHERE (\"value_secs\", \"value_nanos\") = (?, ?))")
);
assert_eq!(binds, 2);
}
#[test]
fn an_element_membership_is_the_pairs_and_not_their_product() {
let mut comparison = empty();
comparison.has_any_of = Some(Box::new([at(7, 250), at(9, 100)]));
let (sql, binds) = render::<sqlx::Sqlite, _>("stamps", &comparison);
assert_eq!(
sql,
format!("{SCOPE} WHERE (\"value_secs\", \"value_nanos\") IN ((?, ?), (?, ?)))")
);
assert_eq!(binds, 4);
assert!(!sql.contains("\"value_secs\" IN ("));
assert!(!sql.contains(" AND \"value_nanos\" IN ("));
}
#[test]
fn an_empty_membership_matches_nothing() {
let mut comparison = empty();
comparison.has_any_of = Some(Box::new([]));
let (sql, binds) = render::<sqlx::Sqlite, _>("stamps", &comparison);
assert_eq!(sql, format!("{SCOPE} WHERE 1 = 0)"));
assert_eq!(binds, 0);
}
#[test]
fn the_element_scope_carries_the_elements_own_comparison() {
let mut element = SqlScalarComparison::<i64, sqlx::Sqlite>::new();
element.gt = Some(1_700_000_000);
let mut comparison = empty();
comparison.any = Some(element);
let (sql, binds) = render::<sqlx::Sqlite, _>("stamps", &comparison);
assert_eq!(sql, format!("{SCOPE} WHERE \"value\" > ?)"));
assert_eq!(binds, 1);
}
#[test]
fn an_empty_element_scope_asks_whether_any_element_exists() {
let mut comparison = empty();
comparison.any = Some(SqlScalarComparison::<i64, sqlx::Sqlite>::new());
let (sql, binds) = render::<sqlx::Sqlite, _>("stamps", &comparison);
assert_eq!(sql, format!("{SCOPE})"));
assert_eq!(binds, 0);
}
#[test]
fn the_cardinality_reads_the_shared_scope() {
let mut count = SqlCountComparison::<i64, sqlx::Sqlite>::new();
count.eq = Some(2);
let mut comparison = empty();
comparison.count = Some(count);
let (sql, binds) = render::<sqlx::Sqlite, _>("stamps", &comparison);
assert_eq!(
sql,
"(SELECT COUNT(*) FROM \"p_stamps\" WHERE \"p_stamps\".\"id\" = \"p\".\"id\") = ?"
);
assert_eq!(binds, 1);
}
#[test]
fn every_operator_is_one_conjunct() {
let mut comparison = empty();
comparison.has_element = Some(at(7, 250));
comparison.has_any_of = Some(Box::new([at(9, 100)]));
assert_eq!(comparison.conjuncts(), 2);
let (sql, binds) = render::<sqlx::Sqlite, _>("stamps", &comparison);
assert!(sql.contains(") = (?, ?)) AND EXISTS ("));
assert_eq!(binds, 4);
}
#[test]
fn the_top_level_has_no_edge_table() {
let mut comparison = empty();
comparison.has_element = Some(at(7, 250));
let mut qb = sqlx::QueryBuilder::<sqlx::Sqlite>::default();
let refused = {
let out = SqlConjunction::with_lead(&mut qb, "");
crate::ComplexComparison::apply(&comparison, At::new(&ROW), out).err()
};
assert_eq!(qb.sql(), "");
assert_eq!(
refused,
Some(SqlLoweringError::EdgeWithoutField(FieldName::new("p")))
);
}
#[test]
fn a_membership_past_the_ceiling_is_refused_by_name() {
let elements = (0..16_384).map(|n| at(n, 0)).collect::<Vec<_>>();
let mut comparison = empty();
comparison.has_any_of = Some(elements.into_boxed_slice());
let frame = At::new(&ROW).frame(FieldName::new("stamps"));
let mut qb = sqlx::QueryBuilder::<sqlx::Sqlite>::default();
let refused = {
let out = SqlConjunction::with_lead(&mut qb, "");
crate::ComplexComparison::apply(&comparison, frame.at(), out).err()
};
assert_eq!(qb.sql(), "");
let Some(SqlLoweringError::BindCeiling(error)) = refused else {
panic!("a membership past the ceiling is refused by the bind count");
};
assert_eq!(error.keys(), 16_384);
assert_eq!(error.columns(), 2);
assert_eq!(error.ceiling(), 32_766);
}
#[test]
fn a_membership_at_the_ceiling_renders() {
let elements = (0..16_383).map(|n| at(n, 0)).collect::<Vec<_>>();
let mut comparison = empty();
comparison.has_any_of = Some(elements.into_boxed_slice());
let frame = At::new(&ROW).frame(FieldName::new("stamps"));
let (_, binds) = render_at::<sqlx::Sqlite, _>(frame.at(), &comparison);
assert_eq!(binds, 32_766);
}
}
#[cfg(feature = "sqlite")]
mod nested {
use crate::{
Carrier, CollectionElement, ColumnKind, ColumnName, ColumnShape, FieldName,
comparison::sql::{
SqlCompositeEdgeComparison, SqlScalarComparison,
tests::{ROW, render},
},
flattened, leaf_names, shape,
};
#[derive(Debug, Clone, Copy)]
struct Span {
start: i64,
end: i64,
}
impl ColumnKind for Span {
const SEGMENTS: &'static [ColumnShape] = &[
ColumnShape::Plain(ColumnName::new("start")),
ColumnShape::Plain(ColumnName::new("end")),
];
}
#[derive(Debug, Clone, Copy)]
struct Cue {
span: Span,
weight: i64,
}
impl ColumnKind for Cue {
const SEGMENTS: &'static [ColumnShape] = &[
flattened::<Span>(),
ColumnShape::Plain(ColumnName::new("weight")),
];
}
impl CollectionElement for Cue {}
impl<Db> Carrier<Db> for Cue
where
Db: sqlx::Database,
i64: Carrier<Db>,
{
fn push_bind(&self, qb: &mut sqlx::QueryBuilder<Db>) {
self.span.start.push_bind(qb);
qb.push(", ");
self.span.end.push_bind(qb);
qb.push(", ");
self.weight.push_bind(qb);
}
}
#[derive(Debug, Clone, Copy)]
struct Cadence {
num: i64,
den: i64,
}
impl ColumnKind for Cadence {
const SEGMENTS: &'static [ColumnShape] = &[
ColumnShape::Plain(ColumnName::new("num")),
ColumnShape::Plain(ColumnName::new("den")),
];
}
#[derive(Debug, Clone, Copy)]
struct Mark {
rate: Cadence,
}
impl ColumnKind for Mark {
const SEGMENTS: &'static [ColumnShape] = &[shape::<Cadence>(ColumnName::new("rate"))];
}
impl CollectionElement for Mark {}
impl<Db> Carrier<Db> for Mark
where
Db: sqlx::Database,
i64: Carrier<Db>,
{
fn push_bind(&self, qb: &mut sqlx::QueryBuilder<Db>) {
self.rate.num.push_bind(qb);
qb.push(", ");
self.rate.den.push_bind(qb);
}
}
type Element = SqlScalarComparison<i64, sqlx::Sqlite>;
type Cues = SqlCompositeEdgeComparison<Cue, Element, sqlx::Sqlite>;
type Marks = SqlCompositeEdgeComparison<Mark, Element, sqlx::Sqlite>;
#[test]
fn a_nested_element_is_as_wide_as_its_leaves() {
assert_eq!(crate::width(<Cue as ColumnKind>::SEGMENTS), 3);
assert_eq!(<Cue as ColumnKind>::SEGMENTS.len(), 2);
assert_eq!(crate::width(<Mark as ColumnKind>::SEGMENTS), 2);
assert_eq!(<Mark as ColumnKind>::SEGMENTS.len(), 1);
}
const _: () = assert!(leaf_names(
<Cue as ColumnKind>::SEGMENTS,
&[
FieldName::new("start"),
FieldName::new("end"),
FieldName::new("weight"),
]
));
const _: () = assert!(leaf_names(
<Mark as ColumnKind>::SEGMENTS,
&[FieldName::new("rate_num"), FieldName::new("rate_den")]
));
#[test]
fn a_flattened_part_splices_its_leaves_into_both_sides() {
let mut comparison = Cues::new();
comparison.has_element = Some(Cue {
span: Span { start: 7, end: 9 },
weight: 3,
});
let (sql, binds) = render::<sqlx::Sqlite, _>("cues", &comparison);
assert_eq!(
sql,
"EXISTS (SELECT 1 FROM ( SELECT \"p_cues\".\"cues_start\" AS \"value_start\", \
\"p_cues\".\"cues_end\" AS \"value_end\", \"p_cues\".\"cues_weight\" AS \"value_weight\" \
FROM \"p_cues\" WHERE \"p_cues\".\"id\" = \"p\".\"id\" ) AS \"__ig_element_0__\" WHERE \
(\"value_start\", \"value_end\", \"value_weight\") = (?, ?, ?))"
);
assert_eq!(binds, 3);
assert!(!sql.contains("cues_span_start"));
}
#[test]
fn a_named_part_prefixes_its_leaves_on_both_sides() {
let mut comparison = Marks::new();
comparison.has_any_of = Some(Box::new([
Mark {
rate: Cadence { num: 24, den: 1 },
},
Mark {
rate: Cadence {
num: 24_000,
den: 1_001,
},
},
]));
let (sql, binds) = render::<sqlx::Sqlite, _>("marks", &comparison);
assert_eq!(
sql,
"EXISTS (SELECT 1 FROM ( SELECT \"p_marks\".\"marks_rate_num\" AS \"value_rate_num\", \
\"p_marks\".\"marks_rate_den\" AS \"value_rate_den\" FROM \"p_marks\" WHERE \
\"p_marks\".\"id\" = \"p\".\"id\" ) AS \"__ig_element_0__\" WHERE (\"value_rate_num\", \
\"value_rate_den\") IN ((?, ?), (?, ?)))"
);
assert_eq!(binds, 4);
}
#[test]
fn the_ceiling_counts_leaves_rather_than_parts() {
let elements = (0..11_000)
.map(|n| Cue {
span: Span { start: n, end: n },
weight: n,
})
.collect::<Vec<_>>();
let mut comparison = Cues::new();
comparison.has_any_of = Some(elements.into_boxed_slice());
let frame = crate::At::new(&ROW).frame(FieldName::new("cues"));
let mut qb = sqlx::QueryBuilder::<sqlx::Sqlite>::default();
let refused = {
let out = crate::comparison::sql::SqlConjunction::with_lead(&mut qb, "");
crate::ComplexComparison::apply(&comparison, frame.at(), out).err()
};
let Some(crate::comparison::sql::SqlLoweringError::BindCeiling(error)) = refused else {
panic!("a membership past the ceiling is refused by the bind count");
};
assert_eq!(error.columns(), 3);
assert_eq!(error.keys(), 11_000);
}
#[test]
fn a_quantified_crossing_carries_the_elements_own_filter() {
use crate::{QuantifiedFilter, ScalarFilter, TryFromFilter};
let filter = QuantifiedFilter::<Cue, ScalarFilter<i64>>::new()
.with_any(ScalarFilter::new().with_gt(2i64))
.with_count(ScalarFilter::new().with_gte(1usize));
let crossed = Cues::try_from_filter(filter).expect("the crossing");
assert!(crossed.any().is_some());
assert!(crossed.count().is_some());
assert!(crossed.has_element().is_none());
assert!(crossed.has_any_of().is_none());
let (sql, binds) = render::<sqlx::Sqlite, _>("cues", &crossed);
assert!(
sql.contains("\"p_cues\".\"cues_start\" AS \"value_start\""),
"{sql}"
);
assert!(sql.contains(" WHERE \"value\" > ?)"), "{sql}");
assert!(
sql.contains("(SELECT COUNT(*) FROM \"p_cues\" WHERE \"p_cues\".\"id\" = \"p\".\"id\") >= ?"),
"{sql}"
);
assert_eq!(binds, 2);
}
#[test]
fn a_cardinality_past_the_integer_is_refused_by_name() {
use crate::{
QuantifiedFilter, ScalarFilter, TryFromFilter, comparison::sql::ListCrossingError,
};
let filter = QuantifiedFilter::<Cue, ScalarFilter<i64>>::new()
.with_count(ScalarFilter::new().with_eq(usize::MAX));
assert!(matches!(
Cues::try_from_filter(filter),
Err(ListCrossingError::Cardinality(_))
));
}
}
#[cfg(feature = "sqlite")]
mod derived_leaf {
use crate::{
Carrier, CollectionElement, ColumnKind, ColumnName, ColumnShape,
comparison::sql::{
SqlCompositeEdgeComparison, SqlScalarComparison,
tests::{ROW, render},
},
};
#[derive(Debug, Clone, Copy)]
struct Tick {
pts: i64,
hz: i64,
}
impl Tick {
const CEILING: i64 = 1_000;
const fn nanos(self) -> Option<i64> {
if self.pts > Self::CEILING || self.pts < -Self::CEILING {
return None;
}
Some(self.pts * 1_000_000_000 / self.hz)
}
}
impl ColumnKind for Tick {
const SEGMENTS: &'static [ColumnShape] = &[
ColumnShape::Plain(ColumnName::new("pts")),
ColumnShape::Plain(ColumnName::new("hz")),
ColumnShape::Nullable(ColumnName::new("nanos")),
];
}
impl CollectionElement for Tick {}
impl<Db> Carrier<Db> for Tick
where
Db: sqlx::Database,
i64: Carrier<Db>,
{
fn push_bind(&self, qb: &mut sqlx::QueryBuilder<Db>) {
self.push_value_bind(qb);
qb.push(", ");
match self.nanos() {
Some(nanos) => nanos.push_bind(qb),
None => {
qb.push("NULL");
}
}
}
fn push_value_bind(&self, qb: &mut sqlx::QueryBuilder<Db>) {
self.pts.push_bind(qb);
qb.push(", ");
self.hz.push_bind(qb);
}
}
type Ticks =
SqlCompositeEdgeComparison<Tick, SqlScalarComparison<i64, sqlx::Sqlite>, sqlx::Sqlite>;
const SCOPE: &str = "EXISTS (SELECT 1 FROM ( SELECT \"p_ticks\".\"ticks_pts\" AS \"value_pts\", \
\"p_ticks\".\"ticks_hz\" AS \"value_hz\", \"p_ticks\".\"ticks_nanos\" AS \
\"value_nanos\" FROM \"p_ticks\" WHERE \"p_ticks\".\"id\" = \"p\".\"id\" ) \
AS \"__ig_element_0__\"";
const fn unplaceable() -> Tick {
Tick {
pts: 10_000,
hz: 90_000,
}
}
#[test]
fn an_element_equality_is_the_value_columns_alone() {
let mut comparison = Ticks::new();
comparison.has_element = Some(unplaceable());
let (sql, binds) = render::<sqlx::Sqlite, _>("ticks", &comparison);
assert_eq!(
sql,
format!("{SCOPE} WHERE (\"value_pts\", \"value_hz\") = (?, ?))")
);
assert_eq!(binds, 2, "the index leaf is not an operand of an identity");
assert!(
!sql.contains("NULL"),
"and the `NULL` it would have bound is nowhere in the statement: {sql}"
);
}
#[test]
fn a_membership_is_the_value_columns_alone() {
let mut comparison = Ticks::new();
comparison.has_any_of = Some(Box::new([unplaceable(), Tick { pts: 9, hz: 90_000 }]));
let (sql, binds) = render::<sqlx::Sqlite, _>("ticks", &comparison);
assert_eq!(
sql,
format!("{SCOPE} WHERE (\"value_pts\", \"value_hz\") IN ((?, ?), (?, ?)))")
);
assert_eq!(binds, 4, "two elements at two value columns each");
}
#[test]
fn the_element_scope_still_projects_the_derived_column() {
let mut element = SqlScalarComparison::<i64, sqlx::Sqlite>::new();
element.gt = Some(0);
let mut comparison = Ticks::new();
comparison.any = Some(element);
let (sql, binds) = render::<sqlx::Sqlite, _>("ticks", &comparison);
assert_eq!(sql, format!("{SCOPE} WHERE \"value\" > ?)"));
assert_eq!(binds, 1);
assert!(sql.contains("AS \"value_nanos\""));
}
#[test]
fn the_bind_ceiling_counts_what_the_statement_spends() {
use crate::{At, ComplexComparison, FieldName, comparison::sql::SqlLoweringError};
let elements = (0..16_384)
.map(|pts| Tick { pts, hz: 90_000 })
.collect::<Vec<_>>();
let mut comparison = Ticks::new();
comparison.has_any_of = Some(elements.into_boxed_slice());
let frame = At::new(&ROW).frame(FieldName::new("ticks"));
let mut qb = sqlx::QueryBuilder::<sqlx::Sqlite>::default();
let refused = {
let out = crate::comparison::sql::SqlConjunction::with_lead(&mut qb, "");
comparison.apply(frame.at(), out).err()
};
assert_eq!(
qb.sql(),
"",
"a refusal leaves the accumulator as it found it"
);
let Some(SqlLoweringError::BindCeiling(error)) = refused else {
panic!("a membership past the ceiling is refused by the bind count");
};
assert_eq!(error.keys(), 16_384);
assert_eq!(
error.columns(),
2,
"the VALUE columns, which are what it spends"
);
assert_eq!(error.ceiling(), 32_766);
}
}