fix(cubesql): Avoid constant folding for current_date() function duri… (#7498)

* fix(cubesql): Avoid constant folding for current_date() function during SQL push down

* More accurate test

* More accurate test: add check

Author: paveltiunov

rust/cubesql/cubesql/src/compile/engine/udf.rs

@@ -4787,5 +4787,15 @@ pub fn register_fun_stubs(mut ctx: SessionContext) -> SessionContext {
         rettyp = Utf8
     );
 
+    register_fun_stub!(
+        udf,
+        "eval_current_date",
+        argc = 0,
+        rettyp = Date32,
+        vol = Stable
+    );
+
+    register_fun_stub!(udf, "eval_now", argc = 0, rettyp = Timestamp, vol = Stable);
+
     ctx
 }

rust/cubesql/cubesql/src/compile/mod.rs

@@ -11749,7 +11749,7 @@ ORDER BY \"COUNT(count)\" DESC"
 
         assert_eq!(
             logical_plan,
-            "Projection: Date32(\"0\") AS COL\
+            "Projection: currentdate() AS COL\
             \n  EmptyRelation",
         );
 
@@ -19277,6 +19277,35 @@ ORDER BY \"COUNT(count)\" DESC"
         );
     }
 
+    #[tokio::test]
+    async fn test_tableau_custom_date_diff() {
+        if !Rewriter::sql_push_down_enabled() {
+            return;
+        }
+        init_logger();
+
+        let query_plan = convert_select_to_query_plan(
+            "SELECT SUM(CAST(FLOOR(EXTRACT(EPOCH FROM CAST(CURRENT_DATE() AS TIMESTAMP)) / 86400) - FLOOR(EXTRACT(EPOCH FROM CAST(order_date AS TIMESTAMP)) / 86400) AS BIGINT)) FROM KibanaSampleDataEcommerce a"
+                .to_string(),
+            DatabaseProtocol::PostgreSQL,
+        )
+            .await;
+
+        let logical_plan = query_plan.as_logical_plan();
+        assert!(logical_plan
+            .find_cube_scan_wrapper()
+            .wrapped_sql
+            .unwrap()
+            .sql
+            .contains("CURRENT_DATE()"));
+
+        let physical_plan = query_plan.as_physical_plan().await.unwrap();
+        println!(
+            "Physical plan: {}",
+            displayable(physical_plan.as_ref()).indent()
+        );
+    }
+
     #[tokio::test]
     async fn test_thoughtspot_pg_date_trunc_year() {
         init_logger();

rust/cubesql/cubesql/src/compile/rewrite/analysis.rs

@@ -20,7 +20,9 @@ use datafusion::{
     },
     logical_plan::{Column, DFSchema, Expr},
     physical_plan::{
-        functions::Volatility, planner::DefaultPhysicalPlanner, ColumnarValue, PhysicalPlanner,
+        functions::{BuiltinScalarFunction, Volatility},
+        planner::DefaultPhysicalPlanner,
+        ColumnarValue, PhysicalPlanner,
     },
     scalar::ScalarValue,
 };
@@ -486,7 +488,23 @@ impl LogicalPlanAnalysis {
                 )
                 .ok()?;
                 if let Expr::ScalarUDF { fun, .. } = &expr {
-                    if &fun.name == "str_to_date"
+                    if &fun.name == "eval_now" {
+                        Self::eval_constant_expr(
+                            &egraph,
+                            &Expr::ScalarFunction {
+                                fun: BuiltinScalarFunction::Now,
+                                args: vec![],
+                            },
+                        )
+                    } else if &fun.name == "eval_current_date" {
+                        Self::eval_constant_expr(
+                            &egraph,
+                            &Expr::ScalarFunction {
+                                fun: BuiltinScalarFunction::CurrentDate,
+                                args: vec![],
+                            },
+                        )
+                    } else if &fun.name == "str_to_date"
                         || &fun.name == "date_add"
                         || &fun.name == "date_sub"
                         || &fun.name == "date"
@@ -511,8 +529,12 @@ impl LogicalPlanAnalysis {
                 .ok()?;
 
                 if let Expr::ScalarFunction { fun, .. } = &expr {
-                    if fun.volatility() == Volatility::Immutable
-                        || fun.volatility() == Volatility::Stable
+                    if (fun.volatility() == Volatility::Immutable
+                        || fun.volatility() == Volatility::Stable)
+                        && !matches!(
+                            fun,
+                            BuiltinScalarFunction::CurrentDate | BuiltinScalarFunction::Now
+                        )
                     {
                         Self::eval_constant_expr(&egraph, &expr)
                     } else {
@@ -562,6 +584,7 @@ impl LogicalPlanAnalysis {
                         Expr::Literal(ScalarValue::Utf8(value)) => match (value, data_type) {
                             // Timezone set in Config
                             (Some(_), DataType::Timestamp(_, _)) => (),
+                            (Some(_), DataType::Date32 | DataType::Date64) => (),
                             _ => return None,
                         },
                         _ => (),
@@ -807,15 +830,16 @@ impl Analysis<LogicalPlanLanguage> for LogicalPlanAnalysis {
         if let Some(ConstantFolding::Scalar(c)) = &egraph[id].data.constant {
             // TODO: ideally all constants should be aliased, but this requires
             // rewrites to extract `.data.constant` instead of `literal_expr`.
-            let alias_name = if c.is_null() {
-                egraph[id]
-                    .data
-                    .original_expr
-                    .as_ref()
-                    .map(|expr| expr.name(&DFSchema::empty()).unwrap())
-            } else {
-                None
-            };
+            let alias_name =
+                if c.is_null() || matches!(c, ScalarValue::Date32(_) | ScalarValue::Date64(_)) {
+                    egraph[id]
+                        .data
+                        .original_expr
+                        .as_ref()
+                        .map(|expr| expr.name(&DFSchema::empty()).unwrap())
+                } else {
+                    None
+                };
             let c = c.clone();
             let value = egraph.add(LogicalPlanLanguage::LiteralExprValue(LiteralExprValue(c)));
             let literal_expr = egraph.add(LogicalPlanLanguage::LiteralExpr([value]));

rust/cubesql/cubesql/src/compile/rewrite/mod.rs

@@ -379,7 +379,7 @@ crate::plan_to_language! {
             members: Vec<LogicalPlan>,
             aliases: Vec<(String, String)>,
         },
-        FilterCastUnwrapReplacer {
+        FilterSimplifyReplacer {
             filters: Vec<LogicalPlan>,
         },
         OrderReplacer {
@@ -1131,8 +1131,8 @@ fn filter_replacer(
     )
 }
 
-fn filter_cast_unwrap_replacer(members: impl Display) -> String {
-    format!("(FilterCastUnwrapReplacer {})", members)
+fn filter_simplify_replacer(members: impl Display) -> String {
+    format!("(FilterSimplifyReplacer {})", members)
 }
 
 fn inner_aggregate_split_replacer(members: impl Display, alias_to_cube: impl Display) -> String {