use core::{fmt::Display, marker::PhantomData};
use super::{
At, Carrier, SqlConjunction, not_wrapped, push_cmp, push_column, push_in, push_subject_cmp,
};
use crate::{
FlagsFilter, TryMapFilter,
comparison::{Backend, ComplexComparison, ToDatabaseComparison, TryFromFilter},
};
comparison_kind! {
SqlFlagsComparison {
one { eq, ne, has_all, has_any, has_none }
many { in_, not_in }
}
}
impl<V, Db> SqlFlagsComparison<V, Db> {
pub fn try_from_filter_with<D, E, F, X>(filter: X, f: F) -> Result<Self, E>
where
X: TryMapFilter<D, V, Mapped = FlagsFilter<V>>,
F: FnMut(D) -> Result<V, E>,
{
let stored = filter.try_map_filter(f)?;
Ok(Self {
eq: stored.eq,
ne: stored.ne,
in_: stored.in_,
not_in: stored.not_in,
has_all: stored.has_all,
has_any: stored.has_any,
has_none: stored.has_none,
db: PhantomData,
})
}
}
impl<D, V, Db> ToDatabaseComparison<V, Db> for FlagsFilter<D>
where
Db: sqlx::Database + for<'q> Backend<Builder<'q> = SqlConjunction<'q, Db>, Buffer: Display>,
V: Carrier<Db>,
{
type Comparison = SqlFlagsComparison<V, Db>;
}
impl<D, V, Db> TryFromFilter<FlagsFilter<D>> for SqlFlagsComparison<V, Db>
where
V: TryFrom<D>,
{
type Error = V::Error;
fn try_from_filter(filter: FlagsFilter<D>) -> Result<Self, Self::Error> {
Self::try_from_filter_with(filter, V::try_from)
}
}
impl<V, Db: crate::comparison::Backend> crate::comparison::ReferentialComparison<Db>
for SqlFlagsComparison<V, Db>
{
#[inline]
fn is_referential(&self) -> bool {
Self::conjuncts(self) == 1 && (self.eq.is_some() || self.in_.is_some())
}
}
fn push_masked<Db, V>(qb: &mut sqlx::QueryBuilder<Db>, at: At<'_>, mask: &V)
where
Db: sqlx::Database + Backend<Buffer: Display>,
V: Carrier<Db>,
{
qb.push("(");
push_column(qb, at);
qb.push(" & ");
mask.push_bind(qb);
qb.push(")");
}
fn push_clear<Db, V>(qb: &mut sqlx::QueryBuilder<Db>, at: At<'_>, mask: &V, negated: bool)
where
Db: sqlx::Database + Backend<Buffer: Display>,
V: Carrier<Db>,
{
not_wrapped(qb, negated, |qb| {
push_masked(qb, at, mask);
qb.push(" = 0");
});
}
impl<V, Db> ComplexComparison<Db> for SqlFlagsComparison<V, Db>
where
Db: sqlx::Database + for<'q> Backend<Builder<'q> = SqlConjunction<'q, Db>, Buffer: Display>,
V: Carrier<Db>,
{
#[inline]
fn conjuncts(&self) -> usize {
Self::conjuncts(self)
}
fn apply<'q>(
&'q self,
at: At<'_>,
mut builder: Db::Builder<'q>,
) -> Result<Db::Builder<'q>, Db::Error> {
if let Some(value) = &self.eq {
push_cmp(builder.open(), at, " = ", value, false);
}
if let Some(value) = &self.ne {
push_cmp(builder.open(), at, " = ", value, true);
}
if let Some(values) = &self.in_ {
push_in(builder.open(), at, values, false);
}
if let Some(values) = &self.not_in {
push_in(builder.open(), at, values, true);
}
if let Some(mask) = &self.has_all {
push_subject_cmp(
builder.open(),
|qb| push_masked(qb, at, mask),
" = ",
mask,
false,
);
}
if let Some(mask) = &self.has_any {
push_clear(builder.open(), at, mask, true);
}
if let Some(mask) = &self.has_none {
push_clear(builder.open(), at, mask, false);
}
Ok(builder)
}
}
#[cfg(test)]
mod tests;