fix(tesseract): Allow paths for symbols in request

rust/cubesqlplanner/cubesqlplanner/src/physical_plan_builder/processors/pre_aggregation.rs

@@ -29,7 +29,7 @@ impl PreAggregationProcessor<'_> {
         let table_name = query_tools
             .base_tools()
             .pre_aggregation_table_name(table.cube_name.clone(), name.clone())?;
-        let alias = PlanSqlTemplates::memeber_alias_name(&table.cube_name, &name, &None);
+        let alias = PlanSqlTemplates::member_alias_name(&table.cube_name, &name, &None);
         let res = SingleAliasedSource::new_from_table_reference(
             table_name,
             Rc::new(Schema::empty()),
@@ -87,7 +87,7 @@ impl PreAggregationProcessor<'_> {
             let mut select_builder = SelectBuilder::new(from);
             for dim in pre_aggregation.dimensions().iter() {
                 let name_in_table =
-                    PlanSqlTemplates::memeber_alias_name(&item.cube_alias, &dim.name(), &None);
+                    PlanSqlTemplates::member_alias_name(&item.cube_alias, &dim.name(), &None);
                 let alias = dim.alias();
                 select_builder.add_projection_reference_member(
                     &dim,
@@ -102,7 +102,7 @@ impl PreAggregationProcessor<'_> {
                     (dim.alias(), None)
                 };
 
-                let name_in_table = PlanSqlTemplates::memeber_alias_name(
+                let name_in_table = PlanSqlTemplates::member_alias_name(
                     &item.cube_alias,
                     &dim.name(),
                     &granularity,
@@ -121,7 +121,7 @@ impl PreAggregationProcessor<'_> {
                 );
             }
             for meas in pre_aggregation.measures().iter() {
-                let name_in_table = PlanSqlTemplates::memeber_alias_name(
+                let name_in_table = PlanSqlTemplates::member_alias_name(
                     &item.cube_alias,
                     &meas.name(),
                     &meas.alias_suffix(),
@@ -141,7 +141,7 @@ impl PreAggregationProcessor<'_> {
 
         let plan = QueryPlan::Union(Rc::new(Union::new(union_sources)));
         let source = SingleSource::Subquery(Rc::new(plan));
-        let alias = PlanSqlTemplates::memeber_alias_name(
+        let alias = PlanSqlTemplates::member_alias_name(
             pre_aggregation.cube_name(),
             pre_aggregation.name(),
             &None,

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

@@ -1,5 +1,6 @@
 use super::collectors::JoinHintsCollector;
 use super::symbols::MemberSymbol;
+use super::SymbolPath;
 use super::{
     CubeNameSymbolFactory, CubeTableSymbolFactory, DimensionSymbolFactory, MeasureSymbolFactory,
     SqlCall, SymbolFactory, TraversalVisitor,
@@ -14,13 +15,21 @@ use chrono_tz::Tz;
 use cubenativeutils::CubeError;
 use std::collections::HashMap;
 use std::rc::Rc;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+enum CacheSymbolType {
+    Dimension,
+    Measure,
+    CubeTable,
+    CubeName,
+}
+
 pub struct Compiler {
     cube_evaluator: Rc<dyn CubeEvaluator>,
     base_tools: Rc<dyn BaseTools>,
     security_context: Rc<dyn SecurityContext>,
     timezone: Tz,
-    /* (type, name) */
-    members: HashMap<(String, String), Rc<MemberSymbol>>,
+    members: HashMap<(CacheSymbolType, String), Rc<MemberSymbol>>,
 }
 
 impl Compiler {
@@ -60,55 +69,71 @@ impl Compiler {
         &mut self,
         measure: String,
     ) -> Result<Rc<MemberSymbol>, CubeError> {
-        if let Some(exists) = self.exists_member::<MeasureSymbolFactory>(&measure) {
+        let path = SymbolPath::parse(self.cube_evaluator.clone(), &measure)?;
+        self.add_measure_evaluator_impl(path)
+    }
+
+    fn add_measure_evaluator_impl(
+        &mut self,
+        path: SymbolPath,
+    ) -> Result<Rc<MemberSymbol>, CubeError> {
+        if let Some(exists) = self.exists_member(CacheSymbolType::Measure, &path.cache_name()) {
             Ok(exists.clone())
         } else {
-            self.add_evaluator_impl(
-                &measure,
-                MeasureSymbolFactory::try_new(&measure, self.cube_evaluator.clone())?,
-            )
+            let result =
+                MeasureSymbolFactory::try_new(path, self.cube_evaluator.clone())?.build(self)?;
+            self.validate_and_cache_result(CacheSymbolType::Measure, result.clone())?;
+            Ok(result)
         }
     }
 
     pub fn add_dimension_evaluator(
         &mut self,
         dimension: String,
     ) -> Result<Rc<MemberSymbol>, CubeError> {
-        if let Some(exists) = self.exists_member::<DimensionSymbolFactory>(&dimension) {
+        let path = SymbolPath::parse(self.cube_evaluator.clone(), &dimension)?;
+        self.add_dimension_evaluator_impl(path)
+    }
+
+    fn add_dimension_evaluator_impl(
+        &mut self,
+        path: SymbolPath,
+    ) -> Result<Rc<MemberSymbol>, CubeError> {
+        if let Some(exists) = self.exists_member(CacheSymbolType::Dimension, &path.cache_name()) {
             Ok(exists.clone())
         } else {
-            self.add_evaluator_impl(
-                &dimension,
-                DimensionSymbolFactory::try_new(&dimension, self.cube_evaluator.clone())?,
-            )
+            let result =
+                DimensionSymbolFactory::try_new(path, self.cube_evaluator.clone())?.build(self)?;
+            self.validate_and_cache_result(CacheSymbolType::Dimension, result.clone())?;
+            Ok(result)
         }
     }
 
     pub fn add_cube_name_evaluator(
         &mut self,
         cube_name: String,
     ) -> Result<Rc<MemberSymbol>, CubeError> {
-        if let Some(exists) = self.exists_member::<CubeNameSymbolFactory>(&cube_name) {
+        if let Some(exists) = self.exists_member(CacheSymbolType::CubeName, &cube_name) {
             Ok(exists.clone())
         } else {
-            self.add_evaluator_impl(
-                &cube_name,
-                CubeNameSymbolFactory::try_new(&cube_name, self.cube_evaluator.clone())?,
-            )
+            let result = CubeNameSymbolFactory::try_new(&cube_name, self.cube_evaluator.clone())?
+                .build(self)?;
+            self.validate_and_cache_result(CacheSymbolType::CubeName, 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::<CubeTableSymbolFactory>(&cube_name) {
+        if let Some(exists) = self.exists_member(CacheSymbolType::CubeTable, &cube_name) {
             Ok(exists.clone())
         } else {
-            self.add_evaluator_impl(
-                &cube_name,
-                CubeTableSymbolFactory::try_new(&cube_name, self.cube_evaluator.clone())?,
-            )
+            let result = CubeTableSymbolFactory::try_new(&cube_name, self.cube_evaluator.clone())?
+                .build(self)?;
+            self.validate_and_cache_result(CacheSymbolType::CubeTable, result.clone())?;
+            Ok(result)
         }
     }
 
@@ -139,26 +164,23 @@ impl Compiler {
         Ok(Rc::new(sql_call))
     }
 
-    fn exists_member<T: SymbolFactory>(&self, full_name: &String) -> Option<Rc<MemberSymbol>> {
-        if T::is_cachable() {
-            let key = (T::symbol_name(), full_name.clone());
-            self.members.get(&key).cloned()
-        } else {
-            None
-        }
+    fn exists_member(
+        &self,
+        symbol_type: CacheSymbolType,
+        full_name: &String,
+    ) -> Option<Rc<MemberSymbol>> {
+        let key = (symbol_type, full_name.clone());
+        self.members.get(&key).cloned()
     }
 
-    fn add_evaluator_impl<T: SymbolFactory + 'static>(
+    fn validate_and_cache_result(
         &mut self,
-        full_name: &String,
-        factory: T,
-    ) -> Result<Rc<MemberSymbol>, CubeError> {
-        let node = factory.build(self)?;
+        symbol_type: CacheSymbolType,
+        node: Rc<MemberSymbol>,
+    ) -> Result<(), CubeError> {
         node.validate()?;
-        let key = (T::symbol_name().to_string(), full_name.clone());
-        if T::is_cachable() {
-            self.members.insert(key, node.clone());
-        }
-        Ok(node)
+        let key = (symbol_type, node.full_name().clone());
+        self.members.insert(key, node.clone());
+        Ok(())
     }
 }

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

@@ -1,5 +1,7 @@
 mod case;
 mod static_filter;
+mod symbol_path;
 
 pub use case::*;
 pub use static_filter::*;
+pub use symbol_path::*;