Use Granularity obj in ToDateRollingWindowJoinCondition

Author: KSDaemon

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

@@ -1,6 +1,7 @@
 use crate::logical_plan::*;
 use crate::planner::query_properties::OrderByItem;
 use crate::planner::sql_evaluator::MemberSymbol;
+use crate::planner::Granularity;
 use std::rc::Rc;
 
 pub struct MultiStageRegularRollingWindow {
@@ -24,14 +25,17 @@ impl PrettyPrint for MultiStageRegularRollingWindow {
 }
 
 pub struct MultiStageToDateRollingWindow {
-    pub granularity: String,
+    pub granularity_obj: Rc<Granularity>,
 }
 
 impl PrettyPrint for MultiStageToDateRollingWindow {
     fn pretty_print(&self, result: &mut PrettyPrintResult, state: &PrettyPrintState) {
         result.println("ToDate Rolling Window", state);
         let state = state.new_level();
-        result.println(&format!("granularity: {}", self.granularity), &state);
+        result.println(
+            &format!("granularity: {}", self.granularity_obj.granularity()),
+            &state,
+        );
     }
 }
 

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

@@ -1061,7 +1061,7 @@ impl PhysicalPlanBuilder {
             MultiStageRollingWindowType::ToDate(to_date_rolling_window) => {
                 JoinCondition::new_to_date_rolling_join(
                     root_alias.clone(),
-                    to_date_rolling_window.granularity.clone(),
+                    to_date_rolling_window.granularity_obj.clone(),
                     Expr::Reference(QualifiedColumnName::new(
                         Some(measure_input_alias.clone()),
                         base_time_dimension_alias,
@@ -1092,7 +1092,7 @@ impl PhysicalPlanBuilder {
         let mut render_references = HashMap::new();
         let mut select_builder = SelectBuilder::new(from.clone());
 
-        //We insert render reference for main time dimension (with the some granularity as in time series to avoid unnecessary date_tranc)
+        //We insert render reference for main time dimension (with some granularity as in time series to avoid unnecessary date_tranc)
         render_references.insert(
             time_dimension.full_name(),
             QualifiedColumnName::new(Some(root_alias.clone()), format!("date_from")),

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

@@ -1,7 +1,7 @@
 use super::{Expr, SingleAliasedSource};
 use crate::planner::query_tools::QueryTools;
 use crate::planner::sql_templates::PlanSqlTemplates;
-use crate::planner::{BaseJoinCondition, VisitorContext};
+use crate::planner::{BaseJoinCondition, Granularity, VisitorContext};
 use cubenativeutils::CubeError;
 use lazy_static::lazy_static;
 
@@ -118,15 +118,15 @@ impl RollingTotalJoinCondition {
 }
 pub struct ToDateRollingWindowJoinCondition {
     time_series_source: String,
-    granularity: String,
+    granularity: Rc<Granularity>,
     time_dimension: Expr,
     _query_tools: Rc<QueryTools>,
 }
 
 impl ToDateRollingWindowJoinCondition {
     pub fn new(
         time_series_source: String,
-        granularity: String,
+        granularity: Rc<Granularity>,
         time_dimension: Expr,
         query_tools: Rc<QueryTools>,
     ) -> Self {
@@ -151,7 +151,7 @@ impl ToDateRollingWindowJoinCondition {
             templates.column_reference(&Some(self.time_series_source.clone()), "date_from")?;
         let date_from = templates.rolling_window_expr_timestamp_cast(&date_from)?;
         let date_to = templates.rolling_window_expr_timestamp_cast(&date_to)?;
-        let grouped_from = templates.time_grouped_column(self.granularity.clone(), date_from)?;
+        let grouped_from = self.granularity.apply_to_input_sql(templates, date_from)?;
         let result = format!("{date_column} >= {grouped_from} and {date_column} <= {date_to}");
         Ok(result)
     }
@@ -243,7 +243,7 @@ impl JoinCondition {
 
     pub fn new_to_date_rolling_join(
         time_series_source: String,
-        granularity: String,
+        granularity: Rc<Granularity>,
         time_dimension: Expr,
         query_tools: Rc<QueryTools>,
     ) -> Self {

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

@@ -6,7 +6,9 @@ use crate::logical_plan::*;
 use crate::planner::planners::{multi_stage::RollingWindowType, QueryPlanner, SimpleQueryPlanner};
 use crate::planner::query_tools::QueryTools;
 use crate::planner::sql_evaluator::MemberSymbol;
-use crate::planner::{BaseDimension, BaseMeasure, BaseMember, BaseMemberHelper, BaseTimeDimension};
+use crate::planner::{
+    BaseDimension, BaseMeasure, BaseMember, BaseMemberHelper, BaseTimeDimension, GranularityHelper,
+};
 use crate::planner::{OrderByItem, QueryProperties};
 
 use cubenativeutils::CubeError;
@@ -126,8 +128,30 @@ impl MultiStageMemberQueryPlanner {
                 })
             }
             RollingWindowType::ToDate(to_date_rolling_window) => {
+                let time_dimension = &rolling_window_desc.time_dimension;
+                let query_granularity = to_date_rolling_window.granularity.clone();
+
+                let evaluator_compiler_cell = self.query_tools.evaluator_compiler().clone();
+                let mut evaluator_compiler = evaluator_compiler_cell.borrow_mut();
+
+                let Some(granularity_obj) = GranularityHelper::make_granularity_obj(
+                    self.query_tools.cube_evaluator().clone(),
+                    &mut evaluator_compiler,
+                    self.query_tools.timezone().clone(),
+                    time_dimension.cube_name(),
+                    time_dimension.name(),
+                    Some(query_granularity.clone()),
+                )?
+                else {
+                    return Err(CubeError::internal(format!(
+                        "Rolling window granularity '{}' is not found in time dimension '{}'",
+                        query_granularity,
+                        time_dimension.name()
+                    )));
+                };
+
                 MultiStageRollingWindowType::ToDate(MultiStageToDateRollingWindow {
-                    granularity: to_date_rolling_window.granularity.clone(),
+                    granularity_obj: Rc::new(granularity_obj),
                 })
             }
             RollingWindowType::RunningTotal => MultiStageRollingWindowType::RunningTotal,

rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/time_dimension.rs

@@ -62,30 +62,7 @@ impl SqlNode for TimeDimensionNode {
                         templates.convert_tz(input_sql)?
                     };
 
-                    let res = if granularity_obj.is_natural_aligned() {
-                        if let Some(granularity_offset) = granularity_obj.granularity_offset() {
-                            let dt = templates
-                                .subtract_interval(converted_tz, granularity_offset.clone())?;
-                            let dt = templates.time_grouped_column(
-                                granularity_obj.granularity_from_interval()?,
-                                dt,
-                            )?;
-                            templates.add_interval(dt, granularity_offset.clone())?
-                        } else {
-                            templates.time_grouped_column(
-                                granularity_obj.granularity().clone(),
-                                converted_tz,
-                            )?
-                        }
-                    } else {
-                        templates.date_bin(
-                            granularity_obj.granularity_interval().clone(),
-                            converted_tz,
-                            granularity_obj.origin_local_formatted(),
-                        )?
-                    };
-
-                    res
+                    granularity_obj.apply_to_input_sql(templates, converted_tz)?
                 } else {
                     input_sql
                 };