use core::fmt::{self, Display};
use crate::{
At, Backend, BindCeiling, Carrier, ComplexComparison, CompositeComparison, FieldName,
ToDatabaseComparison, TryFromFilter,
comparison::sql::{
SqlConjunction, SqlLoweringError, SqlScalarComparison, push_column, render_column,
},
};
use super::{
super::{
MediaTimestamp, NanosecondOverflow, SqlTimebaseComparison, Timebase, TimebaseCrossingError,
timebase::{TIMEBASE_DEN, TIMEBASE_NUM},
},
MediaContained, MediaTimeRange, MediaTimeRangeFilter,
storage::{END_NANOS, END_PTS, SEGMENTS, START_NANOS, START_PTS, TIMEBASE},
};
#[cfg(all(test, feature = "postgres"))]
mod tests;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
enum ContainedNanos {
Instant(i64),
Span(i64, i64),
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
struct Encoding {
start: i64,
end: i64,
num: i32,
den: i32,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
struct DurationNanos {
gt: Option<i64>,
gte: Option<i64>,
lt: Option<i64>,
lte: Option<i64>,
}
impl DurationNanos {
const fn is_empty(&self) -> bool {
self.gt.is_none() && self.gte.is_none() && self.lt.is_none() && self.lte.is_none()
}
const fn conjuncts(&self) -> usize {
self.gt.is_some() as usize
+ self.gte.is_some() as usize
+ self.lt.is_some() as usize
+ self.lte.is_some() as usize
}
}
pub struct SqlMediaTimeRangeComparison<Db> {
exact: Option<Encoding>,
contains: Option<ContainedNanos>,
overlaps: Option<(i64, i64)>,
within: Option<(i64, i64)>,
before: Option<i64>,
after: Option<i64>,
duration: DurationNanos,
start_pts: SqlScalarComparison<i64, Db>,
end_pts: SqlScalarComparison<i64, Db>,
timebase: SqlTimebaseComparison<Db>,
}
impl<Db> SqlMediaTimeRangeComparison<Db> {
#[inline]
pub const fn new() -> Self {
Self {
exact: None,
contains: None,
overlaps: None,
within: None,
before: None,
after: None,
duration: DurationNanos {
gt: None,
gte: None,
lt: None,
lte: None,
},
start_pts: SqlScalarComparison::new(),
end_pts: SqlScalarComparison::new(),
timebase: SqlTimebaseComparison::new(),
}
}
#[inline]
pub const fn exact(&self) -> Option<(i64, i64, i32, i32)> {
match self.exact {
Some(Encoding {
start,
end,
num,
den,
}) => Some((start, end, num, den)),
None => None,
}
}
#[inline]
pub const fn start_pts(&self) -> &SqlScalarComparison<i64, Db> {
&self.start_pts
}
#[inline]
pub const fn end_pts(&self) -> &SqlScalarComparison<i64, Db> {
&self.end_pts
}
#[inline]
pub const fn timebase(&self) -> &SqlTimebaseComparison<Db> {
&self.timebase
}
#[inline]
pub const fn is_empty(&self) -> bool {
self.exact.is_none()
&& self.contains.is_none()
&& self.overlaps.is_none()
&& self.within.is_none()
&& self.before.is_none()
&& self.after.is_none()
&& self.duration.is_empty()
&& self.start_pts.is_empty()
&& self.end_pts.is_empty()
&& self.timebase.is_empty()
}
#[inline]
pub const fn conjuncts(&self) -> usize {
self.exact.is_some() as usize * 4
+ self.contains.is_some() as usize * 2
+ self.overlaps.is_some() as usize * 2
+ self.within.is_some() as usize * 2
+ self.before.is_some() as usize
+ self.after.is_some() as usize
+ self.duration.conjuncts()
+ self.start_pts.conjuncts()
+ self.end_pts.conjuncts()
+ self.timebase.conjuncts()
}
}
fn endpoint<'q, Db>(
builder: &mut SqlConjunction<'q, Db>,
at: At<'_>,
segment: &'static FieldName,
operator: &'static str,
operand: i64,
) where
Db: sqlx::Database + Backend<Buffer: Display>,
i64: Carrier<Db>,
{
let frame = at.frame(segment);
let qb = builder.open();
push_column(qb, frame.at());
qb.push(operator);
<i64 as Carrier<Db>>::push_bind(&operand, qb);
}
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> ComplexComparison<Db> for SqlMediaTimeRangeComparison<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<'_>,
mut builder: Db::Builder<'q>,
) -> Result<Db::Builder<'q>, Db::Error> {
if let Some(Encoding {
start,
end,
num,
den,
}) = self.exact
{
equals::<Db, i64>(&mut builder, at.frame(START_PTS).at(), start);
equals::<Db, i64>(&mut builder, at.frame(END_PTS).at(), end);
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);
}
match self.contains {
Some(ContainedNanos::Instant(instant)) => {
endpoint(&mut builder, at, START_NANOS, " <= ", instant);
endpoint(&mut builder, at, END_NANOS, " > ", instant);
}
Some(ContainedNanos::Span(start, end)) => {
endpoint(&mut builder, at, START_NANOS, " <= ", start);
endpoint(&mut builder, at, END_NANOS, " >= ", end);
}
None => {}
}
if let Some((start, end)) = self.overlaps {
endpoint(&mut builder, at, START_NANOS, " < ", end);
endpoint(&mut builder, at, END_NANOS, " > ", start);
}
if let Some((start, end)) = self.within {
endpoint(&mut builder, at, START_NANOS, " >= ", start);
endpoint(&mut builder, at, END_NANOS, " <= ", end);
}
if let Some(before) = self.before {
endpoint(&mut builder, at, END_NANOS, " <= ", before);
}
if let Some(after) = self.after {
endpoint(&mut builder, at, START_NANOS, " >= ", after);
}
if !self.duration.is_empty() {
let start = render_column::<Db>(at.frame(START_NANOS).at());
let end = render_column::<Db>(at.frame(END_NANOS).at());
for (operator, operand) in [
(" > ", self.duration.gt),
(" >= ", self.duration.gte),
(" < ", self.duration.lt),
(" <= ", self.duration.lte),
] {
let Some(operand) = operand else {
continue;
};
let qb = builder.open();
qb.push("(");
qb.push(&end);
qb.push(" - ");
qb.push(&start);
qb.push(")");
qb.push(operator);
<i64 as Carrier<Db>>::push_bind(&operand, qb);
}
}
let start_pts = at.frame(START_PTS);
let builder = self.start_pts.apply(start_pts.at(), builder)?;
let end_pts = at.frame(END_PTS);
let builder = self.end_pts.apply(end_pts.at(), builder)?;
let timebase = at.frame(TIMEBASE);
self.timebase.apply(timebase.at(), builder)
}
}
impl<Db> CompositeComparison<Db> for SqlMediaTimeRangeComparison<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 SqlMediaTimeRangeComparison<Db> {
#[inline]
fn default() -> Self {
Self::new()
}
}
impl<Db> fmt::Debug for SqlMediaTimeRangeComparison<Db> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("SqlMediaTimeRangeComparison")
.field("exact", &self.exact)
.field("contains", &self.contains)
.field("overlaps", &self.overlaps)
.field("within", &self.within)
.field("before", &self.before)
.field("after", &self.after)
.field("duration", &self.duration)
.field("start_pts", &self.start_pts)
.field("end_pts", &self.end_pts)
.field("timebase", &self.timebase)
.finish()
}
}
impl<Db> Clone for SqlMediaTimeRangeComparison<Db> {
fn clone(&self) -> Self {
Self {
exact: self.exact,
contains: self.contains,
overlaps: self.overlaps,
within: self.within,
before: self.before,
after: self.after,
duration: self.duration,
start_pts: self.start_pts.clone(),
end_pts: self.end_pts.clone(),
timebase: self.timebase.clone(),
}
}
}
impl<Db> PartialEq for SqlMediaTimeRangeComparison<Db> {
fn eq(&self, other: &Self) -> bool {
self.exact == other.exact
&& self.contains == other.contains
&& self.overlaps == other.overlaps
&& self.within == other.within
&& self.before == other.before
&& self.after == other.after
&& self.duration == other.duration
&& self.start_pts == other.start_pts
&& self.end_pts == other.end_pts
&& self.timebase == other.timebase
}
}
impl<Db> ToDatabaseComparison<i64, Db> for MediaTimeRangeFilter
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 = SqlMediaTimeRangeComparison<Db>;
}
impl<Db> ToDatabaseComparison<MediaTimeRange, Db> for MediaTimeRangeFilter
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 = SqlMediaTimeRangeComparison<Db>;
}
impl<Db> TryFromFilter<MediaTimeRangeFilter> for SqlMediaTimeRangeComparison<Db> {
type Error = MediaTimeRangeCrossingError;
fn try_from_filter(filter: MediaTimeRangeFilter) -> Result<Self, Self::Error> {
let MediaTimeRangeFilter {
exact,
contains,
overlaps,
within,
before,
after,
duration,
start_pts,
end_pts,
timebase,
} = filter;
let duration = duration.unwrap_or_default();
let start_pts = start_pts.unwrap_or_default();
let end_pts = end_pts.unwrap_or_default();
let timebase = timebase.unwrap_or_default();
let contains = match contains.map(MediaContained::from) {
Some(MediaContained::Instant(instant)) => Some(ContainedNanos::Instant(position(instant)?)),
Some(MediaContained::Span(span)) => {
let (start, end) = endpoints(span)?;
Some(ContainedNanos::Span(start, end))
}
None => None,
};
let exact = exact.map(MediaTimeRange::from).map(|operand| {
let (num, den) = Timebase::new(operand.get().timebase()).reduced();
Encoding {
start: operand.get().start_pts(),
end: operand.get().end_pts(),
num,
den: den.get(),
}
});
Ok(Self {
exact,
contains,
overlaps: overlaps.map(endpoints).transpose()?,
within: within.map(endpoints).transpose()?,
before: before.map(MediaTimestamp::from).map(position).transpose()?,
after: after.map(MediaTimestamp::from).map(position).transpose()?,
duration: DurationNanos {
gt: length(duration.gt().copied().map(mediatime::SignedDuration::from))?,
gte: length(duration.gte().copied().map(mediatime::SignedDuration::from))?,
lt: length(duration.lt().copied().map(mediatime::SignedDuration::from))?,
lte: length(duration.lte().copied().map(mediatime::SignedDuration::from))?,
},
start_pts: infallible(SqlScalarComparison::try_from_filter(start_pts)),
end_pts: infallible(SqlScalarComparison::try_from_filter(end_pts)),
timebase: SqlTimebaseComparison::try_from_filter(timebase)
.map_err(MediaTimeRangeCrossingError::Timebase)?,
})
}
}
fn position(operand: MediaTimestamp) -> Result<i64, MediaTimeRangeCrossingError> {
operand
.to_nanos()
.map_err(MediaTimeRangeCrossingError::Overflow)
}
fn endpoints(operand: MediaTimeRange) -> Result<(i64, i64), MediaTimeRangeCrossingError> {
operand
.to_nanos()
.map_err(MediaTimeRangeCrossingError::Overflow)
}
fn length(
operand: Option<mediatime::SignedDuration>,
) -> Result<Option<i64>, MediaTimeRangeCrossingError> {
operand
.map(|operand| {
operand
.checked_rescale_to(mediatime::Timebase::NANOS)
.map(|nanos| nanos.ticks())
.ok_or(MediaTimeRangeCrossingError::DurationOverflow)
})
.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 MediaTimeRangeCrossingError {
Overflow(NanosecondOverflow),
DurationOverflow,
Timebase(TimebaseCrossingError),
}
impl fmt::Display for MediaTimeRangeCrossingError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Overflow(overflow) => overflow.fmt(f),
Self::DurationOverflow => {
f.write_str("a length longer than 292 years does not fit i64 nanoseconds")
}
Self::Timebase(timebase) => timebase.fmt(f),
}
}
}
impl core::error::Error for MediaTimeRangeCrossingError {
fn source(&self) -> Option<&(dyn core::error::Error + 'static)> {
match self {
Self::Overflow(overflow) => Some(overflow),
Self::Timebase(timebase) => Some(timebase),
Self::DurationOverflow => None,
}
}
}