use crate::{
At, Backend, ColumnKind, ComplexComparison, CompositeComparison, MongoCarrier, Timestamp,
ToDatabaseComparison, TryFromFilter,
comparison::mongo::{Mongo, MongoOperator, MongoScalarComparison, field_path},
};
use super::{
Contained, TimeRange, TimeRangeFilter, TimeRanged, TimeRangedFilter,
storage::{DATA, END, SEGMENTS, START},
};
#[cfg(test)]
mod tests;
#[derive(Debug, Clone, PartialEq, Default)]
pub struct MongoTimeRangeComparison {
overlaps: Option<TimeRange>,
contains: Option<Contained>,
within: Option<TimeRange>,
start: MongoScalarComparison<Timestamp>,
end: MongoScalarComparison<Timestamp>,
}
impl MongoTimeRangeComparison {
#[inline]
#[must_use]
pub fn new() -> Self {
Self::default()
}
#[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) -> &MongoScalarComparison<Timestamp> {
&self.start
}
#[inline]
#[must_use]
pub const fn end(&self) -> &MongoScalarComparison<Timestamp> {
&self.end
}
}
impl ComplexComparison<Mongo> for MongoTimeRangeComparison {
#[inline]
fn conjuncts(&self) -> usize {
2 * (usize::from(self.overlaps.is_some())
+ usize::from(self.contains.is_some())
+ usize::from(self.within.is_some()))
+ ComplexComparison::<Mongo>::conjuncts(&self.start)
+ ComplexComparison::<Mongo>::conjuncts(&self.end)
}
fn apply<'q>(
&'q self,
at: At<'_>,
mut builder: <Mongo as Backend>::Builder<'q>,
) -> Result<<Mongo as Backend>::Builder<'q>, <Mongo as Backend>::Error> {
let start = at.frame(START);
let end = at.frame(END);
let start_key = field_path(start.at());
let end_key = field_path(end.at());
for (operand, crossed, at_start, at_end) in [
(&self.overlaps, true, MongoOperator::Lt, MongoOperator::Gt),
(&self.within, false, MongoOperator::Gte, MongoOperator::Lte),
] {
let Some(range) = operand else { continue };
let (against_start, against_end) = if crossed {
(range.end(), range.start())
} else {
(range.start(), range.end())
};
builder.merge(&start_key, at_start, against_start.to_bson());
builder.merge(&end_key, at_end, against_end.to_bson());
}
match &self.contains {
Some(Contained::Instant(at)) => {
builder.merge(&start_key, MongoOperator::Lte, at.to_bson());
builder.merge(&end_key, MongoOperator::Gt, at.to_bson());
}
Some(Contained::Span(span)) => {
builder.merge(&start_key, MongoOperator::Lte, span.start().to_bson());
builder.merge(&end_key, MongoOperator::Gte, span.end().to_bson());
}
None => {}
}
let builder = self.start.apply(start.at(), builder)?;
self.end.apply(end.at(), builder)
}
}
impl CompositeComparison<Mongo> for MongoTimeRangeComparison {
const SEGMENTS: &'static [crate::ColumnShape] = SEGMENTS;
}
impl ToDatabaseComparison<Timestamp, Mongo> for TimeRangeFilter {
type Comparison = MongoTimeRangeComparison;
}
impl TryFromFilter<TimeRangeFilter> for MongoTimeRangeComparison {
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: MongoScalarComparison::try_from_filter(start.unwrap_or_default())?,
end: MongoScalarComparison::try_from_filter(end.unwrap_or_default())?,
})
}
}
#[derive(Debug, Clone, PartialEq)]
pub struct MongoTimeRangedComparison<P, C> {
range: MongoTimeRangeComparison,
data: C,
payload: core::marker::PhantomData<fn() -> P>,
}
impl<P, C> MongoTimeRangedComparison<P, C> {
#[inline]
#[must_use]
pub fn new() -> Self
where
C: Default,
{
Self {
range: MongoTimeRangeComparison::new(),
data: C::default(),
payload: core::marker::PhantomData,
}
}
#[inline]
#[must_use]
pub const fn range(&self) -> &MongoTimeRangeComparison {
&self.range
}
#[inline]
#[must_use]
pub const fn data(&self) -> &C {
&self.data
}
}
impl<P, C: Default> Default for MongoTimeRangedComparison<P, C> {
#[inline]
fn default() -> Self {
Self::new()
}
}
impl<P, C: ComplexComparison<Mongo>> ComplexComparison<Mongo> for MongoTimeRangedComparison<P, C> {
#[inline]
fn conjuncts(&self) -> usize {
ComplexComparison::<Mongo>::conjuncts(&self.range)
+ ComplexComparison::<Mongo>::conjuncts(&self.data)
}
fn apply<'q>(
&'q self,
at: At<'_>,
builder: <Mongo as Backend>::Builder<'q>,
) -> Result<<Mongo as Backend>::Builder<'q>, <Mongo as Backend>::Error> {
let builder = self.range.apply(at, builder)?;
let data = at.frame(DATA);
self.data.apply(data.at(), builder)
}
}
impl<P: ColumnKind, C: ComplexComparison<Mongo>> CompositeComparison<Mongo>
for MongoTimeRangedComparison<P, C>
{
const SEGMENTS: &'static [crate::ColumnShape] = <TimeRanged<P> as ColumnKind>::SEGMENTS;
}
impl<TF, P> ToDatabaseComparison<TimeRanged<P>, Mongo> for TimeRangedFilter<TF>
where
TF: ToDatabaseComparison<P, Mongo>,
P: ColumnKind,
{
type Comparison = MongoTimeRangedComparison<P, TF::Comparison>;
}
impl<P, TF: Default, C: TryFromFilter<TF>> TryFromFilter<TimeRangedFilter<TF>>
for MongoTimeRangedComparison<P, C>
{
type Error = C::Error;
fn try_from_filter(filter: TimeRangedFilter<TF>) -> Result<Self, Self::Error> {
let TimeRangedFilter { range, data } = filter;
let range = MongoTimeRangeComparison::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,
})
}
}