use bson::{Bson, Document};
use super::{
Mongo, MongoCarrier, MongoConjunction, MongoCountComparison, MongoLoweringError, MongoOperator,
NOR, count::push_count_slots, field_path, membership,
};
use crate::{
ListFilter, QuantifiedFilter, ScalarFilter, SetFilter, TryMapFilter,
comparison::{At, Backend, ComplexComparison, ToDatabaseComparison, TryFromFilter},
};
mongo_comparison_kind! {
MongoListComparison {
one { has_element }
many { eq, ne, gt, gte, lt, lte }
element { any: C }
cardinality { count }
}
}
mongo_comparison_kind! {
MongoSetComparison {
one { has_element }
many { eq, ne, encloses, enclosed_by, overlaps }
element { any: C }
cardinality { count }
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum MongoCollectionCrossingError<E, X = E> {
Operand(E),
Element(X),
Cardinality(core::num::TryFromIntError),
}
impl<E: core::fmt::Display, X: core::fmt::Display> core::fmt::Display
for MongoCollectionCrossingError<E, X>
{
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
match self {
Self::Operand(error) => error.fmt(f),
Self::Element(error) => error.fmt(f),
Self::Cardinality(error) => error.fmt(f),
}
}
}
impl<E, X> std::error::Error for MongoCollectionCrossingError<E, X>
where
E: std::error::Error + 'static,
X: std::error::Error + 'static,
{
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match self {
Self::Operand(error) => Some(error),
Self::Element(error) => Some(error),
Self::Cardinality(error) => Some(error),
}
}
}
fn cross_element<VF, C, X>(
filter: Option<VF>,
g: impl FnOnce(VF) -> Result<C, X>,
) -> Result<Option<C>, X> {
match filter {
Some(filter) => g(filter).map(Some),
None => Ok(None),
}
}
fn cross_count(
filter: Option<ScalarFilter<usize>>,
) -> Result<Option<MongoCountComparison<i64>>, core::num::TryFromIntError> {
match filter {
Some(filter) => MongoCountComparison::try_from_filter(filter).map(Some),
None => Ok(None),
}
}
fn flatten_collection<E, X>(
why: MongoCollectionCrossingError<E, MongoCollectionCrossingError<E, X>>,
) -> MongoCollectionCrossingError<E, X> {
match why {
MongoCollectionCrossingError::Operand(error) => MongoCollectionCrossingError::Operand(error),
MongoCollectionCrossingError::Element(inner) => inner,
MongoCollectionCrossingError::Cardinality(error) => {
MongoCollectionCrossingError::Cardinality(error)
}
}
}
impl<V, C> MongoListComparison<V, C> {
pub fn try_from_filter_with<D, VF, E, F>(
filter: ListFilter<D, VF>,
f: F,
) -> Result<Self, MongoCollectionCrossingError<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(MongoCollectionCrossingError::Operand)?;
C::try_from_filter(stored).map_err(MongoCollectionCrossingError::Element)
})
.map_err(flatten_collection)
}
pub fn try_from_filter_with_element<D, VF, E, F, X, G>(
filter: ListFilter<D, VF>,
f: F,
g: G,
) -> Result<Self, MongoCollectionCrossingError<E, X>>
where
F: FnMut(D) -> Result<V, E>,
G: FnOnce(VF) -> Result<C, X>,
{
let mut stored = filter
.try_map(f)
.map_err(MongoCollectionCrossingError::Operand)?;
let any = cross_element(stored.any.take(), g).map_err(MongoCollectionCrossingError::Element)?;
let count = cross_count(stored.count).map_err(MongoCollectionCrossingError::Cardinality)?;
Ok(Self {
has_element: stored.has_element,
eq: stored.eq,
ne: stored.ne,
gt: stored.gt,
gte: stored.gte,
lt: stored.lt,
lte: stored.lte,
any,
count,
})
}
}
impl<V, C> MongoSetComparison<V, C> {
pub fn try_from_filter_with<D, VF, E, F>(
filter: SetFilter<D, VF>,
f: F,
) -> Result<Self, MongoCollectionCrossingError<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(MongoCollectionCrossingError::Operand)?;
C::try_from_filter(stored).map_err(MongoCollectionCrossingError::Element)
})
.map_err(flatten_collection)
}
pub fn try_from_filter_with_element<D, VF, E, F, X, G>(
filter: SetFilter<D, VF>,
f: F,
g: G,
) -> Result<Self, MongoCollectionCrossingError<E, X>>
where
F: FnMut(D) -> Result<V, E>,
G: FnOnce(VF) -> Result<C, X>,
{
let mut stored = filter
.try_map(f)
.map_err(MongoCollectionCrossingError::Operand)?;
let any = cross_element(stored.any.take(), g).map_err(MongoCollectionCrossingError::Element)?;
let count = cross_count(stored.count).map_err(MongoCollectionCrossingError::Cardinality)?;
Ok(Self {
has_element: stored.has_element,
eq: stored.eq,
ne: stored.ne,
encloses: stored.encloses,
enclosed_by: stored.enclosed_by,
overlaps: stored.overlaps,
any,
count,
})
}
}
impl<D, VF, V> ToDatabaseComparison<V, Mongo> for ListFilter<D, VF>
where
V: MongoCarrier,
VF: ToDatabaseComparison<V, Mongo>,
{
type Comparison = MongoListComparison<V, VF::Comparison>;
}
impl<D, VF, V> ToDatabaseComparison<V, Mongo> for SetFilter<D, VF>
where
V: MongoCarrier,
VF: ToDatabaseComparison<V, Mongo>,
{
type Comparison = MongoSetComparison<V, VF::Comparison>;
}
impl<D, VF, V> ToDatabaseComparison<V, Mongo> for QuantifiedFilter<D, VF>
where
V: MongoCarrier,
VF: ToDatabaseComparison<V, Mongo>,
{
type Comparison = MongoListComparison<V, VF::Comparison>;
}
impl<D, VF, V: TryFrom<D>, C: TryFromFilter<VF>> TryFromFilter<ListFilter<D, VF>>
for MongoListComparison<V, C>
{
type Error = MongoCollectionCrossingError<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<D, VF, V, C: TryFromFilter<VF>> TryFromFilter<QuantifiedFilter<D, VF>>
for MongoListComparison<V, C>
{
type Error = MongoCollectionCrossingError<core::convert::Infallible, C::Error>;
fn try_from_filter(filter: QuantifiedFilter<D, VF>) -> Result<Self, Self::Error> {
let mut crossed = Self::new();
crossed.any = cross_element(filter.any, C::try_from_filter)
.map_err(MongoCollectionCrossingError::Element)?;
crossed.count = cross_count(filter.count).map_err(MongoCollectionCrossingError::Cardinality)?;
Ok(crossed)
}
}
impl<D, VF, V: TryFrom<D>, C: TryFromFilter<VF>> TryFromFilter<SetFilter<D, VF>>
for MongoSetComparison<V, C>
{
type Error = MongoCollectionCrossingError<V::Error, C::Error>;
fn try_from_filter(filter: SetFilter<D, VF>) -> Result<Self, Self::Error> {
Self::try_from_filter_with_element(filter, V::try_from, C::try_from_filter)
}
}
const ARRAY_TYPE: &str = "array";
fn element_scope<C: ComplexComparison<Mongo>>(
element: &C,
at: At<'_>,
) -> Result<Bson, MongoLoweringError> {
let mut scope = element
.apply(at.top(), MongoConjunction::element())?
.into_element_document()?;
if scope.is_empty() {
scope.insert(MongoOperator::Exists.as_str(), Bson::Boolean(true));
}
Ok(Bson::Document(scope))
}
fn outside<V: MongoCarrier>(elements: &[V]) -> Bson {
let mut excluded = Document::new();
excluded.insert(MongoOperator::Nin.as_str(), membership(elements));
let mut scope = Document::new();
scope.insert(MongoOperator::ElemMatch.as_str(), Bson::Document(excluded));
Bson::Document(scope)
}
fn set_equality<V: MongoCarrier>(elements: &[V], mut write: impl FnMut(MongoOperator, Bson)) {
write(MongoOperator::Type, Bson::String(ARRAY_TYPE.to_owned()));
if !elements.is_empty() {
write(MongoOperator::All, membership(elements));
}
write(MongoOperator::Not, outside(elements));
}
fn push_shared_slots<V: MongoCarrier, C: ComplexComparison<Mongo>>(
has_element: Option<&V>,
any: Option<&C>,
count: Option<&MongoCountComparison<i64>>,
field: &str,
at: At<'_>,
builder: &mut MongoConjunction,
) -> Result<(), MongoLoweringError> {
if let Some(element) = has_element {
builder.merge(field, MongoOperator::Eq, element.to_bson());
}
if let Some(any) = any {
builder.merge(field, MongoOperator::ElemMatch, element_scope(any, at)?);
}
if let Some(count) = count {
push_count_slots(count, field, builder);
}
Ok(())
}
impl<V: MongoCarrier, C: ComplexComparison<Mongo>> ComplexComparison<Mongo>
for MongoListComparison<V, C>
{
#[inline]
fn conjuncts(&self) -> usize {
Self::conjuncts(self)
}
fn apply<'q>(
&'q self,
at: At<'_>,
mut builder: <Mongo as Backend>::Builder<'q>,
) -> Result<<Mongo as Backend>::Builder<'q>, <Mongo as Backend>::Error> {
let field = field_path(at);
for (slot, op) in [
(&self.eq, MongoOperator::Eq),
(&self.ne, MongoOperator::Ne),
(&self.gt, MongoOperator::Gt),
(&self.gte, MongoOperator::Gte),
(&self.lt, MongoOperator::Lt),
(&self.lte, MongoOperator::Lte),
] {
if let Some(elements) = slot {
builder.merge(&field, op, membership(elements));
}
}
push_shared_slots(
self.has_element.as_ref(),
self.any.as_ref(),
self.count.as_ref(),
&field,
at,
&mut builder,
)?;
Ok(builder)
}
}
impl<V: MongoCarrier, C: ComplexComparison<Mongo>> ComplexComparison<Mongo>
for MongoSetComparison<V, C>
{
#[inline]
fn conjuncts(&self) -> usize {
Self::conjuncts(self)
}
fn apply<'q>(
&'q self,
at: At<'_>,
mut builder: <Mongo as Backend>::Builder<'q>,
) -> Result<<Mongo as Backend>::Builder<'q>, <Mongo as Backend>::Error> {
let field = field_path(at);
if let Some(elements) = &self.eq {
set_equality(elements, |op, value| builder.merge(&field, op, value));
}
if let Some(elements) = &self.ne {
let mut operators = Document::new();
set_equality(elements, |op, value| {
operators.insert(op.as_str(), value);
});
let mut equal = Document::new();
equal.insert(&field, Bson::Document(operators));
let mut negation = Document::new();
negation.insert(NOR, Bson::Array(vec![Bson::Document(equal)]));
builder.and(negation);
}
if let Some(elements) = &self.encloses {
if elements.is_empty() {
builder.merge(
&field,
MongoOperator::Type,
Bson::String(ARRAY_TYPE.to_owned()),
);
} else {
builder.merge(&field, MongoOperator::All, membership(elements));
}
}
if let Some(elements) = &self.enclosed_by {
builder.merge(
&field,
MongoOperator::Type,
Bson::String(ARRAY_TYPE.to_owned()),
);
builder.merge(&field, MongoOperator::Not, outside(elements));
}
if let Some(elements) = &self.overlaps {
builder.merge(&field, MongoOperator::In, membership(elements));
}
push_shared_slots(
self.has_element.as_ref(),
self.any.as_ref(),
self.count.as_ref(),
&field,
at,
&mut builder,
)?;
Ok(builder)
}
}
#[cfg(test)]
mod tests;