feat(cubesql): Introduce query rewrite cache

rust/cubesql/cubesql/Cargo.toml

@@ -61,6 +61,7 @@ sha1_smol = "1.0.0"
 tera = { version = "1", default-features = false }
 minijinja = { version = "1", features = ["json", "loader"] }
 lru = "0.12.1"
+sha2 = "0.10.8"
 
 
 [dev-dependencies]

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

@@ -1387,6 +1387,8 @@ WHERE `TABLE_SCHEMA` = '{}'",
         qtrace: &mut Option<Qtrace>,
         span_id: Option<Arc<SpanId>>,
     ) -> CompilationResult<QueryPlan> {
+        self.reauthenticate_if_needed().await?;
+
         match &stmt {
             ast::Statement::Query(query) => match &query.body {
                 ast::SetExpr::Select(select) if select.into.is_some() => {
@@ -1451,20 +1453,25 @@ WHERE `TABLE_SCHEMA` = '{}'",
             qtrace.set_optimized_plan(&optimized_plan);
         }
 
-        let mut converter = LogicalPlanToLanguageConverter::new(Arc::new(cube_ctx));
+        let cube_ctx = Arc::new(cube_ctx);
+        let mut converter = LogicalPlanToLanguageConverter::new(cube_ctx.clone());
+        let mut query_params = Some(HashMap::new());
         let root = converter
-            .add_logical_plan(&optimized_plan)
+            .add_logical_plan_replace_params(&optimized_plan, &mut query_params)
             .map_err(|e| CompilationError::internal(e.to_string()))?;
 
-        self.reauthenticate_if_needed().await?;
-
-        let result = converter
-            .take_rewriter()
-            .find_best_plan(
-                root,
+        let result = self
+            .session_manager
+            .server
+            .compiler_cache
+            .rewrite(
                 self.state.auth_context().unwrap(),
-                qtrace,
+                cube_ctx.clone(),
+                root,
+                converter.take_egraph(),
+                &query_params.unwrap(),
                 span_id.clone(),
+                qtrace,
             )
             .await
             .map_err(|e| match e.cause {
@@ -15679,7 +15686,10 @@ limit
             // Quarter of Year
             ["EXTRACT(QUARTER FROM t.\"order_date\")", "quarter"],
             // Year
-            ["CAST(EXTRACT(YEAR FROM t.\"order_date\") AS varchar)", "year"],
+            [
+                "CAST(EXTRACT(YEAR FROM t.\"order_date\") AS varchar)",
+                "year",
+            ],
         ];
 
         for [expr, expected_granularity] in &supported_granularities {
@@ -18248,7 +18258,7 @@ limit
                 segments: Some(vec![]),
                 time_dimensions: Some(vec![V1LoadRequestQueryTimeDimension {
                     dimension: "KibanaSampleDataEcommerce.order_date".to_string(),
-                    granularity: Some("quarter".to_string()),
+                    granularity: Some("month".to_string()),
                     date_range: None
                 }]),
                 order: None,

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

@@ -1187,16 +1187,22 @@ 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() || matches!(c, ScalarValue::Date32(_) | ScalarValue::Date64(_)) {
-                    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(_)
+                        | ScalarValue::Int64(_)
+                        | ScalarValue::Float64(_)
+                ) {
+                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]));