use super::{
ListCrossingError, PgCollectionStorage, SqlListComparison, SqlSetComparison, cross_count,
cross_element, flatten_list, from_stored,
};
#[cfg(all(feature = "jiff", feature = "time"))]
use super::StrategyOver;
#[cfg(all(feature = "jiff", feature = "time"))]
use crate::Temporal;
use crate::{
BeI128, BeU64, BeU128, Count, ListFilter, TryMapFilter,
comparison::{
At, Backend, ComplexComparison, ToDatabaseComparison, TryFromFilter,
sql::{
ELEMENT_ALIAS, ELEMENT_VALUE, SqlConjunction, SqlCountComparison, SqlEdgeComparison,
SqlEdgeSetComparison, not_wrapped, push_column, push_count_slots, push_element_scope,
quote_ident, render_column,
},
},
};
trait PgArrayElement:
sqlx::postgres::PgHasArrayType
+ sqlx::Type<sqlx::Postgres>
+ for<'q> sqlx::Encode<'q, sqlx::Postgres>
{
}
impl<V> PgArrayElement for V where
V: sqlx::postgres::PgHasArrayType
+ sqlx::Type<sqlx::Postgres>
+ for<'q> sqlx::Encode<'q, sqlx::Postgres>
{
}
macro_rules! pg_collection_storage {
($sequence:ident / $set:ident { $( $ty:ty ),+ $(,)? }) => {
$(
impl<VF: ToDatabaseComparison<$ty, sqlx::Postgres>> PgCollectionStorage<VF> for $ty {
type Sequence = $sequence<$ty, VF::Comparison, sqlx::Postgres>;
type Set = $set<$ty, VF::Comparison, sqlx::Postgres>;
}
impl<'a, VF: ToDatabaseComparison<&'a $ty, sqlx::Postgres>> PgCollectionStorage<VF>
for &'a $ty
{
type Sequence = $sequence<&'a $ty, VF::Comparison, sqlx::Postgres>;
type Set = $set<&'a $ty, VF::Comparison, sqlx::Postgres>;
}
)+
};
}
pg_collection_storage!(SqlListComparison / SqlSetComparison {
bool,
i16,
i32,
i64,
f32,
f64,
String,
Vec<u8>,
::core::time::Duration,
sqlx::postgres::types::PgInterval
});
pg_collection_storage!(
SqlEdgeComparison
/ SqlEdgeSetComparison {
i8,
u8,
u16,
u32,
BeU64,
BeU128,
BeI128,
Count
}
);
impl<S, VF> PgCollectionStorage<VF> for crate::Confidence<S>
where
S: crate::ConfidenceCarrier + crate::Carrier<sqlx::Postgres>,
VF: ToDatabaseComparison<crate::Confidence<S>, sqlx::Postgres>,
{
type Sequence = SqlEdgeComparison<crate::Confidence<S>, VF::Comparison, sqlx::Postgres>;
type Set = SqlEdgeSetComparison<crate::Confidence<S>, VF::Comparison, sqlx::Postgres>;
}
impl<'a, S, VF> PgCollectionStorage<VF> for &'a crate::Confidence<S>
where
S: crate::ConfidenceCarrier + crate::Carrier<sqlx::Postgres>,
VF: ToDatabaseComparison<&'a crate::Confidence<S>, sqlx::Postgres>,
{
type Sequence = SqlEdgeComparison<&'a crate::Confidence<S>, VF::Comparison, sqlx::Postgres>;
type Set = SqlEdgeSetComparison<&'a crate::Confidence<S>, VF::Comparison, sqlx::Postgres>;
}
#[cfg(feature = "time")]
pg_collection_storage!(SqlListComparison / SqlSetComparison {
time::OffsetDateTime,
time::PrimitiveDateTime,
time::Date,
time::Time
});
#[cfg(all(feature = "jiff", feature = "time"))]
#[diagnostic::do_not_recommend]
impl<T, VF> PgCollectionStorage<VF> for Temporal<T>
where
T: PgCollectionStorage<VF>,
<T as PgCollectionStorage<VF>>::Sequence:
StrategyOver<Temporal<T>, Comparison: ComplexComparison<sqlx::Postgres>>,
<T as PgCollectionStorage<VF>>::Set:
StrategyOver<Temporal<T>, Comparison: ComplexComparison<sqlx::Postgres>>,
{
type Sequence =
<<T as PgCollectionStorage<VF>>::Sequence as StrategyOver<Temporal<T>>>::Comparison;
type Set = <<T as PgCollectionStorage<VF>>::Set as StrategyOver<Temporal<T>>>::Comparison;
}
#[cfg(all(feature = "jiff", feature = "time"))]
#[diagnostic::do_not_recommend]
impl<'a, T, VF> PgCollectionStorage<VF> for &'a Temporal<T>
where
T: PgCollectionStorage<VF>,
<T as PgCollectionStorage<VF>>::Sequence:
StrategyOver<&'a Temporal<T>, Comparison: ComplexComparison<sqlx::Postgres>>,
<T as PgCollectionStorage<VF>>::Set:
StrategyOver<&'a Temporal<T>, Comparison: ComplexComparison<sqlx::Postgres>>,
{
type Sequence =
<<T as PgCollectionStorage<VF>>::Sequence as StrategyOver<&'a Temporal<T>>>::Comparison;
type Set = <<T as PgCollectionStorage<VF>>::Set as StrategyOver<&'a Temporal<T>>>::Comparison;
}
impl<V, C> SqlListComparison<V, C, sqlx::Postgres> {
pub fn try_from_filter_with<D, VF, E, F>(
filter: ListFilter<D, VF>,
f: F,
) -> Result<Self, ListCrossingError<E, <C as TryFromFilter<VF::Mapped>>::Error>>
where
F: Fn(D) -> Result<V, E>,
VF: TryMapFilter<D, V>,
C: TryFromFilter<VF::Mapped>,
{
Self::try_from_filter_with_element(filter, &f, |element| {
let stored = element
.try_map_filter(&f)
.map_err(ListCrossingError::Operand)?;
C::try_from_filter(stored).map_err(ListCrossingError::Element)
})
.map_err(flatten_list)
}
pub fn try_from_filter_with_element<D, VF, E, F, X, G>(
filter: ListFilter<D, VF>,
f: F,
g: G,
) -> Result<Self, ListCrossingError<E, X>>
where
F: FnMut(D) -> Result<V, E>,
G: FnOnce(VF) -> Result<C, X>,
{
let mut stored = filter.try_map(f).map_err(ListCrossingError::Operand)?;
let any = cross_element(stored.any.take(), g).map_err(ListCrossingError::Element)?;
let count = cross_count(stored.count.take()).map_err(ListCrossingError::Cardinality)?;
Ok(from_stored(stored, any, count))
}
}
impl<D, VF, V: TryFrom<D>, C: TryFromFilter<VF>> TryFromFilter<ListFilter<D, VF>>
for SqlListComparison<V, C, sqlx::Postgres>
{
type Error = ListCrossingError<V::Error, C::Error>;
fn try_from_filter(filter: ListFilter<D, VF>) -> Result<Self, Self::Error> {
Self::try_from_filter_with_element(filter, V::try_from, C::try_from_filter)
}
}
impl<V: PgArrayElement, C: ComplexComparison<sqlx::Postgres>> ComplexComparison<sqlx::Postgres>
for SqlListComparison<V, C, sqlx::Postgres>
{
#[inline]
fn conjuncts(&self) -> usize {
Self::conjuncts(self)
}
fn apply<'q>(
&'q self,
at: At<'_>,
mut builder: <sqlx::Postgres as Backend>::Builder<'q>,
) -> Result<<sqlx::Postgres as Backend>::Builder<'q>, <sqlx::Postgres as Backend>::Error> {
push_list_slots(self, at, &mut builder);
push_unnest_any(self.any.as_ref(), at, &mut builder)?;
push_array_count(self.count.as_ref(), at, &mut builder);
Ok(builder)
}
}
impl<V: PgArrayElement, C: ComplexComparison<sqlx::Postgres>> ComplexComparison<sqlx::Postgres>
for SqlSetComparison<V, C, sqlx::Postgres>
{
#[inline]
fn conjuncts(&self) -> usize {
Self::conjuncts(self)
}
fn apply<'q>(
&'q self,
at: At<'_>,
mut builder: <sqlx::Postgres as Backend>::Builder<'q>,
) -> Result<<sqlx::Postgres as Backend>::Builder<'q>, <sqlx::Postgres as Backend>::Error> {
push_set_slots(self, at, &mut builder);
push_unnest_any(self.any.as_ref(), at, &mut builder)?;
push_array_count(self.count.as_ref(), at, &mut builder);
Ok(builder)
}
}
fn push_list_slots<V: PgArrayElement, C>(
comparison: &SqlListComparison<V, C, sqlx::Postgres>,
at: At<'_>,
out: &mut SqlConjunction<'_, sqlx::Postgres>,
) {
for (slot, negated) in [(&comparison.eq, false), (&comparison.ne, true)] {
if let Some(values) = slot {
push_array_op(out.open(), at, " = ", values, negated);
}
}
for (slot, op) in [
(&comparison.gt, " > "),
(&comparison.gte, " >= "),
(&comparison.lt, " < "),
(&comparison.lte, " <= "),
] {
if let Some(values) = slot {
push_array_op(out.open(), at, op, values, false);
}
}
push_membership(comparison.has_element.as_ref(), at, out);
}
fn push_set_slots<V: PgArrayElement, C>(
comparison: &SqlSetComparison<V, C, sqlx::Postgres>,
at: At<'_>,
out: &mut SqlConjunction<'_, sqlx::Postgres>,
) {
for (slot, negated) in [(&comparison.eq, false), (&comparison.ne, true)] {
if let Some(values) = slot {
push_mutual_containment(out, at, values, negated);
}
}
for (slot, op) in [
(&comparison.encloses, " @> "),
(&comparison.enclosed_by, " <@ "),
(&comparison.overlaps, " && "),
] {
if let Some(values) = slot {
push_array_op(out.open(), at, op, values, false);
}
}
push_membership(comparison.has_element.as_ref(), at, out);
}
fn push_membership<V: PgArrayElement>(
element: Option<&V>,
at: At<'_>,
out: &mut SqlConjunction<'_, sqlx::Postgres>,
) {
if let Some(element) = element {
push_array_op(
out.open(),
at,
" @> ",
core::slice::from_ref(element),
false,
);
}
}
fn push_array_op<V: PgArrayElement>(
qb: &mut sqlx::QueryBuilder<sqlx::Postgres>,
at: At<'_>,
op: &str,
values: &[V],
negated: bool,
) {
not_wrapped(qb, negated, |qb| {
push_column(qb, at);
qb.push(op);
qb.push_bind(values);
});
}
fn push_unnest_any<C>(
element: Option<&C>,
at: At<'_>,
out: &mut SqlConjunction<'_, sqlx::Postgres>,
) -> Result<(), <sqlx::Postgres as Backend>::Error>
where
C: ComplexComparison<sqlx::Postgres>,
{
let Some(element) = element else {
return Ok(());
};
let column = render_column::<sqlx::Postgres>(at);
push_element_scope(out.open(), element, at, |qb| {
qb.push("unnest(");
qb.push(&column);
qb.push(") AS ");
qb.push(quote_ident::<sqlx::Postgres>(ELEMENT_ALIAS));
qb.push("(");
qb.push(quote_ident::<sqlx::Postgres>(ELEMENT_VALUE));
qb.push(")");
})
}
fn push_array_count(
count: Option<&SqlCountComparison<i64, sqlx::Postgres>>,
at: At<'_>,
out: &mut SqlConjunction<'_, sqlx::Postgres>,
) {
let Some(count) = count else {
return;
};
let column = render_column::<sqlx::Postgres>(at);
push_count_slots(count, out, |qb| {
qb.push("cardinality(");
qb.push(&column);
qb.push(")");
});
}
fn push_mutual_containment<V: PgArrayElement>(
out: &mut SqlConjunction<'_, sqlx::Postgres>,
at: At<'_>,
values: &[V],
negated: bool,
) {
let column = render_column::<sqlx::Postgres>(at);
not_wrapped(out.open(), negated, |qb| {
qb.push("( ");
qb.push(&column);
qb.push(" @> ");
qb.push_bind(values);
qb.push(" AND ");
qb.push(&column);
qb.push(" <@ ");
qb.push_bind(values);
qb.push(" )");
});
}