feat(expr): support builtin function pi. (risingwavelabs#8509)

e2e_test/batch/functions/pi.slt.part

@@ -0,0 +1,32 @@
+statement ok
+create table f64_table (a double);
+
+statement ok
+insert into f64_table values(pi());
+
+statement ok
+insert into f64_table values(1.618033);
+
+statement ok
+create table f32_table (a real);
+
+statement ok
+insert into f32_table values(pi());
+
+query I
+SELECT pi() 
+----
+3.141592653589793
+
+query I rowsort
+SELECT pi(), a from f64_table
+----
+3.141592653589793   1.618033
+3.141592653589793   3.141592653589793
+
+
+statement ok
+drop table f64_table
+
+statement ok
+drop table f32_table

proto/expr.proto

@@ -130,6 +130,9 @@ message ExprNode {
     JSONB_TYPEOF = 602;
     JSONB_ARRAY_LENGTH = 603;
 
+    // Functions that return a constant value
+    PI = 610;
+
     // Non-pure functions below (> 1000)
     // ------------------------
     // Internal functions

src/frontend/src/binder/expr/function.rs

@@ -304,6 +304,9 @@ impl Binder {
                 raw_call(ExprType::Now)(binder, inputs)
             })
         }
+        fn pi() -> Handle {
+            raw_literal(ExprImpl::literal_f64(std::f64::consts::PI))
+        }
 
         static HANDLES: LazyLock<HashMap<&'static str, Handle>> = LazyLock::new(|| {
             [
@@ -383,6 +386,8 @@ impl Binder {
                 ("jsonb_array_element_text", raw_call(ExprType::JsonbAccessStr)),
                 ("jsonb_typeof", raw_call(ExprType::JsonbTypeof)),
                 ("jsonb_array_length", raw_call(ExprType::JsonbArrayLength)),
+                // Functions that return a constant value
+                ("pi", pi()),
                 // System information operations.
                 (
                     "pg_typeof",

src/frontend/src/expr/mod.rs

@@ -109,6 +109,12 @@ impl ExprImpl {
         Literal::new(Some(v.to_scalar_value()), DataType::Int32).into()
     }
 
+    /// A literal float64 value.
+    #[inline(always)]
+    pub fn literal_f64(v: f64) -> Self {
+        Literal::new(Some(v.into()), DataType::Float64).into()
+    }
+
     /// A literal boolean value.
     #[inline(always)]
     pub fn literal_bool(v: bool) -> Self {