chore(tesseract): Refactoring of time shift without time dimension logic

Author: waralexrom

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

@@ -1,13 +1,14 @@
 use crate::logical_plan::*;
 use crate::planner::planners::multi_stage::TimeShiftState;
-use crate::planner::sql_evaluator::MemberSymbol;
+use crate::planner::sql_evaluator::{DimensionTimeShift, MemberSymbol};
+use std::collections::HashMap;
 use std::rc::Rc;
 
 pub struct MultiStageLeafMeasure {
     pub measure: Rc<MemberSymbol>,
     pub render_measure_as_state: bool, //Render measure as state, for example hll state for count_approx
     pub render_measure_for_ungrouped: bool,
-    pub time_shifts: TimeShiftState,
+    pub time_shifts: HashMap<String, DimensionTimeShift>,
     pub query: Rc<Query>,
 }
 
@@ -22,13 +23,10 @@ impl PrettyPrint for MultiStageLeafMeasure {
         if self.render_measure_for_ungrouped {
             result.println("render_measure_for_ungrouped: true", &state);
         }
-        if !self.time_shifts.dimensions_shifts.is_empty() {
+        if !self.time_shifts.is_empty() {
             result.println("time_shifts:", &state);
             let details_state = state.new_level();
-            if let Some(common) = &self.time_shifts.common_time_shift {
-                result.println(&format!("- common: {}", common.to_sql()), &details_state);
-            }
-            for (_, time_shift) in self.time_shifts.dimensions_shifts.iter() {
+            for (_, time_shift) in self.time_shifts.iter() {
                 result.println(
                     &format!(
                         "- {}: {}",

rust/cubesqlplanner/cubesqlplanner/src/physical_plan_builder/builder.rs

@@ -5,6 +5,7 @@ use crate::planner::planners::multi_stage::TimeShiftState;
 use crate::planner::query_properties::OrderByItem;
 use crate::planner::query_tools::QueryTools;
 use crate::planner::sql_evaluator::sql_nodes::SqlNodesFactory;
+use crate::planner::sql_evaluator::DimensionTimeShift;
 use crate::planner::sql_evaluator::MemberSymbol;
 use crate::planner::sql_evaluator::ReferencesBuilder;
 use crate::planner::sql_templates::PlanSqlTemplates;
@@ -24,7 +25,7 @@ struct PhysicalPlanBuilderContext {
     pub alias_prefix: Option<String>,
     pub render_measure_as_state: bool, //Render measure as state, for example hll state for count_approx
     pub render_measure_for_ungrouped: bool,
-    pub time_shifts: TimeShiftState,
+    pub time_shifts: HashMap<String, DimensionTimeShift>,
     pub original_sql_pre_aggregations: HashMap<String, String>,
 }
 

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

@@ -104,6 +104,57 @@ impl MultiStageAppliedState {
         &self.time_shifts
     }
 
+    pub fn resolved_time_shifts(&self) -> HashMap<String, DimensionTimeShift> {
+        let mut resolved_time_shifts = self.time_shifts.dimensions_shifts.clone();
+        if let Some(common) = &self.time_shifts.common_time_shift {
+            for member in self.all_time_members() {
+                if let Some(exists) = resolved_time_shifts.get_mut(&member.full_name()) {
+                    exists.interval += common;
+                } else {
+                    let time_shift = DimensionTimeShift {
+                        interval: common.clone(),
+                        dimension: member.clone(),
+                    };
+                    resolved_time_shifts.insert(member.full_name(), time_shift);
+                }
+            }
+        }
+        resolved_time_shifts
+    }
+
+    fn all_time_members(&self) -> Vec<Rc<MemberSymbol>> {
+        let mut filter_symbols = self.all_dimensions_symbols();
+        for filter_item in self
+            .time_dimensions_filters
+            .iter()
+            .chain(self.dimensions_filters.iter())
+            .chain(self.segments.iter())
+        {
+            filter_item.find_all_member_evaluators(&mut filter_symbols);
+        }
+
+        let time_symbols = filter_symbols
+            .into_iter()
+            .filter_map(|m| {
+                let symbol = if let Ok(time_dim) = m.as_time_dimension() {
+                    time_dim.base_symbol().clone().resolve_reference_chain()
+                } else {
+                    m.resolve_reference_chain()
+                };
+                if let Ok(dim) = symbol.as_dimension() {
+                    if dim.dimension_type() == "time" {
+                        Some(symbol)
+                    } else {
+                        None
+                    }
+                } else {
+                    None
+                }
+            })
+            .collect_vec();
+        time_symbols
+    }
+
     pub fn time_dimensions_filters(&self) -> &Vec<FilterItem> {
         &self.time_dimensions_filters
     }
@@ -122,6 +173,14 @@ impl MultiStageAppliedState {
             .collect()
     }
 
+    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()))
+            .collect()
+    }
+
     pub fn dimensions_filters(&self) -> &Vec<FilterItem> {
         &self.dimensions_filters
     }

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

@@ -301,7 +301,7 @@ impl MultiStageMemberQueryPlanner {
             measure: member_node.clone(),
             query,
             render_measure_as_state: self.description.member().has_aggregates_on_top(),
-            time_shifts: self.description.state().time_shifts().clone(),
+            time_shifts: self.description.state().resolved_time_shifts(),
             render_measure_for_ungrouped: self.description.member().is_ungrupped(),
         };
         let result = LogicalMultiStageMember {

rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/factory.rs

@@ -7,12 +7,13 @@ use super::{
 };
 use crate::plan::schema::QualifiedColumnName;
 use crate::planner::planners::multi_stage::TimeShiftState;
+use crate::planner::sql_evaluator::DimensionTimeShift;
 use std::collections::{HashMap, HashSet};
 use std::rc::Rc;
 
 #[derive(Clone)]
 pub struct SqlNodesFactory {
-    time_shifts: TimeShiftState,
+    time_shifts: HashMap<String, DimensionTimeShift>,
     ungrouped: bool,
     ungrouped_measure: bool,
     count_approx_as_state: bool,
@@ -33,7 +34,7 @@ pub struct SqlNodesFactory {
 impl SqlNodesFactory {
     pub fn new() -> Self {
         Self {
-            time_shifts: TimeShiftState::default(),
+            time_shifts: HashMap::new(),
             ungrouped: false,
             ungrouped_measure: false,
             count_approx_as_state: false,
@@ -52,7 +53,7 @@ impl SqlNodesFactory {
         }
     }
 
-    pub fn set_time_shifts(&mut self, time_shifts: TimeShiftState) {
+    pub fn set_time_shifts(&mut self, time_shifts: HashMap<String, DimensionTimeShift>) {
         self.time_shifts = time_shifts;
     }
 

rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/time_shift.rs

@@ -1,21 +1,23 @@
 use super::SqlNode;
 use crate::planner::planners::multi_stage::TimeShiftState;
 use crate::planner::query_tools::QueryTools;
+use crate::planner::sql_evaluator::DimensionTimeShift;
 use crate::planner::sql_evaluator::MemberSymbol;
 use crate::planner::sql_evaluator::SqlEvaluatorVisitor;
 use crate::planner::sql_templates::PlanSqlTemplates;
 use crate::planner::SqlInterval;
 use cubenativeutils::CubeError;
 use std::any::Any;
+use std::collections::HashMap;
 use std::rc::Rc;
 
 pub struct TimeShiftSqlNode {
-    shifts: TimeShiftState,
+    shifts: HashMap<String, DimensionTimeShift>,
     input: Rc<dyn SqlNode>,
 }
 
 impl TimeShiftSqlNode {
-    pub fn new(shifts: TimeShiftState, input: Rc<dyn SqlNode>) -> Rc<Self> {
+    pub fn new(shifts: HashMap<String, DimensionTimeShift>, input: Rc<dyn SqlNode>) -> Rc<Self> {
         Rc::new(Self { shifts, input })
     }
 
@@ -43,16 +45,12 @@ impl SqlNode for TimeShiftSqlNode {
         let res = match node.as_ref() {
             MemberSymbol::Dimension(ev) => {
                 if !ev.is_reference() && ev.dimension_type() == "time" {
-                    let mut interval = self.shifts.common_time_shift.clone().unwrap_or_default();
-                    if let Some(shift) = self.shifts.dimensions_shifts.get(&ev.full_name()) {
-                        interval += &shift.interval;
-                    }
-                    if interval == SqlInterval::default() {
-                        input
-                    } else {
-                        let shift = interval.to_sql();
+                    if let Some(shift) = self.shifts.get(&ev.full_name()) {
+                        let shift = shift.interval.to_sql();
                         let res = templates.add_timestamp_interval(input, shift)?;
                         format!("({})", res)
+                    } else {
+                        input
                     }
                 } else {
                     input