move to private utils

Author: adriangb

datafusion/functions-aggregate-common/src/utils.rs

@@ -15,18 +15,13 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use arrow::array::{ArrayRef, ArrowNativeTypeOp, RecordBatch};
+use arrow::array::{ArrayRef, ArrowNativeTypeOp};
 use arrow::compute::SortOptions;
 use arrow::datatypes::{
-    ArrowNativeType, DataType, DecimalType, Field, FieldRef, Schema, ToByteSlice,
-};
-use datafusion_common::{
-    exec_err, internal_datafusion_err, internal_err, plan_err, DataFusionError, Result,
-    ScalarValue,
+    ArrowNativeType, DataType, DecimalType, Field, FieldRef, ToByteSlice,
 };
+use datafusion_common::{exec_err, internal_datafusion_err, Result};
 use datafusion_expr_common::accumulator::Accumulator;
-use datafusion_expr_common::columnar_value::ColumnarValue;
-use datafusion_physical_expr_common::physical_expr::PhysicalExpr;
 use datafusion_physical_expr_common::sort_expr::{LexOrdering, PhysicalSortExpr};
 use std::sync::Arc;
 
@@ -166,55 +161,3 @@ impl<T: DecimalType> DecimalAverager<T> {
         }
     }
 }
-
-/// Evaluates a physical expression to extract its scalar value.
-///
-/// This is used to extract constant values from expressions (like percentile parameters)
-/// by evaluating them against an empty record batch.
-pub fn get_percentile_scalar_value(expr: &Arc<dyn PhysicalExpr>) -> Result<ScalarValue> {
-    let empty_schema = Arc::new(Schema::empty());
-    let batch = RecordBatch::new_empty(Arc::clone(&empty_schema));
-    if let ColumnarValue::Scalar(s) = expr.evaluate(&batch)? {
-        Ok(s)
-    } else {
-        internal_err!("Didn't expect ColumnarValue::Array")
-    }
-}
-
-/// Validates that a percentile expression is a literal float value between 0.0 and 1.0.
-///
-/// Used by both `percentile_cont` and `approx_percentile_cont` to validate their
-/// percentile parameters.
-pub fn validate_percentile_expr(
-    expr: &Arc<dyn PhysicalExpr>,
-    fn_name: &str,
-) -> Result<f64> {
-    let scalar_value = get_percentile_scalar_value(expr).map_err(|_e| {
-        DataFusionError::Plan(format!(
-            "Percentile value for '{fn_name}' must be a literal"
-        ))
-    })?;
-
-    let percentile = match scalar_value {
-        ScalarValue::Float32(Some(value)) => {
-            value as f64
-        }
-        ScalarValue::Float64(Some(value)) => {
-            value
-        }
-        sv => {
-            return plan_err!(
-                "Percentile value for '{fn_name}' must be Float32 or Float64 literal (got data type {})",
-                sv.data_type()
-            )
-        }
-    };
-
-    // Ensure the percentile is between 0 and 1.
-    if !(0.0..=1.0).contains(&percentile) {
-        return plan_err!(
-            "Percentile value must be between 0.0 and 1.0 inclusive, {percentile} is invalid"
-        );
-    }
-    Ok(percentile)
-}

datafusion/functions-aggregate/src/approx_percentile_cont.rs

@@ -45,12 +45,11 @@ use datafusion_expr::{
 use datafusion_functions_aggregate_common::tdigest::{
     TDigest, TryIntoF64, DEFAULT_MAX_SIZE,
 };
-use datafusion_functions_aggregate_common::utils::{
-    get_percentile_scalar_value, validate_percentile_expr,
-};
 use datafusion_macros::user_doc;
 use datafusion_physical_expr_common::physical_expr::PhysicalExpr;
 
+use crate::utils::{get_percentile_scalar_value, validate_percentile_expr};
+
 create_func!(ApproxPercentileCont, approx_percentile_cont_udaf);
 
 /// Computes the approximate percentile continuous of a set of numbers

datafusion/functions-aggregate/src/lib.rs

@@ -89,6 +89,7 @@ pub mod sum;
 pub mod variance;
 
 pub mod planner;
+mod utils;
 
 use crate::approx_percentile_cont::approx_percentile_cont_udaf;
 use crate::approx_percentile_cont_with_weight::approx_percentile_cont_with_weight_udaf;

datafusion/functions-aggregate/src/percentile_cont.rs

@@ -48,9 +48,11 @@ use datafusion_expr::{
 use datafusion_expr::{EmitTo, GroupsAccumulator};
 use datafusion_functions_aggregate_common::aggregate::groups_accumulator::accumulate::accumulate;
 use datafusion_functions_aggregate_common::aggregate::groups_accumulator::nulls::filtered_null_mask;
-use datafusion_functions_aggregate_common::utils::{validate_percentile_expr, Hashable};
+use datafusion_functions_aggregate_common::utils::Hashable;
 use datafusion_macros::user_doc;
 
+use crate::utils::validate_percentile_expr;
+
 /// Precision multiplier for linear interpolation calculations.
 ///
 /// This value of 1,000,000 was chosen to balance precision with overflow safety: