#[cfg(feature = "sqlite")]
use crate::{
At, Backend, ComplexComparison, FieldName, RecordAddress, ScalarFilter, TextFilter,
comparison::{
ToDatabaseComparison, TryFromFilter,
sql::{SqlConjunction, SqlScalarComparison, SqlTextComparison},
},
};
#[cfg(feature = "sqlite")]
const ROW: RecordAddress = RecordAddress::new(FieldName::new("track"), &[FieldName::new("id")]);
#[cfg(feature = "sqlite")]
struct Emitted<Db>
where
Db: Backend,
ScalarFilter<i64>: ToDatabaseComparison<i64, Db>,
TextFilter<String>: ToDatabaseComparison<String, Db>,
{
bitrate: <ScalarFilter<i64> as ToDatabaseComparison<i64, Db>>::Comparison,
codec: <TextFilter<String> as ToDatabaseComparison<String, Db>>::Comparison,
}
#[cfg(feature = "sqlite")]
impl<Db> ComplexComparison<Db> for Emitted<Db>
where
Db: Backend,
ScalarFilter<i64>: ToDatabaseComparison<i64, Db>,
TextFilter<String>: ToDatabaseComparison<String, Db>,
{
fn conjuncts(&self) -> usize {
self.bitrate.conjuncts() + self.codec.conjuncts()
}
fn apply<'q>(
&'q self,
at: At<'_>,
builder: Db::Builder<'q>,
) -> Result<Db::Builder<'q>, Db::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)
}
}
#[cfg(feature = "sqlite")]
fn lower<'q, F, V, Db>(
column: &'q <F as ToDatabaseComparison<V, Db>>::Comparison,
at: At<'_>,
builder: Db::Builder<'q>,
) -> Result<Db::Builder<'q>, Db::Error>
where
Db: Backend,
F: ToDatabaseComparison<V, Db>,
{
column.apply(at, builder)
}
#[cfg(feature = "sqlite")]
fn conjuncts<F, V, Db>(column: &<F as ToDatabaseComparison<V, Db>>::Comparison) -> usize
where
Db: Backend,
F: ToDatabaseComparison<V, Db>,
{
column.conjuncts()
}
#[cfg(feature = "sqlite")]
fn lower_pair<'q, F0, V0, F1, V1, Db>(
first: (&'q <F0 as ToDatabaseComparison<V0, Db>>::Comparison, At<'_>),
second: (&'q <F1 as ToDatabaseComparison<V1, Db>>::Comparison, At<'_>),
builder: Db::Builder<'q>,
) -> Result<Db::Builder<'q>, Db::Error>
where
Db: Backend,
F0: ToDatabaseComparison<V0, Db>,
F1: ToDatabaseComparison<V1, Db>,
{
let builder = lower::<F0, V0, Db>(first.0, first.1, builder)?;
lower::<F1, V1, Db>(second.0, second.1, builder)
}
#[cfg(feature = "sqlite")]
#[test]
fn columns_held_at_the_projection_lower_with_no_predicate_about_it() {
let bitrate: SqlScalarComparison<i64, sqlx::Sqlite> =
TryFromFilter::try_from_filter(ScalarFilter::<i64>::new().with_eq(1i64)).unwrap();
let codec: SqlTextComparison<String, sqlx::Sqlite> =
TryFromFilter::try_from_filter(TextFilter::<String>::new().with_eq("av1".to_owned())).unwrap();
assert_eq!(
conjuncts::<ScalarFilter<i64>, i64, sqlx::Sqlite>(&bitrate),
1
);
assert_eq!(
conjuncts::<TextFilter<String>, String, sqlx::Sqlite>(&codec),
1
);
let mut qb = sqlx::QueryBuilder::<sqlx::Sqlite>::default();
let bitrate_at = At::new(&ROW).frame(FieldName::new("bitrate"));
let codec_at = At::new(&ROW).frame(FieldName::new("codec"));
let written = lower_pair::<ScalarFilter<i64>, i64, TextFilter<String>, String, sqlx::Sqlite>(
(&bitrate, bitrate_at.at()),
(&codec, codec_at.at()),
SqlConjunction::new(&mut qb),
)
.unwrap()
.written();
assert_eq!(written, 2);
assert_eq!(qb.sql(), r#" WHERE "bitrate" = ? AND "codec" = ?"#);
}
#[cfg(feature = "sqlite")]
#[test]
fn the_emitted_shape_lowers_its_columns_through_one_accumulator() {
let comparison = Emitted::<sqlx::Sqlite> {
bitrate: TryFromFilter::try_from_filter(ScalarFilter::<i64>::new().with_gt(1i64)).unwrap(),
codec: TryFromFilter::try_from_filter(TextFilter::<String>::new().with_eq("av1".to_owned()))
.unwrap(),
};
assert_eq!(ComplexComparison::<sqlx::Sqlite>::conjuncts(&comparison), 2);
let mut qb = sqlx::QueryBuilder::<sqlx::Sqlite>::default();
comparison
.apply(
At::new(&ROW).frame(FieldName::new("track")).at(),
SqlConjunction::new(&mut qb),
)
.unwrap();
assert_eq!(
qb.sql(),
r#" WHERE "track_bitrate" > ? AND "track_codec" = ?"#
);
}
const fn crosses<F, V, Db>()
where
Db: crate::Backend,
F: crate::comparison::ToCrossedComparison<V, Db>,
{
}
#[cfg(feature = "sqlite")]
#[test]
fn every_shipped_filter_kind_crosses() {
use crate::{
BooleanFilter, BytesFilter, Confidence, ConfidenceFilter, EnumFilter, FixedBytesFilter,
ListFilter, Nullable, QuantifiedFilter, ScalarFilter, SetFilter, TextFilter,
};
crosses::<ScalarFilter<i64>, i64, sqlx::Sqlite>();
crosses::<TextFilter<String>, String, sqlx::Sqlite>();
crosses::<BytesFilter<Vec<u8>>, Vec<u8>, sqlx::Sqlite>();
crosses::<FixedBytesFilter<Vec<u8>, 16>, Vec<u8>, sqlx::Sqlite>();
crosses::<EnumFilter<String>, String, sqlx::Sqlite>();
#[cfg(feature = "flags")]
crosses::<crate::FlagsFilter<i64>, i64, sqlx::Sqlite>();
crosses::<BooleanFilter, bool, sqlx::Sqlite>();
crosses::<ConfidenceFilter, Confidence<f32>, sqlx::Sqlite>();
crosses::<ListFilter<String, TextFilter<String>>, String, sqlx::Sqlite>();
crosses::<SetFilter<String, TextFilter<String>>, String, sqlx::Sqlite>();
crosses::<QuantifiedFilter<String, TextFilter<String>>, String, sqlx::Sqlite>();
crosses::<Nullable<ScalarFilter<i64>>, Option<i64>, sqlx::Sqlite>();
crosses::<Nullable<TextFilter<String>>, Option<String>, sqlx::Sqlite>();
}
#[cfg(feature = "postgres")]
#[test]
fn the_roster_holds_at_a_second_dialect() {
use crate::{BooleanFilter, BytesFilter, EnumFilter, Nullable, ScalarFilter, TextFilter};
crosses::<ScalarFilter<i64>, i64, sqlx::Postgres>();
crosses::<TextFilter<String>, String, sqlx::Postgres>();
crosses::<BytesFilter<Vec<u8>>, Vec<u8>, sqlx::Postgres>();
crosses::<EnumFilter<String>, String, sqlx::Postgres>();
crosses::<BooleanFilter, bool, sqlx::Postgres>();
crosses::<Nullable<ScalarFilter<i64>>, Option<i64>, sqlx::Postgres>();
#[cfg(feature = "jiff")]
crosses::<crate::DurationFilter, crate::PgDuration, sqlx::Postgres>();
}
#[cfg(feature = "mongo")]
#[test]
fn the_roster_holds_at_the_mongo_family() {
use crate::{BooleanFilter, EnumFilter, Nullable, ScalarFilter, TextFilter};
crosses::<ScalarFilter<i64>, i64, crate::Mongo>();
crosses::<TextFilter<String>, String, crate::Mongo>();
crosses::<EnumFilter<String>, String, crate::Mongo>();
crosses::<BooleanFilter, bool, crate::Mongo>();
crosses::<Nullable<ScalarFilter<i64>>, Option<i64>, crate::Mongo>();
}
#[cfg(feature = "sqlite")]
#[test]
fn a_composite_column_lowers_through_the_same_projection() {
use crate::{Nullable, comparison::sql::SqlNullable};
let optional: SqlNullable<SqlScalarComparison<i64, sqlx::Sqlite>, i64> =
TryFromFilter::try_from_filter(
Nullable::new(ScalarFilter::<i64>::new().with_eq(1i64)).with_null(false),
)
.unwrap();
assert_eq!(
conjuncts::<Nullable<ScalarFilter<i64>>, Option<i64>, sqlx::Sqlite>(&optional),
2
);
let mut qb = sqlx::QueryBuilder::<sqlx::Sqlite>::default();
lower::<Nullable<ScalarFilter<i64>>, Option<i64>, sqlx::Sqlite>(
&optional,
At::new(&ROW).frame(FieldName::new("bitrate")).at(),
SqlConjunction::new(&mut qb),
)
.unwrap();
assert_eq!(
qb.sql(),
r#" WHERE "bitrate" = ? AND "bitrate" IS NOT NULL"#
);
}