in work

Author: waralexrom

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

@@ -4240,7 +4240,7 @@ export class BaseQuery {
         'SELECT {{ value }} as {{ group.name }}' +
         '{% if not loop.last %} UNION ALL\n{% endif %}' +
         '{% endfor %}' +
-        ') {{ group.alias }}\n' +
+        ') AS {{ group.alias }}\n' +
         '{% endfor %}'
       },
       expressions: {

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

@@ -169,23 +169,6 @@ impl PhysicalPlanBuilder {
         Ok(())
     }
 
-    pub(crate) fn process_calc_group(
-        &self,
-        symbol: &Rc<MemberSymbol>,
-        context_factory: &mut SqlNodesFactory,
-        filter: &Option<Filter>,
-    ) -> Result<(), CubeError> {
-        for dim in collect_calc_group_dims(symbol)? {
-            let values = get_filtered_values(&dim, filter);
-            context_factory.add_calc_group_item(
-                dim.cube_name().clone(),
-                dim.name().clone(),
-                values,
-            );
-        }
-        Ok(())
-    }
-
     pub(crate) fn make_order_by(
         &self,
         logical_schema: &LogicalSchema,

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

@@ -18,7 +18,6 @@ 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 {

rust/cubesqlplanner/cubesqlplanner/src/physical_plan_builder/processors/keys_sub_query.rs

@@ -1,9 +1,11 @@
 use super::super::{LogicalNodeProcessor, ProcessableNode, PushDownBuilderContext};
-use crate::logical_plan::KeysSubQuery;
+use crate::logical_plan::{all_symbols, KeysSubQuery};
 use crate::physical_plan_builder::PhysicalPlanBuilder;
-use crate::plan::{Select, SelectBuilder};
-use crate::planner::sql_evaluator::ReferencesBuilder;
+use crate::plan::{CalcGroupItem, CalcGroupsJoin, From, Select, SelectBuilder};
+use crate::planner::sql_evaluator::collectors::collect_calc_group_dims_from_nodes;
+use crate::planner::sql_evaluator::{get_filtered_values, ReferencesBuilder};
 use cubenativeutils::CubeError;
+use itertools::Itertools as _;
 use std::collections::HashMap;
 use std::rc::Rc;
 
@@ -36,6 +38,34 @@ impl<'a> LogicalNodeProcessor<'a, KeysSubQuery> for KeysSubQueryProcessor<'a> {
             .builder
             .process_node(keys_subquery.source().as_ref(), &context)?;
 
+        //FIXME dublication with QueryProcessor
+        let all_symbols = all_symbols(&keys_subquery.schema(), &keys_subquery.filter());
+        let calc_group_dims = collect_calc_group_dims_from_nodes(all_symbols.iter())?;
+
+        let filter = keys_subquery.filter().all_filters();
+        let calc_groups_items = calc_group_dims.into_iter().map(|dim| {
+            let values = get_filtered_values(&dim, &filter);
+            CalcGroupItem {
+                symbol: dim,
+                values,
+            }
+        });
+        for item in calc_groups_items
+            .clone()
+            .filter(|itm| itm.values.len() == 1)
+        {
+            context_factory.add_render_reference(item.symbol.full_name(), item.values[0].clone());
+        }
+        let calc_groups_to_join = calc_groups_items
+            .filter(|itm| itm.values.len() > 1)
+            .collect_vec();
+        let source = if calc_groups_to_join.is_empty() {
+            source
+        } else {
+            let groups_join = CalcGroupsJoin::try_new(source, calc_groups_to_join)?;
+            From::new_from_calc_groups_join(groups_join)
+        };
+
         let references_builder = ReferencesBuilder::new(source.clone());
         let mut select_builder = SelectBuilder::new(source);
         self.builder.resolve_subquery_dimensions_references(
@@ -49,11 +79,11 @@ impl<'a> LogicalNodeProcessor<'a, KeysSubQuery> for KeysSubQueryProcessor<'a> {
             .chain(keys_subquery.primary_keys_dimensions().iter())
         {
             let alias = member.alias();
-            self.builder.process_calc_group(
+            /* self.builder.process_calc_group(
                 member,
                 &mut context_factory,
                 &keys_subquery.filter().all_filters(),
-            )?;
+            )?; */
             references_builder.resolve_references_for_member(
                 member.clone(),
                 &None,
@@ -63,7 +93,7 @@ impl<'a> LogicalNodeProcessor<'a, KeysSubQuery> for KeysSubQueryProcessor<'a> {
         }
 
         select_builder.set_distinct();
-        select_builder.set_filter(keys_subquery.filter().all_filters());
+        select_builder.set_filter(filter);
         let res = Rc::new(select_builder.build(query_tools.clone(), context_factory));
         Ok(res)
     }

rust/cubesqlplanner/cubesqlplanner/src/physical_plan_builder/processors/query.rs

@@ -66,9 +66,16 @@ impl<'a> LogicalNodeProcessor<'a, Query> for QueryProcessor<'a> {
                     values,
                 }
             });
-            let calc_groups_to_join = calc_groups_items.collect_vec();
-            /* .filter(|itm| itm.values.len() == 1)
-            .collect_vec(); */
+            for item in calc_groups_items
+                .clone()
+                .filter(|itm| itm.values.len() == 1)
+            {
+                context_factory
+                    .add_render_reference(item.symbol.full_name(), item.values[0].clone());
+            }
+            let calc_groups_to_join = calc_groups_items
+                .filter(|itm| itm.values.len() > 1)
+                .collect_vec();
             if calc_groups_to_join.is_empty() {
                 from
             } else {
@@ -118,8 +125,6 @@ impl<'a> LogicalNodeProcessor<'a, Query> for QueryProcessor<'a> {
                 &None,
                 context_factory.render_references_mut(),
             )?;
-            self.builder
-                .process_calc_group(member, &mut context_factory, &filter)?;
             if context.measure_subquery {
                 select_builder.add_projection_member_without_schema(member, None);
             } else {

rust/cubesqlplanner/cubesqlplanner/src/plan/calc_groups_join.rs

@@ -51,18 +51,8 @@ impl CalcGroupsJoin {
     ) -> Result<String, CubeError> {
         let base_sql = self.from.to_sql(templates, context)?;
         let original_sql = match &self.from.source {
-            FromSource::Join(_) => Some(format!(
-                "({}) {}",
-                base_sql,
-                templates.quote_identifier("original_join")?
-            )),
             FromSource::Empty => None,
-            FromSource::Single(source) => Some(base_sql),
-            FromSource::CalcGroupsJoin(_) => {
-                return Err(CubeError::internal(format!(
-                    "Nested CalcGroupsJoin not supported"
-                )));
-            }
+            _ => Some(base_sql),
         };
 
         let template_groups = self

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

@@ -83,15 +83,6 @@ impl SqlNodesFactory {
         &mut self.render_references
     }
 
-    pub fn add_calc_group_item(
-        &mut self,
-        cube_name: String,
-        dimension_name: String,
-        values: Vec<String>,
-    ) {
-        //self.calc_groups.add(cube_name, dimension_name, values);
-    }
-
     pub fn set_rendered_as_multiplied_measures(&mut self, value: HashSet<String>) {
         self.rendered_as_multiplied_measures = value;
     }