diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/base_cube.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/base_cube.rs index ac9d255290626..b8f7d8661efd5 100644 --- a/rust/cubesqlplanner/cubesqlplanner/src/planner/base_cube.rs +++ b/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,7 +10,7 @@ use std::rc::Rc; pub struct BaseCube { cube_name: String, members: HashSet, - member_evaluator: Rc, + cube_table_symbol: Rc, definition: Rc, query_tools: Rc, } @@ -18,7 +18,7 @@ impl BaseCube { pub fn try_new( cube_name: String, query_tools: Rc, - member_evaluator: Rc, + cube_table_symbol: Rc, ) -> Result, 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, templates: &PlanSqlTemplates, ) -> Result { - 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 { diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/calc_group_dims_collector.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/calc_group_dims_collector.rs index 1b78e4c148011..9dc6e187dfe95 100644 --- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/calc_group_dims_collector.rs +++ b/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(())) diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/cube_names_collector.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/cube_names_collector.rs index a808ebf327858..085ed8bc872c0 100644 --- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/cube_names_collector.rs +++ b/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) -> Result, CubeError> { diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/join_hints_collector.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/join_hints_collector.rs index 3d97d316f82dd..a0b9f248b46ee 100644 --- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/join_hints_collector.rs +++ b/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) -> Result, CubeError> { diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/member_childs_collector.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/member_childs_collector.rs index 002de18a005b2..a0e6d986879f5 100644 --- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/member_childs_collector.rs +++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/member_childs_collector.rs @@ -38,13 +38,7 @@ impl TraversalVisitor for MemberChildsCollector { ) -> Result, 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(_) => { diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/compiler.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/compiler.rs index 7bd2eca25521f..6c133522863ff 100644 --- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/compiler.rs +++ b/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, timezone: Tz, members: HashMap<(CacheSymbolType, String), Rc>, + cube_names: HashMap>, + cube_tables: HashMap>, } impl Compiler { @@ -48,6 +48,8 @@ impl Compiler { base_tools, timezone, members: HashMap::new(), + cube_names: HashMap::new(), + cube_tables: HashMap::new(), } } @@ -150,13 +152,13 @@ impl Compiler { pub fn add_cube_name_evaluator( &mut self, cube_name: String, - ) -> Result, CubeError> { - if let Some(exists) = self.exists_member(CacheSymbolType::CubeName, &cube_name) { + ) -> Result, 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) } } @@ -164,13 +166,13 @@ impl Compiler { pub fn add_cube_table_evaluator( &mut self, cube_name: String, - ) -> Result, CubeError> { - if let Some(exists) = self.exists_member(CacheSymbolType::CubeTable, &cube_name) { + ) -> Result, 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) } } diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/cube_ref_evaluator.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/cube_ref_evaluator.rs new file mode 100644 index 0000000000000..1bf94e8f7e824 --- /dev/null +++ b/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, + original_sql_pre_aggregations: HashMap, +} + +impl CubeRefEvaluator { + pub fn new( + cube_name_references: HashMap, + original_sql_pre_aggregations: HashMap, + ) -> Self { + Self { + cube_name_references, + original_sql_pre_aggregations, + } + } + + pub fn evaluate( + &self, + cube_ref: &CubeRef, + visitor: &SqlEvaluatorVisitor, + node_processor: Rc, + query_tools: Rc, + templates: &PlanSqlTemplates, + ) -> Result { + 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() + } + } +} diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/mod.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/mod.rs index c3808d4b1e4f7..4ed960282c467 100644 --- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/mod.rs +++ b/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; diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_call.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_call.rs index 574192490272d..c6989cefc838d 100644 --- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_call.rs +++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_call.rs @@ -3,7 +3,7 @@ use super::{symbols::MemberSymbol, SqlEvaluatorVisitor}; use crate::cube_bridge::member_sql::{FilterParamsColumn, SecutityContextProps, SqlTemplate}; use crate::planner::query_tools::QueryTools; use crate::planner::sql_evaluator::sql_nodes::SqlNodesFactory; -use crate::planner::sql_evaluator::CubeNameSymbol; +use crate::planner::sql_evaluator::{CubeNameSymbol, CubeTableSymbol}; use crate::planner::sql_templates::PlanSqlTemplates; use crate::planner::VisitorContext; use cubenativeutils::CubeError; @@ -11,6 +11,78 @@ use itertools::Itertools; use std::collections::HashMap; use std::rc::Rc; +#[derive(Clone, Debug)] +pub enum CubeRef { + Name { + symbol: Rc, + path: Vec, + }, + Table { + symbol: Rc, + path: Vec, + }, +} + +impl CubeRef { + pub fn cube_name(&self) -> &String { + match self { + CubeRef::Name { symbol, .. } => symbol.cube_name(), + CubeRef::Table { symbol, .. } => symbol.cube_name(), + } + } + + pub fn path(&self) -> &Vec { + match self { + CubeRef::Name { path, .. } => path, + CubeRef::Table { path, .. } => path, + } + } + + pub fn as_name(&self) -> Option<&Rc> { + match self { + CubeRef::Name { symbol, .. } => Some(symbol), + _ => None, + } + } + + pub fn as_table(&self) -> Option<&Rc> { + match self { + CubeRef::Table { symbol, .. } => Some(symbol), + _ => None, + } + } +} + +#[derive(Clone, Debug)] +pub enum SqlDependency { + Symbol(Rc), + CubeRef(CubeRef), +} + +impl SqlDependency { + pub fn as_symbol(&self) -> Option<&Rc> { + match self { + SqlDependency::Symbol(s) => Some(s), + _ => None, + } + } + + pub fn as_cube_ref(&self) -> Option<&CubeRef> { + match self { + SqlDependency::CubeRef(cr) => Some(cr), + _ => None, + } + } + + pub fn is_symbol(&self) -> bool { + matches!(self, SqlDependency::Symbol(_)) + } + + pub fn is_cube_ref(&self) -> bool { + matches!(self, SqlDependency::CubeRef(_)) + } +} + pub struct SqlCallArg; impl SqlCallArg { @@ -36,7 +108,7 @@ impl SqlCallArg { #[derive(Debug, Clone)] pub struct SqlCallDependency { pub path: Vec, - pub symbol: Rc, + pub symbol: SqlDependency, } #[derive(Debug, Clone)] @@ -141,7 +213,7 @@ impl SqlCall { if self.deps.is_empty() { true } else { - self.deps.iter().any(|dep| dep.symbol.is_cube()) + self.deps.iter().any(|dep| dep.symbol.is_cube_ref()) } } @@ -149,8 +221,8 @@ impl SqlCall { self.deps .iter() .filter_map(|dep| { - if let Ok(cube) = dep.symbol.as_cube_name() { - Some(cube.clone()) + if let SqlDependency::CubeRef(CubeRef::Name { symbol, .. }) = &dep.symbol { + Some(symbol.clone()) } else { None } @@ -158,6 +230,12 @@ impl SqlCall { .collect() } + pub fn get_cube_refs(&self) -> Vec { + let mut result = vec![]; + self.extract_cube_refs(&mut result); + result + } + fn prepare_template_params( &self, visitor: &SqlEvaluatorVisitor, @@ -188,7 +266,12 @@ impl SqlCall { let deps = self .deps .iter() - .map(|dep| visitor.apply(&dep.symbol, node_processor.clone(), templates)) + .map(|dep| match &dep.symbol { + SqlDependency::Symbol(m) => visitor.apply(m, node_processor.clone(), templates), + SqlDependency::CubeRef(cr) => { + visitor.evaluate_cube_ref(cr, node_processor.clone(), templates) + } + }) .collect::, _>>()?; let context_values = self.eval_security_context_values(&query_tools); @@ -319,36 +402,61 @@ impl SqlCall { pub fn resolve_direct_reference(&self) -> Option> { if self.is_direct_reference() { - Some(self.deps[0].symbol.clone()) + self.deps[0].symbol.as_symbol().cloned() } else { None } } pub fn dependencies_count(&self) -> usize { - self.deps.iter().filter(|d| !d.symbol.is_cube()).count() + self.deps.iter().filter(|d| d.symbol.is_symbol()).count() } pub fn get_dependencies(&self) -> Vec> { - self.deps.iter().map(|d| d.symbol.clone()).collect() + self.deps + .iter() + .filter_map(|d| d.symbol.as_symbol().cloned()) + .collect() } pub fn get_dependencies_with_path(&self) -> Vec<(Rc, Vec)> { self.deps .iter() - .map(|d| (d.symbol.clone(), d.path.clone())) + .filter_map(|d| d.symbol.as_symbol().map(|s| (s.clone(), d.path.clone()))) .collect() } pub fn extract_symbol_deps(&self, result: &mut Vec>) { for dep in self.deps.iter() { - result.push(dep.symbol.clone()) + if let Some(s) = dep.symbol.as_symbol() { + result.push(s.clone()) + } } } pub fn extract_symbol_deps_with_path(&self, result: &mut Vec<(Rc, Vec)>) { for dep in self.deps.iter() { - result.push((dep.symbol.clone(), dep.path.clone())) + if let Some(s) = dep.symbol.as_symbol() { + result.push((s.clone(), dep.path.clone())) + } + } + } + + pub fn extract_cube_refs(&self, result: &mut Vec) { + for dep in self.deps.iter() { + if let SqlDependency::CubeRef(cr) = &dep.symbol { + let cube_ref = match cr { + CubeRef::Name { symbol, .. } => CubeRef::Name { + symbol: symbol.clone(), + path: dep.path.clone(), + }, + CubeRef::Table { symbol, .. } => CubeRef::Table { + symbol: symbol.clone(), + path: dep.path.clone(), + }, + }; + result.push(cube_ref); + } } } @@ -358,7 +466,9 @@ impl SqlCall { ) -> Result, CubeError> { let mut result = self.clone(); for dep in result.deps.iter_mut() { - dep.symbol = dep.symbol.apply_recursive(f)?; + if let SqlDependency::Symbol(ref s) = dep.symbol { + dep.symbol = SqlDependency::Symbol(s.apply_recursive(f)?); + } } Ok(Rc::new(result)) } @@ -376,11 +486,20 @@ impl crate::utils::debug::DebugSql for SqlCall { let deps = self .deps .iter() - .map(|dep| { - if expand_deps { - dep.symbol.debug_sql(true) - } else { - format!("{{{}}}", dep.symbol.full_name()) + .map(|dep| match &dep.symbol { + SqlDependency::Symbol(s) => { + if expand_deps { + s.debug_sql(true) + } else { + format!("{{{}}}", s.full_name()) + } + } + SqlDependency::CubeRef(cr) => { + if expand_deps { + cr.cube_name().clone() + } else { + format!("{{{}}}", cr.cube_name()) + } } }) .collect_vec(); diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_call_builder.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_call_builder.rs index f28b19ea07431..99a32ff5352f9 100644 --- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_call_builder.rs +++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_call_builder.rs @@ -1,6 +1,9 @@ use super::symbols::MemberSymbol; use super::Compiler; -use super::{SqlCall, SqlCallDependency, SqlCallFilterGroupItem, SqlCallFilterParamsItem}; +use super::{ + CubeRef, SqlCall, SqlCallDependency, SqlCallFilterGroupItem, SqlCallFilterParamsItem, + SqlDependency, +}; use crate::cube_bridge::base_tools::BaseTools; use crate::cube_bridge::evaluator::CubeEvaluator; use crate::cube_bridge::member_sql::*; @@ -150,7 +153,7 @@ impl<'a> SqlCallBuilder<'a> { )); let result = SqlCallDependency { path: processed_path, - symbol: time_dim_symbol, + symbol: SqlDependency::Symbol(time_dim_symbol), }; return Some(result); } else { @@ -163,7 +166,7 @@ impl<'a> SqlCallBuilder<'a> { } let result = SqlCallDependency { path: processed_path, - symbol: member_symbol, + symbol: SqlDependency::Symbol(member_symbol), }; Some(result) } else { @@ -179,16 +182,24 @@ impl<'a> SqlCallBuilder<'a> { ) -> Result { processed_path.push(cube_name.clone()); if path_tail.len() == 1 { + let symbol = self.compiler.add_cube_name_evaluator(cube_name.clone())?; let result = SqlCallDependency { - path: processed_path, - symbol: self.compiler.add_cube_name_evaluator(cube_name.clone())?, + path: processed_path.clone(), + symbol: SqlDependency::CubeRef(CubeRef::Name { + symbol, + path: processed_path, + }), }; return Ok(result); } if path_tail.len() == 2 && path_tail[1] == "__sql_fn" { + let symbol = self.compiler.add_cube_table_evaluator(cube_name.clone())?; let result = SqlCallDependency { - path: processed_path, - symbol: self.compiler.add_cube_table_evaluator(cube_name.clone())?, + path: processed_path.clone(), + symbol: SqlDependency::CubeRef(CubeRef::Table { + symbol, + path: processed_path, + }), }; return Ok(result); } diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/auto_prefix.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/auto_prefix.rs index aa2ff4657e3fa..74fb544f4eaf9 100644 --- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/auto_prefix.rs +++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/auto_prefix.rs @@ -105,10 +105,6 @@ impl SqlNode for AutoPrefixSqlNode { let cube_alias = self.resolve_cube_alias(&ev.cube_name()); self.auto_prefix_with_cube_name(&cube_alias, &input, templates)? } - MemberSymbol::CubeName(_) => { - let cube_alias = self.resolve_cube_alias(&input); - templates.quote_identifier(&cube_alias)? - } _ => input, }; Ok(res) diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/evaluate_sql.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/evaluate_sql.rs index e4cfd834fab8c..9a96dc43739c6 100644 --- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/evaluate_sql.rs +++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/evaluate_sql.rs @@ -44,13 +44,6 @@ impl SqlNode for EvaluateSqlNode { query_tools.clone(), templates, ), - MemberSymbol::CubeTable(ev) => ev.evaluate_sql( - visitor, - node_processor.clone(), - query_tools.clone(), - templates, - ), - MemberSymbol::CubeName(ev) => ev.evaluate_sql(), MemberSymbol::MemberExpression(e) => { let res = e.evaluate_sql( visitor, diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/factory.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/factory.rs index c3e8838d72f02..c0911d4a7047c 100644 --- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/factory.rs +++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/factory.rs @@ -1,12 +1,12 @@ use super::{ AutoPrefixSqlNode, CaseSqlNode, EvaluateSqlNode, FinalMeasureSqlNode, FinalPreAggregationMeasureSqlNode, GeoDimensionSqlNode, MeasureFilterSqlNode, - MultiStageRankNode, MultiStageWindowNode, OriginalSqlPreAggregationSqlNode, - RenderReferencesSqlNode, RenderReferencesType, RollingWindowNode, RootSqlNode, SqlNode, - TimeDimensionNode, TimeShiftSqlNode, UngroupedMeasureSqlNode, - UngroupedQueryFinalMeasureSqlNode, + MultiStageRankNode, MultiStageWindowNode, RenderReferencesSqlNode, RenderReferencesType, + RollingWindowNode, RootSqlNode, SqlNode, TimeDimensionNode, TimeShiftSqlNode, + UngroupedMeasureSqlNode, UngroupedQueryFinalMeasureSqlNode, }; use crate::planner::planners::multi_stage::TimeShiftState; +use crate::planner::sql_evaluator::cube_ref_evaluator::CubeRefEvaluator; use crate::planner::sql_evaluator::sql_nodes::calendar_time_shift::CalendarTimeShiftSqlNode; use crate::planner::sql_evaluator::sql_nodes::RenderReferences; use crate::planner::sql_evaluator::symbols::CalendarDimensionTimeShift; @@ -143,6 +143,13 @@ impl SqlNodesFactory { self.cube_name_references.insert(key, value); } + pub fn cube_ref_evaluator(&self) -> CubeRefEvaluator { + CubeRefEvaluator::new( + self.cube_name_references.clone(), + self.original_sql_pre_aggregations.clone(), + ) + } + pub fn default_node_processor(&self) -> Rc { let evaluate_sql_processor = EvaluateSqlNode::new(); let auto_prefix_processor = AutoPrefixSqlNode::new( @@ -173,23 +180,10 @@ impl SqlNodesFactory { self.dimension_processor(evaluate_sql_processor.clone()), self.time_dimension_processor(evaluate_sql_processor.clone()), measure_processor.clone(), - auto_prefix_processor.clone(), - self.cube_table_processor(evaluate_sql_processor.clone()), default_processor, ); RenderReferencesSqlNode::new(root_node, self.render_references.clone()) } - - fn cube_table_processor(&self, default: Rc) -> Rc { - if !self.original_sql_pre_aggregations.is_empty() { - OriginalSqlPreAggregationSqlNode::new( - default, - self.original_sql_pre_aggregations.clone(), - ) - } else { - default - } - } fn add_ungrouped_measure_reference_if_needed( &self, default: Rc, diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/mod.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/mod.rs index 39ace9d7522d2..f144b3fe61a94 100644 --- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/mod.rs +++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/mod.rs @@ -10,7 +10,6 @@ pub mod geo_dimension; pub mod measure_filter; pub mod multi_stage_rank; pub mod multi_stage_window; -pub mod original_sql_pre_aggregation; pub mod render_references; pub mod rolling_window; pub mod root_processor; @@ -31,7 +30,6 @@ pub use geo_dimension::GeoDimensionSqlNode; pub use measure_filter::MeasureFilterSqlNode; pub use multi_stage_rank::MultiStageRankNode; pub use multi_stage_window::MultiStageWindowNode; -pub use original_sql_pre_aggregation::OriginalSqlPreAggregationSqlNode; pub use render_references::*; pub use rolling_window::RollingWindowNode; pub use root_processor::RootSqlNode; diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/root_processor.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/root_processor.rs index a481329173cfe..493f7eb5d3c94 100644 --- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/root_processor.rs +++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/root_processor.rs @@ -11,8 +11,6 @@ pub struct RootSqlNode { dimension_processor: Rc, time_dimesions_processor: Rc, measure_processor: Rc, - cube_name_processor: Rc, - cube_table_processor: Rc, default_processor: Rc, } @@ -21,16 +19,12 @@ impl RootSqlNode { dimension_processor: Rc, time_dimesions_processor: Rc, measure_processor: Rc, - cube_name_processor: Rc, - cube_table_processor: Rc, default_processor: Rc, ) -> Rc { Rc::new(Self { dimension_processor, time_dimesions_processor, measure_processor, - cube_name_processor, - cube_table_processor, default_processor, }) } @@ -43,10 +37,6 @@ impl RootSqlNode { &self.measure_processor } - pub fn cube_name_processor(&self) -> &Rc { - &self.cube_name_processor - } - pub fn default_processor(&self) -> &Rc { &self.default_processor } @@ -83,20 +73,6 @@ impl SqlNode for RootSqlNode { node_processor.clone(), templates, )?, - MemberSymbol::CubeName(_) => self.cube_name_processor.to_sql( - visitor, - node, - query_tools.clone(), - node_processor.clone(), - templates, - )?, - MemberSymbol::CubeTable(_) => self.cube_table_processor.to_sql( - visitor, - node, - query_tools.clone(), - node_processor.clone(), - templates, - )?, _ => self.default_processor.to_sql( visitor, node, @@ -116,7 +92,6 @@ impl SqlNode for RootSqlNode { vec![ self.dimension_processor.clone(), self.measure_processor.clone(), - self.cube_name_processor.clone(), self.default_processor.clone(), ] } diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_visitor.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_visitor.rs index 24d39e7326a10..eb9def9ce21aa 100644 --- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_visitor.rs +++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_visitor.rs @@ -1,7 +1,9 @@ use super::sql_nodes::SqlNode; +use super::CubeRefEvaluator; use super::MemberSymbol; use crate::plan::Filter; 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::rc::Rc; @@ -9,13 +11,19 @@ use std::rc::Rc; #[derive(Clone)] pub struct SqlEvaluatorVisitor { query_tools: Rc, + cube_ref_evaluator: Rc, all_filters: Option, //To pass to FILTER_PARAMS and FILTER_GROUP } impl SqlEvaluatorVisitor { - pub fn new(query_tools: Rc, all_filters: Option) -> Self { + pub fn new( + query_tools: Rc, + cube_ref_evaluator: Rc, + all_filters: Option, + ) -> Self { Self { query_tools, + cube_ref_evaluator, all_filters, } } @@ -39,4 +47,19 @@ impl SqlEvaluatorVisitor { )?; Ok(result) } + + pub fn evaluate_cube_ref( + &self, + cube_ref: &CubeRef, + node_processor: Rc, + templates: &PlanSqlTemplates, + ) -> Result { + self.cube_ref_evaluator.evaluate( + cube_ref, + self, + node_processor, + self.query_tools.clone(), + templates, + ) + } } diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/common/case.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/common/case.rs index ae36170b4c29f..4066a50df1857 100644 --- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/common/case.rs +++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/common/case.rs @@ -4,7 +4,7 @@ use crate::{ case_switch_definition::CaseSwitchDefinition as NativeCaseSwitchDefinition, case_variant::CaseVariant, string_or_sql::StringOrSql, }, - planner::sql_evaluator::{find_value_restriction, Compiler, MemberSymbol, SqlCall}, + planner::sql_evaluator::{find_value_restriction, Compiler, CubeRef, MemberSymbol, SqlCall}, }; use cubenativeutils::CubeError; use itertools::Itertools; @@ -29,6 +29,18 @@ pub struct CaseDefinition { } impl CaseDefinition { + fn extract_cube_refs(&self, result: &mut Vec) { + for itm in self.items.iter() { + itm.sql.extract_cube_refs(result); + if let CaseLabel::Sql(sql) = &itm.label { + sql.extract_cube_refs(result); + } + } + if let CaseLabel::Sql(sql) = &self.else_label { + sql.extract_cube_refs(result); + } + } + fn extract_symbol_deps(&self, result: &mut Vec>) { for itm in self.items.iter() { itm.sql.extract_symbol_deps(result); @@ -104,6 +116,13 @@ pub enum CaseSwitchItem { } impl CaseSwitchItem { + fn extract_cube_refs(&self, result: &mut Vec) { + match self { + CaseSwitchItem::Sql(sql_call) => sql_call.extract_cube_refs(result), + CaseSwitchItem::Member(_) => {} + } + } + fn extract_symbol_deps(&self, result: &mut Vec>) { match self { CaseSwitchItem::Sql(sql_call) => sql_call.extract_symbol_deps(result), @@ -145,6 +164,16 @@ pub struct CaseSwitchDefinition { } impl CaseSwitchDefinition { + fn extract_cube_refs(&self, result: &mut Vec) { + self.switch.extract_cube_refs(result); + for itm in self.items.iter() { + itm.sql.extract_cube_refs(result); + } + if let Some(else_sql) = &self.else_sql { + else_sql.extract_cube_refs(result); + } + } + pub fn try_new( cube_name: &String, definition: Rc, @@ -369,6 +398,13 @@ impl Case { Ok(res) } + pub fn extract_cube_refs(&self, result: &mut Vec) { + match self { + Case::Case(def) => def.extract_cube_refs(result), + Case::CaseSwitch(def) => def.extract_cube_refs(result), + } + } + pub fn extract_symbol_deps(&self, result: &mut Vec>) { match self { Case::Case(def) => def.extract_symbol_deps(result), diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/cube_symbol.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/cube_symbol.rs index db1a271acbbd7..f2ac27522b0c1 100644 --- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/cube_symbol.rs +++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/cube_symbol.rs @@ -1,4 +1,3 @@ -use super::{MemberSymbol, SymbolFactory}; use crate::cube_bridge::cube_definition::CubeDefinition; use crate::cube_bridge::evaluator::CubeEvaluator; use crate::cube_bridge::member_sql::MemberSql; @@ -10,6 +9,7 @@ use lazy_static::lazy_static; use regex::Regex; use std::rc::Rc; +#[derive(Debug)] pub struct CubeNameSymbol { cube_name: String, } @@ -46,13 +46,14 @@ impl CubeNameSymbolFactory { } } -impl SymbolFactory for CubeNameSymbolFactory { - fn build(self, _compiler: &mut Compiler) -> Result, CubeError> { +impl CubeNameSymbolFactory { + pub fn build(self, _compiler: &mut Compiler) -> Result, CubeError> { let Self { cube_name } = self; - Ok(MemberSymbol::new_cube_name(CubeNameSymbol::new(cube_name))) + Ok(CubeNameSymbol::new(cube_name)) } } +#[derive(Debug)] pub struct CubeTableSymbol { cube_name: String, member_sql: Option>, @@ -150,10 +151,8 @@ impl CubeTableSymbolFactory { is_table_sql, }) } -} -impl SymbolFactory for CubeTableSymbolFactory { - fn build(self, compiler: &mut Compiler) -> Result, CubeError> { + pub fn build(self, compiler: &mut Compiler) -> Result, CubeError> { let Self { cube_name, sql, @@ -170,13 +169,13 @@ impl SymbolFactory for CubeTableSymbolFactory { } else { PlanSqlTemplates::alias_name(&cube_name) }; - Ok(MemberSymbol::new_cube_table(CubeTableSymbol::new( + Ok(CubeTableSymbol::new( cube_name, sql, alias, is_table_sql, definition.static_data().join_map.clone(), - ))) + )) } } diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/dimension_kinds/case_dimension.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/dimension_kinds/case_dimension.rs index cbbbab3df9f6f..d903bd2a1795d 100644 --- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/dimension_kinds/case_dimension.rs +++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/dimension_kinds/case_dimension.rs @@ -1,7 +1,7 @@ use super::super::common::{Case, DimensionType}; use super::super::MemberSymbol; use crate::planner::query_tools::QueryTools; -use crate::planner::sql_evaluator::{sql_nodes::SqlNode, SqlCall, SqlEvaluatorVisitor}; +use crate::planner::sql_evaluator::{sql_nodes::SqlNode, CubeRef, SqlCall, SqlEvaluatorVisitor}; use crate::planner::sql_templates::PlanSqlTemplates; use cubenativeutils::CubeError; use std::rc::Rc; @@ -98,6 +98,15 @@ impl CaseDimension { Box::new(self.member_sql.iter().chain(self.case.iter_sql_calls())) } + pub fn get_cube_refs(&self) -> Vec { + let mut refs = vec![]; + if let Some(member_sql) = &self.member_sql { + member_sql.extract_cube_refs(&mut refs); + } + self.case.extract_cube_refs(&mut refs); + refs + } + pub fn is_owned_by_cube(&self) -> bool { let mut owned = false; if let Some(sql) = &self.member_sql { diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/dimension_kinds/geo.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/dimension_kinds/geo.rs index 4122699e6ab2b..30096c1b5ed17 100644 --- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/dimension_kinds/geo.rs +++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/dimension_kinds/geo.rs @@ -1,5 +1,5 @@ use super::super::MemberSymbol; -use crate::planner::sql_evaluator::SqlCall; +use crate::planner::sql_evaluator::{CubeRef, SqlCall}; use cubenativeutils::CubeError; use std::rc::Rc; @@ -53,6 +53,13 @@ impl GeoDimension { Box::new(std::iter::once(&self.latitude).chain(std::iter::once(&self.longitude))) } + pub fn get_cube_refs(&self) -> Vec { + let mut refs = vec![]; + self.latitude.extract_cube_refs(&mut refs); + self.longitude.extract_cube_refs(&mut refs); + refs + } + pub fn is_owned_by_cube(&self) -> bool { self.latitude.is_owned_by_cube() || self.longitude.is_owned_by_cube() } diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/dimension_kinds/mod.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/dimension_kinds/mod.rs index 9d7c7c4a47063..0e7e8040ecccd 100644 --- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/dimension_kinds/mod.rs +++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/dimension_kinds/mod.rs @@ -11,7 +11,7 @@ pub use switch::*; use super::common::DimensionType; use super::MemberSymbol; use crate::planner::query_tools::QueryTools; -use crate::planner::sql_evaluator::{sql_nodes::SqlNode, SqlCall, SqlEvaluatorVisitor}; +use crate::planner::sql_evaluator::{sql_nodes::SqlNode, CubeRef, SqlCall, SqlEvaluatorVisitor}; use crate::planner::sql_templates::PlanSqlTemplates; use cubenativeutils::CubeError; use std::rc::Rc; @@ -88,6 +88,15 @@ impl DimensionKind { } } + pub fn get_cube_refs(&self) -> Vec { + match self { + Self::Regular(r) => r.get_cube_refs(), + Self::Geo(g) => g.get_cube_refs(), + Self::Switch(s) => s.get_cube_refs(), + Self::Case(c) => c.get_cube_refs(), + } + } + pub fn is_owned_by_cube(&self) -> bool { match self { Self::Regular(r) => r.is_owned_by_cube(), diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/dimension_kinds/regular.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/dimension_kinds/regular.rs index 7eb393b13e692..edcf8a549c088 100644 --- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/dimension_kinds/regular.rs +++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/dimension_kinds/regular.rs @@ -1,7 +1,7 @@ use super::super::common::DimensionType; use super::super::MemberSymbol; use crate::planner::query_tools::QueryTools; -use crate::planner::sql_evaluator::{sql_nodes::SqlNode, SqlCall, SqlEvaluatorVisitor}; +use crate::planner::sql_evaluator::{sql_nodes::SqlNode, CubeRef, SqlCall, SqlEvaluatorVisitor}; use crate::planner::sql_templates::PlanSqlTemplates; use cubenativeutils::CubeError; use std::rc::Rc; @@ -51,6 +51,10 @@ impl RegularDimension { deps } + pub fn get_cube_refs(&self) -> Vec { + self.member_sql.get_cube_refs() + } + pub fn apply_to_deps) -> Result, CubeError>>( &self, f: &F, diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/dimension_kinds/switch.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/dimension_kinds/switch.rs index a4a101fc12b19..917e0e0c7b124 100644 --- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/dimension_kinds/switch.rs +++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/dimension_kinds/switch.rs @@ -1,6 +1,6 @@ use super::super::MemberSymbol; use crate::planner::query_tools::QueryTools; -use crate::planner::sql_evaluator::{sql_nodes::SqlNode, SqlCall, SqlEvaluatorVisitor}; +use crate::planner::sql_evaluator::{sql_nodes::SqlNode, CubeRef, SqlCall, SqlEvaluatorVisitor}; use crate::planner::sql_templates::PlanSqlTemplates; use cubenativeutils::CubeError; use std::rc::Rc; @@ -78,6 +78,14 @@ impl SwitchDimension { Box::new(self.member_sql.iter()) } + pub fn get_cube_refs(&self) -> Vec { + let mut refs = vec![]; + if let Some(member_sql) = &self.member_sql { + member_sql.extract_cube_refs(&mut refs); + } + refs + } + pub fn is_owned_by_cube(&self) -> bool { false } diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/dimension_symbol.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/dimension_symbol.rs index bce97f970cbf3..2444bd9137cef 100644 --- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/dimension_symbol.rs +++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/dimension_symbol.rs @@ -8,7 +8,9 @@ use crate::cube_bridge::dimension_definition::DimensionDefinition; use crate::cube_bridge::evaluator::CubeEvaluator; use crate::cube_bridge::member_sql::MemberSql; use crate::planner::query_tools::QueryTools; -use crate::planner::sql_evaluator::{sql_nodes::SqlNode, Compiler, SqlCall, SqlEvaluatorVisitor}; +use crate::planner::sql_evaluator::{ + sql_nodes::SqlNode, Compiler, CubeRef, SqlCall, SqlEvaluatorVisitor, +}; use crate::planner::sql_evaluator::{CubeTableSymbol, TimeDimensionSymbol}; use crate::planner::sql_templates::PlanSqlTemplates; use crate::planner::GranularityHelper; @@ -229,6 +231,10 @@ impl DimensionSymbol { self.kind.get_dependencies_with_path() } + pub fn get_cube_refs(&self) -> Vec { + self.kind.get_cube_refs() + } + pub fn cube_name(&self) -> &String { self.cube.cube_name() } @@ -462,9 +468,7 @@ impl SymbolFactory for DimensionSymbolFactory { .propagate_filters_to_sub_query .unwrap_or(false); - let cube_symbol = compiler - .add_cube_table_evaluator(path.cube_name().clone())? - .as_cube_table()?; + let cube_symbol = compiler.add_cube_table_evaluator(path.cube_name().clone())?; let symbol = MemberSymbol::new_dimension(DimensionSymbol::new( cube_symbol, diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/measure_kinds/aggregated.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/measure_kinds/aggregated.rs index fc4b9dd914242..b04208e28a6ca 100644 --- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/measure_kinds/aggregated.rs +++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/measure_kinds/aggregated.rs @@ -1,7 +1,7 @@ use super::super::super::MemberSymbol; use super::super::common::AggregationType; use crate::planner::query_tools::QueryTools; -use crate::planner::sql_evaluator::{sql_nodes::SqlNode, SqlCall, SqlEvaluatorVisitor}; +use crate::planner::sql_evaluator::{sql_nodes::SqlNode, CubeRef, SqlCall, SqlEvaluatorVisitor}; use crate::planner::sql_templates::PlanSqlTemplates; use cubenativeutils::CubeError; use std::rc::Rc; @@ -84,6 +84,14 @@ impl AggregatedMeasure { Box::new(self.member_sql.iter()) } + pub fn get_cube_refs(&self) -> Vec { + let mut refs = vec![]; + if let Some(sql) = &self.member_sql { + sql.extract_cube_refs(&mut refs); + } + refs + } + pub fn is_owned_by_cube(&self) -> bool { self.member_sql .as_ref() diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/measure_kinds/calculated.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/measure_kinds/calculated.rs index 2db26075aff48..d5909956f85ef 100644 --- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/measure_kinds/calculated.rs +++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/measure_kinds/calculated.rs @@ -1,6 +1,6 @@ use super::super::super::MemberSymbol; use crate::planner::query_tools::QueryTools; -use crate::planner::sql_evaluator::{sql_nodes::SqlNode, SqlCall, SqlEvaluatorVisitor}; +use crate::planner::sql_evaluator::{sql_nodes::SqlNode, CubeRef, SqlCall, SqlEvaluatorVisitor}; use crate::planner::sql_templates::PlanSqlTemplates; use cubenativeutils::CubeError; use std::rc::Rc; @@ -112,6 +112,14 @@ impl CalculatedMeasure { Box::new(self.member_sql.iter()) } + pub fn get_cube_refs(&self) -> Vec { + let mut refs = vec![]; + if let Some(sql) = &self.member_sql { + sql.extract_cube_refs(&mut refs); + } + refs + } + pub fn is_owned_by_cube(&self) -> bool { self.member_sql .as_ref() diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/measure_kinds/count.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/measure_kinds/count.rs index 85052222b57cf..d49bfb849ed3f 100644 --- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/measure_kinds/count.rs +++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/measure_kinds/count.rs @@ -1,6 +1,6 @@ use super::super::MemberSymbol; use crate::planner::query_tools::QueryTools; -use crate::planner::sql_evaluator::{sql_nodes::SqlNode, SqlCall, SqlEvaluatorVisitor}; +use crate::planner::sql_evaluator::{sql_nodes::SqlNode, CubeRef, SqlCall, SqlEvaluatorVisitor}; use crate::planner::sql_templates::PlanSqlTemplates; use cubenativeutils::CubeError; use std::rc::Rc; @@ -109,6 +109,19 @@ impl CountMeasure { } } + pub fn get_cube_refs(&self) -> Vec { + let mut refs = vec![]; + match &self.sql { + CountSql::Explicit(sql) => sql.extract_cube_refs(&mut refs), + CountSql::Auto(pk_sqls) => { + for pk in pk_sqls { + pk.extract_cube_refs(&mut refs); + } + } + } + refs + } + pub fn is_owned_by_cube(&self) -> bool { matches!(self.sql, CountSql::Auto(_)) } diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/measure_kinds/mod.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/measure_kinds/mod.rs index 91903b045313c..7c75d4580194f 100644 --- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/measure_kinds/mod.rs +++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/measure_kinds/mod.rs @@ -9,7 +9,7 @@ pub use count::*; use super::common::AggregationType; use super::MemberSymbol; use crate::planner::query_tools::QueryTools; -use crate::planner::sql_evaluator::{sql_nodes::SqlNode, SqlCall, SqlEvaluatorVisitor}; +use crate::planner::sql_evaluator::{sql_nodes::SqlNode, CubeRef, SqlCall, SqlEvaluatorVisitor}; use crate::planner::sql_templates::PlanSqlTemplates; use cubenativeutils::CubeError; use std::rc::Rc; @@ -120,6 +120,15 @@ impl MeasureKind { } } + pub fn get_cube_refs(&self) -> Vec { + match self { + Self::Count(c) => c.get_cube_refs(), + Self::Aggregated(a) => a.get_cube_refs(), + Self::Calculated(c) => c.get_cube_refs(), + Self::Rank => vec![], + } + } + pub fn is_owned_by_cube(&self) -> bool { match self { Self::Count(c) => c.is_owned_by_cube(), diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/measure_symbol.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/measure_symbol.rs index 7010d4b6bb0da..444299b749d7c 100644 --- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/measure_symbol.rs +++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/measure_symbol.rs @@ -8,7 +8,9 @@ use crate::cube_bridge::member_sql::MemberSql; use crate::planner::query_tools::QueryTools; use crate::planner::sql_evaluator::collectors::find_owned_by_cube_child; use crate::planner::sql_evaluator::CubeTableSymbol; -use crate::planner::sql_evaluator::{sql_nodes::SqlNode, Compiler, SqlCall, SqlEvaluatorVisitor}; +use crate::planner::sql_evaluator::{ + sql_nodes::SqlNode, Compiler, CubeRef, SqlCall, SqlEvaluatorVisitor, +}; use crate::planner::sql_templates::PlanSqlTemplates; use crate::planner::SqlInterval; use cubenativeutils::CubeError; @@ -327,6 +329,23 @@ impl MeasureSymbol { deps } + pub fn get_cube_refs(&self) -> Vec { + let mut refs = self.kind.get_cube_refs(); + for filter in self.measure_filters.iter() { + filter.extract_cube_refs(&mut refs); + } + for filter in self.measure_drill_filters.iter() { + filter.extract_cube_refs(&mut refs); + } + for order in self.measure_order_by.iter() { + order.sql_call().extract_cube_refs(&mut refs); + } + if let Some(case) = &self.case { + case.extract_cube_refs(&mut refs); + } + refs + } + pub fn get_dependencies_with_path(&self) -> Vec<(Rc, Vec)> { let mut deps = self.kind.get_dependencies_with_path(); for filter in self.measure_filters.iter() { @@ -709,9 +728,7 @@ impl SymbolFactory for MeasureSymbolFactory { && add_group_by.is_none() && group_by.is_none()); - let cube_symbol = compiler - .add_cube_table_evaluator(path.cube_name().clone())? - .as_cube_table()?; + let cube_symbol = compiler.add_cube_table_evaluator(path.cube_name().clone())?; Ok(MemberSymbol::new_measure(MeasureSymbol::new( cube_symbol, diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/member_expression_symbol.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/member_expression_symbol.rs index 2c08ce4a319c8..fbe71cf49b536 100644 --- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/member_expression_symbol.rs +++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/member_expression_symbol.rs @@ -2,7 +2,7 @@ use super::MemberSymbol; use crate::cube_bridge::base_tools::BaseTools; use crate::planner::query_tools::QueryTools; use crate::planner::sql_evaluator::collectors::member_childs; -use crate::planner::sql_evaluator::{sql_nodes::SqlNode, SqlCall, SqlEvaluatorVisitor}; +use crate::planner::sql_evaluator::{sql_nodes::SqlNode, CubeRef, SqlCall, SqlEvaluatorVisitor}; use crate::planner::sql_templates::PlanSqlTemplates; use crate::utils::debug::DebugSql; use cubenativeutils::CubeError; @@ -146,6 +146,15 @@ impl MemberExpressionSymbol { deps } + pub fn get_cube_refs(&self) -> Vec { + let mut refs = vec![]; + match &self.expression { + MemberExpressionExpression::SqlCall(sql_call) => sql_call.extract_cube_refs(&mut refs), + MemberExpressionExpression::PatchedSymbol(_) => {} + } + refs + } + pub fn cube_names_if_dimension_only_expression( self: Rc, ) -> Result>, CubeError> { diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/member_symbol.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/member_symbol.rs index f464b246fec80..ddb7887d79e35 100644 --- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/member_symbol.rs +++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/member_symbol.rs @@ -2,12 +2,9 @@ use cubenativeutils::CubeError; use itertools::Itertools; use crate::planner::sql_evaluator::collectors::has_multi_stage_members; -use crate::planner::sql_evaluator::{Case, SqlCall}; +use crate::planner::sql_evaluator::{Case, CubeRef, SqlCall}; -use super::{ - CubeNameSymbol, CubeTableSymbol, DimensionSymbol, MeasureSymbol, MemberExpressionSymbol, - TimeDimensionSymbol, -}; +use super::{DimensionSymbol, MeasureSymbol, MemberExpressionSymbol, TimeDimensionSymbol}; use std::fmt::Debug; use std::rc::Rc; @@ -15,8 +12,6 @@ pub enum MemberSymbol { Dimension(Rc), TimeDimension(Rc), Measure(Rc), - CubeName(Rc), - CubeTable(Rc), MemberExpression(Rc), } @@ -29,8 +24,6 @@ impl Debug for MemberSymbol { .field(&self.full_name()) .finish(), Self::Measure(_) => f.debug_tuple("Measure").field(&self.full_name()).finish(), - Self::CubeName(_) => f.debug_tuple("CubeName").field(&self.full_name()).finish(), - Self::CubeTable(_) => f.debug_tuple("CubeTable").field(&self.full_name()).finish(), Self::MemberExpression(_) => f .debug_tuple("MemberExpression") .field(&self.full_name()) @@ -45,8 +38,6 @@ impl PartialEq for MemberSymbol { (Self::Dimension(l0), Self::Dimension(r0)) => l0.full_name() == r0.full_name(), (Self::TimeDimension(l0), Self::TimeDimension(r0)) => l0.full_name() == r0.full_name(), (Self::Measure(l0), Self::Measure(r0)) => l0.full_name() == r0.full_name(), - (Self::CubeName(l0), Self::CubeName(r0)) => l0.cube_name() == r0.cube_name(), - (Self::CubeTable(l0), Self::CubeTable(r0)) => l0.cube_name() == r0.cube_name(), (Self::MemberExpression(l0), Self::MemberExpression(r0)) => { l0.full_name() == r0.full_name() } @@ -64,14 +55,6 @@ impl MemberSymbol { Rc::new(Self::Dimension(symbol)) } - pub fn new_cube_name(symbol: Rc) -> Rc { - Rc::new(Self::CubeName(symbol)) - } - - pub fn new_cube_table(symbol: Rc) -> Rc { - Rc::new(Self::CubeTable(symbol)) - } - pub fn new_member_expression(symbol: Rc) -> Rc { Rc::new(Self::MemberExpression(symbol)) } @@ -85,8 +68,6 @@ impl MemberSymbol { Self::Dimension(d) => d.full_name(), Self::TimeDimension(d) => d.full_name(), Self::Measure(m) => m.full_name(), - Self::CubeName(c) => c.cube_name().clone(), - Self::CubeTable(c) => c.cube_name().clone(), Self::MemberExpression(e) => e.full_name().clone(), } } @@ -96,8 +77,6 @@ impl MemberSymbol { Self::Dimension(d) => d.alias(), Self::TimeDimension(d) => d.alias(), Self::Measure(m) => m.alias(), - Self::CubeName(c) => c.alias(), - Self::CubeTable(c) => c.alias(), Self::MemberExpression(e) => e.alias(), } } @@ -107,8 +86,6 @@ impl MemberSymbol { Self::Dimension(d) => d.name().clone(), Self::TimeDimension(d) => d.name(), Self::Measure(m) => m.name().clone(), - Self::CubeName(c) => c.cube_name().clone(), - Self::CubeTable(c) => c.cube_name().clone(), Self::MemberExpression(e) => e.name().clone(), } } @@ -118,8 +95,6 @@ impl MemberSymbol { Self::Dimension(d) => d.cube_name().clone(), Self::TimeDimension(d) => d.cube_name(), Self::Measure(m) => m.cube_name().clone(), - Self::CubeName(c) => c.cube_name().clone(), - Self::CubeTable(c) => c.cube_name().clone(), Self::MemberExpression(e) => e.cube_name().clone(), } } @@ -152,10 +127,6 @@ impl MemberSymbol { matches!(self, Self::Dimension(_) | Self::TimeDimension(_)) } - pub fn is_cube(&self) -> bool { - matches!(self, Self::CubeName(_) | Self::CubeTable(_)) - } - pub fn apply_recursive) -> Result, CubeError>>( self: &Rc, f: &F, @@ -172,8 +143,6 @@ impl MemberSymbol { Self::Dimension(d) => d.apply_to_deps(f), Self::TimeDimension(d) => d.apply_to_deps(f), Self::Measure(m) => m.apply_to_deps(f), - Self::CubeName(_) => Ok(self.clone()), - Self::CubeTable(_) => Ok(self.clone()), Self::MemberExpression(e) => e.apply_to_deps(f), } } @@ -183,8 +152,6 @@ impl MemberSymbol { Self::Dimension(d) => d.get_dependencies(), Self::TimeDimension(d) => d.get_dependencies(), Self::Measure(m) => m.get_dependencies(), - Self::CubeName(_) => vec![], - Self::CubeTable(_) => vec![], Self::MemberExpression(e) => e.get_dependencies(), } } @@ -194,19 +161,24 @@ impl MemberSymbol { Self::Dimension(d) => d.get_dependencies_with_path(), Self::TimeDimension(d) => d.get_dependencies_with_path(), Self::Measure(m) => m.get_dependencies_with_path(), - Self::CubeName(_) => vec![], - Self::CubeTable(_) => vec![], Self::MemberExpression(e) => e.get_dependencies_with_path(), } } + pub fn get_cube_refs(&self) -> Vec { + match self { + Self::Dimension(d) => d.get_cube_refs(), + Self::TimeDimension(d) => d.get_cube_refs(), + Self::Measure(m) => m.get_cube_refs(), + Self::MemberExpression(e) => e.get_cube_refs(), + } + } + pub fn is_reference(&self) -> bool { match self { Self::Dimension(d) => d.is_reference(), Self::TimeDimension(d) => d.is_reference(), Self::Measure(m) => m.is_reference(), - Self::CubeName(_) => false, - Self::CubeTable(_) => false, Self::MemberExpression(e) => e.is_reference(), } } @@ -216,8 +188,6 @@ impl MemberSymbol { Self::Dimension(d) => d.reference_member(), Self::TimeDimension(d) => d.reference_member(), Self::Measure(m) => m.reference_member(), - Self::CubeName(_) => None, - Self::CubeTable(_) => None, Self::MemberExpression(e) => e.reference_member(), } } @@ -250,8 +220,6 @@ impl MemberSymbol { Self::Dimension(d) => d.owned_by_cube(), Self::TimeDimension(d) => d.owned_by_cube(), Self::Measure(m) => m.owned_by_cube(), - Self::CubeName(_) => true, - Self::CubeTable(_) => true, Self::MemberExpression(_) => false, } } @@ -286,26 +254,6 @@ impl MemberSymbol { } } - pub fn as_cube_table(&self) -> Result, CubeError> { - match self { - Self::CubeTable(c) => Ok(c.clone()), - _ => Err(CubeError::internal(format!( - "{} is not a cube table", - self.full_name() - ))), - } - } - - pub fn as_cube_name(&self) -> Result, CubeError> { - match self { - Self::CubeName(c) => Ok(c.clone()), - _ => Err(CubeError::internal(format!( - "{} is not a cube name", - self.full_name() - ))), - } - } - pub fn as_member_expression(&self) -> Result, CubeError> { match self { Self::MemberExpression(m) => Ok(m.clone()), @@ -401,8 +349,6 @@ impl crate::utils::debug::DebugSql for MemberSymbol { MemberSymbol::Dimension(d) => d.debug_sql(expand_deps), MemberSymbol::Measure(m) => m.debug_sql(expand_deps), MemberSymbol::TimeDimension(t) => t.debug_sql(expand_deps), - MemberSymbol::CubeName(c) => c.debug_sql(expand_deps), - MemberSymbol::CubeTable(c) => c.debug_sql(expand_deps), MemberSymbol::MemberExpression(e) => e.debug_sql(expand_deps), } } diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/time_dimension_symbol.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/time_dimension_symbol.rs index 2e9347065a8ab..b449fe1e473e2 100644 --- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/time_dimension_symbol.rs +++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/time_dimension_symbol.rs @@ -1,5 +1,6 @@ use super::MemberSymbol; use crate::planner::query_tools::QueryTools; +use crate::planner::sql_evaluator::CubeRef; use crate::planner::time_dimension::Granularity; use crate::planner::{GranularityHelper, QueryDateTime, QueryDateTimeHelper}; use chrono::Duration; @@ -171,6 +172,17 @@ impl TimeDimensionSymbol { deps } + pub fn get_cube_refs(&self) -> Vec { + let mut refs = vec![]; + if let Some(granularity_obj) = &self.granularity_obj { + if let Some(calendar_sql) = granularity_obj.calendar_sql() { + calendar_sql.extract_cube_refs(&mut refs); + } + } + refs.append(&mut self.base_symbol.get_cube_refs()); + refs + } + pub fn cube_name(&self) -> String { self.base_symbol.cube_name() } diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/visitor.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/visitor.rs index 7f4a43980b636..df1c324c37c4f 100644 --- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/visitor.rs +++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/visitor.rs @@ -1,4 +1,4 @@ -use super::MemberSymbol; +use super::{CubeRef, MemberSymbol}; use cubenativeutils::CubeError; use std::rc::Rc; @@ -11,6 +11,10 @@ pub trait TraversalVisitor { state: &Self::State, ) -> Result, CubeError>; + fn on_cube_ref(&mut self, _cube_ref: &CubeRef, _state: &Self::State) -> Result<(), CubeError> { + Ok(()) + } + fn apply(&mut self, node: &Rc, state: &Self::State) -> Result<(), CubeError> { self.apply_with_path(node, &vec![], state) } @@ -25,6 +29,9 @@ pub trait TraversalVisitor { for (dep, dep_path) in node.get_dependencies_with_path() { self.apply_with_path(&dep, &dep_path, &state)? } + for cube_ref in node.get_cube_refs() { + self.on_cube_ref(&cube_ref, &state)?; + } } Ok(()) } diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/visitor_context.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/visitor_context.rs index 4edc93b0960d5..ce61b26692ad8 100644 --- a/rust/cubesqlplanner/cubesqlplanner/src/planner/visitor_context.rs +++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/visitor_context.rs @@ -1,6 +1,6 @@ use super::query_tools::QueryTools; use super::sql_evaluator::sql_nodes::{SqlNode, SqlNodesFactory}; -use super::sql_evaluator::{MemberSymbol, SqlCall}; +use super::sql_evaluator::{CubeRefEvaluator, MemberSymbol, SqlCall}; use crate::cube_bridge::member_sql::FilterParamsColumn; use crate::plan::Filter; use crate::planner::sql_evaluator::SqlEvaluatorVisitor; @@ -18,6 +18,7 @@ pub struct FiltersContext { pub struct VisitorContext { query_tools: Rc, node_processor: Rc, + cube_ref_evaluator: Rc, all_filters: Option, //To pass to FILTER_PARAMS and FILTER_GROUP filters_context: FiltersContext, } @@ -35,6 +36,7 @@ impl VisitorContext { Self { query_tools, node_processor: nodes_factory.default_node_processor(), + cube_ref_evaluator: Rc::new(nodes_factory.cube_ref_evaluator()), all_filters, filters_context, } @@ -52,13 +54,18 @@ impl VisitorContext { Self { query_tools, node_processor: nodes_factory.default_node_processor(), + cube_ref_evaluator: Rc::new(nodes_factory.cube_ref_evaluator()), all_filters: None, filters_context, } } pub fn make_visitor(&self, query_tools: Rc) -> SqlEvaluatorVisitor { - SqlEvaluatorVisitor::new(query_tools, self.all_filters.clone()) + SqlEvaluatorVisitor::new( + query_tools, + self.cube_ref_evaluator.clone(), + self.all_filters.clone(), + ) } pub fn node_processor(&self) -> Rc { diff --git a/rust/cubesqlplanner/cubesqlplanner/src/test_fixtures/test_utils/test_context.rs b/rust/cubesqlplanner/cubesqlplanner/src/test_fixtures/test_utils/test_context.rs index 763bd66944b73..66e4d36d209e8 100644 --- a/rust/cubesqlplanner/cubesqlplanner/src/test_fixtures/test_utils/test_context.rs +++ b/rust/cubesqlplanner/cubesqlplanner/src/test_fixtures/test_utils/test_context.rs @@ -126,11 +126,13 @@ impl TestContext { } pub fn evaluate_symbol(&self, symbol: &Rc) -> Result { - let visitor = SqlEvaluatorVisitor::new(self.query_tools.clone(), None); + let nodes_factory = SqlNodesFactory::default(); + let cube_ref_evaluator = Rc::new(nodes_factory.cube_ref_evaluator()); + let visitor = SqlEvaluatorVisitor::new(self.query_tools.clone(), cube_ref_evaluator, None); let base_tools = self.query_tools.base_tools(); let driver_tools = base_tools.driver_tools(false)?; let templates = PlanSqlTemplates::try_new(driver_tools, false)?; - let node_processor = SqlNodesFactory::default().default_node_processor(); + let node_processor = nodes_factory.default_node_processor(); visitor.apply(symbol, node_processor, &templates) } diff --git a/rust/cubesqlplanner/cubesqlplanner/src/tests/cube_evaluator/compilation.rs b/rust/cubesqlplanner/cubesqlplanner/src/tests/cube_evaluator/compilation.rs index c57f9f1a09bb6..b0fcc9c61eb1c 100644 --- a/rust/cubesqlplanner/cubesqlplanner/src/tests/cube_evaluator/compilation.rs +++ b/rust/cubesqlplanner/cubesqlplanner/src/tests/cube_evaluator/compilation.rs @@ -280,10 +280,6 @@ fn test_add_cube_table_evaluator() { .add_cube_table_evaluator("visitors".to_string()) .unwrap(); - assert!(symbol.is_cube()); - assert!(!symbol.is_dimension()); - assert!(!symbol.is_measure()); - assert_eq!(symbol.full_name(), "visitors"); assert_eq!(symbol.cube_name(), "visitors"); } @@ -298,10 +294,6 @@ fn test_add_cube_name_evaluator() { .add_cube_name_evaluator("visitors".to_string()) .unwrap(); - assert!(symbol.is_cube()); - assert!(!symbol.is_dimension()); - assert!(!symbol.is_measure()); - assert_eq!(symbol.full_name(), "visitors"); assert_eq!(symbol.cube_name(), "visitors"); } @@ -324,12 +316,11 @@ fn test_dimension_with_cube_table_dependency() { ); let dependencies = symbol.get_dependencies(); - assert_eq!(dependencies.len(), 1, "Should have 1 dependency on CUBE"); + assert_eq!(dependencies.len(), 0, "Should have no member dependencies"); - let dep = &dependencies[0]; - assert!(dep.is_cube(), "Dependency should be a cube symbol"); - assert_eq!(dep.full_name(), "visitors"); - assert_eq!(dep.cube_name(), "visitors"); + let cube_refs = symbol.get_cube_refs(); + assert_eq!(cube_refs.len(), 1, "Should have 1 cube ref dependency"); + assert_eq!(cube_refs[0].cube_name(), "visitors"); } #[test] @@ -424,12 +415,11 @@ fn test_measure_with_cube_table_dependency() { )); let dependencies = symbol.get_dependencies(); - assert_eq!(dependencies.len(), 1, "Should have 1 dependency on CUBE"); + assert_eq!(dependencies.len(), 0, "Should have no member dependencies"); - let dep = &dependencies[0]; - assert!(dep.is_cube(), "Dependency should be a cube symbol"); - assert_eq!(dep.full_name(), "visitors"); - assert_eq!(dep.cube_name(), "visitors"); + let cube_refs = symbol.get_cube_refs(); + assert_eq!(cube_refs.len(), 1, "Should have 1 cube ref dependency"); + assert_eq!(cube_refs[0].cube_name(), "visitors"); } #[test]