use super::{ListCrossingError, SqlListComparison, SqlSetComparison};
#[cfg(feature = "sqlite")]
use super::SetCrossingError;
use crate::comparison::sql::SqlScalarComparison;
#[cfg(any(feature = "sqlite", feature = "postgres"))]
use crate::comparison::sql::SqlTextComparison;
#[cfg(all(feature = "postgres", feature = "jiff", feature = "time"))]
use crate::comparison::sql::{SqlEdgeComparison, SqlEdgeSetComparison};
type Sequence<V, Db, C = SqlScalarComparison<V, Db>> = SqlListComparison<V, C, Db>;
type Unordered<V, Db, C = SqlScalarComparison<V, Db>> = SqlSetComparison<V, C, Db>;
#[cfg(all(feature = "postgres", feature = "jiff", feature = "time"))]
type EdgeSequence<V, Db, C = SqlScalarComparison<V, Db>> = SqlEdgeComparison<V, C, Db>;
#[cfg(all(feature = "postgres", feature = "jiff", feature = "time"))]
type EdgeUnordered<V, Db, C = SqlScalarComparison<V, Db>> = SqlEdgeSetComparison<V, C, Db>;
#[cfg(feature = "postgres")]
type ElementFilter<V> = crate::ScalarFilter<V>;
#[cfg(feature = "sqlite")]
type TextSequence<V, Db> = SqlListComparison<V, SqlTextComparison<V, Db>, Db>;
#[cfg(any(feature = "sqlite", feature = "postgres"))]
type TextUnordered<V, Db> = SqlSetComparison<V, SqlTextComparison<V, Db>, Db>;
#[cfg(any(feature = "sqlite", feature = "mysql"))]
const ORDERING: [&str; 4] = ["gt", "gte", "lt", "lte"];
#[cfg(feature = "sqlite")]
mod sqlite {
use core::convert::Infallible;
use super::{
ListCrossingError, ORDERING, Sequence, SetCrossingError, TextSequence, TextUnordered, Unordered,
};
use crate::{
ListFilter, QuantifiedFilter, SetFilter, TextFilter,
comparison::{
TryFromFilter,
sql::{
SqlTextComparison,
tests::{render, threaded},
},
},
};
fn length(tag: String) -> Result<i64, Infallible> {
Ok(tag.len() as i64)
}
#[test]
fn a_dialect_refusal_precedes_the_one_converter_at_either_level() {
let filter = ListFilter::<u64, crate::ScalarFilter<u64>>::new()
.with_gt([1u64])
.with_any(crate::ScalarFilter::new().with_eq(u64::MAX));
let refused = Sequence::<i64, sqlx::Sqlite>::try_from_filter_with(filter, i64::try_from);
assert!(
matches!(refused, Err(ListCrossingError::JsonOrdering("gt"))),
"the column has no element-wise order, whatever its operands convert to"
);
}
#[test]
fn the_one_converter_reaches_the_nested_element_filter() {
let filter = SetFilter::<String, TextFilter<String>>::new()
.with_has_element("stereo".to_owned())
.with_any(TextFilter::<String>::new().with_eq("hdr".to_owned()));
let crossed = TextUnordered::<i64, sqlx::Sqlite>::try_from_filter_with(filter, length).unwrap();
assert_eq!(crossed.has_element(), Some(&6i64));
assert_eq!(
crossed.any().expect("the element question").eq(),
Some(&3i64),
"the nested operand crossed through the same converter, one level down"
);
}
#[test]
fn one_element_converter_serves_every_slot() {
let filter = SetFilter::<String>::new()
.with_encloses(["hdr".to_owned(), "sdr".to_owned()])
.with_has_element("stereo".to_owned());
let crossed = TextUnordered::<i64, sqlx::Sqlite>::try_from_filter_with(filter, length).unwrap();
assert_eq!(crossed.encloses(), Some(&[3i64, 3][..]));
assert_eq!(crossed.has_element(), Some(&6i64));
assert_eq!(crossed.conjuncts(), 2);
}
#[test]
fn the_identity_crossing_is_infallible_in_its_operand_half() {
let crossed: Result<TextSequence<String, sqlx::Sqlite>, ListCrossingError<Infallible>> =
TextSequence::try_from_filter(ListFilter::<String>::new().with_eq(["hdr".to_owned()]));
assert_eq!(crossed.unwrap().eq().unwrap(), ["hdr".to_owned()]);
}
#[test]
fn a_set_crossing_carries_the_converters_error_undressed() {
let crossed: Result<TextUnordered<String, sqlx::Sqlite>, SetCrossingError<Infallible>> =
TextUnordered::try_from_filter(SetFilter::<String>::new().with_overlaps(["hdr".to_owned()]));
assert_eq!(crossed.unwrap().overlaps().unwrap(), ["hdr".to_owned()]);
}
#[test]
fn a_collection_operand_binds_once_whatever_its_length() {
for len in [0usize, 1, 3, 1000] {
let operand: Vec<i64> = (0..len as i64).collect();
let crossed = Unordered::<i64, sqlx::Sqlite>::try_from_filter(
SetFilter::<i64>::new().with_encloses(operand),
)
.unwrap();
let (_, binds) = render::<sqlx::Sqlite, _>("t", &crossed);
assert_eq!(binds, 1, "an {len}-element operand");
}
}
#[test]
fn set_equality_binds_each_direction_and_sequence_equality_does_not() {
let sequence = Sequence::<i64, sqlx::Sqlite>::try_from_filter(
ListFilter::<i64>::new().with_eq([1i64, 2, 3]),
)
.unwrap();
let set = Unordered::<i64, sqlx::Sqlite>::try_from_filter(
SetFilter::<i64>::new().with_eq([1i64, 2, 3]),
)
.unwrap();
assert_eq!(
render::<sqlx::Sqlite, _>("t", &sequence),
("\"t\" = ?".to_owned(), 1)
);
let (sql, binds) = render::<sqlx::Sqlite, _>("t", &set);
assert_eq!(binds, 2);
assert_eq!(
sql,
"( NOT EXISTS (SELECT 1 FROM json_each(?) WHERE value NOT IN (SELECT value FROM \
json_each(\"t\"))) AND NOT EXISTS (SELECT 1 FROM json_each(\"t\") WHERE value NOT IN \
(SELECT value FROM json_each(?))) )"
);
}
#[test]
fn every_set_operator_renders_its_own_conjunct() {
let filter = SetFilter::<i64>::new()
.with_eq([1i64])
.with_ne([2i64])
.with_encloses([3i64])
.with_enclosed_by([4i64])
.with_overlaps([5i64])
.with_has_element(6i64);
let crossed = Unordered::<i64, sqlx::Sqlite>::try_from_filter(filter).unwrap();
assert_eq!(crossed.conjuncts(), 6);
let (sql, binds) = render::<sqlx::Sqlite, _>("t", &crossed);
assert_eq!(binds, 8);
assert_eq!(
sql,
"( NOT EXISTS (SELECT 1 FROM json_each(?) WHERE value NOT IN (SELECT value FROM \
json_each(\"t\"))) AND NOT EXISTS (SELECT 1 FROM json_each(\"t\") WHERE value NOT IN \
(SELECT value FROM json_each(?))) ) AND \
NOT ( ( NOT EXISTS (SELECT 1 FROM json_each(?) WHERE value NOT IN (SELECT value FROM \
json_each(\"t\"))) AND NOT EXISTS (SELECT 1 FROM json_each(\"t\") WHERE value NOT IN \
(SELECT value FROM json_each(?))) ) ) AND \
NOT EXISTS (SELECT 1 FROM json_each(?) WHERE value NOT IN (SELECT value FROM \
json_each(\"t\"))) AND \
NOT EXISTS (SELECT 1 FROM json_each(\"t\") WHERE value NOT IN (SELECT value FROM \
json_each(?))) AND \
EXISTS (SELECT 1 FROM json_each(\"t\") WHERE value IN (SELECT value FROM json_each(?))) AND \
NOT EXISTS (SELECT 1 FROM json_each(?) WHERE value NOT IN (SELECT value FROM \
json_each(\"t\")))"
);
}
#[test]
fn every_sequence_operator_renders_its_own_conjunct() {
let filter = ListFilter::<i64>::new()
.with_eq([1i64])
.with_ne([2i64])
.with_has_element(3i64);
let crossed = Sequence::<i64, sqlx::Sqlite>::try_from_filter(filter).unwrap();
assert_eq!(crossed.conjuncts(), 3);
assert_eq!(
render::<sqlx::Sqlite, _>("t", &crossed),
(
"\"t\" = ? AND NOT ( \"t\" = ? ) AND \
NOT EXISTS (SELECT 1 FROM json_each(?) WHERE value NOT IN (SELECT value FROM \
json_each(\"t\")))"
.to_owned(),
3
)
);
}
#[test]
fn an_ordering_operator_is_refused_because_the_collection_is_json() {
for (operator, filter) in [
("gt", ListFilter::<i64>::new().with_gt([1i64])),
("gte", ListFilter::<i64>::new().with_gte([1i64])),
("lt", ListFilter::<i64>::new().with_lt([1i64])),
("lte", ListFilter::<i64>::new().with_lte([1i64])),
] {
let refused = Sequence::<i64, sqlx::Sqlite>::try_from_filter(filter);
assert_eq!(
refused.unwrap_err(),
ListCrossingError::JsonOrdering(operator)
);
}
assert_eq!(ORDERING, ["gt", "gte", "lt", "lte"]);
assert!(
Sequence::<i64, sqlx::Sqlite>::try_from_filter(ListFilter::<i64>::new().with_eq([1i64]),)
.is_ok()
);
}
#[test]
fn the_dialect_is_checked_before_the_operands_convert() {
let refused = Sequence::<u8, sqlx::Sqlite>::try_from_filter(
ListFilter::<u64>::new()
.with_gt([1u64])
.with_eq([999u64]),
);
assert_eq!(refused.unwrap_err(), ListCrossingError::JsonOrdering("gt"));
}
#[test]
fn membership_is_containment_of_the_singleton_on_both_kinds() {
let member = Unordered::<i64, sqlx::Sqlite>::try_from_filter(
SetFilter::<i64>::new().with_has_element(6i64),
)
.unwrap();
let singleton = Unordered::<i64, sqlx::Sqlite>::try_from_filter(
SetFilter::<i64>::new().with_encloses([6i64]),
)
.unwrap();
let sequence = Sequence::<i64, sqlx::Sqlite>::try_from_filter(
ListFilter::<i64>::new().with_has_element(6i64),
)
.unwrap();
assert_eq!(
render::<sqlx::Sqlite, _>("t", &member),
render::<sqlx::Sqlite, _>("t", &singleton)
);
assert_eq!(
render::<sqlx::Sqlite, _>("t", &sequence),
render::<sqlx::Sqlite, _>("t", &member)
);
}
#[test]
fn the_membership_operand_is_the_singleton_array() {
use core::cell::Cell;
use crate::comparison::sql::JsonElement;
#[derive(Debug, PartialEq)]
struct Probe {
offset: Cell<usize>,
}
impl crate::ScalarFilterMarker for Probe {
type Filter = crate::ScalarFilter<Probe>;
}
impl crate::DefaultMarker for Probe {
type Marker = crate::ScalarMarker<Probe>;
}
impl<Db: sqlx::Database> crate::comparison::sql::Carrier<Db> for Probe
where
i64: crate::comparison::sql::Carrier<Db>,
{
fn push_bind(&self, qb: &mut sqlx::QueryBuilder<Db>) {
crate::comparison::sql::Carrier::push_bind(&0i64, qb);
}
}
impl crate::ColumnKind for Probe {}
impl JsonElement for Probe {
fn push_json(&self, out: &mut String) {
self.offset.set(out.len());
out.push('0');
}
}
let crossed = Unordered::<Probe, sqlx::Sqlite>::try_from_filter(
SetFilter::<Probe>::new().with_has_element(Probe {
offset: Cell::new(usize::MAX),
}),
)
.unwrap();
render::<sqlx::Sqlite, _>("t", &crossed);
assert_eq!(
crossed.has_element().unwrap().offset.get(),
1,
"the element was written at offset 0, so nothing opened an array around it"
);
}
#[test]
fn the_threaded_lowering_renders_this_dialect_leaf() {
let crossed = Unordered::<i64, sqlx::Sqlite>::try_from_filter(
SetFilter::<i64>::new()
.with_encloses([3i64])
.with_overlaps([5i64]),
)
.unwrap();
assert_eq!(
threaded::<sqlx::Sqlite, _>("t", &crossed),
"SELECT \"id\" FROM \"t\" WHERE \
NOT EXISTS (SELECT 1 FROM json_each(?) WHERE value NOT IN (SELECT value FROM \
json_each(\"t\"))) AND \
EXISTS (SELECT 1 FROM json_each(\"t\") WHERE value IN (SELECT value FROM json_each(?)))"
);
}
#[test]
fn an_element_question_opens_a_json_each_scope() {
let crossed = TextUnordered::<String, sqlx::Sqlite>::try_from_filter_with_element(
SetFilter::<String, TextFilter<String>>::new()
.with_any(TextFilter::<String>::new().with_starts_with("hd".to_owned())),
Ok::<_, Infallible>,
SqlTextComparison::try_from_filter,
)
.unwrap();
assert_eq!(
render::<sqlx::Sqlite, _>("t", &crossed),
(
"EXISTS (SELECT 1 FROM json_each(\"t\") WHERE substr(\"value\", 1, length(?)) = ?)"
.to_owned(),
2
)
);
assert_eq!(crossed.conjuncts(), 1);
}
#[test]
fn a_quantified_crossing_renders_what_the_wide_one_does() {
let narrow = Sequence::<i64, sqlx::Sqlite>::try_from_filter(
QuantifiedFilter::<i64>::new()
.with_any(crate::ScalarFilter::new().with_eq(1))
.with_count(crate::ScalarFilter::new().with_gte(2)),
)
.unwrap();
let wide = Sequence::<i64, sqlx::Sqlite>::try_from_filter(
ListFilter::<i64>::new()
.with_any(crate::ScalarFilter::new().with_eq(1))
.with_count(crate::ScalarFilter::new().with_gte(2)),
)
.unwrap();
assert_eq!(narrow, wide);
assert_eq!(narrow.conjuncts(), wide.conjuncts());
assert_eq!(
render::<sqlx::Sqlite, _>("t", &narrow),
render::<sqlx::Sqlite, _>("t", &wide)
);
assert_eq!(
render::<sqlx::Sqlite, _>("t", &narrow),
(
"EXISTS (SELECT 1 FROM json_each(\"t\") WHERE \"value\" = ?) AND \
json_array_length(\"t\") >= ?"
.to_owned(),
2
)
);
}
#[test]
fn a_quantified_crossing_leaves_every_element_slot_absent() {
let crossed = Sequence::<i64, sqlx::Sqlite>::try_from_filter(
QuantifiedFilter::<i64>::new().with_any(crate::ScalarFilter::new()),
)
.unwrap();
assert!(crossed.has_element().is_none());
assert!(crossed.eq().is_none());
assert!(crossed.ne().is_none());
assert!(crossed.gt().is_none());
assert!(crossed.gte().is_none());
assert!(crossed.lt().is_none());
assert!(crossed.lte().is_none());
assert!(!crossed.is_empty());
assert_eq!(crossed.conjuncts(), 1);
assert_eq!(
render::<sqlx::Sqlite, _>("t", &crossed),
("EXISTS (SELECT 1 FROM json_each(\"t\"))".to_owned(), 0)
);
}
#[test]
fn an_empty_element_comparison_is_the_collection_being_non_empty() {
let crossed = Unordered::<i64, sqlx::Sqlite>::try_from_filter(
SetFilter::<i64>::new().with_any(crate::ScalarFilter::new()),
)
.unwrap();
assert_eq!(
render::<sqlx::Sqlite, _>("t", &crossed),
("EXISTS (SELECT 1 FROM json_each(\"t\"))".to_owned(), 0)
);
assert!(!crossed.is_empty());
}
#[test]
fn a_cardinality_is_json_array_length() {
let crossed = Unordered::<i64, sqlx::Sqlite>::try_from_filter(
SetFilter::<i64>::new().with_count(crate::ScalarFilter::new().with_gt(3).with_lte(9)),
)
.unwrap();
assert_eq!(
render::<sqlx::Sqlite, _>("t", &crossed),
(
"json_array_length(\"t\") > ? AND json_array_length(\"t\") <= ?".to_owned(),
2
)
);
assert_eq!(crossed.conjuncts(), 2);
}
#[test]
fn an_empty_cardinality_folds_in() {
let crossed = Unordered::<i64, sqlx::Sqlite>::try_from_filter(
SetFilter::<i64>::new().with_count(crate::ScalarFilter::new()),
)
.unwrap();
assert_eq!(render::<sqlx::Sqlite, _>("t", &crossed), (String::new(), 0));
assert_eq!(crossed.conjuncts(), 0);
assert!(crossed.is_empty());
assert!(
SetFilter::<i64>::new()
.with_count(crate::ScalarFilter::new())
.is_empty()
);
}
#[test]
fn a_cardinality_membership_degenerates_like_every_other() {
let none = Unordered::<i64, sqlx::Sqlite>::try_from_filter(
SetFilter::<i64>::new().with_count(crate::ScalarFilter::new().with_in_([])),
)
.unwrap();
let every = Unordered::<i64, sqlx::Sqlite>::try_from_filter(
SetFilter::<i64>::new().with_count(crate::ScalarFilter::new().with_not_in([])),
)
.unwrap();
assert_eq!(
render::<sqlx::Sqlite, _>("t", &none),
("1 = 0".to_owned(), 0)
);
assert_eq!(
render::<sqlx::Sqlite, _>("t", &every),
("NOT ( 1 = 0 )".to_owned(), 0)
);
}
}
#[cfg(feature = "postgres")]
mod postgres {
use super::{Sequence, Unordered};
use crate::{
ListFilter, SetFilter,
comparison::{
TryFromFilter,
sql::tests::{render, threaded},
},
};
#[test]
fn no_postgres_rendering_mentions_json() {
let sequence = Sequence::<i64, sqlx::Postgres>::try_from_filter(
ListFilter::<i64>::new()
.with_eq([1i64])
.with_ne([2i64])
.with_gt([3i64])
.with_gte([4i64])
.with_lt([5i64])
.with_lte([6i64])
.with_has_element(7i64),
)
.unwrap();
let (sql, _) = render::<sqlx::Postgres, _>("t", &sequence);
assert!(
!sql.to_lowercase().contains("json"),
"a native-array lowering renders no JSON: {sql}"
);
let set = Unordered::<i64, sqlx::Postgres>::try_from_filter(
SetFilter::<i64>::new()
.with_eq([1i64])
.with_encloses([2i64])
.with_enclosed_by([3i64])
.with_overlaps([4i64])
.with_has_element(5i64),
)
.unwrap();
let (sql, _) = render::<sqlx::Postgres, _>("t", &set);
assert!(!sql.to_lowercase().contains("json"), "{sql}");
}
#[test]
fn every_sequence_operator_renders_its_own_conjunct() {
let filter = ListFilter::<i64>::new()
.with_eq([1i64])
.with_ne([2i64])
.with_gt([3i64])
.with_gte([4i64])
.with_lt([5i64])
.with_lte([6i64])
.with_has_element(7i64);
let crossed = Sequence::<i64, sqlx::Postgres>::try_from_filter(filter).unwrap();
assert_eq!(crossed.conjuncts(), 7);
assert_eq!(
render::<sqlx::Postgres, _>("t", &crossed),
(
"\"t\" = $1 AND NOT ( \"t\" = $2 ) AND \"t\" > $3 AND \"t\" >= $4 AND \"t\" < $5 AND \
\"t\" <= $6 AND \"t\" @> $7"
.to_owned(),
7
)
);
}
#[test]
fn every_set_operator_renders_its_own_conjunct() {
let filter = SetFilter::<i64>::new()
.with_eq([1i64])
.with_ne([2i64])
.with_encloses([3i64])
.with_enclosed_by([4i64])
.with_overlaps([5i64])
.with_has_element(6i64);
let crossed = Unordered::<i64, sqlx::Postgres>::try_from_filter(filter).unwrap();
assert_eq!(crossed.conjuncts(), 6);
assert_eq!(
render::<sqlx::Postgres, _>("t", &crossed),
(
"( \"t\" @> $1 AND \"t\" <@ $2 ) AND NOT ( ( \"t\" @> $3 AND \"t\" <@ $4 ) ) AND \
\"t\" @> $5 AND \"t\" <@ $6 AND \"t\" && $7 AND \"t\" @> $8"
.to_owned(),
8
)
);
}
#[test]
fn a_collection_operand_binds_once_whatever_its_length() {
for len in [0usize, 1, 3, 1000] {
let operand: Vec<i64> = (0..len as i64).collect();
let crossed = Unordered::<i64, sqlx::Postgres>::try_from_filter(
SetFilter::<i64>::new().with_encloses(operand),
)
.unwrap();
let (sql, binds) = render::<sqlx::Postgres, _>("t", &crossed);
assert_eq!(binds, 1, "an {len}-element operand");
assert_eq!(sql, "\"t\" @> $1");
}
}
#[test]
fn the_kind_splits_equality_and_leaves_membership_alone() {
let sequence =
Sequence::<i64, sqlx::Postgres>::try_from_filter(ListFilter::<i64>::new().with_eq([1i64, 2]))
.unwrap();
let set =
Unordered::<i64, sqlx::Postgres>::try_from_filter(SetFilter::<i64>::new().with_eq([1i64, 2]))
.unwrap();
assert_eq!(
render::<sqlx::Postgres, _>("t", &sequence),
("\"t\" = $1".to_owned(), 1)
);
assert_eq!(
render::<sqlx::Postgres, _>("t", &set),
("( \"t\" @> $1 AND \"t\" <@ $2 )".to_owned(), 2)
);
let sequence_member = Sequence::<i64, sqlx::Postgres>::try_from_filter(
ListFilter::<i64>::new().with_has_element(1i64),
)
.unwrap();
let set_member = Unordered::<i64, sqlx::Postgres>::try_from_filter(
SetFilter::<i64>::new().with_has_element(1i64),
)
.unwrap();
assert_eq!(
render::<sqlx::Postgres, _>("t", &sequence_member),
render::<sqlx::Postgres, _>("t", &set_member)
);
assert_eq!(
render::<sqlx::Postgres, _>("t", &set_member),
("\"t\" @> $1".to_owned(), 1)
);
}
#[test]
fn membership_is_containment_of_the_singleton() {
let member = Unordered::<i64, sqlx::Postgres>::try_from_filter(
SetFilter::<i64>::new().with_has_element(6i64),
)
.unwrap();
let singleton = Unordered::<i64, sqlx::Postgres>::try_from_filter(
SetFilter::<i64>::new().with_encloses([6i64]),
)
.unwrap();
assert_eq!(
render::<sqlx::Postgres, _>("t", &member),
render::<sqlx::Postgres, _>("t", &singleton)
);
}
#[test]
fn the_membership_operand_is_the_singleton_array() {
use core::cell::Cell;
use sqlx::postgres::{PgArgumentBuffer, PgHasArrayType, PgTypeInfo};
#[derive(Debug, PartialEq)]
struct Probe {
offset: Cell<usize>,
}
impl crate::ScalarFilterMarker for Probe {
type Filter = crate::ScalarFilter<Probe>;
}
impl crate::DefaultMarker for Probe {
type Marker = crate::ScalarMarker<Probe>;
}
impl<Db: sqlx::Database> crate::comparison::sql::Carrier<Db> for Probe
where
i64: crate::comparison::sql::Carrier<Db>,
{
fn push_bind(&self, qb: &mut sqlx::QueryBuilder<Db>) {
crate::comparison::sql::Carrier::push_bind(&0i64, qb);
}
}
impl crate::ColumnKind for Probe {}
impl From<i64> for Probe {
fn from(_: i64) -> Self {
Self {
offset: Cell::new(usize::MAX),
}
}
}
impl sqlx::Type<sqlx::Postgres> for Probe {
fn type_info() -> PgTypeInfo {
<i64 as sqlx::Type<sqlx::Postgres>>::type_info()
}
}
impl PgHasArrayType for Probe {
fn array_type_info() -> PgTypeInfo {
<i64 as PgHasArrayType>::array_type_info()
}
}
impl sqlx::Encode<'_, sqlx::Postgres> for Probe {
fn encode_by_ref(
&self,
buf: &mut PgArgumentBuffer,
) -> Result<sqlx::encode::IsNull, sqlx::error::BoxDynError> {
self.offset.set(buf.len());
<i64 as sqlx::Encode<'_, sqlx::Postgres>>::encode_by_ref(&0i64, buf)
}
}
let control = Unordered::<Probe, sqlx::Postgres>::try_from_filter(
SetFilter::<i64>::new().with_encloses([1i64]),
)
.unwrap();
render::<sqlx::Postgres, _>("t", &control);
let array_offset = control.encloses().unwrap()[0].offset.get();
let member = Unordered::<Probe, sqlx::Postgres>::try_from_filter(
SetFilter::<i64>::new().with_has_element(1i64),
)
.unwrap();
render::<sqlx::Postgres, _>("t", &member);
assert_ne!(array_offset, usize::MAX, "the control element encoded");
assert!(
array_offset > 0,
"an array writes its header before the first element"
);
assert_eq!(
member.has_element().unwrap().offset.get(),
array_offset,
"the membership operand took the same encoding path its `encloses` twin did"
);
}
#[test]
fn an_ordering_operator_is_answered_because_the_array_is_native() {
let ordered =
Sequence::<i64, sqlx::Postgres>::try_from_filter(ListFilter::<i64>::new().with_gt([1i64]))
.unwrap();
assert_eq!(
render::<sqlx::Postgres, _>("t", &ordered),
("\"t\" > $1".to_owned(), 1)
);
}
#[test]
fn a_declared_element_type_renders_through_its_own_array_type() {
let crossed = super::TextUnordered::<String, sqlx::Postgres>::try_from_filter(
SetFilter::<String>::new().with_encloses(["hdr".to_owned()]),
)
.unwrap();
assert_eq!(
render::<sqlx::Postgres, _>("t", &crossed),
("\"t\" @> $1".to_owned(), 1)
);
}
#[test]
fn an_element_question_opens_an_unnest_scope() {
use crate::{TextFilter, comparison::sql::SqlTextComparison};
let crossed = super::TextUnordered::<String, sqlx::Postgres>::try_from_filter_with_element(
SetFilter::<String, TextFilter<String>>::new()
.with_any(TextFilter::<String>::new().with_starts_with("hd".to_owned())),
Ok::<_, core::convert::Infallible>,
SqlTextComparison::try_from_filter,
)
.unwrap();
assert_eq!(
render::<sqlx::Postgres, _>("t", &crossed),
(
"EXISTS (SELECT 1 FROM unnest(\"t\") AS \"__ig_element_0__\"(\"value\") WHERE \"value\" LIKE \
$1 ESCAPE '\\')"
.to_owned(),
1
)
);
assert_eq!(crossed.conjuncts(), 1);
}
#[test]
fn a_cardinality_is_cardinality_and_not_array_length() {
let crossed = Unordered::<i64, sqlx::Postgres>::try_from_filter(
SetFilter::<i64>::new().with_count(crate::ScalarFilter::new().with_eq(0)),
)
.unwrap();
let (sql, binds) = render::<sqlx::Postgres, _>("t", &crossed);
assert_eq!((sql.as_str(), binds), ("cardinality(\"t\") = $1", 1));
assert!(!sql.contains("array_length"));
}
#[test]
fn the_threaded_lowering_renders_this_dialect_leaf() {
let crossed = Unordered::<i64, sqlx::Postgres>::try_from_filter(
SetFilter::<i64>::new()
.with_encloses([7i64])
.with_enclosed_by([8i64])
.with_overlaps([9i64]),
)
.unwrap();
let sql = threaded::<sqlx::Postgres, _>("t", &crossed);
assert_eq!(
sql,
"SELECT \"id\" FROM \"t\" WHERE \"t\" @> $1 AND \"t\" <@ $2 AND \"t\" && $3"
);
assert!(!sql.contains("json"), "{sql}");
}
}
#[cfg(feature = "postgres")]
mod strategy {
use super::{ElementFilter, Sequence, Unordered};
#[cfg(all(feature = "jiff", feature = "time"))]
use super::{EdgeSequence, EdgeUnordered};
use crate::{
BeI128, BeU64, BeU128, ListFilter, SetFilter,
comparison::{
ComplexComparison, TryFromFilter,
sql::{
CollectionStorage, PgCollectionStorage, SqlEdgeComparison, SqlEdgeSetComparison,
tests::render,
},
},
};
#[cfg(all(feature = "jiff", feature = "time"))]
use crate::{ScalarFilter, comparison::sql::postgres::ScalarComparison};
fn crossing_lowers<V>()
where
sqlx::Postgres: CollectionStorage<V, ElementFilter<V>>,
<sqlx::Postgres as CollectionStorage<V, ElementFilter<V>>>::Sequence:
ComplexComparison<sqlx::Postgres>,
<sqlx::Postgres as CollectionStorage<V, ElementFilter<V>>>::Set:
ComplexComparison<sqlx::Postgres>,
{
}
#[test]
fn every_shipped_row_names_comparisons_that_lower() {
macro_rules! owned_and_borrowed {
($( $ty:ty ),+ $(,)?) => {
$(
crossing_lowers::<$ty>();
crossing_lowers::<&$ty>();
)+
};
}
owned_and_borrowed!(
bool,
i8,
i16,
i32,
i64,
u8,
u16,
u32,
f32,
f64,
String,
Vec<u8>,
crate::Score,
BeU64,
BeU128,
BeI128,
::core::time::Duration,
sqlx::postgres::types::PgInterval,
);
#[cfg(feature = "time")]
owned_and_borrowed!(time::OffsetDateTime, time::Date, time::Time);
#[cfg(all(feature = "jiff", feature = "time"))]
owned_and_borrowed!(
crate::Temporal<time::OffsetDateTime>,
crate::Temporal<time::Date>,
crate::Temporal<time::Time>,
);
#[cfg(all(feature = "jiff", feature = "time"))]
owned_and_borrowed!(crate::Temporal<i8>, crate::Temporal<BeU64>,);
}
#[cfg(all(feature = "jiff", feature = "time"))]
#[test]
fn a_temporal_collection_takes_whichever_strategy_its_element_declared() {
use crate::Temporal;
fn follows_its_element<A, E, AC, EC>()
where
sqlx::Postgres: CollectionStorage<
A,
ElementFilter<A>,
Sequence = Sequence<A, sqlx::Postgres, AC>,
Set = Unordered<A, sqlx::Postgres, AC>,
> + CollectionStorage<
E,
ElementFilter<E>,
Sequence = EdgeSequence<E, sqlx::Postgres, EC>,
Set = EdgeUnordered<E, sqlx::Postgres, EC>,
>,
{
}
follows_its_element::<
Temporal<time::OffsetDateTime>,
Temporal<BeU64>,
ScalarComparison<Temporal<time::OffsetDateTime>>,
ScalarComparison<Temporal<BeU64>>,
>();
follows_its_element::<
Temporal<time::Date>,
Temporal<i8>,
ScalarComparison<Temporal<time::Date>>,
ScalarComparison<Temporal<i8>>,
>();
follows_its_element::<
&Temporal<time::Time>,
&Temporal<BeU64>,
ScalarComparison<&Temporal<time::Time>>,
ScalarComparison<&Temporal<BeU64>>,
>();
}
#[cfg(all(feature = "jiff", feature = "time"))]
#[test]
fn a_temporal_collection_over_a_blob_carrier_renders_the_edge_table() {
use crate::Temporal;
struct Era(u64);
impl crate::ScalarFilterMarker for Era {
type Filter = crate::ScalarFilter<Era>;
}
impl crate::DefaultMarker for Era {
type Marker = crate::ScalarMarker<Era>;
}
impl crate::TemporalStorage for Era {
type Storage = BeU64;
fn to_storage(&self) -> Self::Storage {
BeU64(self.0)
}
}
let crossed: <sqlx::Postgres as CollectionStorage<
Temporal<BeU64>,
ElementFilter<Temporal<BeU64>>,
>>::Sequence =
SqlEdgeComparison::try_from_filter(ListFilter::<Era>::new().with_has_element(Era(7)))
.unwrap();
assert_eq!(
render::<sqlx::Postgres, _>("eras", &crossed),
(
"EXISTS (SELECT 1 FROM \"p_eras\" WHERE \"p_eras\".\"id\" = \"p\".\"id\" AND \
\"p_eras\".\"eras\" = $1)"
.to_owned(),
1
)
);
}
#[cfg(all(feature = "jiff", feature = "time"))]
#[test]
fn a_temporal_collection_takes_the_array_where_times_own_does() {
use crate::Temporal;
fn both_take_the_array<A, B, AC, BC>()
where
sqlx::Postgres: CollectionStorage<
A,
ElementFilter<A>,
Sequence = Sequence<A, sqlx::Postgres, AC>,
Set = Unordered<A, sqlx::Postgres, AC>,
> + CollectionStorage<
B,
ElementFilter<B>,
Sequence = Sequence<B, sqlx::Postgres, BC>,
Set = Unordered<B, sqlx::Postgres, BC>,
>,
{
}
both_take_the_array::<
Temporal<time::OffsetDateTime>,
time::OffsetDateTime,
ScalarComparison<Temporal<time::OffsetDateTime>>,
ScalarComparison<time::OffsetDateTime>,
>();
both_take_the_array::<
Temporal<time::Date>,
time::Date,
ScalarComparison<Temporal<time::Date>>,
ScalarComparison<time::Date>,
>();
both_take_the_array::<
Temporal<time::Time>,
time::Time,
ScalarComparison<Temporal<time::Time>>,
ScalarComparison<time::Time>,
>();
both_take_the_array::<
&Temporal<time::OffsetDateTime>,
&time::OffsetDateTime,
ScalarComparison<&Temporal<time::OffsetDateTime>>,
ScalarComparison<&time::OffsetDateTime>,
>();
let stamp: jiff::Timestamp = "2024-05-06T07:08:09.123456789Z".parse().unwrap();
let plain = time::OffsetDateTime::from_unix_timestamp_nanos(stamp.as_nanosecond()).unwrap();
let from_jiff: <sqlx::Postgres as CollectionStorage<
Temporal<time::OffsetDateTime>,
ElementFilter<Temporal<time::OffsetDateTime>>,
>>::Set =
Unordered::try_from_filter(SetFilter::<jiff::Timestamp>::new().with_encloses([stamp]))
.unwrap();
let from_time: <sqlx::Postgres as CollectionStorage<
time::OffsetDateTime,
ElementFilter<time::OffsetDateTime>,
>>::Set = Unordered::try_from_filter(
SetFilter::<time::OffsetDateTime, ScalarFilter<time::OffsetDateTime>>::new()
.with_encloses([plain]),
)
.unwrap();
assert_eq!(
render::<sqlx::Postgres, _>("t", &from_jiff),
("\"t\" @> $1".to_owned(), 1)
);
assert_eq!(
render::<sqlx::Postgres, _>("t", &from_jiff),
render::<sqlx::Postgres, _>("t", &from_time)
);
assert_eq!(
<Temporal<time::OffsetDateTime> as sqlx::Type<sqlx::Postgres>>::type_info(),
<time::OffsetDateTime as sqlx::Type<sqlx::Postgres>>::type_info()
);
assert_eq!(
<Temporal<time::OffsetDateTime> as sqlx::postgres::PgHasArrayType>::array_type_info(),
<time::OffsetDateTime as sqlx::postgres::PgHasArrayType>::array_type_info()
);
assert_eq!(
encoded(from_jiff.encloses().unwrap()),
encoded(from_time.encloses().unwrap())
);
let later: jiff::Timestamp = "2024-05-06T07:08:10.123456789Z".parse().unwrap();
let from_later: Unordered<Temporal<time::OffsetDateTime>, sqlx::Postgres> =
Unordered::try_from_filter(SetFilter::<jiff::Timestamp>::new().with_encloses([later]))
.unwrap();
assert_ne!(
encoded(from_jiff.encloses().unwrap()),
encoded(from_later.encloses().unwrap())
);
}
#[cfg(all(feature = "jiff", feature = "time"))]
fn encoded<V>(values: &[V]) -> Vec<u8>
where
V: sqlx::Type<sqlx::Postgres> + for<'q> sqlx::Encode<'q, sqlx::Postgres>,
{
let mut buf = sqlx::postgres::PgArgumentBuffer::default();
let _ = sqlx::Encode::<sqlx::Postgres>::encode_by_ref(&values, &mut buf).unwrap();
buf.to_vec()
}
#[test]
fn a_blob_carrier_reaches_the_edge_table() {
let crossed: <sqlx::Postgres as CollectionStorage<BeU64, ElementFilter<BeU64>>>::Sequence =
SqlEdgeComparison::try_from_filter(ListFilter::<u64>::new().with_has_element(7)).unwrap();
assert_eq!(
render::<sqlx::Postgres, _>("keys", &crossed),
(
"EXISTS (SELECT 1 FROM \"p_keys\" WHERE \"p_keys\".\"id\" = \"p\".\"id\" AND \
\"p_keys\".\"keys\" = $1)"
.to_owned(),
1
)
);
}
#[test]
fn an_element_with_a_usable_array_type_keeps_it() {
let crossed: <sqlx::Postgres as CollectionStorage<i64, ElementFilter<i64>>>::Set =
Unordered::try_from_filter(SetFilter::<i64>::new().with_encloses([1i64])).unwrap();
assert_eq!(
render::<sqlx::Postgres, _>("t", &crossed),
("\"t\" @> $1".to_owned(), 1)
);
}
#[test]
fn an_array_capable_element_may_decline_the_array() {
#[derive(Debug, Clone, Copy, PartialEq)]
struct Crowded(i64);
impl From<i64> for Crowded {
fn from(value: i64) -> Self {
Self(value)
}
}
impl sqlx::Type<sqlx::Postgres> for Crowded {
fn type_info() -> sqlx::postgres::PgTypeInfo {
<i64 as sqlx::Type<sqlx::Postgres>>::type_info()
}
}
impl sqlx::postgres::PgHasArrayType for Crowded {
fn array_type_info() -> sqlx::postgres::PgTypeInfo {
<i64 as sqlx::postgres::PgHasArrayType>::array_type_info()
}
}
impl sqlx::Encode<'_, sqlx::Postgres> for Crowded {
fn encode_by_ref(
&self,
buf: &mut sqlx::postgres::PgArgumentBuffer,
) -> Result<sqlx::encode::IsNull, sqlx::error::BoxDynError> {
<i64 as sqlx::Encode<'_, sqlx::Postgres>>::encode_by_ref(&self.0, buf)
}
}
impl crate::comparison::sql::Carrier<sqlx::Postgres> for Crowded {
fn push_bind(&self, qb: &mut sqlx::QueryBuilder<sqlx::Postgres>) {
qb.push_bind(self.0);
}
}
impl crate::ColumnKind for Crowded {}
impl<VF: crate::comparison::ToDatabaseComparison<Crowded, sqlx::Postgres>>
PgCollectionStorage<VF> for Crowded
{
type Sequence = SqlEdgeComparison<Crowded, VF::Comparison, sqlx::Postgres>;
type Set = SqlEdgeSetComparison<Crowded, VF::Comparison, sqlx::Postgres>;
}
fn array_is_available<V>()
where
Sequence<V, sqlx::Postgres>: ComplexComparison<sqlx::Postgres>,
Unordered<V, sqlx::Postgres>: ComplexComparison<sqlx::Postgres>,
{
}
array_is_available::<Crowded>();
#[cfg(all(feature = "jiff", feature = "time"))]
{
use crate::Temporal;
fn the_wrapper_declines_too<V, C>()
where
sqlx::Postgres: CollectionStorage<
Temporal<V>,
ElementFilter<Temporal<V>>,
Sequence = EdgeSequence<Temporal<V>, sqlx::Postgres, C>,
Set = EdgeUnordered<Temporal<V>, sqlx::Postgres, C>,
>,
{
}
the_wrapper_declines_too::<Crowded, ScalarComparison<Temporal<Crowded>>>();
}
let crossed: <sqlx::Postgres as CollectionStorage<Crowded, ElementFilter<Crowded>>>::Set =
SqlEdgeSetComparison::try_from_filter(SetFilter::<i64>::new().with_overlaps([1i64, 2]))
.unwrap();
let (sql, binds) = render::<sqlx::Postgres, _>("tags", &crossed);
assert!(sql.starts_with("EXISTS (SELECT 1 FROM \"p_tags\""), "{sql}");
assert!(
!sql.contains("@>"),
"the array operators are not on this path: {sql}"
);
assert_eq!(binds, 2);
}
}
#[cfg(feature = "mysql")]
mod mysql {
use super::{ListCrossingError, ORDERING, Sequence, Unordered};
use crate::{
FieldName, ListFilter, SetFilter,
comparison::{
At, ComplexComparison, TryFromFilter,
sql::{
SqlConjunction, SqlLoweringError,
tests::{ROW, render, threaded},
},
},
};
#[test]
fn the_operand_is_cast_into_json() {
let crossed = Unordered::<i64, sqlx::MySql>::try_from_filter(
SetFilter::<i64>::new().with_overlaps([1i64, 2]),
)
.unwrap();
assert_eq!(
render::<sqlx::MySql, _>("t", &crossed),
("JSON_OVERLAPS(`t`, CAST(? AS JSON))".to_owned(), 1)
);
}
#[test]
fn every_set_operator_renders_its_own_conjunct() {
let filter = SetFilter::<i64>::new()
.with_eq([1i64])
.with_ne([2i64])
.with_encloses([3i64])
.with_enclosed_by([4i64])
.with_overlaps([5i64])
.with_has_element(6i64);
let crossed = Unordered::<i64, sqlx::MySql>::try_from_filter(filter).unwrap();
assert_eq!(crossed.conjuncts(), 6);
assert_eq!(
render::<sqlx::MySql, _>("t", &crossed),
(
"( JSON_CONTAINS(`t`, CAST(? AS JSON)) AND JSON_CONTAINS(CAST(? AS JSON), `t`) ) AND \
NOT ( ( JSON_CONTAINS(`t`, CAST(? AS JSON)) AND JSON_CONTAINS(CAST(? AS JSON), `t`) ) ) \
AND JSON_CONTAINS(`t`, CAST(? AS JSON)) AND JSON_CONTAINS(CAST(? AS JSON), `t`) AND \
JSON_OVERLAPS(`t`, CAST(? AS JSON)) AND JSON_CONTAINS(`t`, CAST(? AS JSON))"
.to_owned(),
8
)
);
}
#[test]
fn every_sequence_operator_renders_its_own_conjunct() {
let filter = ListFilter::<i64>::new()
.with_eq([1i64])
.with_ne([2i64])
.with_has_element(3i64);
let crossed = Sequence::<i64, sqlx::MySql>::try_from_filter(filter).unwrap();
assert_eq!(crossed.conjuncts(), 3);
assert_eq!(
render::<sqlx::MySql, _>("t", &crossed),
(
"`t` = CAST(? AS JSON) AND NOT ( `t` = CAST(? AS JSON) ) AND \
JSON_CONTAINS(`t`, CAST(? AS JSON))"
.to_owned(),
3
)
);
}
#[test]
fn an_ordering_operator_is_refused_because_the_collection_is_json() {
for (operator, filter) in [
("gt", ListFilter::<i64>::new().with_gt([1i64])),
("gte", ListFilter::<i64>::new().with_gte([1i64])),
("lt", ListFilter::<i64>::new().with_lt([1i64])),
("lte", ListFilter::<i64>::new().with_lte([1i64])),
] {
let refused = Sequence::<i64, sqlx::MySql>::try_from_filter(filter);
assert_eq!(
refused.unwrap_err(),
ListCrossingError::JsonOrdering(operator)
);
}
assert_eq!(ORDERING, ["gt", "gte", "lt", "lte"]);
}
#[test]
fn the_threaded_lowering_renders_this_dialect_leaf() {
let crossed = Unordered::<i64, sqlx::MySql>::try_from_filter(
SetFilter::<i64>::new()
.with_encloses([3i64])
.with_overlaps([5i64]),
)
.unwrap();
assert_eq!(
threaded::<sqlx::MySql, _>("t", &crossed),
"SELECT \"id\" FROM \"t\" WHERE JSON_CONTAINS(`t`, CAST(? AS JSON)) AND \
JSON_OVERLAPS(`t`, CAST(? AS JSON))"
);
}
#[test]
fn an_element_question_is_refused_because_this_dialect_has_no_scope() {
let set = Unordered::<i64, sqlx::MySql>::try_from_filter(
SetFilter::<i64>::new().with_any(crate::ScalarFilter::new().with_eq(1)),
)
.unwrap();
let sequence = Sequence::<i64, sqlx::MySql>::try_from_filter(
ListFilter::<i64>::new().with_any(crate::ScalarFilter::new().with_eq(1)),
)
.unwrap();
assert_eq!(refusal(&set), Some(SqlLoweringError::JsonElementScope));
assert_eq!(refusal(&sequence), Some(SqlLoweringError::JsonElementScope));
}
fn refusal<C: ComplexComparison<sqlx::MySql>>(comparison: &C) -> Option<SqlLoweringError> {
let mut qb = sqlx::QueryBuilder::<sqlx::MySql>::default();
let frame = At::new(&ROW).frame(FieldName::new("t"));
let error = {
let out = SqlConjunction::with_lead(&mut qb, "");
comparison.apply(frame.at(), out).err()
};
assert_eq!(qb.sql(), "");
error
}
#[test]
fn a_cardinality_is_json_length() {
let crossed = Unordered::<i64, sqlx::MySql>::try_from_filter(
SetFilter::<i64>::new().with_count(crate::ScalarFilter::new().with_gte(1)),
)
.unwrap();
assert_eq!(
render::<sqlx::MySql, _>("t", &crossed),
("JSON_LENGTH(`t`) >= ?".to_owned(), 1)
);
}
}
#[test]
fn the_crossing_error_names_the_operator_it_refused() {
let json: ListCrossingError<core::convert::Infallible> = ListCrossingError::JsonOrdering("gt");
assert!(json.to_string().contains("JSON"));
assert!(json.to_string().contains("\"gt\""));
}
#[test]
fn each_kind_counts_its_own_slots() {
let sequence: Sequence<i64, ()> = Sequence {
eq: Some(Box::from([1i64])),
lt: Some(Box::from([2i64])),
..Sequence::new()
};
let set: Unordered<i64, ()> = Unordered {
eq: Some(Box::from([1i64])),
overlaps: Some(Box::from([2i64])),
..Unordered::new()
};
assert_eq!(sequence.conjuncts(), 2);
assert_eq!(set.conjuncts(), 2);
assert_eq!(sequence.eq(), set.eq());
}