in work

Author: waralexrom

rust/cubesqlplanner/cubesqlplanner/src/logical_plan/multistage/common.rs

@@ -10,28 +10,13 @@ impl PrettyPrint for MultiStageAppliedState {
         result.println(
             &format!(
                 "-time_dimensions: {}",
-                print_symbols(
-                    &self
-                        .time_dimensions()
-                        .iter()
-                        .map(|d| d.member_evaluator())
-                        .collect_vec()
-                )
+                print_symbols(&self.time_dimensions())
             ),
             state,
         );
 
         result.println(
-            &format!(
-                "-dimensions: {}",
-                print_symbols(
-                    &self
-                        .dimensions()
-                        .iter()
-                        .map(|d| d.member_evaluator())
-                        .collect_vec()
-                )
-            ),
+            &format!("-dimensions: {}", print_symbols(&self.dimensions())),
             state,
         );
 

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

@@ -3,7 +3,7 @@ use super::FilterOperator;
 use crate::cube_bridge::base_query_options::FilterItem as NativeFilterItem;
 use crate::plan::filter::{FilterGroup, FilterGroupOperator, FilterItem};
 use crate::planner::query_tools::QueryTools;
-use crate::planner::sql_evaluator::Compiler;
+use crate::planner::sql_evaluator::{Compiler, MemberSymbol};
 use crate::planner::BaseMember;
 use crate::planner::BaseTimeDimension;
 use cubenativeutils::CubeError;
@@ -40,16 +40,18 @@ impl<'a> FilterCompiler<'a> {
         Ok(())
     }
 
-    pub fn add_time_dimension_item(&mut self, item: &BaseTimeDimension) -> Result<(), CubeError> {
-        if let Some(date_range) = item.get_date_range() {
-            let filter = BaseFilter::try_new(
-                self.query_tools.clone(),
-                item.member_evaluator(),
-                FilterType::Dimension,
-                FilterOperator::InDateRange,
-                Some(date_range.into_iter().map(|v| Some(v)).collect()),
-            )?;
-            self.time_dimension_filters.push(FilterItem::Item(filter));
+    pub fn add_time_dimension_item(&mut self, item: &Rc<MemberSymbol>) -> Result<(), CubeError> {
+        if let Ok(td_item) = item.as_time_dimension() {
+            if let Some(date_range) = td_item.date_range_vec() {
+                let filter = BaseFilter::try_new(
+                    self.query_tools.clone(),
+                    item.clone(),
+                    FilterType::Dimension,
+                    FilterOperator::InDateRange,
+                    Some(date_range.into_iter().map(|v| Some(v)).collect()),
+                )?;
+                self.time_dimension_filters.push(FilterItem::Item(filter));
+            }
         }
         Ok(())
     }

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

@@ -1,4 +1,5 @@
 use crate::planner::query_tools::QueryTools;
+use crate::planner::sql_evaluator::MemberSymbol;
 use crate::planner::{BaseCube, BaseDimension};
 use cubenativeutils::CubeError;
 use std::rc::Rc;
@@ -23,7 +24,7 @@ impl CommonUtils {
     pub fn primary_keys_dimensions(
         &self,
         cube_name: &String,
-    ) -> Result<Vec<Rc<BaseDimension>>, CubeError> {
+    ) -> Result<Vec<Rc<MemberSymbol>>, CubeError> {
         let evaluator_compiler_cell = self.query_tools.evaluator_compiler().clone();
         let mut evaluator_compiler = evaluator_compiler_cell.borrow_mut();
         let primary_keys = self
@@ -39,9 +40,8 @@ impl CommonUtils {
             .iter()
             .map(|d| -> Result<_, CubeError> {
                 let full_name = format!("{}.{}", cube_name, d);
-                let evaluator = evaluator_compiler.add_dimension_evaluator(full_name.clone())?;
-                let dim = BaseDimension::try_new_required(evaluator, self.query_tools.clone())?;
-                Ok(dim)
+                let symbol = evaluator_compiler.add_dimension_evaluator(full_name.clone())?;
+                Ok(symbol)
             })
             .collect::<Result<Vec<_>, _>>()?;
         Ok(dims)

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

@@ -3,7 +3,9 @@ use crate::logical_plan::DimensionSubQuery;
 use crate::plan::{FilterItem, QualifiedColumnName};
 use crate::planner::query_tools::QueryTools;
 use crate::planner::sql_evaluator::collectors::collect_sub_query_dimensions;
-use crate::planner::sql_evaluator::MemberExpressionExpression;
+use crate::planner::sql_evaluator::{
+    MemberExpressionExpression, MemberExpressionSymbol, MemberSymbol,
+};
 use crate::planner::QueryProperties;
 use crate::planner::{BaseDimension, BaseMeasure, BaseMember};
 use cubenativeutils::CubeError;
@@ -15,7 +17,7 @@ pub struct DimensionSubqueryPlanner {
     utils: CommonUtils,
     query_tools: Rc<QueryTools>,
     query_properties: Rc<QueryProperties>,
-    sub_query_dims: HashMap<String, Vec<Rc<BaseDimension>>>,
+    sub_query_dims: HashMap<String, Vec<Rc<MemberSymbol>>>,
     dimensions_refs: RefCell<HashMap<String, QualifiedColumnName>>,
 }
 
@@ -30,11 +32,11 @@ impl DimensionSubqueryPlanner {
         }
     }
     pub fn try_new(
-        dimensions: &Vec<Rc<BaseDimension>>,
+        dimensions: &Vec<Rc<MemberSymbol>>,
         query_tools: Rc<QueryTools>,
         query_properties: Rc<QueryProperties>,
     ) -> Result<Self, CubeError> {
-        let mut sub_query_dims: HashMap<String, Vec<Rc<BaseDimension>>> = HashMap::new();
+        let mut sub_query_dims: HashMap<String, Vec<Rc<MemberSymbol>>> = HashMap::new();
         for subquery_dimension in dimensions.iter() {
             let cube_name = subquery_dimension.cube_name().clone();
             sub_query_dims
@@ -54,7 +56,7 @@ impl DimensionSubqueryPlanner {
 
     pub fn plan_queries(
         &self,
-        dimensions: &Vec<Rc<BaseDimension>>,
+        dimensions: &Vec<Rc<MemberSymbol>>,
     ) -> Result<Vec<Rc<DimensionSubQuery>>, CubeError> {
         let mut result = Vec::new();
         for subquery_dimension in dimensions.iter() {
@@ -65,21 +67,33 @@ impl DimensionSubqueryPlanner {
 
     fn plan_query(
         &self,
-        subquery_dimension: Rc<BaseDimension>,
+        subquery_dimension: Rc<MemberSymbol>,
     ) -> Result<Rc<DimensionSubQuery>, CubeError> {
         let dim_name = subquery_dimension.name();
         let cube_name = subquery_dimension.cube_name().clone();
+        let dimension_symbol = subquery_dimension.as_dimension()?;
+
         let primary_keys_dimensions = self.utils.primary_keys_dimensions(&cube_name)?;
-        let expression = subquery_dimension.sql_call()?;
-        let measure = BaseMeasure::try_new_from_expression(
-            MemberExpressionExpression::SqlCall(expression),
+
+        let expression = if let Some(sql_call) = dimension_symbol.member_sql() {
+            sql_call.clone()
+        } else {
+            return Err(CubeError::user(format!(
+                "Subquery dimension {} must have `sql` field",
+                subquery_dimension.full_name()
+            )));
+        };
+
+        let member_expression_symbol = MemberExpressionSymbol::try_new(
             cube_name.clone(),
             dim_name.clone(),
+            MemberExpressionExpression::SqlCall(expression),
             None,
-            self.query_tools.clone(),
+            self.query_tools.base_tools().clone(),
         )?;
+        let measure = MemberSymbol::new_member_expression(member_expression_symbol);
 
-        let (dimensions_filters, time_dimensions_filters) = if subquery_dimension
+        let (dimensions_filters, time_dimensions_filters) = if dimension_symbol
             .propagate_filters_to_sub_query()
         {
             let dimensions_filters = self
@@ -114,12 +128,9 @@ impl DimensionSubqueryPlanner {
         let sub_query = query_planner.plan()?;
         let result = Rc::new(DimensionSubQuery {
             query: sub_query,
-            primary_keys_dimensions: primary_keys_dimensions
-                .into_iter()
-                .map(|d| d.member_evaluator())
-                .collect(),
-            subquery_dimension: subquery_dimension.member_evaluator(),
-            measure_for_subquery_dimension: measure.member_evaluator().clone(),
+            primary_keys_dimensions,
+            subquery_dimension,
+            measure_for_subquery_dimension: measure,
         });
         Ok(result)
     }

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

@@ -11,8 +11,8 @@ use std::rc::Rc;
 
 #[derive(Clone)]
 pub struct MultiStageAppliedState {
-    time_dimensions: Vec<Rc<BaseTimeDimension>>,
-    dimensions: Vec<Rc<BaseDimension>>,
+    time_dimensions: Vec<Rc<MemberSymbol>>,
+    dimensions: Vec<Rc<MemberSymbol>>,
     time_dimensions_filters: Vec<FilterItem>,
     dimensions_filters: Vec<FilterItem>,
     measures_filters: Vec<FilterItem>,
@@ -22,8 +22,8 @@ pub struct MultiStageAppliedState {
 
 impl MultiStageAppliedState {
     pub fn new(
-        time_dimensions: Vec<Rc<BaseTimeDimension>>,
-        dimensions: Vec<Rc<BaseDimension>>,
+        time_dimensions: Vec<Rc<MemberSymbol>>,
+        dimensions: Vec<Rc<MemberSymbol>>,
         time_dimensions_filters: Vec<FilterItem>,
         dimensions_filters: Vec<FilterItem>,
         measures_filters: Vec<FilterItem>,
@@ -52,13 +52,13 @@ impl MultiStageAppliedState {
         }
     }
 
-    pub fn add_dimensions(&mut self, dimensions: Vec<Rc<BaseDimension>>) {
+    pub fn add_dimensions(&mut self, dimensions: Vec<Rc<MemberSymbol>>) {
         self.dimensions = self
             .dimensions
             .iter()
             .cloned()
             .chain(dimensions.into_iter())
-            .unique_by(|d| d.member_evaluator().full_name())
+            .unique_by(|d| d.full_name())
             .collect_vec();
     }
 
@@ -170,24 +170,18 @@ impl MultiStageAppliedState {
     }
 
     pub fn time_dimensions_symbols(&self) -> Vec<Rc<MemberSymbol>> {
-        self.time_dimensions
-            .iter()
-            .map(|d| d.member_evaluator().clone())
-            .collect()
+        self.time_dimensions().clone()
     }
 
     pub fn dimensions_symbols(&self) -> Vec<Rc<MemberSymbol>> {
-        self.dimensions
-            .iter()
-            .map(|d| d.member_evaluator().clone())
-            .collect()
+        self.dimensions.clone()
     }
 
     pub fn all_dimensions_symbols(&self) -> Vec<Rc<MemberSymbol>> {
         self.time_dimensions
             .iter()
-            .map(|d| d.member_evaluator().clone())
-            .chain(self.dimensions.iter().map(|d| d.member_evaluator().clone()))
+            .cloned()
+            .chain(self.dimensions.iter().cloned())
             .collect()
     }
 
@@ -203,19 +197,19 @@ impl MultiStageAppliedState {
         &self.measures_filters
     }
 
-    pub fn dimensions(&self) -> &Vec<Rc<BaseDimension>> {
+    pub fn dimensions(&self) -> &Vec<Rc<MemberSymbol>> {
         &self.dimensions
     }
 
-    pub fn time_dimensions(&self) -> &Vec<Rc<BaseTimeDimension>> {
+    pub fn time_dimensions(&self) -> &Vec<Rc<MemberSymbol>> {
         &self.time_dimensions
     }
 
-    pub fn set_time_dimensions(&mut self, time_dimensions: Vec<Rc<BaseTimeDimension>>) {
+    pub fn set_time_dimensions(&mut self, time_dimensions: Vec<Rc<MemberSymbol>>) {
         self.time_dimensions = time_dimensions;
     }
 
-    pub fn set_dimensions(&mut self, dimensions: Vec<Rc<BaseDimension>>) {
+    pub fn set_dimensions(&mut self, dimensions: Vec<Rc<MemberSymbol>>) {
         self.dimensions = dimensions;
     }
 
@@ -407,7 +401,7 @@ impl PartialEq for MultiStageAppliedState {
                 .dimensions
                 .iter()
                 .zip(other.dimensions.iter())
-                .all(|(a, b)| a.member_evaluator().full_name() == b.member_evaluator().full_name());
+                .all(|(a, b)| a.full_name() == b.full_name());
         dims_eq
             && self.time_dimensions_filters == other.time_dimensions_filters
             && self.dimensions_filters == other.dimensions_filters
@@ -421,11 +415,7 @@ impl Debug for MultiStageAppliedState {
         f.debug_struct("MultiStageAppliedState")
             .field(
                 "dimensions",
-                &self
-                    .dimensions
-                    .iter()
-                    .map(|d| d.member_evaluator().full_name())
-                    .join(", "),
+                &self.dimensions.iter().map(|d| d.full_name()).join(", "),
             )
             .field("time_shifts", &self.time_shifts)
             .finish()

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

@@ -4,15 +4,15 @@ use std::rc::Rc;
 
 #[derive(Clone)]
 pub struct TimeSeriesDescription {
-    pub time_dimension: Rc<BaseTimeDimension>,
+    pub time_dimension: Rc<MemberSymbol>,
     pub date_range_cte: Option<String>,
 }
 
 #[derive(Clone)]
 pub enum MultiStageLeafMemberType {
     Measure,
     TimeSeries(Rc<TimeSeriesDescription>),
-    TimeSeriesGetRange(Rc<BaseTimeDimension>),
+    TimeSeriesGetRange(Rc<MemberSymbol>),
 }
 
 #[derive(Clone)]
@@ -36,15 +36,15 @@ pub enum RollingWindowType {
 
 #[derive(Clone)]
 pub struct RollingWindowDescription {
-    pub time_dimension: Rc<BaseTimeDimension>,
-    pub base_time_dimension: Rc<BaseTimeDimension>,
+    pub time_dimension: Rc<MemberSymbol>,
+    pub base_time_dimension: Rc<MemberSymbol>,
     pub rolling_window: RollingWindowType,
 }
 
 impl RollingWindowDescription {
     pub fn new_regular(
-        time_dimension: Rc<BaseTimeDimension>,
-        base_time_dimension: Rc<BaseTimeDimension>,
+        time_dimension: Rc<MemberSymbol>,
+        base_time_dimension: Rc<MemberSymbol>,
         trailing: Option<String>,
         leading: Option<String>,
         offset: String,
@@ -62,8 +62,8 @@ impl RollingWindowDescription {
     }
 
     pub fn new_to_date(
-        time_dimension: Rc<BaseTimeDimension>,
-        base_time_dimension: Rc<BaseTimeDimension>,
+        time_dimension: Rc<MemberSymbol>,
+        base_time_dimension: Rc<MemberSymbol>,
         granularity: String,
     ) -> Self {
         Self {
@@ -74,8 +74,8 @@ impl RollingWindowDescription {
     }
 
     pub fn new_running_total(
-        time_dimension: Rc<BaseTimeDimension>,
-        base_time_dimension: Rc<BaseTimeDimension>,
+        time_dimension: Rc<MemberSymbol>,
+        base_time_dimension: Rc<MemberSymbol>,
     ) -> Self {
         Self {
             time_dimension,