use core::fmt::{self, Display};
use crate::{
At, Backend, Carrier, ColumnKind, ComplexComparison, CompositeComparison, Timestamp,
ToDatabaseComparison, TryFromFilter,
comparison::sql::{SqlConjunction, SqlScalarComparison, push_operand_cmp},
};
use super::{
Contained, TimeRange, TimeRangeFilter, TimeRangedFilter,
storage::{DATA, END, SEGMENTS, START},
};
#[cfg(all(test, feature = "sqlite"))]
mod tests;
pub struct SqlTimeRangeComparison<Db> {
overlaps: Option<TimeRange>,
contains: Option<Contained>,
within: Option<TimeRange>,
start: SqlScalarComparison<Timestamp, Db>,
end: SqlScalarComparison<Timestamp, Db>,
}
impl<Db> SqlTimeRangeComparison<Db> {
#[inline]
#[must_use]
pub const fn new() -> Self {
Self {
overlaps: None,
contains: None,
within: None,
start: SqlScalarComparison::new(),
end: SqlScalarComparison::new(),
}
}
#[inline]
#[must_use]
pub const fn overlaps(&self) -> Option<&TimeRange> {
self.overlaps.as_ref()
}
#[inline]
#[must_use]
pub const fn contains(&self) -> Option<&Contained> {
self.contains.as_ref()
}
#[inline]
#[must_use]
pub const fn within(&self) -> Option<&TimeRange> {
self.within.as_ref()
}
#[inline]
#[must_use]
pub const fn start(&self) -> &SqlScalarComparison<Timestamp, Db> {
&self.start
}
#[inline]
#[must_use]
pub const fn end(&self) -> &SqlScalarComparison<Timestamp, Db> {
&self.end
}
#[inline]
const fn interval_conjuncts(&self) -> usize {
2 * (self.overlaps.is_some() as usize
+ self.contains.is_some() as usize
+ self.within.is_some() as usize)
}
}
impl<Db> ComplexComparison<Db> for SqlTimeRangeComparison<Db>
where
Db: sqlx::Database + for<'q> Backend<Builder<'q> = SqlConjunction<'q, Db>, Buffer: Display>,
Timestamp: Carrier<Db> + ColumnKind,
{
#[inline]
fn conjuncts(&self) -> usize {
self.interval_conjuncts()
+ ComplexComparison::<Db>::conjuncts(&self.start)
+ ComplexComparison::<Db>::conjuncts(&self.end)
}
fn apply<'q>(
&'q self,
at: At<'_>,
mut builder: Db::Builder<'q>,
) -> Result<Db::Builder<'q>, Db::Error> {
let start = at.frame(START);
let end = at.frame(END);
if let Some(operand) = &self.overlaps {
push_operand_cmp(builder.open(), start.at(), " < ", &operand.end(), false);
push_operand_cmp(builder.open(), end.at(), " > ", &operand.start(), false);
}
match &self.contains {
Some(Contained::Instant(at)) => {
push_operand_cmp(builder.open(), start.at(), " <= ", at, false);
push_operand_cmp(builder.open(), end.at(), " > ", at, false);
}
Some(Contained::Span(span)) => {
push_operand_cmp(builder.open(), start.at(), " <= ", &span.start(), false);
push_operand_cmp(builder.open(), end.at(), " >= ", &span.end(), false);
}
None => {}
}
if let Some(operand) = &self.within {
push_operand_cmp(builder.open(), start.at(), " >= ", &operand.start(), false);
push_operand_cmp(builder.open(), end.at(), " <= ", &operand.end(), false);
}
let builder = self.start.apply(start.at(), builder)?;
self.end.apply(end.at(), builder)
}
}
impl<Db> CompositeComparison<Db> for SqlTimeRangeComparison<Db>
where
Db: sqlx::Database + for<'q> Backend<Builder<'q> = SqlConjunction<'q, Db>, Buffer: Display>,
Timestamp: Carrier<Db> + ColumnKind,
{
const SEGMENTS: &'static [crate::ColumnShape] = SEGMENTS;
}
impl<Db> Default for SqlTimeRangeComparison<Db> {
#[inline]
fn default() -> Self {
Self::new()
}
}
impl<Db> fmt::Debug for SqlTimeRangeComparison<Db> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("SqlTimeRangeComparison")
.field("overlaps", &self.overlaps)
.field("contains", &self.contains)
.field("within", &self.within)
.field("start", &self.start)
.field("end", &self.end)
.finish()
}
}
impl<Db> Clone for SqlTimeRangeComparison<Db> {
fn clone(&self) -> Self {
Self {
overlaps: self.overlaps,
contains: self.contains,
within: self.within,
start: self.start.clone(),
end: self.end.clone(),
}
}
}
impl<Db> PartialEq for SqlTimeRangeComparison<Db> {
fn eq(&self, other: &Self) -> bool {
self.overlaps == other.overlaps
&& self.contains == other.contains
&& self.within == other.within
&& self.start == other.start
&& self.end == other.end
}
}
impl<Db> ToDatabaseComparison<Timestamp, Db> for TimeRangeFilter
where
Db: sqlx::Database + for<'q> Backend<Builder<'q> = SqlConjunction<'q, Db>, Buffer: Display>,
Timestamp: Carrier<Db> + ColumnKind,
{
type Comparison = SqlTimeRangeComparison<Db>;
}
impl<Db> TryFromFilter<TimeRangeFilter> for SqlTimeRangeComparison<Db> {
type Error = core::convert::Infallible;
fn try_from_filter(filter: TimeRangeFilter) -> Result<Self, Self::Error> {
let TimeRangeFilter {
overlaps,
contains,
within,
start,
end,
} = filter;
Ok(Self {
overlaps: overlaps.map(Into::into),
contains: contains.map(Into::into),
within: within.map(Into::into),
start: SqlScalarComparison::try_from_filter(start.unwrap_or_default())?,
end: SqlScalarComparison::try_from_filter(end.unwrap_or_default())?,
})
}
}
pub struct SqlTimeRangedComparison<P, C, Db> {
range: SqlTimeRangeComparison<Db>,
data: C,
payload: core::marker::PhantomData<fn() -> P>,
}
impl<P, C, Db> SqlTimeRangedComparison<P, C, Db> {
#[inline]
#[must_use]
pub fn new() -> Self
where
C: Default,
{
Self {
range: SqlTimeRangeComparison::new(),
data: C::default(),
payload: core::marker::PhantomData,
}
}
#[inline]
#[must_use]
pub const fn range(&self) -> &SqlTimeRangeComparison<Db> {
&self.range
}
#[inline]
#[must_use]
pub const fn data(&self) -> &C {
&self.data
}
}
impl<P, C, Db> ComplexComparison<Db> for SqlTimeRangedComparison<P, C, Db>
where
Db: sqlx::Database + for<'q> Backend<Builder<'q> = SqlConjunction<'q, Db>, Buffer: Display>,
Timestamp: Carrier<Db> + ColumnKind,
C: ComplexComparison<Db>,
{
#[inline]
fn conjuncts(&self) -> usize {
ComplexComparison::<Db>::conjuncts(&self.range) + ComplexComparison::<Db>::conjuncts(&self.data)
}
fn apply<'q>(
&'q self,
at: At<'_>,
builder: Db::Builder<'q>,
) -> Result<Db::Builder<'q>, Db::Error> {
let builder = self.range.apply(at, builder)?;
let data = at.frame(DATA);
self.data.apply(data.at(), builder)
}
}
impl<P, C, Db> CompositeComparison<Db> for SqlTimeRangedComparison<P, C, Db>
where
Db: sqlx::Database + for<'q> Backend<Builder<'q> = SqlConjunction<'q, Db>, Buffer: Display>,
Timestamp: Carrier<Db> + ColumnKind,
C: ComplexComparison<Db>,
P: ColumnKind,
{
const SEGMENTS: &'static [crate::ColumnShape] = <super::TimeRanged<P> as ColumnKind>::SEGMENTS;
}
impl<P, C: Default, Db> Default for SqlTimeRangedComparison<P, C, Db> {
#[inline]
fn default() -> Self {
Self::new()
}
}
impl<P, C: fmt::Debug, Db> fmt::Debug for SqlTimeRangedComparison<P, C, Db> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("SqlTimeRangedComparison")
.field("range", &self.range)
.field("data", &self.data)
.finish()
}
}
impl<P, C: Clone, Db> Clone for SqlTimeRangedComparison<P, C, Db> {
fn clone(&self) -> Self {
Self {
range: self.range.clone(),
data: self.data.clone(),
payload: core::marker::PhantomData,
}
}
}
impl<P, C: PartialEq, Db> PartialEq for SqlTimeRangedComparison<P, C, Db> {
fn eq(&self, other: &Self) -> bool {
self.range == other.range && self.data == other.data
}
}
impl<TF, P, Db> ToDatabaseComparison<super::TimeRanged<P>, Db> for TimeRangedFilter<TF>
where
Db: sqlx::Database + for<'q> Backend<Builder<'q> = SqlConjunction<'q, Db>, Buffer: Display>,
Timestamp: Carrier<Db> + ColumnKind,
TF: ToDatabaseComparison<P, Db>,
P: ColumnKind,
{
type Comparison = SqlTimeRangedComparison<P, TF::Comparison, Db>;
}
impl<P, TF, C, Db> TryFromFilter<TimeRangedFilter<TF>> for SqlTimeRangedComparison<P, C, Db>
where
TF: Default,
C: TryFromFilter<TF>,
{
type Error = C::Error;
fn try_from_filter(filter: TimeRangedFilter<TF>) -> Result<Self, Self::Error> {
let TimeRangedFilter { range, data } = filter;
let range = SqlTimeRangeComparison::try_from_filter(range.unwrap_or_default())
.unwrap_or_else(|infallible| match infallible {});
Ok(Self {
range,
data: C::try_from_filter(data.unwrap_or_default())?,
payload: core::marker::PhantomData,
})
}
}