use core::fmt::{self, Display};
use crate::{
At, Backend, BindCeiling, Carrier, ComplexComparison, CompositeComparison, ToDatabaseComparison,
TryFromFilter,
comparison::sql::{
SqlConjunction, SqlKeyIn, SqlLoweringError, SqlScalarComparison, render_column,
},
};
use smol_bytes::Utf8Bytes;
use super::{
super::rational::Affix,
Rate, RateFilter,
storage::{DEN, NUM, SEGMENTS},
};
#[cfg(all(test, feature = "postgres"))]
mod tests;
const PARTS: [&str; 2] = [NUM.as_str(), DEN.as_str()];
pub struct SqlRateComparison<Db> {
numerator: SqlScalarComparison<i32, Db>,
denominator: SqlScalarComparison<i32, Db>,
members: Option<SqlKeyIn<i32, Db, 2>>,
excluded: Option<SqlKeyIn<i32, Db, 2>>,
starts_with: Option<Utf8Bytes>,
ends_with: Option<Utf8Bytes>,
contains: Option<Utf8Bytes>,
}
impl<Db> SqlRateComparison<Db> {
#[inline]
pub const fn new() -> Self {
Self {
numerator: SqlScalarComparison::new(),
denominator: SqlScalarComparison::new(),
members: None,
excluded: None,
starts_with: None,
ends_with: None,
contains: None,
}
}
#[inline]
pub const fn numerator(&self) -> &SqlScalarComparison<i32, Db> {
&self.numerator
}
#[inline]
pub const fn denominator(&self) -> &SqlScalarComparison<i32, Db> {
&self.denominator
}
#[inline]
pub const fn members(&self) -> Option<&SqlKeyIn<i32, Db, 2>> {
self.members.as_ref()
}
#[inline]
pub const fn excluded(&self) -> Option<&SqlKeyIn<i32, Db, 2>> {
self.excluded.as_ref()
}
#[inline]
pub const fn starts_with(&self) -> Option<&Utf8Bytes> {
self.starts_with.as_ref()
}
#[inline]
pub const fn ends_with(&self) -> Option<&Utf8Bytes> {
self.ends_with.as_ref()
}
#[inline]
pub const fn contains(&self) -> Option<&Utf8Bytes> {
self.contains.as_ref()
}
#[inline]
pub const fn is_empty(&self) -> bool {
self.numerator.is_empty()
&& self.denominator.is_empty()
&& self.members.is_none()
&& self.excluded.is_none()
&& self.starts_with.is_none()
&& self.ends_with.is_none()
&& self.contains.is_none()
}
#[inline]
pub const fn conjuncts(&self) -> usize {
self.numerator.conjuncts()
+ self.denominator.conjuncts()
+ self.members.is_some() as usize
+ self.excluded.is_some() as usize
+ self.starts_with.is_some() as usize
+ self.ends_with.is_some() as usize
+ self.contains.is_some() as usize
}
}
impl<Db> ComplexComparison<Db> for SqlRateComparison<Db>
where
Db: sqlx::Database
+ BindCeiling
+ for<'q> Backend<Builder<'q> = SqlConjunction<'q, Db>, Error = SqlLoweringError, Buffer: Display>,
i32: Carrier<Db>,
for<'a> &'a str: sqlx::Encode<'a, Db> + sqlx::Type<Db>,
{
#[inline]
fn conjuncts(&self) -> usize {
Self::conjuncts(self)
}
fn apply<'q>(
&'q self,
at: At<'_>,
builder: Db::Builder<'q>,
) -> Result<Db::Builder<'q>, Db::Error> {
let num = at.frame(NUM);
let builder = self.numerator.apply(num.at(), builder)?;
let den = at.frame(DEN);
let builder = self.denominator.apply(den.at(), builder)?;
let mut builder = match &self.members {
Some(members) => members.apply(at, builder)?,
None => builder,
};
if let Some(excluded) = &self.excluded {
builder = negated(excluded, at, builder)?;
}
if self.starts_with.is_some() || self.ends_with.is_some() || self.contains.is_some() {
let num = render_column::<Db>(at.frame(NUM).at());
let den = render_column::<Db>(at.frame(DEN).at());
for pattern in [&self.starts_with, &self.ends_with, &self.contains]
.into_iter()
.flatten()
{
let qb = builder.open();
qb.push("CONCAT(");
qb.push(&num);
qb.push(", '/', ");
qb.push(&den);
qb.push(") LIKE ");
qb.push_bind(pattern.as_str());
}
}
Ok(builder)
}
}
fn negated<'q, Db>(
keys: &'q SqlKeyIn<i32, Db, 2>,
at: At<'_>,
mut builder: SqlConjunction<'q, Db>,
) -> Result<SqlConjunction<'q, Db>, SqlLoweringError>
where
Db: sqlx::Database
+ BindCeiling
+ for<'a> Backend<Builder<'a> = SqlConjunction<'a, Db>, Error = SqlLoweringError, Buffer: Display>,
i32: Carrier<Db>,
{
let qb = builder.open();
qb.push("NOT (");
let _ = keys.apply(at, SqlConjunction::with_lead(&mut *qb, ""))?;
qb.push(")");
Ok(builder)
}
impl<Db> CompositeComparison<Db> for SqlRateComparison<Db>
where
Db: sqlx::Database
+ BindCeiling
+ for<'q> Backend<Builder<'q> = SqlConjunction<'q, Db>, Error = SqlLoweringError, Buffer: Display>,
i32: Carrier<Db>,
for<'a> &'a str: sqlx::Encode<'a, Db> + sqlx::Type<Db>,
{
const SEGMENTS: &'static [crate::ColumnShape] = SEGMENTS;
}
impl<Db> Default for SqlRateComparison<Db> {
#[inline]
fn default() -> Self {
Self::new()
}
}
impl<Db> fmt::Debug for SqlRateComparison<Db> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("SqlRateComparison")
.field("numerator", &self.numerator)
.field("denominator", &self.denominator)
.field("members", &self.members)
.field("excluded", &self.excluded)
.field("starts_with", &self.starts_with)
.field("ends_with", &self.ends_with)
.field("contains", &self.contains)
.finish()
}
}
impl<Db> Clone for SqlRateComparison<Db> {
fn clone(&self) -> Self {
Self {
numerator: self.numerator.clone(),
denominator: self.denominator.clone(),
members: self.members.clone(),
excluded: self.excluded.clone(),
starts_with: self.starts_with.clone(),
ends_with: self.ends_with.clone(),
contains: self.contains.clone(),
}
}
}
impl<Db> PartialEq for SqlRateComparison<Db> {
fn eq(&self, other: &Self) -> bool {
self.numerator == other.numerator
&& self.denominator == other.denominator
&& self.members == other.members
&& self.excluded == other.excluded
&& self.starts_with == other.starts_with
&& self.ends_with == other.ends_with
&& self.contains == other.contains
}
}
impl<Db> ToDatabaseComparison<i32, Db> for RateFilter
where
Db: sqlx::Database
+ BindCeiling
+ for<'q> Backend<Builder<'q> = SqlConjunction<'q, Db>, Error = SqlLoweringError, Buffer: Display>,
i32: Carrier<Db>,
for<'a> &'a str: sqlx::Encode<'a, Db> + sqlx::Type<Db>,
{
type Comparison = SqlRateComparison<Db>;
}
impl<Db> ToDatabaseComparison<Rate, Db> for RateFilter
where
Db: sqlx::Database
+ BindCeiling
+ for<'q> Backend<Builder<'q> = SqlConjunction<'q, Db>, Error = SqlLoweringError, Buffer: Display>,
i32: Carrier<Db>,
for<'a> &'a str: sqlx::Encode<'a, Db> + sqlx::Type<Db>,
{
type Comparison = SqlRateComparison<Db>;
}
impl<Db> TryFromFilter<RateFilter> for SqlRateComparison<Db> {
type Error = RateCrossingError;
fn try_from_filter(filter: RateFilter) -> Result<Self, Self::Error> {
let RateFilter {
eq,
ne,
in_,
not_in,
starts_with,
ends_with,
contains,
numerator,
denominator,
} = filter;
let mut numerator = numerator.unwrap_or_default();
let mut denominator = denominator.unwrap_or_default();
if let Some(whole) = eq {
if numerator.eq().is_some() {
return Err(RateCrossingError::NumeratorConflict);
}
if denominator.eq().is_some() {
return Err(RateCrossingError::DenominatorConflict);
}
let (num, den) = whole.reduced();
numerator = numerator.with_eq(num);
denominator = denominator.with_eq(den);
}
let members = in_.map(|list| SqlKeyIn::new(PARTS, keys(&list)));
let excluded = match (ne, not_in) {
(None, None) => None,
(single, list) => {
let mut keys = keys(list.as_deref().unwrap_or_default());
if let Some(single) = single {
let (num, den) = single.reduced();
keys.push([num, den.get()]);
}
Some(SqlKeyIn::new(PARTS, keys))
}
};
Ok(Self {
numerator: infallible(SqlScalarComparison::try_from_filter(numerator)),
denominator: infallible(SqlScalarComparison::try_from_filter(denominator)),
members,
excluded,
starts_with: affix(starts_with.as_deref(), Affix::Prefix)?,
ends_with: affix(ends_with.as_deref(), Affix::Suffix)?,
contains: affix(contains.as_deref(), Affix::Contains)?,
})
}
}
fn keys(operands: &[Rate]) -> Vec<[i32; 2]> {
operands
.iter()
.map(|operand| {
let (num, den) = operand.reduced();
[num, den.get()]
})
.collect()
}
fn affix(operand: Option<&str>, affix: Affix) -> Result<Option<Utf8Bytes>, RateCrossingError> {
super::super::rational::pattern(operand, affix).map_err(RateCrossingError::RenderAlphabet)
}
fn infallible<T>(crossed: Result<T, core::convert::Infallible>) -> T {
match crossed {
Ok(crossed) => crossed,
Err(never) => match never {},
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum RateCrossingError {
NumeratorConflict,
DenominatorConflict,
RenderAlphabet(char),
}
impl fmt::Display for RateCrossingError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::NumeratorConflict => f.write_str("the rate's numerator equality is named twice"),
Self::DenominatorConflict => f.write_str("the rate's denominator equality is named twice"),
Self::RenderAlphabet(outside) => write!(
f,
"a rate renders as digits and a slash, so `{outside}` matches no stored value"
),
}
}
}
impl core::error::Error for RateCrossingError {}