wip: constant folding original expr

rust/cubesql/cubesql/src/compile/engine/df/wrapper.rs

@@ -10,6 +10,7 @@ use crate::{
     },
     CubeError,
 };
+use chrono::{Days, NaiveDate};
 use cubeclient::models::V1LoadRequestQuery;
 use datafusion::{
     error::{DataFusionError, Result},
@@ -23,7 +24,7 @@ use datafusion::{
 use itertools::Itertools;
 use regex::{Captures, Regex};
 use serde_derive::*;
-use std::{any::Any, collections::HashMap, fmt, future::Future, pin::Pin, result, sync::Arc};
+use std::{any::Any, collections::HashMap, convert::TryInto, fmt, future::Future, pin::Pin, result, sync::Arc};
 
 #[derive(Debug, Clone, Deserialize)]
 pub struct SqlQuery {
@@ -1218,7 +1219,39 @@ impl CubeScanWrapperNode {
                         // ScalarValue::Binary(_) => {}
                         // ScalarValue::LargeBinary(_) => {}
                         // ScalarValue::List(_, _) => {}
-                        // ScalarValue::Date32(_) => {}
+                        ScalarValue::Date32(x) => {
+                            if let Some(x) = x {
+                                let days = Days::new(x.abs().try_into().unwrap());
+                                let epoch = NaiveDate::from_ymd_opt(1970, 1, 1).unwrap();
+                                let new_date = if x < 0 {
+                                    epoch.checked_sub_days(days)
+                                } else {
+                                    epoch.checked_add_days(days)
+                                };
+                                let Some(new_date) = new_date else {
+                                    return Err(DataFusionError::Internal(format!("Can't generate SQL for date: day out of bounds ({})", x)));
+                                };
+                                let formatted_date = new_date.format("%Y-%m-%d").to_string();
+                                (
+                                    sql_generator
+                                        .get_sql_templates()
+                                        .scalar_function(
+                                            "DATE".to_string(),
+                                            vec![format!("'{}'", formatted_date)],
+                                            None,
+                                            None
+                                        ).map_err(|e| {
+                                            DataFusionError::Internal(format!(
+                                                "Can't generate SQL for date: {}",
+                                                e
+                                            ))
+                                        })?,
+                                    sql_query
+                                )
+                            } else {
+                                ("NULL".to_string(), sql_query)
+                            }
+                        }
                         // ScalarValue::Date64(_) => {}
                         // ScalarValue::TimestampSecond(_, _) => {}
                         // ScalarValue::TimestampMillisecond(_, _) => {}

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

@@ -865,6 +865,7 @@ impl LogicalPlanAnalysis {
                         || &fun.name == "date_to_timestamp"
                         || &fun.name == "interval_mul"
                     {
+                        println!("EVALUATING {} UDF CONSTANT FOLDING", fun.name);
                         Self::eval_constant_expr(&egraph, &expr)
                     } else {
                         None
@@ -1188,15 +1189,17 @@ impl Analysis<LogicalPlanLanguage> for LogicalPlanAnalysis {
             // 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() || matches!(c, ScalarValue::Date32(_) | ScalarValue::Date64(_) | ScalarValue::Float64(_) | ScalarValue::Int64(_)) {
-                    egraph[id]
+                if c.is_null() || matches!(c, ScalarValue::Date32(_) | ScalarValue::Date64(_) | ScalarValue::Float64(_) | ScalarValue::Int64(_) | ScalarValue::IntervalYearMonth(_)) {
+                    let original_expr = &egraph[id]
                         .data
-                        .original_expr
-                        .as_ref()
+                        .original_expr;
+                    println!("ORIGINAL EXPR: {:#?}", original_expr);
+                    original_expr.as_ref()
                         .map(|expr| expr.name(&DFSchema::empty()).unwrap())
                 } else {
                     None
                 };
+            println!("ALIAS NAME: {:?}", alias_name);
             let c = c.clone();
             let value = egraph.add(LogicalPlanLanguage::LiteralExprValue(LiteralExprValue(c)));
             let literal_expr = egraph.add(LogicalPlanLanguage::LiteralExpr([value]));