use core::{convert::Infallible, fmt};
use smol_bytes::Utf8Bytes;
use crate::{
At, Backend, ColumnKind, ComplexComparison, CompositeComparison, Score, SqlBoundingBoxComparison,
ToDatabaseComparison, TryFromFilter,
comparison::sql::{SqlConjunction, SqlEnumComparison, SqlScalarComparison, SqlTextComparison},
};
use super::{
BarcodeDetection, BarcodeDetectionFilter, Detection, DetectionFilter, DocumentSegment,
DocumentSegmentFilter, Label, LocatedDetection, LocatedDetectionFilter, Symbology, TextDetection,
TextDetectionFilter,
barcode::{PAYLOAD, SYMBOLOGY},
detection::{CONFIDENCE, LABEL, SEGMENTS as DETECTION_SEGMENTS},
located::BBOX,
segment::QUAD,
text::TEXT,
};
pub struct SqlDetectionComparison<Db> {
label: SqlTextComparison<Label, Db>,
confidence: SqlScalarComparison<Score, Db>,
}
impl<Db> SqlDetectionComparison<Db> {
#[inline]
#[must_use]
pub const fn new() -> Self {
Self {
label: SqlTextComparison::new(),
confidence: SqlScalarComparison::new(),
}
}
#[inline]
pub const fn label(&self) -> &SqlTextComparison<Label, Db> {
&self.label
}
#[inline]
pub const fn confidence(&self) -> &SqlScalarComparison<Score, Db> {
&self.confidence
}
}
impl<Db> ComplexComparison<Db> for SqlDetectionComparison<Db>
where
Db: sqlx::Database + for<'q> Backend<Builder<'q> = SqlConjunction<'q, Db>>,
SqlTextComparison<Label, Db>: ComplexComparison<Db>,
SqlScalarComparison<Score, Db>: ComplexComparison<Db>,
{
#[inline]
fn conjuncts(&self) -> usize {
ComplexComparison::<Db>::conjuncts(&self.label)
+ ComplexComparison::<Db>::conjuncts(&self.confidence)
}
fn apply<'q>(
&'q self,
at: At<'_>,
builder: Db::Builder<'q>,
) -> Result<Db::Builder<'q>, Db::Error> {
let label = at.frame(LABEL);
let builder = self.label.apply(label.at(), builder)?;
let confidence = at.frame(CONFIDENCE);
self.confidence.apply(confidence.at(), builder)
}
}
impl<Db> CompositeComparison<Db> for SqlDetectionComparison<Db>
where
Db: sqlx::Database + for<'q> Backend<Builder<'q> = SqlConjunction<'q, Db>>,
SqlTextComparison<Label, Db>: ComplexComparison<Db>,
SqlScalarComparison<Score, Db>: ComplexComparison<Db>,
{
const SEGMENTS: &'static [crate::ColumnShape] = DETECTION_SEGMENTS;
}
impl<Db> Default for SqlDetectionComparison<Db> {
#[inline]
fn default() -> Self {
Self::new()
}
}
impl<Db> fmt::Debug for SqlDetectionComparison<Db> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("SqlDetectionComparison")
.field("label", &self.label)
.field("confidence", &self.confidence)
.finish()
}
}
impl<Db> Clone for SqlDetectionComparison<Db> {
fn clone(&self) -> Self {
Self {
label: self.label.clone(),
confidence: self.confidence.clone(),
}
}
}
impl<Db> PartialEq for SqlDetectionComparison<Db> {
fn eq(&self, other: &Self) -> bool {
self.label == other.label && self.confidence == other.confidence
}
}
impl<Db> ToDatabaseComparison<Detection, Db> for DetectionFilter
where
Db: sqlx::Database + for<'q> Backend<Builder<'q> = SqlConjunction<'q, Db>>,
SqlTextComparison<Label, Db>: ComplexComparison<Db>,
SqlScalarComparison<Score, Db>: ComplexComparison<Db>,
{
type Comparison = SqlDetectionComparison<Db>;
}
impl<Db> TryFromFilter<DetectionFilter> for SqlDetectionComparison<Db> {
type Error = Infallible;
fn try_from_filter(filter: DetectionFilter) -> Result<Self, Self::Error> {
let DetectionFilter { label, confidence } = filter;
Ok(Self {
label: SqlTextComparison::try_from_filter(label.unwrap_or_default())
.expect("a label crosses into itself"),
confidence: SqlScalarComparison::try_from_filter(confidence.unwrap_or_default())
.expect("a binary width holds every confidence operand"),
})
}
}
pub struct SqlLocatedDetectionComparison<T, C, Db> {
detection: SqlDetectionComparison<Db>,
bbox: SqlBoundingBoxComparison<T, C>,
}
impl<T, C, Db> SqlLocatedDetectionComparison<T, C, Db> {
#[inline]
#[must_use]
pub fn new() -> Self
where
C: Default,
{
Self {
detection: SqlDetectionComparison::new(),
bbox: SqlBoundingBoxComparison::new(),
}
}
#[inline]
pub const fn detection(&self) -> &SqlDetectionComparison<Db> {
&self.detection
}
#[inline]
pub const fn bbox(&self) -> &SqlBoundingBoxComparison<T, C> {
&self.bbox
}
}
impl<T, C, Db> ComplexComparison<Db> for SqlLocatedDetectionComparison<T, C, Db>
where
Db: sqlx::Database + for<'q> Backend<Builder<'q> = SqlConjunction<'q, Db>>,
SqlDetectionComparison<Db>: ComplexComparison<Db>,
C: ComplexComparison<Db>,
{
#[inline]
fn conjuncts(&self) -> usize {
ComplexComparison::<Db>::conjuncts(&self.detection)
+ ComplexComparison::<Db>::conjuncts(&self.bbox)
}
fn apply<'q>(
&'q self,
at: At<'_>,
builder: Db::Builder<'q>,
) -> Result<Db::Builder<'q>, Db::Error> {
let builder = self.detection.apply(at, builder)?;
let bbox = at.frame(BBOX);
self.bbox.apply(bbox.at(), builder)
}
}
impl<T, C, Db> CompositeComparison<Db> for SqlLocatedDetectionComparison<T, C, Db>
where
Db: sqlx::Database + for<'q> Backend<Builder<'q> = SqlConjunction<'q, Db>>,
SqlDetectionComparison<Db>: ComplexComparison<Db>,
C: ComplexComparison<Db>,
T: ColumnKind,
{
const SEGMENTS: &'static [crate::ColumnShape] = <LocatedDetection<T> as ColumnKind>::SEGMENTS;
}
impl<T, C: Default, Db> Default for SqlLocatedDetectionComparison<T, C, Db> {
#[inline]
fn default() -> Self {
Self::new()
}
}
impl<T, C: fmt::Debug, Db> fmt::Debug for SqlLocatedDetectionComparison<T, C, Db> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("SqlLocatedDetectionComparison")
.field("detection", &self.detection)
.field("bbox", &self.bbox)
.finish()
}
}
impl<T, C: Clone, Db> Clone for SqlLocatedDetectionComparison<T, C, Db> {
fn clone(&self) -> Self {
Self {
detection: self.detection.clone(),
bbox: self.bbox.clone(),
}
}
}
impl<T, C: PartialEq, Db> PartialEq for SqlLocatedDetectionComparison<T, C, Db> {
fn eq(&self, other: &Self) -> bool {
self.detection == other.detection && self.bbox == other.bbox
}
}
impl<T, CF, Db> ToDatabaseComparison<LocatedDetection<T>, Db> for LocatedDetectionFilter<CF>
where
Db: sqlx::Database + for<'q> Backend<Builder<'q> = SqlConjunction<'q, Db>>,
SqlDetectionComparison<Db>: ComplexComparison<Db>,
CF: ToDatabaseComparison<T, Db>,
{
type Comparison = SqlLocatedDetectionComparison<T, CF::Comparison, Db>;
}
impl<T, CF, C, Db> TryFromFilter<LocatedDetectionFilter<CF>>
for SqlLocatedDetectionComparison<T, C, Db>
where
CF: Default,
C: TryFromFilter<CF>,
{
type Error = C::Error;
fn try_from_filter(filter: LocatedDetectionFilter<CF>) -> Result<Self, Self::Error> {
let LocatedDetectionFilter { detection, bbox } = filter;
Ok(Self {
detection: SqlDetectionComparison::try_from_filter(detection)
.unwrap_or_else(|never| match never {}),
bbox: SqlBoundingBoxComparison::try_from_filter(bbox.unwrap_or_default())?,
})
}
}
pub struct SqlTextDetectionComparison<T, C, Db> {
text: SqlTextComparison<Utf8Bytes, Db>,
confidence: SqlScalarComparison<Score, Db>,
bbox: SqlBoundingBoxComparison<T, C>,
}
impl<T, C, Db> SqlTextDetectionComparison<T, C, Db> {
#[inline]
#[must_use]
pub fn new() -> Self
where
C: Default,
{
Self {
text: SqlTextComparison::new(),
confidence: SqlScalarComparison::new(),
bbox: SqlBoundingBoxComparison::new(),
}
}
#[inline]
pub const fn text(&self) -> &SqlTextComparison<Utf8Bytes, Db> {
&self.text
}
#[inline]
pub const fn confidence(&self) -> &SqlScalarComparison<Score, Db> {
&self.confidence
}
#[inline]
pub const fn bbox(&self) -> &SqlBoundingBoxComparison<T, C> {
&self.bbox
}
}
impl<T, C, Db> ComplexComparison<Db> for SqlTextDetectionComparison<T, C, Db>
where
Db: sqlx::Database + for<'q> Backend<Builder<'q> = SqlConjunction<'q, Db>>,
SqlTextComparison<Utf8Bytes, Db>: ComplexComparison<Db>,
SqlScalarComparison<Score, Db>: ComplexComparison<Db>,
C: ComplexComparison<Db>,
{
#[inline]
fn conjuncts(&self) -> usize {
ComplexComparison::<Db>::conjuncts(&self.text)
+ ComplexComparison::<Db>::conjuncts(&self.confidence)
+ ComplexComparison::<Db>::conjuncts(&self.bbox)
}
fn apply<'q>(
&'q self,
at: At<'_>,
builder: Db::Builder<'q>,
) -> Result<Db::Builder<'q>, Db::Error> {
let text = at.frame(TEXT);
let builder = self.text.apply(text.at(), builder)?;
let confidence = at.frame(CONFIDENCE);
let builder = self.confidence.apply(confidence.at(), builder)?;
let bbox = at.frame(BBOX);
self.bbox.apply(bbox.at(), builder)
}
}
impl<T, C, Db> CompositeComparison<Db> for SqlTextDetectionComparison<T, C, Db>
where
Db: sqlx::Database + for<'q> Backend<Builder<'q> = SqlConjunction<'q, Db>>,
SqlTextComparison<Utf8Bytes, Db>: ComplexComparison<Db>,
SqlScalarComparison<Score, Db>: ComplexComparison<Db>,
C: ComplexComparison<Db>,
T: ColumnKind,
{
const SEGMENTS: &'static [crate::ColumnShape] = <TextDetection<T> as ColumnKind>::SEGMENTS;
}
impl<T, C: Default, Db> Default for SqlTextDetectionComparison<T, C, Db> {
#[inline]
fn default() -> Self {
Self::new()
}
}
impl<T, C: fmt::Debug, Db> fmt::Debug for SqlTextDetectionComparison<T, C, Db> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("SqlTextDetectionComparison")
.field("text", &self.text)
.field("confidence", &self.confidence)
.field("bbox", &self.bbox)
.finish()
}
}
impl<T, C: Clone, Db> Clone for SqlTextDetectionComparison<T, C, Db> {
fn clone(&self) -> Self {
Self {
text: self.text.clone(),
confidence: self.confidence.clone(),
bbox: self.bbox.clone(),
}
}
}
impl<T, C: PartialEq, Db> PartialEq for SqlTextDetectionComparison<T, C, Db> {
fn eq(&self, other: &Self) -> bool {
self.text == other.text && self.confidence == other.confidence && self.bbox == other.bbox
}
}
impl<T, CF, Db> ToDatabaseComparison<TextDetection<T>, Db> for TextDetectionFilter<CF>
where
Db: sqlx::Database + for<'q> Backend<Builder<'q> = SqlConjunction<'q, Db>>,
SqlTextComparison<Utf8Bytes, Db>: ComplexComparison<Db>,
SqlScalarComparison<Score, Db>: ComplexComparison<Db>,
CF: ToDatabaseComparison<T, Db>,
{
type Comparison = SqlTextDetectionComparison<T, CF::Comparison, Db>;
}
impl<T, CF, C, Db> TryFromFilter<TextDetectionFilter<CF>> for SqlTextDetectionComparison<T, C, Db>
where
CF: Default,
C: TryFromFilter<CF>,
{
type Error = C::Error;
fn try_from_filter(filter: TextDetectionFilter<CF>) -> Result<Self, Self::Error> {
let TextDetectionFilter {
text,
confidence,
bbox,
} = filter;
Ok(Self {
text: SqlTextComparison::try_from_filter(text.unwrap_or_default())
.expect("a text carrier crosses into itself"),
confidence: SqlScalarComparison::try_from_filter(confidence.unwrap_or_default())
.expect("a binary width holds every confidence operand"),
bbox: SqlBoundingBoxComparison::try_from_filter(bbox.unwrap_or_default())?,
})
}
}
pub struct SqlBarcodeDetectionComparison<T, C, Db> {
payload: SqlTextComparison<Utf8Bytes, Db>,
symbology: SqlEnumComparison<Symbology, Db>,
confidence: SqlScalarComparison<Score, Db>,
bbox: SqlBoundingBoxComparison<T, C>,
}
impl<T, C, Db> SqlBarcodeDetectionComparison<T, C, Db> {
#[inline]
#[must_use]
pub fn new() -> Self
where
C: Default,
{
Self {
payload: SqlTextComparison::new(),
symbology: SqlEnumComparison::new(),
confidence: SqlScalarComparison::new(),
bbox: SqlBoundingBoxComparison::new(),
}
}
#[inline]
pub const fn payload(&self) -> &SqlTextComparison<Utf8Bytes, Db> {
&self.payload
}
#[inline]
pub const fn symbology(&self) -> &SqlEnumComparison<Symbology, Db> {
&self.symbology
}
#[inline]
pub const fn confidence(&self) -> &SqlScalarComparison<Score, Db> {
&self.confidence
}
#[inline]
pub const fn bbox(&self) -> &SqlBoundingBoxComparison<T, C> {
&self.bbox
}
}
impl<T, C, Db> ComplexComparison<Db> for SqlBarcodeDetectionComparison<T, C, Db>
where
Db: sqlx::Database + for<'q> Backend<Builder<'q> = SqlConjunction<'q, Db>>,
SqlTextComparison<Utf8Bytes, Db>: ComplexComparison<Db>,
SqlEnumComparison<Symbology, Db>: ComplexComparison<Db>,
SqlScalarComparison<Score, Db>: ComplexComparison<Db>,
C: ComplexComparison<Db>,
{
#[inline]
fn conjuncts(&self) -> usize {
ComplexComparison::<Db>::conjuncts(&self.payload)
+ ComplexComparison::<Db>::conjuncts(&self.symbology)
+ ComplexComparison::<Db>::conjuncts(&self.confidence)
+ ComplexComparison::<Db>::conjuncts(&self.bbox)
}
fn apply<'q>(
&'q self,
at: At<'_>,
builder: Db::Builder<'q>,
) -> Result<Db::Builder<'q>, Db::Error> {
let payload = at.frame(PAYLOAD);
let builder = self.payload.apply(payload.at(), builder)?;
let symbology = at.frame(SYMBOLOGY);
let builder = self.symbology.apply(symbology.at(), builder)?;
let confidence = at.frame(CONFIDENCE);
let builder = self.confidence.apply(confidence.at(), builder)?;
let bbox = at.frame(BBOX);
self.bbox.apply(bbox.at(), builder)
}
}
impl<T, C, Db> CompositeComparison<Db> for SqlBarcodeDetectionComparison<T, C, Db>
where
Db: sqlx::Database + for<'q> Backend<Builder<'q> = SqlConjunction<'q, Db>>,
SqlTextComparison<Utf8Bytes, Db>: ComplexComparison<Db>,
SqlEnumComparison<Symbology, Db>: ComplexComparison<Db>,
SqlScalarComparison<Score, Db>: ComplexComparison<Db>,
C: ComplexComparison<Db>,
T: ColumnKind,
{
const SEGMENTS: &'static [crate::ColumnShape] = <BarcodeDetection<T> as ColumnKind>::SEGMENTS;
}
impl<T, C: Default, Db> Default for SqlBarcodeDetectionComparison<T, C, Db> {
#[inline]
fn default() -> Self {
Self::new()
}
}
impl<T, C: fmt::Debug, Db> fmt::Debug for SqlBarcodeDetectionComparison<T, C, Db> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("SqlBarcodeDetectionComparison")
.field("payload", &self.payload)
.field("symbology", &self.symbology)
.field("confidence", &self.confidence)
.field("bbox", &self.bbox)
.finish()
}
}
impl<T, C: Clone, Db> Clone for SqlBarcodeDetectionComparison<T, C, Db> {
fn clone(&self) -> Self {
Self {
payload: self.payload.clone(),
symbology: self.symbology.clone(),
confidence: self.confidence.clone(),
bbox: self.bbox.clone(),
}
}
}
impl<T, C: PartialEq, Db> PartialEq for SqlBarcodeDetectionComparison<T, C, Db> {
fn eq(&self, other: &Self) -> bool {
self.payload == other.payload
&& self.symbology == other.symbology
&& self.confidence == other.confidence
&& self.bbox == other.bbox
}
}
impl<T, CF, Db> ToDatabaseComparison<BarcodeDetection<T>, Db> for BarcodeDetectionFilter<CF>
where
Db: sqlx::Database + for<'q> Backend<Builder<'q> = SqlConjunction<'q, Db>>,
SqlTextComparison<Utf8Bytes, Db>: ComplexComparison<Db>,
SqlEnumComparison<Symbology, Db>: ComplexComparison<Db>,
SqlScalarComparison<Score, Db>: ComplexComparison<Db>,
CF: ToDatabaseComparison<T, Db>,
{
type Comparison = SqlBarcodeDetectionComparison<T, CF::Comparison, Db>;
}
impl<T, CF, C, Db> TryFromFilter<BarcodeDetectionFilter<CF>>
for SqlBarcodeDetectionComparison<T, C, Db>
where
CF: Default,
C: TryFromFilter<CF>,
{
type Error = C::Error;
fn try_from_filter(filter: BarcodeDetectionFilter<CF>) -> Result<Self, Self::Error> {
let BarcodeDetectionFilter {
payload,
symbology,
confidence,
bbox,
} = filter;
Ok(Self {
payload: SqlTextComparison::try_from_filter(payload.unwrap_or_default())
.expect("a text carrier crosses into itself"),
symbology: SqlEnumComparison::try_from_filter(symbology.unwrap_or_default())
.expect("a symbology crosses into itself"),
confidence: SqlScalarComparison::try_from_filter(confidence.unwrap_or_default())
.expect("a binary width holds every confidence operand"),
bbox: SqlBoundingBoxComparison::try_from_filter(bbox.unwrap_or_default())?,
})
}
}
pub struct SqlDocumentSegmentComparison<T, C, Db> {
quad: crate::SqlQuadComparison<T, C>,
confidence: SqlScalarComparison<Score, Db>,
}
impl<T, C, Db> SqlDocumentSegmentComparison<T, C, Db> {
#[inline]
#[must_use]
pub fn new() -> Self
where
C: Default,
{
Self {
quad: crate::SqlQuadComparison::new(),
confidence: SqlScalarComparison::new(),
}
}
#[inline]
pub const fn quad(&self) -> &crate::SqlQuadComparison<T, C> {
&self.quad
}
#[inline]
pub const fn confidence(&self) -> &SqlScalarComparison<Score, Db> {
&self.confidence
}
}
impl<T, C, Db> ComplexComparison<Db> for SqlDocumentSegmentComparison<T, C, Db>
where
Db: sqlx::Database + for<'q> Backend<Builder<'q> = SqlConjunction<'q, Db>>,
SqlScalarComparison<Score, Db>: ComplexComparison<Db>,
C: ComplexComparison<Db>,
{
#[inline]
fn conjuncts(&self) -> usize {
ComplexComparison::<Db>::conjuncts(&self.quad)
+ ComplexComparison::<Db>::conjuncts(&self.confidence)
}
fn apply<'q>(
&'q self,
at: At<'_>,
builder: Db::Builder<'q>,
) -> Result<Db::Builder<'q>, Db::Error> {
let quad = at.frame(QUAD);
let builder = self.quad.apply(quad.at(), builder)?;
let confidence = at.frame(CONFIDENCE);
self.confidence.apply(confidence.at(), builder)
}
}
impl<T, C, Db> CompositeComparison<Db> for SqlDocumentSegmentComparison<T, C, Db>
where
Db: sqlx::Database + for<'q> Backend<Builder<'q> = SqlConjunction<'q, Db>>,
SqlScalarComparison<Score, Db>: ComplexComparison<Db>,
C: ComplexComparison<Db>,
T: ColumnKind,
{
const SEGMENTS: &'static [crate::ColumnShape] = <DocumentSegment<T> as ColumnKind>::SEGMENTS;
}
impl<T, C: Default, Db> Default for SqlDocumentSegmentComparison<T, C, Db> {
#[inline]
fn default() -> Self {
Self::new()
}
}
impl<T, C: fmt::Debug, Db> fmt::Debug for SqlDocumentSegmentComparison<T, C, Db> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("SqlDocumentSegmentComparison")
.field("quad", &self.quad)
.field("confidence", &self.confidence)
.finish()
}
}
impl<T, C: Clone, Db> Clone for SqlDocumentSegmentComparison<T, C, Db> {
fn clone(&self) -> Self {
Self {
quad: self.quad.clone(),
confidence: self.confidence.clone(),
}
}
}
impl<T, C: PartialEq, Db> PartialEq for SqlDocumentSegmentComparison<T, C, Db> {
fn eq(&self, other: &Self) -> bool {
self.quad == other.quad && self.confidence == other.confidence
}
}
impl<T, CF, Db> ToDatabaseComparison<DocumentSegment<T>, Db> for DocumentSegmentFilter<CF>
where
Db: sqlx::Database + for<'q> Backend<Builder<'q> = SqlConjunction<'q, Db>>,
SqlScalarComparison<Score, Db>: ComplexComparison<Db>,
CF: ToDatabaseComparison<T, Db>,
{
type Comparison = SqlDocumentSegmentComparison<T, CF::Comparison, Db>;
}
impl<T, CF, C, Db> TryFromFilter<DocumentSegmentFilter<CF>>
for SqlDocumentSegmentComparison<T, C, Db>
where
CF: Default,
C: TryFromFilter<CF>,
{
type Error = C::Error;
fn try_from_filter(filter: DocumentSegmentFilter<CF>) -> Result<Self, Self::Error> {
let DocumentSegmentFilter { quad, confidence } = filter;
Ok(Self {
quad: crate::SqlQuadComparison::try_from_filter(quad.unwrap_or_default())?,
confidence: SqlScalarComparison::try_from_filter(confidence.unwrap_or_default())
.expect("a binary width holds every confidence operand"),
})
}
}