feat(datafusion): support abs argument and fold literal helper

Re-add `abs(x)` as a NaN-preserving argument to `isnan`, and merge the literal
f64 extraction into a single `literal_as_f64` helper. No other behavior change.

Author: huan233usc

crates/integrations/datafusion/src/physical_plan/expr_to_predicate.rs

@@ -249,16 +249,14 @@ fn scalar_function_to_iceberg_predicate(func_name: &str, args: &[Expr]) -> Trans
 /// wrapped column is NaN — so both `isnan(arg)` and `NOT isnan(arg)` are sound:
 ///
 /// * negation: `-x` is NaN iff `x` is NaN
+/// * `abs(x)`: `abs(x)` is NaN iff `x` is NaN
 /// * casts between numeric types preserve NaN
 /// * `x + c`, `c + x`, `x - c`, `c - x` for a finite literal `c`
 /// * `x * c`, `c * x`, `x / c` for a finite, non-zero literal `c`
 ///
 /// Multiplication/division by zero and `c / x` are intentionally rejected: e.g.
 /// `x * 0` is NaN when `x` is `±inf`, so it does not imply `x` is NaN.
 ///
-/// Scalar-function arguments (e.g. `abs(x)`) are intentionally left for a
-/// follow-up; only references, negation, casts and arithmetic are resolved here.
-///
 /// [`IcebergTableProvider::supports_filters_pushdown`]: crate::table::IcebergTableProvider
 fn resolve_nan_preserving_reference(expr: &Expr) -> Option<Reference> {
     match expr {
@@ -272,9 +270,12 @@ fn resolve_nan_preserving_reference(expr: &Expr) -> Option<Reference> {
             }
             resolve_nan_preserving_reference(&cast.expr)
         }
+        Expr::ScalarFunction(ScalarFunction { func, args })
+            if func.name() == "abs" && args.len() == 1 =>
+        {
+            resolve_nan_preserving_reference(&args[0])
+        }
         Expr::BinaryExpr(binary) => resolve_nan_preserving_binary(binary),
-        // TODO(#2154): resolve NaN-preserving scalar-function arguments such as
-        // `abs(x)` (and similar, e.g. `signum`).
         _ => None,
     }
 }
@@ -338,14 +339,9 @@ fn is_finite_nonzero_literal(expr: &Expr) -> bool {
 /// Returns the value of `expr` as an `f64` if it is a numeric literal. Used only
 /// to inspect the finiteness and sign of literals (precision loss is irrelevant).
 fn literal_as_f64(expr: &Expr) -> Option<f64> {
-    match expr {
-        Expr::Literal(value, _) => scalar_value_as_f64(value),
-        _ => None,
-    }
-}
-
-/// Extracts a numeric [`ScalarValue`] as an `f64`.
-fn scalar_value_as_f64(value: &ScalarValue) -> Option<f64> {
+    let Expr::Literal(value, _) = expr else {
+        return None;
+    };
     match value {
         ScalarValue::Int8(Some(v)) => Some(*v as f64),
         ScalarValue::Int16(Some(v)) => Some(*v as f64),
@@ -864,6 +860,13 @@ mod tests {
         assert_eq!(predicate, !Reference::new("qux").is_nan());
     }
 
+    #[test]
+    fn test_predicate_conversion_with_isnan_abs() {
+        // abs(x) is NaN iff x is NaN
+        let predicate = convert_to_iceberg_predicate("isnan(abs(qux))").unwrap();
+        assert_eq!(predicate, Reference::new("qux").is_nan());
+    }
+
     #[test]
     fn test_predicate_conversion_with_isnan_additive() {
         // x + c, c + x, x - c, c - x are NaN iff x is NaN (for finite c)
@@ -891,7 +894,7 @@ mod tests {
     #[test]
     fn test_predicate_conversion_with_isnan_nested_expr() {
         // Nested NaN-preserving transformations resolve to the inner column
-        let predicate = convert_to_iceberg_predicate("isnan(-(qux + 1) * 3)").unwrap();
+        let predicate = convert_to_iceberg_predicate("isnan(-(abs(qux) + 1) * 3)").unwrap();
         assert_eq!(predicate, Reference::new("qux").is_nan());
     }
 
@@ -920,9 +923,6 @@ mod tests {
         // single column reference.
         assert_eq!(convert_to_iceberg_predicate("isnan(qux + foo)"), None);
 
-        // Scalar-function arguments (e.g. abs) are left for a follow-up.
-        assert_eq!(convert_to_iceberg_predicate("isnan(abs(qux))"), None);
-
         // Unknown scalar functions are not pushed down.
         assert_eq!(convert_to_iceberg_predicate("isnan(sqrt(qux))"), None);
     }