Actually ergonomic timestamp options (#6247)

Signed-off-by: Nicholas Gates <nick@nickgates.com>

Author: gatesn

vortex-array/src/arrays/datetime/test.rs

@@ -161,7 +161,7 @@ fn test_timestamp() {
             );
             assert_eq!(
                 temporal_array.temporal_metadata(),
-                TemporalMetadata::Timestamp((&unit, &tz))
+                TemporalMetadata::Timestamp(&unit, &tz)
             );
         }
     }

vortex-array/src/arrow/executor/temporal.rs

@@ -76,7 +76,7 @@ pub(super) fn to_arrow_temporal(
             DataType::Time64(ArrowTimeUnit::Nanosecond),
         ) => to_temporal::<Time64NanosecondType>(array, ctx),
 
-        (TemporalMetadata::Timestamp((unit, tz)), DataType::Timestamp(arrow_unit, arrow_tz)) => {
+        (TemporalMetadata::Timestamp(unit, tz), DataType::Timestamp(arrow_unit, arrow_tz)) => {
             vortex_ensure!(
                 tz == arrow_tz,
                 "Cannot convert {} array to Arrow type {} due to timezone mismatch",

vortex-datafusion/src/convert/scalars.rs

@@ -125,7 +125,7 @@ impl TryToDataFusion<ScalarValue> for Scalar {
                 // temporal physical types.
                 let pv = storage_scalar.as_primitive();
                 match temporal {
-                    TemporalMetadata::Timestamp((unit, tz)) => match unit {
+                    TemporalMetadata::Timestamp(unit, tz) => match unit {
                         TimeUnit::Nanoseconds => {
                             ScalarValue::TimestampNanosecond(pv.as_::<i64>(), tz.clone())
                         }

vortex-dtype/src/arrow.rs

@@ -301,7 +301,7 @@ impl DType {
                 // Try and match against the known extension DTypes.
                 if let Some(temporal) = ext_dtype.metadata_opt::<AnyTemporal>() {
                     return Ok(match temporal {
-                        TemporalMetadata::Timestamp((unit, tz)) => {
+                        TemporalMetadata::Timestamp(unit, tz) => {
                             DataType::Timestamp(ArrowTimeUnit::try_from(*unit)?, tz.clone())
                         }
                         TemporalMetadata::Date(unit) => match unit {

vortex-dtype/src/datetime/matcher.rs

@@ -22,7 +22,7 @@ impl Matcher for AnyTemporal {
 
     fn try_match<'a>(item: &'a ExtDTypeRef) -> Option<Self::Match<'a>> {
         if let Some(opts) = item.metadata_opt::<Timestamp>() {
-            return Some(TemporalMetadata::Timestamp((&opts.unit, &opts.tz)));
+            return Some(TemporalMetadata::Timestamp(&opts.unit, &opts.tz));
         }
         if let Some(opts) = item.metadata_opt::<Date>() {
             return Some(TemporalMetadata::Date(opts));
@@ -38,7 +38,7 @@ impl Matcher for AnyTemporal {
 #[derive(Debug, PartialEq, Eq)]
 pub enum TemporalMetadata<'a> {
     /// Metadata for Timestamp dtypes, a tuple of time unit and optional timezone.
-    Timestamp((&'a TimeUnit, &'a Option<Arc<str>>)),
+    Timestamp(&'a TimeUnit, &'a Option<Arc<str>>),
     /// Metadata for Date dtypes
     Date(&'a <Date as ExtDTypeVTable>::Metadata),
     /// Metadata for Time dtypes
@@ -53,7 +53,7 @@ impl TemporalMetadata<'_> {
         match self {
             TemporalMetadata::Time(unit) => **unit,
             TemporalMetadata::Date(unit) => **unit,
-            TemporalMetadata::Timestamp((unit, _tz)) => **unit,
+            TemporalMetadata::Timestamp(unit, _tz) => **unit,
         }
     }
 
@@ -66,7 +66,7 @@ impl TemporalMetadata<'_> {
             TemporalMetadata::Date(unit) => Ok(TemporalJiff::Date(
                 jiff::civil::Date::new(1970, 1, 1)?.checked_add(unit.to_jiff_span(v)?)?,
             )),
-            TemporalMetadata::Timestamp((unit, tz)) => match tz {
+            TemporalMetadata::Timestamp(unit, tz) => match tz {
                 None => Ok(TemporalJiff::Unzoned(
                     jiff::civil::DateTime::new(1970, 1, 1, 0, 0, 0, 0)?
                         .checked_add(unit.to_jiff_span(v)?)?,

vortex-duckdb/src/convert/dtype.rs

@@ -235,14 +235,14 @@ impl TryFrom<&DType> for LogicalType {
                 };
 
                 match temporal {
-                    TemporalMetadata::Timestamp((unit, None)) => match unit {
+                    TemporalMetadata::Timestamp(unit, None) => match unit {
                         TimeUnit::Nanoseconds => DUCKDB_TYPE::DUCKDB_TYPE_TIMESTAMP_NS,
                         TimeUnit::Microseconds => DUCKDB_TYPE::DUCKDB_TYPE_TIMESTAMP,
                         TimeUnit::Milliseconds => DUCKDB_TYPE::DUCKDB_TYPE_TIMESTAMP_MS,
                         TimeUnit::Seconds => DUCKDB_TYPE::DUCKDB_TYPE_TIMESTAMP_S,
                         _ => vortex_bail!("Invalid TimeUnit {} for timestamp", unit),
                     },
-                    TemporalMetadata::Timestamp((unit, Some(tz))) => {
+                    TemporalMetadata::Timestamp(unit, Some(tz)) => {
                         if tz.as_ref() != "UTC" {
                             vortex_bail!("Invalid timezone for timestamp_tz {tz}, must be UTC");
                         }

vortex-duckdb/src/convert/scalar.rs

@@ -182,7 +182,7 @@ impl ToDuckDBScalar for ExtScalar<'_> {
         };
 
         Ok(match temporal {
-            TemporalMetadata::Timestamp((unit, tz)) => {
+            TemporalMetadata::Timestamp(unit, tz) => {
                 if let Some(tz) = tz.as_ref() {
                     if tz.as_ref() != "UTC" {
                         // TODO(ngates): we should convert into UTC as DuckDB does internally.

vortex-scalar/src/arrow/mod.rs

@@ -133,7 +133,7 @@ impl TryFrom<&Scalar> for Arc<dyn Datum> {
                     .ok_or_else(|| vortex_err!("Expected primitive scalar"))?;
 
                 match temporal {
-                    TemporalMetadata::Timestamp((unit, tz)) => {
+                    TemporalMetadata::Timestamp(unit, tz) => {
                         let value = primitive.as_::<i64>();
                         match unit {
                             TimeUnit::Nanoseconds => {