Initial support for named time shifts

Author: KSDaemon

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

@@ -15,7 +15,8 @@ use std::rc::Rc;
 
 #[derive(Serialize, Deserialize, Debug, PartialEq, Eq, Clone)]
 pub struct TimeShiftReference {
-    pub interval: String,
+    pub interval: Option<String>,
+    pub name: Option<String>,
     #[serde(rename = "type")]
     pub shift_type: Option<String>,
     #[serde(rename = "timeDimension")]

rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/timeshift_definition.rs

@@ -11,9 +11,10 @@ use std::rc::Rc;
 
 #[derive(Deserialize, Serialize, Clone, Debug, PartialEq, Eq, Hash)]
 pub struct TimeShiftDefinitionStatic {
-    pub interval: String,
+    pub interval: Option<String>,
     #[serde(rename = "type")]
-    pub timeshift_type: String,
+    pub timeshift_type: Option<String>,
+    pub name: Option<String>,
 }
 
 #[nativebridge::native_bridge(TimeShiftDefinitionStatic)]

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

@@ -58,7 +58,13 @@ impl PrettyPrint for MultiStageAppliedState {
                 &format!(
                     "- {}: {}",
                     time_shift.dimension.full_name(),
-                    time_shift.interval.to_sql()
+                    if let Some(interval) = &time_shift.interval {
+                        interval.to_sql()
+                    } else if let Some(name) = &time_shift.name {
+                        format!("{} (named)", name.to_string())
+                    } else {
+                        "None".to_string()
+                    }
                 ),
                 &details_state,
             );

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

@@ -30,7 +30,13 @@ impl PrettyPrint for MultiStageLeafMeasure {
                     &format!(
                         "- {}: {}",
                         time_shift.dimension.full_name(),
-                        time_shift.interval.to_sql()
+                        if let Some(interval) = &time_shift.interval {
+                            interval.to_sql()
+                        } else if let Some(name) = &time_shift.name {
+                            format!("{} (named)", name.to_string())
+                        } else {
+                            "None".to_string()
+                        }
                     ),
                     &details_state,
                 );

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

@@ -43,14 +43,24 @@ impl PhysicalPlanBuilderContext {
             .iter()
             .partition_map(|(key, shift)| {
                 if let Ok(dimension) = shift.dimension.as_dimension() {
-                    if let Some((dim_key, cts)) =
-                        dimension.calendar_time_shift_for_interval(&shift.interval)
-                    {
-                        return Either::Right((dim_key.clone(), cts.clone()));
-                    } else if let Some(calendar_pk) = dimension.time_shift_pk() {
-                        let mut shift = shift.clone();
-                        shift.interval = shift.interval.inverse();
-                        return Either::Left((calendar_pk.full_name(), shift.clone()));
+                    if let Some(dim_shift_name) = &shift.name {
+                        if let Some((dim_key, cts)) =
+                            dimension.calendar_time_shift_for_named_interval(dim_shift_name)
+                        {
+                            return Either::Right((dim_key.clone(), cts.clone()));
+                        } else if let Some(_calendar_pk) = dimension.time_shift_pk() {
+                            // TODO: Handle case when named shift is not found
+                        }
+                    } else if let Some(dim_shift_interval) = &shift.interval {
+                        if let Some((dim_key, cts)) =
+                            dimension.calendar_time_shift_for_interval(dim_shift_interval)
+                        {
+                            return Either::Right((dim_key.clone(), cts.clone()));
+                        } else if let Some(calendar_pk) = dimension.time_shift_pk() {
+                            let mut shift = shift.clone();
+                            shift.interval = Some(dim_shift_interval.inverse());
+                            return Either::Left((calendar_pk.full_name(), shift.clone()));
+                        }
                     }
                 }
                 Either::Left((key.clone(), shift.clone()))

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

@@ -2,6 +2,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};
+use cubenativeutils::CubeError;
 use itertools::Itertools;
 use std::cmp::PartialEq;
 use std::collections::HashMap;
@@ -72,15 +73,25 @@ impl MultiStageAppliedState {
             .collect_vec();
     }
 
-    pub fn add_time_shifts(&mut self, time_shifts: MeasureTimeShifts) {
+    pub fn add_time_shifts(&mut self, time_shifts: MeasureTimeShifts) -> Result<(), CubeError> {
         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(),
+                    interval: Some(interval.clone()),
                     dimension: m,
+                    name: None,
+                })
+                .collect_vec(),
+            MeasureTimeShifts::Named(named_shift) => self
+                .all_time_members()
+                .into_iter()
+                .map(|m| DimensionTimeShift {
+                    interval: None,
+                    dimension: m,
+                    name: Some(named_shift.clone()),
                 })
                 .collect_vec(),
         };
@@ -90,13 +101,41 @@ impl MultiStageAppliedState {
                 .dimensions_shifts
                 .get_mut(&ts.dimension.full_name())
             {
-                exists.interval += ts.interval;
+                if let Some(interval) = exists.interval.clone() {
+                    if let Some(new_interval) = ts.interval {
+                        exists.interval = Some(interval + new_interval);
+                    } else {
+                        return Err(CubeError::internal(format!(
+                            "Cannot use both named ({}) and interval ({}) shifts for the same dimension: {}.",
+                            ts.name.clone().unwrap_or("-".to_string()),
+                            interval.to_sql(),
+                            ts.dimension.full_name(),
+                        )));
+                    }
+                } else if let Some(named_shift) = exists.name.clone() {
+                    return if let Some(new_interval) = ts.interval {
+                        Err(CubeError::internal(format!(
+                            "Cannot use both named ({}) and interval ({}) shifts for the same dimension: {}.",
+                            named_shift,
+                            new_interval.to_sql(),
+                            ts.dimension.full_name(),
+                        )))
+                    } else {
+                        Err(CubeError::internal(format!(
+                            "Cannot use more than one named shifts ({}, {}) for the same dimension: {}.",
+                            ts.name.clone().unwrap_or("-".to_string()),
+                            named_shift,
+                            ts.dimension.full_name(),
+                        )))
+                    };
+                }
             } else {
                 self.time_shifts
                     .dimensions_shifts
                     .insert(ts.dimension.full_name(), ts);
             }
         }
+        Ok(())
     }
 
     pub fn time_shifts(&self) -> &TimeShiftState {

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

@@ -225,7 +225,7 @@ impl MultiStageQueryPlanner {
                     new_state.add_dimensions(dimensions_to_add);
                 }
                 if let Some(time_shift) = multi_stage_member.time_shift() {
-                    new_state.add_time_shifts(time_shift.clone());
+                    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/sql_evaluator/sql_nodes/time_shift.rs

@@ -43,7 +43,7 @@ impl SqlNode for TimeShiftSqlNode {
             MemberSymbol::Dimension(ev) => {
                 if !ev.is_reference() && ev.dimension_type() == "time" {
                     if let Some(shift) = self.shifts.dimensions_shifts.get(&ev.full_name()) {
-                        let shift = shift.interval.to_sql();
+                        let shift = shift.interval.clone().unwrap().to_sql(); // Common time shifts should always have an interval
                         let res = templates.add_timestamp_interval(input, shift)?;
                         format!("({})", res)
                     } else {

rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/dimension_symbol.rs

@@ -27,7 +27,8 @@ pub struct DimensionCaseDefinition {
 
 #[derive(Clone)]
 pub struct CalendarDimensionTimeShift {
-    pub interval: SqlInterval,
+    pub interval: Option<SqlInterval>,
+    pub name: Option<String>,
     pub sql: Option<Rc<SqlCall>>,
 }
 
@@ -229,11 +230,31 @@ impl DimensionSymbol {
         &self,
         interval: &SqlInterval,
     ) -> Option<(String, CalendarDimensionTimeShift)> {
-        if let Some(ts) = self
-            .time_shift
-            .iter()
-            .find(|shift| shift.interval == *interval)
-        {
+        if let Some(ts) = self.time_shift.iter().find(|shift| {
+            if let Some(s_i) = &shift.interval {
+                s_i == interval
+            } else {
+                false
+            }
+        }) {
+            if let Some(pk) = &self.time_shift_pk {
+                return Some((pk.full_name(), ts.clone()));
+            }
+        }
+        None
+    }
+
+    pub fn calendar_time_shift_for_named_interval(
+        &self,
+        interval_name: &String,
+    ) -> Option<(String, CalendarDimensionTimeShift)> {
+        if let Some(ts) = self.time_shift.iter().find(|shift| {
+            if let Some(s_n) = &shift.name {
+                s_n == interval_name
+            } else {
+                false
+            }
+        }) {
             if let Some(pk) = &self.time_shift_pk {
                 return Some((pk.full_name(), ts.clone()));
             }
@@ -362,18 +383,28 @@ impl SymbolFactory for DimensionSymbolFactory {
             time_shift
                 .iter()
                 .map(|item| -> Result<_, CubeError> {
-                    let interval = item.static_data().interval.parse::<SqlInterval>()?;
-                    let interval = if item.static_data().timeshift_type == "next" {
-                        -interval
-                    } else {
-                        interval
+                    let interval = match &item.static_data().interval {
+                        Some(raw) => {
+                            let mut iv = raw.parse::<SqlInterval>()?;
+                            if item.static_data().timeshift_type.as_deref() == Some("next") {
+                                iv = -iv;
+                            }
+
+                            Some(iv)
+                        }
+                        None => None,
                     };
+                    let name = item.static_data().name.clone();
                     let sql = if let Some(sql) = item.sql()? {
                         Some(compiler.compile_sql_call(&cube_name, sql)?)
                     } else {
                         None
                     };
-                    Ok(CalendarDimensionTimeShift { interval, sql })
+                    Ok(CalendarDimensionTimeShift {
+                        interval,
+                        name,
+                        sql,
+                    })
                 })
                 .collect::<Result<Vec<_>, _>>()?
         } else {

rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/measure_symbol.rs

@@ -38,13 +38,16 @@ impl MeasureOrderBy {
 
 #[derive(Clone, Debug)]
 pub struct DimensionTimeShift {
-    pub interval: SqlInterval,
+    pub interval: Option<SqlInterval>,
+    pub name: Option<String>,
     pub dimension: Rc<MemberSymbol>,
 }
 
 impl PartialEq for DimensionTimeShift {
     fn eq(&self, other: &Self) -> bool {
-        self.interval == other.interval && self.dimension.full_name() == other.dimension.full_name()
+        self.interval == other.interval
+            && self.dimension.full_name() == other.dimension.full_name()
+            && self.name == other.name
     }
 }
 
@@ -54,6 +57,7 @@ impl Eq for DimensionTimeShift {}
 pub enum MeasureTimeShifts {
     Dimensions(Vec<DimensionTimeShift>),
     Common(SqlInterval),
+    Named(String),
 }
 
 #[derive(Clone)]
@@ -567,19 +571,29 @@ impl SymbolFactory for MeasureSymbolFactory {
             let mut shifts: HashMap<String, DimensionTimeShift> = HashMap::new();
             let mut common_shift = None;
             for shift_ref in time_shift_references.iter() {
-                let interval = shift_ref.interval.parse::<SqlInterval>()?;
-                let interval =
-                    if shift_ref.shift_type.as_ref().unwrap_or(&format!("prior")) == "next" {
-                        -interval
-                    } else {
-                        interval
-                    };
+                let interval = match &shift_ref.interval {
+                    Some(raw) => {
+                        let mut iv = raw.parse::<SqlInterval>()?;
+                        if shift_ref
+                            .shift_type
+                            .as_deref()
+                            .unwrap_or("prior")
+                            == "next"
+                        {
+                            iv = -iv;
+                        }
+
+                        Some(iv)
+                    }
+                    None => None,
+                };
+                let name = shift_ref.name.clone();
                 if let Some(time_dimension) = &shift_ref.time_dimension {
                     let dimension = compiler.add_dimension_evaluator(time_dimension.clone())?;
                     let dimension = find_owned_by_cube_child(&dimension)?;
                     let dimension_name = dimension.full_name();
                     if let Some(exists) = shifts.get(&dimension_name) {
-                        if exists.interval != interval {
+                        if exists.interval != interval || exists.name != name {
                             return Err(CubeError::user(format!(
                                 "Different time shifts for one dimension {} not allowed",
                                 dimension_name
@@ -590,15 +604,16 @@ impl SymbolFactory for MeasureSymbolFactory {
                             dimension_name,
                             DimensionTimeShift {
                                 interval: interval.clone(),
+                                name: name.clone(),
                                 dimension: dimension.clone(),
                             },
                         );
                     };
                 } else {
                     if common_shift.is_none() {
-                        common_shift = Some(interval);
+                        common_shift = interval;
                     } else {
-                        if common_shift != Some(interval) {
+                        if common_shift != interval {
                             return Err(CubeError::user(format!(
                                     "Measure can contain only one common time_shift (without time_dimension).",
                                 )));