update

Author: waralexrom

rust/cubesqlplanner/cubesqlplanner/src/planner/planners/join_planner.rs

@@ -1,7 +1,7 @@
 use super::{CommonUtils, DimensionSubqueryPlanner};
 use crate::cube_bridge::join_definition::JoinDefinition;
 use crate::cube_bridge::join_hints::JoinHintItem;
-use crate::cube_bridge::member_sql::MemberSql;
+use crate::cube_bridge::join_item::JoinItem;
 use crate::plan::{From, JoinBuilder, JoinCondition};
 use crate::planner::query_tools::QueryTools;
 use crate::planner::sql_evaluator::SqlCall;
@@ -49,9 +49,7 @@ impl JoinPlanner {
             );
             dimension_subquery_planner.add_joins_for_cube(&mut join_builder, root.name())?;
             for join in joins.iter() {
-                let definition = join.join()?;
-                let sql_call = self
-                    .compile_join_condition(&join.static_data().original_from, definition.sql()?)?;
+                let sql_call = self.compile_join_condition(join.clone())?;
                 let on = JoinCondition::new_base_join(SqlJoinCondition::try_new(
                     self.query_tools.clone(),
                     sql_call,
@@ -71,13 +69,14 @@ impl JoinPlanner {
         }
     }
 
-    fn compile_join_condition(
+    pub fn compile_join_condition(
         &self,
-        cube_name: &String,
-        sql: Rc<dyn MemberSql>,
+        join_item: Rc<dyn JoinItem>,
     ) -> Result<Rc<SqlCall>, CubeError> {
+        let definition = join_item.join()?;
         let evaluator_compiler_cell = self.query_tools.evaluator_compiler().clone();
         let mut evaluator_compiler = evaluator_compiler_cell.borrow_mut();
-        evaluator_compiler.compile_sql_call(&cube_name, sql)
+        evaluator_compiler
+            .compile_sql_call(&join_item.static_data().original_from, definition.sql()?)
     }
 }

rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multiplied_measures_query_planner.rs

@@ -111,6 +111,8 @@ impl MultipliedMeasuresQueryPlanner {
     ) -> Result<Rc<Select>, CubeError> {
         let subquery_dimensions = collect_sub_query_dimensions_from_members(
             &BaseMemberHelper::iter_as_base_member(measures).collect_vec(),
+            &self.join_planner,
+            &key_join,
             self.query_tools.clone(),
         )?;
 
@@ -312,6 +314,8 @@ impl MultipliedMeasuresQueryPlanner {
     ) -> Result<Rc<Select>, CubeError> {
         let subquery_dimensions = collect_sub_query_dimensions_from_symbols(
             &self.query_properties.all_member_symbols(false),
+            &self.join_planner,
+            &join,
             self.query_tools.clone(),
         )?;
 
@@ -378,6 +382,8 @@ impl MultipliedMeasuresQueryPlanner {
 
         let subquery_dimensions = collect_sub_query_dimensions_from_symbols(
             &symbols_for_subquery_dimensions,
+            &self.join_planner,
+            &key_join,
             self.query_tools.clone(),
         )?;
 

rust/cubesqlplanner/cubesqlplanner/src/planner/planners/simple_query_planer.rs

@@ -30,8 +30,11 @@ impl SimpleQueryPlanner {
     }
 
     pub fn plan(&self) -> Result<Rc<Select>, CubeError> {
+        let join = self.query_properties.simple_query_join()?;
         let subquery_dimensions = collect_sub_query_dimensions_from_symbols(
             &self.query_properties.all_member_symbols(false),
+            &self.join_planner,
+            &join,
             self.query_tools.clone(),
         )?;
         let dimension_subquery_planner = DimensionSubqueryPlanner::try_new(
@@ -49,11 +52,9 @@ impl SimpleQueryPlanner {
             })
         };
         let mut context_factory = self.context_factory.clone();
-        let from = self.join_planner.make_join_node_impl(
-            &None,
-            self.query_properties.simple_query_join()?,
-            &dimension_subquery_planner,
-        )?;
+        let from =
+            self.join_planner
+                .make_join_node_impl(&None, join, &dimension_subquery_planner)?;
         let mut select_builder = SelectBuilder::new(from.clone());
 
         for member in self

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

@@ -1,3 +1,5 @@
+use crate::cube_bridge::join_definition::JoinDefinition;
+use crate::planner::planners::JoinPlanner;
 use crate::planner::query_tools::QueryTools;
 use crate::planner::sql_evaluator::{DimensionSymbol, MemberSymbol, TraversalVisitor};
 use crate::planner::{BaseDimension, BaseMember};
@@ -60,20 +62,30 @@ impl TraversalVisitor for SubQueryDimensionsCollector {
 
 pub fn collect_sub_query_dimensions_from_members(
     members: &Vec<Rc<dyn BaseMember>>,
+    join_planner: &JoinPlanner,
+    join: &Rc<dyn JoinDefinition>,
     query_tools: Rc<QueryTools>,
 ) -> Result<Vec<Rc<BaseDimension>>, CubeError> {
     let symbols = members.iter().map(|m| m.member_evaluator()).collect_vec();
-    collect_sub_query_dimensions_from_symbols(&symbols, query_tools)
+    collect_sub_query_dimensions_from_symbols(&symbols, join_planner, join, query_tools)
 }
 
 pub fn collect_sub_query_dimensions_from_symbols(
     members: &Vec<Rc<MemberSymbol>>,
+    join_planner: &JoinPlanner,
+    join: &Rc<dyn JoinDefinition>,
     query_tools: Rc<QueryTools>,
 ) -> Result<Vec<Rc<BaseDimension>>, CubeError> {
     let mut visitor = SubQueryDimensionsCollector::new();
     for member in members.iter() {
         visitor.apply(&member, &())?;
     }
+    for join_item in join.joins()? {
+        let condition = join_planner.compile_join_condition(join_item.clone())?;
+        for dep in condition.get_dependencies() {
+            visitor.apply(&dep, &())?;
+        }
+    }
     visitor
         .extract_result()
         .into_iter()