Apache DataFusion SQL Query Engine
perf: Optimize scalar performance for cot (#19888)
Kumar Ujjawal4d8d48c0c7bc
diff --git a/datafusion/functions/benches/cot.rs b/datafusion/functions/benches/cot.rsindex c47198d4a6..061d14cbf0 100644--- a/datafusion/functions/benches/cot.rs+++ b/datafusion/functions/benches/cot.rs@@ -27,11 +27,15 @@ use datafusion_functions::math::cot;use std::hint::black_box;use arrow::datatypes::{DataType, Field};+use datafusion_common::ScalarValue;use datafusion_common::config::ConfigOptions;use std::sync::Arc;fn criterion_benchmark(c: &mut Criterion) {let cot_fn = cot();+ let config_options = Arc::new(ConfigOptions::default());++ // Array benchmarks - run for different sizesfor size in [1024, 4096, 8192] {let f32_array = Arc::new(create_primitive_array::<Float32Type>(size, 0.2));let f32_args = vec![ColumnarValue::Array(f32_array)];@@ -42,7 +46,6 @@ fn criterion_benchmark(c: &mut Criterion) {Field::new(format!("arg_{idx}"), arg.data_type(), true).into()}).collect::<Vec<_>>();- let config_options = Arc::new(ConfigOptions::default());c.bench_function(&format!("cot f32 array: {size}"), |b| {b.iter(|| {@@ -59,6 +62,7 @@ fn criterion_benchmark(c: &mut Criterion) {)})});+let f64_array = Arc::new(create_primitive_array::<Float64Type>(size, 0.2));let f64_args = vec![ColumnarValue::Array(f64_array)];let arg_fields = f64_args@@ -86,6 +90,47 @@ fn criterion_benchmark(c: &mut Criterion) {})});}++ // Scalar benchmarks - run only once since size doesn't affect scalar performance+ let scalar_f32_args = vec![ColumnarValue::Scalar(ScalarValue::Float32(Some(1.0)))];+ let scalar_f32_arg_fields = vec![Field::new("a", DataType::Float32, false).into()];+ let return_field_f32 = Field::new("f", DataType::Float32, false).into();++ c.bench_function("cot f32 scalar", |b| {+ b.iter(|| {+ black_box(+ cot_fn+ .invoke_with_args(ScalarFunctionArgs {+ args: scalar_f32_args.clone(),+ arg_fields: scalar_f32_arg_fields.clone(),+ number_rows: 1,+ return_field: Arc::clone(&return_field_f32),+ config_options: Arc::clone(&config_options),+ })+ .unwrap(),+ )+ })+ });++ let scalar_f64_args = vec![ColumnarValue::Scalar(ScalarValue::Float64(Some(1.0)))];+ let scalar_f64_arg_fields = vec![Field::new("a", DataType::Float64, false).into()];+ let return_field_f64 = Field::new("f", DataType::Float64, false).into();++ c.bench_function("cot f64 scalar", |b| {+ b.iter(|| {+ black_box(+ cot_fn+ .invoke_with_args(ScalarFunctionArgs {+ args: scalar_f64_args.clone(),+ arg_fields: scalar_f64_arg_fields.clone(),+ number_rows: 1,+ return_field: Arc::clone(&return_field_f64),+ config_options: Arc::clone(&config_options),+ })+ .unwrap(),+ )+ })+ });}criterion_group!(benches, criterion_benchmark);diff --git a/datafusion/functions/src/math/cot.rs b/datafusion/functions/src/math/cot.rsindex a0d7b02b68..1f67ef7138 100644--- a/datafusion/functions/src/math/cot.rs+++ b/datafusion/functions/src/math/cot.rs@@ -18,12 +18,12 @@use std::any::Any;use std::sync::Arc;-use arrow::array::{ArrayRef, AsArray};+use arrow::array::AsArray;use arrow::datatypes::DataType::{Float32, Float64};use arrow::datatypes::{DataType, Float32Type, Float64Type};-use crate::utils::make_scalar_function;-use datafusion_common::{Result, exec_err};+use datafusion_common::utils::take_function_args;+use datafusion_common::{Result, ScalarValue, internal_err};use datafusion_expr::{ColumnarValue, Documentation, ScalarFunctionArgs};use datafusion_expr::{ScalarUDFImpl, Signature, Volatility};use datafusion_macros::user_doc;@@ -96,24 +96,47 @@ impl ScalarUDFImpl for CotFunc {}fn invoke_with_args(&self, args: ScalarFunctionArgs) -> Result<ColumnarValue> {- make_scalar_function(cot, vec![])(&args.args)- }-}+ let return_field = args.return_field;+ let [arg] = take_function_args(self.name(), args.args)?;++ match arg {+ ColumnarValue::Scalar(scalar) => {+ if scalar.is_null() {+ return ColumnarValue::Scalar(ScalarValue::Null)+ .cast_to(return_field.data_type(), None);+ }-///cot SQL function-fn cot(args: &[ArrayRef]) -> Result<ArrayRef> {- match args[0].data_type() {- Float64 => Ok(Arc::new(- args[0]- .as_primitive::<Float64Type>()- .unary::<_, Float64Type>(|x: f64| compute_cot64(x)),- ) as ArrayRef),- Float32 => Ok(Arc::new(- args[0]- .as_primitive::<Float32Type>()- .unary::<_, Float32Type>(|x: f32| compute_cot32(x)),- ) as ArrayRef),- other => exec_err!("Unsupported data type {other:?} for function cot"),+ match scalar {+ ScalarValue::Float64(Some(v)) => Ok(ColumnarValue::Scalar(+ ScalarValue::Float64(Some(compute_cot64(v))),+ )),+ ScalarValue::Float32(Some(v)) => Ok(ColumnarValue::Scalar(+ ScalarValue::Float32(Some(compute_cot32(v))),+ )),+ _ => {+ internal_err!(+ "Unexpected scalar type for cot: {:?}",+ scalar.data_type()+ )+ }+ }+ }+ ColumnarValue::Array(array) => match array.data_type() {+ Float64 => Ok(ColumnarValue::Array(Arc::new(+ array+ .as_primitive::<Float64Type>()+ .unary::<_, Float64Type>(compute_cot64),+ ))),+ Float32 => Ok(ColumnarValue::Array(Arc::new(+ array+ .as_primitive::<Float32Type>()+ .unary::<_, Float32Type>(compute_cot32),+ ))),+ other => {+ internal_err!("Unexpected data type {other:?} for function cot")+ }+ },+ }}}@@ -129,54 +152,212 @@ fn compute_cot64(x: f64) -> f64 {#[cfg(test)]mod test {- use crate::math::cot::cot;+ use std::sync::Arc;+use arrow::array::{ArrayRef, Float32Array, Float64Array};+ use arrow::datatypes::{DataType, Field};+ use datafusion_common::ScalarValue;use datafusion_common::cast::{as_float32_array, as_float64_array};- use std::sync::Arc;+ use datafusion_common::config::ConfigOptions;+ use datafusion_expr::{ColumnarValue, ScalarFunctionArgs, ScalarUDFImpl};++ use crate::math::cot::CotFunc;#[test]fn test_cot_f32() {- let args: Vec<ArrayRef> =- vec![Arc::new(Float32Array::from(vec![12.1, 30.0, 90.0, -30.0]))];- let result = cot(&args).expect("failed to initialize function cot");- let floats =- as_float32_array(&result).expect("failed to initialize function cot");-- let expected = Float32Array::from(vec![- -1.986_460_4,- -0.156_119_96,- -0.501_202_8,- 0.156_119_96,- ]);-- let eps = 1e-6;- assert_eq!(floats.len(), 4);- assert!((floats.value(0) - expected.value(0)).abs() < eps);- assert!((floats.value(1) - expected.value(1)).abs() < eps);- assert!((floats.value(2) - expected.value(2)).abs() < eps);- assert!((floats.value(3) - expected.value(3)).abs() < eps);+ let array = Arc::new(Float32Array::from(vec![12.1, 30.0, 90.0, -30.0]));+ let arg_fields = vec![Field::new("a", DataType::Float32, false).into()];+ let args = ScalarFunctionArgs {+ args: vec![ColumnarValue::Array(Arc::clone(&array) as ArrayRef)],+ arg_fields,+ number_rows: array.len(),+ return_field: Field::new("f", DataType::Float32, true).into(),+ config_options: Arc::new(ConfigOptions::default()),+ };+ let result = CotFunc::new()+ .invoke_with_args(args)+ .expect("failed to initialize function cot");++ match result {+ ColumnarValue::Array(arr) => {+ let floats = as_float32_array(&arr)+ .expect("failed to convert result to a Float32Array");++ let expected = Float32Array::from(vec![+ -1.986_460_4,+ -0.156_119_96,+ -0.501_202_8,+ 0.156_119_96,+ ]);++ let eps = 1e-6;+ assert_eq!(floats.len(), 4);+ assert!((floats.value(0) - expected.value(0)).abs() < eps);+ assert!((floats.value(1) - expected.value(1)).abs() < eps);+ assert!((floats.value(2) - expected.value(2)).abs() < eps);+ assert!((floats.value(3) - expected.value(3)).abs() < eps);+ }+ ColumnarValue::Scalar(_) => {+ panic!("Expected an array value")+ }+ }}#[test]fn test_cot_f64() {- let args: Vec<ArrayRef> =- vec![Arc::new(Float64Array::from(vec![12.1, 30.0, 90.0, -30.0]))];- let result = cot(&args).expect("failed to initialize function cot");- let floats =- as_float64_array(&result).expect("failed to initialize function cot");-- let expected = Float64Array::from(vec![- -1.986_458_685_881_4,- -0.156_119_952_161_6,- -0.501_202_783_380_1,- 0.156_119_952_161_6,- ]);-- let eps = 1e-12;- assert_eq!(floats.len(), 4);- assert!((floats.value(0) - expected.value(0)).abs() < eps);- assert!((floats.value(1) - expected.value(1)).abs() < eps);- assert!((floats.value(2) - expected.value(2)).abs() < eps);- assert!((floats.value(3) - expected.value(3)).abs() < eps);+ let array = Arc::new(Float64Array::from(vec![12.1, 30.0, 90.0, -30.0]));+ let arg_fields = vec![Field::new("a", DataType::Float64, false).into()];+ let args = ScalarFunctionArgs {+ args: vec![ColumnarValue::Array(Arc::clone(&array) as ArrayRef)],+ arg_fields,+ number_rows: array.len(),+ return_field: Field::new("f", DataType::Float64, true).into(),+ config_options: Arc::new(ConfigOptions::default()),+ };+ let result = CotFunc::new()+ .invoke_with_args(args)+ .expect("failed to initialize function cot");++ match result {+ ColumnarValue::Array(arr) => {+ let floats = as_float64_array(&arr)+ .expect("failed to convert result to a Float64Array");++ let expected = Float64Array::from(vec![+ -1.986_458_685_881_4,+ -0.156_119_952_161_6,+ -0.501_202_783_380_1,+ 0.156_119_952_161_6,+ ]);++ let eps = 1e-12;+ assert_eq!(floats.len(), 4);+ assert!((floats.value(0) - expected.value(0)).abs() < eps);+ assert!((floats.value(1) - expected.value(1)).abs() < eps);+ assert!((floats.value(2) - expected.value(2)).abs() < eps);+ assert!((floats.value(3) - expected.value(3)).abs() < eps);+ }+ ColumnarValue::Scalar(_) => {+ panic!("Expected an array value")+ }+ }+ }++ #[test]+ fn test_cot_scalar_f64() {+ let arg_fields = vec![Field::new("a", DataType::Float64, false).into()];+ let args = ScalarFunctionArgs {+ args: vec![ColumnarValue::Scalar(ScalarValue::Float64(Some(1.0)))],+ arg_fields,+ number_rows: 1,+ return_field: Field::new("f", DataType::Float64, false).into(),+ config_options: Arc::new(ConfigOptions::default()),+ };+ let result = CotFunc::new()+ .invoke_with_args(args)+ .expect("cot scalar should succeed");++ match result {+ ColumnarValue::Scalar(ScalarValue::Float64(Some(v))) => {+ // cot(1.0) = 1/tan(1.0) ≈ 0.6420926159343306+ let expected = 1.0_f64 / 1.0_f64.tan();+ assert!((v - expected).abs() < 1e-12);+ }+ _ => panic!("Expected Float64 scalar"),+ }+ }++ #[test]+ fn test_cot_scalar_f32() {+ let arg_fields = vec![Field::new("a", DataType::Float32, false).into()];+ let args = ScalarFunctionArgs {+ args: vec![ColumnarValue::Scalar(ScalarValue::Float32(Some(1.0)))],+ arg_fields,+ number_rows: 1,+ return_field: Field::new("f", DataType::Float32, false).into(),+ config_options: Arc::new(ConfigOptions::default()),+ };+ let result = CotFunc::new()+ .invoke_with_args(args)+ .expect("cot scalar should succeed");++ match result {+ ColumnarValue::Scalar(ScalarValue::Float32(Some(v))) => {+ let expected = 1.0_f32 / 1.0_f32.tan();+ assert!((v - expected).abs() < 1e-6);+ }+ _ => panic!("Expected Float32 scalar"),+ }+ }++ #[test]+ fn test_cot_scalar_null() {+ let arg_fields = vec![Field::new("a", DataType::Float64, true).into()];+ let args = ScalarFunctionArgs {+ args: vec![ColumnarValue::Scalar(ScalarValue::Float64(None))],+ arg_fields,+ number_rows: 1,+ return_field: Field::new("f", DataType::Float64, true).into(),+ config_options: Arc::new(ConfigOptions::default()),+ };+ let result = CotFunc::new()+ .invoke_with_args(args)+ .expect("cot null should succeed");++ match result {+ ColumnarValue::Scalar(scalar) => {+ assert!(scalar.is_null());+ }+ _ => panic!("Expected scalar result"),+ }+ }++ #[test]+ fn test_cot_scalar_zero() {+ let arg_fields = vec![Field::new("a", DataType::Float64, false).into()];+ let args = ScalarFunctionArgs {+ args: vec![ColumnarValue::Scalar(ScalarValue::Float64(Some(0.0)))],+ arg_fields,+ number_rows: 1,+ return_field: Field::new("f", DataType::Float64, false).into(),+ config_options: Arc::new(ConfigOptions::default()),+ };+ let result = CotFunc::new()+ .invoke_with_args(args)+ .expect("cot zero should succeed");++ match result {+ ColumnarValue::Scalar(ScalarValue::Float64(Some(v))) => {+ // cot(0) = 1/tan(0) = infinity+ assert!(v.is_infinite());+ }+ _ => panic!("Expected Float64 scalar"),+ }+ }++ #[test]+ fn test_cot_scalar_pi() {+ let arg_fields = vec![Field::new("a", DataType::Float64, false).into()];+ let args = ScalarFunctionArgs {+ args: vec![ColumnarValue::Scalar(ScalarValue::Float64(Some(+ std::f64::consts::PI,+ )))],+ arg_fields,+ number_rows: 1,+ return_field: Field::new("f", DataType::Float64, false).into(),+ config_options: Arc::new(ConfigOptions::default()),+ };+ let result = CotFunc::new()+ .invoke_with_args(args)+ .expect("cot pi should succeed");++ match result {+ ColumnarValue::Scalar(ScalarValue::Float64(Some(v))) => {+ // cot(PI) = 1/tan(PI) - very large negative number due to floating point+ let expected = 1.0_f64 / std::f64::consts::PI.tan();+ assert!((v - expected).abs() < 1e-6);+ }+ _ => panic!("Expected Float64 scalar"),+ }}}