plan works

Author: waralexrom

rust/cubesqlplanner/cubesqlplanner/src/logical_plan/aggregate_multiplied_subquery.rs

@@ -2,36 +2,24 @@ use super::pretty_print::*;
 use super::LogicalFilter;
 use super::LogicalJoin;
 use super::*;
-use crate::plan::{Expr, Filter, FilterItem, MemberExpression};
-use crate::planner::sql_evaluator::MemberSymbol;
 use crate::planner::query_properties::OrderByItem;
+use crate::planner::BaseCube;
 use std::rc::Rc;
 
 pub enum AggregateMultipliedSubquerySouce {
-    Cube(Rc<Cube>)
+    Cube,
+    MeasureSubquery(Rc<MeasureSubquery>),
 }
 
-impl PrettyPrint for AggregateMultipliedSubquerySouce {
-    fn pretty_print(&self, result: &mut PrettyPrintResult, state: &PrettyPrintState) {
-        match self {
-            AggregateMultipliedSubquerySouce::Cube(cube) => {
-                result.println(&format!("Cube: {}", cube.cube.name()), state);
-            }
-        }
-    }
-}
-    
-
-
 pub struct AggregateMultipliedSubquery {
     pub schema: Rc<LogicalSchema>,
     pub dimension_subqueries: Vec<Rc<DimensionSubQuery>>,
     pub keys_subquery: Rc<KeysSubQuery>,
+    pub pk_cube: Rc<BaseCube>, //FIXME may be duplication with information in keys_subquery
     pub source: Rc<AggregateMultipliedSubquerySouce>,
-    
 }
 
-impl PrettyPrint for AggregateMultipliedSubquery {    
+impl PrettyPrint for AggregateMultipliedSubquery {
     fn pretty_print(&self, result: &mut PrettyPrintResult, state: &PrettyPrintState) {
         result.println("AggregateMultipliedSubquery: ", state);
         let state = state.new_level();
@@ -47,8 +35,17 @@ impl PrettyPrint for AggregateMultipliedSubquery {
         result.println("keys_subquery:", &state);
         self.keys_subquery.pretty_print(result, &details_state);
         result.println("source:", &state);
-        self.source.pretty_print(result, &details_state);
-
+        match self.source.as_ref() {
+            AggregateMultipliedSubquerySouce::Cube => {
+                result.println(&format!("Cube: {}", self.pk_cube.name()), &details_state);
+            }
+            AggregateMultipliedSubquerySouce::MeasureSubquery(measure_subquery) => {
+                result.println(
+                    &format!("MeasureSubquery: {}", measure_subquery.measures.len()),
+                    &details_state,
+                );
+                measure_subquery.pretty_print(result, &details_state);
+            }
+        }
     }
 }
-

rust/cubesqlplanner/cubesqlplanner/src/logical_plan/dimension_subquery.rs

@@ -1,6 +1,6 @@
 use super::pretty_print::*;
-use super::*;
 use super::LogicalSchema;
+use super::*;
 use crate::plan::{Expr, Filter, FilterItem, MemberExpression};
 use crate::planner::sql_evaluator::MemberSymbol;
 use std::rc::Rc;
@@ -10,7 +10,7 @@ pub struct DimensionSubQuery {
     pub primary_keys_dimensions: Vec<Rc<MemberSymbol>>,
     pub subquery_dimension: Rc<MemberSymbol>,
     pub measure_for_subquery_dimension: Rc<MemberSymbol>,
-} 
+}
 
 impl PrettyPrint for DimensionSubQuery {
     fn pretty_print(&self, result: &mut PrettyPrintResult, state: &PrettyPrintState) {
@@ -20,10 +20,25 @@ impl PrettyPrint for DimensionSubQuery {
         result.println(&format!("query: "), &state);
         self.query.pretty_print(result, &details_state);
         result.println(
-            &format!("-primary_keys_dimensions: {}", print_symbols(&self.primary_keys_dimensions)),
+            &format!(
+                "-primary_keys_dimensions: {}",
+                print_symbols(&self.primary_keys_dimensions)
+            ),
+            &state,
+        );
+        result.println(
+            &format!(
+                "-subquery_dimension: {}",
+                self.subquery_dimension.full_name()
+            ),
+            &state,
+        );
+        result.println(
+            &format!(
+                "-measure_for_subquery_dimension: {}",
+                self.measure_for_subquery_dimension.full_name()
+            ),
             &state,
         );
-        result.println(&format!("-subquery_dimension: {}", self.subquery_dimension.full_name()), &state);
-        result.println(&format!("-measure_for_subquery_dimension: {}", self.measure_for_subquery_dimension.full_name()), &state);
     }
-}
+}

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

@@ -1,8 +1,8 @@
 use super::pretty_print::*;
 use crate::plan::{Expr, Filter, FilterItem, MemberExpression};
 use crate::planner::sql_evaluator::MemberSymbol;
-use std::rc::Rc;
 use itertools::Itertools;
+use std::rc::Rc;
 
 pub struct LogicalFilter {
     pub dimensions_filters: Vec<FilterItem>,

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

@@ -1,11 +1,11 @@
 use super::*;
 use crate::plan::{Expr, Filter, FilterItem, MemberExpression};
-use crate::planner::sql_evaluator::MemberSymbol;
 use crate::planner::query_properties::OrderByItem;
+use crate::planner::sql_evaluator::MemberSymbol;
 use std::rc::Rc;
 
 pub struct MultiStageSubqueryRef {
-    pub name: String
+    pub name: String,
 }
 
 impl PrettyPrint for MultiStageSubqueryRef {
@@ -14,10 +14,9 @@ impl PrettyPrint for MultiStageSubqueryRef {
     }
 }
 
-    
 pub enum FullKeyAggregateSource {
     ResolveMultipliedMeasures(Rc<ResolveMultipliedMeasures>),
-    MultiStageSubqueryRef(Rc<MultiStageSubqueryRef>)
+    MultiStageSubqueryRef(Rc<MultiStageSubqueryRef>),
 }
 
 impl PrettyPrint for FullKeyAggregateSource {
@@ -35,7 +34,8 @@ impl PrettyPrint for FullKeyAggregateSource {
 
 pub struct FullKeyAggregate {
     pub join_dimensions: Vec<Rc<MemberSymbol>>,
-    pub sources: Vec<FullKeyAggregateSource>
+    pub use_full_join_and_coalesce: bool,
+    pub sources: Vec<FullKeyAggregateSource>,
 }
 
 impl PrettyPrint for FullKeyAggregate {
@@ -47,10 +47,16 @@ impl PrettyPrint for FullKeyAggregate {
             &format!("join_dimensions: {}", print_symbols(&self.join_dimensions)),
             &state,
         );
+        result.println(
+            &format!(
+                "use_full_join_and_coalesce: {}",
+                self.use_full_join_and_coalesce
+            ),
+            &state,
+        );
         result.println("sources:", &state);
         for source in self.sources.iter() {
             source.pretty_print(result, &details_state);
         }
     }
 }
-

rust/cubesqlplanner/cubesqlplanner/src/logical_plan/full_key_aggregate_query.rs

@@ -1,6 +1,6 @@
 use super::*;
-use std::rc::Rc;
 use crate::planner::query_properties::OrderByItem;
+use std::rc::Rc;
 
 pub struct FullKeyAggregateQuery {
     pub multistage_members: Vec<Rc<LogicalMultiStageMember>>,
@@ -14,7 +14,7 @@ pub struct FullKeyAggregateQuery {
 }
 
 impl PrettyPrint for FullKeyAggregateQuery {
-    fn pretty_print(&self, result: &mut PrettyPrintResult, state: &PrettyPrintState) {  
+    fn pretty_print(&self, result: &mut PrettyPrintResult, state: &PrettyPrintState) {
         result.println("FullKeyAggregateQuery: ", state);
         let state = state.new_level();
         let details_state = state.new_level();
@@ -39,11 +39,17 @@ impl PrettyPrint for FullKeyAggregateQuery {
         if !self.order_by.is_empty() {
             result.println("order_by:", &state);
             for order_by in self.order_by.iter() {
-                result.println(&format!("{} {}", order_by.name(), if order_by.desc() { "desc" } else { "asc" }), &details_state);
+                result.println(
+                    &format!(
+                        "{} {}",
+                        order_by.name(),
+                        if order_by.desc() { "desc" } else { "asc" }
+                    ),
+                    &details_state,
+                );
             }
         }
         result.println("source:", &state);
         self.source.pretty_print(result, &details_state);
     }
 }
-    

rust/cubesqlplanner/cubesqlplanner/src/logical_plan/keys_subquery.rs

@@ -7,7 +7,7 @@ pub struct KeysSubQuery {
     pub key_cube_name: String,
     pub time_dimensions: Vec<Rc<MemberSymbol>>,
     pub dimensions: Vec<Rc<MemberSymbol>>,
-   pub dimension_subqueries: Vec<Rc<DimensionSubQuery>>,
+    pub dimension_subqueries: Vec<Rc<DimensionSubQuery>>,
     pub primary_keys_dimensions: Vec<Rc<MemberSymbol>>,
     pub filter: Rc<LogicalFilter>,
     pub source: Rc<LogicalJoin>,
@@ -18,7 +18,7 @@ impl PrettyPrint for KeysSubQuery {
         result.println("KeysSubQuery: ", state);
         let state = state.new_level();
         let details_state = state.new_level();
-        result.println(&format!("-key_cube_name: {}", self.key_cube_name), &state); 
+        result.println(&format!("-key_cube_name: {}", self.key_cube_name), &state);
         result.println(
             &format!("-time_dimensions: {}", print_symbols(&self.time_dimensions)),
             &state,
@@ -27,14 +27,17 @@ impl PrettyPrint for KeysSubQuery {
             &format!("-dimensions: {}", print_symbols(&self.dimensions)),
             &state,
         );
-/*         if !self.dimension_subqueries.is_empty() {
+        /*         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(
-            &format!("-primary_keys_dimensions: {}", print_symbols(&self.primary_keys_dimensions)),
+            &format!(
+                "-primary_keys_dimensions: {}",
+                print_symbols(&self.primary_keys_dimensions)
+            ),
             &state,
         );
         result.println("filters:", &state);

rust/cubesqlplanner/cubesqlplanner/src/logical_plan/measure_subquery.rs

@@ -0,0 +1,36 @@
+use super::*;
+use crate::planner::query_properties::OrderByItem;
+use crate::planner::sql_evaluator::MemberSymbol;
+use std::rc::Rc;
+
+pub struct MeasureSubquery {
+    pub primary_keys_dimensions: Vec<Rc<MemberSymbol>>,
+    pub measures: Vec<Rc<MemberSymbol>>,
+    pub dimension_subqueries: Vec<Rc<DimensionSubQuery>>,
+    pub source: Rc<LogicalJoin>,
+}
+
+impl PrettyPrint for MeasureSubquery {
+    fn pretty_print(&self, result: &mut PrettyPrintResult, state: &PrettyPrintState) {
+        let details_state = state.new_level();
+        result.println(
+            &format!(
+                "primary_key_dimensions: {}",
+                print_symbols(&self.primary_keys_dimensions)
+            ),
+            state,
+        );
+        result.println(
+            &format!("measures: {}", print_symbols(&self.measures)),
+            state,
+        );
+        result.println("dimension_subqueries:", state);
+        if !self.dimension_subqueries.is_empty() {
+            for subquery in self.dimension_subqueries.iter() {
+                subquery.pretty_print(result, &details_state);
+            }
+        }
+        result.println("source:", state);
+        self.source.pretty_print(result, &details_state);
+    }
+}

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

@@ -1,31 +1,33 @@
+mod aggregate_multiplied_subquery;
 mod cube;
+mod dimension_subquery;
 mod filter;
+mod full_key_aggregate;
+mod full_key_aggregate_query;
 mod join;
+mod keys_subquery;
+mod measure_subquery;
+mod multistage;
 mod pretty_print;
-mod simple_query;
-mod schema;
+mod query;
 mod regular_measures_query;
-mod keys_subquery;
-mod aggregate_multiplied_subquery;
 mod resolve_multiplied_measures;
-mod full_key_aggregate;
-mod full_key_aggregate_query;
-mod query;
-mod dimension_subquery;
-mod multistage;
+mod schema;
+mod simple_query;
 
+pub use aggregate_multiplied_subquery::*;
 pub use cube::*;
+pub use dimension_subquery::*;
 pub use filter::*;
+pub use full_key_aggregate::*;
+pub use full_key_aggregate_query::*;
 pub use join::*;
+pub use keys_subquery::*;
+pub use measure_subquery::*;
+pub use multistage::*;
 pub use pretty_print::*;
-pub use simple_query::*;
-pub use dimension_subquery::*;
-pub use schema::*;
-pub use aggregate_multiplied_subquery::*;
+pub use query::*;
 pub use regular_measures_query::*;
-pub use keys_subquery::*;
 pub use resolve_multiplied_measures::*;
-pub use full_key_aggregate::*;
-pub use full_key_aggregate_query::*;
-pub use query::*;
-pub use multistage::*;
+pub use schema::*;
+pub use simple_query::*;