use std::fmt;
use vortex_error::VortexExpect;
use vortex_error::VortexResult;
use vortex_error::vortex_bail;
use vortex_error::vortex_ensure;
use vortex_error::vortex_ensure_eq;
use vortex_error::vortex_err;
use vortex_session::registry::CachedId;
use crate::dtype::DType;
use crate::dtype::Nullability;
use crate::dtype::PType;
use crate::dtype::extension::ExtDType;
use crate::dtype::extension::ExtId;
use crate::dtype::extension::ExtVTable;
use crate::extension::datetime::TimeUnit;
use crate::scalar::ScalarValue;
const EPOCH: jiff::civil::Date = jiff::civil::Date::constant(1970, 1, 1);
#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
pub struct Date;
fn date_ptype(time_unit: &TimeUnit) -> Option<PType> {
match time_unit {
TimeUnit::Nanoseconds => None,
TimeUnit::Microseconds => None,
TimeUnit::Milliseconds => Some(PType::I64),
TimeUnit::Seconds => None,
TimeUnit::Days => Some(PType::I32),
}
}
impl Date {
pub fn try_new(time_unit: TimeUnit, nullability: Nullability) -> VortexResult<ExtDType<Self>> {
let ptype = date_ptype(&time_unit)
.ok_or_else(|| vortex_err!("Date type does not support time unit {}", time_unit))?;
ExtDType::try_new(time_unit, DType::Primitive(ptype, nullability))
}
pub fn new(time_unit: TimeUnit, nullability: Nullability) -> ExtDType<Self> {
Self::try_new(time_unit, nullability).vortex_expect("failed to create date dtype")
}
}
pub enum DateValue {
Days(i32),
Milliseconds(i64),
}
impl fmt::Display for DateValue {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let (unit, value) = match *self {
DateValue::Days(days) => (TimeUnit::Days, i64::from(days)),
DateValue::Milliseconds(ms) => (TimeUnit::Milliseconds, ms),
};
let Ok(date) = unit
.to_jiff_span(value)
.and_then(|span| Ok(EPOCH.checked_add(span)?))
else {
return write!(f, "{value}{unit}");
};
write!(f, "{date}")
}
}
impl ExtVTable for Date {
type Metadata = TimeUnit;
type NativeValue<'a> = DateValue;
fn id(&self) -> ExtId {
static ID: CachedId = CachedId::new("vortex.date");
*ID
}
fn serialize_metadata(&self, metadata: &Self::Metadata) -> VortexResult<Vec<u8>> {
Ok(vec![u8::from(*metadata)])
}
fn deserialize_metadata(&self, metadata: &[u8]) -> VortexResult<Self::Metadata> {
vortex_ensure!(!metadata.is_empty(), "Date metadata must not be empty");
let tag = metadata[0];
TimeUnit::try_from(tag)
}
fn validate_dtype(ext_dtype: &ExtDType<Self>) -> VortexResult<()> {
let metadata = ext_dtype.metadata();
let ptype = date_ptype(metadata)
.ok_or_else(|| vortex_err!("Date type does not support time unit {}", metadata))?;
let DType::Primitive(storage_ptype, _) = ext_dtype.storage_dtype() else {
vortex_bail!(
"Date storage dtype must be primitive, got {}",
ext_dtype.storage_dtype()
);
};
vortex_ensure_eq!(*storage_ptype, ptype);
Ok(())
}
fn unpack_native<'a>(
ext_dtype: &'a ExtDType<Self>,
storage_value: &'a ScalarValue,
) -> VortexResult<Self::NativeValue<'a>> {
let metadata = ext_dtype.metadata();
match metadata {
TimeUnit::Milliseconds => Ok(DateValue::Milliseconds(
storage_value.as_primitive().cast::<i64>()?,
)),
TimeUnit::Days => Ok(DateValue::Days(storage_value.as_primitive().cast::<i32>()?)),
_ => vortex_bail!("Date type does not support time unit {}", metadata),
}
}
}
#[cfg(test)]
mod tests {
use rstest::rstest;
use vortex_error::VortexResult;
use crate::dtype::DType;
use crate::dtype::Nullability::Nullable;
use crate::dtype::extension::ExtDType;
use crate::extension::datetime::Date;
use crate::extension::datetime::DateValue;
use crate::extension::datetime::TimeUnit;
use crate::scalar::PValue;
use crate::scalar::Scalar;
use crate::scalar::ScalarValue;
#[test]
fn test_reject_non_primitive_storage() {
assert!(ExtDType::<Date>::try_new(TimeUnit::Days, DType::Utf8(Nullable),).is_err());
}
#[test]
fn validate_date_scalar() -> VortexResult<()> {
let days_dtype = DType::Extension(Date::new(TimeUnit::Days, Nullable).erased());
Scalar::try_new(days_dtype, Some(ScalarValue::Primitive(PValue::I32(0))))?;
let ms_dtype = DType::Extension(Date::new(TimeUnit::Milliseconds, Nullable).erased());
Scalar::try_new(
ms_dtype,
Some(ScalarValue::Primitive(PValue::I64(86_400_000))),
)?;
Ok(())
}
#[test]
fn reject_date_with_overflowing_value() {
let dtype = DType::Extension(Date::new(TimeUnit::Days, Nullable).erased());
let result = Scalar::try_new(dtype, Some(ScalarValue::Primitive(PValue::I64(i64::MAX))));
assert!(result.is_err());
}
#[test]
fn display_date_scalar() {
let dtype = DType::Extension(Date::new(TimeUnit::Days, Nullable).erased());
let scalar = Scalar::new(dtype.clone(), Some(ScalarValue::Primitive(PValue::I32(0))));
assert_eq!(format!("{}", scalar.as_extension()), "1970-01-01");
let scalar = Scalar::new(dtype, Some(ScalarValue::Primitive(PValue::I32(365))));
assert_eq!(format!("{}", scalar.as_extension()), "1971-01-01");
}
#[rstest]
#[case::ordinary(DateValue::Milliseconds(86_400_000), "1970-01-02")]
#[case::after_year_9999(DateValue::Days(2_932_897), "2932897days")]
#[case::beyond_jiff_span(DateValue::Days(10_000_000), "10000000days")]
#[case::max_milliseconds(DateValue::Milliseconds(i64::MAX), "9223372036854775807ms")]
fn display_date_value(#[case] value: DateValue, #[case] expected: &str) {
assert_eq!(value.to_string(), expected);
}
#[test]
fn deserialize_empty_metadata_returns_error() {
use crate::dtype::extension::ExtVTable;
let vtable = Date;
assert!(vtable.deserialize_metadata(&[]).is_err());
}
#[test]
fn deserialize_invalid_tag_returns_error() {
use crate::dtype::extension::ExtVTable;
let vtable = Date;
assert!(vtable.deserialize_metadata(&[0xFF]).is_err());
}
}