diff --git a/arrow-array/src/delta.rs b/arrow-array/src/delta.rs index b7efdab0a48..b9b7a11e2d4 100644 --- a/arrow-array/src/delta.rs +++ b/arrow-array/src/delta.rs @@ -105,75 +105,186 @@ mod tests { #[test] fn test_shift_months() { - let base = NaiveDate::from_ymd(2020, 1, 31); - - assert_eq!(shift_months(base, 0), NaiveDate::from_ymd(2020, 1, 31)); - assert_eq!(shift_months(base, 1), NaiveDate::from_ymd(2020, 2, 29)); - assert_eq!(shift_months(base, 2), NaiveDate::from_ymd(2020, 3, 31)); - assert_eq!(shift_months(base, 3), NaiveDate::from_ymd(2020, 4, 30)); - assert_eq!(shift_months(base, 4), NaiveDate::from_ymd(2020, 5, 31)); - assert_eq!(shift_months(base, 5), NaiveDate::from_ymd(2020, 6, 30)); - assert_eq!(shift_months(base, 6), NaiveDate::from_ymd(2020, 7, 31)); - assert_eq!(shift_months(base, 7), NaiveDate::from_ymd(2020, 8, 31)); - assert_eq!(shift_months(base, 8), NaiveDate::from_ymd(2020, 9, 30)); - assert_eq!(shift_months(base, 9), NaiveDate::from_ymd(2020, 10, 31)); - assert_eq!(shift_months(base, 10), NaiveDate::from_ymd(2020, 11, 30)); - assert_eq!(shift_months(base, 11), NaiveDate::from_ymd(2020, 12, 31)); - assert_eq!(shift_months(base, 12), NaiveDate::from_ymd(2021, 1, 31)); - assert_eq!(shift_months(base, 13), NaiveDate::from_ymd(2021, 2, 28)); - - assert_eq!(shift_months(base, -1), NaiveDate::from_ymd(2019, 12, 31)); - assert_eq!(shift_months(base, -2), NaiveDate::from_ymd(2019, 11, 30)); - assert_eq!(shift_months(base, -3), NaiveDate::from_ymd(2019, 10, 31)); - assert_eq!(shift_months(base, -4), NaiveDate::from_ymd(2019, 9, 30)); - assert_eq!(shift_months(base, -5), NaiveDate::from_ymd(2019, 8, 31)); - assert_eq!(shift_months(base, -6), NaiveDate::from_ymd(2019, 7, 31)); - assert_eq!(shift_months(base, -7), NaiveDate::from_ymd(2019, 6, 30)); - assert_eq!(shift_months(base, -8), NaiveDate::from_ymd(2019, 5, 31)); - assert_eq!(shift_months(base, -9), NaiveDate::from_ymd(2019, 4, 30)); - assert_eq!(shift_months(base, -10), NaiveDate::from_ymd(2019, 3, 31)); - assert_eq!(shift_months(base, -11), NaiveDate::from_ymd(2019, 2, 28)); - assert_eq!(shift_months(base, -12), NaiveDate::from_ymd(2019, 1, 31)); - assert_eq!(shift_months(base, -13), NaiveDate::from_ymd(2018, 12, 31)); - - assert_eq!(shift_months(base, 1265), NaiveDate::from_ymd(2125, 6, 30)); + let base = NaiveDate::from_ymd_opt(2020, 1, 31).unwrap(); + + assert_eq!( + shift_months(base, 0), + NaiveDate::from_ymd_opt(2020, 1, 31).unwrap() + ); + assert_eq!( + shift_months(base, 1), + NaiveDate::from_ymd_opt(2020, 2, 29).unwrap() + ); + assert_eq!( + shift_months(base, 2), + NaiveDate::from_ymd_opt(2020, 3, 31).unwrap() + ); + assert_eq!( + shift_months(base, 3), + NaiveDate::from_ymd_opt(2020, 4, 30).unwrap() + ); + assert_eq!( + shift_months(base, 4), + NaiveDate::from_ymd_opt(2020, 5, 31).unwrap() + ); + assert_eq!( + shift_months(base, 5), + NaiveDate::from_ymd_opt(2020, 6, 30).unwrap() + ); + assert_eq!( + shift_months(base, 6), + NaiveDate::from_ymd_opt(2020, 7, 31).unwrap() + ); + assert_eq!( + shift_months(base, 7), + NaiveDate::from_ymd_opt(2020, 8, 31).unwrap() + ); + assert_eq!( + shift_months(base, 8), + NaiveDate::from_ymd_opt(2020, 9, 30).unwrap() + ); + assert_eq!( + shift_months(base, 9), + NaiveDate::from_ymd_opt(2020, 10, 31).unwrap() + ); + assert_eq!( + shift_months(base, 10), + NaiveDate::from_ymd_opt(2020, 11, 30).unwrap() + ); + assert_eq!( + shift_months(base, 11), + NaiveDate::from_ymd_opt(2020, 12, 31).unwrap() + ); + assert_eq!( + shift_months(base, 12), + NaiveDate::from_ymd_opt(2021, 1, 31).unwrap() + ); + assert_eq!( + shift_months(base, 13), + NaiveDate::from_ymd_opt(2021, 2, 28).unwrap() + ); + + assert_eq!( + shift_months(base, -1), + NaiveDate::from_ymd_opt(2019, 12, 31).unwrap() + ); + assert_eq!( + shift_months(base, -2), + NaiveDate::from_ymd_opt(2019, 11, 30).unwrap() + ); + assert_eq!( + shift_months(base, -3), + NaiveDate::from_ymd_opt(2019, 10, 31).unwrap() + ); + assert_eq!( + shift_months(base, -4), + NaiveDate::from_ymd_opt(2019, 9, 30).unwrap() + ); + assert_eq!( + shift_months(base, -5), + NaiveDate::from_ymd_opt(2019, 8, 31).unwrap() + ); + assert_eq!( + shift_months(base, -6), + NaiveDate::from_ymd_opt(2019, 7, 31).unwrap() + ); + assert_eq!( + shift_months(base, -7), + NaiveDate::from_ymd_opt(2019, 6, 30).unwrap() + ); + assert_eq!( + shift_months(base, -8), + NaiveDate::from_ymd_opt(2019, 5, 31).unwrap() + ); + assert_eq!( + shift_months(base, -9), + NaiveDate::from_ymd_opt(2019, 4, 30).unwrap() + ); + assert_eq!( + shift_months(base, -10), + NaiveDate::from_ymd_opt(2019, 3, 31).unwrap() + ); + assert_eq!( + shift_months(base, -11), + NaiveDate::from_ymd_opt(2019, 2, 28).unwrap() + ); + assert_eq!( + shift_months(base, -12), + NaiveDate::from_ymd_opt(2019, 1, 31).unwrap() + ); + assert_eq!( + shift_months(base, -13), + NaiveDate::from_ymd_opt(2018, 12, 31).unwrap() + ); + + assert_eq!( + shift_months(base, 1265), + NaiveDate::from_ymd_opt(2125, 6, 30).unwrap() + ); } #[test] fn test_shift_months_with_overflow() { - let base = NaiveDate::from_ymd(2020, 12, 31); + let base = NaiveDate::from_ymd_opt(2020, 12, 31).unwrap(); assert_eq!(shift_months(base, 0), base); - assert_eq!(shift_months(base, 1), NaiveDate::from_ymd(2021, 1, 31)); - assert_eq!(shift_months(base, 2), NaiveDate::from_ymd(2021, 2, 28)); - assert_eq!(shift_months(base, 12), NaiveDate::from_ymd(2021, 12, 31)); - assert_eq!(shift_months(base, 18), NaiveDate::from_ymd(2022, 6, 30)); - - assert_eq!(shift_months(base, -1), NaiveDate::from_ymd(2020, 11, 30)); - assert_eq!(shift_months(base, -2), NaiveDate::from_ymd(2020, 10, 31)); - assert_eq!(shift_months(base, -10), NaiveDate::from_ymd(2020, 2, 29)); - assert_eq!(shift_months(base, -12), NaiveDate::from_ymd(2019, 12, 31)); - assert_eq!(shift_months(base, -18), NaiveDate::from_ymd(2019, 6, 30)); + assert_eq!( + shift_months(base, 1), + NaiveDate::from_ymd_opt(2021, 1, 31).unwrap() + ); + assert_eq!( + shift_months(base, 2), + NaiveDate::from_ymd_opt(2021, 2, 28).unwrap() + ); + assert_eq!( + shift_months(base, 12), + NaiveDate::from_ymd_opt(2021, 12, 31).unwrap() + ); + assert_eq!( + shift_months(base, 18), + NaiveDate::from_ymd_opt(2022, 6, 30).unwrap() + ); + + assert_eq!( + shift_months(base, -1), + NaiveDate::from_ymd_opt(2020, 11, 30).unwrap() + ); + assert_eq!( + shift_months(base, -2), + NaiveDate::from_ymd_opt(2020, 10, 31).unwrap() + ); + assert_eq!( + shift_months(base, -10), + NaiveDate::from_ymd_opt(2020, 2, 29).unwrap() + ); + assert_eq!( + shift_months(base, -12), + NaiveDate::from_ymd_opt(2019, 12, 31).unwrap() + ); + assert_eq!( + shift_months(base, -18), + NaiveDate::from_ymd_opt(2019, 6, 30).unwrap() + ); } #[test] fn test_shift_months_datetime() { - let date = NaiveDate::from_ymd(2020, 1, 31); - let o_clock = NaiveTime::from_hms(1, 2, 3); + let date = NaiveDate::from_ymd_opt(2020, 1, 31).unwrap(); + let o_clock = NaiveTime::from_hms_opt(1, 2, 3).unwrap(); let base = NaiveDateTime::new(date, o_clock); assert_eq!( shift_months(base, 0).date(), - NaiveDate::from_ymd(2020, 1, 31) + NaiveDate::from_ymd_opt(2020, 1, 31).unwrap() ); assert_eq!( shift_months(base, 1).date(), - NaiveDate::from_ymd(2020, 2, 29) + NaiveDate::from_ymd_opt(2020, 2, 29).unwrap() ); assert_eq!( shift_months(base, 2).date(), - NaiveDate::from_ymd(2020, 3, 31) + NaiveDate::from_ymd_opt(2020, 3, 31).unwrap() ); assert_eq!(shift_months(base, 0).time(), o_clock); assert_eq!(shift_months(base, 1).time(), o_clock); diff --git a/arrow-array/src/temporal_conversions.rs b/arrow-array/src/temporal_conversions.rs index a4d910cc8bc..f1f3f36d3c6 100644 --- a/arrow-array/src/temporal_conversions.rs +++ b/arrow-array/src/temporal_conversions.rs @@ -252,7 +252,7 @@ pub fn as_time(v: i64) -> Option { _ => None, }, DataType::Timestamp(_, _) => as_datetime::(v).map(|datetime| datetime.time()), - DataType::Date32 | DataType::Date64 => Some(NaiveTime::from_hms(0, 0, 0)), + DataType::Date32 | DataType::Date64 => NaiveTime::from_hms_opt(0, 0, 0), DataType::Interval(_) => None, _ => None, } diff --git a/arrow-array/src/timezone.rs b/arrow-array/src/timezone.rs index 7bd59790473..fd8c099c209 100644 --- a/arrow-array/src/timezone.rs +++ b/arrow-array/src/timezone.rs @@ -158,8 +158,8 @@ mod private { #[test] fn test_with_timezone() { let vals = [ - Utc.timestamp_millis(37800000), - Utc.timestamp_millis(86339000), + Utc.timestamp_millis_opt(37800000).unwrap(), + Utc.timestamp_millis_opt(86339000).unwrap(), ]; assert_eq!(10, vals[0].hour()); @@ -175,8 +175,8 @@ mod private { fn test_using_chrono_tz_and_utc_naive_date_time() { let sydney_tz = "Australia/Sydney".to_string(); let tz: Tz = sydney_tz.parse().unwrap(); - let sydney_offset_without_dst = FixedOffset::east(10 * 60 * 60); - let sydney_offset_with_dst = FixedOffset::east(11 * 60 * 60); + let sydney_offset_without_dst = FixedOffset::east_opt(10 * 60 * 60).unwrap(); + let sydney_offset_with_dst = FixedOffset::east_opt(11 * 60 * 60).unwrap(); // Daylight savings ends // When local daylight time was about to reach // Sunday, 4 April 2021, 3:00:00 am clocks were turned backward 1 hour to @@ -188,32 +188,40 @@ mod private { // Sunday, 3 October 2021, 3:00:00 am local daylight time instead. // Sydney 2021-04-04T02:30:00+11:00 is 2021-04-03T15:30:00Z - let utc_just_before_sydney_dst_ends = - NaiveDate::from_ymd(2021, 4, 3).and_hms_nano(15, 30, 0, 0); + let utc_just_before_sydney_dst_ends = NaiveDate::from_ymd_opt(2021, 4, 3) + .unwrap() + .and_hms_nano_opt(15, 30, 0, 0) + .unwrap(); assert_eq!( tz.offset_from_utc_datetime(&utc_just_before_sydney_dst_ends) .fix(), sydney_offset_with_dst ); // Sydney 2021-04-04T02:30:00+10:00 is 2021-04-03T16:30:00Z - let utc_just_after_sydney_dst_ends = - NaiveDate::from_ymd(2021, 4, 3).and_hms_nano(16, 30, 0, 0); + let utc_just_after_sydney_dst_ends = NaiveDate::from_ymd_opt(2021, 4, 3) + .unwrap() + .and_hms_nano_opt(16, 30, 0, 0) + .unwrap(); assert_eq!( tz.offset_from_utc_datetime(&utc_just_after_sydney_dst_ends) .fix(), sydney_offset_without_dst ); // Sydney 2021-10-03T01:30:00+10:00 is 2021-10-02T15:30:00Z - let utc_just_before_sydney_dst_starts = - NaiveDate::from_ymd(2021, 10, 2).and_hms_nano(15, 30, 0, 0); + let utc_just_before_sydney_dst_starts = NaiveDate::from_ymd_opt(2021, 10, 2) + .unwrap() + .and_hms_nano_opt(15, 30, 0, 0) + .unwrap(); assert_eq!( tz.offset_from_utc_datetime(&utc_just_before_sydney_dst_starts) .fix(), sydney_offset_without_dst ); // Sydney 2021-04-04T03:30:00+11:00 is 2021-10-02T16:30:00Z - let utc_just_after_sydney_dst_starts = - NaiveDate::from_ymd(2022, 10, 2).and_hms_nano(16, 30, 0, 0); + let utc_just_after_sydney_dst_starts = NaiveDate::from_ymd_opt(2022, 10, 2) + .unwrap() + .and_hms_nano_opt(16, 30, 0, 0) + .unwrap(); assert_eq!( tz.offset_from_utc_datetime(&utc_just_after_sydney_dst_starts) .fix(), @@ -300,7 +308,7 @@ mod tests { #[test] fn test_with_offset() { - let t = NaiveDate::from_ymd(2000, 1, 1); + let t = NaiveDate::from_ymd_opt(2000, 1, 1).unwrap(); let tz: Tz = "-00:00".parse().unwrap(); assert_eq!(tz.offset_from_utc_date(&t).fix().local_minus_utc(), 0); diff --git a/arrow-array/src/types.rs b/arrow-array/src/types.rs index 03ecef361b0..dd4d1ba4292 100644 --- a/arrow-array/src/types.rs +++ b/arrow-array/src/types.rs @@ -327,7 +327,7 @@ impl Date32Type { /// /// * `i` - The Date32Type to convert pub fn to_naive_date(i: ::Native) -> NaiveDate { - let epoch = NaiveDate::from_ymd(1970, 1, 1); + let epoch = NaiveDate::from_ymd_opt(1970, 1, 1).unwrap(); epoch.add(Duration::days(i as i64)) } @@ -337,7 +337,7 @@ impl Date32Type { /// /// * `d` - The NaiveDate to convert pub fn from_naive_date(d: NaiveDate) -> ::Native { - let epoch = NaiveDate::from_ymd(1970, 1, 1); + let epoch = NaiveDate::from_ymd_opt(1970, 1, 1).unwrap(); d.sub(epoch).num_days() as ::Native } @@ -400,7 +400,7 @@ impl Date64Type { /// /// * `i` - The Date64Type to convert pub fn to_naive_date(i: ::Native) -> NaiveDate { - let epoch = NaiveDate::from_ymd(1970, 1, 1); + let epoch = NaiveDate::from_ymd_opt(1970, 1, 1).unwrap(); epoch.add(Duration::milliseconds(i as i64)) } @@ -410,7 +410,7 @@ impl Date64Type { /// /// * `d` - The NaiveDate to convert pub fn from_naive_date(d: NaiveDate) -> ::Native { - let epoch = NaiveDate::from_ymd(1970, 1, 1); + let epoch = NaiveDate::from_ymd_opt(1970, 1, 1).unwrap(); d.sub(epoch).num_milliseconds() as ::Native } diff --git a/arrow-cast/src/cast.rs b/arrow-cast/src/cast.rs index bbd38fbc026..b3c0aaa8203 100644 --- a/arrow-cast/src/cast.rs +++ b/arrow-cast/src/cast.rs @@ -6120,7 +6120,7 @@ mod tests { #[test] fn test_cast_utf8_to_date32() { use chrono::NaiveDate; - let from_ymd = chrono::NaiveDate::from_ymd; + let from_ymd = chrono::NaiveDate::from_ymd_opt; let since = chrono::NaiveDate::signed_duration_since; let a = StringArray::from(vec![ @@ -6135,13 +6135,19 @@ mod tests { let c = b.as_any().downcast_ref::().unwrap(); // test valid inputs - let date_value = since(NaiveDate::from_ymd(2000, 1, 1), from_ymd(1970, 1, 1)) - .num_days() as i32; + let date_value = since( + NaiveDate::from_ymd_opt(2000, 1, 1).unwrap(), + from_ymd(1970, 1, 1).unwrap(), + ) + .num_days() as i32; assert!(c.is_valid(0)); // "2000-01-01" assert_eq!(date_value, c.value(0)); - let date_value = since(NaiveDate::from_ymd(2000, 2, 2), from_ymd(1970, 1, 1)) - .num_days() as i32; + let date_value = since( + NaiveDate::from_ymd_opt(2000, 2, 2).unwrap(), + from_ymd(1970, 1, 1).unwrap(), + ) + .num_days() as i32; assert!(c.is_valid(1)); // "2000-2-2" assert_eq!(date_value, c.value(1)); diff --git a/arrow-cast/src/parse.rs b/arrow-cast/src/parse.rs index 126beb902a5..b93d6c80024 100644 --- a/arrow-cast/src/parse.rs +++ b/arrow-cast/src/parse.rs @@ -305,8 +305,8 @@ mod tests { // timezone the test machine is running. Thus it is still // somewhat susceptible to bugs in the use of chrono let naive_datetime = NaiveDateTime::new( - NaiveDate::from_ymd(2020, 9, 8), - NaiveTime::from_hms_nano(13, 42, 29, 190855000), + NaiveDate::from_ymd_opt(2020, 9, 8).unwrap(), + NaiveTime::from_hms_nano_opt(13, 42, 29, 190855000).unwrap(), ); // Ensure both T and ' ' variants work @@ -323,8 +323,8 @@ mod tests { // Also ensure that parsing timestamps with no fractional // second part works as well let naive_datetime_whole_secs = NaiveDateTime::new( - NaiveDate::from_ymd(2020, 9, 8), - NaiveTime::from_hms(13, 42, 29), + NaiveDate::from_ymd_opt(2020, 9, 8).unwrap(), + NaiveTime::from_hms_opt(13, 42, 29).unwrap(), ); // Ensure both T and ' ' variants work @@ -380,8 +380,8 @@ mod tests { // string without timezone should always output the same regardless the local or session timezone let naive_datetime = NaiveDateTime::new( - NaiveDate::from_ymd(2020, 9, 8), - NaiveTime::from_hms_nano(13, 42, 29, 190855000), + NaiveDate::from_ymd_opt(2020, 9, 8).unwrap(), + NaiveTime::from_hms_nano_opt(13, 42, 29, 190855000).unwrap(), ); // Ensure both T and ' ' variants work @@ -396,8 +396,8 @@ mod tests { ); let naive_datetime = NaiveDateTime::new( - NaiveDate::from_ymd(2020, 9, 8), - NaiveTime::from_hms_nano(13, 42, 29, 0), + NaiveDate::from_ymd_opt(2020, 9, 8).unwrap(), + NaiveTime::from_hms_nano_opt(13, 42, 29, 0).unwrap(), ); // Ensure both T and ' ' variants work diff --git a/arrow-csv/src/reader.rs b/arrow-csv/src/reader.rs index 2fb6493e1be..0bf05960a37 100644 --- a/arrow-csv/src/reader.rs +++ b/arrow-csv/src/reader.rs @@ -1701,8 +1701,8 @@ mod tests { 0 ); let naive_datetime = NaiveDateTime::new( - NaiveDate::from_ymd(2018, 11, 13), - NaiveTime::from_hms_nano(17, 11, 10, 0), + NaiveDate::from_ymd_opt(2018, 11, 13).unwrap(), + NaiveTime::from_hms_nano_opt(17, 11, 10, 0).unwrap(), ); assert_eq!( parse_item::("2018-11-13T17:11:10").unwrap(), @@ -1713,16 +1713,16 @@ mod tests { naive_datetime.timestamp_nanos() / 1000 ); let naive_datetime = NaiveDateTime::new( - NaiveDate::from_ymd(2018, 11, 13), - NaiveTime::from_hms_nano(17, 11, 10, 11000000), + NaiveDate::from_ymd_opt(2018, 11, 13).unwrap(), + NaiveTime::from_hms_nano_opt(17, 11, 10, 11000000).unwrap(), ); assert_eq!( parse_item::("2018-11-13T17:11:10.011").unwrap(), naive_datetime.timestamp_nanos() / 1000 ); let naive_datetime = NaiveDateTime::new( - NaiveDate::from_ymd(1900, 2, 28), - NaiveTime::from_hms_nano(12, 34, 56, 0), + NaiveDate::from_ymd_opt(1900, 2, 28).unwrap(), + NaiveTime::from_hms_nano_opt(12, 34, 56, 0).unwrap(), ); assert_eq!( parse_item::("1900-02-28T12:34:56").unwrap(), @@ -1737,8 +1737,8 @@ mod tests { 0 ); let naive_datetime = NaiveDateTime::new( - NaiveDate::from_ymd(2018, 11, 13), - NaiveTime::from_hms_nano(17, 11, 10, 0), + NaiveDate::from_ymd_opt(2018, 11, 13).unwrap(), + NaiveTime::from_hms_nano_opt(17, 11, 10, 0).unwrap(), ); assert_eq!( parse_item::("2018-11-13T17:11:10").unwrap(), @@ -1749,16 +1749,16 @@ mod tests { naive_datetime.timestamp_nanos() ); let naive_datetime = NaiveDateTime::new( - NaiveDate::from_ymd(2018, 11, 13), - NaiveTime::from_hms_nano(17, 11, 10, 11000000), + NaiveDate::from_ymd_opt(2018, 11, 13).unwrap(), + NaiveTime::from_hms_nano_opt(17, 11, 10, 11000000).unwrap(), ); assert_eq!( parse_item::("2018-11-13T17:11:10.011").unwrap(), naive_datetime.timestamp_nanos() ); let naive_datetime = NaiveDateTime::new( - NaiveDate::from_ymd(1900, 2, 28), - NaiveTime::from_hms_nano(12, 34, 56, 0), + NaiveDate::from_ymd_opt(1900, 2, 28).unwrap(), + NaiveTime::from_hms_nano_opt(12, 34, 56, 0).unwrap(), ); assert_eq!( parse_item::("1900-02-28T12:34:56").unwrap(), diff --git a/arrow/benches/cast_kernels.rs b/arrow/benches/cast_kernels.rs index 2c3d8cd1678..e93c7860885 100644 --- a/arrow/benches/cast_kernels.rs +++ b/arrow/benches/cast_kernels.rs @@ -52,7 +52,8 @@ fn build_utf8_date_array(size: usize, with_nulls: bool) -> ArrayRef { if with_nulls && rng.gen::() > 0.8 { builder.append_null(); } else { - let string = NaiveDate::from_num_days_from_ce(rng.sample(range)) + let string = NaiveDate::from_num_days_from_ce_opt(rng.sample(range)) + .unwrap() .format("%Y-%m-%d") .to_string(); builder.append_value(&string); @@ -73,7 +74,8 @@ fn build_utf8_date_time_array(size: usize, with_nulls: bool) -> ArrayRef { if with_nulls && rng.gen::() > 0.8 { builder.append_null(); } else { - let string = NaiveDateTime::from_timestamp(rng.sample(range), 0) + let string = NaiveDateTime::from_timestamp_opt(rng.sample(range), 0) + .unwrap() .format("%Y-%m-%dT%H:%M:%S") .to_string(); builder.append_value(&string); diff --git a/arrow/src/compute/kernels/arithmetic.rs b/arrow/src/compute/kernels/arithmetic.rs index 328ce02e4f5..a99a90204b7 100644 --- a/arrow/src/compute/kernels/arithmetic.rs +++ b/arrow/src/compute/kernels/arithmetic.rs @@ -1644,7 +1644,7 @@ mod tests { #[test] fn test_date32_month_add() { let a = Date32Array::from(vec![Date32Type::from_naive_date( - NaiveDate::from_ymd(2000, 1, 1), + NaiveDate::from_ymd_opt(2000, 1, 1).unwrap(), )]); let b = IntervalYearMonthArray::from(vec![IntervalYearMonthType::make_value(1, 2)]); @@ -1652,28 +1652,28 @@ mod tests { let c = c.as_any().downcast_ref::().unwrap(); assert_eq!( c.value(0), - Date32Type::from_naive_date(NaiveDate::from_ymd(2001, 3, 1)) + Date32Type::from_naive_date(NaiveDate::from_ymd_opt(2001, 3, 1).unwrap()) ); } #[test] fn test_date32_day_time_add() { let a = Date32Array::from(vec![Date32Type::from_naive_date( - NaiveDate::from_ymd(2000, 1, 1), + NaiveDate::from_ymd_opt(2000, 1, 1).unwrap(), )]); let b = IntervalDayTimeArray::from(vec![IntervalDayTimeType::make_value(1, 2)]); let c = add_dyn(&a, &b).unwrap(); let c = c.as_any().downcast_ref::().unwrap(); assert_eq!( c.value(0), - Date32Type::from_naive_date(NaiveDate::from_ymd(2000, 1, 2)) + Date32Type::from_naive_date(NaiveDate::from_ymd_opt(2000, 1, 2).unwrap()) ); } #[test] fn test_date32_month_day_nano_add() { let a = Date32Array::from(vec![Date32Type::from_naive_date( - NaiveDate::from_ymd(2000, 1, 1), + NaiveDate::from_ymd_opt(2000, 1, 1).unwrap(), )]); let b = IntervalMonthDayNanoArray::from(vec![IntervalMonthDayNanoType::make_value( @@ -1683,14 +1683,14 @@ mod tests { let c = c.as_any().downcast_ref::().unwrap(); assert_eq!( c.value(0), - Date32Type::from_naive_date(NaiveDate::from_ymd(2000, 2, 3)) + Date32Type::from_naive_date(NaiveDate::from_ymd_opt(2000, 2, 3).unwrap()) ); } #[test] fn test_date64_month_add() { let a = Date64Array::from(vec![Date64Type::from_naive_date( - NaiveDate::from_ymd(2000, 1, 1), + NaiveDate::from_ymd_opt(2000, 1, 1).unwrap(), )]); let b = IntervalYearMonthArray::from(vec![IntervalYearMonthType::make_value(1, 2)]); @@ -1698,28 +1698,28 @@ mod tests { let c = c.as_any().downcast_ref::().unwrap(); assert_eq!( c.value(0), - Date64Type::from_naive_date(NaiveDate::from_ymd(2001, 3, 1)) + Date64Type::from_naive_date(NaiveDate::from_ymd_opt(2001, 3, 1).unwrap()) ); } #[test] fn test_date64_day_time_add() { let a = Date64Array::from(vec![Date64Type::from_naive_date( - NaiveDate::from_ymd(2000, 1, 1), + NaiveDate::from_ymd_opt(2000, 1, 1).unwrap(), )]); let b = IntervalDayTimeArray::from(vec![IntervalDayTimeType::make_value(1, 2)]); let c = add_dyn(&a, &b).unwrap(); let c = c.as_any().downcast_ref::().unwrap(); assert_eq!( c.value(0), - Date64Type::from_naive_date(NaiveDate::from_ymd(2000, 1, 2)) + Date64Type::from_naive_date(NaiveDate::from_ymd_opt(2000, 1, 2).unwrap()) ); } #[test] fn test_date64_month_day_nano_add() { let a = Date64Array::from(vec![Date64Type::from_naive_date( - NaiveDate::from_ymd(2000, 1, 1), + NaiveDate::from_ymd_opt(2000, 1, 1).unwrap(), )]); let b = IntervalMonthDayNanoArray::from(vec![IntervalMonthDayNanoType::make_value( @@ -1729,7 +1729,7 @@ mod tests { let c = c.as_any().downcast_ref::().unwrap(); assert_eq!( c.value(0), - Date64Type::from_naive_date(NaiveDate::from_ymd(2000, 2, 3)) + Date64Type::from_naive_date(NaiveDate::from_ymd_opt(2000, 2, 3).unwrap()) ); } diff --git a/parquet/src/record/api.rs b/parquet/src/record/api.rs index d7e1e7550f0..02cb94765cf 100644 --- a/parquet/src/record/api.rs +++ b/parquet/src/record/api.rs @@ -795,7 +795,9 @@ impl fmt::Display for Field { #[inline] fn convert_date_to_string(value: u32) -> String { static NUM_SECONDS_IN_DAY: i64 = 60 * 60 * 24; - let dt = Utc.timestamp(value as i64 * NUM_SECONDS_IN_DAY, 0).date(); + let dt = Utc + .timestamp_opt(value as i64 * NUM_SECONDS_IN_DAY, 0) + .unwrap(); format!("{}", dt.format("%Y-%m-%d %:z")) } @@ -804,7 +806,7 @@ fn convert_date_to_string(value: u32) -> String { /// Datetime is displayed in local timezone. #[inline] fn convert_timestamp_secs_to_string(value: i64) -> String { - let dt = Utc.timestamp(value, 0); + let dt = Utc.timestamp_opt(value, 0).unwrap(); format!("{}", dt.format("%Y-%m-%d %H:%M:%S %:z")) } @@ -1075,7 +1077,10 @@ mod tests { #[test] fn test_convert_date_to_string() { fn check_date_conversion(y: u32, m: u32, d: u32) { - let datetime = chrono::NaiveDate::from_ymd(y as i32, m, d).and_hms(0, 0, 0); + let datetime = chrono::NaiveDate::from_ymd_opt(y as i32, m, d) + .unwrap() + .and_hms_opt(0, 0, 0) + .unwrap(); let dt = Utc.from_utc_datetime(&datetime); let res = convert_date_to_string((dt.timestamp() / 60 / 60 / 24) as u32); let exp = format!("{}", dt.format("%Y-%m-%d %:z")); @@ -1092,7 +1097,10 @@ mod tests { #[test] fn test_convert_timestamp_millis_to_string() { fn check_datetime_conversion(y: u32, m: u32, d: u32, h: u32, mi: u32, s: u32) { - let datetime = chrono::NaiveDate::from_ymd(y as i32, m, d).and_hms(h, mi, s); + let datetime = chrono::NaiveDate::from_ymd_opt(y as i32, m, d) + .unwrap() + .and_hms_opt(h, mi, s) + .unwrap(); let dt = Utc.from_utc_datetime(&datetime); let res = convert_timestamp_millis_to_string(dt.timestamp_millis() as u64); let exp = format!("{}", dt.format("%Y-%m-%d %H:%M:%S %:z")); @@ -1110,7 +1118,10 @@ mod tests { #[test] fn test_convert_timestamp_micros_to_string() { fn check_datetime_conversion(y: u32, m: u32, d: u32, h: u32, mi: u32, s: u32) { - let datetime = chrono::NaiveDate::from_ymd(y as i32, m, d).and_hms(h, mi, s); + let datetime = chrono::NaiveDate::from_ymd_opt(y as i32, m, d) + .unwrap() + .and_hms_opt(h, mi, s) + .unwrap(); let dt = Utc.from_utc_datetime(&datetime); let res = convert_timestamp_micros_to_string(dt.timestamp_micros() as u64); let exp = format!("{}", dt.format("%Y-%m-%d %H:%M:%S %:z"));