This is an automated email from the ASF dual-hosted git repository.
alamb pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/arrow-datafusion.git
The following commit(s) were added to refs/heads/main by this push:
new 66c8ba22aa move `Atan2`, `Atan`, `Acosh`, `Asinh`, `Atanh` to
`datafusion-function` (#9872)
66c8ba22aa is described below
commit 66c8ba22aa9569300c2ae12cef337fee089875e0
Author: Alex Huang <[email protected]>
AuthorDate: Sun Mar 31 17:41:15 2024 +0800
move `Atan2`, `Atan`, `Acosh`, `Asinh`, `Atanh` to `datafusion-function`
(#9872)
* Refactor math functions in datafusion code
* fic ci
* fix: avoid regression
* refactor: move atan2 function
* chore: move atan2 test
---
datafusion/expr/src/built_in_function.rs | 48 +-------
datafusion/expr/src/expr_fn.rs | 10 --
datafusion/functions/src/macros.rs | 29 +++++
datafusion/functions/src/math/atan2.rs | 140 +++++++++++++++++++++++
datafusion/functions/src/math/mod.rs | 14 ++-
datafusion/functions/src/utils.rs | 3 +
datafusion/physical-expr/src/functions.rs | 7 --
datafusion/physical-expr/src/math_expressions.rs | 61 ----------
datafusion/proto/proto/datafusion.proto | 10 +-
datafusion/proto/src/generated/pbjson.rs | 15 ---
datafusion/proto/src/generated/prost.rs | 20 +---
datafusion/proto/src/logical_plan/from_proto.rs | 23 +---
datafusion/proto/src/logical_plan/to_proto.rs | 5 -
13 files changed, 201 insertions(+), 184 deletions(-)
diff --git a/datafusion/expr/src/built_in_function.rs
b/datafusion/expr/src/built_in_function.rs
index f8d16f4650..a1b3b71739 100644
--- a/datafusion/expr/src/built_in_function.rs
+++ b/datafusion/expr/src/built_in_function.rs
@@ -37,16 +37,6 @@ use strum_macros::EnumIter;
#[derive(Debug, Clone, PartialEq, Eq, Hash, EnumIter, Copy)]
pub enum BuiltinScalarFunction {
// math functions
- /// atan
- Atan,
- /// atan2
- Atan2,
- /// acosh
- Acosh,
- /// asinh
- Asinh,
- /// atanh
- Atanh,
/// cbrt
Cbrt,
/// ceil
@@ -159,11 +149,6 @@ impl BuiltinScalarFunction {
pub fn volatility(&self) -> Volatility {
match self {
// Immutable scalar builtins
- BuiltinScalarFunction::Atan => Volatility::Immutable,
- BuiltinScalarFunction::Atan2 => Volatility::Immutable,
- BuiltinScalarFunction::Acosh => Volatility::Immutable,
- BuiltinScalarFunction::Asinh => Volatility::Immutable,
- BuiltinScalarFunction::Atanh => Volatility::Immutable,
BuiltinScalarFunction::Ceil => Volatility::Immutable,
BuiltinScalarFunction::Coalesce => Volatility::Immutable,
BuiltinScalarFunction::Cos => Volatility::Immutable,
@@ -238,11 +223,6 @@ impl BuiltinScalarFunction {
_ => Ok(Float64),
},
- BuiltinScalarFunction::Atan2 => match &input_expr_types[0] {
- Float32 => Ok(Float32),
- _ => Ok(Float64),
- },
-
BuiltinScalarFunction::Log => match &input_expr_types[0] {
Float32 => Ok(Float32),
_ => Ok(Float64),
@@ -255,11 +235,7 @@ impl BuiltinScalarFunction {
BuiltinScalarFunction::Iszero => Ok(Boolean),
- BuiltinScalarFunction::Atan
- | BuiltinScalarFunction::Acosh
- | BuiltinScalarFunction::Asinh
- | BuiltinScalarFunction::Atanh
- | BuiltinScalarFunction::Ceil
+ BuiltinScalarFunction::Ceil
| BuiltinScalarFunction::Cos
| BuiltinScalarFunction::Cosh
| BuiltinScalarFunction::Degrees
@@ -332,10 +308,7 @@ impl BuiltinScalarFunction {
],
self.volatility(),
),
- BuiltinScalarFunction::Atan2 => Signature::one_of(
- vec![Exact(vec![Float32, Float32]), Exact(vec![Float64,
Float64])],
- self.volatility(),
- ),
+
BuiltinScalarFunction::Log => Signature::one_of(
vec![
Exact(vec![Float32]),
@@ -355,11 +328,7 @@ impl BuiltinScalarFunction {
BuiltinScalarFunction::Gcd | BuiltinScalarFunction::Lcm => {
Signature::uniform(2, vec![Int64], self.volatility())
}
- BuiltinScalarFunction::Atan
- | BuiltinScalarFunction::Acosh
- | BuiltinScalarFunction::Asinh
- | BuiltinScalarFunction::Atanh
- | BuiltinScalarFunction::Cbrt
+ BuiltinScalarFunction::Cbrt
| BuiltinScalarFunction::Ceil
| BuiltinScalarFunction::Cos
| BuiltinScalarFunction::Cosh
@@ -392,11 +361,7 @@ impl BuiltinScalarFunction {
pub fn monotonicity(&self) -> Option<FuncMonotonicity> {
if matches!(
&self,
- BuiltinScalarFunction::Atan
- | BuiltinScalarFunction::Acosh
- | BuiltinScalarFunction::Asinh
- | BuiltinScalarFunction::Atanh
- | BuiltinScalarFunction::Ceil
+ BuiltinScalarFunction::Ceil
| BuiltinScalarFunction::Degrees
| BuiltinScalarFunction::Exp
| BuiltinScalarFunction::Factorial
@@ -421,11 +386,6 @@ impl BuiltinScalarFunction {
/// Returns all names that can be used to call this function
pub fn aliases(&self) -> &'static [&'static str] {
match self {
- BuiltinScalarFunction::Acosh => &["acosh"],
- BuiltinScalarFunction::Asinh => &["asinh"],
- BuiltinScalarFunction::Atan => &["atan"],
- BuiltinScalarFunction::Atanh => &["atanh"],
- BuiltinScalarFunction::Atan2 => &["atan2"],
BuiltinScalarFunction::Cbrt => &["cbrt"],
BuiltinScalarFunction::Ceil => &["ceil"],
BuiltinScalarFunction::Cos => &["cos"],
diff --git a/datafusion/expr/src/expr_fn.rs b/datafusion/expr/src/expr_fn.rs
index ab5628fece..a201578704 100644
--- a/datafusion/expr/src/expr_fn.rs
+++ b/datafusion/expr/src/expr_fn.rs
@@ -541,10 +541,6 @@ scalar_expr!(Cos, cos, num, "cosine");
scalar_expr!(Cot, cot, num, "cotangent");
scalar_expr!(Sinh, sinh, num, "hyperbolic sine");
scalar_expr!(Cosh, cosh, num, "hyperbolic cosine");
-scalar_expr!(Atan, atan, num, "inverse tangent");
-scalar_expr!(Asinh, asinh, num, "inverse hyperbolic sine");
-scalar_expr!(Acosh, acosh, num, "inverse hyperbolic cosine");
-scalar_expr!(Atanh, atanh, num, "inverse hyperbolic tangent");
scalar_expr!(Factorial, factorial, num, "factorial");
scalar_expr!(
Floor,
@@ -571,7 +567,6 @@ scalar_expr!(Exp, exp, num, "exponential");
scalar_expr!(Gcd, gcd, arg_1 arg_2, "greatest common divisor");
scalar_expr!(Lcm, lcm, arg_1 arg_2, "least common multiple");
scalar_expr!(Power, power, base exponent, "`base` raised to the power of
`exponent`");
-scalar_expr!(Atan2, atan2, y x, "inverse tangent of a division given in the
argument");
scalar_expr!(Log, log, base x, "logarithm of a `x` for a particular `base`");
scalar_expr!(InitCap, initcap, string, "converts the first letter of each word
in `string` in uppercase and the remaining characters in lowercase");
@@ -979,10 +974,6 @@ mod test {
test_unary_scalar_expr!(Cot, cot);
test_unary_scalar_expr!(Sinh, sinh);
test_unary_scalar_expr!(Cosh, cosh);
- test_unary_scalar_expr!(Atan, atan);
- test_unary_scalar_expr!(Asinh, asinh);
- test_unary_scalar_expr!(Acosh, acosh);
- test_unary_scalar_expr!(Atanh, atanh);
test_unary_scalar_expr!(Factorial, factorial);
test_unary_scalar_expr!(Floor, floor);
test_unary_scalar_expr!(Ceil, ceil);
@@ -994,7 +985,6 @@ mod test {
test_nary_scalar_expr!(Trunc, trunc, num, precision);
test_unary_scalar_expr!(Signum, signum);
test_unary_scalar_expr!(Exp, exp);
- test_scalar_expr!(Atan2, atan2, y, x);
test_scalar_expr!(Nanvl, nanvl, x, y);
test_scalar_expr!(Iszero, iszero, input);
diff --git a/datafusion/functions/src/macros.rs
b/datafusion/functions/src/macros.rs
index b23baeeacf..4907d74fe9 100644
--- a/datafusion/functions/src/macros.rs
+++ b/datafusion/functions/src/macros.rs
@@ -156,6 +156,7 @@ macro_rules! downcast_arg {
/// $GNAME: a singleton instance of the UDF
/// $NAME: the name of the function
/// $UNARY_FUNC: the unary function to apply to the argument
+/// $MONOTONIC_FUNC: the monotonicity of the function
macro_rules! make_math_unary_udf {
($UDF:ident, $GNAME:ident, $NAME:ident, $UNARY_FUNC:ident,
$MONOTONICITY:expr) => {
make_udf_function!($NAME::$UDF, $GNAME, $NAME);
@@ -249,3 +250,31 @@ macro_rules! make_math_unary_udf {
}
};
}
+
+#[macro_export]
+macro_rules! make_function_inputs2 {
+ ($ARG1: expr, $ARG2: expr, $NAME1:expr, $NAME2: expr, $ARRAY_TYPE:ident,
$FUNC: block) => {{
+ let arg1 = downcast_arg!($ARG1, $NAME1, $ARRAY_TYPE);
+ let arg2 = downcast_arg!($ARG2, $NAME2, $ARRAY_TYPE);
+
+ 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_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>()
+ }};
+}
diff --git a/datafusion/functions/src/math/atan2.rs
b/datafusion/functions/src/math/atan2.rs
new file mode 100644
index 0000000000..b090c6c454
--- /dev/null
+++ b/datafusion/functions/src/math/atan2.rs
@@ -0,0 +1,140 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements. See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership. The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License. You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+//! Math function: `atan2()`.
+
+use arrow::array::{ArrayRef, Float32Array, Float64Array};
+use arrow::datatypes::DataType;
+use datafusion_common::DataFusionError;
+use datafusion_common::{exec_err, Result};
+use datafusion_expr::ColumnarValue;
+use datafusion_expr::TypeSignature::*;
+use datafusion_expr::{ScalarUDFImpl, Signature, Volatility};
+use std::any::Any;
+use std::sync::Arc;
+
+use crate::make_function_inputs2;
+use crate::utils::make_scalar_function;
+
+#[derive(Debug)]
+pub(super) struct Atan2 {
+ signature: Signature,
+}
+
+impl Atan2 {
+ pub fn new() -> Self {
+ use DataType::*;
+ Self {
+ signature: Signature::one_of(
+ vec![Exact(vec![Float32, Float32]), Exact(vec![Float64,
Float64])],
+ Volatility::Immutable,
+ ),
+ }
+ }
+}
+
+impl ScalarUDFImpl for Atan2 {
+ fn as_any(&self) -> &dyn Any {
+ self
+ }
+ fn name(&self) -> &str {
+ "atan2"
+ }
+
+ fn signature(&self) -> &Signature {
+ &self.signature
+ }
+
+ fn return_type(&self, arg_types: &[DataType]) -> Result<DataType> {
+ use self::DataType::*;
+ match &arg_types[0] {
+ Float32 => Ok(Float32),
+ _ => Ok(Float64),
+ }
+ }
+
+ fn invoke(&self, args: &[ColumnarValue]) -> Result<ColumnarValue> {
+ make_scalar_function(atan2, vec![])(args)
+ }
+}
+
+/// Atan2 SQL function
+pub fn atan2(args: &[ArrayRef]) -> Result<ArrayRef> {
+ match args[0].data_type() {
+ DataType::Float64 => Ok(Arc::new(make_function_inputs2!(
+ &args[0],
+ &args[1],
+ "y",
+ "x",
+ Float64Array,
+ { f64::atan2 }
+ )) as ArrayRef),
+
+ DataType::Float32 => Ok(Arc::new(make_function_inputs2!(
+ &args[0],
+ &args[1],
+ "y",
+ "x",
+ Float32Array,
+ { f32::atan2 }
+ )) as ArrayRef),
+
+ other => exec_err!("Unsupported data type {other:?} for function
atan2"),
+ }
+}
+
+#[cfg(test)]
+mod test {
+ use super::*;
+ use datafusion_common::cast::{as_float32_array, as_float64_array};
+
+ #[test]
+ fn test_atan2_f64() {
+ let args: Vec<ArrayRef> = vec![
+ Arc::new(Float64Array::from(vec![2.0, -3.0, 4.0, -5.0])), // y
+ Arc::new(Float64Array::from(vec![1.0, 2.0, -3.0, -4.0])), // x
+ ];
+
+ let result = atan2(&args).expect("failed to initialize function
atan2");
+ let floats =
+ as_float64_array(&result).expect("failed to initialize function
atan2");
+
+ assert_eq!(floats.len(), 4);
+ assert_eq!(floats.value(0), (2.0_f64).atan2(1.0));
+ assert_eq!(floats.value(1), (-3.0_f64).atan2(2.0));
+ assert_eq!(floats.value(2), (4.0_f64).atan2(-3.0));
+ assert_eq!(floats.value(3), (-5.0_f64).atan2(-4.0));
+ }
+
+ #[test]
+ fn test_atan2_f32() {
+ let args: Vec<ArrayRef> = vec![
+ Arc::new(Float32Array::from(vec![2.0, -3.0, 4.0, -5.0])), // y
+ Arc::new(Float32Array::from(vec![1.0, 2.0, -3.0, -4.0])), // x
+ ];
+
+ let result = atan2(&args).expect("failed to initialize function
atan2");
+ let floats =
+ as_float32_array(&result).expect("failed to initialize function
atan2");
+
+ assert_eq!(floats.len(), 4);
+ assert_eq!(floats.value(0), (2.0_f32).atan2(1.0));
+ assert_eq!(floats.value(1), (-3.0_f32).atan2(2.0));
+ assert_eq!(floats.value(2), (4.0_f32).atan2(-3.0));
+ assert_eq!(floats.value(3), (-5.0_f32).atan2(-4.0));
+ }
+}
diff --git a/datafusion/functions/src/math/mod.rs
b/datafusion/functions/src/math/mod.rs
index 3a4c1b1e87..2ee1fffa16 100644
--- a/datafusion/functions/src/math/mod.rs
+++ b/datafusion/functions/src/math/mod.rs
@@ -18,11 +18,13 @@
//! "math" DataFusion functions
mod abs;
+mod atan2;
mod nans;
// Create UDFs
make_udf_function!(nans::IsNanFunc, ISNAN, isnan);
make_udf_function!(abs::AbsFunc, ABS, abs);
+make_udf_function!(atan2::Atan2, ATAN2, atan2);
make_math_unary_udf!(Log2Func, LOG2, log2, log2, Some(vec![Some(true)]));
make_math_unary_udf!(Log10Func, LOG10, log10, log10, Some(vec![Some(true)]));
@@ -33,6 +35,11 @@ make_math_unary_udf!(AcosFunc, ACOS, acos, acos, None);
make_math_unary_udf!(AsinFunc, ASIN, asin, asin, None);
make_math_unary_udf!(TanFunc, TAN, tan, tan, None);
+make_math_unary_udf!(AtanhFunc, ATANH, atanh, atanh, Some(vec![Some(true)]));
+make_math_unary_udf!(AsinhFunc, ASINH, asinh, asinh, Some(vec![Some(true)]));
+make_math_unary_udf!(AcoshFunc, ACOSH, acosh, acosh, Some(vec![Some(true)]));
+make_math_unary_udf!(AtanFunc, ATAN, atan, atan, Some(vec![Some(true)]));
+
// Export the functions out of this package, both as expr_fn as well as a list
of functions
export_functions!(
(
@@ -55,5 +62,10 @@ export_functions!(
"returns the arc sine or inverse sine of a number"
),
(tan, num, "returns the tangent of a number"),
- (tanh, num, "returns the hyperbolic tangent of a number")
+ (tanh, num, "returns the hyperbolic tangent of a number"),
+ (atanh, num, "returns inverse hyperbolic tangent"),
+ (asinh, num, "returns inverse hyperbolic sine"),
+ (acosh, num, "returns inverse hyperbolic cosine"),
+ (atan, num, "returns inverse tangent"),
+ (atan2, y x, "returns inverse tangent of a division given in the argument")
);
diff --git a/datafusion/functions/src/utils.rs
b/datafusion/functions/src/utils.rs
index f45deafdb3..9b7144b483 100644
--- a/datafusion/functions/src/utils.rs
+++ b/datafusion/functions/src/utils.rs
@@ -68,6 +68,9 @@ get_optimal_return_type!(utf8_to_str_type,
DataType::LargeUtf8, DataType::Utf8);
// `utf8_to_int_type`: returns either a Int32 or Int64 based on the input type
size.
get_optimal_return_type!(utf8_to_int_type, DataType::Int64, DataType::Int32);
+/// Creates a scalar function implementation for the given function.
+/// * `inner` - the function to be executed
+/// * `hints` - hints to be used when expanding scalars to arrays
pub(super) fn make_scalar_function<F>(
inner: F,
hints: Vec<Hint>,
diff --git a/datafusion/physical-expr/src/functions.rs
b/datafusion/physical-expr/src/functions.rs
index 5b9b46c399..a1e471bdd4 100644
--- a/datafusion/physical-expr/src/functions.rs
+++ b/datafusion/physical-expr/src/functions.rs
@@ -179,10 +179,6 @@ pub fn create_physical_fun(
) -> Result<ScalarFunctionImplementation> {
Ok(match fun {
// math functions
- BuiltinScalarFunction::Atan => Arc::new(math_expressions::atan),
- BuiltinScalarFunction::Acosh => Arc::new(math_expressions::acosh),
- BuiltinScalarFunction::Asinh => Arc::new(math_expressions::asinh),
- BuiltinScalarFunction::Atanh => Arc::new(math_expressions::atanh),
BuiltinScalarFunction::Ceil => Arc::new(math_expressions::ceil),
BuiltinScalarFunction::Cos => Arc::new(math_expressions::cos),
BuiltinScalarFunction::Cosh => Arc::new(math_expressions::cosh),
@@ -221,9 +217,6 @@ pub fn create_physical_fun(
BuiltinScalarFunction::Power => {
Arc::new(|args|
make_scalar_function_inner(math_expressions::power)(args))
}
- BuiltinScalarFunction::Atan2 => {
- Arc::new(|args|
make_scalar_function_inner(math_expressions::atan2)(args))
- }
BuiltinScalarFunction::Log => {
Arc::new(|args|
make_scalar_function_inner(math_expressions::log)(args))
}
diff --git a/datafusion/physical-expr/src/math_expressions.rs
b/datafusion/physical-expr/src/math_expressions.rs
index db8855cb54..5339c12f6e 100644
--- a/datafusion/physical-expr/src/math_expressions.rs
+++ b/datafusion/physical-expr/src/math_expressions.rs
@@ -492,31 +492,6 @@ pub fn power(args: &[ArrayRef]) -> Result<ArrayRef> {
}
}
-/// Atan2 SQL function
-pub fn atan2(args: &[ArrayRef]) -> Result<ArrayRef> {
- match args[0].data_type() {
- DataType::Float64 => Ok(Arc::new(make_function_inputs2!(
- &args[0],
- &args[1],
- "y",
- "x",
- Float64Array,
- { f64::atan2 }
- )) as ArrayRef),
-
- DataType::Float32 => Ok(Arc::new(make_function_inputs2!(
- &args[0],
- &args[1],
- "y",
- "x",
- Float32Array,
- { f32::atan2 }
- )) as ArrayRef),
-
- other => exec_err!("Unsupported data type {other:?} for function
atan2"),
- }
-}
-
/// Log SQL function
pub fn log(args: &[ArrayRef]) -> Result<ArrayRef> {
// Support overloaded log(base, x) and log(x) which defaults to log(10, x)
@@ -725,42 +700,6 @@ mod tests {
assert_eq!(floats.value(3), 625);
}
- #[test]
- fn test_atan2_f64() {
- let args: Vec<ArrayRef> = vec![
- Arc::new(Float64Array::from(vec![2.0, -3.0, 4.0, -5.0])), // y
- Arc::new(Float64Array::from(vec![1.0, 2.0, -3.0, -4.0])), // x
- ];
-
- let result = atan2(&args).expect("failed to initialize function
atan2");
- let floats =
- as_float64_array(&result).expect("failed to initialize function
atan2");
-
- assert_eq!(floats.len(), 4);
- assert_eq!(floats.value(0), (2.0_f64).atan2(1.0));
- assert_eq!(floats.value(1), (-3.0_f64).atan2(2.0));
- assert_eq!(floats.value(2), (4.0_f64).atan2(-3.0));
- assert_eq!(floats.value(3), (-5.0_f64).atan2(-4.0));
- }
-
- #[test]
- fn test_atan2_f32() {
- let args: Vec<ArrayRef> = vec![
- Arc::new(Float32Array::from(vec![2.0, -3.0, 4.0, -5.0])), // y
- Arc::new(Float32Array::from(vec![1.0, 2.0, -3.0, -4.0])), // x
- ];
-
- let result = atan2(&args).expect("failed to initialize function
atan2");
- let floats =
- as_float32_array(&result).expect("failed to initialize function
atan2");
-
- assert_eq!(floats.len(), 4);
- assert_eq!(floats.value(0), (2.0_f32).atan2(1.0));
- assert_eq!(floats.value(1), (-3.0_f32).atan2(2.0));
- assert_eq!(floats.value(2), (4.0_f32).atan2(-3.0));
- assert_eq!(floats.value(3), (-5.0_f32).atan2(-4.0));
- }
-
#[test]
fn test_log_f64() {
let args: Vec<ArrayRef> = vec![
diff --git a/datafusion/proto/proto/datafusion.proto
b/datafusion/proto/proto/datafusion.proto
index b756e0575d..e959cad2a8 100644
--- a/datafusion/proto/proto/datafusion.proto
+++ b/datafusion/proto/proto/datafusion.proto
@@ -544,7 +544,7 @@ enum ScalarFunction {
unknown = 0;
// 1 was Acos
// 2 was Asin
- Atan = 3;
+ // 3 was Atan
// 4 was Ascii
Ceil = 5;
Cos = 6;
@@ -608,16 +608,16 @@ enum ScalarFunction {
Power = 64;
// 65 was StructFun
// 66 was FromUnixtime
- Atan2 = 67;
+ // 67 Atan2
// 68 was DateBin
// 69 was ArrowTypeof
// 70 was CurrentDate
// 71 was CurrentTime
// 72 was Uuid
Cbrt = 73;
- Acosh = 74;
- Asinh = 75;
- Atanh = 76;
+ // 74 Acosh
+ // 75 was Asinh
+ // 76 was Atanh
Sinh = 77;
Cosh = 78;
// Tanh = 79;
diff --git a/datafusion/proto/src/generated/pbjson.rs
b/datafusion/proto/src/generated/pbjson.rs
index 3c3d603007..d900d0031d 100644
--- a/datafusion/proto/src/generated/pbjson.rs
+++ b/datafusion/proto/src/generated/pbjson.rs
@@ -22914,7 +22914,6 @@ impl serde::Serialize for ScalarFunction {
{
let variant = match self {
Self::Unknown => "unknown",
- Self::Atan => "Atan",
Self::Ceil => "Ceil",
Self::Cos => "Cos",
Self::Exp => "Exp",
@@ -22931,11 +22930,7 @@ impl serde::Serialize for ScalarFunction {
Self::Random => "Random",
Self::Coalesce => "Coalesce",
Self::Power => "Power",
- Self::Atan2 => "Atan2",
Self::Cbrt => "Cbrt",
- Self::Acosh => "Acosh",
- Self::Asinh => "Asinh",
- Self::Atanh => "Atanh",
Self::Sinh => "Sinh",
Self::Cosh => "Cosh",
Self::Pi => "Pi",
@@ -22960,7 +22955,6 @@ impl<'de> serde::Deserialize<'de> for ScalarFunction {
{
const FIELDS: &[&str] = &[
"unknown",
- "Atan",
"Ceil",
"Cos",
"Exp",
@@ -22977,11 +22971,7 @@ impl<'de> serde::Deserialize<'de> for ScalarFunction {
"Random",
"Coalesce",
"Power",
- "Atan2",
"Cbrt",
- "Acosh",
- "Asinh",
- "Atanh",
"Sinh",
"Cosh",
"Pi",
@@ -23035,7 +23025,6 @@ impl<'de> serde::Deserialize<'de> for ScalarFunction {
{
match value {
"unknown" => Ok(ScalarFunction::Unknown),
- "Atan" => Ok(ScalarFunction::Atan),
"Ceil" => Ok(ScalarFunction::Ceil),
"Cos" => Ok(ScalarFunction::Cos),
"Exp" => Ok(ScalarFunction::Exp),
@@ -23052,11 +23041,7 @@ impl<'de> serde::Deserialize<'de> for ScalarFunction {
"Random" => Ok(ScalarFunction::Random),
"Coalesce" => Ok(ScalarFunction::Coalesce),
"Power" => Ok(ScalarFunction::Power),
- "Atan2" => Ok(ScalarFunction::Atan2),
"Cbrt" => Ok(ScalarFunction::Cbrt),
- "Acosh" => Ok(ScalarFunction::Acosh),
- "Asinh" => Ok(ScalarFunction::Asinh),
- "Atanh" => Ok(ScalarFunction::Atanh),
"Sinh" => Ok(ScalarFunction::Sinh),
"Cosh" => Ok(ScalarFunction::Cosh),
"Pi" => Ok(ScalarFunction::Pi),
diff --git a/datafusion/proto/src/generated/prost.rs
b/datafusion/proto/src/generated/prost.rs
index 9860587d3e..753abb4e27 100644
--- a/datafusion/proto/src/generated/prost.rs
+++ b/datafusion/proto/src/generated/prost.rs
@@ -2843,7 +2843,7 @@ pub enum ScalarFunction {
Unknown = 0,
/// 1 was Acos
/// 2 was Asin
- Atan = 3,
+ /// 3 was Atan
/// 4 was Ascii
Ceil = 5,
Cos = 6,
@@ -2907,16 +2907,16 @@ pub enum ScalarFunction {
Power = 64,
/// 65 was StructFun
/// 66 was FromUnixtime
- Atan2 = 67,
+ /// 67 Atan2
/// 68 was DateBin
/// 69 was ArrowTypeof
/// 70 was CurrentDate
/// 71 was CurrentTime
/// 72 was Uuid
Cbrt = 73,
- Acosh = 74,
- Asinh = 75,
- Atanh = 76,
+ /// 74 Acosh
+ /// 75 was Asinh
+ /// 76 was Atanh
Sinh = 77,
Cosh = 78,
/// Tanh = 79;
@@ -2987,7 +2987,6 @@ impl ScalarFunction {
pub fn as_str_name(&self) -> &'static str {
match self {
ScalarFunction::Unknown => "unknown",
- ScalarFunction::Atan => "Atan",
ScalarFunction::Ceil => "Ceil",
ScalarFunction::Cos => "Cos",
ScalarFunction::Exp => "Exp",
@@ -3004,11 +3003,7 @@ impl ScalarFunction {
ScalarFunction::Random => "Random",
ScalarFunction::Coalesce => "Coalesce",
ScalarFunction::Power => "Power",
- ScalarFunction::Atan2 => "Atan2",
ScalarFunction::Cbrt => "Cbrt",
- ScalarFunction::Acosh => "Acosh",
- ScalarFunction::Asinh => "Asinh",
- ScalarFunction::Atanh => "Atanh",
ScalarFunction::Sinh => "Sinh",
ScalarFunction::Cosh => "Cosh",
ScalarFunction::Pi => "Pi",
@@ -3027,7 +3022,6 @@ impl ScalarFunction {
pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
match value {
"unknown" => Some(Self::Unknown),
- "Atan" => Some(Self::Atan),
"Ceil" => Some(Self::Ceil),
"Cos" => Some(Self::Cos),
"Exp" => Some(Self::Exp),
@@ -3044,11 +3038,7 @@ impl ScalarFunction {
"Random" => Some(Self::Random),
"Coalesce" => Some(Self::Coalesce),
"Power" => Some(Self::Power),
- "Atan2" => Some(Self::Atan2),
"Cbrt" => Some(Self::Cbrt),
- "Acosh" => Some(Self::Acosh),
- "Asinh" => Some(Self::Asinh),
- "Atanh" => Some(Self::Atanh),
"Sinh" => Some(Self::Sinh),
"Cosh" => Some(Self::Cosh),
"Pi" => Some(Self::Pi),
diff --git a/datafusion/proto/src/logical_plan/from_proto.rs
b/datafusion/proto/src/logical_plan/from_proto.rs
index c068cfd46c..f9e2dc5596 100644
--- a/datafusion/proto/src/logical_plan/from_proto.rs
+++ b/datafusion/proto/src/logical_plan/from_proto.rs
@@ -37,8 +37,8 @@ use datafusion_expr::expr::Unnest;
use datafusion_expr::expr::{Alias, Placeholder};
use datafusion_expr::window_frame::{check_window_frame,
regularize_window_order_by};
use datafusion_expr::{
- acosh, asinh, atan, atan2, atanh, cbrt, ceil, coalesce, concat_expr,
concat_ws_expr,
- cos, cosh, cot, degrees, ends_with, exp,
+ cbrt, ceil, coalesce, concat_expr, concat_ws_expr, cos, cosh, cot, degrees,
+ ends_with, exp,
expr::{self, InList, Sort, WindowFunction},
factorial, floor, gcd, initcap, iszero, lcm, log,
logical_plan::{PlanType, StringifiedPlan},
@@ -428,12 +428,8 @@ impl From<&protobuf::ScalarFunction> for
BuiltinScalarFunction {
ScalarFunction::Sin => Self::Sin,
ScalarFunction::Cos => Self::Cos,
ScalarFunction::Cot => Self::Cot,
- ScalarFunction::Atan => Self::Atan,
ScalarFunction::Sinh => Self::Sinh,
ScalarFunction::Cosh => Self::Cosh,
- ScalarFunction::Asinh => Self::Asinh,
- ScalarFunction::Acosh => Self::Acosh,
- ScalarFunction::Atanh => Self::Atanh,
ScalarFunction::Exp => Self::Exp,
ScalarFunction::Log => Self::Log,
ScalarFunction::Degrees => Self::Degrees,
@@ -454,7 +450,6 @@ impl From<&protobuf::ScalarFunction> for
BuiltinScalarFunction {
ScalarFunction::Coalesce => Self::Coalesce,
ScalarFunction::Pi => Self::Pi,
ScalarFunction::Power => Self::Power,
- ScalarFunction::Atan2 => Self::Atan2,
ScalarFunction::Nanvl => Self::Nanvl,
ScalarFunction::Iszero => Self::Iszero,
}
@@ -1318,22 +1313,12 @@ pub fn parse_expr(
match scalar_function {
ScalarFunction::Unknown => Err(proto_error("Unknown scalar
function")),
- ScalarFunction::Asinh => {
- Ok(asinh(parse_expr(&args[0], registry, codec)?))
- }
- ScalarFunction::Acosh => {
- Ok(acosh(parse_expr(&args[0], registry, codec)?))
- }
ScalarFunction::Sqrt => Ok(sqrt(parse_expr(&args[0], registry,
codec)?)),
ScalarFunction::Cbrt => Ok(cbrt(parse_expr(&args[0], registry,
codec)?)),
ScalarFunction::Sin => Ok(sin(parse_expr(&args[0], registry,
codec)?)),
ScalarFunction::Cos => Ok(cos(parse_expr(&args[0], registry,
codec)?)),
- ScalarFunction::Atan => Ok(atan(parse_expr(&args[0], registry,
codec)?)),
ScalarFunction::Sinh => Ok(sinh(parse_expr(&args[0], registry,
codec)?)),
ScalarFunction::Cosh => Ok(cosh(parse_expr(&args[0], registry,
codec)?)),
- ScalarFunction::Atanh => {
- Ok(atanh(parse_expr(&args[0], registry, codec)?))
- }
ScalarFunction::Exp => Ok(exp(parse_expr(&args[0], registry,
codec)?)),
ScalarFunction::Degrees => {
Ok(degrees(parse_expr(&args[0], registry, codec)?))
@@ -1387,10 +1372,6 @@ pub fn parse_expr(
parse_expr(&args[0], registry, codec)?,
parse_expr(&args[1], registry, codec)?,
)),
- ScalarFunction::Atan2 => Ok(atan2(
- parse_expr(&args[0], registry, codec)?,
- parse_expr(&args[1], registry, codec)?,
- )),
ScalarFunction::Cot => Ok(cot(parse_expr(&args[0], registry,
codec)?)),
ScalarFunction::Nanvl => Ok(nanvl(
parse_expr(&args[0], registry, codec)?,
diff --git a/datafusion/proto/src/logical_plan/to_proto.rs
b/datafusion/proto/src/logical_plan/to_proto.rs
index 9d433bb6ff..3ee69066e1 100644
--- a/datafusion/proto/src/logical_plan/to_proto.rs
+++ b/datafusion/proto/src/logical_plan/to_proto.rs
@@ -1422,10 +1422,6 @@ impl TryFrom<&BuiltinScalarFunction> for
protobuf::ScalarFunction {
BuiltinScalarFunction::Cot => Self::Cot,
BuiltinScalarFunction::Sinh => Self::Sinh,
BuiltinScalarFunction::Cosh => Self::Cosh,
- BuiltinScalarFunction::Atan => Self::Atan,
- BuiltinScalarFunction::Asinh => Self::Asinh,
- BuiltinScalarFunction::Acosh => Self::Acosh,
- BuiltinScalarFunction::Atanh => Self::Atanh,
BuiltinScalarFunction::Exp => Self::Exp,
BuiltinScalarFunction::Factorial => Self::Factorial,
BuiltinScalarFunction::Gcd => Self::Gcd,
@@ -1446,7 +1442,6 @@ impl TryFrom<&BuiltinScalarFunction> for
protobuf::ScalarFunction {
BuiltinScalarFunction::Coalesce => Self::Coalesce,
BuiltinScalarFunction::Pi => Self::Pi,
BuiltinScalarFunction::Power => Self::Power,
- BuiltinScalarFunction::Atan2 => Self::Atan2,
BuiltinScalarFunction::Nanvl => Self::Nanvl,
BuiltinScalarFunction::Iszero => Self::Iszero,
};
