use super::{Mongo, MongoCarrier, MongoOperator, field_path, membership};
use crate::{
ScalarFilter, TryMapFilter,
comparison::{At, Backend, ComplexComparison, ToDatabaseComparison, TryFromFilter},
};
mongo_comparison_kind! {
MongoScalarComparison {
one { eq, ne, gt, gte, lt, lte }
many { in_, not_in }
}
}
impl<V> MongoScalarComparison<V> {
pub fn try_from_filter_with<D, I, E, F, X>(filter: X, f: F) -> Result<Self, E>
where
X: TryMapFilter<D, V, Mapped = ScalarFilter<V, I>>,
F: FnMut(D) -> Result<V, E>,
{
let stored = filter.try_map_filter(f)?;
Ok(Self {
eq: stored.eq,
ne: stored.ne,
gt: stored.gt,
gte: stored.gte,
lt: stored.lt,
lte: stored.lte,
in_: stored.in_,
not_in: stored.not_in,
})
}
}
impl<D, I, V: MongoCarrier> ToDatabaseComparison<V, Mongo> for ScalarFilter<D, I> {
type Comparison = MongoScalarComparison<V>;
}
impl<D, I, V: TryFrom<D>> TryFromFilter<ScalarFilter<D, I>> for MongoScalarComparison<V> {
type Error = V::Error;
fn try_from_filter(filter: ScalarFilter<D, I>) -> Result<Self, Self::Error> {
Self::try_from_filter_with(filter, V::try_from)
}
}
impl<V: MongoCarrier> ToDatabaseComparison<V, Mongo> for crate::ConfidenceFilter {
type Comparison = MongoScalarComparison<V>;
}
impl<V: crate::ScoreKind> TryFromFilter<crate::ConfidenceFilter> for MongoScalarComparison<V> {
type Error = V::Error;
fn try_from_filter(filter: crate::ConfidenceFilter) -> Result<Self, Self::Error> {
Self::try_from_filter_with(filter, |operand| V::from_operand(&operand))
}
}
impl<V> crate::comparison::ReferentialComparison<Mongo> for MongoScalarComparison<V> {
#[inline]
fn is_referential(&self) -> bool {
Self::conjuncts(self) == 1 && (self.eq.is_some() || self.in_.is_some())
}
}
impl<V: MongoCarrier> ComplexComparison<Mongo> for MongoScalarComparison<V> {
#[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(value) = slot {
builder.merge(&field, op, value.to_bson());
}
}
for (slot, op) in [
(&self.in_, MongoOperator::In),
(&self.not_in, MongoOperator::Nin),
] {
if let Some(values) = slot {
builder.merge(&field, op, membership(values));
}
}
Ok(builder)
}
}
#[cfg(test)]
mod tests;