Support round() function with two parameters (apache#5807)

mcheshkov · mcheshkov · commit 961e2f4bca4f · 2025-05-19T20:07:24.000+02:00
Can drop this after rebase on commit 771c20c "Support round() function with two parameters (apache#5807)", first released in 22.0.0
diff --git a/datafusion/core/src/optimizer/projection_drop_out.rs b/datafusion/core/src/optimizer/projection_drop_out.rs
@@ -631,7 +631,7 @@ mod tests {
             )?
             .project_with_alias(
                 vec![
-                    round(col("id")).alias("first"),
+                    round(vec![col("id")]).alias("first"),
                     col("n").alias("second"),
                     lit(2).alias("third"),
                 ],
@@ -649,7 +649,7 @@ mod tests {
         // select * from (select id first, a second, 2 third from (select round(a) id, 1 num from table) a) x;
         let plan = LogicalPlanBuilder::from(table_scan)
             .project_with_alias(
-                vec![round(col("a")).alias("id"), lit(1).alias("n")],
+                vec![round(vec![col("a")]).alias("id"), lit(1).alias("n")],
                 Some("a".to_string()),
             )?
             .project_with_alias(
@@ -748,7 +748,7 @@ mod tests {
             )?
             .project_with_alias(
                 vec![
-                    round(col("id")).alias("first"),
+                    round(vec![col("id")]).alias("first"),
                     col("n").alias("second"),
                     lit(2).alias("third"),
                 ],
@@ -826,7 +826,10 @@ mod tests {
         let plan = LogicalPlanBuilder::from(table_scan)
             .project_with_alias(vec![col("a").alias("id")], Some("a".to_string()))?
             .project_with_alias(
-                vec![round(col("id")).alias("first"), lit(2).alias("second")],
+                vec![
+                    round(vec![col("id")]).alias("first"),
+                    lit(2).alias("second"),
+                ],
                 Some("b".to_string()),
             )?
             .sort(vec![col("first")])?
@@ -1019,7 +1022,7 @@ mod tests {
             .project_with_alias(vec![col("a").alias("num")], Some("a".to_string()))?
             .project_with_alias(vec![col("num")], Some("b".to_string()))?
             .filter(col("num").gt(lit(0)))?
-            .aggregate(vec![round(col("num"))], Vec::<Expr>::new())?
+            .aggregate(vec![round(vec![col("num")])], Vec::<Expr>::new())?
             .project(vec![col("Round(b.num)")])?
             .sort(vec![col("Round(b.num)")])?
             .build()?;
@@ -1044,7 +1047,7 @@ mod tests {
         let plan = LogicalPlanBuilder::from(table_scan.clone())
             .project_with_alias(vec![col("a").alias("num")], Some("a".to_string()))?
             .project_with_alias(vec![col("num")], Some("b".to_string()))?
-            .aggregate(vec![round(col("num"))], Vec::<Expr>::new())?
+            .aggregate(vec![round(vec![col("num")])], Vec::<Expr>::new())?
             .project(vec![col("Round(b.num)")])?
             .sort(vec![col("Round(b.num)")])?
             .build()?;
@@ -1061,7 +1064,7 @@ mod tests {
         let plan = LogicalPlanBuilder::from(table_scan)
             .project_with_alias(vec![col("a").alias("num")], Some("a".to_string()))?
             .project_with_alias(vec![col("num")], Some("b".to_string()))?
-            .aggregate(vec![round(col("num"))], Vec::<Expr>::new())?
+            .aggregate(vec![round(vec![col("num")])], Vec::<Expr>::new())?
             .project(vec![col("Round(b.num)")])?
             .sort(vec![col("Round(b.num)")])?
             .project_with_alias(vec![col("Round(b.num)")], Some("x".to_string()))?
@@ -1099,7 +1102,7 @@ mod tests {
             .project_with_alias(vec![col("num")], Some("x".to_string()))?
             .join(&right, JoinType::Left, (vec!["num"], vec!["a"]))?
             .project_with_alias(
-                vec![col("num"), col("a"), round(col("num"))],
+                vec![col("num"), col("a"), round(vec![col("num")])],
                 Some("b".to_string()),
             )?
             .build()?;
diff --git a/datafusion/core/src/physical_plan/functions.rs b/datafusion/core/src/physical_plan/functions.rs
@@ -306,7 +306,9 @@ pub fn create_physical_fun(
         BuiltinScalarFunction::Log10 => Arc::new(math_expressions::log10),
         BuiltinScalarFunction::Log2 => Arc::new(math_expressions::log2),
         BuiltinScalarFunction::Random => Arc::new(math_expressions::random),
-        BuiltinScalarFunction::Round => Arc::new(math_expressions::round),
+        BuiltinScalarFunction::Round => {
+            Arc::new(|args| make_scalar_function(math_expressions::round)(args))
+        }
         BuiltinScalarFunction::Signum => Arc::new(math_expressions::signum),
         BuiltinScalarFunction::Sin => Arc::new(math_expressions::sin),
         BuiltinScalarFunction::Sqrt => Arc::new(math_expressions::sqrt),
diff --git a/datafusion/expr/src/expr_fn.rs b/datafusion/expr/src/expr_fn.rs
@@ -257,7 +257,7 @@ unary_scalar_expr!(Atan, atan);
 unary_scalar_expr!(Floor, floor);
 unary_scalar_expr!(Ceil, ceil);
 unary_scalar_expr!(Now, now);
-unary_scalar_expr!(Round, round);
+nary_scalar_expr!(Round, round);
 unary_scalar_expr!(Trunc, trunc);
 unary_scalar_expr!(Abs, abs);
 unary_scalar_expr!(Signum, signum);
@@ -418,7 +418,8 @@ mod test {
         test_unary_scalar_expr!(Floor, floor);
         test_unary_scalar_expr!(Ceil, ceil);
         test_unary_scalar_expr!(Now, now);
-        test_unary_scalar_expr!(Round, round);
+        test_nary_scalar_expr!(Round, round, input);
+        test_nary_scalar_expr!(Round, round, input, decimal_places);
         test_unary_scalar_expr!(Trunc, trunc);
         test_unary_scalar_expr!(Abs, abs);
         test_unary_scalar_expr!(Signum, signum);
diff --git a/datafusion/physical-expr/src/math_expressions.rs b/datafusion/physical-expr/src/math_expressions.rs
@@ -113,6 +113,18 @@ macro_rules! make_function_inputs2 {
             })
             .collect::<$ARRAY_TYPE>()
     }};
+    ($ARG1: expr, $ARG2: expr, $NAME1:expr, $NAME2: expr, $ARRAY_TYPE1:ident, $ARRAY_TYPE2:ident, $FUNC: block) => {{
+        let arg1 = downcast_arg!($ARG1, $NAME1, $ARRAY_TYPE1);
+        let arg2 = downcast_arg!($ARG2, $NAME2, $ARRAY_TYPE2);
+
+        arg1.iter()
+            .zip(arg2.iter())
+            .map(|(a1, a2)| match (a1, a2) {
+                (Some(a1), Some(a2)) => Some($FUNC(a1, a2.try_into().ok()?)),
+                _ => None,
+            })
+            .collect::<$ARRAY_TYPE1>()
+    }};
 }
 
 math_unary_function!("sqrt", sqrt);
@@ -124,7 +136,6 @@ math_unary_function!("acos", acos);
 math_unary_function!("atan", atan);
 math_unary_function!("floor", floor);
 math_unary_function!("ceil", ceil);
-math_unary_function!("round", round);
 math_unary_function!("trunc", trunc);
 math_unary_function!("abs", abs);
 math_unary_function!("signum", signum);
@@ -160,6 +171,59 @@ pub fn random(args: &[ColumnarValue]) -> Result<ColumnarValue> {
     Ok(ColumnarValue::Array(Arc::new(array)))
 }
 
+/// Round SQL function
+pub fn round(args: &[ArrayRef]) -> Result<ArrayRef> {
+    if args.len() != 1 && args.len() != 2 {
+        return Err(DataFusionError::Internal(format!(
+            "round function requires one or two arguments, got {}",
+            args.len()
+        )));
+    }
+
+    let mut decimal_places =
+        &(Arc::new(Int64Array::from_value(0, args[0].len())) as ArrayRef);
+
+    if args.len() == 2 {
+        decimal_places = &args[1];
+    }
+
+    match args[0].data_type() {
+        DataType::Float64 => Ok(Arc::new(make_function_inputs2!(
+            &args[0],
+            decimal_places,
+            "value",
+            "decimal_places",
+            Float64Array,
+            Int64Array,
+            {
+                |value: f64, decimal_places: i64| {
+                    (value * 10.0_f64.powi(decimal_places.try_into().unwrap())).round()
+                        / 10.0_f64.powi(decimal_places.try_into().unwrap())
+                }
+            }
+        )) as ArrayRef),
+
+        DataType::Float32 => Ok(Arc::new(make_function_inputs2!(
+            &args[0],
+            decimal_places,
+            "value",
+            "decimal_places",
+            Float32Array,
+            Int64Array,
+            {
+                |value: f32, decimal_places: i64| {
+                    (value * 10.0_f32.powi(decimal_places.try_into().unwrap())).round()
+                        / 10.0_f32.powi(decimal_places.try_into().unwrap())
+                }
+            }
+        )) as ArrayRef),
+
+        other => Err(DataFusionError::Internal(format!(
+            "Unsupported data type {other:?} for function round"
+        ))),
+    }
+}
+
 pub fn power(args: &[ArrayRef]) -> Result<ArrayRef> {
     match args[0].data_type() {
         DataType::Float64 => Ok(Arc::new(make_function_inputs2!(
@@ -202,4 +266,44 @@ mod tests {
         assert_eq!(floats.len(), 1);
         assert!(0.0 <= floats.value(0) && floats.value(0) < 1.0);
     }
+
+    #[test]
+    fn test_round_f32() {
+        let args: Vec<ArrayRef> = vec![
+            Arc::new(Float32Array::from(vec![125.2345; 10])), // input
+            Arc::new(Int64Array::from(vec![0, 1, 2, 3, 4, 5, -1, -2, -3, -4])), // decimal_places
+        ];
+
+        let result = round(&args).expect("failed to initialize function round");
+        let floats = result
+            .as_any()
+            .downcast_ref::<Float32Array>()
+            .expect("failed to initialize function round");
+
+        let expected = Float32Array::from(vec![
+            125.0, 125.2, 125.23, 125.235, 125.2345, 125.2345, 130.0, 100.0, 0.0, 0.0,
+        ]);
+
+        assert_eq!(floats, &expected);
+    }
+
+    #[test]
+    fn test_round_f64() {
+        let args: Vec<ArrayRef> = vec![
+            Arc::new(Float64Array::from(vec![125.2345; 10])), // input
+            Arc::new(Int64Array::from(vec![0, 1, 2, 3, 4, 5, -1, -2, -3, -4])), // decimal_places
+        ];
+
+        let result = round(&args).expect("failed to initialize function round");
+        let floats = result
+            .as_any()
+            .downcast_ref::<Float64Array>()
+            .expect("failed to initialize function round");
+
+        let expected = Float64Array::from(vec![
+            125.0, 125.2, 125.23, 125.235, 125.2345, 125.2345, 130.0, 100.0, 0.0, 0.0,
+        ]);
+
+        assert_eq!(floats, &expected);
+    }
 }
diff --git a/datafusion/proto/src/from_proto.rs b/datafusion/proto/src/from_proto.rs
@@ -1089,7 +1089,12 @@ pub fn parse_expr(
                 ScalarFunction::Log10 => Ok(log10(parse_expr(&args[0], registry)?)),
                 ScalarFunction::Floor => Ok(floor(parse_expr(&args[0], registry)?)),
                 ScalarFunction::Ceil => Ok(ceil(parse_expr(&args[0], registry)?)),
-                ScalarFunction::Round => Ok(round(parse_expr(&args[0], registry)?)),
+                ScalarFunction::Round => Ok(round(
+                    args.to_owned()
+                        .iter()
+                        .map(|expr| parse_expr(expr, registry))
+                        .collect::<Result<Vec<_>, _>>()?,
+                )),
                 ScalarFunction::Trunc => Ok(trunc(parse_expr(&args[0], registry)?)),
                 ScalarFunction::Abs => Ok(abs(parse_expr(&args[0], registry)?)),
                 ScalarFunction::Signum => Ok(signum(parse_expr(&args[0], registry)?)),
