use core::{fmt, marker::PhantomData};
use crate::{
At, Backend, ColumnKind, ComplexComparison, CompositeComparison, ToDatabaseComparison,
TryFromFilter, comparison::sql::SqlConjunction,
};
use super::{
BoundingBox, BoundingBoxFilter, Point2, Point2Filter, Quad, QuadFilter,
bbox::{AREA, HEIGHT, WIDTH, X as BOX_X, Y as BOX_Y},
point::{X as POINT_X, Y as POINT_Y},
quad::{BOTTOM_LEFT, BOTTOM_RIGHT, TOP_LEFT, TOP_RIGHT},
};
pub struct SqlPoint2Comparison<T, C> {
x: C,
y: C,
component: PhantomData<fn() -> T>,
}
impl<T, C> SqlPoint2Comparison<T, C> {
#[inline]
#[must_use]
pub fn new() -> Self
where
C: Default,
{
Self {
x: C::default(),
y: C::default(),
component: PhantomData,
}
}
#[inline]
pub const fn x(&self) -> &C {
&self.x
}
#[inline]
pub const fn y(&self) -> &C {
&self.y
}
}
impl<T, C, Db> ComplexComparison<Db> for SqlPoint2Comparison<T, C>
where
Db: sqlx::Database + for<'q> Backend<Builder<'q> = SqlConjunction<'q, Db>>,
C: ComplexComparison<Db>,
{
fn conjuncts(&self) -> usize {
self.x.conjuncts() + self.y.conjuncts()
}
fn apply<'q>(
&'q self,
at: At<'_>,
builder: Db::Builder<'q>,
) -> Result<Db::Builder<'q>, Db::Error> {
let x = at.frame(POINT_X);
let builder = self.x.apply(x.at(), builder)?;
let y = at.frame(POINT_Y);
self.y.apply(y.at(), builder)
}
}
impl<T, C, Db> CompositeComparison<Db> for SqlPoint2Comparison<T, C>
where
Db: sqlx::Database + for<'q> Backend<Builder<'q> = SqlConjunction<'q, Db>>,
C: ComplexComparison<Db>,
T: ColumnKind,
{
const SEGMENTS: &'static [crate::ColumnShape] = <Point2<T> as ColumnKind>::SEGMENTS;
}
impl<T, C: Default> Default for SqlPoint2Comparison<T, C> {
#[inline]
fn default() -> Self {
Self::new()
}
}
impl<T, C: fmt::Debug> fmt::Debug for SqlPoint2Comparison<T, C> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("SqlPoint2Comparison")
.field("x", &self.x)
.field("y", &self.y)
.finish()
}
}
impl<T, C: Clone> Clone for SqlPoint2Comparison<T, C> {
fn clone(&self) -> Self {
Self {
x: self.x.clone(),
y: self.y.clone(),
component: PhantomData,
}
}
}
impl<T, C: PartialEq> PartialEq for SqlPoint2Comparison<T, C> {
fn eq(&self, other: &Self) -> bool {
self.x == other.x && self.y == other.y
}
}
impl<T, CF, Db> ToDatabaseComparison<Point2<T>, Db> for Point2Filter<CF>
where
Db: sqlx::Database + for<'q> Backend<Builder<'q> = SqlConjunction<'q, Db>>,
CF: ToDatabaseComparison<T, Db>,
{
type Comparison = SqlPoint2Comparison<T, CF::Comparison>;
}
impl<T, CF, C> TryFromFilter<Point2Filter<CF>> for SqlPoint2Comparison<T, C>
where
CF: Default,
C: TryFromFilter<CF>,
{
type Error = C::Error;
fn try_from_filter(filter: Point2Filter<CF>) -> Result<Self, Self::Error> {
let Point2Filter { x, y } = filter;
Ok(Self {
x: C::try_from_filter(x.unwrap_or_default())?,
y: C::try_from_filter(y.unwrap_or_default())?,
component: PhantomData,
})
}
}
pub struct SqlBoundingBoxComparison<T, C> {
x: C,
y: C,
width: C,
height: C,
area: C,
component: PhantomData<fn() -> T>,
}
impl<T, C> SqlBoundingBoxComparison<T, C> {
#[inline]
#[must_use]
pub fn new() -> Self
where
C: Default,
{
Self {
x: C::default(),
y: C::default(),
width: C::default(),
height: C::default(),
area: C::default(),
component: PhantomData,
}
}
#[inline]
pub const fn x(&self) -> &C {
&self.x
}
#[inline]
pub const fn y(&self) -> &C {
&self.y
}
#[inline]
pub const fn width(&self) -> &C {
&self.width
}
#[inline]
pub const fn height(&self) -> &C {
&self.height
}
#[inline]
pub const fn area(&self) -> &C {
&self.area
}
}
impl<T, C, Db> ComplexComparison<Db> for SqlBoundingBoxComparison<T, C>
where
Db: sqlx::Database + for<'q> Backend<Builder<'q> = SqlConjunction<'q, Db>>,
C: ComplexComparison<Db>,
{
fn conjuncts(&self) -> usize {
self.x.conjuncts()
+ self.y.conjuncts()
+ self.width.conjuncts()
+ self.height.conjuncts()
+ self.area.conjuncts()
}
fn apply<'q>(
&'q self,
at: At<'_>,
builder: Db::Builder<'q>,
) -> Result<Db::Builder<'q>, Db::Error> {
let x = at.frame(BOX_X);
let builder = self.x.apply(x.at(), builder)?;
let y = at.frame(BOX_Y);
let builder = self.y.apply(y.at(), builder)?;
let width = at.frame(WIDTH);
let builder = self.width.apply(width.at(), builder)?;
let height = at.frame(HEIGHT);
let builder = self.height.apply(height.at(), builder)?;
let area = at.frame(AREA);
self.area.apply(area.at(), builder)
}
}
impl<T, C, Db> CompositeComparison<Db> for SqlBoundingBoxComparison<T, C>
where
Db: sqlx::Database + for<'q> Backend<Builder<'q> = SqlConjunction<'q, Db>>,
C: ComplexComparison<Db>,
T: ColumnKind,
{
const SEGMENTS: &'static [crate::ColumnShape] = <BoundingBox<T> as ColumnKind>::SEGMENTS;
}
impl<T, C: Default> Default for SqlBoundingBoxComparison<T, C> {
#[inline]
fn default() -> Self {
Self::new()
}
}
impl<T, C: fmt::Debug> fmt::Debug for SqlBoundingBoxComparison<T, C> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("SqlBoundingBoxComparison")
.field("x", &self.x)
.field("y", &self.y)
.field("width", &self.width)
.field("height", &self.height)
.field("area", &self.area)
.finish()
}
}
impl<T, C: Clone> Clone for SqlBoundingBoxComparison<T, C> {
fn clone(&self) -> Self {
Self {
x: self.x.clone(),
y: self.y.clone(),
width: self.width.clone(),
height: self.height.clone(),
area: self.area.clone(),
component: PhantomData,
}
}
}
impl<T, C: PartialEq> PartialEq for SqlBoundingBoxComparison<T, C> {
fn eq(&self, other: &Self) -> bool {
self.x == other.x
&& self.y == other.y
&& self.width == other.width
&& self.height == other.height
&& self.area == other.area
}
}
impl<T, CF, Db> ToDatabaseComparison<BoundingBox<T>, Db> for BoundingBoxFilter<CF>
where
Db: sqlx::Database + for<'q> Backend<Builder<'q> = SqlConjunction<'q, Db>>,
CF: ToDatabaseComparison<T, Db>,
{
type Comparison = SqlBoundingBoxComparison<T, CF::Comparison>;
}
impl<T, CF, C> TryFromFilter<BoundingBoxFilter<CF>> for SqlBoundingBoxComparison<T, C>
where
CF: Default,
C: TryFromFilter<CF>,
{
type Error = C::Error;
fn try_from_filter(filter: BoundingBoxFilter<CF>) -> Result<Self, Self::Error> {
let BoundingBoxFilter {
x,
y,
width,
height,
area,
} = filter;
Ok(Self {
x: C::try_from_filter(x.unwrap_or_default())?,
y: C::try_from_filter(y.unwrap_or_default())?,
width: C::try_from_filter(width.unwrap_or_default())?,
height: C::try_from_filter(height.unwrap_or_default())?,
area: C::try_from_filter(area.unwrap_or_default())?,
component: PhantomData,
})
}
}
pub struct SqlQuadComparison<T, C> {
top_left: SqlPoint2Comparison<T, C>,
top_right: SqlPoint2Comparison<T, C>,
bottom_right: SqlPoint2Comparison<T, C>,
bottom_left: SqlPoint2Comparison<T, C>,
}
impl<T, C> SqlQuadComparison<T, C> {
#[inline]
#[must_use]
pub fn new() -> Self
where
C: Default,
{
Self {
top_left: SqlPoint2Comparison::new(),
top_right: SqlPoint2Comparison::new(),
bottom_right: SqlPoint2Comparison::new(),
bottom_left: SqlPoint2Comparison::new(),
}
}
#[inline]
pub const fn top_left(&self) -> &SqlPoint2Comparison<T, C> {
&self.top_left
}
#[inline]
pub const fn top_right(&self) -> &SqlPoint2Comparison<T, C> {
&self.top_right
}
#[inline]
pub const fn bottom_right(&self) -> &SqlPoint2Comparison<T, C> {
&self.bottom_right
}
#[inline]
pub const fn bottom_left(&self) -> &SqlPoint2Comparison<T, C> {
&self.bottom_left
}
}
impl<T, C, Db> ComplexComparison<Db> for SqlQuadComparison<T, C>
where
Db: sqlx::Database + for<'q> Backend<Builder<'q> = SqlConjunction<'q, Db>>,
C: ComplexComparison<Db>,
{
fn conjuncts(&self) -> usize {
ComplexComparison::<Db>::conjuncts(&self.top_left)
+ ComplexComparison::<Db>::conjuncts(&self.top_right)
+ ComplexComparison::<Db>::conjuncts(&self.bottom_right)
+ ComplexComparison::<Db>::conjuncts(&self.bottom_left)
}
fn apply<'q>(
&'q self,
at: At<'_>,
builder: Db::Builder<'q>,
) -> Result<Db::Builder<'q>, Db::Error> {
let top_left = at.frame(TOP_LEFT);
let builder = self.top_left.apply(top_left.at(), builder)?;
let top_right = at.frame(TOP_RIGHT);
let builder = self.top_right.apply(top_right.at(), builder)?;
let bottom_right = at.frame(BOTTOM_RIGHT);
let builder = self.bottom_right.apply(bottom_right.at(), builder)?;
let bottom_left = at.frame(BOTTOM_LEFT);
self.bottom_left.apply(bottom_left.at(), builder)
}
}
impl<T, C, Db> CompositeComparison<Db> for SqlQuadComparison<T, C>
where
Db: sqlx::Database + for<'q> Backend<Builder<'q> = SqlConjunction<'q, Db>>,
C: ComplexComparison<Db>,
T: ColumnKind,
{
const SEGMENTS: &'static [crate::ColumnShape] = <Quad<T> as ColumnKind>::SEGMENTS;
}
impl<T, C: Default> Default for SqlQuadComparison<T, C> {
#[inline]
fn default() -> Self {
Self::new()
}
}
impl<T, C: fmt::Debug> fmt::Debug for SqlQuadComparison<T, C> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("SqlQuadComparison")
.field("top_left", &self.top_left)
.field("top_right", &self.top_right)
.field("bottom_right", &self.bottom_right)
.field("bottom_left", &self.bottom_left)
.finish()
}
}
impl<T, C: Clone> Clone for SqlQuadComparison<T, C> {
fn clone(&self) -> Self {
Self {
top_left: self.top_left.clone(),
top_right: self.top_right.clone(),
bottom_right: self.bottom_right.clone(),
bottom_left: self.bottom_left.clone(),
}
}
}
impl<T, C: PartialEq> PartialEq for SqlQuadComparison<T, C> {
fn eq(&self, other: &Self) -> bool {
self.top_left == other.top_left
&& self.top_right == other.top_right
&& self.bottom_right == other.bottom_right
&& self.bottom_left == other.bottom_left
}
}
impl<T, CF, Db> ToDatabaseComparison<Quad<T>, Db> for QuadFilter<CF>
where
Db: sqlx::Database + for<'q> Backend<Builder<'q> = SqlConjunction<'q, Db>>,
CF: ToDatabaseComparison<T, Db>,
{
type Comparison = SqlQuadComparison<T, CF::Comparison>;
}
impl<T, CF, C> TryFromFilter<QuadFilter<CF>> for SqlQuadComparison<T, C>
where
CF: Default,
C: TryFromFilter<CF>,
{
type Error = C::Error;
fn try_from_filter(filter: QuadFilter<CF>) -> Result<Self, Self::Error> {
let QuadFilter {
top_left,
top_right,
bottom_right,
bottom_left,
} = filter;
let corner = |facet: Option<Point2Filter<CF>>| {
SqlPoint2Comparison::try_from_filter(facet.unwrap_or_default())
};
Ok(Self {
top_left: corner(top_left)?,
top_right: corner(top_right)?,
bottom_right: corner(bottom_right)?,
bottom_left: corner(bottom_left)?,
})
}
}