in work

Author: waralexrom

rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multi_stage/multi_stage_query_planner.rs

@@ -405,7 +405,7 @@ impl MultiStageQueryPlanner {
 
     fn add_time_series_get_range_query(
         &self,
-        time_dimension: Rc<BaseTimeDimension>,
+        time_dimension: Rc<MemberSymbol>,
         state: Rc<MultiStageAppliedState>,
         descriptions: &mut Vec<Rc<MultiStageQueryDescription>>,
     ) -> Result<Rc<MultiStageQueryDescription>, CubeError> {
@@ -420,7 +420,7 @@ impl MultiStageQueryPlanner {
                     MultiStageMemberType::Leaf(MultiStageLeafMemberType::TimeSeriesGetRange(
                         time_dimension.clone(),
                     )),
-                    time_dimension.member_evaluator(),
+                    time_dimension.clone(),
                     true,
                     false,
                 ),
@@ -436,7 +436,7 @@ impl MultiStageQueryPlanner {
 
     fn add_time_series(
         &self,
-        time_dimension: Rc<BaseTimeDimension>,
+        time_dimension: Rc<MemberSymbol>,
         state: Rc<MultiStageAppliedState>,
         descriptions: &mut Vec<Rc<MultiStageQueryDescription>>,
     ) -> Result<Rc<MultiStageQueryDescription>, CubeError> {
@@ -445,7 +445,11 @@ impl MultiStageQueryPlanner {
         {
             description.clone()
         } else {
-            let get_range_query_description = if time_dimension.get_date_range().is_some() {
+            let get_range_query_description = if time_dimension
+                .as_time_dimension()?
+                .date_range_vec()
+                .is_some()
+            {
                 None
             } else {
                 Some(self.add_time_series_get_range_query(
@@ -462,7 +466,7 @@ impl MultiStageQueryPlanner {
                             date_range_cte: get_range_query_description.map(|d| d.alias().clone()),
                         },
                     ))),
-                    time_dimension.member_evaluator(),
+                    time_dimension.clone(),
                     true,
                     false,
                 ),
@@ -523,11 +527,12 @@ impl MultiStageQueryPlanner {
 
     fn make_rolling_base_state(
         &self,
-        time_dimension: Rc<BaseTimeDimension>,
+        time_dimension: Rc<MemberSymbol>,
         rolling_window: &RollingWindow,
         state: Rc<MultiStageAppliedState>,
-    ) -> Result<(Rc<MultiStageAppliedState>, Rc<BaseTimeDimension>), CubeError> {
-        let time_dimension_base_name = time_dimension.base_dimension().full_name();
+    ) -> Result<(Rc<MultiStageAppliedState>, Rc<MemberSymbol>), CubeError> {
+        let time_dimension_symbol = time_dimension.as_time_dimension()?;
+        let time_dimension_base_name = time_dimension_symbol.base_symbol().full_name();
         let mut new_state = state.clone_state();
         let trailing_granularity =
             GranularityHelper::granularity_from_interval(&rolling_window.trailing);
@@ -537,10 +542,12 @@ impl MultiStageQueryPlanner {
             GranularityHelper::min_granularity(&trailing_granularity, &leading_granularity)?;
         let result_granularity = GranularityHelper::min_granularity(
             &window_granularity,
-            &time_dimension.resolved_granularity()?,
+            &time_dimension_symbol.resolved_granularity()?,
         )?;
 
-        let new_time_dimension = time_dimension.change_granularity(result_granularity.clone())?;
+        let new_time_dimension_symbol = time_dimension_symbol
+            .change_granularity(self.query_tools.clone(), result_granularity.clone())?;
+        let new_time_dimension = MemberSymbol::new_time_dimension(new_time_dimension_symbol);
         //We keep only one time_dimension in the leaf query because, even if time_dimension values have different granularity, in the leaf query we need to group by the lowest granularity.
         new_state.set_time_dimensions(vec![new_time_dimension.clone()]);
 
@@ -549,7 +556,7 @@ impl MultiStageQueryPlanner {
             .clone()
             .into_iter()
             .filter(|d| {
-                d.member_evaluator()
+                d.clone()
                     .resolve_reference_chain()
                     .as_time_dimension()
                     .is_err()

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

@@ -6,6 +6,7 @@ use crate::planner::sql_evaluator::collectors::{
     collect_cube_names, collect_join_hints, collect_join_hints_for_measures,
     collect_sub_query_dimensions_from_members, collect_sub_query_dimensions_from_symbols,
 };
+use crate::planner::sql_evaluator::MemberSymbol;
 use crate::planner::{
     BaseMeasure, BaseMember, BaseMemberHelper, FullKeyAggregateMeasures, QueryProperties,
 };
@@ -101,7 +102,7 @@ impl MultipliedMeasuresQueryPlanner {
                         .iter()
                         .map(|m| m.measure()),
                 )
-                .map(|m| m.member_evaluator().clone())
+                .map(|m| m.clone())
                 .collect_vec();
             let schema = LogicalSchema::default()
                 .set_time_dimensions(self.query_properties.time_dimension_symbols())
@@ -132,15 +133,11 @@ impl MultipliedMeasuresQueryPlanner {
     fn aggregate_subquery_plan(
         &self,
         key_cube_name: &String,
-        measures: &Vec<Rc<BaseMeasure>>,
+        measures: &Vec<Rc<MemberSymbol>>,
         key_join: Rc<dyn JoinDefinition>,
     ) -> Result<Rc<AggregateMultipliedSubquery>, CubeError> {
-        let measures_symbols = measures
-            .iter()
-            .map(|m| m.member_evaluator().clone())
-            .collect();
         let subquery_dimensions = collect_sub_query_dimensions_from_symbols(
-            &measures_symbols,
+            &measures,
             &self.join_planner,
             &key_join,
             self.query_tools.clone(),
@@ -154,19 +151,14 @@ impl MultipliedMeasuresQueryPlanner {
         let subquery_dimension_queries =
             dimension_subquery_planner.plan_queries(&subquery_dimensions)?;
 
-        let primary_keys_dimensions = self
-            .common_utils
-            .primary_keys_dimensions(key_cube_name)?
-            .into_iter()
-            .map(|d| d.as_base_member())
-            .collect_vec();
+        let primary_keys_dimensions = self.common_utils.primary_keys_dimensions(key_cube_name)?;
         let keys_subquery =
             self.key_query(&primary_keys_dimensions, key_join.clone(), key_cube_name)?;
 
         let schema = LogicalSchema::default()
             .set_dimensions(self.query_properties.dimension_symbols())
             .set_time_dimensions(self.query_properties.time_dimension_symbols())
-            .set_measures(measures_symbols)
+            .set_measures(measures.clone())
             .set_multiplied_measures(
                 self.full_key_aggregate_measures
                     .rendered_as_multiplied_measures
@@ -200,22 +192,22 @@ impl MultipliedMeasuresQueryPlanner {
 
     fn check_should_build_join_for_measure_select(
         &self,
-        measures: &Vec<Rc<BaseMeasure>>,
+        measures: &Vec<Rc<MemberSymbol>>,
         key_cube_name: &String,
     ) -> Result<bool, CubeError> {
         for measure in measures.iter() {
             let member_expression_over_dimensions_cubes =
-                if let Ok(member_expression) = measure.member_evaluator().as_member_expression() {
+                if let Ok(member_expression) = measure.as_member_expression() {
                     member_expression.cube_names_if_dimension_only_expression()?
                 } else {
                     None
                 };
             let cubes = if let Some(cubes) = member_expression_over_dimensions_cubes {
                 cubes
             } else {
-                collect_cube_names(measure.member_evaluator())?
+                collect_cube_names(&measure)?
             };
-            let join_hints = collect_join_hints(measure.member_evaluator())?;
+            let join_hints = collect_join_hints(&measure)?;
             if cubes.iter().any(|cube| cube != key_cube_name) {
                 let measures_join = self.query_tools.join_graph().build_join(join_hints)?;
                 if *measures_join
@@ -235,11 +227,11 @@ impl MultipliedMeasuresQueryPlanner {
     fn aggregate_subquery_measure(
         &self,
         key_join: Rc<dyn JoinDefinition>,
-        measures: &Vec<Rc<BaseMeasure>>,
-        primary_keys_dimensions: &Vec<Rc<dyn BaseMember>>,
+        measures: &Vec<Rc<MemberSymbol>>,
+        primary_keys_dimensions: &Vec<Rc<MemberSymbol>>,
     ) -> Result<Rc<MeasureSubquery>, CubeError> {
         let subquery_dimensions = collect_sub_query_dimensions_from_members(
-            &BaseMemberHelper::iter_as_base_member(measures).collect_vec(),
+            &measures,
             &self.join_planner,
             &key_join,
             self.query_tools.clone(),
@@ -251,24 +243,14 @@ impl MultipliedMeasuresQueryPlanner {
         )?;
         let subquery_dimension_queries =
             dimension_subquery_planner.plan_queries(&subquery_dimensions)?;
-        let join_hints = collect_join_hints_for_measures(measures)?;
+        let join_hints = collect_join_hints_for_measures(&measures)?;
         let source = self
             .join_planner
             .make_join_logical_plan_with_join_hints(join_hints, subquery_dimension_queries)?;
 
         let schema = LogicalSchema::default()
-            .set_dimensions(
-                primary_keys_dimensions
-                    .iter()
-                    .map(|dim| dim.member_evaluator().clone())
-                    .collect(),
-            )
-            .set_measures(
-                measures
-                    .iter()
-                    .map(|meas| meas.member_evaluator().clone())
-                    .collect(),
-            )
+            .set_dimensions(primary_keys_dimensions.clone())
+            .set_measures(measures.clone())
             .into_rc();
 
         let result = MeasureSubquery { schema, source };
@@ -277,16 +259,12 @@ impl MultipliedMeasuresQueryPlanner {
 
     fn regular_measures_subquery(
         &self,
-        measures: &Vec<Rc<BaseMeasure>>,
+        measures: &Vec<Rc<MemberSymbol>>,
         join: Rc<dyn JoinDefinition>,
     ) -> Result<Rc<Query>, CubeError> {
-        let measures_symbols = measures
-            .iter()
-            .map(|m| m.member_evaluator().clone())
-            .collect();
-        let all_symbols =
-            self.query_properties
-                .get_member_symbols(true, true, false, true, &measures_symbols);
+        let all_symbols = self
+            .query_properties
+            .get_member_symbols(true, true, false, true, &measures);
 
         let subquery_dimensions = collect_sub_query_dimensions_from_symbols(
             &all_symbols,
@@ -310,7 +288,7 @@ impl MultipliedMeasuresQueryPlanner {
         let schema = LogicalSchema::default()
             .set_dimensions(self.query_properties.dimension_symbols())
             .set_time_dimensions(self.query_properties.time_dimension_symbols())
-            .set_measures(measures_symbols)
+            .set_measures(measures.clone())
             .set_multiplied_measures(
                 self.full_key_aggregate_measures
                     .rendered_as_multiplied_measures
@@ -342,18 +320,13 @@ impl MultipliedMeasuresQueryPlanner {
 
     fn key_query(
         &self,
-        dimensions: &Vec<Rc<dyn BaseMember>>,
+        dimensions: &Vec<Rc<MemberSymbol>>,
         key_join: Rc<dyn JoinDefinition>,
         key_cube_name: &String,
     ) -> Result<Rc<KeysSubQuery>, CubeError> {
-        let dimensions_symbols = dimensions
-            .iter()
-            .map(|d| d.member_evaluator().clone())
-            .collect();
-
         let all_symbols =
             self.query_properties
-                .get_member_symbols(true, true, false, true, &dimensions_symbols);
+                .get_member_symbols(true, true, false, true, &dimensions);
 
         let subquery_dimensions = collect_sub_query_dimensions_from_symbols(
             &all_symbols,
@@ -388,7 +361,7 @@ impl MultipliedMeasuresQueryPlanner {
 
         let keys_query = KeysSubQuery {
             schema,
-            primary_keys_dimensions: dimensions_symbols,
+            primary_keys_dimensions: dimensions.clone(),
             filter: logical_filter,
             source,
             //dimension_subqueries: subquery_dimension_queries,

rust/cubesqlplanner/cubesqlplanner/src/planner/query_properties.rs

@@ -168,7 +168,7 @@ impl QueryProperties {
         {
             time_dimensions
                 .iter()
-                .map(|d| {
+                .map(|d| -> Result<Rc<MemberSymbol>, CubeError> {
                     let base_symbol =
                         evaluator_compiler.add_dimension_evaluator(d.dimension.clone())?;
                     let granularity_obj = GranularityHelper::make_granularity_obj(
@@ -494,8 +494,8 @@ impl QueryProperties {
 
     pub fn compute_join_multi_fact_groups_with_measures(
         &self,
-        measures: &Vec<Rc<BaseMeasure>>,
-    ) -> Result<Vec<(Rc<dyn JoinDefinition>, Vec<Rc<BaseMeasure>>)>, CubeError> {
+        measures: &Vec<Rc<MemberSymbol>>,
+    ) -> Result<Vec<(Rc<dyn JoinDefinition>, Vec<Rc<MemberSymbol>>)>, CubeError> {
         Self::compute_join_multi_fact_groups(
             self.query_join_hints.clone(),
             self.query_tools.clone(),
@@ -825,7 +825,12 @@ impl QueryProperties {
                             .rendered_as_multiplied_measures
                             .insert(item.measure.full_name());
                     }
-                    if item.multiplied && !item.measure.can_be_used_as_additive_in_multplied() {
+                    if item.multiplied
+                        && !item
+                            .measure
+                            .as_measure()?
+                            .can_used_as_addictive_in_multplied()
+                    {
                         result
                             .multiplied_measures
                             .push(MultipliedMeasure::new(item.measure.clone(), item.cube_name));

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

@@ -84,11 +84,11 @@ pub fn collect_join_hints(node: &Rc<MemberSymbol>) -> Result<Vec<JoinHintItem>,
 }
 
 pub fn collect_join_hints_for_measures(
-    measures: &Vec<Rc<BaseMeasure>>,
+    measures: &Vec<Rc<MemberSymbol>>,
 ) -> Result<Vec<JoinHintItem>, CubeError> {
     let mut visitor = JoinHintsCollector::new();
     for meas in measures.iter() {
-        visitor.apply(&meas.member_evaluator(), &())?;
+        visitor.apply(&meas, &())?;
     }
     let res = visitor.extract_result();
     Ok(res)

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

@@ -63,21 +63,20 @@ impl TraversalVisitor for SubQueryDimensionsCollector {
 }
 
 pub fn collect_sub_query_dimensions_from_members(
-    members: &Vec<Rc<dyn BaseMember>>,
+    members: &Vec<Rc<MemberSymbol>>,
     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, join_planner, join, query_tools)
+) -> Result<Vec<Rc<MemberSymbol>>, CubeError> {
+    collect_sub_query_dimensions_from_symbols(&members, 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> {
+) -> Result<Vec<Rc<MemberSymbol>>, CubeError> {
     let mut visitor = SubQueryDimensionsCollector::new();
     for member in members.iter() {
         visitor.apply(&member, &())?;
@@ -88,11 +87,7 @@ pub fn collect_sub_query_dimensions_from_symbols(
             visitor.apply(&dep, &())?;
         }
     }
-    visitor
-        .extract_result()
-        .into_iter()
-        .map(|s| BaseDimension::try_new_required(s, query_tools.clone()))
-        .collect::<Result<Vec<_>, CubeError>>()
+    Ok(visitor.extract_result())
 }
 
 pub fn collect_sub_query_dimensions(

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

@@ -68,6 +68,32 @@ impl TimeDimensionSymbol {
         Ok(res)
     }
 
+    pub fn change_granularity(
+        &self,
+        query_tools: Rc<QueryTools>,
+        new_granularity: Option<String>,
+    ) -> Result<Rc<Self>, CubeError> {
+        let evaluator_compiler_cell = query_tools.evaluator_compiler().clone();
+        let mut evaluator_compiler = evaluator_compiler_cell.borrow_mut();
+
+        let new_granularity_obj = GranularityHelper::make_granularity_obj(
+            query_tools.cube_evaluator().clone(),
+            &mut evaluator_compiler,
+            query_tools.timezone(),
+            &&self.base_symbol.cube_name(),
+            &self.base_symbol.name(),
+            new_granularity.clone(),
+        )?;
+        let date_range_tuple = self.date_range.clone();
+        let result = TimeDimensionSymbol::new(
+            self.base_symbol.clone(),
+            new_granularity.clone(),
+            new_granularity_obj.clone(),
+            date_range_tuple,
+        );
+        Ok(result)
+    }
+
     pub fn full_name(&self) -> String {
         self.full_name.clone()
     }