use super::{
Conjunction, CountComparison, Error, ListComparison, ListCrossingError, ScalarComparison,
SetComparison, TextComparison,
};
use crate::{
At, ComplexComparison, FieldName, ListFilter, ScalarFilter, SetFilter, TextFilter,
comparison::{
TryFromFilter,
sql::{
SqlScalarComparison, SqlTextComparison,
tests::{render, threaded},
},
},
};
struct Track {
bitrate: ScalarComparison<i64>,
codec: TextComparison<String>,
}
impl ComplexComparison<sqlx::Postgres> for Track {
fn conjuncts(&self) -> usize {
self.bitrate.conjuncts() + self.codec.conjuncts()
}
fn apply<'q>(&'q self, at: At<'_>, builder: Conjunction<'q>) -> Result<Conjunction<'q>, Error> {
let bitrate = at.frame(FieldName::new("bitrate"));
let builder = self.bitrate.apply(bitrate.at(), builder)?;
let codec = at.frame(FieldName::new("codec"));
self.codec.apply(codec.at(), builder)
}
}
fn track() -> Track {
Track {
bitrate: SqlScalarComparison::try_from_filter(ScalarFilter::<i64>::new().with_gte(1_000i64))
.unwrap(),
codec: SqlTextComparison::try_from_filter(
TextFilter::<String>::new().with_contains("av1".to_owned()),
)
.unwrap(),
}
}
#[test]
fn the_two_spellings_are_one_type() {
let track = track();
let bitrate: SqlScalarComparison<i64, sqlx::Postgres> = track.bitrate.clone();
let codec: SqlTextComparison<String, sqlx::Postgres> = track.codec.clone();
assert_eq!(bitrate.gte(), Some(&1_000));
assert_eq!(codec.contains().map(String::as_str), Some("av1"));
assert_eq!(bitrate, track.bitrate);
assert_eq!(codec, track.codec);
let _: ScalarComparison<i64> = bitrate;
let _: TextComparison<String> = codec;
}
#[test]
fn the_aliased_impl_lowers_what_the_full_form_lowers() {
let track = track();
let bitrate: SqlScalarComparison<i64, sqlx::Postgres> = track.bitrate.clone();
let codec: SqlTextComparison<String, sqlx::Postgres> = track.codec.clone();
assert_eq!(
render::<sqlx::Postgres, _>("track_bitrate", &bitrate),
("\"track_bitrate\" >= $1".to_owned(), 1)
);
assert_eq!(
render::<sqlx::Postgres, _>("track_codec", &codec),
("\"track_codec\" LIKE $1 ESCAPE '\\'".to_owned(), 1)
);
assert_eq!(track.conjuncts(), 2);
assert_eq!(
threaded::<sqlx::Postgres, _>("track", &track),
"SELECT \"id\" FROM \"t\" WHERE \"track_bitrate\" >= $1 AND \"track_codec\" LIKE $2 \
ESCAPE '\\'"
);
}
#[test]
fn a_crossing_names_its_comparison_and_its_refusal_from_one_module() {
type Element = ScalarComparison<i64>;
let crossed: Result<ListComparison<i64, Element>, ListCrossingError<core::convert::Infallible>> =
ListComparison::<i64, Element>::try_from_filter(
ListFilter::<i64>::new()
.with_gt([1i64])
.with_count(ScalarFilter::new().with_gte(2)),
);
let crossed = crossed.unwrap();
assert_eq!(crossed.gt(), Some(&[1i64][..]));
let count: &CountComparison<i64> = crossed.count().expect("the cardinality crossed");
assert_eq!(count.gte(), Some(&2i64));
let set: SetComparison<i64, Element> =
SetComparison::<i64, Element>::try_from_filter(SetFilter::<i64>::new().with_overlaps([1i64]))
.unwrap();
assert_eq!(set.overlaps(), Some(&[1i64][..]));
}
#[cfg(feature = "jiff")]
#[test]
fn the_duration_alias_is_the_kind_the_dialects_do_not_share() {
use jiff::SignedDuration;
use crate::{DurationFilter, PgDuration};
let aliased: super::DurationComparison<PgDuration> = super::DurationComparison::try_from_filter(
DurationFilter::new().with_lte(SignedDuration::from_secs(90)),
)
.unwrap();
assert_eq!(
aliased.lte().map(|stored| stored.get().microseconds),
Some(90_000_000)
);
assert_eq!(
render::<sqlx::Postgres, _>("len", &aliased),
("\"len\" <= $1".to_owned(), 1)
);
}