fix(rust): Return null for out-of-range dates in temporal operations

Change `to_temporal_unit!`, `to_calendar_value!`, and
`to_boolean_temporal_unit!` macros to return null for out-of-range dates
instead of silently returning incorrect values.

Co-authored-by: Claude <noreply@anthropic.com>

Author: wtn

crates/polars-time/src/chunkedarray/kernels.rs

@@ -1,7 +1,6 @@
 //! macros that define kernels for extracting
 //! `week`, `weekday`, `year`, `hour` etc. from primitive arrays.
 use arrow::array::{BooleanArray, PrimitiveArray};
-use arrow::compute::arity::unary;
 #[cfg(feature = "dtype-time")]
 use arrow::temporal_conversions::time64ns_to_time_opt;
 use arrow::temporal_conversions::{
@@ -42,14 +41,12 @@ macro_rules! to_temporal_unit {
     $primitive_out: ty,
     $dtype_out:expr) => {
         pub(crate) fn $name(arr: &PrimitiveArray<$primitive_in>) -> ArrayRef {
-            Box::new(unary(
-                arr,
-                |value| {
-                    $to_datetime_fn(value)
-                        .map(|dt| dt.$chrono_method() as $primitive_out)
-                        .unwrap_or(value as $primitive_out)
-                },
-                $dtype_out,
+            Box::new(PrimitiveArray::<$primitive_out>::from_trusted_len_iter(
+                arr.iter().map(|opt_value| {
+                    opt_value.and_then(|&value| {
+                        $to_datetime_fn(value).map(|dt| dt.$chrono_method() as $primitive_out)
+                    })
+                }),
             )) as ArrayRef
         }
     };
@@ -58,20 +55,13 @@ macro_rules! to_temporal_unit {
 macro_rules! to_boolean_temporal_unit {
     ($name: ident, $chrono_method: ident, $boolean_method: ident, $to_datetime_fn: expr, $dtype_in: ty) => {
         pub(crate) fn $name(arr: &PrimitiveArray<$dtype_in>) -> ArrayRef {
-            let values = arr
-                .values()
-                .iter()
-                .map(|value| {
-                    $to_datetime_fn(*value)
-                        .map(|dt| $boolean_method(dt.$chrono_method()))
-                        .unwrap_or(false)
-                })
-                .collect::<Vec<_>>();
-            Box::new(BooleanArray::new(
-                ArrowDataType::Boolean,
-                values.into(),
-                arr.validity().cloned(),
-            ))
+            Box::new(BooleanArray::from_trusted_len_iter(arr.iter().map(
+                |opt_value| {
+                    opt_value.and_then(|&value| {
+                        $to_datetime_fn(value).map(|dt| $boolean_method(dt.$chrono_method()))
+                    })
+                },
+            )))
         }
     };
 }
@@ -82,14 +72,12 @@ macro_rules! to_calendar_value {
     $primitive_out: ty,
     $dtype_out:expr) => {
         pub(crate) fn $name(arr: &PrimitiveArray<$primitive_in>) -> ArrayRef {
-            Box::new(unary(
-                arr,
-                |value| {
-                    $to_datetime_fn(value)
-                        .map(|$dt| $expr as $primitive_out)
-                        .unwrap_or(value as $primitive_out)
-                },
-                $dtype_out,
+            Box::new(PrimitiveArray::<$primitive_out>::from_trusted_len_iter(
+                arr.iter().map(|opt_value| {
+                    opt_value.and_then(|&value| {
+                        $to_datetime_fn(value).map(|$dt| $expr as $primitive_out)
+                    })
+                }),
             )) as ArrayRef
         }
     };

crates/polars/tests/it/time/date.rs

@@ -1,44 +1,49 @@
-use polars::prelude::*;
+#[test]
+#[cfg(feature = "dtype-date")]
+fn test_date_temporal_operations_11991() {
+    use polars::prelude::*;
+
+    let normal_date = 18628; // 2021-01-01
+    let s = Int32Chunked::new("".into(), &[normal_date])
+        .into_date()
+        .into_series();
+
+    let year = s.year().unwrap();
+    assert_eq!(year.get(0), Some(2021));
+
+    let month = s.month().unwrap();
+    assert_eq!(month.get(0), Some(1));
+
+    let day = s.day().unwrap();
+    assert_eq!(day.get(0), Some(1));
+
+    // Null values should remain null (regression test for #15313)
+    let s_with_null = Int32Chunked::new("".into(), &[Some(18628), None])
+        .into_date()
+        .into_series();
+
+    let year_with_null = s_with_null.year().unwrap();
+    assert_eq!(year_with_null.get(0), Some(2021));
+    assert_eq!(year_with_null.get(1), None);
+}
 
 #[test]
-fn test_datetime_parse_overflow_7631() {
-    let df = df![
-        "year"=> &[2020, 2021, 2022],
-        "month"=> &[1, 2, 3],
-        "day"=> &[1, 2, 3],
-    ]
-    .unwrap()
-    .lazy();
-
-    let df = df.with_column(
-        concat_str([col("year"), col("month"), col("day")], "-", false) // produces e.g., `2020-1-1`
-            .str()
-            .strptime(
-                DataType::Datetime(TimeUnit::Milliseconds, None),
-                StrptimeOptions {
-                    format: Some("%Y-%m-%_d".into()),
-                    ..Default::default()
-                },
-                lit("latest"),
-            )
-            .alias("dt1"),
-    );
-    let actual = df.collect().unwrap();
-
-    let expected = DataFrame::new(vec![
-        Column::new("year".into(), &[2020, 2021, 2022]),
-        Column::new("month".into(), &[1, 2, 3]),
-        Column::new("day".into(), &[1, 2, 3]),
-        Column::new(
-            "dt1".into(),
-            &[
-                AnyValue::Datetime(1577836800000, TimeUnit::Milliseconds, None),
-                AnyValue::Datetime(1612224000000, TimeUnit::Milliseconds, None),
-                AnyValue::Datetime(1646265600000, TimeUnit::Milliseconds, None),
-            ],
-        ),
-    ])
-    .unwrap();
-
-    assert_eq!(actual, expected);
+#[cfg(feature = "dtype-date")]
+fn test_out_of_range_date_year_11991() {
+    use polars::prelude::*;
+
+    // Out-of-range dates should return null instead of panicking or returning wrong values
+    // Regression test for #11991 where out-of-range dates silently returned the input value
+    let out_of_range_date = -96_465_659;
+    let s = Int32Chunked::new("".into(), &[out_of_range_date])
+        .into_date()
+        .into_series();
+
+    let year = s.year().unwrap();
+    // Should return null, not the input value -96465659
+    assert_eq!(year.get(0), None);
+
+    // is_leap_year should also return null for out-of-range dates
+    let is_leap = s.is_leap_year().unwrap();
+    assert_eq!(is_leap.get(0), None);
 }

py-polars/tests/unit/operations/namespaces/temporal/test_datetime.py

@@ -1551,3 +1551,17 @@ def test_literal_from_timedelta(value: time, dtype: pl.Duration | None) -> None:
     out = pl.select(pl.lit(value, dtype=dtype))
     assert out.schema == OrderedDict({"literal": dtype or pl.Duration("us")})
     assert out.item() == value
+
+
+def test_out_of_range_date_year_11991() -> None:
+    # Out-of-range dates should return null instead of wrong values or panicking
+    # Regression test for #11991 where out-of-range dates silently returned
+    # the input value
+    s = pl.Series([-96_465_659]).cast(pl.Date)
+    result = s.dt.year()
+    # Should return null, not the input value -96465659
+    assert result[0] is None
+
+    # is_leap_year should also return null for out-of-range dates
+    result_leap = s.dt.is_leap_year()
+    assert result_leap[0] is None