chore(tesseract): Refactor: remove tables from symbols

rust/cubesqlplanner/cubesqlplanner/src/planner/base_cube.rs

@@ -1,6 +1,6 @@
 use super::query_tools::QueryTools;
-use super::sql_evaluator::MemberSymbol;
-use super::{evaluate_with_context, VisitorContext};
+use super::sql_evaluator::{CubeRef, CubeTableSymbol};
+use super::VisitorContext;
 use crate::cube_bridge::cube_definition::CubeDefinition;
 use crate::planner::sql_templates::PlanSqlTemplates;
 use cubenativeutils::CubeError;
@@ -10,15 +10,15 @@ use std::rc::Rc;
 pub struct BaseCube {
     cube_name: String,
     members: HashSet<String>,
-    member_evaluator: Rc<MemberSymbol>,
+    cube_table_symbol: Rc<CubeTableSymbol>,
     definition: Rc<dyn CubeDefinition>,
     query_tools: Rc<QueryTools>,
 }
 impl BaseCube {
     pub fn try_new(
         cube_name: String,
         query_tools: Rc<QueryTools>,
-        member_evaluator: Rc<MemberSymbol>,
+        cube_table_symbol: Rc<CubeTableSymbol>,
     ) -> Result<Rc<Self>, CubeError> {
         let definition = query_tools
             .cube_evaluator()
@@ -32,7 +32,7 @@ impl BaseCube {
         Ok(Rc::new(Self {
             cube_name,
             members,
-            member_evaluator,
+            cube_table_symbol,
             definition,
             query_tools,
         }))
@@ -43,8 +43,13 @@ impl BaseCube {
         context: Rc<VisitorContext>,
         templates: &PlanSqlTemplates,
     ) -> Result<String, CubeError> {
-        let cube_sql = evaluate_with_context(&self.member_evaluator, context, templates)?;
-        Ok(cube_sql)
+        let cube_ref = CubeRef::Table {
+            symbol: self.cube_table_symbol.clone(),
+            path: vec![],
+        };
+        let visitor = context.make_visitor(context.query_tools());
+        let node_processor = context.node_processor();
+        visitor.evaluate_cube_ref(&cube_ref, node_processor, templates)
     }
 
     pub fn name(&self) -> &String {

rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/calc_group_dims_collector.rs

@@ -41,8 +41,6 @@ impl TraversalVisitor for CalcGroupDimsCollector {
                 return self.on_node_traverse(e.base_symbol(), path, &())
             }
             MemberSymbol::Measure(_) => {}
-            MemberSymbol::CubeName(_) => {}
-            MemberSymbol::CubeTable(_) => {}
             MemberSymbol::MemberExpression(_) => {}
         };
         Ok(Some(()))

rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/cube_names_collector.rs

@@ -1,4 +1,4 @@
-use crate::planner::sql_evaluator::{MemberSymbol, TraversalVisitor};
+use crate::planner::sql_evaluator::{CubeRef, MemberSymbol, TraversalVisitor};
 use cubenativeutils::CubeError;
 use std::collections::HashSet;
 use std::rc::Rc;
@@ -56,19 +56,22 @@ impl TraversalVisitor for CubeNamesCollector {
                     }
                 }
             }
-            MemberSymbol::CubeName(e) => {
-                if !path.is_empty() {
-                    for p in path {
-                        self.names.insert(p.clone());
-                    }
-                }
-                self.names.insert(e.cube_name().clone());
-            }
-            MemberSymbol::CubeTable(_) => {}
             MemberSymbol::MemberExpression(_) => {}
         };
         Ok(Some(()))
     }
+
+    fn on_cube_ref(&mut self, cube_ref: &CubeRef, _state: &Self::State) -> Result<(), CubeError> {
+        if let CubeRef::Name { symbol, path, .. } = cube_ref {
+            if !path.is_empty() {
+                for p in path {
+                    self.names.insert(p.clone());
+                }
+            }
+            self.names.insert(symbol.cube_name().clone());
+        }
+        Ok(())
+    }
 }
 
 pub fn collect_cube_names(node: &Rc<MemberSymbol>) -> Result<Vec<String>, CubeError> {

rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/join_hints_collector.rs

@@ -1,5 +1,5 @@
 use crate::cube_bridge::join_hints::JoinHintItem;
-use crate::planner::sql_evaluator::{MemberSymbol, TraversalVisitor};
+use crate::planner::sql_evaluator::{CubeRef, MemberSymbol, TraversalVisitor};
 use cubenativeutils::CubeError;
 use itertools::Itertools;
 use std::rc::Rc;
@@ -77,20 +77,24 @@ impl TraversalVisitor for JoinHintsCollector {
                     }
                 }
             }
-            MemberSymbol::CubeName(e) => {
-                if !path.is_empty() {
-                    let mut path = path.clone();
-                    path.push(e.cube_name().clone());
-                    self.hints.push(JoinHintItem::Vector(path));
-                } else {
-                    self.hints.push(JoinHintItem::Single(e.cube_name().clone()));
-                }
-            }
-            MemberSymbol::CubeTable(_) => {}
             MemberSymbol::MemberExpression(_) => {}
         };
         Ok(Some(()))
     }
+
+    fn on_cube_ref(&mut self, cube_ref: &CubeRef, _state: &Self::State) -> Result<(), CubeError> {
+        if let CubeRef::Name { symbol, path, .. } = cube_ref {
+            if !path.is_empty() {
+                let mut path = path.clone();
+                path.push(symbol.cube_name().clone());
+                self.hints.push(JoinHintItem::Vector(path));
+            } else {
+                self.hints
+                    .push(JoinHintItem::Single(symbol.cube_name().clone()));
+            }
+        }
+        Ok(())
+    }
 }
 
 pub fn collect_join_hints(node: &Rc<MemberSymbol>) -> Result<Vec<JoinHintItem>, CubeError> {

rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/member_childs_collector.rs

@@ -38,13 +38,7 @@ impl TraversalVisitor for MemberChildsCollector {
     ) -> Result<Option<Self::State>, CubeError> {
         if state.is_root {
             let new_state = MemberChildsCollectorState::new(false);
-            match node.as_ref() {
-                MemberSymbol::Measure(_) => Ok(Some(new_state)),
-                MemberSymbol::Dimension(_) => Ok(Some(new_state)),
-                MemberSymbol::TimeDimension(_) => Ok(Some(new_state)),
-                MemberSymbol::MemberExpression(_) => Ok(Some(new_state)),
-                _ => Ok(None),
-            }
+            Ok(Some(new_state))
         } else {
             match node.as_ref() {
                 MemberSymbol::Measure(_) | MemberSymbol::Dimension(_) => {

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

@@ -3,8 +3,8 @@ use super::symbols::{MemberExpressionExpression, MemberExpressionSymbol, MemberS
 use super::SymbolPath;
 use super::SymbolPathType;
 use super::{
-    CubeNameSymbolFactory, CubeTableSymbolFactory, DimensionSymbolFactory, MeasureSymbolFactory,
-    SqlCall, SymbolFactory, TraversalVisitor,
+    CubeNameSymbol, CubeNameSymbolFactory, CubeTableSymbol, CubeTableSymbolFactory,
+    DimensionSymbolFactory, MeasureSymbolFactory, SqlCall, SymbolFactory, TraversalVisitor,
 };
 use crate::cube_bridge::base_tools::BaseTools;
 use crate::cube_bridge::evaluator::CubeEvaluator;
@@ -23,8 +23,6 @@ enum CacheSymbolType {
     Dimension,
     Measure,
     Segment,
-    CubeTable,
-    CubeName,
 }
 
 pub struct Compiler {
@@ -33,6 +31,8 @@ pub struct Compiler {
     security_context: Rc<dyn SecurityContext>,
     timezone: Tz,
     members: HashMap<(CacheSymbolType, String), Rc<MemberSymbol>>,
+    cube_names: HashMap<String, Rc<CubeNameSymbol>>,
+    cube_tables: HashMap<String, Rc<CubeTableSymbol>>,
 }
 
 impl Compiler {
@@ -48,6 +48,8 @@ impl Compiler {
             base_tools,
             timezone,
             members: HashMap::new(),
+            cube_names: HashMap::new(),
+            cube_tables: HashMap::new(),
         }
     }
 
@@ -150,27 +152,27 @@ impl Compiler {
     pub fn add_cube_name_evaluator(
         &mut self,
         cube_name: String,
-    ) -> Result<Rc<MemberSymbol>, CubeError> {
-        if let Some(exists) = self.exists_member(CacheSymbolType::CubeName, &cube_name) {
+    ) -> Result<Rc<CubeNameSymbol>, CubeError> {
+        if let Some(exists) = self.cube_names.get(&cube_name) {
             Ok(exists.clone())
         } else {
             let result = CubeNameSymbolFactory::try_new(&cube_name, self.cube_evaluator.clone())?
                 .build(self)?;
-            self.validate_and_cache_result(CacheSymbolType::CubeName, result.clone())?;
+            self.cube_names.insert(cube_name, result.clone());
             Ok(result)
         }
     }
 
     pub fn add_cube_table_evaluator(
         &mut self,
         cube_name: String,
-    ) -> Result<Rc<MemberSymbol>, CubeError> {
-        if let Some(exists) = self.exists_member(CacheSymbolType::CubeTable, &cube_name) {
+    ) -> Result<Rc<CubeTableSymbol>, CubeError> {
+        if let Some(exists) = self.cube_tables.get(&cube_name) {
             Ok(exists.clone())
         } else {
             let result = CubeTableSymbolFactory::try_new(&cube_name, self.cube_evaluator.clone())?
                 .build(self)?;
-            self.validate_and_cache_result(CacheSymbolType::CubeTable, result.clone())?;
+            self.cube_tables.insert(cube_name, result.clone());
             Ok(result)
         }
     }

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

@@ -0,0 +1,56 @@
+use super::sql_nodes::SqlNode;
+use super::SqlEvaluatorVisitor;
+use crate::planner::query_tools::QueryTools;
+use crate::planner::sql_evaluator::sql_call::CubeRef;
+use crate::planner::sql_templates::PlanSqlTemplates;
+use cubenativeutils::CubeError;
+use std::collections::HashMap;
+use std::rc::Rc;
+
+pub struct CubeRefEvaluator {
+    cube_name_references: HashMap<String, String>,
+    original_sql_pre_aggregations: HashMap<String, String>,
+}
+
+impl CubeRefEvaluator {
+    pub fn new(
+        cube_name_references: HashMap<String, String>,
+        original_sql_pre_aggregations: HashMap<String, String>,
+    ) -> Self {
+        Self {
+            cube_name_references,
+            original_sql_pre_aggregations,
+        }
+    }
+
+    pub fn evaluate(
+        &self,
+        cube_ref: &CubeRef,
+        visitor: &SqlEvaluatorVisitor,
+        node_processor: Rc<dyn SqlNode>,
+        query_tools: Rc<QueryTools>,
+        templates: &PlanSqlTemplates,
+    ) -> Result<String, CubeError> {
+        match cube_ref {
+            CubeRef::Name { symbol, .. } => {
+                let name = symbol.evaluate_sql()?;
+                let alias = self.resolve_cube_alias(&name);
+                templates.quote_identifier(&alias)
+            }
+            CubeRef::Table { symbol, .. } => {
+                if let Some(pre_agg) = self.original_sql_pre_aggregations.get(symbol.cube_name()) {
+                    return Ok(pre_agg.clone());
+                }
+                symbol.evaluate_sql(visitor, node_processor, query_tools, templates)
+            }
+        }
+    }
+
+    fn resolve_cube_alias(&self, name: &String) -> String {
+        if let Some(alias) = self.cube_name_references.get(name) {
+            alias.clone()
+        } else {
+            name.clone()
+        }
+    }
+}

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

@@ -1,5 +1,6 @@
 pub mod collectors;
 pub mod compiler;
+pub mod cube_ref_evaluator;
 pub mod references_builder;
 pub mod sql_call;
 mod sql_call_builder;
@@ -10,6 +11,7 @@ pub mod visitor;
 
 pub use crate::utils::debug::DebugSql;
 pub use compiler::Compiler;
+pub use cube_ref_evaluator::CubeRefEvaluator;
 pub use references_builder::ReferencesBuilder;
 pub use sql_call::*;
 pub use sql_visitor::SqlEvaluatorVisitor;