use bson::{Bson, Document};
use super::{EXPR, MongoCarrier, MongoConjunction, membership};
use crate::{ScalarFilter, comparison::TryFromFilter};
mongo_comparison_kind! {
MongoCountComparison {
one { eq, ne, gt, gte, lt, lte }
many { in_, not_in }
}
}
impl<V> MongoCountComparison<V> {
pub fn try_from_filter_with<D, I, E, F>(filter: ScalarFilter<D, I>, f: F) -> Result<Self, E>
where
F: FnMut(D) -> Result<V, E>,
{
let stored = filter.try_map(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: TryFrom<D>> TryFromFilter<ScalarFilter<D, I>> for MongoCountComparison<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)
}
}
const IS_ARRAY: &str = "$isArray";
const SIZE: &str = "$size";
const AGGREGATE_AND: &str = "$and";
const AGGREGATE_NOT: &str = "$not";
const AGGREGATE_IN: &str = "$in";
pub(super) fn push_count_slots<V: MongoCarrier>(
comparison: &MongoCountComparison<V>,
field: &str,
out: &mut MongoConjunction,
) {
let path = Bson::String(format!("${field}"));
let size = || {
let mut expression = Document::new();
expression.insert(SIZE, path.clone());
Bson::Document(expression)
};
for (slot, name) in [
(&comparison.eq, "$eq"),
(&comparison.ne, "$ne"),
(&comparison.gt, "$gt"),
(&comparison.gte, "$gte"),
(&comparison.lt, "$lt"),
(&comparison.lte, "$lte"),
] {
if let Some(value) = slot {
out.and(guarded(&path, compare(name, size(), value.to_bson())));
}
}
if let Some(values) = &comparison.in_ {
out.and(guarded(
&path,
compare(AGGREGATE_IN, size(), membership(values)),
));
}
if let Some(values) = &comparison.not_in {
let mut negated = Document::new();
negated.insert(
AGGREGATE_NOT,
Bson::Document(compare(AGGREGATE_IN, size(), membership(values))),
);
out.and(guarded(&path, negated));
}
}
fn compare(name: &str, subject: Bson, operand: Bson) -> Document {
let mut comparison = Document::new();
comparison.insert(name, Bson::Array(vec![subject, operand]));
comparison
}
fn guarded(path: &Bson, comparison: Document) -> Document {
let mut guard = Document::new();
guard.insert(IS_ARRAY, path.clone());
let mut conjunction = Document::new();
conjunction.insert(
AGGREGATE_AND,
Bson::Array(vec![Bson::Document(guard), Bson::Document(comparison)]),
);
let mut expression = Document::new();
expression.insert(EXPR, Bson::Document(conjunction));
expression
}
#[cfg(test)]
mod tests;