use core::fmt::{self, Display};
use crate::{
At, Backend, BindCeiling, Carrier, ComplexComparison, CompositeComparison, Temporal,
ToDatabaseComparison, TryFromFilter,
comparison::sql::{SqlConjunction, SqlLoweringError, SqlScalarComparison, push_column},
};
use super::{
LocalTimestamp, LocalTimestampFilter,
storage::{LOCAL, OFFSET_SECONDS, OFFSET_STATED, SEGMENTS, UTC_NANOS},
};
#[cfg(all(test, feature = "postgres"))]
mod tests;
type StoredLocal = Temporal<time::PrimitiveDateTime>;
pub struct SqlLocalTimestampComparison<Db> {
exact: Option<Stored>,
utc: SqlScalarComparison<i64, Db>,
local: SqlScalarComparison<StoredLocal, Db>,
offset: SqlScalarComparison<Temporal<i32>, Db>,
zoned: Option<bool>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
struct Stored {
local: StoredLocal,
seconds: i32,
stated: bool,
}
impl<Db> SqlLocalTimestampComparison<Db> {
#[inline]
#[must_use]
pub const fn new() -> Self {
Self {
exact: None,
utc: SqlScalarComparison::new(),
local: SqlScalarComparison::new(),
offset: SqlScalarComparison::new(),
zoned: None,
}
}
#[inline]
#[must_use]
pub const fn utc(&self) -> &SqlScalarComparison<i64, Db> {
&self.utc
}
#[inline]
#[must_use]
pub const fn local(&self) -> &SqlScalarComparison<StoredLocal, Db> {
&self.local
}
#[inline]
#[must_use]
pub const fn offset(&self) -> &SqlScalarComparison<Temporal<i32>, Db> {
&self.offset
}
#[inline]
#[must_use]
pub const fn zoned(&self) -> Option<bool> {
self.zoned
}
#[inline]
#[must_use]
pub const fn is_empty(&self) -> bool {
self.exact.is_none()
&& self.utc.is_empty()
&& self.local.is_empty()
&& self.offset.is_empty()
&& self.zoned.is_none()
}
#[inline]
#[must_use]
pub const fn conjuncts(&self) -> usize {
self.exact.is_some() as usize * 3
+ self.utc.conjuncts()
+ self.local.conjuncts()
+ self.offset.conjuncts()
+ !self.offset.is_empty() as usize
+ self.zoned.is_some() as usize
}
}
impl<Db> ComplexComparison<Db> for SqlLocalTimestampComparison<Db>
where
Db: sqlx::Database
+ BindCeiling
+ for<'q> Backend<Builder<'q> = SqlConjunction<'q, Db>, Error = SqlLoweringError, Buffer: Display>,
bool: Carrier<Db>,
i32: Carrier<Db>,
i64: Carrier<Db>,
StoredLocal: Carrier<Db>,
Temporal<i32>: Carrier<Db>,
for<'a> &'a str: sqlx::Encode<'a, Db> + sqlx::Type<Db>,
{
#[inline]
fn conjuncts(&self) -> usize {
Self::conjuncts(self)
}
fn apply<'q>(
&'q self,
at: At<'_>,
builder: Db::Builder<'q>,
) -> Result<Db::Builder<'q>, Db::Error> {
let mut builder = builder;
if let Some(Stored {
local,
seconds,
stated,
}) = self.exact
{
equals::<Db, StoredLocal>(&mut builder, at.frame(LOCAL).at(), local);
equals::<Db, i32>(&mut builder, at.frame(OFFSET_SECONDS).at(), seconds);
equals::<Db, bool>(&mut builder, at.frame(OFFSET_STATED).at(), stated);
}
if !self.offset.is_empty() {
equals::<Db, bool>(&mut builder, at.frame(OFFSET_STATED).at(), true);
}
if let Some(zoned) = self.zoned {
equals::<Db, bool>(&mut builder, at.frame(OFFSET_STATED).at(), zoned);
}
let local = at.frame(LOCAL);
let builder = self.local.apply(local.at(), builder)?;
let offset = at.frame(OFFSET_SECONDS);
let builder = self.offset.apply(offset.at(), builder)?;
let utc = at.frame(UTC_NANOS);
self.utc.apply(utc.at(), builder)
}
}
fn equals<'q, Db, V>(builder: &mut SqlConjunction<'q, Db>, at: At<'_>, operand: V)
where
Db: sqlx::Database + Backend<Buffer: Display>,
V: Carrier<Db>,
{
let qb = builder.open();
push_column(qb, at);
qb.push(" = ");
operand.push_bind(qb);
}
impl<Db> CompositeComparison<Db> for SqlLocalTimestampComparison<Db>
where
Db: sqlx::Database
+ BindCeiling
+ for<'q> Backend<Builder<'q> = SqlConjunction<'q, Db>, Error = SqlLoweringError, Buffer: Display>,
bool: Carrier<Db>,
i32: Carrier<Db>,
i64: Carrier<Db>,
StoredLocal: Carrier<Db>,
Temporal<i32>: Carrier<Db>,
for<'a> &'a str: sqlx::Encode<'a, Db> + sqlx::Type<Db>,
{
const SEGMENTS: &'static [crate::ColumnShape] = SEGMENTS;
}
impl<Db> Default for SqlLocalTimestampComparison<Db> {
#[inline]
fn default() -> Self {
Self::new()
}
}
impl<Db> fmt::Debug for SqlLocalTimestampComparison<Db> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("SqlLocalTimestampComparison")
.field("exact", &self.exact)
.field("utc", &self.utc)
.field("local", &self.local)
.field("offset", &self.offset)
.field("zoned", &self.zoned)
.finish()
}
}
impl<Db> Clone for SqlLocalTimestampComparison<Db> {
fn clone(&self) -> Self {
Self {
exact: self.exact,
utc: self.utc.clone(),
local: self.local.clone(),
offset: self.offset.clone(),
zoned: self.zoned,
}
}
}
impl<Db> PartialEq for SqlLocalTimestampComparison<Db> {
fn eq(&self, other: &Self) -> bool {
self.exact == other.exact
&& self.utc == other.utc
&& self.local == other.local
&& self.offset == other.offset
&& self.zoned == other.zoned
}
}
impl<Db> ToDatabaseComparison<LocalTimestamp, Db> for LocalTimestampFilter
where
Db: sqlx::Database
+ BindCeiling
+ for<'q> Backend<Builder<'q> = SqlConjunction<'q, Db>, Error = SqlLoweringError, Buffer: Display>,
bool: Carrier<Db>,
i32: Carrier<Db>,
i64: Carrier<Db>,
StoredLocal: Carrier<Db>,
Temporal<i32>: Carrier<Db>,
for<'a> &'a str: sqlx::Encode<'a, Db> + sqlx::Type<Db>,
{
type Comparison = SqlLocalTimestampComparison<Db>;
}
impl<Db> TryFromFilter<LocalTimestampFilter> for SqlLocalTimestampComparison<Db> {
type Error = core::convert::Infallible;
fn try_from_filter(filter: LocalTimestampFilter) -> Result<Self, Self::Error> {
let LocalTimestampFilter {
exact,
eq,
ne,
in_,
not_in,
gt,
gte,
lt,
lte,
local,
offset,
zoned,
} = filter;
let local = local.unwrap_or_default();
let offset = offset.unwrap_or_default();
let mut utc = crate::ScalarFilter::<i64>::new();
utc.update_eq(eq.map(nanos_of));
utc.update_ne(ne.map(nanos_of));
utc.update_gt(gt.map(nanos_of));
utc.update_gte(gte.map(nanos_of));
utc.update_lt(lt.map(nanos_of));
utc.update_lte(lte.map(nanos_of));
utc.update_in_(in_.as_deref().map(positions));
utc.update_not_in(not_in.as_deref().map(positions));
let exact = exact.map(|operand| Stored {
local: Temporal::from(operand.local()),
seconds: operand.offset().map_or(0, |offset| offset.seconds()),
stated: operand.is_zoned(),
});
Ok(Self {
exact,
utc: infallible(SqlScalarComparison::try_from_filter(utc)),
local: infallible(SqlScalarComparison::try_from_filter(local)),
offset: infallible(SqlScalarComparison::try_from_filter(offset)),
zoned,
})
}
}
fn nanos_of(operand: crate::Timestamp) -> i64 {
let nanos = operand.get().as_nanosecond();
if nanos > i128::from(i64::MAX) {
i64::MAX
} else if nanos < i128::from(i64::MIN) {
i64::MIN
} else {
nanos as i64
}
}
fn positions(operands: &[crate::Timestamp]) -> Box<[i64]> {
operands.iter().copied().map(nanos_of).collect()
}
fn infallible<T>(crossed: Result<T, core::convert::Infallible>) -> T {
match crossed {
Ok(crossed) => crossed,
Err(never) => match never {},
}
}