fix(tesseract): Support rolling window with multiple granularities

packages/cubejs-schema-compiler/test/integration/postgres/sql-generation.test.ts

@@ -902,7 +902,7 @@ SELECT 1 AS revenue,  cast('2024-01-01' AS timestamp) as time UNION ALL
     timeDimensions: [
       {
         dimension: 'visitors.created_at',
-        granularity: 'three_days',
+        granularity: 'month',
         dateRange: ['2017-01-01', '2017-01-10']
       },
       {
@@ -919,52 +919,52 @@ SELECT 1 AS revenue,  cast('2024-01-01' AS timestamp) as time UNION ALL
     {
       visitors__count_rolling_week_to_date: null,
       visitors__created_at_day: '2017-01-01T00:00:00.000Z',
-      visitors__created_at_three_days: '2017-01-01T00:00:00.000Z',
+      visitors__created_at_month: '2017-01-01T00:00:00.000Z',
     },
     {
       visitors__count_rolling_week_to_date: '1',
       visitors__created_at_day: '2017-01-02T00:00:00.000Z',
-      visitors__created_at_three_days: '2017-01-01T00:00:00.000Z',
+      visitors__created_at_month: '2017-01-01T00:00:00.000Z',
     },
     {
       visitors__count_rolling_week_to_date: '1',
       visitors__created_at_day: '2017-01-03T00:00:00.000Z',
-      visitors__created_at_three_days: '2017-01-01T00:00:00.000Z',
+      visitors__created_at_month: '2017-01-01T00:00:00.000Z',
     },
     {
       visitors__count_rolling_week_to_date: '2',
       visitors__created_at_day: '2017-01-04T00:00:00.000Z',
-      visitors__created_at_three_days: '2017-01-04T00:00:00.000Z',
+      visitors__created_at_month: '2017-01-01T00:00:00.000Z',
     },
     {
       visitors__count_rolling_week_to_date: '3',
       visitors__created_at_day: '2017-01-05T00:00:00.000Z',
-      visitors__created_at_three_days: '2017-01-04T00:00:00.000Z',
+      visitors__created_at_month: '2017-01-01T00:00:00.000Z',
     },
     {
       visitors__count_rolling_week_to_date: '5',
       visitors__created_at_day: '2017-01-06T00:00:00.000Z',
-      visitors__created_at_three_days: '2017-01-04T00:00:00.000Z',
+      visitors__created_at_month: '2017-01-01T00:00:00.000Z',
     },
     {
       visitors__count_rolling_week_to_date: '5',
       visitors__created_at_day: '2017-01-07T00:00:00.000Z',
-      visitors__created_at_three_days: '2017-01-07T00:00:00.000Z',
+      visitors__created_at_month: '2017-01-01T00:00:00.000Z',
     },
     {
       visitors__count_rolling_week_to_date: '5',
       visitors__created_at_day: '2017-01-08T00:00:00.000Z',
-      visitors__created_at_three_days: '2017-01-07T00:00:00.000Z',
+      visitors__created_at_month: '2017-01-01T00:00:00.000Z',
     },
     {
       visitors__count_rolling_week_to_date: null,
       visitors__created_at_day: '2017-01-09T00:00:00.000Z',
-      visitors__created_at_three_days: '2017-01-07T00:00:00.000Z',
+      visitors__created_at_month: '2017-01-01T00:00:00.000Z',
     },
     {
       visitors__count_rolling_week_to_date: null,
       visitors__created_at_day: '2017-01-10T00:00:00.000Z',
-      visitors__created_at_three_days: '2017-01-10T00:00:00.000Z',
+      visitors__created_at_month: '2017-01-01T00:00:00.000Z',
     }
   ]));
 
@@ -976,12 +976,12 @@ SELECT 1 AS revenue,  cast('2024-01-01' AS timestamp) as time UNION ALL
     timeDimensions: [
       {
         dimension: 'visitors.created_at',
-        granularity: 'three_days',
+        granularity: 'day',
         dateRange: ['2017-01-01', '2017-01-10']
       },
       {
         dimension: 'visitors.created_at',
-        granularity: 'day',
+        granularity: 'week',
         dateRange: ['2017-01-01', '2017-01-10']
       }
     ],
@@ -994,61 +994,61 @@ SELECT 1 AS revenue,  cast('2024-01-01' AS timestamp) as time UNION ALL
       visitors__count_rolling_unbounded: '1',
       visitors__count_rolling_week_to_date: null,
       visitors__created_at_day: '2017-01-01T00:00:00.000Z',
-      visitors__created_at_three_days: '2017-01-01T00:00:00.000Z',
+      visitors__created_at_week: '2016-12-26T00:00:00.000Z',
     },
     {
       visitors__count_rolling_unbounded: '2',
       visitors__count_rolling_week_to_date: '1',
-      visitors__created_at_day: '2017-01-03T00:00:00.000Z',
-      visitors__created_at_three_days: '2017-01-01T00:00:00.000Z',
+      visitors__created_at_day: '2017-01-02T00:00:00.000Z',
+      visitors__created_at_week: '2017-01-02T00:00:00.000Z',
     },
     {
       visitors__count_rolling_unbounded: '2',
       visitors__count_rolling_week_to_date: '1',
-      visitors__created_at_day: '2017-01-02T00:00:00.000Z',
-      visitors__created_at_three_days: '2017-01-01T00:00:00.000Z',
+      visitors__created_at_day: '2017-01-03T00:00:00.000Z',
+      visitors__created_at_week: '2017-01-02T00:00:00.000Z',
     },
     {
       visitors__count_rolling_unbounded: '3',
       visitors__count_rolling_week_to_date: '2',
       visitors__created_at_day: '2017-01-04T00:00:00.000Z',
-      visitors__created_at_three_days: '2017-01-04T00:00:00.000Z',
+      visitors__created_at_week: '2017-01-02T00:00:00.000Z',
     },
     {
       visitors__count_rolling_unbounded: '4',
       visitors__count_rolling_week_to_date: '3',
       visitors__created_at_day: '2017-01-05T00:00:00.000Z',
-      visitors__created_at_three_days: '2017-01-04T00:00:00.000Z',
+      visitors__created_at_week: '2017-01-02T00:00:00.000Z',
     },
     {
       visitors__count_rolling_unbounded: '6',
       visitors__count_rolling_week_to_date: '5',
       visitors__created_at_day: '2017-01-06T00:00:00.000Z',
-      visitors__created_at_three_days: '2017-01-04T00:00:00.000Z',
+      visitors__created_at_week: '2017-01-02T00:00:00.000Z',
     },
     {
       visitors__count_rolling_unbounded: '6',
       visitors__count_rolling_week_to_date: '5',
-      visitors__created_at_day: '2017-01-08T00:00:00.000Z',
-      visitors__created_at_three_days: '2017-01-07T00:00:00.000Z',
+      visitors__created_at_day: '2017-01-07T00:00:00.000Z',
+      visitors__created_at_week: '2017-01-02T00:00:00.000Z',
     },
     {
       visitors__count_rolling_unbounded: '6',
       visitors__count_rolling_week_to_date: '5',
-      visitors__created_at_day: '2017-01-07T00:00:00.000Z',
-      visitors__created_at_three_days: '2017-01-07T00:00:00.000Z',
+      visitors__created_at_day: '2017-01-08T00:00:00.000Z',
+      visitors__created_at_week: '2017-01-02T00:00:00.000Z',
     },
     {
       visitors__count_rolling_unbounded: '6',
       visitors__count_rolling_week_to_date: null,
       visitors__created_at_day: '2017-01-09T00:00:00.000Z',
-      visitors__created_at_three_days: '2017-01-07T00:00:00.000Z',
+      visitors__created_at_week: '2017-01-09T00:00:00.000Z',
     },
     {
       visitors__count_rolling_unbounded: '6',
       visitors__count_rolling_week_to_date: null,
       visitors__created_at_day: '2017-01-10T00:00:00.000Z',
-      visitors__created_at_three_days: '2017-01-10T00:00:00.000Z',
+      visitors__created_at_week: '2017-01-09T00:00:00.000Z',
     }
   ]));
 

rust/cubesqlplanner/cubesqlplanner/src/plan/join.rs

@@ -88,6 +88,31 @@ impl RegularRollingWindowJoinCondition {
     }
 }
 
+pub struct RollingTotalJoinCondition {
+    time_series_source: String,
+    time_dimension: Expr,
+}
+
+impl RollingTotalJoinCondition {
+    pub fn new(time_series_source: String, time_dimension: Expr) -> Self {
+        Self {
+            time_series_source,
+            time_dimension,
+        }
+    }
+
+    pub fn to_sql(
+        &self,
+        templates: &PlanSqlTemplates,
+        context: Rc<VisitorContext>,
+    ) -> Result<String, CubeError> {
+        let date_column = self.time_dimension.to_sql(templates, context)?;
+        let date_to =
+            templates.column_reference(&Some(self.time_series_source.clone()), "date_to")?;
+        let result = format!("{date_column} <= {date_to}");
+        Ok(result)
+    }
+}
 pub struct ToDateRollingWindowJoinCondition {
     time_series_source: String,
     granularity: String,
@@ -117,8 +142,6 @@ impl ToDateRollingWindowJoinCondition {
     ) -> Result<String, CubeError> {
         let date_column = self.time_dimension.to_sql(templates, context)?;
 
-        //(dateFrom, dateTo, dateField, dimensionDateFrom, dimensionDateTo, isFromStartToEnd) => `${dateField} >= ${this.timeGroupedColumn(granularity, dateFrom)} AND ${dateField} <= ${dateTo}`
-
         let date_from =
             templates.column_reference(&Some(self.time_series_source.clone()), "date_to")?;
         let date_to =
@@ -192,6 +215,7 @@ pub enum JoinCondition {
     BaseJoinCondition(Rc<dyn BaseJoinCondition>),
     RegularRollingWindowJoinCondition(RegularRollingWindowJoinCondition),
     ToDateRollingWindowJoinCondition(ToDateRollingWindowJoinCondition),
+    RollingTotalJoinCondition(RollingTotalJoinCondition),
 }
 
 impl JoinCondition {
@@ -229,6 +253,13 @@ impl JoinCondition {
         ))
     }
 
+    pub fn new_rolling_total_join(time_series_source: String, time_dimension: Expr) -> Self {
+        Self::RollingTotalJoinCondition(RollingTotalJoinCondition::new(
+            time_series_source,
+            time_dimension,
+        ))
+    }
+
     pub fn new_base_join(base: Rc<dyn BaseJoinCondition>) -> Self {
         Self::BaseJoinCondition(base)
     }
@@ -247,6 +278,7 @@ impl JoinCondition {
             JoinCondition::ToDateRollingWindowJoinCondition(cond) => {
                 cond.to_sql(templates, context)
             }
+            JoinCondition::RollingTotalJoinCondition(cond) => cond.to_sql(templates, context),
         }
     }
 }

rust/cubesqlplanner/cubesqlplanner/src/plan/mod.rs

@@ -16,7 +16,9 @@ pub use cte::Cte;
 pub use expression::{Expr, MemberExpression};
 pub use filter::{Filter, FilterGroup, FilterItem};
 pub use from::{From, FromSource, SingleAliasedSource, SingleSource};
-pub use join::{Join, JoinCondition, JoinItem, RegularRollingWindowJoinCondition};
+pub use join::{
+    Join, JoinCondition, JoinItem, RegularRollingWindowJoinCondition, RollingTotalJoinCondition,
+};
 pub use order::OrderBy;
 pub use query_plan::QueryPlan;
 pub use schema::{QualifiedColumnName, Schema, SchemaColumn};

rust/cubesqlplanner/cubesqlplanner/src/planner/base_time_dimension.rs

@@ -126,7 +126,7 @@ impl BaseTimeDimension {
         self.dimension.clone()
     }
 
-    pub fn member_evaluator(&self) -> Rc<MemberSymbol> {
+    pub fn base_member_evaluator(&self) -> Rc<MemberSymbol> {
         self.dimension.member_evaluator()
     }
 

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

@@ -273,19 +273,19 @@ impl BaseFilter {
         date: String,
         interval: &Option<String>,
         is_sub: bool,
-    ) -> Result<String, CubeError> {
+    ) -> Result<Option<String>, CubeError> {
         if let Some(interval) = interval {
             if interval != "unbounded" {
                 if is_sub {
-                    self.templates.sub_interval(date, interval.clone())
+                    Ok(Some(self.templates.sub_interval(date, interval.clone())?))
                 } else {
-                    self.templates.add_interval(date, interval.clone())
+                    Ok(Some(self.templates.add_interval(date, interval.clone())?))
                 }
             } else {
-                Ok(date.to_string())
+                Ok(None)
             }
         } else {
-            Ok(date.to_string())
+            Ok(Some(date.to_string()))
         }
     }
 
@@ -295,20 +295,29 @@ impl BaseFilter {
         let from = if self.values.len() >= 3 {
             self.extend_date_range_bound(from, &self.values[2], true)?
         } else {
-            from
+            Some(from)
         };
 
         let to = if self.values.len() >= 4 {
             self.extend_date_range_bound(to, &self.values[3], false)?
         } else {
-            to
+            Some(to)
         };
 
         let date_field = self
             .query_tools
             .base_tools()
             .convert_tz(member_sql.to_string())?;
-        self.templates.time_range_filter(date_field, from, to)
+        if let (Some(from), Some(to)) = (&from, &to) {
+            self.templates
+                .time_range_filter(date_field, from.clone(), to.clone())
+        } else if let Some(from) = &from {
+            self.templates.gte(date_field, from.clone())
+        } else if let Some(to) = &to {
+            self.templates.lte(date_field, to.clone())
+        } else {
+            self.templates.always_true()
+        }
     }
 
     fn to_date_rolling_window_date_range(&self, member_sql: &str) -> Result<String, CubeError> {

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

@@ -43,7 +43,7 @@ impl<'a> FilterCompiler<'a> {
         if let Some(date_range) = item.get_date_range() {
             let filter = BaseFilter::try_new(
                 self.query_tools.clone(),
-                item.member_evaluator(),
+                item.base_member_evaluator(),
                 FilterType::Dimension,
                 FilterOperator::InDateRange,
                 Some(date_range.into_iter().map(|v| Some(v)).collect()),

rust/cubesqlplanner/cubesqlplanner/src/planner/granularity_helper.rs

@@ -2,6 +2,9 @@ use cubenativeutils::CubeError;
 use itertools::Itertools;
 use lazy_static::lazy_static;
 use std::collections::HashMap;
+use std::rc::Rc;
+
+use super::BaseTimeDimension;
 
 pub struct GranularityHelper {}
 
@@ -41,6 +44,29 @@ impl GranularityHelper {
         }
     }
 
+    pub fn find_dimension_with_min_granularity(
+        dimensions: &Vec<Rc<BaseTimeDimension>>,
+    ) -> Result<Rc<BaseTimeDimension>, CubeError> {
+        if dimensions.is_empty() {
+            return Err(CubeError::internal(
+                "No dimensions provided for find_dimension_with_min_granularity".to_string(),
+            ));
+        }
+        let first = Ok(dimensions[0].clone());
+        dimensions.iter().skip(1).fold(first, |acc, d| match acc {
+            Ok(min_dim) => {
+                let min_granularity =
+                    Self::min_granularity(&min_dim.get_granularity(), &d.get_granularity())?;
+                if min_granularity == min_dim.get_granularity() {
+                    Ok(min_dim)
+                } else {
+                    Ok(d.clone())
+                }
+            }
+            Err(e) => Err(e),
+        })
+    }
+
     pub fn granularity_from_interval(interval: &Option<String>) -> Option<String> {
         if let Some(interval) = interval {
             if interval.find("day").is_some() {

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::planners::multi_stage::MultiStageTimeShift;
-use crate::planner::{BaseDimension, BaseTimeDimension};
+use crate::planner::{BaseDimension, BaseMember, BaseTimeDimension};
 use itertools::Itertools;
 use std::cmp::PartialEq;
 use std::collections::HashMap;
@@ -88,15 +88,19 @@ impl MultiStageAppliedState {
         &self.time_dimensions
     }
 
+    pub fn set_time_dimensions(&mut self, time_dimensions: Vec<Rc<BaseTimeDimension>>) {
+        self.time_dimensions = time_dimensions;
+    }
+
     pub fn change_time_dimension_granularity(
         &mut self,
-        dimension_name: &str,
+        time_dimension: &Rc<BaseTimeDimension>,
         new_granularity: Option<String>,
     ) {
         if let Some(time_dimension) = self
             .time_dimensions
             .iter_mut()
-            .find(|dim| dim.member_evaluator().full_name() == dimension_name)
+            .find(|dim| dim.full_name() == time_dimension.full_name())
         {
             *time_dimension = time_dimension.change_granularity(new_granularity);
         }