use super::{BytesComparison, Conjunction, Error, ScalarComparison, TextComparison};
use crate::{
At, ComplexComparison, FieldName, FixedBytesFilter, ScalarFilter, TextFilter,
comparison::{
TryFromFilter,
sql::{
SqlScalarComparison, SqlTextComparison,
tests::{render, threaded},
},
},
};
struct Track {
bitrate: ScalarComparison<i64>,
codec: TextComparison<String>,
}
impl ComplexComparison<sqlx::MySql> 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::MySql> = track.bitrate.clone();
let codec: SqlTextComparison<String, sqlx::MySql> = 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::MySql> = track.bitrate.clone();
let codec: SqlTextComparison<String, sqlx::MySql> = track.codec.clone();
assert_eq!(
render::<sqlx::MySql, _>("track_bitrate", &bitrate),
("`track_bitrate` >= ?".to_owned(), 1)
);
assert_eq!(
render::<sqlx::MySql, _>("track_codec", &codec),
("`track_codec` LIKE ? ESCAPE '\\\\'".to_owned(), 1)
);
assert_eq!(track.conjuncts(), 2);
assert_eq!(
threaded::<sqlx::MySql, _>("track", &track),
"SELECT \"id\" FROM \"t\" WHERE `track_bitrate` >= ? AND `track_codec` LIKE ? \
ESCAPE '\\\\'"
);
}
#[test]
fn a_crossing_names_its_comparison_from_one_module() {
let crossed: Result<BytesComparison<Vec<u8>>, core::convert::Infallible> =
BytesComparison::<Vec<u8>>::try_from_filter(
FixedBytesFilter::<Vec<u8>, 4>::new().with_eq(vec![0x89u8]),
);
assert_eq!(crossed.unwrap().eq(), Some(&vec![0x89u8]));
}
#[cfg(feature = "jiff")]
#[test]
fn the_duration_alias_is_the_kind_the_dialects_do_not_share() {
use jiff::SignedDuration;
use crate::{DurationFilter, comparison::sql::MySqlDuration};
let aliased: super::DurationComparison<MySqlDuration> =
super::DurationComparison::try_from_filter(
DurationFilter::new().with_lte(SignedDuration::from_secs(90)),
)
.unwrap();
assert_eq!(
aliased.lte(),
Some(&MySqlDuration::try_from(SignedDuration::from_secs(90)).unwrap())
);
assert_eq!(
render::<sqlx::MySql, _>("len", &aliased),
("`len` <= ?".to_owned(), 1)
);
}