fix copilot

Author: davidlghellin

datafusion/functions/src/math/ceil.rs

@@ -192,11 +192,10 @@ impl ScalarUDFImpl for CeilFunc {
 
     fn evaluate_bounds(&self, inputs: &[&Interval]) -> Result<Interval> {
         let [input] = inputs else {
-            let data_type = inputs
-                .first()
-                .map(|i| i.data_type())
-                .unwrap_or(DataType::Float64);
-            return Interval::make_unbounded(&data_type);
+            return exec_err!(
+                "ceil expected 1 argument for bounds evaluation, got {}",
+                inputs.len()
+            );
         };
         let data_type = input.data_type();
         match (ceil_scalar(input.lower()), ceil_scalar(input.upper())) {
@@ -212,7 +211,10 @@ impl ScalarUDFImpl for CeilFunc {
         inputs: &[&Interval],
     ) -> Result<Option<Vec<Interval>>> {
         let [input_interval] = inputs else {
-            return Ok(Some(inputs.iter().map(|i| (*i).clone()).collect()));
+            return exec_err!(
+                "ceil expected 1 argument for constraint propagation, got {}",
+                inputs.len()
+            );
         };
         // ceil(x) ∈ [N, M] → x ∈ (N−1, M] — conservative closed: [N−1, M]
         let lo = match interval.lower() {

datafusion/physical-expr/src/intervals/utils.rs

@@ -28,8 +28,8 @@ use crate::{
 use arrow::array::types::{IntervalDayTime, IntervalMonthDayNano};
 use arrow::datatypes::{DataType, SchemaRef};
 use datafusion_common::{Result, ScalarValue, internal_err};
-use datafusion_expr::Operator;
 use datafusion_expr::interval_arithmetic::Interval;
+use datafusion_expr::{Operator, Volatility};
 
 /// Indicates whether interval arithmetic is supported for the given expression.
 /// Currently, we do not support all [`PhysicalExpr`]s for interval calculations.
@@ -58,7 +58,8 @@ pub fn check_support(expr: &Arc<dyn PhysicalExpr>, schema: &SchemaRef) -> bool {
     } else if let Some(negative) = expr.downcast_ref::<NegativeExpr>() {
         check_support(negative.arg(), schema)
     } else if let Some(scalar_fn) = expr.downcast_ref::<ScalarFunctionExpr>() {
-        is_datatype_supported(scalar_fn.return_type())
+        scalar_fn.fun().signature().volatility == Volatility::Immutable
+            && is_datatype_supported(scalar_fn.return_type())
             && scalar_fn
                 .args()
                 .iter()
@@ -265,9 +266,6 @@ mod tests {
     }
 
     impl ScalarUDFImpl for Utf8UDF {
-        fn as_any(&self) -> &dyn std::any::Any {
-            self
-        }
         fn name(&self) -> &str {
             "utf8_udf"
         }