in work

Author: waralexrom

packages/cubejs-schema-compiler/src/adapter/BaseQuery.js

@@ -4214,7 +4214,7 @@ export class BaseQuery {
           '{{ min_expr }} as {{ quoted_min_name }}\n' +
           'FROM {{ from_prepared }}\n' +
           '{% if filter %}WHERE {{ filter }}{% endif %}',
-        calc_groups_join: 'SELECT {{ original_cube }}.*, ' +
+        /* calc_groups_join: 'SELECT {{ original_cube }}.*, ' +
         '{%for single_value in single_values %}' +
         '{{ single_value.value }} as {{ single_value.name }}{% if not loop.last %}, {% endif %}' +
         '{% endfor %}' +
@@ -4231,6 +4231,16 @@ export class BaseQuery {
         '{% if not loop.last %} UNION ALL\n{% endif %}' +
         '{% endfor %}' +
         ') {{ group.alias }}\n' +
+        '{% endfor %}', */
+        calc_groups_join: '{% if original_sql %}{{ original_sql }}\n{% endif %}' +
+        '{% for group in groups  %}' +
+        '{% if original_sql or not loop.first %}CROSS JOIN\n{% endif %}' +
+        '(\n' +
+        '{% for value in group.values  %}' +
+        'SELECT {{ value }} as {{ group.name }}' +
+        '{% if not loop.last %} UNION ALL\n{% endif %}' +
+        '{% endfor %}' +
+        ') {{ group.alias }}\n' +
         '{% endfor %}'
       },
       expressions: {

packages/cubejs-schema-compiler/test/integration/postgres/calc-groups.test.ts

@@ -436,7 +436,7 @@ views:
     `);
 
   if (getEnv('nativeSqlPlanner')) {
-    it('basic cross join', async () => dbRunner.runQueryTest({
+    it('basic cross join 1', async () => dbRunner.runQueryTest({
       dimensions: ['orders.currency'],
       timeDimensions: [
         {

rust/cubesqlplanner/cubesqlplanner/src/logical_plan/calc_groups_cross_join.rs

@@ -3,6 +3,7 @@ use crate::planner::sql_evaluator::MemberSymbol;
 use super::*;
 use cubenativeutils::CubeError;
 use std::rc::Rc;
+use typed_builder::TypedBuilder;
 
 #[derive(Clone)]
 pub struct CalcGroupDescription {
@@ -20,15 +21,20 @@ impl PrettyPrint for CalcGroupDescription {
     }
 }
 
-logical_source_enum!(
-    CalcGroupsCrossJoinSource,
-    [LogicalJoin, FullKeyAggregate, PreAggregation]
-);
-
-#[derive(Clone)]
+#[derive(Clone, TypedBuilder)]
 pub struct CalcGroupsCrossJoin {
-    pub source: CalcGroupsCrossJoinSource,
-    pub calc_groups: Vec<Rc<CalcGroupDescription>>,
+    source: BaseQuerySource,
+    calc_groups: Vec<Rc<CalcGroupDescription>>,
+}
+
+impl CalcGroupsCrossJoin {
+    pub fn source(&self) -> &BaseQuerySource {
+        &self.source
+    }
+
+    pub fn calc_groups(&self) -> &Vec<Rc<CalcGroupDescription>> {
+        &self.calc_groups
+    }
 }
 
 impl LogicalNode for CalcGroupsCrossJoin {

rust/cubesqlplanner/cubesqlplanner/src/logical_plan/cube.rs

@@ -17,21 +17,23 @@ impl OriginalSqlPreAggregation {
 
 impl PrettyPrint for OriginalSqlPreAggregation {
     fn pretty_print(&self, result: &mut PrettyPrintResult, state: &PrettyPrintState) {
-        result.println(&format!("OriginalSqlPreAggregation: {}", self.name()), state);
+        result.println(
+            &format!("OriginalSqlPreAggregation: {}", self.name()),
+            state,
+        );
     }
 }
 
 #[derive(Clone, TypedBuilder)]
 pub struct Cube {
-    name: String,
     cube: Rc<BaseCube>,
     #[builder(default)]
     original_sql_pre_aggregation: Option<OriginalSqlPreAggregation>,
 }
 
 impl Cube {
     pub fn name(&self) -> &String {
-        &self.name
+        &self.cube.name()
     }
 
     pub fn cube(&self) -> &Rc<BaseCube> {
@@ -54,21 +56,19 @@ impl PrettyPrint for Cube {
 
 impl Cube {
     pub fn new(cube: Rc<BaseCube>) -> Rc<Self> {
-        Rc::new(Self::builder()
-            .name(cube.name().clone())
-            .cube(cube)
-            .build())
+        Rc::new(Self::builder().cube(cube).build())
     }
 
     pub fn with_original_sql_pre_aggregation(
         self: Rc<Self>,
         original_sql_pre_aggregation: OriginalSqlPreAggregation,
     ) -> Rc<Self> {
-        Rc::new(Self::builder()
-            .name(self.name().clone())
-            .cube(self.cube().clone())
-            .original_sql_pre_aggregation(Some(original_sql_pre_aggregation))
-            .build())
+        Rc::new(
+            Self::builder()
+                .cube(self.cube().clone())
+                .original_sql_pre_aggregation(Some(original_sql_pre_aggregation))
+                .build(),
+        )
     }
 }
 

rust/cubesqlplanner/cubesqlplanner/src/logical_plan/filter.rs

@@ -2,6 +2,7 @@ use super::pretty_print::*;
 use crate::plan::{Filter, FilterItem};
 use itertools::Itertools;
 
+#[derive(Default)]
 pub struct LogicalFilter {
     pub dimensions_filters: Vec<FilterItem>,
     pub time_dimensions_filters: Vec<FilterItem>,

rust/cubesqlplanner/cubesqlplanner/src/logical_plan/helper.rs

@@ -0,0 +1,17 @@
+use itertools::Itertools;
+
+use crate::planner::sql_evaluator::MemberSymbol;
+
+use super::*;
+use std::rc::Rc;
+pub fn all_symbols(schema: &Rc<LogicalSchema>, filters: &LogicalFilter) -> Vec<Rc<MemberSymbol>> {
+    let mut symbols = schema.all_members().cloned().collect_vec();
+
+    if let Some(dim_filter) = filters.all_filters() {
+        symbols.extend(dim_filter.all_member_evaluators().iter().cloned());
+    }
+    if let Some(meas_filter) = filters.measures_filter() {
+        symbols.extend(meas_filter.all_member_evaluators().iter().cloned());
+    }
+    symbols
+}

rust/cubesqlplanner/cubesqlplanner/src/logical_plan/logical_node.rs

@@ -26,7 +26,6 @@ pub enum PlanNode {
     MeasureSubquery(Rc<MeasureSubquery>),
     DimensionSubQuery(Rc<DimensionSubQuery>),
     KeysSubQuery(Rc<KeysSubQuery>),
-    CalcGroupsCrossJoin(Rc<CalcGroupsCrossJoin>),
     MultiStageGetDateRange(Rc<MultiStageGetDateRange>),
     MultiStageLeafMeasure(Rc<MultiStageLeafMeasure>),
     MultiStageMeasureCalculation(Rc<MultiStageMeasureCalculation>),
@@ -49,7 +48,6 @@ macro_rules! match_plan_node {
             PlanNode::MeasureSubquery($node) => $block,
             PlanNode::DimensionSubQuery($node) => $block,
             PlanNode::KeysSubQuery($node) => $block,
-            PlanNode::CalcGroupsCrossJoin($node) => $block,
             PlanNode::MultiStageGetDateRange($node) => $block,
             PlanNode::MultiStageLeafMeasure($node) => $block,
             PlanNode::MultiStageMeasureCalculation($node) => $block,

rust/cubesqlplanner/cubesqlplanner/src/logical_plan/mod.rs

@@ -1,11 +1,11 @@
 #[macro_use]
 mod logical_source;
 mod aggregate_multiplied_subquery;
-mod calc_groups_cross_join;
 mod cube;
 mod dimension_subquery;
 mod filter;
 mod full_key_aggregate;
+mod helper;
 mod join;
 mod keys_subquery;
 mod logical_node;
@@ -22,11 +22,11 @@ mod schema;
 pub mod visitor;
 
 pub use aggregate_multiplied_subquery::*;
-pub use calc_groups_cross_join::*;
 pub use cube::*;
 pub use dimension_subquery::*;
 pub use filter::*;
 pub use full_key_aggregate::*;
+pub use helper::*;
 pub use join::*;
 pub use keys_subquery::*;
 pub use logical_node::*;

rust/cubesqlplanner/cubesqlplanner/src/logical_plan/query_source.rs

@@ -2,4 +2,74 @@ use super::*;
 use cubenativeutils::CubeError;
 use std::rc::Rc;
 
-logical_source_enum!(QuerySource, [LogicalJoin, FullKeyAggregate, PreAggregation]);
+logical_source_enum!(
+    QuerySource,
+    [LogicalJoin, FullKeyAggregate, PreAggregation]
+);
+
+/* #[derive(Clone)]
+pub enum QuerySource {
+    CalcGroupsCrossJoin(Rc<CalcGroupsCrossJoin>),
+    BaseSource(BaseQuerySource),
+}
+
+impl QuerySource {
+    pub fn base_source(&self) -> &BaseQuerySource {
+        match &self {
+            QuerySource::CalcGroupsCrossJoin(cross_join) => cross_join.source(),
+            QuerySource::BaseSource(base) => base,
+        }
+    }
+}
+
+impl LogicalSource for QuerySource {
+    fn as_plan_node(&self) -> PlanNode {
+        match &self {
+            QuerySource::CalcGroupsCrossJoin(item) => item.as_plan_node(),
+            QuerySource::BaseSource(base) => base.as_plan_node(),
+        }
+    }
+    fn with_plan_node(&self, plan_node: PlanNode) -> Result<Self, CubeError> {
+        Ok(match &self {
+            QuerySource::CalcGroupsCrossJoin(_) => {
+                QuerySource::CalcGroupsCrossJoin(plan_node.into_logical_node()?)
+            }
+            QuerySource::BaseSource(base) => {
+                QuerySource::BaseSource(base.with_plan_node(plan_node)?)
+            }
+        })
+    }
+}
+
+impl PrettyPrint for QuerySource {
+    fn pretty_print(&self, result: &mut PrettyPrintResult, state: &PrettyPrintState) {
+        match &self {
+            QuerySource::CalcGroupsCrossJoin(item) => item.pretty_print(result, state),
+            QuerySource::BaseSource(base) => base.pretty_print(result, state),
+        }
+    }
+}
+
+impl From<Rc<CalcGroupsCrossJoin>> for QuerySource {
+    fn from(value: Rc<CalcGroupsCrossJoin>) -> Self {
+        Self::CalcGroupsCrossJoin(value)
+    }
+}
+
+impl From<Rc<LogicalJoin>> for QuerySource {
+    fn from(value: Rc<LogicalJoin>) -> Self {
+        Self::BaseSource(value.into())
+    }
+}
+
+impl From<Rc<FullKeyAggregate>> for QuerySource {
+    fn from(value: Rc<FullKeyAggregate>) -> Self {
+        Self::BaseSource(value.into())
+    }
+}
+
+impl From<Rc<PreAggregation>> for QuerySource {
+    fn from(value: Rc<PreAggregation>) -> Self {
+        Self::BaseSource(value.into())
+    }
+} */

rust/cubesqlplanner/cubesqlplanner/src/physical_plan_builder/context.rs

@@ -18,6 +18,7 @@ pub(super) struct PushDownBuilderContext {
     pub dimensions_query: bool,
     pub measure_subquery: bool,
     pub multi_stage_schemas: HashMap<String, Rc<Schema>>,
+    pub calc_groups_resolved: bool,
 }
 
 impl PushDownBuilderContext {