use core::fmt::Display;
use crate::{
At, Backend, BindCeiling, Carrier, ComplexComparison, FieldName, RecordAddress, ScalarFilter,
ToDatabaseComparison, TryFromFilter,
comparison::sql::{SqlConjunction, SqlLoweringError},
};
use mediatime as mt;
use super::{MediaTimeRangeCrossingError, SqlMediaTimeRangeComparison};
use crate::primitives::mediatime::{
MediaContained, MediaContainedOperand, MediaDurationBound, MediaInstantBound,
MediaSpanDurationFilter, MediaTimeRangeFilter, MediaTimeRangeOperand, TimebaseFilter,
tests::{range, timebase, timestamp},
};
const ROW: RecordAddress = RecordAddress::new(FieldName::new("clips"), &[FieldName::new("id")]);
type Dialect = sqlx::Postgres;
enum AnyDialect {}
#[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>,
i64: Carrier<Db>,
for<'a> &'a str: sqlx::Encode<'a, Db> + sqlx::Type<Db>,
{
fn crosses<Db: Backend, C>()
where
MediaTimeRangeFilter: ToDatabaseComparison<i64, Db, Comparison = C>,
{
}
crosses::<Db, SqlMediaTimeRangeComparison<Db>>();
}
fn cross(
filter: MediaTimeRangeFilter,
) -> Result<SqlMediaTimeRangeComparison<AnyDialect>, MediaTimeRangeCrossingError> {
SqlMediaTimeRangeComparison::try_from_filter(filter)
}
fn lower(filter: MediaTimeRangeFilter) -> SqlMediaTimeRangeComparison<Dialect> {
SqlMediaTimeRangeComparison::try_from_filter(filter).expect("the filter is crossable")
}
fn render(comparison: &SqlMediaTimeRangeComparison<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 seconds(count: i64) -> MediaDurationBound {
MediaDurationBound::new(mt::SignedDuration::new(
count * 1_000_000_000,
mt::Timebase::NANOS,
))
}
#[test]
fn each_relation_renders_the_predicate_it_names() {
let point = timestamp(1, 1, 1);
let span = range(1, 2, 1, 1);
for (filter, expected) in [
(
MediaTimeRangeFilter::new()
.with_contains(MediaContainedOperand::new(MediaContained::Instant(point))),
r#""span_start_nanos" <= $1 AND "span_end_nanos" > $2"#,
),
(
MediaTimeRangeFilter::new()
.with_contains(MediaContainedOperand::new(MediaContained::Span(span))),
r#""span_start_nanos" <= $1 AND "span_end_nanos" >= $2"#,
),
(
MediaTimeRangeFilter::new().with_overlaps(span),
r#""span_start_nanos" < $1 AND "span_end_nanos" > $2"#,
),
(
MediaTimeRangeFilter::new().with_within(span),
r#""span_start_nanos" >= $1 AND "span_end_nanos" <= $2"#,
),
(
MediaTimeRangeFilter::new().with_before(MediaInstantBound::new(point)),
r#""span_end_nanos" <= $1"#,
),
(
MediaTimeRangeFilter::new().with_after(MediaInstantBound::new(point)),
r#""span_start_nanos" >= $1"#,
),
] {
let comparison = lower(filter);
let (sql, written) = render(&comparison, "span");
assert_eq!(sql, expected);
assert_eq!(written, comparison.conjuncts(), "{sql}");
}
}
#[test]
fn overlaps_binds_the_operand_endpoints_crosswise() {
let comparison = lower(MediaTimeRangeFilter::new().with_overlaps(range(1, 2, 1, 1)));
assert_eq!(
comparison,
lower(MediaTimeRangeFilter::new().with_overlaps(range(1, 2, 1, 1)))
);
let mut qb = sqlx::QueryBuilder::<Dialect>::default();
let column = At::new(&ROW).frame(FieldName::new("span"));
{
let out = SqlConjunction::with_lead(&mut qb, "");
comparison.apply(column.at(), out).unwrap();
}
assert_eq!(
qb.sql(),
r#""span_start_nanos" < $1 AND "span_end_nanos" > $2"#
);
}
#[test]
fn two_relations_over_one_column_both_render() {
let comparison = lower(
MediaTimeRangeFilter::new()
.with_contains(MediaContainedOperand::new(MediaContained::Instant(
timestamp(1, 1, 1),
)))
.with_overlaps(range(0, 5, 1, 1)),
);
let (sql, written) = render(&comparison, "span");
assert_eq!(
sql,
concat!(
r#""span_start_nanos" <= $1 AND "span_end_nanos" > $2"#,
r#" AND "span_start_nanos" < $3 AND "span_end_nanos" > $4"#
)
);
assert_eq!(written, 4);
assert_eq!(comparison.conjuncts(), written);
}
#[test]
fn the_duration_facet_compares_the_difference() {
let comparison = lower(
MediaTimeRangeFilter::new().with_duration(
MediaSpanDurationFilter::new()
.with_gt(seconds(1))
.with_lte(seconds(10)),
),
);
let (sql, written) = render(&comparison, "span");
assert_eq!(
sql,
concat!(
r#"("span_end_nanos" - "span_start_nanos") > $1"#,
r#" AND ("span_end_nanos" - "span_start_nanos") <= $2"#
)
);
assert_eq!(written, 2);
assert_eq!(comparison.conjuncts(), written);
}
#[test]
fn a_length_crosses_through_the_rescale_and_meets_its_own_ceiling() {
let comparison = lower(MediaTimeRangeFilter::new().with_duration(
MediaSpanDurationFilter::new().with_gte(MediaDurationBound::new(mt::SignedDuration::new(
-1500,
mt::Timebase::MILLIS,
))),
));
assert_eq!(render(&comparison, "span").1, 1);
let refused = cross(MediaTimeRangeFilter::new().with_duration(
MediaSpanDurationFilter::new().with_gt(MediaDurationBound::new(mt::SignedDuration::new(
i64::MAX,
mt::Timebase::SECONDS,
))),
))
.unwrap_err();
assert_eq!(refused, MediaTimeRangeCrossingError::DurationOverflow);
assert!(refused.to_string().contains("292 years"));
assert!(
core::error::Error::source(&refused).is_none(),
"a length ceiling has no leaf beneath it"
);
}
#[test]
fn the_components_reach_their_own_columns() {
let comparison = lower(
MediaTimeRangeFilter::new()
.with_start_pts(ScalarFilter::new().with_gte(0))
.with_end_pts(ScalarFilter::new().with_lt(1000))
.with_timebase(TimebaseFilter::new().with_eq(timebase(1, 90_000))),
);
let (sql, written) = render(&comparison, "span");
assert_eq!(
sql,
concat!(
r#""span_start_pts" >= $1 AND "span_end_pts" < $2"#,
r#" AND "span_timebase_num" = $3 AND "span_timebase_den" = $4"#
)
);
assert_eq!(written, 4);
}
#[test]
fn an_endpoint_with_no_position_is_refused() {
let refused = cross(
MediaTimeRangeFilter::new().with_after(MediaInstantBound::new(timestamp(i64::MAX, 1, 1))),
)
.unwrap_err();
assert!(matches!(refused, MediaTimeRangeCrossingError::Overflow(_)));
assert!(core::error::Error::source(&refused).is_some());
}
#[test]
fn the_nested_citizens_refusal_passes_through() {
let refused = cross(
MediaTimeRangeFilter::new()
.with_timebase(TimebaseFilter::new().with_starts_with(smol_bytes::Utf8Bytes::from("_"))),
)
.unwrap_err();
assert!(matches!(refused, MediaTimeRangeCrossingError::Timebase(_)));
assert!(refused.to_string().contains("digits and a slash"));
}
#[test]
fn the_empty_filter_crosses_to_the_empty_comparison() {
let comparison = cross(MediaTimeRangeFilter::new()).expect("an empty filter is crossable");
assert!(comparison.is_empty());
assert_eq!(comparison.conjuncts(), 0);
assert_eq!(comparison, SqlMediaTimeRangeComparison::new());
assert_eq!(
SqlMediaTimeRangeComparison::<AnyDialect>::default(),
SqlMediaTimeRangeComparison::new()
);
}
#[test]
fn the_conjunct_count_is_what_the_lowering_opens() {
let comparison = lower(
MediaTimeRangeFilter::new()
.with_contains(MediaContainedOperand::new(MediaContained::Instant(
timestamp(1, 1, 1),
)))
.with_overlaps(range(0, 5, 1, 1))
.with_within(range(0, 100, 1, 1))
.with_before(MediaInstantBound::new(timestamp(50, 1, 1)))
.with_after(MediaInstantBound::new(timestamp(0, 1, 1)))
.with_duration(
MediaSpanDurationFilter::new()
.with_gt(seconds(1))
.with_gte(seconds(1))
.with_lt(seconds(9))
.with_lte(seconds(9)),
)
.with_start_pts(ScalarFilter::new().with_gte(0))
.with_end_pts(ScalarFilter::new().with_lt(1000))
.with_timebase(TimebaseFilter::new().with_eq(timebase(1, 90_000))),
);
let (sql, written) = render(&comparison, "span");
assert_eq!(comparison.conjuncts(), 16, "{sql}");
assert_eq!(written, 16, "{sql}");
assert_eq!(sql.matches(" AND ").count(), 15, "{sql}");
}
#[test]
fn the_structural_identity_binds_the_value_columns() {
let comparison = lower(
MediaTimeRangeFilter::new().with_exact(MediaTimeRangeOperand::new(range(100, 250, 1, 90_000))),
);
let (sql, written) = render(&comparison, "span");
assert_eq!(
sql,
concat!(
r#""span_start_pts" = $1 AND "span_end_pts" = $2"#,
r#" AND "span_timebase_num" = $3 AND "span_timebase_den" = $4"#
)
);
assert_eq!(written, 4);
assert_eq!(comparison.conjuncts(), written);
assert_eq!(comparison.exact(), Some((100, 250, 1, 90_000)));
}
#[test]
fn the_structural_identity_reduces_and_meets_no_ceiling() {
let declared = cross(
MediaTimeRangeFilter::new().with_exact(MediaTimeRangeOperand::new(range(1, 2, 2, 180_000))),
)
.expect("a range");
let reduced = cross(
MediaTimeRangeFilter::new().with_exact(MediaTimeRangeOperand::new(range(1, 2, 1, 90_000))),
)
.expect("its twin");
assert_eq!(declared, reduced);
assert_eq!(declared.exact(), Some((1, 2, 1, 90_000)));
let extreme = range(0, i64::MAX, 1, 1);
assert!(extreme.end().to_nanos().is_err(), "no position exists");
assert_eq!(
cross(MediaTimeRangeFilter::new().with_exact(MediaTimeRangeOperand::new(extreme)))
.expect("the value columns hold it")
.exact(),
Some((0, i64::MAX, 1, 1))
);
}
#[test]
fn the_structural_identity_composes_with_the_algebra() {
let comparison = lower(
MediaTimeRangeFilter::new()
.with_exact(MediaTimeRangeOperand::new(range(0, 90_000, 1, 90_000)))
.with_after(MediaInstantBound::new(timestamp(0, 1, 1)))
.with_start_pts(ScalarFilter::new().with_lt(10)),
);
let (sql, written) = render(&comparison, "span");
assert_eq!(
sql,
concat!(
r#""span_start_pts" = $1 AND "span_end_pts" = $2"#,
r#" AND "span_timebase_num" = $3 AND "span_timebase_den" = $4"#,
r#" AND "span_start_nanos" >= $5"#,
r#" AND "span_start_pts" < $6"#
)
);
assert_eq!(written, 6);
assert_eq!(comparison.conjuncts(), written);
}