done

waralexrom · waralexrom · commit 4b0fb66cbce4 · 2025-07-03T13:49:44.000+02:00
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/logical_plan/multistage/common.rs b/rust/cubesqlplanner/cubesqlplanner/src/logical_plan/multistage/common.rs
@@ -53,9 +53,6 @@ impl PrettyPrint for MultiStageAppliedState {
         }
 
         result.println("time_shifts:", &state);
-        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!(
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/logical_plan/multistage/leaf_measure.rs b/rust/cubesqlplanner/cubesqlplanner/src/logical_plan/multistage/leaf_measure.rs
@@ -1,14 +1,13 @@
 use crate::logical_plan::*;
 use crate::planner::planners::multi_stage::TimeShiftState;
-use crate::planner::sql_evaluator::{DimensionTimeShift, MemberSymbol};
-use std::collections::HashMap;
+use crate::planner::sql_evaluator::MemberSymbol;
 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, DimensionTimeShift>,
+    pub time_shifts: TimeShiftState,
     pub query: Rc<Query>,
 }
 
@@ -26,7 +25,7 @@ impl PrettyPrint for MultiStageLeafMeasure {
         if !self.time_shifts.is_empty() {
             result.println("time_shifts:", &state);
             let details_state = state.new_level();
-            for (_, time_shift) in self.time_shifts.iter() {
+            for (_, time_shift) in self.time_shifts.dimensions_shifts.iter() {
                 result.println(
                     &format!(
                         "- {}: {}",
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/physical_plan_builder/builder.rs b/rust/cubesqlplanner/cubesqlplanner/src/physical_plan_builder/builder.rs
@@ -5,7 +5,6 @@ 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;
@@ -25,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, DimensionTimeShift>,
+    pub time_shifts: TimeShiftState,
     pub original_sql_pre_aggregations: HashMap<String, String>,
 }
 
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multi_stage/applied_state.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multi_stage/applied_state.rs
@@ -1,7 +1,7 @@
 use crate::plan::{FilterGroup, FilterItem};
 use crate::planner::filter::FilterOperator;
 use crate::planner::sql_evaluator::{DimensionTimeShift, MeasureTimeShifts, MemberSymbol};
-use crate::planner::{BaseDimension, BaseMember, BaseTimeDimension, SqlInterval};
+use crate::planner::{BaseDimension, BaseMember, BaseTimeDimension};
 use itertools::Itertools;
 use std::cmp::PartialEq;
 use std::collections::HashMap;
@@ -11,12 +11,11 @@ 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()
+        self.dimensions_shifts.is_empty()
     }
 }
 
@@ -74,28 +73,28 @@ impl MultiStageAppliedState {
     }
 
     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);
-                }
+        let resolved_shifts = match time_shifts {
+            MeasureTimeShifts::Dimensions(dimensions) => dimensions,
+            MeasureTimeShifts::Common(interval) => self
+                .all_time_members()
+                .into_iter()
+                .map(|m| DimensionTimeShift {
+                    interval: interval.clone(),
+                    dimension: m,
+                })
+                .collect_vec(),
+        };
+        for ts in resolved_shifts.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);
             }
         }
     }
@@ -104,24 +103,6 @@ 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
@@ -151,6 +132,7 @@ impl MultiStageAppliedState {
                     None
                 }
             })
+            .unique_by(|s| s.full_name())
             .collect_vec();
         time_symbols
     }
@@ -402,7 +384,6 @@ 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.common_time_shift == other.time_shifts.common_time_shift
             && self.time_shifts.dimensions_shifts == other.time_shifts.dimensions_shifts
     }
 }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multi_stage/member_query_planner.rs b/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().resolved_time_shifts(),
+            time_shifts: self.description.state().time_shifts().clone(),
             render_measure_for_ungrouped: self.description.member().is_ungrupped(),
         };
         let result = LogicalMultiStageMember {
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/factory.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/factory.rs
@@ -7,13 +7,12 @@ 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: HashMap<String, DimensionTimeShift>,
+    time_shifts: TimeShiftState,
     ungrouped: bool,
     ungrouped_measure: bool,
     count_approx_as_state: bool,
@@ -34,7 +33,7 @@ pub struct SqlNodesFactory {
 impl SqlNodesFactory {
     pub fn new() -> Self {
         Self {
-            time_shifts: HashMap::new(),
+            time_shifts: TimeShiftState::default(),
             ungrouped: false,
             ungrouped_measure: false,
             count_approx_as_state: false,
@@ -53,7 +52,7 @@ impl SqlNodesFactory {
         }
     }
 
-    pub fn set_time_shifts(&mut self, time_shifts: HashMap<String, DimensionTimeShift>) {
+    pub fn set_time_shifts(&mut self, time_shifts: TimeShiftState) {
         self.time_shifts = time_shifts;
     }
 
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/time_shift.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/time_shift.rs
@@ -1,23 +1,20 @@
 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: HashMap<String, DimensionTimeShift>,
+    shifts: TimeShiftState,
     input: Rc<dyn SqlNode>,
 }
 
 impl TimeShiftSqlNode {
-    pub fn new(shifts: HashMap<String, DimensionTimeShift>, input: Rc<dyn SqlNode>) -> Rc<Self> {
+    pub fn new(shifts: TimeShiftState, input: Rc<dyn SqlNode>) -> Rc<Self> {
         Rc::new(Self { shifts, input })
     }
 
@@ -45,7 +42,7 @@ impl SqlNode for TimeShiftSqlNode {
         let res = match node.as_ref() {
             MemberSymbol::Dimension(ev) => {
                 if !ev.is_reference() && ev.dimension_type() == "time" {
-                    if let Some(shift) = self.shifts.get(&ev.full_name()) {
+                    if let Some(shift) = self.shifts.dimensions_shifts.get(&ev.full_name()) {
                         let shift = shift.interval.to_sql();
                         let res = templates.add_timestamp_interval(input, shift)?;
                         format!("({})", res)

Original file line number	Diff line number	Diff line change
`@@ -53,9 +53,6 @@ impl PrettyPrint for MultiStageAppliedState {`
`53`	`53`	`}`
`54`	`54`
`55`	`55`	`result.println("time_shifts:", &state);`
`56`		`- if let Some(common) = &self.time_shifts().common_time_shift {`
`57`		`- result.println(&format!("- common: {}", common.to_sql()), &details_state);`
`58`		`- }`
`59`	`56`	`for (_, time_shift) in self.time_shifts().dimensions_shifts.iter() {`
`60`	`57`	`result.println(`
`61`	`58`	`&format!(`