addon

Author: waralexrom

rust/cubesqlplanner/cubesqlplanner/src/planner/base_dimension.rs

@@ -132,7 +132,7 @@ impl BaseDimension {
             query_tools.base_tools().clone(),
         )?;
         let full_name = member_expression_symbol.full_name();
-        let member_evaluator = Rc::new(MemberSymbol::MemberExpression(member_expression_symbol));
+        let member_evaluator = MemberSymbol::new_member_expression(member_expression_symbol);
         let default_alias = PlanSqlTemplates::alias_name(&name);
 
         Ok(Rc::new(Self {

rust/cubesqlplanner/cubesqlplanner/src/planner/base_measure.rs

@@ -139,7 +139,7 @@ impl BaseMeasure {
             query_tools.base_tools().clone(),
         )?;
         let full_name = member_expression_symbol.full_name();
-        let member_evaluator = Rc::new(MemberSymbol::MemberExpression(member_expression_symbol));
+        let member_evaluator = MemberSymbol::new_member_expression(member_expression_symbol);
         let default_alias = PlanSqlTemplates::alias_name(&name);
         Ok(Rc::new(Self {
             measure: full_name,
@@ -215,11 +215,11 @@ impl BaseMeasure {
         self.is_rolling_window() || self.is_running_total()
     }
 
-    pub fn measure_type(&self) -> &str {
+    pub fn measure_type(&self) -> String {
         if let Ok(measure_symbol) = self.member_evaluator.as_measure() {
-            measure_symbol.measure_type()
+            measure_symbol.measure_type().clone()
         } else {
-            "number"
+            "number".to_string()
         }
     }
 

rust/cubesqlplanner/cubesqlplanner/src/planner/base_time_dimension.rs

@@ -65,7 +65,7 @@ impl BaseMember for BaseTimeDimension {
 impl BaseTimeDimension {
     pub fn try_new_from_td_symbol(
         query_tools: Rc<QueryTools>,
-        td_symbol: &TimeDimensionSymbol,
+        td_symbol: Rc<TimeDimensionSymbol>,
     ) -> Result<Rc<Self>, CubeError> {
         let dimension =
             BaseDimension::try_new_required(td_symbol.base_symbol().clone(), query_tools.clone())?;
@@ -79,7 +79,7 @@ impl BaseTimeDimension {
             &Some(alias_suffix.clone()),
             query_tools.clone(),
         )?;
-        let member_evaluator = Rc::new(MemberSymbol::TimeDimension(td_symbol.clone()));
+        let member_evaluator = MemberSymbol::new_time_dimension(td_symbol.clone());
 
         Ok(Rc::new(Self {
             dimension,
@@ -128,12 +128,12 @@ impl BaseTimeDimension {
         } else {
             None
         };
-        let member_evaluator = Rc::new(MemberSymbol::TimeDimension(TimeDimensionSymbol::new(
+        let member_evaluator = MemberSymbol::new_time_dimension(TimeDimensionSymbol::new(
             member_evaluator.clone(),
             granularity.clone(),
             granularity_obj.clone(),
             date_range_tuple,
-        )));
+        ));
         Ok(Rc::new(Self {
             dimension,
             query_tools,
@@ -163,12 +163,12 @@ impl BaseTimeDimension {
         } else {
             None
         };
-        let member_evaluator = Rc::new(MemberSymbol::TimeDimension(TimeDimensionSymbol::new(
+        let member_evaluator = MemberSymbol::new_time_dimension(TimeDimensionSymbol::new(
             self.dimension.member_evaluator(),
             new_granularity.clone(),
             new_granularity_obj.clone(),
             date_range_tuple,
-        )));
+        ));
         Ok(Rc::new(Self {
             dimension: self.dimension.clone(),
             granularity_obj: new_granularity_obj,

rust/cubesqlplanner/cubesqlplanner/src/planner/filter/base_filter.rs

@@ -75,11 +75,11 @@ impl BaseFilter {
         })
     }
 
-    pub fn member_evaluator(&self) -> &Rc<MemberSymbol> {
+    pub fn member_evaluator(&self) -> Rc<MemberSymbol> {
         if let Ok(time_dimension) = self.member_evaluator.as_time_dimension() {
-            time_dimension.base_symbol()
+            time_dimension.base_symbol().clone()
         } else {
-            &self.member_evaluator
+            self.member_evaluator.clone()
         }
     }
 
@@ -395,8 +395,8 @@ impl BaseFilter {
         &self,
         plan_templates: &PlanSqlTemplates,
     ) -> Result<(String, String), CubeError> {
-        let from_expr = format!("min(date_from)");
-        let to_expr = format!("max(date_to)");
+        let from_expr = format!("min({})", plan_templates.quote_identifier("date_from")?);
+        let to_expr = format!("max({})", plan_templates.quote_identifier("date_to")?);
         let alias = format!("value");
         let time_series_cte_name = format!("time_series"); // FIXME May be should be passed as parameter
 

rust/cubesqlplanner/cubesqlplanner/src/planner/filter/base_segment.rs

@@ -37,7 +37,7 @@ impl BaseSegment {
             query_tools.base_tools().clone(),
         )?;
         let full_name = full_name.unwrap_or(member_expression_symbol.full_name());
-        let member_evaluator = Rc::new(MemberSymbol::MemberExpression(member_expression_symbol));
+        let member_evaluator = MemberSymbol::new_member_expression(member_expression_symbol);
 
         Ok(Rc::new(Self {
             full_name,

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

@@ -200,7 +200,17 @@ impl MultipliedMeasuresQueryPlanner {
         key_cube_name: &String,
     ) -> Result<bool, CubeError> {
         for measure in measures.iter() {
-            let cubes = collect_cube_names(measure.member_evaluator())?;
+            let member_expression_over_dimensions_cubes =
+                if let Ok(member_expression) = measure.member_evaluator().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())?
+            };
             let join_hints = collect_join_hints(measure.member_evaluator())?;
             if cubes.iter().any(|cube| cube != key_cube_name) {
                 let measures_join = self.query_tools.join_graph().build_join(join_hints)?;

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

@@ -225,7 +225,7 @@ impl QueryProperties {
                                     }
                                     let source_measure_compiled = evaluator_compiler.add_measure_evaluator(source_measure.clone())?;
                                     let patched_measure = source_measure_compiled.as_measure()?.new_patched(new_measure_type, filters_to_add)?;
-                                    let patched_symbol = Rc::new(MemberSymbol::Measure(patched_measure));
+                                    let patched_symbol = MemberSymbol::new_measure(patched_measure);
                                     MemberExpressionExpression::PatchedSymbol(patched_symbol)
 
                                 } else {

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

@@ -1,10 +1,8 @@
-use super::member_childs;
 use crate::cube_bridge::join_definition::JoinDefinition;
 use crate::planner::query_tools::QueryTools;
 use crate::planner::sql_evaluator::{MemberSymbol, TraversalVisitor};
 use crate::planner::BaseMeasure;
 use cubenativeutils::CubeError;
-use itertools::Itertools;
 use std::collections::HashSet;
 use std::rc::Rc;
 
@@ -142,50 +140,47 @@ pub fn collect_multiplied_measures(
     node: &Rc<MemberSymbol>,
     join: Rc<dyn JoinDefinition>,
 ) -> Result<Vec<MeasureResult>, CubeError> {
+    if let Ok(member_expression) = node.as_member_expression() {
+        if let Some(cube_names) = member_expression.cube_names_if_dimension_only_expression()? {
+            let result = if cube_names.is_empty() {
+                let measure = BaseMeasure::try_new(node.clone(), query_tools.clone())?.unwrap();
+                vec![MeasureResult {
+                    cube_name: measure.cube_name().clone(),
+                    measure,
+                    multiplied: false,
+                }]
+            } else if cube_names.len() == 1 {
+                let cube_name = cube_names[0].clone();
+                let multiplied = join
+                    .static_data()
+                    .multiplication_factor
+                    .get(&cube_name)
+                    .unwrap_or(&false)
+                    .clone();
+                let measure = BaseMeasure::try_new(node.clone(), query_tools.clone())?.unwrap();
+
+                vec![MeasureResult {
+                    measure,
+                    cube_name,
+                    multiplied,
+                }]
+            } else {
+                return Err(CubeError::user(format!(
+                    "Expected single cube for dimension-only measure {}, got {:?}",
+                    node.full_name(),
+                    cube_names
+                )));
+            };
+            return Ok(result);
+        }
+    }
+
     let mut composite_collector = CompositeMeasuresCollector::new();
     composite_collector.apply(node, &CompositeMeasureCollectorState::new(None))?;
     let composite_measures = composite_collector.extract_result();
     let mut visitor =
         MultipliedMeasuresCollector::new(query_tools.clone(), composite_measures, join.clone());
     visitor.apply(node, &())?;
     let result = visitor.extract_result();
-    if result.is_empty() && node.as_member_expression().is_ok() {
-        let childs = member_childs(node, true)?;
-        let cube_names = childs
-            .into_iter()
-            .map(|child| child.cube_name())
-            .collect_vec();
-        let result = if cube_names.is_empty() {
-            let measure = BaseMeasure::try_new(node.clone(), query_tools.clone())?.unwrap();
-            vec![MeasureResult {
-                cube_name: measure.cube_name().clone(),
-                measure,
-                multiplied: false,
-            }]
-        } else if cube_names.len() == 1 {
-            let cube_name = cube_names[0].clone();
-            let multiplied = join
-                .static_data()
-                .multiplication_factor
-                .get(&cube_name)
-                .unwrap_or(&false)
-                .clone();
-            let measure = BaseMeasure::try_new(node.clone(), query_tools.clone())?.unwrap();
-
-            vec![MeasureResult {
-                measure,
-                cube_name,
-                multiplied,
-            }]
-        } else {
-            return Err(CubeError::user(format!(
-                "Expected single cube for dimension-only measure {}, got {:?}",
-                node.full_name(),
-                cube_names
-            )));
-        };
-        Ok(result)
-    } else {
-        Ok(result)
-    }
+    Ok(result)
 }

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

@@ -177,13 +177,12 @@ impl<'a> DependenciesBuilder<'a> {
                 &dep.name,
                 Some(granularity.clone()),
             )? {
-                let member_evaluator =
-                    Rc::new(MemberSymbol::TimeDimension(TimeDimensionSymbol::new(
-                        base_evaluator.clone(),
-                        Some(granularity.clone()),
-                        Some(granularity_obj),
-                        None,
-                    )));
+                let member_evaluator = MemberSymbol::new_time_dimension(TimeDimensionSymbol::new(
+                    base_evaluator.clone(),
+                    Some(granularity.clone()),
+                    Some(granularity_obj),
+                    None,
+                ));
                 granularities.insert(granularity.clone(), member_evaluator);
             } else {
                 return Err(CubeError::user(format!(

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

@@ -15,8 +15,8 @@ pub struct CubeNameSymbol {
 }
 
 impl CubeNameSymbol {
-    pub fn new(cube_name: String) -> Self {
-        Self { cube_name }
+    pub fn new(cube_name: String) -> Rc<Self> {
+        Rc::new(Self { cube_name })
     }
 
     pub fn evaluate_sql(&self) -> Result<String, CubeError> {
@@ -80,13 +80,13 @@ impl CubeTableSymbol {
         member_sql: Option<Rc<SqlCall>>,
         definition: Rc<dyn CubeDefinition>,
         is_table_sql: bool,
-    ) -> Self {
-        Self {
+    ) -> Rc<Self> {
+        Rc::new(Self {
             cube_name,
             member_sql,
             definition,
             is_table_sql,
-        }
+        })
     }
 
     pub fn evaluate_sql(