[arrow-datafusion] branch main updated: feat: degrees and radians (#6023)

[yj...@apache.org]

This is an automated email from the ASF dual-hosted git repository.

yjshen 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 427231ef88 feat: degrees and radians (#6023)
427231ef88 is described below

commit 427231ef886fb698e71509b59b7a4654a08cd0ff
Author: Igor Izvekov <iz...@gmail.com>
AuthorDate: Wed Apr 19 04:34:01 2023 +0300

    feat: degrees and radians (#6023)
    
    * feat: degrees and radians
    
    * fix: expressions.md
    
    * fix: use prettier
---
 .../core/tests/sqllogictests/test_files/scalar.slt | 24 ++++++++++++++++++
 datafusion/expr/src/built_in_function.rs           |  8 ++++++
 datafusion/expr/src/expr_fn.rs                     |  4 +++
 datafusion/expr/src/function.rs                    |  2 ++
 datafusion/physical-expr/src/functions.rs          |  2 ++
 datafusion/physical-expr/src/math_expressions.rs   |  2 ++
 datafusion/proto/proto/datafusion.proto            |  2 ++
 datafusion/proto/src/generated/pbjson.rs           |  6 +++++
 datafusion/proto/src/generated/prost.rs            |  6 +++++
 datafusion/proto/src/logical_plan/from_proto.rs    | 16 +++++++-----
 datafusion/proto/src/logical_plan/to_proto.rs      |  2 ++
 docs/source/user-guide/expressions.md              |  2 ++
 docs/source/user-guide/sql/scalar_functions.md     | 29 ++++++++++++++++++++++
 13 files changed, 99 insertions(+), 6 deletions(-)

diff --git a/datafusion/core/tests/sqllogictests/test_files/scalar.slt b/datafusion/core/tests/sqllogictests/test_files/scalar.slt
index 138d71e1c4..7583600802 100644
--- a/datafusion/core/tests/sqllogictests/test_files/scalar.slt
+++ b/datafusion/core/tests/sqllogictests/test_files/scalar.slt
@@ -166,6 +166,18 @@ select ceil(null);
 ----
 NULL
 
+# degrees scalar function
+query RRR rowsort
+select degrees(0), degrees(pi() / 2), degrees(pi());
+----
+0 90 180
+
+# degrees scalar nulls
+query R rowsort
+select degrees(null);
+----
+NULL
+
 # cos scalar function
 query RRR rowsort
 select cos(0), cos(pi() / 3), cos(pi() / 2);
@@ -342,6 +354,18 @@ select power(null, null);
 ----
 NULL
 
+# radians scalar function
+query RRR rowsort
+select radians(0), radians(90), radians(180);
+----
+0 1.570796326795 3.14159265359
+
+# radians scalar nulls
+query R rowsort
+select radians(null);
+----
+NULL
+
 # round scalar function
 query RRR rowsort
 select round(1.4), round(1.5), round(1.6);
diff --git a/datafusion/expr/src/built_in_function.rs b/datafusion/expr/src/built_in_function.rs
index 95bd811dd4..524fe23a32 100644
--- a/datafusion/expr/src/built_in_function.rs
+++ b/datafusion/expr/src/built_in_function.rs
@@ -52,6 +52,8 @@ pub enum BuiltinScalarFunction {
     Cos,
     /// cos
     Cosh,
+    /// degrees
+    Degrees,
     /// Digest
     Digest,
     /// exp
@@ -70,6 +72,8 @@ pub enum BuiltinScalarFunction {
     Pi,
     /// power
     Power,
+    /// radians
+    Radians,
     /// round
     Round,
     /// signum
@@ -222,6 +226,7 @@ impl BuiltinScalarFunction {
             BuiltinScalarFunction::Coalesce => Volatility::Immutable,
             BuiltinScalarFunction::Cos => Volatility::Immutable,
             BuiltinScalarFunction::Cosh => Volatility::Immutable,
+            BuiltinScalarFunction::Degrees => Volatility::Immutable,
             BuiltinScalarFunction::Exp => Volatility::Immutable,
             BuiltinScalarFunction::Floor => Volatility::Immutable,
             BuiltinScalarFunction::Ln => Volatility::Immutable,
@@ -258,6 +263,7 @@ impl BuiltinScalarFunction {
             BuiltinScalarFunction::MD5 => Volatility::Immutable,
             BuiltinScalarFunction::NullIf => Volatility::Immutable,
             BuiltinScalarFunction::OctetLength => Volatility::Immutable,
+            BuiltinScalarFunction::Radians => Volatility::Immutable,
             BuiltinScalarFunction::RegexpReplace => Volatility::Immutable,
             BuiltinScalarFunction::Repeat => Volatility::Immutable,
             BuiltinScalarFunction::Replace => Volatility::Immutable,
@@ -323,6 +329,7 @@ impl FromStr for BuiltinScalarFunction {
             "ceil" => BuiltinScalarFunction::Ceil,
             "cos" => BuiltinScalarFunction::Cos,
             "cosh" => BuiltinScalarFunction::Cosh,
+            "degrees" => BuiltinScalarFunction::Degrees,
             "exp" => BuiltinScalarFunction::Exp,
             "floor" => BuiltinScalarFunction::Floor,
             "ln" => BuiltinScalarFunction::Ln,
@@ -331,6 +338,7 @@ impl FromStr for BuiltinScalarFunction {
             "log2" => BuiltinScalarFunction::Log2,
             "pi" => BuiltinScalarFunction::Pi,
             "power" | "pow" => BuiltinScalarFunction::Power,
+            "radians" => BuiltinScalarFunction::Radians,
             "random" => BuiltinScalarFunction::Random,
             "round" => BuiltinScalarFunction::Round,
             "signum" => BuiltinScalarFunction::Signum,
diff --git a/datafusion/expr/src/expr_fn.rs b/datafusion/expr/src/expr_fn.rs
index 9cfc565b59..99ecfd4abe 100644
--- a/datafusion/expr/src/expr_fn.rs
+++ b/datafusion/expr/src/expr_fn.rs
@@ -479,6 +479,8 @@ scalar_expr!(
     num,
     "nearest integer greater than or equal to argument"
 );
+scalar_expr!(Degrees, degrees, num, "converts radians to degrees");
+scalar_expr!(Radians, radians, num, "converts degrees to radians");
 nary_scalar_expr!(Round, round, "round to nearest integer");
 scalar_expr!(Trunc, trunc, num, "truncate toward zero");
 scalar_expr!(Abs, abs, num, "absolute value");
@@ -788,6 +790,8 @@ mod test {
         test_unary_scalar_expr!(Atanh, atanh);
         test_unary_scalar_expr!(Floor, floor);
         test_unary_scalar_expr!(Ceil, ceil);
+        test_unary_scalar_expr!(Degrees, degrees);
+        test_unary_scalar_expr!(Radians, radians);
         test_nary_scalar_expr!(Round, round, input);
         test_nary_scalar_expr!(Round, round, input, decimal_places);
         test_unary_scalar_expr!(Trunc, trunc);
diff --git a/datafusion/expr/src/function.rs b/datafusion/expr/src/function.rs
index eff5111d05..37afd17956 100644
--- a/datafusion/expr/src/function.rs
+++ b/datafusion/expr/src/function.rs
@@ -288,11 +288,13 @@ pub fn return_type(
         | BuiltinScalarFunction::Ceil
         | BuiltinScalarFunction::Cos
         | BuiltinScalarFunction::Cosh
+        | BuiltinScalarFunction::Degrees
         | BuiltinScalarFunction::Exp
         | BuiltinScalarFunction::Floor
         | BuiltinScalarFunction::Ln
         | BuiltinScalarFunction::Log10
         | BuiltinScalarFunction::Log2
+        | BuiltinScalarFunction::Radians
         | BuiltinScalarFunction::Round
         | BuiltinScalarFunction::Signum
         | BuiltinScalarFunction::Sin
diff --git a/datafusion/physical-expr/src/functions.rs b/datafusion/physical-expr/src/functions.rs
index 15d9810b01..352ec08166 100644
--- a/datafusion/physical-expr/src/functions.rs
+++ b/datafusion/physical-expr/src/functions.rs
@@ -345,11 +345,13 @@ pub fn create_physical_fun(
         BuiltinScalarFunction::Ceil => Arc::new(math_expressions::ceil),
         BuiltinScalarFunction::Cos => Arc::new(math_expressions::cos),
         BuiltinScalarFunction::Cosh => Arc::new(math_expressions::cosh),
+        BuiltinScalarFunction::Degrees => Arc::new(math_expressions::to_degrees),
         BuiltinScalarFunction::Exp => Arc::new(math_expressions::exp),
         BuiltinScalarFunction::Floor => Arc::new(math_expressions::floor),
         BuiltinScalarFunction::Ln => Arc::new(math_expressions::ln),
         BuiltinScalarFunction::Log10 => Arc::new(math_expressions::log10),
         BuiltinScalarFunction::Log2 => Arc::new(math_expressions::log2),
+        BuiltinScalarFunction::Radians => Arc::new(math_expressions::to_radians),
         BuiltinScalarFunction::Random => Arc::new(math_expressions::random),
         BuiltinScalarFunction::Round => {
             Arc::new(|args| make_scalar_function(math_expressions::round)(args))
diff --git a/datafusion/physical-expr/src/math_expressions.rs b/datafusion/physical-expr/src/math_expressions.rs
index ee96b19a5c..1af9f29805 100644
--- a/datafusion/physical-expr/src/math_expressions.rs
+++ b/datafusion/physical-expr/src/math_expressions.rs
@@ -164,6 +164,8 @@ math_unary_function!("exp", exp);
 math_unary_function!("ln", ln);
 math_unary_function!("log2", log2);
 math_unary_function!("log10", log10);
+math_unary_function!("degrees", to_degrees);
+math_unary_function!("radians", to_radians);
 
 /// Pi SQL function
 pub fn pi(args: &[ColumnarValue]) -> Result<ColumnarValue> {
diff --git a/datafusion/proto/proto/datafusion.proto b/datafusion/proto/proto/datafusion.proto
index 6b8cc61034..3023cbc264 100644
--- a/datafusion/proto/proto/datafusion.proto
+++ b/datafusion/proto/proto/datafusion.proto
@@ -532,6 +532,8 @@ enum ScalarFunction {
   Cosh = 78;
   Tanh = 79;
   Pi = 80;
+  Degrees = 81;
+  Radians = 82;
 }
 
 message ScalarFunctionNode {
diff --git a/datafusion/proto/src/generated/pbjson.rs b/datafusion/proto/src/generated/pbjson.rs
index 2acac28c40..6a416d37c9 100644
--- a/datafusion/proto/src/generated/pbjson.rs
+++ b/datafusion/proto/src/generated/pbjson.rs
@@ -17321,6 +17321,8 @@ impl serde::Serialize for ScalarFunction {
             Self::Cosh => "Cosh",
             Self::Tanh => "Tanh",
             Self::Pi => "Pi",
+            Self::Degrees => "Degrees",
+            Self::Radians => "Radians",
         };
         serializer.serialize_str(variant)
     }
@@ -17413,6 +17415,8 @@ impl<'de> serde::Deserialize<'de> for ScalarFunction {
             "Cosh",
             "Tanh",
             "Pi",
+            "Degrees",
+            "Radians",
         ];
 
         struct GeneratedVisitor;
@@ -17536,6 +17540,8 @@ impl<'de> serde::Deserialize<'de> for ScalarFunction {
                     "Cosh" => Ok(ScalarFunction::Cosh),
                     "Tanh" => Ok(ScalarFunction::Tanh),
                     "Pi" => Ok(ScalarFunction::Pi),
+                    "Degrees" => Ok(ScalarFunction::Degrees),
+                    "Radians" => Ok(ScalarFunction::Radians),
                     _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
                 }
             }
diff --git a/datafusion/proto/src/generated/prost.rs b/datafusion/proto/src/generated/prost.rs
index a3d60ef436..8ec16070ee 100644
--- a/datafusion/proto/src/generated/prost.rs
+++ b/datafusion/proto/src/generated/prost.rs
@@ -2152,6 +2152,8 @@ pub enum ScalarFunction {
     Cosh = 78,
     Tanh = 79,
     Pi = 80,
+    Degrees = 81,
+    Radians = 82,
 }
 impl ScalarFunction {
     /// String value of the enum field names used in the ProtoBuf definition.
@@ -2241,6 +2243,8 @@ impl ScalarFunction {
             ScalarFunction::Cosh => "Cosh",
             ScalarFunction::Tanh => "Tanh",
             ScalarFunction::Pi => "Pi",
+            ScalarFunction::Degrees => "Degrees",
+            ScalarFunction::Radians => "Radians",
         }
     }
     /// Creates an enum from field names used in the ProtoBuf definition.
@@ -2327,6 +2331,8 @@ impl ScalarFunction {
             "Cosh" => Some(Self::Cosh),
             "Tanh" => Some(Self::Tanh),
             "Pi" => Some(Self::Pi),
+            "Degrees" => Some(Self::Degrees),
+            "Radians" => Some(Self::Radians),
             _ => None,
         }
     }
diff --git a/datafusion/proto/src/logical_plan/from_proto.rs b/datafusion/proto/src/logical_plan/from_proto.rs
index fdb048c78e..c66fbc0e7d 100644
--- a/datafusion/proto/src/logical_plan/from_proto.rs
+++ b/datafusion/proto/src/logical_plan/from_proto.rs
@@ -37,15 +37,15 @@ use datafusion_common::{
 use datafusion_expr::{
     abs, acos, acosh, array, ascii, asin, asinh, atan, atan2, atanh, bit_length, btrim,
     cbrt, ceil, character_length, chr, coalesce, concat_expr, concat_ws_expr, cos, cosh,
-    date_bin, date_part, date_trunc, digest, exp,
+    date_bin, date_part, date_trunc, degrees, digest, exp,
     expr::{self, Sort, WindowFunction},
     floor, from_unixtime, left, ln, log, log10, log2,
     logical_plan::{PlanType, StringifiedPlan},
-    lower, lpad, ltrim, md5, now, nullif, octet_length, pi, power, random, regexp_match,
-    regexp_replace, repeat, replace, reverse, right, round, rpad, rtrim, sha224, sha256,
-    sha384, sha512, signum, sin, sinh, split_part, sqrt, starts_with, strpos, substr,
-    substring, tan, tanh, to_hex, to_timestamp_micros, to_timestamp_millis,
-    to_timestamp_seconds, translate, trim, trunc, upper, uuid,
+    lower, lpad, ltrim, md5, now, nullif, octet_length, pi, power, radians, random,
+    regexp_match, regexp_replace, repeat, replace, reverse, right, round, rpad, rtrim,
+    sha224, sha256, sha384, sha512, signum, sin, sinh, split_part, sqrt, starts_with,
+    strpos, substr, substring, tan, tanh, to_hex, to_timestamp_micros,
+    to_timestamp_millis, to_timestamp_seconds, translate, trim, trunc, upper, uuid,
     window_frame::regularize,
     AggregateFunction, Between, BinaryExpr, BuiltInWindowFunction, BuiltinScalarFunction,
     Case, Cast, Expr, GetIndexedField, GroupingSet,
@@ -425,6 +425,8 @@ impl From<&protobuf::ScalarFunction> for BuiltinScalarFunction {
             ScalarFunction::Log => Self::Log,
             ScalarFunction::Ln => Self::Ln,
             ScalarFunction::Log10 => Self::Log10,
+            ScalarFunction::Degrees => Self::Degrees,
+            ScalarFunction::Radians => Self::Radians,
             ScalarFunction::Floor => Self::Floor,
             ScalarFunction::Ceil => Self::Ceil,
             ScalarFunction::Round => Self::Round,
@@ -1157,6 +1159,8 @@ pub fn parse_expr(
                 ScalarFunction::Tanh => Ok(tanh(parse_expr(&args[0], registry)?)),
                 ScalarFunction::Atanh => Ok(atanh(parse_expr(&args[0], registry)?)),
                 ScalarFunction::Exp => Ok(exp(parse_expr(&args[0], registry)?)),
+                ScalarFunction::Degrees => Ok(degrees(parse_expr(&args[0], registry)?)),
+                ScalarFunction::Radians => Ok(radians(parse_expr(&args[0], registry)?)),
                 ScalarFunction::Log2 => Ok(log2(parse_expr(&args[0], registry)?)),
                 ScalarFunction::Ln => Ok(ln(parse_expr(&args[0], registry)?)),
                 ScalarFunction::Log10 => Ok(log10(parse_expr(&args[0], registry)?)),
diff --git a/datafusion/proto/src/logical_plan/to_proto.rs b/datafusion/proto/src/logical_plan/to_proto.rs
index 53bc8a7dce..e757f7830b 100644
--- a/datafusion/proto/src/logical_plan/to_proto.rs
+++ b/datafusion/proto/src/logical_plan/to_proto.rs
@@ -1279,6 +1279,8 @@ impl TryFrom<&BuiltinScalarFunction> for protobuf::ScalarFunction {
             BuiltinScalarFunction::Log => Self::Log,
             BuiltinScalarFunction::Ln => Self::Ln,
             BuiltinScalarFunction::Log10 => Self::Log10,
+            BuiltinScalarFunction::Degrees => Self::Degrees,
+            BuiltinScalarFunction::Radians => Self::Radians,
             BuiltinScalarFunction::Floor => Self::Floor,
             BuiltinScalarFunction::Ceil => Self::Ceil,
             BuiltinScalarFunction::Round => Self::Round,
diff --git a/docs/source/user-guide/expressions.md b/docs/source/user-guide/expressions.md
index cbbc328df1..0a8bef345f 100644
--- a/docs/source/user-guide/expressions.md
+++ b/docs/source/user-guide/expressions.md
@@ -89,6 +89,7 @@ expressions such as `col("a") + col("b")` to be used.
 | ceil(x)               | nearest integer greater than or equal to argument |
 | cos(x)                | cosine                                            |
 | cosh(x)               | hyperbolic cosine                                 |
+| degrees(x)            | converts radians to degrees                       |
 | exp(x)                | exponential                                       |
 | floor(x)              | nearest integer less than or equal to argument    |
 | ln(x)                 | natural logarithm                                 |
@@ -97,6 +98,7 @@ expressions such as `col("a") + col("b")` to be used.
 | log2(x)               | base 2 logarithm                                  |
 | pi()                  | approximate value of π                            |
 | power(base, exponent) | base raised to the power of exponent              |
+| radians(x)            | converts degrees to radians                       |
 | round(x)              | round to nearest integer                          |
 | signum(x)             | sign of the argument (-1, 0, +1)                  |
 | sin(x)                | sine                                              |
diff --git a/docs/source/user-guide/sql/scalar_functions.md b/docs/source/user-guide/sql/scalar_functions.md
index 25002e572d..0f2e3f1439 100644
--- a/docs/source/user-guide/sql/scalar_functions.md
+++ b/docs/source/user-guide/sql/scalar_functions.md
@@ -33,6 +33,7 @@
 - [ceil](#ceil)
 - [cos](#cos)
 - [cosh](#cosh)
+- [degrees](#degrees)
 - [exp](#exp)
 - [floor](#floor)
 - [ln](#ln)
@@ -42,6 +43,7 @@
 - [pi](#pi)
 - [power](#power)
 - [pow](#pow)
+- [radians](#radians)
 - [random](#random)
 - [round](#round)
 - [signum](#signum)
@@ -205,6 +207,19 @@ Returns the hyperbolic cosine of a number.
 cosh(numeric_expression)
 ```
 
+### `degrees`
+
+Converts radians to degrees.
+
+```
+degrees(numeric_expression)
+```
+
+#### Arguments
+
+- **numeric_expression**: Numeric expression to operate on.
+  Can be a constant, column, or function, and any combination of arithmetic operators.
+
 #### Arguments
 
 - **numeric_expression**: Numeric expression to operate on.
@@ -323,6 +338,20 @@ power(base, exponent)
 
 _Alias of [power](#power)._
 
+### `radians`
+
+Converts degrees to radians.
+
+```
+radians(numeric_expression)
+```
+
+#### Arguments
+
+- **numeric_expression**: Numeric expression to operate on.
+  Can be a constant, column, or function, and any combination of arithmetic operators.
+  =======
+
 ### `random`
 
 Returns a random float value in the range [0, 1).