@@ -91,20 +91,44 @@ pub enum TimestampValue<'a> {
9191
9292impl fmt:: Display for TimestampValue < ' _ > {
9393 fn fmt ( & self , f : & mut fmt:: Formatter < ' _ > ) -> fmt:: Result {
94- let ( span, tz) = match self {
95- TimestampValue :: Seconds ( v, tz) => ( Span :: new ( ) . seconds ( * v) , * tz) ,
96- TimestampValue :: Milliseconds ( v, tz) => ( Span :: new ( ) . milliseconds ( * v) , * tz) ,
97- TimestampValue :: Microseconds ( v, tz) => ( Span :: new ( ) . microseconds ( * v) , * tz) ,
98- TimestampValue :: Nanoseconds ( v, tz) => ( Span :: new ( ) . nanoseconds ( * v) , * tz) ,
94+ let ( span, raw, unit, tz) = match self {
95+ TimestampValue :: Seconds ( v, tz) => {
96+ ( Span :: new ( ) . try_seconds ( * v) , * v, TimeUnit :: Seconds , * tz)
97+ }
98+ TimestampValue :: Milliseconds ( v, tz) => (
99+ Span :: new ( ) . try_milliseconds ( * v) ,
100+ * v,
101+ TimeUnit :: Milliseconds ,
102+ * tz,
103+ ) ,
104+ TimestampValue :: Microseconds ( v, tz) => (
105+ Span :: new ( ) . try_microseconds ( * v) ,
106+ * v,
107+ TimeUnit :: Microseconds ,
108+ * tz,
109+ ) ,
110+ TimestampValue :: Nanoseconds ( v, tz) => (
111+ Span :: new ( ) . try_nanoseconds ( * v) ,
112+ * v,
113+ TimeUnit :: Nanoseconds ,
114+ * tz,
115+ ) ,
116+ } ;
117+
118+ let Some ( ts) = span
119+ . ok ( )
120+ . and_then ( |span| jiff:: Timestamp :: UNIX_EPOCH . checked_add ( span) . ok ( ) )
121+ else {
122+ // storage values may exceed jiff's Timestamp range
123+ return write ! ( f, "{raw}{unit} since Unix epoch" ) ;
99124 } ;
100- let ts = jiff:: Timestamp :: UNIX_EPOCH + span;
101125
102126 match tz {
103127 None => write ! ( f, "{ts}" ) ,
104- Some ( tz) => {
105- let adjusted_ts = ts . in_tz ( tz . as_ref ( ) ) . vortex_expect ( "unknown timezone" ) ;
106- write ! ( f, "{adjusted_ts}" , )
107- }
128+ Some ( tz) => match ts . in_tz ( tz . as_ref ( ) ) {
129+ Ok ( adjusted_ts) => write ! ( f , "{adjusted_ts}" ) ,
130+ Err ( _ ) => write ! ( f, "{ts}" ) ,
131+ } ,
108132 }
109133 }
110134}
@@ -226,37 +250,18 @@ impl ExtVTable for Timestamp {
226250 let ts_value = storage_value. as_primitive ( ) . cast :: < i64 > ( ) ?;
227251 let tz = metadata. tz . as_ref ( ) ;
228252
229- let ( span, value) = match metadata. unit {
230- TimeUnit :: Nanoseconds => (
231- Span :: new ( ) . nanoseconds ( ts_value) ,
232- TimestampValue :: Nanoseconds ( ts_value, tz) ,
233- ) ,
234- TimeUnit :: Microseconds => (
235- Span :: new ( ) . microseconds ( ts_value) ,
236- TimestampValue :: Microseconds ( ts_value, tz) ,
237- ) ,
238- TimeUnit :: Milliseconds => (
239- Span :: new ( ) . milliseconds ( ts_value) ,
240- TimestampValue :: Milliseconds ( ts_value, tz) ,
241- ) ,
242- TimeUnit :: Seconds => (
243- Span :: new ( ) . seconds ( ts_value) ,
244- TimestampValue :: Seconds ( ts_value, tz) ,
245- ) ,
246- TimeUnit :: Days => vortex_bail ! ( "Timestamp does not support Days time unit" ) ,
247- } ;
248-
249- // Validate the storage value is within the valid range for Timestamp.
250- let ts = jiff:: Timestamp :: UNIX_EPOCH
251- . checked_add ( span)
252- . map_err ( |e| vortex_err ! ( "Invalid timestamp scalar: {}" , e) ) ?;
253-
254253 if let Some ( tz) = tz {
255- ts . in_tz ( tz. as_ref ( ) )
254+ jiff :: tz :: TimeZone :: get ( tz. as_ref ( ) )
256255 . map_err ( |e| vortex_err ! ( "Invalid timezone for timestamp scalar: {}" , e) ) ?;
257256 }
258257
259- Ok ( value)
258+ Ok ( match metadata. unit {
259+ TimeUnit :: Nanoseconds => TimestampValue :: Nanoseconds ( ts_value, tz) ,
260+ TimeUnit :: Microseconds => TimestampValue :: Microseconds ( ts_value, tz) ,
261+ TimeUnit :: Milliseconds => TimestampValue :: Milliseconds ( ts_value, tz) ,
262+ TimeUnit :: Seconds => TimestampValue :: Seconds ( ts_value, tz) ,
263+ TimeUnit :: Days => vortex_bail ! ( "Timestamp does not support Days time unit" ) ,
264+ } )
260265 }
261266}
262267
@@ -282,6 +287,17 @@ mod tests {
282287 Ok ( ( ) )
283288 }
284289
290+ #[ test]
291+ fn validate_timestamp_scalar_beyond_jiff_range ( ) -> VortexResult < ( ) > {
292+ let dtype = DType :: Extension ( Timestamp :: new ( TimeUnit :: Microseconds , Nullable ) . erased ( ) ) ;
293+ Scalar :: try_new (
294+ dtype,
295+ Some ( ScalarValue :: Primitive ( PValue :: I64 ( 253_402_214_400_000_000 ) ) ) ,
296+ ) ?;
297+
298+ Ok ( ( ) )
299+ }
300+
285301 #[ cfg_attr( miri, ignore) ]
286302 #[ test]
287303 fn reject_timestamp_with_invalid_timezone ( ) {
@@ -321,6 +337,20 @@ mod tests {
321337 ) ;
322338 }
323339
340+ #[ cfg_attr( miri, ignore) ]
341+ #[ test]
342+ fn display_timestamp_scalar_beyond_jiff_range ( ) {
343+ let dtype = DType :: Extension ( Timestamp :: new ( TimeUnit :: Microseconds , Nullable ) . erased ( ) ) ;
344+ let scalar = Scalar :: new (
345+ dtype,
346+ Some ( ScalarValue :: Primitive ( PValue :: I64 ( 253_402_214_400_000_000 ) ) ) ,
347+ ) ;
348+ assert_eq ! (
349+ format!( "{}" , scalar. as_extension( ) ) ,
350+ "253402214400000000µs since Unix epoch"
351+ ) ;
352+ }
353+
324354 #[ test]
325355 fn least_supertype_timestamp_units ( ) {
326356 use crate :: dtype:: Nullability :: NonNullable ;
0 commit comments