in work

Author: waralexrom

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

@@ -4108,7 +4108,7 @@ export class BaseQuery {
         VAR_SAMP: 'VAR_SAMP({{ args_concat }})',
         COVAR_POP: 'COVAR_POP({{ args_concat }})',
         COVAR_SAMP: 'COVAR_SAMP({{ args_concat }})',
-
+        GROUP_ANY: 'max({{ expr }})',
         COALESCE: 'COALESCE({{ args_concat }})',
         CONCAT: 'CONCAT({{ args_concat }})',
         FLOOR: 'FLOOR({{ args_concat }})',

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

@@ -862,7 +862,7 @@ SELECT 1 AS revenue,  cast('2024-01-01' AS timestamp) as time UNION ALL
     })
     `);
 
-  it('simple join', async () => {
+  it('simple join 1', async () => {
     await compiler.compile();
 
     console.log(joinGraph.buildJoin(['visitor_checkins', 'visitors']));

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

@@ -24,6 +24,15 @@ impl LogicalFilter {
             Some(Filter { items })
         }
     }
+    pub fn measures_filter(&self) -> Option<Filter> {
+        if self.measures_filter.is_empty() {
+            None
+        } else {
+            Some(Filter {
+                items: self.measures_filter.clone(),
+            })
+        }
+    }
 }
 
 impl PrettyPrint for LogicalFilter {

rust/cubesqlplanner/cubesqlplanner/src/logical_plan/full_key_aggregate.rs

@@ -24,6 +24,17 @@ pub enum ResolvedMultipliedMeasures {
     PreAggregation(Rc<SimpleQuery>),
 }
 
+impl ResolvedMultipliedMeasures {
+    pub fn schema(&self) -> Rc<LogicalSchema> {
+        match self {
+            ResolvedMultipliedMeasures::ResolveMultipliedMeasures(resolve_multiplied_measures) => {
+                resolve_multiplied_measures.schema.clone()
+            }
+            ResolvedMultipliedMeasures::PreAggregation(simple_query) => simple_query.schema.clone(),
+        }
+    }
+}
+
 impl PrettyPrint for ResolvedMultipliedMeasures {
     fn pretty_print(&self, result: &mut PrettyPrintResult, state: &PrettyPrintState) {
         match self {
@@ -39,7 +50,7 @@ impl PrettyPrint for ResolvedMultipliedMeasures {
 }
 
 pub struct FullKeyAggregate {
-    pub join_dimensions: Vec<Rc<MemberSymbol>>,
+    pub schema: Rc<LogicalSchema>,
     pub use_full_join_and_coalesce: bool,
     pub multiplied_measures_resolver: Option<ResolvedMultipliedMeasures>,
     pub multi_stage_subquery_refs: Vec<Rc<MultiStageSubqueryRef>>,
@@ -50,10 +61,8 @@ impl PrettyPrint for FullKeyAggregate {
         result.println("FullKeyAggregate: ", state);
         let state = state.new_level();
         let details_state = state.new_level();
-        result.println(
-            &format!("join_dimensions: {}", print_symbols(&self.join_dimensions)),
-            &state,
-        );
+        result.println(&format!("schema:"), &state);
+        self.schema.pretty_print(result, &details_state);
         result.println(
             &format!(
                 "use_full_join_and_coalesce: {}",

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

@@ -1,5 +1,5 @@
-mod common;
+//mod common;
 mod pre_aggregation;
 
-pub use common::*;
+//pub use common::*;
 pub use pre_aggregation::*;

rust/cubesqlplanner/cubesqlplanner/src/logical_plan/query.rs

@@ -1,15 +1,58 @@
 use super::*;
+use std::rc::Rc;
 
-pub enum Query {
-    SimpleQuery(SimpleQuery),
-    FullKeyAggregateQuery(FullKeyAggregateQuery),
+#[derive(Clone)]
+pub enum QuerySource {
+    LogicalJoin(Rc<LogicalJoin>),
+    FullKeyAggregate(Rc<FullKeyAggregate>),
+    PreAggregation(Rc<PreAggregation>),
+}
+impl PrettyPrint for QuerySource {
+    fn pretty_print(&self, result: &mut PrettyPrintResult, state: &PrettyPrintState) {
+        match self {
+            QuerySource::LogicalJoin(join) => join.pretty_print(result, state),
+            QuerySource::FullKeyAggregate(full_key) => full_key.pretty_print(result, state),
+            QuerySource::PreAggregation(pre_aggregation) => {
+                pre_aggregation.pretty_print(result, state)
+            }
+        }
+    }
+}
+#[derive(Clone)]
+pub struct Query {
+    pub multistage_members: Vec<Rc<LogicalMultiStageMember>>,
+    pub schema: Rc<LogicalSchema>,
+    pub dimension_subqueries: Vec<Rc<DimensionSubQuery>>,
+    pub filter: Rc<LogicalFilter>,
+    pub modifers: Rc<LogicalQueryModifiers>,
+    pub source: QuerySource,
 }
 
 impl PrettyPrint for Query {
     fn pretty_print(&self, result: &mut PrettyPrintResult, state: &PrettyPrintState) {
-        match self {
-            Self::SimpleQuery(query) => query.pretty_print(result, state),
-            Self::FullKeyAggregateQuery(query) => query.pretty_print(result, state),
+        result.println("Query: ", state);
+        let state = state.new_level();
+        let details_state = state.new_level();
+        if !self.multistage_members.is_empty() {
+            result.println("multistage_members:", &state);
+            for member in self.multistage_members.iter() {
+                member.pretty_print(result, &details_state);
+            }
         }
+
+        result.println("schema:", &state);
+        self.schema.pretty_print(result, &details_state);
+        if !self.dimension_subqueries.is_empty() {
+            result.println("dimension_subqueries:", &state);
+            for subquery in self.dimension_subqueries.iter() {
+                subquery.pretty_print(result, &details_state);
+            }
+        }
+        result.println("filters:", &state);
+        self.filter.pretty_print(result, &details_state);
+        self.modifers.pretty_print(result, &state);
+
+        result.println("source:", &state);
+        self.source.pretty_print(result, &details_state);
     }
 }

rust/cubesqlplanner/cubesqlplanner/src/logical_plan/resolve_multiplied_measures.rs

@@ -4,7 +4,7 @@ use std::rc::Rc;
 pub struct ResolveMultipliedMeasures {
     pub schema: Rc<LogicalSchema>,
     pub filter: Rc<LogicalFilter>,
-    pub regular_measure_subqueries: Vec<Rc<SimpleQuery>>,
+    pub regular_measure_subqueries: Vec<Rc<Query>>,
     pub aggregate_multiplied_subqueries: Vec<Rc<AggregateMultipliedSubquery>>,
 }
 

rust/cubesqlplanner/cubesqlplanner/src/logical_plan/schema.rs

@@ -39,6 +39,10 @@ impl LogicalSchema {
     pub fn all_dimensions(&self) -> impl Iterator<Item = &Rc<MemberSymbol>> {
         self.dimensions.iter().chain(self.time_dimensions.iter())
     }
+
+    pub fn all_members(&self) -> impl Iterator<Item = &Rc<MemberSymbol>> {
+        self.all_dimensions().chain(self.measures.iter())
+    }
 }
 
 impl PrettyPrint for LogicalSchema {

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

@@ -118,9 +118,29 @@ impl PhysicalPlanBuilder {
         logical_plan: Rc<Query>,
         context: &PushDownBuilderContext,
     ) -> Result<Rc<Select>, CubeError> {
-        match logical_plan.as_ref() {
-            Query::SimpleQuery(query) => self.process_node(query, context),
-            Query::FullKeyAggregateQuery(query) => self.process_node(query, context),
+        self.process_node(logical_plan.as_ref(), context)
+    }
+
+    pub(super) fn extend_measures(
+        &self,
+        node_measures: &Vec<Rc<MemberSymbol>>,
+        context: &PushDownBuilderContext,
+    ) -> Vec<(Rc<MemberSymbol>, bool)> {
+        if let Some(required_measures) = &context.required_measures {
+            required_measures
+                .iter()
+                .map(|member| {
+                    (
+                        member.clone(),
+                        node_measures.iter().find(|m| m == &member).is_some(),
+                    )
+                })
+                .collect_vec()
+        } else {
+            node_measures
+                .iter()
+                .map(|member| (member.clone(), true))
+                .collect_vec()
         }
     }
 
@@ -398,7 +418,7 @@ impl PhysicalPlanBuilder {
     } */
 
     //FIXME refactor required
-    pub(super) fn process_full_key_aggregate_dimensions(
+    /* pub(super) fn process_full_key_aggregate_dimensions(
         &self,
         dimensions: &Vec<Rc<MemberSymbol>>,
         full_key_aggregate: &Rc<FullKeyAggregate>,
@@ -516,7 +536,7 @@ impl PhysicalPlanBuilder {
             }
         }
         Ok(())
-    }
+    } */
 
     /* fn process_full_key_aggregate(
         &self,

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

@@ -1,7 +1,9 @@
 use crate::plan::schema::QualifiedColumnName;
 use crate::planner::planners::multi_stage::TimeShiftState;
 use crate::planner::sql_evaluator::sql_nodes::SqlNodesFactory;
+use crate::planner::sql_evaluator::MemberSymbol;
 use std::collections::HashMap;
+use std::rc::Rc;
 
 #[derive(Clone, Debug, Default)]
 pub(super) struct PushDownBuilderContext {
@@ -10,6 +12,7 @@ pub(super) struct PushDownBuilderContext {
     pub render_measure_for_ungrouped: bool,
     pub time_shifts: TimeShiftState,
     pub original_sql_pre_aggregations: HashMap<String, String>,
+    pub required_measures: Option<Vec<Rc<MemberSymbol>>>,
 }
 
 impl PushDownBuilderContext {
@@ -22,4 +25,3 @@ impl PushDownBuilderContext {
         factory
     }
 }
-