use core::marker::PhantomData;
#[cfg(any(feature = "sqlite", feature = "postgres", feature = "mysql"))]
use core::fmt::Display;
#[cfg(any(feature = "sqlite", feature = "postgres", feature = "mysql"))]
use super::{Carrier, SqlConjunction, push_cmp, push_in};
#[cfg(any(feature = "sqlite", feature = "postgres", feature = "mysql"))]
use crate::comparison::At;
use crate::{
BytesFilter, FixedBytesFilter, TryMapFilter,
comparison::{Backend, ComplexComparison, ToDatabaseComparison, TryFromFilter},
graphql::filter::ByteSlots,
};
comparison_kind! {
SqlBytesComparison {
one { eq, ne, gt, gte, lt, lte, contains, not_contains }
many { in_, not_in }
}
}
impl<V, Db> SqlBytesComparison<V, Db> {
#[allow(private_bounds)]
pub fn try_from_filter_with<D, E, F, X>(filter: X, f: F) -> Result<Self, E>
where
X: TryMapFilter<D, V, Mapped: ByteSlots<V>>,
F: FnMut(D) -> Result<V, E>,
{
let stored = filter.try_map_filter(f)?.byte_operands();
Ok(Self {
eq: stored.eq,
ne: stored.ne,
gt: stored.gt,
gte: stored.gte,
lt: stored.lt,
lte: stored.lte,
contains: stored.contains,
not_contains: stored.not_contains,
in_: stored.in_,
not_in: stored.not_in,
db: PhantomData,
})
}
}
impl<D, V, I, Db> ToDatabaseComparison<V, Db> for BytesFilter<D, I>
where
Db: sqlx::Database + Backend,
SqlBytesComparison<V, Db>: ComplexComparison<Db>,
{
type Comparison = SqlBytesComparison<V, Db>;
}
impl<D, V, const N: usize, I, Db> ToDatabaseComparison<V, Db> for FixedBytesFilter<D, N, I>
where
Db: sqlx::Database + Backend,
SqlBytesComparison<V, Db>: ComplexComparison<Db>,
{
type Comparison = SqlBytesComparison<V, Db>;
}
impl<D, V, I, Db> TryFromFilter<BytesFilter<D, I>> for SqlBytesComparison<V, Db>
where
V: TryFrom<D>,
{
type Error = V::Error;
fn try_from_filter(filter: BytesFilter<D, I>) -> Result<Self, Self::Error> {
Self::try_from_filter_with(filter, V::try_from)
}
}
impl<D, V, const N: usize, I, Db> TryFromFilter<FixedBytesFilter<D, N, I>>
for SqlBytesComparison<V, Db>
where
V: TryFrom<D>,
{
type Error = V::Error;
fn try_from_filter(filter: FixedBytesFilter<D, N, I>) -> Result<Self, Self::Error> {
Self::try_from_filter_with(filter, V::try_from)
}
}
impl<V, Db: crate::comparison::Backend> crate::comparison::ReferentialComparison<Db>
for SqlBytesComparison<V, Db>
{
#[inline]
fn is_referential(&self) -> bool {
Self::conjuncts(self) == 1 && (self.eq.is_some() || self.in_.is_some())
}
}
#[cfg(any(feature = "sqlite", feature = "postgres", feature = "mysql"))]
fn push_slots<V, Db, L>(
comparison: &SqlBytesComparison<V, Db>,
at: At<'_>,
out: &mut SqlConjunction<'_, Db>,
leaf: L,
) where
Db: sqlx::Database + Backend<Buffer: Display>,
V: Carrier<Db>,
L: Fn(&mut sqlx::QueryBuilder<Db>, At<'_>, &V, bool),
{
if let Some(value) = &comparison.eq {
push_cmp(out.open(), at, " = ", value, false);
}
if let Some(value) = &comparison.ne {
push_cmp(out.open(), at, " = ", value, true);
}
if let Some(value) = &comparison.gt {
push_cmp(out.open(), at, " > ", value, false);
}
if let Some(value) = &comparison.gte {
push_cmp(out.open(), at, " >= ", value, false);
}
if let Some(value) = &comparison.lt {
push_cmp(out.open(), at, " < ", value, false);
}
if let Some(value) = &comparison.lte {
push_cmp(out.open(), at, " <= ", value, false);
}
if let Some(value) = &comparison.contains {
leaf(out.open(), at, value, false);
}
if let Some(value) = &comparison.not_contains {
leaf(out.open(), at, value, true);
}
if let Some(values) = &comparison.in_ {
push_in(out.open(), at, values, false);
}
if let Some(values) = &comparison.not_in {
push_in(out.open(), at, values, true);
}
}
#[cfg(feature = "mysql")]
mod mysql;
#[cfg(feature = "postgres")]
mod postgres;
#[cfg(feature = "sqlite")]
mod sqlite;
#[cfg(test)]
mod tests;