use core::fmt::{self, Display};
use crate::{
At, Backend, Carrier, ComplexComparison, CompositeComparison, Nullable, ScalarFilter,
ToDatabaseComparison, TryFromFilter,
comparison::sql::{SqlConjunction, SqlNullable, SqlScalarComparison, render_column},
};
use super::{
LanguageId, LanguageIdFilter,
storage::{LANGUAGE, REGION, REST, SCRIPT, SEGMENTS},
};
#[cfg(all(test, feature = "sqlite"))]
mod tests;
type Column<Db> = SqlNullable<SqlScalarComparison<String, Db>, String>;
pub struct SqlLanguageIdComparison<Db> {
language: SqlScalarComparison<String, Db>,
script: Column<Db>,
region: Column<Db>,
rest: Column<Db>,
members: Option<Box<[Stored]>>,
excluded: Option<Box<[Stored]>>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
struct Stored {
language: String,
script: Option<String>,
region: Option<String>,
rest: Option<String>,
}
impl Stored {
fn of(id: &LanguageId) -> Self {
Self {
language: String::from(id.language().as_str()),
script: id.script().map(|script| String::from(script.as_str())),
region: id.region().map(|region| String::from(region.as_str())),
rest: id.rest().map(|rest| String::from(rest.as_str())),
}
}
}
impl<Db> SqlLanguageIdComparison<Db> {
#[inline]
pub const fn new() -> Self {
Self {
language: SqlScalarComparison::new(),
script: SqlNullable::new(SqlScalarComparison::new()),
region: SqlNullable::new(SqlScalarComparison::new()),
rest: SqlNullable::new(SqlScalarComparison::new()),
members: None,
excluded: None,
}
}
#[inline]
pub const fn language(&self) -> &SqlScalarComparison<String, Db> {
&self.language
}
#[inline]
pub const fn script(&self) -> &Column<Db> {
&self.script
}
#[inline]
pub const fn region(&self) -> &Column<Db> {
&self.region
}
#[inline]
pub const fn rest(&self) -> &Column<Db> {
&self.rest
}
#[inline]
pub fn members(&self) -> Option<usize> {
self.members.as_ref().map(|members| members.len())
}
#[inline]
pub fn excluded(&self) -> Option<usize> {
self.excluded.as_ref().map(|excluded| excluded.len())
}
}
impl<Db> ComplexComparison<Db> for SqlLanguageIdComparison<Db>
where
Db: sqlx::Database + for<'q> Backend<Builder<'q> = SqlConjunction<'q, Db>, Buffer: Display>,
String: Carrier<Db>,
for<'a> &'a str: sqlx::Encode<'a, Db> + sqlx::Type<Db>,
{
fn conjuncts(&self) -> usize {
ComplexComparison::<Db>::conjuncts(&self.language)
+ ComplexComparison::<Db>::conjuncts(&self.script)
+ ComplexComparison::<Db>::conjuncts(&self.region)
+ ComplexComparison::<Db>::conjuncts(&self.rest)
+ usize::from(self.members.is_some())
+ usize::from(self.excluded.is_some())
}
fn apply<'q>(
&'q self,
at: At<'_>,
builder: Db::Builder<'q>,
) -> Result<Db::Builder<'q>, Db::Error> {
let language = at.frame(LANGUAGE);
let builder = self.language.apply(language.at(), builder)?;
let script = at.frame(SCRIPT);
let builder = self.script.apply(script.at(), builder)?;
let region = at.frame(REGION);
let builder = self.region.apply(region.at(), builder)?;
let rest = at.frame(REST);
let mut builder = self.rest.apply(rest.at(), builder)?;
if let Some(members) = &self.members {
set::<Db>(members, at, &mut builder, false);
}
if let Some(excluded) = &self.excluded {
set::<Db>(excluded, at, &mut builder, true);
}
Ok(builder)
}
}
fn set<'q, Db>(
identities: &'q [Stored],
at: At<'_>,
builder: &mut SqlConjunction<'q, Db>,
negated: bool,
) where
Db: sqlx::Database + Backend<Buffer: Display>,
for<'a> &'a str: sqlx::Encode<'a, Db> + sqlx::Type<Db>,
{
let language = at.frame(LANGUAGE);
let language = render_column::<Db>(language.at());
let script = at.frame(SCRIPT);
let script = render_column::<Db>(script.at());
let region = at.frame(REGION);
let region = render_column::<Db>(region.at());
let rest = at.frame(REST);
let rest = render_column::<Db>(rest.at());
let qb = builder.open();
if negated {
qb.push("NOT ");
}
qb.push("(");
if identities.is_empty() {
qb.push("1 = 0");
}
for (nth, identity) in identities.iter().enumerate() {
if nth > 0 {
qb.push(" OR ");
}
qb.push("(");
qb.push(&language);
qb.push(" = ");
qb.push_bind(identity.language.as_str());
for (column, held) in [
(&script, &identity.script),
(®ion, &identity.region),
(&rest, &identity.rest),
] {
qb.push(" AND ");
match held {
Some(held) => {
qb.push("(");
qb.push(column);
qb.push(" IS NOT NULL AND ");
qb.push(column);
qb.push(" = ");
qb.push_bind(held.as_str());
qb.push(")");
}
None => {
qb.push(column);
qb.push(" IS NULL");
}
}
}
qb.push(")");
}
qb.push(")");
}
impl<Db> CompositeComparison<Db> for SqlLanguageIdComparison<Db>
where
Db: sqlx::Database + for<'q> Backend<Builder<'q> = SqlConjunction<'q, Db>, Buffer: Display>,
String: Carrier<Db>,
for<'a> &'a str: sqlx::Encode<'a, Db> + sqlx::Type<Db>,
{
const SEGMENTS: &'static [crate::ColumnShape] = SEGMENTS;
}
impl<Db> Default for SqlLanguageIdComparison<Db> {
#[inline]
fn default() -> Self {
Self::new()
}
}
impl<Db> fmt::Debug for SqlLanguageIdComparison<Db> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("SqlLanguageIdComparison")
.field("language", &self.language)
.field("script", &self.script)
.field("region", &self.region)
.field("rest", &self.rest)
.field("members", &self.members)
.field("excluded", &self.excluded)
.finish()
}
}
impl<Db> Clone for SqlLanguageIdComparison<Db> {
fn clone(&self) -> Self {
Self {
language: self.language.clone(),
script: self.script.clone(),
region: self.region.clone(),
rest: self.rest.clone(),
members: self.members.clone(),
excluded: self.excluded.clone(),
}
}
}
impl<Db> PartialEq for SqlLanguageIdComparison<Db> {
fn eq(&self, other: &Self) -> bool {
self.language == other.language
&& self.script == other.script
&& self.region == other.region
&& self.rest == other.rest
&& self.members == other.members
&& self.excluded == other.excluded
}
}
impl<Db> ToDatabaseComparison<String, Db> for LanguageIdFilter
where
Db: sqlx::Database + for<'q> Backend<Builder<'q> = SqlConjunction<'q, Db>, Buffer: Display>,
String: Carrier<Db>,
for<'a> &'a str: sqlx::Encode<'a, Db> + sqlx::Type<Db>,
{
type Comparison = SqlLanguageIdComparison<Db>;
}
impl<Db> TryFromFilter<LanguageIdFilter> for SqlLanguageIdComparison<Db> {
type Error = LanguageIdCrossingError;
fn try_from_filter(filter: LanguageIdFilter) -> Result<Self, Self::Error> {
let LanguageIdFilter {
eq,
ne,
in_,
not_in,
language,
script,
region,
} = filter;
let mut language = language.unwrap_or_default();
let mut script = script.unwrap_or_default();
let mut region = region.unwrap_or_default();
let mut rest = Nullable::<ScalarFilter<String>>::default();
if let Some(whole) = eq {
if language.eq().is_some() {
return Err(LanguageIdCrossingError::LanguageConflict);
}
if script.inner().eq().is_some() || script.null().is_some() {
return Err(LanguageIdCrossingError::ScriptConflict);
}
if region.inner().eq().is_some() || region.null().is_some() {
return Err(LanguageIdCrossingError::RegionConflict);
}
language = language.with_eq(whole.language().clone());
script = seat(script, whole.script().cloned());
region = seat(region, whole.region().cloned());
rest = seat(rest, whole.rest().map(|rest| String::from(rest.as_str())));
}
let members = in_.map(|list| stored(&list));
let excluded = match (ne, not_in) {
(None, None) => None,
(single, list) => {
let mut identities = stored(list.as_deref().unwrap_or_default()).into_vec();
if let Some(single) = single {
identities.push(Stored::of(&single));
}
Some(identities.into_boxed_slice())
}
};
Ok(Self {
language: infallible(SqlScalarComparison::try_from_filter(language)),
script: infallible(SqlNullable::try_from_filter(script)),
region: infallible(SqlNullable::try_from_filter(region)),
rest: infallible(SqlNullable::try_from_filter(rest)),
members,
excluded,
})
}
}
fn seat<T, I>(
filter: Nullable<ScalarFilter<T, I>>,
value: Option<T>,
) -> Nullable<ScalarFilter<T, I>> {
match value {
Some(value) => {
match filter.try_map(|inner| Ok::<_, core::convert::Infallible>(inner.with_eq(value))) {
Ok(filter) => filter,
Err(never) => match never {},
}
}
None => filter.with_null(true),
}
}
fn stored(identities: &[LanguageId]) -> Box<[Stored]> {
identities.iter().map(Stored::of).collect()
}
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 LanguageIdCrossingError {
LanguageConflict,
ScriptConflict,
RegionConflict,
}
impl fmt::Display for LanguageIdCrossingError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let doubled = match self {
Self::LanguageConflict => "language",
Self::ScriptConflict => "script",
Self::RegionConflict => "region",
};
write!(f, "the {doubled} column's value is named twice")
}
}
impl core::error::Error for LanguageIdCrossingError {}