use crate::{
BooleanFilter, BytesFilter, DefaultMarker, DefaultVecMarker, EnumFilter, EnumFilterMarker,
EnumMarker, FixedBytesFilter, GraphqlFilter, ListFilter, ListMarker, Nullable, ScalarFilter,
ScalarFilterMarker, ScalarMarker, Score, TextFilter, Timestamp, ToGraphqlFilter,
};
#[cfg(feature = "async-graphql")]
mod wire;
type Filter<T> = <<T as DefaultMarker>::Marker as ToGraphqlFilter>::Filter;
struct Field;
struct FieldFilter {
eq: Option<u8>,
}
impl ScalarFilterMarker for Field {
type Filter = FieldFilter;
}
impl DefaultMarker for Field {
type Marker = ScalarMarker<Field>;
}
impl GraphqlFilter for FieldFilter {
fn is_empty(&self) -> bool {
self.eq.is_none()
}
}
#[test]
fn the_shelf_names_the_public_traits() {
type Shelved<T> = <<T as crate::__private::marker::DefaultMarker>::Marker as crate::__private::graphql::ToGraphqlFilter>::Filter;
let empty: Shelved<Field> = FieldFilter { eq: None };
assert!(GraphqlFilter::is_empty(&empty));
assert!(!GraphqlFilter::is_empty(&FieldFilter { eq: Some(1) }));
}
#[derive(Clone, Copy)]
enum MediaKind {
Video,
Audio,
}
impl EnumFilterMarker for MediaKind {
type Filter = EnumFilter<MediaKind>;
}
impl DefaultMarker for MediaKind {
type Marker = EnumMarker<MediaKind>;
}
impl DefaultVecMarker for MediaKind {
type Marker = ListMarker<Vec<MediaKind>>;
}
fn same<A>(_: core::marker::PhantomData<A>, _: core::marker::PhantomData<A>) {}
#[test]
fn every_kind_answers_to_its_public_name_and_both_shelf_paths() {
use core::marker::PhantomData;
use crate::__private::{graphql as shelf, graphql::filter as kinds};
same(
PhantomData::<crate::ScalarFilter<i64>>,
PhantomData::<shelf::ScalarFilter<i64>>,
);
same(
PhantomData::<crate::ScalarFilter<i64>>,
PhantomData::<kinds::ScalarFilter<i64>>,
);
same(
PhantomData::<crate::EnumFilter<MediaKind>>,
PhantomData::<shelf::EnumFilter<MediaKind>>,
);
same(
PhantomData::<crate::EnumFilter<MediaKind>>,
PhantomData::<kinds::EnumFilter<MediaKind>>,
);
same(
PhantomData::<crate::BooleanFilter>,
PhantomData::<shelf::BooleanFilter>,
);
same(
PhantomData::<crate::BooleanFilter>,
PhantomData::<kinds::BooleanFilter>,
);
same(
PhantomData::<crate::TextFilter<String>>,
PhantomData::<shelf::TextFilter<String>>,
);
same(
PhantomData::<crate::TextFilter<String>>,
PhantomData::<kinds::TextFilter<String>>,
);
same(
PhantomData::<crate::BytesFilter<Vec<u8>>>,
PhantomData::<shelf::BytesFilter<Vec<u8>>>,
);
same(
PhantomData::<crate::BytesFilter<Vec<u8>>>,
PhantomData::<kinds::BytesFilter<Vec<u8>>>,
);
same(
PhantomData::<crate::ListFilter<i64>>,
PhantomData::<shelf::ListFilter<i64>>,
);
same(
PhantomData::<crate::ListFilter<i64>>,
PhantomData::<kinds::ListFilter<i64>>,
);
same(
PhantomData::<crate::Nullable<BooleanFilter>>,
PhantomData::<shelf::Nullable<BooleanFilter>>,
);
same(
PhantomData::<crate::Nullable<BooleanFilter>>,
PhantomData::<kinds::Nullable<BooleanFilter>>,
);
#[cfg(feature = "jiff")]
{
same(
PhantomData::<crate::DurationFilter>,
PhantomData::<shelf::DurationFilter>,
);
same(
PhantomData::<crate::DurationFilter>,
PhantomData::<kinds::DurationFilter>,
);
same(
PhantomData::<crate::DurationOutOfRange>,
PhantomData::<shelf::DurationOutOfRange>,
);
same(
PhantomData::<crate::DurationOutOfRange>,
PhantomData::<kinds::DurationOutOfRange>,
);
}
fn contract<F>()
where
F: crate::GraphqlFilter
+ crate::__private::graphql::GraphqlFilter
+ crate::__private::graphql::filter::GraphqlFilter,
{
}
contract::<BooleanFilter>();
{
let _: crate::BeU64 = u64::MAX.into();
let _: crate::BeU128 = u128::MAX.into();
let _: crate::BeI128 = i128::MIN.into();
#[cfg(all(feature = "jiff", feature = "time"))]
{
let _: crate::Temporal<time::OffsetDateTime> = jiff::Timestamp::UNIX_EPOCH.into();
}
}
same(
PhantomData::<crate::comparison::TextMatch>,
PhantomData::<crate::__private::comparison::TextMatch>,
);
#[cfg(feature = "sqlx")]
{
use crate::{
__private::comparison as shelf,
comparison::{TextMatch, sql as family},
};
same(
PhantomData::<family::SqlScalarComparison<i64, ()>>,
PhantomData::<shelf::sql::SqlScalarComparison<i64, ()>>,
);
same(
PhantomData::<family::SqlEnumComparison<i64, ()>>,
PhantomData::<shelf::sql::SqlEnumComparison<i64, ()>>,
);
same(
PhantomData::<family::SqlBooleanComparison<bool, ()>>,
PhantomData::<shelf::sql::SqlBooleanComparison<bool, ()>>,
);
same(
PhantomData::<family::SqlTextComparison<String, ()>>,
PhantomData::<shelf::sql::SqlTextComparison<String, ()>>,
);
same(
PhantomData::<family::SqlBytesComparison<Vec<u8>, ()>>,
PhantomData::<shelf::sql::SqlBytesComparison<Vec<u8>, ()>>,
);
same(
PhantomData::<family::SqlListComparison<i64, family::SqlScalarComparison<i64, ()>, ()>>,
PhantomData::<shelf::sql::SqlListComparison<i64, shelf::sql::SqlScalarComparison<i64, ()>, ()>>,
);
same(
PhantomData::<family::SqlSetComparison<i64, family::SqlScalarComparison<i64, ()>, ()>>,
PhantomData::<shelf::sql::SqlSetComparison<i64, shelf::sql::SqlScalarComparison<i64, ()>, ()>>,
);
same(
PhantomData::<family::SqlCountComparison<i64, ()>>,
PhantomData::<shelf::sql::SqlCountComparison<i64, ()>>,
);
same(
PhantomData::<family::SqlNullable<family::SqlScalarComparison<i64, ()>, i64>>,
PhantomData::<shelf::sql::SqlNullable<shelf::sql::SqlScalarComparison<i64, ()>, i64>>,
);
#[cfg(all(feature = "mysql", feature = "jiff"))]
{
same(
PhantomData::<crate::MySqlDuration>,
PhantomData::<shelf::sql::MySqlDuration>,
);
same(
PhantomData::<crate::MySqlDurationError>,
PhantomData::<shelf::sql::MySqlDurationError>,
);
}
same(
PhantomData::<family::CollectionOp>,
PhantomData::<shelf::sql::CollectionOp>,
);
let by_path: fn(&[i64]) -> String = family::json_elements;
let by_shelf: fn(&[i64]) -> String = shelf::sql::json_elements;
assert_eq!(by_path(&[1, 2]), by_shelf(&[1, 2]));
let by_path: fn(&str, TextMatch) -> String = family::like_pattern;
let by_shelf: fn(&str, TextMatch) -> String = shelf::sql::like_pattern;
assert_eq!(
by_path("a%", TextMatch::Prefix),
by_shelf("a%", TextMatch::Prefix)
);
#[cfg(feature = "jiff")]
same(
PhantomData::<family::SqlDurationComparison<i64, ()>>,
PhantomData::<shelf::sql::SqlDurationComparison<i64, ()>>,
);
fn crossing<C>()
where
C: crate::TryFromFilter<crate::ScalarFilter<i64>>
+ crate::comparison::TryFromFilter<crate::ScalarFilter<i64>>
+ crate::__private::comparison::TryFromFilter<crate::ScalarFilter<i64>>,
{
}
crossing::<family::SqlScalarComparison<i64, ()>>();
#[cfg(feature = "sqlite")]
{
fn maps<F>()
where
F: crate::ToDatabaseComparison<i64, sqlx::Sqlite>
+ crate::__private::comparison::ToDatabaseComparison<i64, sqlx::Sqlite>,
{
}
maps::<crate::ScalarFilter<i64>>();
fn carried<V>()
where
V: crate::Carrier<sqlx::Sqlite>
+ family::Carrier<sqlx::Sqlite>
+ shelf::sql::Carrier<sqlx::Sqlite>,
{
}
carried::<crate::BeU64>();
fn encoded<V>()
where
V: crate::JsonElement + family::JsonElement + shelf::sql::JsonElement,
{
}
encoded::<i64>();
fn lowered<C>()
where
C: crate::ComplexComparison<sqlx::Sqlite>
+ crate::__private::comparison::ComplexComparison<sqlx::Sqlite>,
{
}
lowered::<family::SqlScalarComparison<i64, sqlx::Sqlite>>();
}
}
}
#[test]
fn a_getter_named_eq_shadows_the_method_and_not_the_operator() {
let one = ScalarFilter::<i64>::new().with_eq(1i64).with_in_([2i64, 3]);
let same_again = ScalarFilter::new().with_eq(1i64).with_in_([2i64, 3]);
let other = ScalarFilter::new().with_eq(2i64);
assert_eq!(one, same_again);
assert!(one == same_again);
assert!(one != other);
assert!(!(one == other));
let _: Option<&i64> = one.eq();
let _: Option<&[i64]> = one.in_();
assert_eq!(one.eq(), Some(&1));
assert_eq!(one.ne(), None);
assert_eq!(one.in_(), Some(&[2i64, 3][..]));
assert_eq!(one.not_in(), None);
let empty = ScalarFilter::<i64>::new().with_in_(Vec::<i64>::new());
assert_eq!(empty.in_(), Some(&[][..]));
assert_eq!(empty.not_in(), None);
assert!(!empty.is_empty());
}
#[test]
fn every_kind_projects_its_operands() {
assert!(EnumFilter::new().with_eq(MediaKind::Video).eq().is_some());
assert_eq!(BooleanFilter::new().with_ne(true).ne(), Some(&true));
assert_eq!(
TextFilter::<&str>::new().with_contains("x").contains(),
Some(&"x")
);
assert_eq!(
BytesFilter::<Vec<u8>>::new().with_eq(vec![1u8]).eq(),
Some(&vec![1u8])
);
assert_eq!(
ListFilter::<i64>::new().with_lte([1i64]).lte(),
Some(&[1i64][..])
);
assert_eq!(
crate::SetFilter::<i64>::new()
.with_overlaps([1i64])
.overlaps(),
Some(&[1i64][..])
);
assert_eq!(
Nullable::new(ScalarFilter::<i64>::new())
.with_null(true)
.null(),
Some(&true)
);
#[cfg(feature = "jiff")]
assert_eq!(
crate::DurationFilter::new()
.with_gte(jiff::SignedDuration::from_secs(1))
.gte(),
Some(&jiff::SignedDuration::from_secs(1))
);
}
#[test]
fn try_map_converts_operands_and_keeps_the_operator_set() {
let mapped = ScalarFilter::<u8>::new()
.with_eq(1u8)
.with_in_([2u8, 3])
.try_map(|v| Ok::<_, core::convert::Infallible>(i64::from(v) * 10))
.unwrap();
assert_eq!(mapped.eq(), Some(&10));
assert_eq!(mapped.in_(), Some(&[20i64, 30][..]));
assert_eq!(mapped.gt(), None);
let refused = ScalarFilter::<i64>::new()
.with_in_([1i64, 300, 2])
.try_map(u8::try_from);
assert!(refused.is_err());
let nullable = Nullable::new(EnumFilter::new().with_eq(MediaKind::Audio))
.with_null(false)
.try_map(|inner| inner.try_map(|_| Ok::<_, core::convert::Infallible>(1i16)))
.unwrap();
assert_eq!(nullable.inner().eq(), Some(&1));
assert_eq!(nullable.null(), Some(&false));
}
#[test]
fn the_default_marker_maps_each_field_type_to_its_filter() {
same(
core::marker::PhantomData::<Filter<i64>>,
core::marker::PhantomData::<ScalarFilter<i64>>,
);
same(
core::marker::PhantomData::<Filter<Option<i64>>>,
core::marker::PhantomData::<Nullable<ScalarFilter<i64>>>,
);
same(
core::marker::PhantomData::<Filter<Vec<i64>>>,
core::marker::PhantomData::<ListFilter<i64>>,
);
same(
core::marker::PhantomData::<Filter<Option<Vec<i64>>>>,
core::marker::PhantomData::<ListFilter<i64>>,
);
same(
core::marker::PhantomData::<Filter<String>>,
core::marker::PhantomData::<TextFilter<String>>,
);
same(
core::marker::PhantomData::<Filter<Option<String>>>,
core::marker::PhantomData::<Nullable<TextFilter<String>>>,
);
same(
core::marker::PhantomData::<Filter<Vec<String>>>,
core::marker::PhantomData::<ListFilter<String, TextFilter<String>>>,
);
same(
core::marker::PhantomData::<Filter<Option<Vec<String>>>>,
core::marker::PhantomData::<ListFilter<String, TextFilter<String>>>,
);
same(
core::marker::PhantomData::<Filter<bool>>,
core::marker::PhantomData::<BooleanFilter>,
);
same(
core::marker::PhantomData::<Filter<Option<bool>>>,
core::marker::PhantomData::<Nullable<BooleanFilter>>,
);
same(
core::marker::PhantomData::<Filter<Vec<bool>>>,
core::marker::PhantomData::<ListFilter<bool>>,
);
same(
core::marker::PhantomData::<Filter<MediaKind>>,
core::marker::PhantomData::<EnumFilter<MediaKind>>,
);
same(
core::marker::PhantomData::<Filter<Vec<u8>>>,
core::marker::PhantomData::<BytesFilter<Vec<u8>>>,
);
same(
core::marker::PhantomData::<Filter<Option<Vec<u8>>>>,
core::marker::PhantomData::<Nullable<BytesFilter<Vec<u8>>>>,
);
same(
core::marker::PhantomData::<Filter<u8>>,
core::marker::PhantomData::<ScalarFilter<u8>>,
);
same(
core::marker::PhantomData::<Filter<Option<u8>>>,
core::marker::PhantomData::<Nullable<ScalarFilter<u8>>>,
);
same(
core::marker::PhantomData::<Filter<Vec<Vec<u8>>>>,
core::marker::PhantomData::<ListFilter<Vec<u8>>>,
);
same(
core::marker::PhantomData::<Filter<Option<Vec<Vec<u8>>>>>,
core::marker::PhantomData::<ListFilter<Vec<u8>>>,
);
same(
core::marker::PhantomData::<Filter<[u8; 32]>>,
core::marker::PhantomData::<FixedBytesFilter<[u8; 32], 32>>,
);
same(
core::marker::PhantomData::<Filter<Option<[u8; 32]>>>,
core::marker::PhantomData::<Nullable<FixedBytesFilter<[u8; 32], 32>>>,
);
same(
core::marker::PhantomData::<Filter<Vec<[u8; 32]>>>,
core::marker::PhantomData::<ListFilter<[u8; 32]>>,
);
same(
core::marker::PhantomData::<Filter<Option<Vec<[u8; 32]>>>>,
core::marker::PhantomData::<ListFilter<[u8; 32]>>,
);
}
#[test]
fn every_confidence_width_resolves_to_the_confidence_filter() {
use crate::{Confidence, ConfidenceFilter};
same(
core::marker::PhantomData::<Filter<Score>>,
core::marker::PhantomData::<ConfidenceFilter>,
);
same(
core::marker::PhantomData::<Filter<Confidence<f64>>>,
core::marker::PhantomData::<ConfidenceFilter>,
);
same(
core::marker::PhantomData::<Filter<Option<Score>>>,
core::marker::PhantomData::<Nullable<ConfidenceFilter>>,
);
same(
core::marker::PhantomData::<Filter<Vec<Score>>>,
core::marker::PhantomData::<ListFilter<Score>>,
);
}
#[test]
fn timestamp_resolves_to_a_scalar_filter() {
same(
core::marker::PhantomData::<Filter<Timestamp>>,
core::marker::PhantomData::<ScalarFilter<Timestamp>>,
);
same(
core::marker::PhantomData::<Filter<Option<Timestamp>>>,
core::marker::PhantomData::<Nullable<ScalarFilter<Timestamp>>>,
);
same(
core::marker::PhantomData::<Filter<Vec<Timestamp>>>,
core::marker::PhantomData::<ListFilter<Timestamp>>,
);
}
#[test]
fn list_operator_slots_are_boxed_slices() {
use core::mem::{align_of, size_of};
let word = size_of::<usize>();
let list = size_of::<Option<Box<[i64]>>>();
let operand = size_of::<Option<i64>>();
assert_eq!(list, 2 * word);
assert_eq!(size_of::<Option<Vec<i64>>>(), 3 * word);
assert_eq!(size_of::<ScalarFilter<i64>>(), 6 * operand + 2 * list);
assert_eq!(size_of::<EnumFilter<i64>>(), 2 * operand + 2 * list);
let element = size_of::<Option<ScalarFilter<i64>>>();
let cardinality = size_of::<Option<ScalarFilter<usize>>>();
assert_eq!(
size_of::<ListFilter<i64>>(),
6 * list + operand + element + cardinality
);
assert_eq!(
size_of::<crate::SetFilter<i64>>(),
5 * list + operand + element + cardinality
);
assert_eq!(
size_of::<TextFilter<String>>(),
18 * size_of::<Option<String>>() + 2 * list
);
assert_eq!(
size_of::<BytesFilter<Vec<u8>>>(),
8 * size_of::<Option<Vec<u8>>>() + 2 * list
);
assert_eq!(
size_of::<Nullable<ScalarFilter<i64>>>(),
size_of::<ScalarFilter<i64>>() + align_of::<ScalarFilter<i64>>()
);
}
#[test]
fn every_filter_is_empty_until_a_field_is_set() {
assert!(ScalarFilter::<i64>::new().is_empty());
assert!(!ScalarFilter::<i64>::new().with_gt(1).is_empty());
assert!(EnumFilter::<MediaKind>::new().is_empty());
assert!(
!EnumFilter::<MediaKind>::new()
.with_eq(MediaKind::Video)
.is_empty()
);
assert!(
!EnumFilter::<MediaKind>::new()
.with_in_([MediaKind::Video, MediaKind::Audio])
.is_empty()
);
assert!(BooleanFilter::new().is_empty());
assert!(!BooleanFilter::new().with_eq(true).is_empty());
assert!(!BooleanFilter::new().with_ne(true).is_empty());
assert!(!BooleanFilter::new().with_in_([true, false]).is_empty());
assert!(!BooleanFilter::new().with_not_in([true]).is_empty());
assert!(!BooleanFilter::new().with_in_([]).is_empty());
assert!(BooleanFilter::default().is_empty());
assert!(TextFilter::<String>::new().is_empty());
assert!(
!TextFilter::<String>::new()
.with_contains("x".into())
.is_empty()
);
assert!(BytesFilter::<Vec<u8>>::new().is_empty());
assert!(
!BytesFilter::<Vec<u8>>::new()
.with_contains(b"x".to_vec())
.is_empty()
);
assert!(FixedBytesFilter::<[u8; 32], 32>::new().is_empty());
assert!(
!FixedBytesFilter::<[u8; 32], 32>::new()
.with_eq([0; 32])
.is_empty()
);
assert!(ListFilter::<i64>::new().is_empty());
assert!(!ListFilter::<i64>::new().with_has_element(1).is_empty());
assert!(Nullable::new(ScalarFilter::<i64>::new()).is_empty());
assert!(
!Nullable::new(ScalarFilter::<i64>::new())
.with_null(true)
.is_empty()
);
assert!(!Nullable::new(ScalarFilter::<i64>::new().with_gt(1)).is_empty());
assert!(Nullable::<ListFilter<i64>>::default().is_empty());
}
type Exclusion<F> = (&'static str, fn(F) -> F);
#[test]
fn is_referential_admits_a_lone_equality_or_membership_and_nothing_else() {
assert!(ScalarFilter::<i64>::new().with_eq(1).is_referential());
assert!(ScalarFilter::<i64>::new().with_in_([1]).is_referential());
assert!(
TextFilter::<String>::new()
.with_eq("a".into())
.is_referential()
);
assert!(
TextFilter::<String>::new()
.with_in_(["a".into()])
.is_referential()
);
assert!(
EnumFilter::<MediaKind>::new()
.with_eq(MediaKind::Video)
.is_referential()
);
assert!(
EnumFilter::<MediaKind>::new()
.with_in_([MediaKind::Audio])
.is_referential()
);
assert!(
BytesFilter::<Vec<u8>>::new()
.with_eq(b"a".to_vec())
.is_referential()
);
assert!(
BytesFilter::<Vec<u8>>::new()
.with_in_([b"a".to_vec()])
.is_referential()
);
assert!(
!ScalarFilter::<i64>::new()
.with_eq(1)
.with_in_([1])
.is_referential()
);
assert!(!ScalarFilter::<i64>::new().is_referential());
let scalar: [Exclusion<ScalarFilter<i64>>; 6] = [
("ne", |f| f.with_ne(2)),
("gt", |f| f.with_gt(2)),
("gte", |f| f.with_gte(2)),
("lt", |f| f.with_lt(2)),
("lte", |f| f.with_lte(2)),
("not_in", |f| f.with_not_in([2])),
];
for (operator, set) in scalar {
assert!(
!set(ScalarFilter::new().with_eq(1)).is_referential(),
"`eq` beside `{operator}` is not a referential shape"
);
}
let enumerated: [Exclusion<EnumFilter<MediaKind>>; 2] = [
("ne", |f| f.with_ne(MediaKind::Audio)),
("not_in", |f| f.with_not_in([MediaKind::Audio])),
];
for (operator, set) in enumerated {
assert!(
!set(EnumFilter::new().with_eq(MediaKind::Video)).is_referential(),
"`eq` beside `{operator}` is not a referential shape"
);
}
let text: [Exclusion<TextFilter<String>>; 18] = [
("ne", |f| f.with_ne("b".into())),
("gt", |f| f.with_gt("b".into())),
("gte", |f| f.with_gte("b".into())),
("lt", |f| f.with_lt("b".into())),
("lte", |f| f.with_lte("b".into())),
("contains", |f| f.with_contains("b".into())),
("contains_nocase", |f| f.with_contains_nocase("b".into())),
("not_contains", |f| f.with_not_contains("b".into())),
("not_contains_nocase", |f| {
f.with_not_contains_nocase("b".into())
}),
("starts_with", |f| f.with_starts_with("b".into())),
("starts_with_nocase", |f| {
f.with_starts_with_nocase("b".into())
}),
("not_starts_with", |f| f.with_not_starts_with("b".into())),
("not_starts_with_nocase", |f| {
f.with_not_starts_with_nocase("b".into())
}),
("ends_with", |f| f.with_ends_with("b".into())),
("ends_with_nocase", |f| f.with_ends_with_nocase("b".into())),
("not_ends_with", |f| f.with_not_ends_with("b".into())),
("not_ends_with_nocase", |f| {
f.with_not_ends_with_nocase("b".into())
}),
("not_in", |f| f.with_not_in(["b".into()])),
];
for (operator, set) in text {
assert!(
!set(TextFilter::new().with_eq("a".into())).is_referential(),
"`eq` beside `{operator}` is not a referential shape"
);
}
let bytes: [Exclusion<BytesFilter<Vec<u8>>>; 8] = [
("ne", |f| f.with_ne(b"b".to_vec())),
("gt", |f| f.with_gt(b"b".to_vec())),
("gte", |f| f.with_gte(b"b".to_vec())),
("lt", |f| f.with_lt(b"b".to_vec())),
("lte", |f| f.with_lte(b"b".to_vec())),
("contains", |f| f.with_contains(b"b".to_vec())),
("not_contains", |f| f.with_not_contains(b"b".to_vec())),
("not_in", |f| f.with_not_in([b"b".to_vec()])),
];
for (operator, set) in bytes {
assert!(
!set(BytesFilter::new().with_eq(b"a".to_vec())).is_referential(),
"`eq` beside `{operator}` is not a referential shape"
);
}
}
#[cfg(feature = "smol_str")]
#[test]
fn smol_str_is_a_text_column() {
use smol_str::SmolStr;
same(
core::marker::PhantomData::<Filter<SmolStr>>,
core::marker::PhantomData::<TextFilter<SmolStr>>,
);
same(
core::marker::PhantomData::<Filter<Option<SmolStr>>>,
core::marker::PhantomData::<Nullable<TextFilter<SmolStr>>>,
);
assert!(
!TextFilter::<SmolStr>::new()
.with_starts_with(SmolStr::new("x"))
.is_empty()
);
}
#[test]
fn the_bytes_crates_blob_is_a_byte_column_and_its_buffer_is_not_a_column_at_all() {
use bytes::Bytes;
same(
core::marker::PhantomData::<Filter<Bytes>>,
core::marker::PhantomData::<BytesFilter<Bytes>>,
);
same(
core::marker::PhantomData::<Filter<Option<Bytes>>>,
core::marker::PhantomData::<Nullable<BytesFilter<Bytes>>>,
);
assert!(
!BytesFilter::<Bytes>::new()
.with_contains(Bytes::from_static(b"x"))
.is_empty()
);
}
#[test]
fn smol_bytes_registers_one_name_per_face_at_the_crates_own_spelling() {
same(
core::marker::PhantomData::<Filter<smol_bytes::Bytes>>,
core::marker::PhantomData::<BytesFilter<smol_bytes::shared::Bytes>>,
);
same(
core::marker::PhantomData::<Filter<smol_bytes::Utf8Bytes>>,
core::marker::PhantomData::<TextFilter<smol_bytes::shared::Utf8Bytes>>,
);
assert!(
!BytesFilter::<smol_bytes::Bytes>::new()
.with_contains(smol_bytes::Bytes::from_static(b"x"))
.is_empty()
);
assert!(
!TextFilter::<smol_bytes::Utf8Bytes>::new()
.with_starts_with(smol_bytes::Utf8Bytes::from(String::from("x")))
.is_empty()
);
}
#[cfg(feature = "jiff")]
#[test]
fn the_four_orderable_jiff_types_are_scalar_columns() {
use jiff::{
Timestamp, Zoned,
civil::{Date, Time},
tz::TimeZone,
};
same(
core::marker::PhantomData::<Filter<Timestamp>>,
core::marker::PhantomData::<ScalarFilter<Timestamp>>,
);
same(
core::marker::PhantomData::<Filter<Option<Timestamp>>>,
core::marker::PhantomData::<Nullable<ScalarFilter<Timestamp>>>,
);
same(
core::marker::PhantomData::<Filter<Date>>,
core::marker::PhantomData::<ScalarFilter<Date>>,
);
same(
core::marker::PhantomData::<Filter<Time>>,
core::marker::PhantomData::<ScalarFilter<Time>>,
);
same(
core::marker::PhantomData::<Filter<Zoned>>,
core::marker::PhantomData::<ScalarFilter<Zoned>>,
);
same(
core::marker::PhantomData::<Filter<Vec<Timestamp>>>,
core::marker::PhantomData::<ListFilter<Timestamp>>,
);
assert!(
!ScalarFilter::<Timestamp>::new()
.with_gte(Timestamp::UNIX_EPOCH)
.is_empty()
);
assert!(
!ScalarFilter::<Date>::new()
.with_lt(Date::constant(2026, 1, 1))
.is_empty()
);
assert!(
!ScalarFilter::<Time>::new()
.with_gt(Time::midnight())
.is_empty()
);
assert!(
!ScalarFilter::<Zoned>::new()
.with_in_([Timestamp::UNIX_EPOCH.to_zoned(TimeZone::UTC)])
.is_empty()
);
}
#[cfg(feature = "jiff")]
#[test]
fn a_zoned_operand_compares_by_instant_and_not_by_zone() {
use jiff::{
Timestamp, Zoned,
tz::{Offset, TimeZone},
};
let utc: Zoned = Timestamp::UNIX_EPOCH.to_zoned(TimeZone::UTC);
let shifted: Zoned = utc
.timestamp()
.to_zoned(TimeZone::fixed(Offset::constant(-5)));
assert_eq!(utc, shifted);
assert_eq!(utc.cmp(&shifted), core::cmp::Ordering::Equal);
assert_ne!(utc.to_string(), shifted.to_string());
}
#[cfg(feature = "jiff")]
#[test]
fn a_span_has_no_single_comparison_to_filter_by() {
use core::cmp::Ordering;
use jiff::{ToSpan, civil::date};
assert_eq!(
120
.minutes()
.compare(2.hours())
.expect("both are time units"),
Ordering::Equal
);
assert_ne!(120.minutes().fieldwise(), 2.hours().fieldwise());
assert!(1.month().compare(30.days()).is_err());
assert_eq!(
1.month()
.compare((30.days(), date(2026, 1, 1)))
.expect("a relative date answers it"),
Ordering::Greater
);
assert_eq!(
1.month()
.compare((30.days(), date(2026, 2, 1)))
.expect("a relative date answers it"),
Ordering::Less
);
}
#[cfg(feature = "jiff")]
#[test]
fn duration_maps_to_a_filter_of_its_own() {
use jiff::SignedDuration;
use crate::DurationFilter;
same(
core::marker::PhantomData::<Filter<SignedDuration>>,
core::marker::PhantomData::<DurationFilter>,
);
same(
core::marker::PhantomData::<Filter<Option<SignedDuration>>>,
core::marker::PhantomData::<Nullable<DurationFilter>>,
);
same(
core::marker::PhantomData::<Filter<Vec<SignedDuration>>>,
core::marker::PhantomData::<ListFilter<SignedDuration>>,
);
same(
core::marker::PhantomData::<Filter<Option<Vec<SignedDuration>>>>,
core::marker::PhantomData::<ListFilter<SignedDuration>>,
);
assert!(DurationFilter::new().is_empty());
assert!(DurationFilter::default().is_empty());
assert!(
!DurationFilter::new()
.with_gte(SignedDuration::from_secs(1))
.is_empty()
);
assert!(
!DurationFilter::new()
.with_in_([SignedDuration::from_millis(500)])
.is_empty()
);
}