use core::marker::PhantomData;
use super::{Carrier, SqlConjunction, push_subject_cmp, push_subject_in};
use crate::{ScalarFilter, comparison::TryFromFilter};
comparison_kind! {
SqlCountComparison {
one { eq, ne, gt, gte, lt, lte }
many { in_, not_in }
}
}
impl<V, Db> SqlCountComparison<V, Db> {
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,
db: PhantomData,
})
}
}
impl<D, I, V, Db> TryFromFilter<ScalarFilter<D, I>> for SqlCountComparison<V, Db>
where
V: TryFrom<D>,
{
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)
}
}
pub(super) fn push_count_slots<V, Db>(
comparison: &SqlCountComparison<V, Db>,
out: &mut SqlConjunction<'_, Db>,
cardinality: impl Fn(&mut sqlx::QueryBuilder<Db>),
) where
Db: sqlx::Database,
V: Carrier<Db>,
{
for (value, op, negated) in [
(&comparison.eq, " = ", false),
(&comparison.ne, " = ", true),
(&comparison.gt, " > ", false),
(&comparison.gte, " >= ", false),
(&comparison.lt, " < ", false),
(&comparison.lte, " <= ", false),
] {
if let Some(value) = value {
push_subject_cmp(out.open(), &cardinality, op, value, negated);
}
}
for (values, negated) in [(&comparison.in_, false), (&comparison.not_in, true)] {
if let Some(values) = values {
push_subject_in(out.open(), &cardinality, values, negated);
}
}
}
#[cfg(test)]
mod tests;