use core::{fmt::Display, num::NonZeroI32};
use crate::{
At, Backend, BindCeiling, Carrier, ComplexComparison, FieldName, RecordAddress, ScalarFilter,
ToDatabaseComparison, TryFromFilter,
comparison::sql::{SqlConjunction, SqlLoweringError},
};
use smol_bytes::Utf8Bytes;
use super::{SqlTimebaseComparison, TimebaseCrossingError};
use crate::primitives::mediatime::{Timebase, TimebaseFilter, tests::timebase};
const ROW: RecordAddress = RecordAddress::new(FieldName::new("stream"), &[FieldName::new("id")]);
enum AnyDialect {}
type Dialect = sqlx::Postgres;
#[expect(
dead_code,
reason = "the signature is the assertion; instantiating it would name one dialect"
)]
fn assert_the_filter_maps_to_the_comparison<Db>()
where
Db: sqlx::Database
+ BindCeiling
+ for<'q> Backend<Builder<'q> = SqlConjunction<'q, Db>, Error = SqlLoweringError, Buffer: Display>,
i32: Carrier<Db>,
for<'a> &'a str: sqlx::Encode<'a, Db> + sqlx::Type<Db>,
{
fn crosses<Db: Backend, C>()
where
TimebaseFilter: ToDatabaseComparison<i32, Db, Comparison = C>,
{
}
crosses::<Db, SqlTimebaseComparison<Db>>();
}
fn denominator(value: i32) -> NonZeroI32 {
NonZeroI32::new(value).expect("a denominator is never zero")
}
fn whole_eq(num: i32, den: i32) -> TimebaseFilter {
TimebaseFilter::new().with_eq(timebase(num, den))
}
fn cross(
filter: TimebaseFilter,
) -> Result<SqlTimebaseComparison<AnyDialect>, TimebaseCrossingError> {
SqlTimebaseComparison::try_from_filter(filter)
}
fn lower(filter: TimebaseFilter) -> SqlTimebaseComparison<Dialect> {
SqlTimebaseComparison::try_from_filter(filter).expect("the filter is crossable")
}
fn render(comparison: &SqlTimebaseComparison<Dialect>, field: &str) -> (String, usize) {
let mut qb = sqlx::QueryBuilder::<Dialect>::default();
let column = At::new(&ROW).frame(FieldName::new(field));
let written = {
let out = SqlConjunction::with_lead(&mut qb, "");
comparison
.apply(column.at(), out)
.expect("the operands are few and meet no ceiling")
.written()
};
(qb.sql().as_str().to_owned(), written)
}
fn render_at_top_level(comparison: &SqlTimebaseComparison<Dialect>) -> String {
let mut qb = sqlx::QueryBuilder::<Dialect>::default();
{
let out = SqlConjunction::with_lead(&mut qb, "");
comparison
.apply(At::new(&ROW), out)
.expect("the operands are few and meet no ceiling");
}
qb.sql().as_str().to_owned()
}
fn every_component_operator() -> TimebaseFilter {
TimebaseFilter::new()
.with_numerator(
ScalarFilter::new()
.with_eq(1)
.with_ne(2)
.with_gt(3)
.with_gte(4)
.with_lt(5)
.with_lte(6)
.with_in_([7, 8])
.with_not_in([9]),
)
.with_denominator(
ScalarFilter::new()
.with_eq(denominator(90_000))
.with_ne(denominator(1_000))
.with_gt(denominator(11))
.with_gte(denominator(12))
.with_lt(denominator(13))
.with_lte(denominator(14))
.with_in_([denominator(15), denominator(16)])
.with_not_in([denominator(17)]),
)
}
#[test]
fn the_crossing_decomposes_and_reduces_a_whole_value_operand() {
let comparison = cross(whole_eq(2, 180_000)).expect("2/180000 is a timebase");
assert_eq!(comparison.numerator().eq(), Some(&1));
assert_eq!(comparison.denominator().eq(), Some(&90_000));
assert_eq!(comparison.conjuncts(), 2);
assert_ne!(comparison.numerator().eq(), Some(&2));
assert_ne!(comparison.denominator().eq(), Some(&180_000));
}
#[test]
fn the_stored_pair_and_the_bound_pair_come_from_one_reduction() {
for (num, den) in [(2, 180_000), (2, 4), (0, 90_000), (60_000, 2002), (8, 12)] {
let declared = timebase(num, den);
let (stored_num, stored_den) = declared.reduced();
let bound = cross(TimebaseFilter::new().with_eq(declared)).expect("a timebase crosses");
assert_eq!(bound.numerator().eq(), Some(&stored_num), "{num}/{den}");
assert_eq!(
bound.denominator().eq(),
Some(&stored_den.get()),
"{num}/{den}"
);
assert_ne!(
(stored_num, stored_den.get()),
(num, den),
"{num}/{den} must not already be in lowest terms, or the case proves nothing"
);
}
}
#[test]
fn equal_timebases_cross_to_the_same_comparison() {
let half = cross(whole_eq(1, 2)).expect("a timebase");
let two_quarters = cross(whole_eq(2, 4)).expect("a timebase");
assert_eq!(half, two_quarters);
assert_eq!(half.numerator().eq(), Some(&1));
assert_eq!(half.denominator().eq(), Some(&2));
}
#[test]
fn a_zero_numerator_reduces_to_a_denominator_of_one() {
let comparison = cross(whole_eq(0, 90_000)).expect("0/90000 is a timebase");
assert_eq!(comparison.numerator().eq(), Some(&0));
assert_eq!(comparison.denominator().eq(), Some(&1));
}
#[test]
fn both_halves_cross_with_every_operator() {
let comparison = cross(every_component_operator()).expect("both halves are plain columns");
assert_eq!(comparison.numerator().eq(), Some(&1));
assert_eq!(comparison.numerator().ne(), Some(&2));
assert_eq!(comparison.numerator().gt(), Some(&3));
assert_eq!(comparison.numerator().gte(), Some(&4));
assert_eq!(comparison.numerator().lt(), Some(&5));
assert_eq!(comparison.numerator().lte(), Some(&6));
assert_eq!(comparison.numerator().in_(), Some([7, 8].as_slice()));
assert_eq!(comparison.numerator().not_in(), Some([9].as_slice()));
assert_eq!(comparison.denominator().eq(), Some(&90_000));
assert_eq!(comparison.denominator().ne(), Some(&1_000));
assert_eq!(comparison.denominator().gt(), Some(&11));
assert_eq!(comparison.denominator().gte(), Some(&12));
assert_eq!(comparison.denominator().lt(), Some(&13));
assert_eq!(comparison.denominator().lte(), Some(&14));
assert_eq!(comparison.denominator().in_(), Some([15, 16].as_slice()));
assert_eq!(comparison.denominator().not_in(), Some([17].as_slice()));
assert_eq!(comparison.conjuncts(), 16);
}
#[test]
fn a_whole_value_equality_composes_with_the_components_other_operators() {
let comparison = cross(
whole_eq(2, 180_000)
.with_numerator(ScalarFilter::new().with_gte(1))
.with_denominator(ScalarFilter::new().with_not_in([denominator(1)])),
)
.expect("no slot is named twice");
assert_eq!(comparison.numerator().eq(), Some(&1));
assert_eq!(comparison.numerator().gte(), Some(&1));
assert_eq!(comparison.denominator().eq(), Some(&90_000));
assert_eq!(comparison.denominator().not_in(), Some([1].as_slice()));
assert_eq!(comparison.conjuncts(), 4);
}
#[test]
fn a_whole_value_equality_and_a_component_equality_conflict() {
assert_eq!(
cross(whole_eq(1, 90_000).with_numerator(ScalarFilter::new().with_eq(1))).unwrap_err(),
TimebaseCrossingError::NumeratorConflict
);
assert_eq!(
cross(whole_eq(1, 90_000).with_denominator(ScalarFilter::new().with_eq(denominator(90_000))))
.unwrap_err(),
TimebaseCrossingError::DenominatorConflict
);
assert_eq!(
cross(
whole_eq(1, 90_000)
.with_numerator(ScalarFilter::new().with_eq(1))
.with_denominator(ScalarFilter::new().with_eq(denominator(90_000)))
)
.unwrap_err(),
TimebaseCrossingError::NumeratorConflict
);
}
#[test]
fn a_membership_list_lowers_as_one_row_value() {
let comparison =
lower(TimebaseFilter::new().with_in_(vec![timebase(2, 180_000), timebase(30_000, 1001)]));
let (sql, written) = render(&comparison, "timebase");
assert_eq!(
sql,
r#"("timebase_num", "timebase_den") IN (($1, $2), ($3, $4))"#
);
assert_eq!(written, 1, "a membership is ONE conjunct however many keys");
assert_eq!(comparison.conjuncts(), written);
assert_eq!(
comparison.members().expect("in was asked").keys(),
[[1, 90_000], [30_000, 1001]],
"the keys are the reduced pairs, in the order they were sent"
);
}
#[test]
fn a_negation_and_an_exclusion_merge_into_one_predicate() {
let comparison = lower(
TimebaseFilter::new()
.with_ne(timebase(1, 1000))
.with_not_in(vec![timebase(2, 180_000)]),
);
let (sql, written) = render(&comparison, "timebase");
assert_eq!(
sql,
r#"NOT (("timebase_num", "timebase_den") IN (($1, $2), ($3, $4)))"#
);
assert_eq!(written, 1);
assert_eq!(comparison.conjuncts(), written);
assert_eq!(
comparison.excluded().expect("ne was asked").keys(),
[[1, 90_000], [1, 1000]],
"the list's keys first, then the single one appended"
);
}
#[test]
fn either_negating_slot_alone_reaches_the_negated_row_value() {
for filter in [
TimebaseFilter::new().with_ne(timebase(1, 90_000)),
TimebaseFilter::new().with_not_in(vec![timebase(1, 90_000)]),
] {
let comparison = lower(filter);
assert_eq!(
render(&comparison, "timebase").0,
r#"NOT (("timebase_num", "timebase_den") IN (($1, $2)))"#
);
assert_eq!(
comparison.excluded().expect("a key set").keys(),
[[1, 90_000]]
);
}
}
#[test]
fn an_empty_membership_list_keeps_its_direction() {
let included = lower(TimebaseFilter::new().with_in_(Vec::new()));
assert_eq!(render(&included, "timebase").0, "1 = 0");
let excluded = lower(TimebaseFilter::new().with_not_in(Vec::new()));
assert_eq!(render(&excluded, "timebase").0, "NOT (1 = 0)");
assert!(!included.is_empty());
assert!(!excluded.is_empty());
}
#[test]
fn the_render_facet_matches_against_the_stored_spelling() {
let comparison = lower(
TimebaseFilter::new()
.with_starts_with(Utf8Bytes::from("1/"))
.with_ends_with(Utf8Bytes::from("90000"))
.with_contains(Utf8Bytes::from("/9")),
);
let (sql, written) = render(&comparison, "timebase");
assert_eq!(
sql,
concat!(
r#"CONCAT("timebase_num", '/', "timebase_den") LIKE $1"#,
r#" AND CONCAT("timebase_num", '/', "timebase_den") LIKE $2"#,
r#" AND CONCAT("timebase_num", '/', "timebase_den") LIKE $3"#
)
);
assert_eq!(written, 3);
assert_eq!(comparison.conjuncts(), written);
assert_eq!(comparison.starts_with(), Some(&Utf8Bytes::from("1/%")));
assert_eq!(comparison.ends_with(), Some(&Utf8Bytes::from("%90000")));
assert_eq!(comparison.contains(), Some(&Utf8Bytes::from("%/9%")));
}
#[test]
fn a_render_pattern_stays_inside_the_inline_representation() {
let widest = format!("{}/{}", i32::MAX, i32::MAX);
for operand in ["1/", "/90000", "/9", "1001/30000", widest.as_str()] {
let comparison = cross(TimebaseFilter::new().with_contains(Utf8Bytes::from(operand)))
.expect("the alphabet is digits and a slash");
let pattern = comparison.contains().expect("contains was asked");
assert!(
pattern.is_inline(),
"`{pattern}` ({} bytes) spilled to the heap",
pattern.len()
);
}
}
#[test]
fn an_operand_outside_the_rendered_alphabet_is_refused() {
for outside in ['%', '_', '\\', 'e', ' ', '-'] {
let operand = Utf8Bytes::from(format!("1{outside}"));
assert_eq!(
cross(TimebaseFilter::new().with_contains(operand.clone())).unwrap_err(),
TimebaseCrossingError::RenderAlphabet(outside),
"contains: {operand:?}"
);
assert_eq!(
cross(TimebaseFilter::new().with_starts_with(operand.clone())).unwrap_err(),
TimebaseCrossingError::RenderAlphabet(outside)
);
assert_eq!(
cross(TimebaseFilter::new().with_ends_with(operand)).unwrap_err(),
TimebaseCrossingError::RenderAlphabet(outside)
);
}
for inside in ["1/90000", "/", "9", "0/1", "//"] {
assert!(cross(TimebaseFilter::new().with_contains(Utf8Bytes::from(inside))).is_ok());
}
}
#[test]
fn the_empty_filter_crosses_to_the_empty_comparison() {
let comparison = cross(TimebaseFilter::new()).expect("an empty filter is crossable");
assert!(comparison.is_empty());
assert_eq!(comparison.conjuncts(), 0);
assert_eq!(comparison, SqlTimebaseComparison::new());
}
#[test]
fn an_empty_component_membership_survives_the_crossing() {
let comparison =
cross(TimebaseFilter::new().with_numerator(ScalarFilter::new().with_in_(Vec::new())))
.expect("an empty list has no operand to refuse");
assert_eq!(comparison.numerator().in_(), Some([].as_slice()));
assert!(!comparison.is_empty());
assert_eq!(comparison.conjuncts(), 1);
}
#[test]
fn default_is_the_empty_comparison() {
assert_eq!(
SqlTimebaseComparison::<AnyDialect>::default(),
SqlTimebaseComparison::new()
);
}
#[test]
fn each_refusal_names_the_part_it_is_about() {
assert_eq!(
TimebaseCrossingError::NumeratorConflict.to_string(),
"the numerator's equality is named twice"
);
assert_eq!(
TimebaseCrossingError::DenominatorConflict.to_string(),
"the denominator's equality is named twice"
);
assert_eq!(
TimebaseCrossingError::RenderAlphabet('%').to_string(),
"a timebase renders as digits and a slash, so `%` matches no stored value"
);
}
#[test]
fn the_lowering_derives_both_columns_from_one_address() {
let comparison = lower(whole_eq(2, 180_000));
let (sql, written) = render(&comparison, "timebase");
assert_eq!(sql, r#""timebase_num" = $1 AND "timebase_den" = $2"#);
assert_eq!(written, 2);
assert_eq!(comparison.conjuncts(), written);
}
#[test]
fn the_top_level_renders_every_facet_bare() {
assert_eq!(
render_at_top_level(&lower(whole_eq(2, 180_000))),
r#""num" = $1 AND "den" = $2"#
);
assert_eq!(
render_at_top_level(&lower(TimebaseFilter::new().with_in_(vec![timebase(1, 2)]))),
r#"("num", "den") IN (($1, $2))"#
);
assert_eq!(
render_at_top_level(&lower(
TimebaseFilter::new().with_contains(Utf8Bytes::from("/9"))
)),
r#"CONCAT("num", '/', "den") LIKE $1"#
);
}
#[test]
fn each_half_renders_under_its_own_derived_name() {
let comparison = lower(
TimebaseFilter::new()
.with_numerator(ScalarFilter::new().with_gte(1))
.with_denominator(ScalarFilter::new().with_lt(denominator(5))),
);
assert_eq!(
render(&comparison, "pts_timebase").0,
r#""pts_timebase_num" >= $1 AND "pts_timebase_den" < $2"#
);
}
#[test]
fn the_conjunct_count_is_what_the_lowering_opens() {
let cases = [
(TimebaseFilter::new(), 0),
(
TimebaseFilter::new().with_numerator(ScalarFilter::new().with_eq(1)),
1,
),
(whole_eq(2, 180_000), 2),
(
whole_eq(2, 180_000)
.with_numerator(ScalarFilter::new().with_gte(1))
.with_denominator(ScalarFilter::new().with_not_in([denominator(1)])),
4,
),
(TimebaseFilter::new().with_in_(vec![timebase(1, 2)]), 1),
(
TimebaseFilter::new()
.with_ne(timebase(1, 2))
.with_not_in(vec![timebase(1, 3)]),
1,
),
(every_component_operator(), 16),
(
every_component_operator()
.with_in_(vec![timebase(1, 2)])
.with_ne(timebase(1, 3))
.with_starts_with(Utf8Bytes::from("1/"))
.with_ends_with(Utf8Bytes::from("2"))
.with_contains(Utf8Bytes::from("/")),
21,
),
];
for (filter, expected) in cases {
let comparison = lower(filter);
let (sql, written) = render(&comparison, "timebase");
assert_eq!(comparison.conjuncts(), expected, "{sql}");
assert_eq!(written, expected, "{sql}");
assert_eq!(
sql.matches(" AND ").count(),
expected.saturating_sub(1),
"{sql}"
);
}
}
#[test]
fn the_clause_keyword_rides_on_the_first_conjunct() {
let column = At::new(&ROW).frame(FieldName::new("timebase"));
let mut qb = sqlx::QueryBuilder::<Dialect>::default();
let comparison = lower(whole_eq(1, 90_000));
{
let out = SqlConjunction::new(&mut qb);
comparison.apply(column.at(), out).unwrap();
}
assert_eq!(
qb.sql(),
r#" WHERE "timebase_num" = $1 AND "timebase_den" = $2"#
);
let mut qb = sqlx::QueryBuilder::<Dialect>::default();
let empty = lower(TimebaseFilter::new());
let written = {
let out = SqlConjunction::new(&mut qb);
empty.apply(column.at(), out).unwrap().written()
};
assert!(empty.is_empty());
assert_eq!(written, 0);
assert_eq!(qb.sql(), "");
}
#[test]
fn a_negation_nests_without_leaking_its_lead() {
let column = At::new(&ROW).frame(FieldName::new("timebase"));
let comparison = lower(
TimebaseFilter::new()
.with_numerator(ScalarFilter::new().with_gt(0))
.with_ne(timebase(1, 2)),
);
let mut qb = sqlx::QueryBuilder::<Dialect>::default();
{
let out = SqlConjunction::new(&mut qb);
comparison.apply(column.at(), out).unwrap();
}
assert_eq!(
qb.sql(),
concat!(
r#" WHERE "timebase_num" > $1"#,
r#" AND NOT (("timebase_num", "timebase_den") IN (($2, $3)))"#
)
);
}
#[test]
fn the_value_facet_holds_timebases_rather_than_spellings() {
let filter = TimebaseFilter::new().with_eq(timebase(2, 4));
assert_eq!(filter.eq(), Some(&timebase(1, 2)));
assert_eq!(
filter.eq().map(Timebase::to_string),
Some(String::from("2/4")),
"and the DECLARED pair is still what it renders as"
);
}