use core::fmt::{self, Display};
use crate::{
At, Backend, Carrier, ComplexComparison, CompositeComparison, Score, ToDatabaseComparison,
TryFromFilter,
comparison::sql::{SqlConjunction, SqlScalarComparison},
};
use super::{
super::{LanguageIdCrossingError, SqlLanguageIdComparison},
DetectedLanguageFilter,
storage::{CONFIDENCE, SEGMENTS},
};
#[cfg(all(test, feature = "sqlite"))]
mod tests;
pub struct SqlDetectedLanguageComparison<Db> {
language: SqlLanguageIdComparison<Db>,
confidence: SqlScalarComparison<Score, Db>,
}
impl<Db> SqlDetectedLanguageComparison<Db> {
#[inline]
pub const fn new() -> Self {
Self {
language: SqlLanguageIdComparison::new(),
confidence: SqlScalarComparison::new(),
}
}
#[inline]
pub const fn language(&self) -> &SqlLanguageIdComparison<Db> {
&self.language
}
#[inline]
pub const fn confidence(&self) -> &SqlScalarComparison<Score, Db> {
&self.confidence
}
}
impl<Db> ComplexComparison<Db> for SqlDetectedLanguageComparison<Db>
where
Db: sqlx::Database + for<'q> Backend<Builder<'q> = SqlConjunction<'q, Db>, Buffer: Display>,
String: Carrier<Db>,
Score: Carrier<Db>,
for<'a> &'a str: sqlx::Encode<'a, Db> + sqlx::Type<Db>,
{
#[inline]
fn conjuncts(&self) -> usize {
ComplexComparison::<Db>::conjuncts(&self.language)
+ ComplexComparison::<Db>::conjuncts(&self.confidence)
}
fn apply<'q>(
&'q self,
at: At<'_>,
builder: Db::Builder<'q>,
) -> Result<Db::Builder<'q>, Db::Error> {
let builder = self.language.apply(at, builder)?;
let confidence = at.frame(CONFIDENCE);
self.confidence.apply(confidence.at(), builder)
}
}
impl<Db> CompositeComparison<Db> for SqlDetectedLanguageComparison<Db>
where
Db: sqlx::Database + for<'q> Backend<Builder<'q> = SqlConjunction<'q, Db>, Buffer: Display>,
String: Carrier<Db>,
Score: Carrier<Db>,
for<'a> &'a str: sqlx::Encode<'a, Db> + sqlx::Type<Db>,
{
const SEGMENTS: &'static [crate::ColumnShape] = SEGMENTS;
}
impl<Db> Default for SqlDetectedLanguageComparison<Db> {
#[inline]
fn default() -> Self {
Self::new()
}
}
impl<Db> fmt::Debug for SqlDetectedLanguageComparison<Db> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("SqlDetectedLanguageComparison")
.field("language", &self.language)
.field("confidence", &self.confidence)
.finish()
}
}
impl<Db> Clone for SqlDetectedLanguageComparison<Db> {
fn clone(&self) -> Self {
Self {
language: self.language.clone(),
confidence: self.confidence.clone(),
}
}
}
impl<Db> PartialEq for SqlDetectedLanguageComparison<Db> {
fn eq(&self, other: &Self) -> bool {
self.language == other.language && self.confidence == other.confidence
}
}
impl<Db> ToDatabaseComparison<(String, Score), Db> for DetectedLanguageFilter
where
Db: sqlx::Database + for<'q> Backend<Builder<'q> = SqlConjunction<'q, Db>, Buffer: Display>,
String: Carrier<Db>,
Score: Carrier<Db>,
for<'a> &'a str: sqlx::Encode<'a, Db> + sqlx::Type<Db>,
{
type Comparison = SqlDetectedLanguageComparison<Db>;
}
impl<Db> TryFromFilter<DetectedLanguageFilter> for SqlDetectedLanguageComparison<Db> {
type Error = LanguageIdCrossingError;
fn try_from_filter(filter: DetectedLanguageFilter) -> Result<Self, Self::Error> {
let DetectedLanguageFilter {
language,
confidence,
} = filter;
let confidence = confidence.unwrap_or_default();
Ok(Self {
language: SqlLanguageIdComparison::try_from_filter(language)?,
confidence: SqlScalarComparison::try_from_filter(confidence)
.expect("a binary width holds every confidence operand"),
})
}
}