feat: implementation of the constant "Pi" (apache#5965)

Author: izveigor

datafusion/core/src/logical_plan/mod.rs

@@ -48,7 +48,7 @@ pub use expr::{
     count, count_distinct, create_udaf, create_udf, create_udtf, date_part, date_trunc,
     digest, exp, exprlist_to_fields, floor, in_list, initcap, left, length, lit,
     lit_timestamp_nano, ln, log10, log2, lower, lpad, ltrim, max, md5, min, now,
-    now_expr, nullif, octet_length, or, random, regexp_match, regexp_replace, repeat,
+    now_expr, nullif, octet_length, or, pi, random, regexp_match, regexp_replace, repeat,
     replace, reverse, right, round, rpad, rtrim, sha224, sha256, sha384, sha512, signum,
     sin, split_part, sqrt, starts_with, strpos, substr, sum, tan, to_hex,
     to_timestamp_micros, to_timestamp_millis, to_timestamp_seconds, translate, trim,

datafusion/core/src/physical_plan/functions.rs

@@ -140,6 +140,7 @@ pub fn return_type(
         BuiltinScalarFunction::OctetLength => {
             utf8_to_int_type(&input_expr_types[0], "octet_length")
         }
+        BuiltinScalarFunction::Pi => Ok(DataType::Float64),
         BuiltinScalarFunction::Random => Ok(DataType::Float64),
         BuiltinScalarFunction::RegexpReplace => {
             utf8_to_str_type(&input_expr_types[0], "regex_replace")
@@ -646,6 +647,7 @@ fn signature(fun: &BuiltinScalarFunction) -> Signature {
             ],
             fun.volatility(),
         ),
+        BuiltinScalarFunction::Pi => Signature::exact(vec![], fun.volatility()),
         BuiltinScalarFunction::Random => Signature::exact(vec![], fun.volatility()),
         // math expressions expect 1 argument of type f64 or f32
         // priority is given to f64 because e.g. `sqrt(1i32)` is in IR (real numbers) and thus we
@@ -803,6 +805,7 @@ pub fn create_physical_fun(
         BuiltinScalarFunction::Sqrt => Arc::new(math_expressions::sqrt),
         BuiltinScalarFunction::Tan => Arc::new(math_expressions::tan),
         BuiltinScalarFunction::Trunc => Arc::new(math_expressions::trunc),
+        BuiltinScalarFunction::Pi => Arc::new(math_expressions::pi),
         // string functions
         BuiltinScalarFunction::MakeArray => Arc::new(array_expressions::array),
         BuiltinScalarFunction::Ascii => Arc::new(|args| match args[0].data_type() {
@@ -3549,7 +3552,11 @@ mod tests {
         let execution_props = ExecutionProps::new();
         let schema = Schema::new(vec![Field::new("a", DataType::Int32, false)]);
 
-        let funs = [BuiltinScalarFunction::Now, BuiltinScalarFunction::Random];
+        let funs = [
+            BuiltinScalarFunction::Now,
+            BuiltinScalarFunction::Pi,
+            BuiltinScalarFunction::Random,
+        ];
 
         for fun in funs.iter() {
             create_physical_expr(fun, &[], &schema, &execution_props)?;

datafusion/core/tests/sql/functions.rs

@@ -594,3 +594,19 @@ async fn case_builtin_math_expression() {
 //         .unwrap();
 //     assert_batches_sorted_eq!(expected, &results);
 // }
+
+#[tokio::test]
+async fn pi_function() -> Result<()> {
+    let ctx = SessionContext::new();
+    let sql = "select pi(), pi() / 2, pi() / 3";
+    let actual = execute_to_batches(&ctx, sql).await;
+    let expected = vec![
+        "+-------------------+--------------------+--------------------+",
+        "| pi()              | pi() / Int64(2)    | pi() / Int64(3)    |",
+        "+-------------------+--------------------+--------------------+",
+        "| 3.141592653589793 | 1.5707963267948966 | 1.0471975511965976 |",
+        "+-------------------+--------------------+--------------------+",
+    ];
+    assert_batches_eq!(expected, &actual);
+    Ok(())
+}

datafusion/expr/src/built_in_function.rs

@@ -54,6 +54,8 @@ pub enum BuiltinScalarFunction {
     Log10,
     /// log2
     Log2,
+    /// pi
+    Pi,
     /// round
     Round,
     /// signum
@@ -170,7 +172,8 @@ impl BuiltinScalarFunction {
     pub fn supports_zero_argument(&self) -> bool {
         matches!(
             self,
-            BuiltinScalarFunction::Random
+            BuiltinScalarFunction::Pi
+                | BuiltinScalarFunction::Random
                 | BuiltinScalarFunction::Now
                 | BuiltinScalarFunction::UtcTimestamp
                 | BuiltinScalarFunction::CurrentDate
@@ -193,6 +196,7 @@ impl BuiltinScalarFunction {
             BuiltinScalarFunction::Log => Volatility::Immutable,
             BuiltinScalarFunction::Log10 => Volatility::Immutable,
             BuiltinScalarFunction::Log2 => Volatility::Immutable,
+            BuiltinScalarFunction::Pi => Volatility::Immutable,
             BuiltinScalarFunction::Round => Volatility::Immutable,
             BuiltinScalarFunction::Signum => Volatility::Immutable,
             BuiltinScalarFunction::Sin => Volatility::Immutable,
@@ -280,6 +284,7 @@ impl FromStr for BuiltinScalarFunction {
             "log" => BuiltinScalarFunction::Log,
             "log10" => BuiltinScalarFunction::Log10,
             "log2" => BuiltinScalarFunction::Log2,
+            "pi" => BuiltinScalarFunction::Pi,
             "round" => BuiltinScalarFunction::Round,
             "signum" => BuiltinScalarFunction::Signum,
             "sin" => BuiltinScalarFunction::Sin,

datafusion/expr/src/expr_fn.rs

@@ -134,6 +134,14 @@ pub fn concat_ws(sep: impl Into<String>, values: &[Expr]) -> Expr {
     }
 }
 
+/// Returns an approximate value of π
+pub fn pi() -> Expr {
+    Expr::ScalarFunction {
+        fun: built_in_function::BuiltinScalarFunction::Pi,
+        args: vec![],
+    }
+}
+
 /// Returns a random value in the range 0.0 <= x < 1.0
 pub fn random() -> Expr {
     Expr::ScalarFunction {

datafusion/physical-expr/src/math_expressions.rs

@@ -104,6 +104,17 @@ math_unary_function!("ln", ln);
 math_unary_function!("log2", log2);
 math_unary_function!("log10", log10);
 
+/// Pi SQL function
+pub fn pi(args: &[ColumnarValue]) -> Result<ColumnarValue> {
+    if !matches!(&args[0], ColumnarValue::Array(_)) {
+        return Err(DataFusionError::Internal(
+            "Expect pi function to take no param".to_string(),
+        ));
+    }
+    let array = Float64Array::from_value(std::f64::consts::PI, 1);
+    Ok(ColumnarValue::Array(Arc::new(array)))
+}
+
 /// random SQL function
 pub fn random(args: &[ColumnarValue]) -> Result<ColumnarValue> {
     let len: usize = match &args[0] {

datafusion/proto/proto/datafusion.proto

@@ -191,6 +191,7 @@ enum ScalarFunction {
   Coalesce=63;
   // Upstream
   CurrentDate=70;
+  Pi=80;
   // Cubesql
   UtcTimestamp=101;
   ToDayInterval=102;

datafusion/proto/src/from_proto.rs

@@ -24,7 +24,7 @@ use datafusion::{
     logical_plan::{
         abs, acos, ascii, asin, atan, ceil, character_length, chr, concat_expr,
         concat_ws_expr, cos, digest, exp, floor, left, ln, log10, log2, now_expr, nullif,
-        random, regexp_replace, repeat, replace, reverse, right, round, signum, sin,
+        pi, random, regexp_replace, repeat, replace, reverse, right, round, signum, sin,
         split_part, sqrt, starts_with, strpos, substr, tan, to_hex, to_timestamp_micros,
         to_timestamp_millis, to_timestamp_seconds, translate, trunc,
         window_frames::{WindowFrame, WindowFrameBound, WindowFrameUnits},
@@ -432,6 +432,7 @@ impl From<&protobuf::ScalarFunction> for BuiltinScalarFunction {
             ScalarFunction::Translate => Self::Translate,
             ScalarFunction::RegexpMatch => Self::RegexpMatch,
             ScalarFunction::Coalesce => Self::Coalesce,
+            ScalarFunction::Pi => Self::Pi,
             // Cube SQL
             ScalarFunction::UtcTimestamp => Self::UtcTimestamp,
             ScalarFunction::ToDayInterval => Self::ToDayInterval,
@@ -1233,6 +1234,7 @@ pub fn parse_expr(
                         .map(|expr| parse_expr(expr, registry))
                         .collect::<Result<Vec<_>, _>>()?,
                 )),
+                ScalarFunction::Pi => Ok(pi()),
                 _ => Err(proto_error(
                     "Protobuf deserialization error: Unsupported scalar function",
                 )),

datafusion/proto/src/to_proto.rs

@@ -1088,6 +1088,7 @@ impl TryFrom<&BuiltinScalarFunction> for protobuf::ScalarFunction {
             BuiltinScalarFunction::Translate => Self::Translate,
             BuiltinScalarFunction::RegexpMatch => Self::RegexpMatch,
             BuiltinScalarFunction::Coalesce => Self::Coalesce,
+            BuiltinScalarFunction::Pi => Self::Pi,
             // Cube SQL
             BuiltinScalarFunction::UtcTimestamp => Self::UtcTimestamp,
             BuiltinScalarFunction::ToDayInterval => Self::ToDayInterval,