fix(tesseract): Dimnesions with granularity in group_by + drivers support

Author: waralexrom

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

@@ -302,6 +302,18 @@ describe('SQL Generation', () => {
           type: 'sum',
           group_by: [visitors.source]
         },
+        visitors_revenue_per_year: {
+          multi_stage: true,
+          sql: \`\${revenue}\`,
+          type: 'sum',
+          group_by: [visitors.created_at.year]
+        },
+        visitors_revenue_reduce_day: {
+          multi_stage: true,
+          sql: \`\${revenue}\`,
+          type: 'sum',
+          reduce_by: [visitors.created_at.day]
+        },
         visitors_revenue_without_date: {
           multi_stage: true,
           sql: \`\${revenue}\`,
@@ -4434,6 +4446,184 @@ SELECT 1 AS revenue,  cast('2024-01-01' AS timestamp) as time UNION ALL
     }]
   ));
 
+  if (getEnv('nativeSqlPlanner')) {
+  it('multi stage sum with group by time dim with granularity', async () => runQueryTest(
+    {
+      measures: ['visitors.visitors_revenue_per_year', 'visitors.revenue'],
+      dimensions: ['visitors.source'],
+      timeDimensions: [{
+        dimension: 'visitors.created_at',
+        granularity: 'year',
+        dateRange: ['2016-01-01', '2017-01-30']
+      }],
+      timezone: 'America/Los_Angeles',
+      order: [{
+        id: 'visitors.source'
+      }, {
+        id: 'visitors.created_at'
+      }],
+    },
+
+    [{
+      visitors__source: 'google',
+      visitors__created_at_year: '2017-01-01T00:00:00.000Z',
+      visitors__visitors_revenue_per_year: '1500',
+      visitors__revenue: '300'
+    },
+    {
+      visitors__source: 'some',
+      visitors__created_at_year: '2017-01-01T00:00:00.000Z',
+      visitors__visitors_revenue_per_year: '1500',
+      visitors__revenue: '300'
+    },
+    {
+      visitors__source: null,
+      visitors__created_at_year: '2016-01-01T00:00:00.000Z',
+      visitors__visitors_revenue_per_year: '500',
+      visitors__revenue: '500'
+    },
+    {
+      visitors__source: null,
+      visitors__created_at_year: '2017-01-01T00:00:00.000Z',
+      visitors__visitors_revenue_per_year: '1500',
+      visitors__revenue: '900'
+    }]
+  ));
+  } else {
+    it.skip('multi stage sum with group by time dim with granularity', async () => {
+    // Works only in Tesseract
+    });
+  }
+
+if (getEnv('nativeSqlPlanner')) {
+  it('multi stage sum multiple time dims group by time dim with granularity', async () => runQueryTest(
+    {
+      measures: ['visitors.visitors_revenue_per_year', 'visitors.revenue'],
+      dimensions: ['visitors.source'],
+      timeDimensions: [{
+        dimension: 'visitors.created_at',
+        granularity: 'year',
+        dateRange: ['2014-01-01', '2018-01-30']
+      },
+      {
+        dimension: 'visitors.created_at',
+        granularity: 'day',
+        dateRange: ['2014-01-01', '2018-01-30']
+      }],
+      timezone: 'America/Los_Angeles',
+      order: [{
+        id: 'visitors.source'
+      }, {
+        id: 'visitors.created_at'
+      }],
+    },
+
+    [
+      {
+        visitors__source: 'google',
+        visitors__created_at_year: '2017-01-01T00:00:00.000Z',
+        visitors__created_at_day: '2017-01-05T00:00:00.000Z',
+        visitors__visitors_revenue_per_year: '1500',
+        visitors__revenue: '300'
+      },
+      {
+        visitors__source: 'some',
+        visitors__created_at_year: '2017-01-01T00:00:00.000Z',
+        visitors__created_at_day: '2017-01-02T00:00:00.000Z',
+        visitors__visitors_revenue_per_year: '1500',
+        visitors__revenue: '100'
+      },
+      {
+        visitors__source: 'some',
+        visitors__created_at_year: '2017-01-01T00:00:00.000Z',
+        visitors__created_at_day: '2017-01-04T00:00:00.000Z',
+        visitors__visitors_revenue_per_year: '1500',
+        visitors__revenue: '200'
+      },
+      {
+        visitors__source: null,
+        visitors__created_at_year: '2016-01-01T00:00:00.000Z',
+        visitors__created_at_day: '2016-09-06T00:00:00.000Z',
+        visitors__visitors_revenue_per_year: '500',
+        visitors__revenue: '500'
+      },
+      {
+        visitors__source: null,
+        visitors__created_at_year: '2017-01-01T00:00:00.000Z',
+        visitors__created_at_day: '2017-01-06T00:00:00.000Z',
+        visitors__visitors_revenue_per_year: '1500',
+        visitors__revenue: '900'
+      }
+    ]
+  ));
+  } else {
+    it.skip('multi stage sum multiple time dims group by time dim with granularity', async () => {
+    // Works only in Tesseract
+    });
+  }
+
+  if (getEnv('nativeSqlPlanner')) {
+  it('multi stage sum multiple time dims reduce by time dim with granularity', async () => runQueryTest(
+    {
+      measures: ['visitors.visitors_revenue_reduce_day', 'visitors.revenue'],
+      timeDimensions: [{
+        dimension: 'visitors.created_at',
+        granularity: 'year',
+        dateRange: ['2014-01-01', '2018-01-30']
+      },
+      {
+        dimension: 'visitors.created_at',
+        granularity: 'day',
+        dateRange: ['2014-01-01', '2018-01-30']
+      }],
+      timezone: 'America/Los_Angeles',
+      order: [{
+        id: 'visitors.source'
+      }, {
+        id: 'visitors.created_at'
+      }],
+    },
+
+    [
+
+      {
+        visitors__created_at_year: '2016-01-01T00:00:00.000Z',
+        visitors__created_at_day: '2016-09-06T00:00:00.000Z',
+        visitors__visitors_revenue_reduce_day: '500',
+        visitors__revenue: '500'
+      },
+      {
+        visitors__created_at_year: '2017-01-01T00:00:00.000Z',
+        visitors__created_at_day: '2017-01-02T00:00:00.000Z',
+        visitors__visitors_revenue_reduce_day: '1500',
+        visitors__revenue: '100'
+      },
+      {
+        visitors__created_at_year: '2017-01-01T00:00:00.000Z',
+        visitors__created_at_day: '2017-01-04T00:00:00.000Z',
+        visitors__visitors_revenue_reduce_day: '1500',
+        visitors__revenue: '200'
+      },
+      {
+        visitors__created_at_year: '2017-01-01T00:00:00.000Z',
+        visitors__created_at_day: '2017-01-05T00:00:00.000Z',
+        visitors__visitors_revenue_reduce_day: '1500',
+        visitors__revenue: '300'
+      },
+      {
+        visitors__created_at_year: '2017-01-01T00:00:00.000Z',
+        visitors__created_at_day: '2017-01-06T00:00:00.000Z',
+        visitors__visitors_revenue_reduce_day: '1500',
+        visitors__revenue: '900'
+      }
+    ]
+  ));
+  } else {
+    it.skip('multi stage sum multiple time dims reduce by time dim with granularity', async () => {
+    // Works only in Tesseract
+    });
+  }
+
   if (getEnv('nativeSqlPlanner')) {
     it('multi stage sum with group by over view', async () => runQueryTest(
       {

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

@@ -203,7 +203,6 @@ impl BaseFilter {
                     let Some(granularity_obj) = GranularityHelper::make_granularity_obj(
                         self.query_tools.cube_evaluator().clone(),
                         &mut evaluator_compiler,
-                        self.query_tools.timezone().clone(),
                         &symbol.cube_name(),
                         &symbol.name(),
                         Some(query_granularity.clone()),

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

@@ -132,7 +132,6 @@ impl MultiStageMemberQueryPlanner {
                 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()),

rust/cubesqlplanner/cubesqlplanner/src/planner/query_properties.rs

@@ -172,7 +172,6 @@ impl QueryProperties {
                     let granularity_obj = GranularityHelper::make_granularity_obj(
                         query_tools.cube_evaluator().clone(),
                         &mut evaluator_compiler,
-                        query_tools.timezone().clone(),
                         &base_symbol.cube_name(),
                         &base_symbol.name(),
                         d.granularity.clone(),

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

@@ -120,13 +120,16 @@ impl Compiler {
         Ok(collector.extract_result())
     }
 
+    pub fn timezone(&self) -> Tz {
+        self.timezone.clone()
+    }
+
     pub fn compile_sql_call(
         &mut self,
         cube_name: &String,
         member_sql: Rc<dyn MemberSql>,
     ) -> Result<Rc<SqlCall>, CubeError> {
-        let dep_builder =
-            DependenciesBuilder::new(self, self.cube_evaluator.clone(), self.timezone.clone());
+        let dep_builder = DependenciesBuilder::new(self, self.cube_evaluator.clone());
         let deps = dep_builder.build(cube_name.clone(), member_sql.clone())?;
         let sql_call = SqlCall::new(member_sql, deps);
         Ok(Rc::new(sql_call))

rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/dependecy.rs

@@ -4,7 +4,6 @@ use crate::cube_bridge::evaluator::{CallDep, CubeEvaluator};
 use crate::cube_bridge::member_sql::MemberSql;
 use crate::planner::sql_evaluator::TimeDimensionSymbol;
 use crate::planner::GranularityHelper;
-use chrono_tz::Tz;
 use cubenativeutils::CubeError;
 use std::collections::HashMap;
 use std::rc::Rc;
@@ -65,19 +64,13 @@ pub enum Dependency {
 pub struct DependenciesBuilder<'a> {
     compiler: &'a mut Compiler,
     cube_evaluator: Rc<dyn CubeEvaluator>,
-    timezone: Tz,
 }
 
 impl<'a> DependenciesBuilder<'a> {
-    pub fn new(
-        compiler: &'a mut Compiler,
-        cube_evaluator: Rc<dyn CubeEvaluator>,
-        timezone: Tz,
-    ) -> Self {
+    pub fn new(compiler: &'a mut Compiler, cube_evaluator: Rc<dyn CubeEvaluator>) -> Self {
         DependenciesBuilder {
             compiler,
             cube_evaluator,
-            timezone,
         }
     }
 
@@ -173,7 +166,6 @@ impl<'a> DependenciesBuilder<'a> {
             if let Some(granularity_obj) = GranularityHelper::make_granularity_obj(
                 self.cube_evaluator.clone(),
                 self.compiler,
-                self.timezone.clone(),
                 cube_name,
                 &dep.name,
                 Some(granularity.clone()),

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

@@ -4,8 +4,10 @@ use crate::cube_bridge::dimension_definition::DimensionDefinition;
 use crate::cube_bridge::evaluator::CubeEvaluator;
 use crate::cube_bridge::member_sql::MemberSql;
 use crate::planner::query_tools::QueryTools;
+use crate::planner::sql_evaluator::TimeDimensionSymbol;
 use crate::planner::sql_evaluator::{sql_nodes::SqlNode, Compiler, SqlCall, SqlEvaluatorVisitor};
 use crate::planner::sql_templates::PlanSqlTemplates;
+use crate::planner::GranularityHelper;
 use crate::planner::SqlInterval;
 use cubenativeutils::CubeError;
 use std::rc::Rc;
@@ -287,6 +289,7 @@ impl DimensionSymbol {
 pub struct DimensionSymbolFactory {
     cube_name: String,
     name: String,
+    granularity: Option<String>,
     sql: Option<Rc<dyn MemberSql>>,
     definition: Rc<dyn DimensionDefinition>,
     cube_evaluator: Rc<dyn CubeEvaluator>,
@@ -302,10 +305,12 @@ impl DimensionSymbolFactory {
             .into_iter();
         let cube_name = iter.next().unwrap();
         let name = iter.next().unwrap();
+        let granularity = iter.next();
         let definition = cube_evaluator.dimension_by_path(full_name.clone())?;
         Ok(Self {
             cube_name,
             name,
+            granularity,
             sql: definition.sql()?,
             definition,
             cube_evaluator,
@@ -338,6 +343,7 @@ impl SymbolFactory for DimensionSymbolFactory {
         let Self {
             cube_name,
             name,
+            granularity,
             sql,
             definition,
             cube_evaluator,
@@ -477,9 +483,9 @@ impl SymbolFactory for DimensionSymbolFactory {
                 && longitude.is_none()
                 && !is_multi_stage);
 
-        Ok(MemberSymbol::new_dimension(DimensionSymbol::new(
-            cube_name,
-            name,
+        let symbol = MemberSymbol::new_dimension(DimensionSymbol::new(
+            cube_name.clone(),
+            name.clone(),
             alias,
             sql,
             is_reference,
@@ -491,6 +497,32 @@ impl SymbolFactory for DimensionSymbolFactory {
             time_shift,
             time_shift_pk,
             is_self_time_shift_pk,
-        )))
+        ));
+
+        if let Some(granularity) = &granularity {
+            if let Some(granularity_obj) = GranularityHelper::make_granularity_obj(
+                cube_evaluator.clone(),
+                compiler,
+                &cube_name,
+                &name,
+                Some(granularity.clone()),
+            )? {
+                let time_dim_symbol = MemberSymbol::new_time_dimension(TimeDimensionSymbol::new(
+                    symbol,
+                    Some(granularity.clone()),
+                    Some(granularity_obj),
+                    None,
+                ));
+                return Ok(time_dim_symbol);
+            } else {
+                return Err(CubeError::user(format!(
+                    "Undefined granularity {} for time dimension {}",
+                    granularity,
+                    symbol.full_name()
+                )));
+            }
+        }
+
+        Ok(symbol)
     }
 }

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

@@ -79,7 +79,6 @@ impl TimeDimensionSymbol {
         let new_granularity_obj = GranularityHelper::make_granularity_obj(
             query_tools.cube_evaluator().clone(),
             &mut evaluator_compiler,
-            query_tools.timezone(),
             &&self.base_symbol.cube_name(),
             &self.base_symbol.name(),
             new_granularity.clone(),

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

@@ -224,11 +224,11 @@ impl GranularityHelper {
     pub fn make_granularity_obj(
         cube_evaluator: Rc<dyn CubeEvaluator>,
         compiler: &mut Compiler,
-        timezone: Tz,
         cube_name: &String,
         name: &String,
         granularity: Option<String>,
     ) -> Result<Option<Granularity>, CubeError> {
+        let timezone = compiler.timezone();
         let granularity_obj = if let Some(granularity) = &granularity {
             let path = vec![
                 cube_name.clone(),