in work

Author: waralexrom

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

@@ -316,6 +316,10 @@ describe('SQL Generation', () => {
             }
           }
         },
+        created_month: {
+          type: 'time',
+          sql: \`\${created_at.month}\`
+        },
         updated_at: {
           type: 'time',
           sql: 'updated_at'
@@ -1343,6 +1347,33 @@ SELECT 1 AS revenue,  cast('2024-01-01' AS timestamp) as time UNION ALL
     });
   }
 
+  if (getEnv('nativeSqlPlanner')) {
+    it('rolling count proxy time dimension', async () => {
+      await runQueryTest({
+        measures: [
+          'visitors.countRollingThreeMonth'
+        ],
+        dimensions: [
+          'visitors.created_month'
+        ],
+        order: [{
+          id: 'visitors.created_month'
+        }],
+        timezone: 'America/Los_Angeles'
+      }, [
+        { visitors__created_month: '2016-09-01T00:00:00.000Z', visitors__count_rolling_three_month: '1' },
+        { visitors__created_month: '2016-10-01T00:00:00.000Z', visitors__count_rolling_three_month: '1' },
+        { visitors__created_month: '2016-11-01T00:00:00.000Z', visitors__count_rolling_three_month: '1' },
+        { visitors__created_month: '2016-12-01T00:00:00.000Z', visitors__count_rolling_three_month: null },
+        { visitors__created_month: '2017-01-01T00:00:00.000Z', visitors__count_rolling_three_month: '5' },
+      ]);
+    });
+  } else {
+    it.skip('rolling count without date range', () => {
+      // Skipping because it works only in Tesseract
+    });
+  }
+
   it('rolling qtd', async () => runQueryTest({
     measures: [
       'visitors.revenue_qtd'

rust/cubesqlplanner/cubesqlplanner/src/plan/time_series.rs

@@ -1,9 +1,5 @@
 use super::{Schema, SchemaColumn};
-use crate::planner::{
-    query_tools::QueryTools,
-    sql_templates::PlanSqlTemplates,
-    Granularity,
-};
+use crate::planner::{query_tools::QueryTools, sql_templates::PlanSqlTemplates, Granularity};
 use cubenativeutils::CubeError;
 use std::rc::Rc;
 

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

@@ -63,6 +63,36 @@ impl BaseMember for BaseTimeDimension {
 }
 
 impl BaseTimeDimension {
+    pub fn try_new_from_td_symbol(
+        query_tools: Rc<QueryTools>,
+        td_symbol: &TimeDimensionSymbol,
+    ) -> Result<Rc<Self>, CubeError> {
+        let dimension =
+            BaseDimension::try_new_required(td_symbol.base_symbol().clone(), query_tools.clone())?;
+        let granularity = td_symbol.granularity().clone();
+        let granularity_obj = td_symbol.granularity_obj().clone();
+        let date_range = td_symbol.date_range_vec();
+        let alias_suffix = td_symbol.alias_suffix();
+        let default_alias = BaseMemberHelper::default_alias(
+            &dimension.cube_name(),
+            &dimension.name(),
+            &Some(alias_suffix.clone()),
+            query_tools.clone(),
+        )?;
+        let member_evaluator = Rc::new(MemberSymbol::TimeDimension(td_symbol.clone()));
+
+        Ok(Rc::new(Self {
+            dimension,
+            query_tools,
+            granularity,
+            granularity_obj,
+            date_range,
+            alias_suffix,
+            default_alias,
+            member_evaluator,
+        }))
+    }
+
     pub fn try_new_required(
         query_tools: Rc<QueryTools>,
         member_evaluator: Rc<MemberSymbol>,

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

@@ -117,6 +117,10 @@ impl MultiStageAppliedState {
         self.time_dimensions = time_dimensions;
     }
 
+    pub fn set_dimensions(&mut self, dimensions: Vec<Rc<BaseDimension>>) {
+        self.dimensions = dimensions;
+    }
+
     pub fn remove_filter_for_member(&mut self, member_name: &String) {
         self.time_dimensions_filters =
             self.extract_filters_exclude_member(member_name, &self.time_dimensions_filters);

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

@@ -51,7 +51,18 @@ impl RollingWindowPlanner {
                     }
                     _ => false,
                 };
-                let time_dimensions = self.query_properties.time_dimensions();
+                let mut time_dimensions = self.query_properties.time_dimensions().clone();
+                for dim in self.query_properties.dimension_symbols() {
+                    let dim = dim.resolve_reference_chain();
+                    if let Ok(time_dimension_symbol) = dim.as_time_dimension() {
+                        let time_dimension = BaseTimeDimension::try_new_from_td_symbol(
+                            self.query_tools.clone(),
+                            time_dimension_symbol,
+                        )?;
+                        time_dimensions.push(time_dimension);
+                    }
+                }
+
                 if time_dimensions.len() == 0 {
                     let rolling_base = self.add_rolling_window_base(
                         member.clone(),
@@ -358,6 +369,19 @@ impl RollingWindowPlanner {
         //We keep only one time_dimension in the leaf query because, even if time_dimension values have different granularity, in the leaf query we need to group by the lowest granularity.
         new_state.set_time_dimensions(vec![new_time_dimension.clone()]);
 
+        let dimensions = new_state
+            .dimensions()
+            .clone()
+            .into_iter()
+            .filter(|d| {
+                d.member_evaluator()
+                    .resolve_reference_chain()
+                    .as_time_dimension()
+                    .is_err()
+            })
+            .collect_vec();
+        new_state.set_dimensions(dimensions);
+
         if let Some(granularity) = self.get_to_date_rolling_granularity(rolling_window)? {
             new_state.replace_to_date_date_range_filter(&time_dimension_base_name, &granularity);
         } else {

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

@@ -68,6 +68,10 @@ impl TimeDimensionSymbol {
         self.base_symbol.owned_by_cube()
     }
 
+    pub fn date_range_vec(&self) -> Option<Vec<String>> {
+        self.date_range.clone().map(|(from, to)| vec![from, to])
+    }
+
     pub fn get_dependencies_as_time_dimensions(&self) -> Vec<Rc<MemberSymbol>> {
         self.get_dependencies()
             .into_iter()