feat(tesseract): Catch up with features recently added to BaseQuery

Author: waralexrom

rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/measure_definition.rs

@@ -19,7 +19,7 @@ pub struct TimeShiftReference {
     #[serde(rename = "type")]
     pub shift_type: Option<String>,
     #[serde(rename = "timeDimension")]
-    pub time_dimension: String,
+    pub time_dimension: Option<String>,
 }
 
 #[derive(Serialize, Deserialize, Debug, PartialEq, Eq, Clone)]

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

@@ -53,7 +53,10 @@ impl PrettyPrint for MultiStageAppliedState {
         }
 
         result.println("time_shifts:", &state);
-        for (_, time_shift) in self.time_shifts().iter() {
+        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() {
             result.println(
                 &format!(
                     "- {}: {}",

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

@@ -1,14 +1,13 @@
 use crate::logical_plan::*;
-use crate::planner::sql_evaluator::MeasureTimeShift;
+use crate::planner::planners::multi_stage::TimeShiftState;
 use crate::planner::sql_evaluator::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: HashMap<String, MeasureTimeShift>,
+    pub time_shifts: TimeShiftState,
     pub query: Rc<Query>,
 }
 
@@ -23,10 +22,13 @@ impl PrettyPrint for MultiStageLeafMeasure {
         if self.render_measure_for_ungrouped {
             result.println("render_measure_for_ungrouped: true", &state);
         }
-        if !self.time_shifts.is_empty() {
+        if !self.time_shifts.dimensions_shifts.is_empty() {
             result.println("time_shifts:", &state);
             let details_state = state.new_level();
-            for (_, time_shift) in self.time_shifts.iter() {
+            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() {
                 result.println(
                     &format!(
                         "- {}: {}",

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

@@ -1,10 +1,10 @@
 use crate::logical_plan::*;
 use crate::plan::schema::QualifiedColumnName;
 use crate::plan::*;
+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::MeasureTimeShift;
 use crate::planner::sql_evaluator::MemberSymbol;
 use crate::planner::sql_evaluator::ReferencesBuilder;
 use crate::planner::sql_templates::PlanSqlTemplates;
@@ -24,7 +24,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: HashMap<String, MeasureTimeShift>,
+    pub time_shifts: TimeShiftState,
     pub original_sql_pre_aggregations: HashMap<String, String>,
 }
 

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

@@ -1,5 +1,5 @@
 use super::query_tools::QueryTools;
-use super::sql_evaluator::{MeasureTimeShift, MemberExpressionSymbol, MemberSymbol, SqlCall};
+use super::sql_evaluator::{MeasureTimeShifts, MemberExpressionSymbol, MemberSymbol, SqlCall};
 use super::{evaluate_with_context, BaseMember, BaseMemberHelper, VisitorContext};
 use crate::cube_bridge::measure_definition::{MeasureDefinition, RollingWindow};
 use crate::planner::sql_templates::PlanSqlTemplates;
@@ -208,10 +208,10 @@ impl BaseMeasure {
         }
     }
 
-    pub fn time_shifts(&self) -> Vec<MeasureTimeShift> {
+    pub fn time_shift(&self) -> Option<MeasureTimeShifts> {
         match self.member_evaluator.as_ref() {
-            MemberSymbol::Measure(measure_symbol) => measure_symbol.time_shifts().clone(),
-            _ => vec![],
+            MemberSymbol::Measure(measure_symbol) => measure_symbol.time_shift().clone(),
+            _ => None,
         }
     }
 

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

@@ -1,13 +1,25 @@
 use crate::plan::{FilterGroup, FilterItem};
 use crate::planner::filter::FilterOperator;
-use crate::planner::sql_evaluator::{MeasureTimeShift, MemberSymbol};
-use crate::planner::{BaseDimension, BaseMember, BaseTimeDimension};
+use crate::planner::sql_evaluator::{DimensionTimeShift, MeasureTimeShifts, MemberSymbol};
+use crate::planner::{BaseDimension, BaseMember, BaseTimeDimension, SqlInterval};
 use itertools::Itertools;
 use std::cmp::PartialEq;
 use std::collections::HashMap;
 use std::fmt::Debug;
 use std::rc::Rc;
 
+#[derive(Clone, Default, Debug)]
+pub struct TimeShiftState {
+    pub dimensions_shifts: HashMap<String, DimensionTimeShift>,
+    pub common_time_shift: Option<SqlInterval>,
+}
+
+impl TimeShiftState {
+    pub fn is_empty(&self) -> bool {
+        self.dimensions_shifts.is_empty() && self.common_time_shift.is_none()
+    }
+}
+
 #[derive(Clone)]
 pub struct MultiStageAppliedState {
     time_dimensions: Vec<Rc<BaseTimeDimension>>,
@@ -16,7 +28,7 @@ pub struct MultiStageAppliedState {
     dimensions_filters: Vec<FilterItem>,
     measures_filters: Vec<FilterItem>,
     segments: Vec<FilterItem>,
-    time_shifts: HashMap<String, MeasureTimeShift>,
+    time_shifts: TimeShiftState,
 }
 
 impl MultiStageAppliedState {
@@ -35,7 +47,7 @@ impl MultiStageAppliedState {
             dimensions_filters,
             measures_filters,
             segments,
-            time_shifts: HashMap::new(),
+            time_shifts: TimeShiftState::default(),
         })
     }
 
@@ -61,17 +73,34 @@ impl MultiStageAppliedState {
             .collect_vec();
     }
 
-    pub fn add_time_shifts(&mut self, time_shifts: Vec<MeasureTimeShift>) {
-        for ts in time_shifts.into_iter() {
-            if let Some(exists) = self.time_shifts.get_mut(&ts.dimension.full_name()) {
-                exists.interval += ts.interval;
-            } else {
-                self.time_shifts.insert(ts.dimension.full_name(), ts);
+    pub fn add_time_shifts(&mut self, time_shifts: MeasureTimeShifts) {
+        match time_shifts {
+            MeasureTimeShifts::Dimensions(dimensions) => {
+                for ts in dimensions.into_iter() {
+                    if let Some(exists) = self
+                        .time_shifts
+                        .dimensions_shifts
+                        .get_mut(&ts.dimension.full_name())
+                    {
+                        exists.interval += ts.interval;
+                    } else {
+                        self.time_shifts
+                            .dimensions_shifts
+                            .insert(ts.dimension.full_name(), ts);
+                    }
+                }
+            }
+            MeasureTimeShifts::Common(interval) => {
+                if let Some(common) = self.time_shifts.common_time_shift.as_mut() {
+                    *common += interval;
+                } else {
+                    self.time_shifts.common_time_shift = Some(interval);
+                }
             }
         }
     }
 
-    pub fn time_shifts(&self) -> &HashMap<String, MeasureTimeShift> {
+    pub fn time_shifts(&self) -> &TimeShiftState {
         &self.time_shifts
     }
 
@@ -314,7 +343,8 @@ impl PartialEq for MultiStageAppliedState {
             && self.time_dimensions_filters == other.time_dimensions_filters
             && self.dimensions_filters == other.dimensions_filters
             && self.measures_filters == other.measures_filters
-            && self.time_shifts == other.time_shifts
+            && self.time_shifts.common_time_shift == other.time_shifts.common_time_shift
+            && self.time_shifts.dimensions_shifts == other.time_shifts.dimensions_shifts
     }
 }
 

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

@@ -1,4 +1,4 @@
-use crate::planner::sql_evaluator::{MeasureTimeShift, MemberSymbol};
+use crate::planner::sql_evaluator::{MeasureTimeShifts, MemberSymbol};
 use crate::planner::BaseTimeDimension;
 use std::rc::Rc;
 
@@ -99,7 +99,7 @@ pub struct MultiStageInodeMember {
     reduce_by: Vec<Rc<MemberSymbol>>,
     add_group_by: Vec<Rc<MemberSymbol>>,
     group_by: Option<Vec<Rc<MemberSymbol>>>,
-    time_shifts: Vec<MeasureTimeShift>,
+    time_shift: Option<MeasureTimeShifts>,
 }
 
 impl MultiStageInodeMember {
@@ -108,14 +108,14 @@ impl MultiStageInodeMember {
         reduce_by: Vec<Rc<MemberSymbol>>,
         add_group_by: Vec<Rc<MemberSymbol>>,
         group_by: Option<Vec<Rc<MemberSymbol>>>,
-        time_shifts: Vec<MeasureTimeShift>,
+        time_shift: Option<MeasureTimeShifts>,
     ) -> Self {
         Self {
             inode_type,
             reduce_by,
             add_group_by,
             group_by,
-            time_shifts,
+            time_shift,
         }
     }
 
@@ -149,8 +149,8 @@ impl MultiStageInodeMember {
         &self.group_by
     }
 
-    pub fn time_shifts(&self) -> &Vec<MeasureTimeShift> {
-        &self.time_shifts
+    pub fn time_shift(&self) -> &Option<MeasureTimeShifts> {
+        &self.time_shift
     }
 }
 

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

@@ -5,7 +5,7 @@ mod multi_stage_query_planner;
 mod query_description;
 mod rolling_window_planner;
 
-pub use applied_state::MultiStageAppliedState;
+pub use applied_state::*;
 pub use member::*;
 pub use member_query_planner::MultiStageMemberQueryPlanner;
 pub use multi_stage_query_planner::MultiStageQueryPlanner;

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

@@ -124,7 +124,7 @@ impl MultiStageQueryPlanner {
                 MultiStageInodeMemberType::Calculate
             };
 
-            let time_shifts = measure.time_shifts();
+            let time_shift = measure.time_shift();
 
             let is_ungrupped = match &member_type {
                 MultiStageInodeMemberType::Rank | MultiStageInodeMemberType::Calculate => true,
@@ -146,7 +146,7 @@ impl MultiStageQueryPlanner {
                     reduce_by,
                     add_group_by,
                     group_by,
-                    time_shifts,
+                    time_shift,
                 ),
                 is_ungrupped,
             )
@@ -157,7 +157,7 @@ impl MultiStageQueryPlanner {
                     vec![],
                     vec![],
                     None,
-                    vec![],
+                    None,
                 ),
                 self.query_properties.ungrouped(),
             )
@@ -222,15 +222,15 @@ impl MultiStageQueryPlanner {
                 .collect::<Result<Vec<_>, _>>()?;
 
             let new_state = if !dimensions_to_add.is_empty()
-                || !multi_stage_member.time_shifts().is_empty()
+                || multi_stage_member.time_shift().is_some()
                 || state.has_filters_for_member(&member_name)
             {
                 let mut new_state = state.clone_state();
                 if !dimensions_to_add.is_empty() {
                     new_state.add_dimensions(dimensions_to_add);
                 }
-                if !multi_stage_member.time_shifts().is_empty() {
-                    new_state.add_time_shifts(multi_stage_member.time_shifts().clone());
+                if let Some(time_shift) = multi_stage_member.time_shift() {
+                    new_state.add_time_shifts(time_shift.clone());
                 }
                 if state.has_filters_for_member(&member_name) {
                     new_state.remove_filter_for_member(&member_name);

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

@@ -127,7 +127,7 @@ impl RollingWindowPlanner {
                     vec![],
                     vec![],
                     None,
-                    vec![],
+                    None,
                 );
 
                 let description = MultiStageQueryDescription::new(