use core::fmt::{self, Display};
use crate::{
At, Backend, BindCeiling, Carrier, ComplexComparison, CompositeComparison, ScalarFilter,
ToDatabaseComparison, TryFromFilter,
comparison::sql::{SqlConjunction, SqlLoweringError, SqlScalarComparison, push_column},
};
use super::{
super::{
NanosecondOverflow, SqlTimebaseComparison, Timebase, TimebaseCrossingError,
timebase::{TIMEBASE_DEN, TIMEBASE_NUM},
},
MediaTimestamp, MediaTimestampFilter,
storage::{NANOS, PTS, SEGMENTS, TIMEBASE},
};
#[cfg(all(test, feature = "postgres"))]
mod tests;
pub struct SqlMediaTimestampComparison<Db> {
exact: Option<Encoding>,
nanos: SqlScalarComparison<i64, Db>,
pts: SqlScalarComparison<i64, Db>,
timebase: SqlTimebaseComparison<Db>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
struct Encoding {
pts: i64,
num: i32,
den: i32,
}
impl<Db> SqlMediaTimestampComparison<Db> {
#[inline]
pub const fn new() -> Self {
Self {
exact: None,
nanos: SqlScalarComparison::new(),
pts: SqlScalarComparison::new(),
timebase: SqlTimebaseComparison::new(),
}
}
#[inline]
pub const fn exact(&self) -> Option<(i64, i32, i32)> {
match self.exact {
Some(Encoding { pts, num, den }) => Some((pts, num, den)),
None => None,
}
}
#[inline]
pub const fn nanos(&self) -> &SqlScalarComparison<i64, Db> {
&self.nanos
}
#[inline]
pub const fn pts(&self) -> &SqlScalarComparison<i64, Db> {
&self.pts
}
#[inline]
pub const fn timebase(&self) -> &SqlTimebaseComparison<Db> {
&self.timebase
}
#[inline]
pub const fn is_empty(&self) -> bool {
self.exact.is_none() && self.nanos.is_empty() && self.pts.is_empty() && self.timebase.is_empty()
}
#[inline]
pub const fn conjuncts(&self) -> usize {
self.exact.is_some() as usize * 3
+ self.nanos.conjuncts()
+ self.pts.conjuncts()
+ self.timebase.conjuncts()
}
}
impl<Db> ComplexComparison<Db> for SqlMediaTimestampComparison<Db>
where
Db: sqlx::Database
+ BindCeiling
+ for<'q> Backend<Builder<'q> = SqlConjunction<'q, Db>, Error = SqlLoweringError, Buffer: Display>,
i32: Carrier<Db>,
i64: 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(Encoding { pts, num, den }) = self.exact {
equals::<Db, i64>(&mut builder, at.frame(PTS).at(), pts);
let timebase = at.frame(TIMEBASE);
equals::<Db, i32>(&mut builder, timebase.at().frame(TIMEBASE_NUM).at(), num);
equals::<Db, i32>(&mut builder, timebase.at().frame(TIMEBASE_DEN).at(), den);
}
let pts = at.frame(PTS);
let builder = self.pts.apply(pts.at(), builder)?;
let timebase = at.frame(TIMEBASE);
let builder = self.timebase.apply(timebase.at(), builder)?;
let nanos = at.frame(NANOS);
self.nanos.apply(nanos.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 SqlMediaTimestampComparison<Db>
where
Db: sqlx::Database
+ BindCeiling
+ for<'q> Backend<Builder<'q> = SqlConjunction<'q, Db>, Error = SqlLoweringError, Buffer: Display>,
i32: Carrier<Db>,
i64: Carrier<Db>,
for<'a> &'a str: sqlx::Encode<'a, Db> + sqlx::Type<Db>,
{
const SEGMENTS: &'static [crate::ColumnShape] = SEGMENTS;
}
impl<Db> Default for SqlMediaTimestampComparison<Db> {
#[inline]
fn default() -> Self {
Self::new()
}
}
impl<Db> fmt::Debug for SqlMediaTimestampComparison<Db> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("SqlMediaTimestampComparison")
.field("exact", &self.exact)
.field("nanos", &self.nanos)
.field("pts", &self.pts)
.field("timebase", &self.timebase)
.finish()
}
}
impl<Db> Clone for SqlMediaTimestampComparison<Db> {
fn clone(&self) -> Self {
Self {
exact: self.exact,
nanos: self.nanos.clone(),
pts: self.pts.clone(),
timebase: self.timebase.clone(),
}
}
}
impl<Db> PartialEq for SqlMediaTimestampComparison<Db> {
fn eq(&self, other: &Self) -> bool {
self.exact == other.exact
&& self.nanos == other.nanos
&& self.pts == other.pts
&& self.timebase == other.timebase
}
}
impl<Db> ToDatabaseComparison<i64, Db> for MediaTimestampFilter
where
Db: sqlx::Database
+ BindCeiling
+ for<'q> Backend<Builder<'q> = SqlConjunction<'q, Db>, Error = SqlLoweringError, Buffer: Display>,
i32: Carrier<Db>,
i64: Carrier<Db>,
for<'a> &'a str: sqlx::Encode<'a, Db> + sqlx::Type<Db>,
{
type Comparison = SqlMediaTimestampComparison<Db>;
}
impl<Db> ToDatabaseComparison<MediaTimestamp, Db> for MediaTimestampFilter
where
Db: sqlx::Database
+ BindCeiling
+ for<'q> Backend<Builder<'q> = SqlConjunction<'q, Db>, Error = SqlLoweringError, Buffer: Display>,
i32: Carrier<Db>,
i64: Carrier<Db>,
for<'a> &'a str: sqlx::Encode<'a, Db> + sqlx::Type<Db>,
{
type Comparison = SqlMediaTimestampComparison<Db>;
}
impl<Db> TryFromFilter<MediaTimestampFilter> for SqlMediaTimestampComparison<Db> {
type Error = MediaTimestampCrossingError;
fn try_from_filter(filter: MediaTimestampFilter) -> Result<Self, Self::Error> {
let MediaTimestampFilter {
exact,
eq,
ne,
in_,
not_in,
gt,
gte,
lt,
lte,
pts,
timebase,
} = filter;
let pts = pts.unwrap_or_default();
let timebase = timebase.unwrap_or_default();
let mut nanos = ScalarFilter::<i64>::new();
nanos.update_eq(position(eq)?);
nanos.update_ne(position(ne)?);
nanos.update_gt(position(gt.map(MediaTimestamp::from))?);
nanos.update_gte(position(gte.map(MediaTimestamp::from))?);
nanos.update_lt(position(lt.map(MediaTimestamp::from))?);
nanos.update_lte(position(lte.map(MediaTimestamp::from))?);
nanos.update_in_(positions(in_)?);
nanos.update_not_in(positions(not_in)?);
let exact = exact.map(|operand| {
let (num, den) = Timebase::new(operand.get().timebase()).reduced();
Encoding {
pts: operand.get().pts(),
num,
den: den.get(),
}
});
Ok(Self {
exact,
nanos: infallible(SqlScalarComparison::try_from_filter(nanos)),
pts: infallible(SqlScalarComparison::try_from_filter(pts)),
timebase: SqlTimebaseComparison::try_from_filter(timebase)
.map_err(MediaTimestampCrossingError::Timebase)?,
})
}
}
fn position(operand: Option<MediaTimestamp>) -> Result<Option<i64>, MediaTimestampCrossingError> {
operand
.map(|operand| operand.to_nanos())
.transpose()
.map_err(MediaTimestampCrossingError::Overflow)
}
fn positions(
operands: Option<Box<[MediaTimestamp]>>,
) -> Result<Option<Box<[i64]>>, MediaTimestampCrossingError> {
operands
.map(|operands| {
operands
.iter()
.map(|operand| operand.to_nanos())
.collect::<Result<Box<[i64]>, _>>()
.map_err(MediaTimestampCrossingError::Overflow)
})
.transpose()
}
fn infallible<T>(crossed: Result<T, core::convert::Infallible>) -> T {
match crossed {
Ok(crossed) => crossed,
Err(never) => match never {},
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum MediaTimestampCrossingError {
Overflow(NanosecondOverflow),
Timebase(TimebaseCrossingError),
}
impl fmt::Display for MediaTimestampCrossingError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Overflow(overflow) => overflow.fmt(f),
Self::Timebase(timebase) => timebase.fmt(f),
}
}
}
impl core::error::Error for MediaTimestampCrossingError {
fn source(&self) -> Option<&(dyn core::error::Error + 'static)> {
match self {
Self::Overflow(overflow) => Some(overflow),
Self::Timebase(timebase) => Some(timebase),
}
}
}