feat(spark): implement Spark datetime function last_day

Signed-off-by: Alan Tang <jmtangcs@gmail.com>

Author: Standing-Man

Cargo.lock

@@ -44,10 +44,12 @@ datafusion-expr = { workspace = true }
 datafusion-functions = { workspace = true, features = ["crypto_expressions"] }
 datafusion-macros = { workspace = true }
 log = { workspace = true }
+chrono = { workspace = true }
 
 [dev-dependencies]
 criterion = { workspace = true }
 rand = { workspace = true }
+chrono = { workspace = true }
 
 [[bench]]
 harness = false

datafusion/spark/Cargo.toml

@@ -0,0 +1,145 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+use std::any::Any;
+use std::sync::Arc;
+
+use arrow::array::{ArrayRef, AsArray, Date32Array};
+use arrow::datatypes::{DataType, Date32Type};
+use chrono::{Datelike, Duration, NaiveDate};
+use datafusion_common::types::NativeType;
+use datafusion_common::{exec_datafusion_err, exec_err, plan_err, Result, ScalarValue};
+use datafusion_expr::{
+    ColumnarValue, ScalarFunctionArgs, ScalarUDFImpl, Signature, Volatility,
+};
+
+#[derive(Debug)]
+pub struct SparkLastDay {
+    signature: Signature,
+}
+
+impl Default for SparkLastDay {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl SparkLastDay {
+    pub fn new() -> Self {
+        Self {
+            signature: Signature::user_defined(Volatility::Immutable),
+        }
+    }
+}
+
+impl ScalarUDFImpl for SparkLastDay {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    fn name(&self) -> &str {
+        "spark_last_day"
+    }
+
+    fn signature(&self) -> &Signature {
+        &self.signature
+    }
+
+    fn return_type(&self, _arg_types: &[DataType]) -> Result<DataType> {
+        Ok(DataType::Date32)
+    }
+
+    fn invoke_with_args(&self, args: ScalarFunctionArgs) -> Result<ColumnarValue> {
+        let ScalarFunctionArgs { args, .. } = args;
+        let [arg] = args.as_slice() else {
+            return exec_err!(
+                "Spark `last_day` function requires 1 argument, got {}",
+                args.len()
+            );
+        };
+        match arg {
+            ColumnarValue::Scalar(ScalarValue::Date32(days)) => {
+                if let Some(days) = days {
+                    Ok(ColumnarValue::Scalar(ScalarValue::Date32(Some(
+                        spark_last_day(*days)?,
+                    ))))
+                } else {
+                    Ok(ColumnarValue::Scalar(ScalarValue::Date32(None)))
+                }
+            }
+            ColumnarValue::Array(array) => {
+                let result = match array.data_type() {
+                    DataType::Date32 => {
+                        let result: Date32Array = array
+                            .as_primitive::<Date32Type>()
+                            .try_unary(spark_last_day)?
+                            .with_data_type(DataType::Date32);
+                        Ok(Arc::new(result) as ArrayRef)
+                    }
+                    other => {
+                        exec_err!("Unsupported data type {other:?} for Spark function `last_day`")
+                    }
+                }?;
+                Ok(ColumnarValue::Array(result))
+            }
+            other => exec_err!("Unsupported arg {other:?} for Spark function `last_day"),
+        }
+    }
+
+    fn coerce_types(&self, arg_types: &[DataType]) -> Result<Vec<DataType>> {
+        if arg_types.len() != 1 {
+            return exec_err!(
+                "Spark `last_day` function requires 1 argument, got {}",
+                arg_types.len()
+            );
+        }
+
+        let current_native_type: NativeType = (&arg_types[0]).into();
+        if matches!(current_native_type, NativeType::Date)
+            || matches!(current_native_type, NativeType::String)
+            || matches!(current_native_type, NativeType::Null)
+        {
+            Ok(vec![DataType::Date32])
+        } else {
+            plan_err!(
+                "The first argument of the Spark `last_day` function can only be a date or string, but got {}", &arg_types[0]
+            )
+        }
+    }
+}
+
+fn spark_last_day(days: i32) -> Result<i32> {
+    let date = Date32Type::to_naive_date(days);
+
+    let (year, month) = (date.year(), date.month());
+    let (next_year, next_month) = if month == 12 {
+        (year + 1, 1)
+    } else {
+        (year, month + 1)
+    };
+
+    let first_day_next_month = NaiveDate::from_ymd_opt(next_year, next_month, 1)
+        .ok_or_else(|| {
+            exec_datafusion_err!(
+                "Spark `last_day`: Unable to parse date from {next_year}, {next_month}, 1"
+            )
+        })?;
+
+    Ok(Date32Type::from_naive_date(
+        first_day_next_month - Duration::days(1),
+    ))
+}

datafusion/spark/src/function/datetime/last_day.rs

@@ -15,11 +15,24 @@
 // specific language governing permissions and limitations
 // under the License.
 
+pub mod last_day;
+
 use datafusion_expr::ScalarUDF;
+use datafusion_functions::make_udf_function;
 use std::sync::Arc;
 
-pub mod expr_fn {}
+make_udf_function!(last_day::SparkLastDay, last_day);
+
+pub mod expr_fn {
+    use datafusion_functions::export_functions;
+
+    export_functions!((
+        last_day,
+        "Returns the last day of the month which the date belongs to.",
+        arg1
+    ));
+}
 
 pub fn functions() -> Vec<Arc<ScalarUDF>> {
-    vec![]
+    vec![last_day()]
 }

datafusion/spark/src/function/datetime/mod.rs

@@ -23,5 +23,8 @@
 
 ## Original Query: SELECT last_day('2009-01-12');
 ## PySpark 3.5.5 Result: {'last_day(2009-01-12)': datetime.date(2009, 1, 31), 'typeof(last_day(2009-01-12))': 'date', 'typeof(2009-01-12)': 'string'}
-#query
-#SELECT last_day('2009-01-12'::string);
+
+query D
+SELECT last_day('2009-01-12'::string);
+----
+2009-01-31