chore(tesseract): DebugSql for symbols and filters

rust/cubesqlplanner/cubesqlplanner/Cargo.toml

@@ -26,6 +26,7 @@ indoc = "2.0.7"
 [dev-dependencies]
 petgraph = "0.6"
 serde_yaml = "0.9"
+insta = "1.34"
 
 [dependencies.neon]
 version = "=1"

rust/cubesqlplanner/cubesqlplanner/src/plan/filter_debug.rs

@@ -0,0 +1,88 @@
+use super::filter::{Filter, FilterGroup, FilterGroupOperator, FilterItem};
+use crate::planner::filter::BaseFilter;
+use crate::planner::sql_evaluator::DebugSql;
+
+impl DebugSql for BaseFilter {
+    fn debug_sql(&self, expand_deps: bool) -> String {
+        let member = if expand_deps {
+            self.member_evaluator().debug_sql(true)
+        } else {
+            format!("{{{}}}", self.member_evaluator().full_name())
+        };
+
+        let values_str = self
+            .values()
+            .iter()
+            .map(|v| match v {
+                Some(val) => format!("'{}'", val),
+                None => "NULL".to_string(),
+            })
+            .collect::<Vec<_>>()
+            .join(", ");
+
+        format!(
+            "{} {}: [{}]",
+            member,
+            self.filter_operator().to_string(),
+            values_str
+        )
+    }
+}
+
+impl DebugSql for FilterItem {
+    fn debug_sql(&self, expand_deps: bool) -> String {
+        match self {
+            FilterItem::Group(group) => group.debug_sql(expand_deps),
+            FilterItem::Item(filter) => filter.debug_sql(expand_deps),
+            FilterItem::Segment(segment) => {
+                let member = if expand_deps {
+                    segment.member_evaluator().debug_sql(true)
+                } else {
+                    format!("{{{}}}", segment.member_evaluator().full_name())
+                };
+                format!("SEGMENT({})", member)
+            }
+        }
+    }
+}
+
+impl DebugSql for FilterGroup {
+    fn debug_sql(&self, expand_deps: bool) -> String {
+        if self.items.is_empty() {
+            return format!("{}: []", self.operator);
+        }
+
+        let items_str = self
+            .items
+            .iter()
+            .map(|item| {
+                let item_str = item.debug_sql(expand_deps);
+                // Indent each line of the item
+                item_str
+                    .lines()
+                    .map(|line| format!("  {}", line))
+                    .collect::<Vec<_>>()
+                    .join("\n")
+            })
+            .collect::<Vec<_>>()
+            .join(",\n");
+
+        format!("{}: [\n{}\n]", self.operator, items_str)
+    }
+}
+
+impl DebugSql for Filter {
+    fn debug_sql(&self, expand_deps: bool) -> String {
+        if self.items.is_empty() {
+            return "Filter: []".to_string();
+        }
+
+        if self.items.len() == 1 {
+            return self.items[0].debug_sql(expand_deps);
+        }
+
+        // Multiple items treated as AND group
+        let group = FilterGroup::new(FilterGroupOperator::And, self.items.clone());
+        group.debug_sql(expand_deps)
+    }
+}

rust/cubesqlplanner/cubesqlplanner/src/plan/mod.rs

@@ -3,6 +3,7 @@ pub mod calc_groups_join;
 pub mod cte;
 pub mod expression;
 pub mod filter;
+pub mod filter_debug;
 pub mod from;
 pub mod join;
 pub mod order;

rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/mod.rs

@@ -8,6 +8,7 @@ pub mod sql_visitor;
 pub mod symbols;
 pub mod visitor;
 
+pub use crate::utils::debug::DebugSql;
 pub use compiler::Compiler;
 pub use references_builder::ReferencesBuilder;
 pub use sql_call::*;

rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_call.rs

@@ -327,3 +327,57 @@ impl SqlCall {
         Ok(Rc::new(result))
     }
 }
+
+impl crate::utils::debug::DebugSql for SqlCall {
+    fn debug_sql(&self, expand_deps: bool) -> String {
+        let template_str = match &self.template {
+            SqlTemplate::String(s) => s.clone(),
+            SqlTemplate::StringVec(vec) => {
+                format!("[{}]", vec.join(", "))
+            }
+        };
+
+        let deps = self
+            .deps
+            .iter()
+            .map(|dep| {
+                if expand_deps {
+                    dep.symbol.debug_sql(true)
+                } else {
+                    format!("{{{}}}", dep.symbol.full_name())
+                }
+            })
+            .collect_vec();
+
+        let filter_params = self
+            .filter_params
+            .iter()
+            .enumerate()
+            .map(|(i, _filter_param)| format!("{{FILTER_PARAMS[{}]}}", i))
+            .collect_vec();
+
+        let filter_groups = self
+            .filter_groups
+            .iter()
+            .enumerate()
+            .map(|(i, _filter_group)| format!("{{FILTER_GROUP[{}]}}", i))
+            .collect_vec();
+
+        let context_values = self
+            .security_context
+            .values
+            .iter()
+            .enumerate()
+            .map(|(key, _value)| format!("{{SECURITY_CONTEXT[{}]}}", key))
+            .collect_vec();
+
+        Self::substitute_template(
+            &template_str,
+            &deps,
+            &filter_params,
+            &filter_groups,
+            &context_values,
+        )
+        .unwrap()
+    }
+}

rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/common/case.rs

@@ -371,3 +371,58 @@ impl Case {
         }
     }
 }
+
+impl crate::utils::debug::DebugSql for Case {
+    fn debug_sql(&self, expand_deps: bool) -> String {
+        match self {
+            Case::Case(case_def) => {
+                let mut result = "CASE\n".to_string();
+
+                for when in &case_def.items {
+                    let condition = when.sql.debug_sql(expand_deps);
+                    let then = match &when.label {
+                        CaseLabel::String(s) => format!("'{}'", s),
+                        CaseLabel::Sql(sql) => sql.debug_sql(expand_deps),
+                    };
+                    result.push_str(&format!("  WHEN {} THEN {}\n", condition, then));
+                }
+
+                let else_sql = match &case_def.else_label {
+                    CaseLabel::String(s) => format!("'{}'", s),
+                    CaseLabel::Sql(sql) => sql.debug_sql(expand_deps),
+                };
+                result.push_str(&format!("  ELSE {}\n", else_sql));
+
+                result.push_str("END");
+                result
+            }
+            Case::CaseSwitch(case_switch) => {
+                let switch_sql = match &case_switch.switch {
+                    CaseSwitchItem::Sql(sql) => sql.debug_sql(expand_deps),
+                    CaseSwitchItem::Member(member) => {
+                        if expand_deps {
+                            member.debug_sql(true)
+                        } else {
+                            format!("{{{}}}", member.full_name())
+                        }
+                    }
+                };
+
+                let mut result = format!("CASE {}\n", switch_sql);
+
+                for when in &case_switch.items {
+                    let then = when.sql.debug_sql(expand_deps);
+                    result.push_str(&format!("  WHEN '{}' THEN {}\n", when.value, then));
+                }
+
+                if let Some(else_sql) = &case_switch.else_sql {
+                    let else_sql_str = else_sql.debug_sql(expand_deps);
+                    result.push_str(&format!("  ELSE {}\n", else_sql_str));
+                }
+
+                result.push_str("END");
+                result
+            }
+        }
+    }
+}

rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/cube_symbol.rs

@@ -214,3 +214,20 @@ impl SymbolFactory for CubeTableSymbolFactory {
         )))
     }
 }
+
+impl crate::utils::debug::DebugSql for CubeNameSymbol {
+    fn debug_sql(&self, _expand_deps: bool) -> String {
+        self.cube_name().clone()
+    }
+}
+
+impl crate::utils::debug::DebugSql for CubeTableSymbol {
+    fn debug_sql(&self, expand_deps: bool) -> String {
+        let sql_debug = if let Some(sql) = &self.member_sql {
+            sql.debug_sql(expand_deps)
+        } else {
+            "NULL".to_string()
+        };
+        format!("{}({})", self.cube_name(), sql_debug)
+    }
+}