member expressions fixes

Author: waralexrom

packages/cubejs-schema-compiler/src/adapter/BaseQuery.js

@@ -806,6 +806,7 @@ export class BaseQuery {
       exportAnnotatedSql: exportAnnotatedSql === true,
       preAggregationQuery: this.options.preAggregationQuery,
       totalQuery: this.options.totalQuery,
+      joinHints: this.options.joinHints,
     };
 
     const buildResult = nativeBuildSqlAndParams(queryParams);

rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/base_query_options.rs

@@ -1,4 +1,5 @@
 use super::join_graph::{JoinGraph, NativeJoinGraph};
+use super::join_hints::JoinHintItem;
 use super::options_member::OptionsMember;
 use crate::cube_bridge::base_tools::{BaseTools, NativeBaseTools};
 use crate::cube_bridge::evaluator::{CubeEvaluator, NativeCubeEvaluator};
@@ -81,4 +82,6 @@ pub trait BaseQueryOptions {
     fn base_tools(&self) -> Result<Rc<dyn BaseTools>, CubeError>;
     #[nbridge(field)]
     fn join_graph(&self) -> Result<Rc<dyn JoinGraph>, CubeError>;
+    #[nbridge(field, optional, vec)]
+    fn join_hints(&self) -> Result<Option<Vec<JoinHintItem>>, CubeError>;
 }

rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/join_hints.rs

@@ -1,7 +1,25 @@
-use serde::{Deserialize, Serialize};
+use cubenativeutils::wrappers::inner_types::InnerTypes;
+use cubenativeutils::wrappers::serializer::NativeDeserialize;
+use cubenativeutils::wrappers::NativeObjectHandle;
+use cubenativeutils::CubeError;
+use serde::Serialize;
 
-#[derive(Debug, Clone, Eq, PartialEq, Hash, Serialize, Deserialize)]
+#[derive(Debug, Clone, Eq, PartialEq, Hash, Serialize)]
 pub enum JoinHintItem {
     Single(String),
     Vector(Vec<String>),
 }
+
+impl<IT: InnerTypes> NativeDeserialize<IT> for JoinHintItem {
+    fn from_native(native_object: NativeObjectHandle<IT>) -> Result<Self, CubeError> {
+        match Vec::<String>::from_native(native_object.clone()) {
+            Ok(value) => Ok(Self::Vector(value)),
+            Err(_) => match String::from_native(native_object) {
+                Ok(value) => Ok(Self::Single(value)),
+                Err(_) => Err(CubeError::user(format!(
+                    "Join hint item expected to be string or vector of strings"
+                ))),
+            },
+        }
+    }
+}

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

@@ -108,6 +108,7 @@ impl DimensionSubqueryPlanner {
             false,
             false,
             false,
+            Rc::new(vec![]),
         )?;
         let query_planner = QueryPlanner::new(sub_query_properties, self.query_tools.clone());
         let sub_query = query_planner.plan()?;

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

@@ -16,7 +16,7 @@ use std::rc::Rc;
 
 pub struct MultiStageMemberQueryPlanner {
     query_tools: Rc<QueryTools>,
-    _query_properties: Rc<QueryProperties>,
+    query_properties: Rc<QueryProperties>,
     description: Rc<MultiStageQueryDescription>,
 }
 
@@ -28,7 +28,7 @@ impl MultiStageMemberQueryPlanner {
     ) -> Self {
         Self {
             query_tools,
-            _query_properties: query_properties,
+            query_properties,
             description,
         }
     }
@@ -73,6 +73,7 @@ impl MultiStageMemberQueryPlanner {
             true,
             false,
             false,
+            Rc::new(vec![]),
         )?;
 
         let simple_query_planer =
@@ -266,6 +267,7 @@ impl MultiStageMemberQueryPlanner {
             self.description.member().is_ungrupped(),
             false,
             false,
+            self.query_properties.query_join_hints().clone(),
         )?;
 
         let query_planner =

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

@@ -67,6 +67,10 @@ impl MultipliedMeasuresQueryPlanner {
             .into_iter()
             .into_group_map_by(|m| m.cube_name().clone())
         {
+            let measures = measures
+                .into_iter()
+                .map(|m| m.measure().clone())
+                .collect_vec();
             let join_multi_fact_groups = self
                 .query_properties
                 .compute_join_multi_fact_groups_with_measures(&measures)?;
@@ -91,7 +95,12 @@ impl MultipliedMeasuresQueryPlanner {
             let all_measures = full_key_aggregate_measures
                 .regular_measures
                 .iter()
-                .chain(full_key_aggregate_measures.multiplied_measures.iter())
+                .chain(
+                    full_key_aggregate_measures
+                        .multiplied_measures
+                        .iter()
+                        .map(|m| m.measure()),
+                )
                 .map(|m| m.member_evaluator().clone())
                 .collect_vec();
             let schema = Rc::new(LogicalSchema {

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

@@ -1,6 +1,7 @@
 use super::filter::compiler::FilterCompiler;
 use super::filter::BaseSegment;
 use super::query_tools::QueryTools;
+use crate::cube_bridge::join_hints::JoinHintItem;
 use crate::cube_bridge::member_expression::MemberExpressionExpressionDef;
 use crate::planner::sql_evaluator::MemberExpressionExpression;
 
@@ -45,9 +46,29 @@ impl OrderByItem {
     }
 }
 
+#[derive(Debug, Clone)]
+pub struct MultipliedMeasure {
+    measure: Rc<BaseMeasure>,
+    cube_name: String, //May differ from cube_name of the measure for a member_expression that refers to a dimension.
+}
+
+impl MultipliedMeasure {
+    pub fn new(measure: Rc<BaseMeasure>, cube_name: String) -> Rc<Self> {
+        Rc::new(Self { measure, cube_name })
+    }
+
+    pub fn measure(&self) -> &Rc<BaseMeasure> {
+        &self.measure
+    }
+
+    pub fn cube_name(&self) -> &String {
+        &self.cube_name
+    }
+}
+
 #[derive(Default, Clone, Debug)]
 pub struct FullKeyAggregateMeasures {
-    pub multiplied_measures: Vec<Rc<BaseMeasure>>,
+    pub multiplied_measures: Vec<Rc<MultipliedMeasure>>,
     pub regular_measures: Vec<Rc<BaseMeasure>>,
     pub multi_stage_measures: Vec<Rc<BaseMeasure>>,
     pub rendered_as_multiplied_measures: HashSet<String>,
@@ -81,6 +102,7 @@ pub struct QueryProperties {
     multi_fact_join_groups: Vec<(Rc<dyn JoinDefinition>, Vec<Rc<BaseMeasure>>)>,
     pre_aggregation_query: bool,
     total_query: bool,
+    query_join_hints: Rc<Vec<JoinHintItem>>,
 }
 
 impl QueryProperties {
@@ -350,7 +372,10 @@ impl QueryProperties {
         };
         let ungrouped = options.static_data().ungrouped.unwrap_or(false);
 
+        let query_join_hints = Rc::new(options.join_hints()?.unwrap_or_default());
+
         let multi_fact_join_groups = Self::compute_join_multi_fact_groups(
+            query_join_hints.clone(),
             query_tools.clone(),
             &measures,
             &dimensions,
@@ -381,6 +406,7 @@ impl QueryProperties {
             multi_fact_join_groups,
             pre_aggregation_query,
             total_query,
+            query_join_hints,
         }))
     }
 
@@ -400,6 +426,7 @@ impl QueryProperties {
         ungrouped: bool,
         pre_aggregation_query: bool,
         total_query: bool,
+        query_join_hints: Rc<Vec<JoinHintItem>>,
     ) -> Result<Rc<Self>, CubeError> {
         let order_by = if order_by.is_empty() {
             Self::default_order(&dimensions, &time_dimensions, &measures)
@@ -408,6 +435,7 @@ impl QueryProperties {
         };
 
         let multi_fact_join_groups = Self::compute_join_multi_fact_groups(
+            query_join_hints.clone(),
             query_tools.clone(),
             &measures,
             &dimensions,
@@ -435,6 +463,7 @@ impl QueryProperties {
             multi_fact_join_groups,
             pre_aggregation_query,
             total_query,
+            query_join_hints,
         }))
     }
 
@@ -443,6 +472,7 @@ impl QueryProperties {
         measures: &Vec<Rc<BaseMeasure>>,
     ) -> Result<Vec<(Rc<dyn JoinDefinition>, Vec<Rc<BaseMeasure>>)>, CubeError> {
         Self::compute_join_multi_fact_groups(
+            self.query_join_hints.clone(),
             self.query_tools.clone(),
             measures,
             &self.dimensions,
@@ -459,6 +489,7 @@ impl QueryProperties {
     }
 
     pub fn compute_join_multi_fact_groups(
+        query_join_hints: Rc<Vec<JoinHintItem>>,
         query_tools: Rc<QueryTools>,
         measures: &Vec<Rc<BaseMeasure>>,
         dimensions: &Vec<Rc<BaseDimension>>,
@@ -487,7 +518,7 @@ impl QueryProperties {
             .cached_data_mut()
             .join_hints_for_filter_item_vec(&measures_filters)?;
 
-        let mut dimension_and_filter_join_hints_concat = Vec::new();
+        let mut dimension_and_filter_join_hints_concat = vec![query_join_hints];
 
         dimension_and_filter_join_hints_concat.extend(dimensions_join_hints.into_iter());
         dimension_and_filter_join_hints_concat.extend(time_dimensions_join_hints.into_iter());
@@ -608,6 +639,10 @@ impl QueryProperties {
         self.row_limit
     }
 
+    pub fn query_join_hints(&self) -> &Rc<Vec<JoinHintItem>> {
+        &self.query_join_hints
+    }
+
     pub fn offset(&self) -> Option<usize> {
         self.offset
     }
@@ -862,7 +897,9 @@ impl QueryProperties {
                             .insert(item.measure.full_name());
                     }
                     if item.multiplied && !item.measure.can_used_as_addictive_in_multplied() {
-                        result.multiplied_measures.push(item.measure.clone());
+                        result
+                            .multiplied_measures
+                            .push(MultipliedMeasure::new(item.measure.clone(), item.cube_name));
                     } else {
                         result.regular_measures.push(item.measure.clone());
                     }

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

@@ -29,7 +29,7 @@ impl TraversalVisitor for CubeNamesCollector {
     ) -> Result<Option<Self::State>, CubeError> {
         match node.as_ref() {
             MemberSymbol::Dimension(e) => {
-                if e.owned_by_cube() {
+                if !e.is_view() {
                     if !path.is_empty() {
                         for p in path {
                             self.names.insert(p.clone());
@@ -46,7 +46,7 @@ impl TraversalVisitor for CubeNamesCollector {
                 return self.on_node_traverse(e.base_symbol(), path, &())
             }
             MemberSymbol::Measure(e) => {
-                if e.owned_by_cube() {
+                if !e.is_view() {
                     if !path.is_empty() {
                         for p in path {
                             self.names.insert(p.clone());

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

@@ -29,7 +29,7 @@ impl TraversalVisitor for JoinHintsCollector {
     ) -> Result<Option<Self::State>, CubeError> {
         match node.as_ref() {
             MemberSymbol::Dimension(e) => {
-                if e.owned_by_cube() {
+                if !e.is_view() {
                     if !path.is_empty() {
                         if path.len() == 1 {
                             self.hints.push(JoinHintItem::Single(path[0].clone()))
@@ -48,7 +48,7 @@ impl TraversalVisitor for JoinHintsCollector {
                 return self.on_node_traverse(e.base_symbol(), path, &())
             }
             MemberSymbol::Measure(e) => {
-                if e.owned_by_cube() {
+                if !e.is_view() {
                     if !path.is_empty() {
                         if path.len() == 1 {
                             self.hints.push(JoinHintItem::Single(path[0].clone()))

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

@@ -1,15 +1,18 @@
+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;
 
 struct CompositeMeasuresCollector {
     composite_measures: HashSet<String>,
 }
 
+#[derive(Clone)]
 struct CompositeMeasureCollectorState {
     pub parent_measure: Option<Rc<MemberSymbol>>,
 }
@@ -52,15 +55,18 @@ impl TraversalVisitor for CompositeMeasuresCollector {
                 Some(new_state)
             }
             MemberSymbol::Dimension(_) => None,
+            MemberSymbol::MemberExpression(_) => Some(state.clone()),
             _ => None,
         };
         Ok(res)
     }
 }
 
+#[derive(Debug)]
 pub struct MeasureResult {
     pub multiplied: bool,
     pub measure: Rc<BaseMeasure>,
+    pub cube_name: String,
 }
 
 pub struct MultipliedMeasuresCollector {
@@ -113,6 +119,7 @@ impl TraversalVisitor for MultipliedMeasuresCollector {
                         multiplied,
                         measure: BaseMeasure::try_new(node.clone(), self.query_tools.clone())?
                             .unwrap(),
+                        cube_name: node.cube_name(),
                     })
                 }
 
@@ -138,7 +145,47 @@ pub fn collect_multiplied_measures(
     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, composite_measures, join);
+    let mut visitor =
+        MultipliedMeasuresCollector::new(query_tools.clone(), composite_measures, join.clone());
     visitor.apply(node, &())?;
-    Ok(visitor.extract_result())
+    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)
+    }
 }