feat(tesseract): Logical plan

rust/cubesqlplanner/cubesqlplanner/src/lib.rs

@@ -1,3 +1,5 @@
 pub mod cube_bridge;
+pub mod logical_plan;
+pub mod physical_plan_builder;
 pub mod plan;
 pub mod planner;

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

@@ -0,0 +1,48 @@
+use super::pretty_print::*;
+use super::*;
+use crate::planner::BaseCube;
+use std::rc::Rc;
+
+pub enum AggregateMultipliedSubquerySouce {
+    Cube,
+    MeasureSubquery(Rc<MeasureSubquery>),
+}
+
+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 {
+    fn pretty_print(&self, result: &mut PrettyPrintResult, state: &PrettyPrintState) {
+        result.println("AggregateMultipliedSubquery: ", state);
+        let state = state.new_level();
+        let details_state = state.new_level();
+        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("keys_subquery:", &state);
+        self.keys_subquery.pretty_print(result, &details_state);
+        result.println("source:", &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/cube.rs

@@ -0,0 +1,16 @@
+use crate::planner::BaseCube;
+use std::rc::Rc;
+#[derive(Clone)]
+pub struct Cube {
+    pub name: String,
+    pub cube: Rc<BaseCube>,
+}
+
+impl Cube {
+    pub fn new(cube: Rc<BaseCube>) -> Rc<Self> {
+        Rc::new(Self {
+            name: cube.name().clone(),
+            cube,
+        })
+    }
+}

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

@@ -0,0 +1,42 @@
+use super::pretty_print::*;
+use super::*;
+use crate::planner::sql_evaluator::MemberSymbol;
+use std::rc::Rc;
+
+pub struct DimensionSubQuery {
+    pub query: Rc<Query>,
+    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) {
+        result.println("DimensionSubQuery: ", state);
+        let state = state.new_level();
+        let details_state = state.new_level();
+        result.println(&format!("query: "), &state);
+        self.query.pretty_print(result, &details_state);
+        result.println(
+            &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,
+        );
+    }
+}

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

@@ -0,0 +1,49 @@
+use super::pretty_print::*;
+use crate::plan::{Filter, FilterItem};
+use itertools::Itertools;
+
+pub struct LogicalFilter {
+    pub dimensions_filters: Vec<FilterItem>,
+    pub time_dimensions_filters: Vec<FilterItem>,
+    pub measures_filter: Vec<FilterItem>,
+    pub segments: Vec<FilterItem>,
+}
+
+impl LogicalFilter {
+    pub fn all_filters(&self) -> Option<Filter> {
+        let items = self
+            .time_dimensions_filters
+            .iter()
+            .chain(self.dimensions_filters.iter())
+            .chain(self.segments.iter())
+            .cloned()
+            .collect_vec();
+        if items.is_empty() {
+            None
+        } else {
+            Some(Filter { items })
+        }
+    }
+}
+
+impl PrettyPrint for LogicalFilter {
+    fn pretty_print(&self, result: &mut PrettyPrintResult, state: &PrettyPrintState) {
+        let details_state = state.new_level();
+        result.println("dimensions_filters:", &state);
+        for filter in self.dimensions_filters.iter() {
+            pretty_print_filter_item(result, &details_state, filter);
+        }
+        result.println("time_dimensions_filters:", &state);
+        for filter in self.time_dimensions_filters.iter() {
+            pretty_print_filter_item(result, &details_state, filter);
+        }
+        result.println("measures_filter:", &state);
+        for filter in self.measures_filter.iter() {
+            pretty_print_filter_item(result, &details_state, filter);
+        }
+        result.println("segments:", &state);
+        for filter in self.segments.iter() {
+            pretty_print_filter_item(result, &details_state, filter);
+        }
+    }
+}

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

@@ -0,0 +1,60 @@
+use super::*;
+use crate::planner::sql_evaluator::MemberSymbol;
+use std::rc::Rc;
+
+pub struct MultiStageSubqueryRef {
+    pub name: String,
+}
+
+impl PrettyPrint for MultiStageSubqueryRef {
+    fn pretty_print(&self, result: &mut PrettyPrintResult, state: &PrettyPrintState) {
+        result.println(&format!("MultiStageSubqueryRef: {}", self.name), state);
+    }
+}
+
+pub enum FullKeyAggregateSource {
+    ResolveMultipliedMeasures(Rc<ResolveMultipliedMeasures>),
+    MultiStageSubqueryRef(Rc<MultiStageSubqueryRef>),
+}
+
+impl PrettyPrint for FullKeyAggregateSource {
+    fn pretty_print(&self, result: &mut PrettyPrintResult, state: &PrettyPrintState) {
+        match self {
+            Self::ResolveMultipliedMeasures(resolve_multiplied_measures) => {
+                resolve_multiplied_measures.pretty_print(result, state);
+            }
+            Self::MultiStageSubqueryRef(subquery_ref) => {
+                subquery_ref.pretty_print(result, state);
+            }
+        }
+    }
+}
+
+pub struct FullKeyAggregate {
+    pub join_dimensions: Vec<Rc<MemberSymbol>>,
+    pub use_full_join_and_coalesce: bool,
+    pub sources: Vec<FullKeyAggregateSource>,
+}
+
+impl PrettyPrint for FullKeyAggregate {
+    fn pretty_print(&self, result: &mut PrettyPrintResult, state: &PrettyPrintState) {
+        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!(
+                "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

@@ -0,0 +1,55 @@
+use super::*;
+use crate::planner::query_properties::OrderByItem;
+use std::rc::Rc;
+
+pub struct FullKeyAggregateQuery {
+    pub multistage_members: Vec<Rc<LogicalMultiStageMember>>,
+    pub schema: Rc<LogicalSchema>,
+    pub filter: Rc<LogicalFilter>,
+    pub offset: Option<usize>,
+    pub limit: Option<usize>,
+    pub ungrouped: bool,
+    pub order_by: Vec<OrderByItem>,
+    pub source: Rc<FullKeyAggregate>,
+}
+
+impl PrettyPrint for FullKeyAggregateQuery {
+    fn pretty_print(&self, result: &mut PrettyPrintResult, state: &PrettyPrintState) {
+        result.println("FullKeyAggregateQuery: ", 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);
+        result.println("filter:", &state);
+        self.filter.pretty_print(result, &details_state);
+        if let Some(offset) = &self.offset {
+            result.println(&format!("offset:{}", offset), &state);
+        }
+        if let Some(limit) = &self.limit {
+            result.println(&format!("limit:{}", limit), &state);
+        }
+        result.println(&format!("ungrouped:{}", self.ungrouped), &state);
+        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("source:", &state);
+        self.source.pretty_print(result, &details_state);
+    }
+}

rust/cubesqlplanner/cubesqlplanner/src/logical_plan/join.rs

@@ -0,0 +1,74 @@
+use super::pretty_print::*;
+use super::Cube;
+use super::SimpleQuery;
+use crate::planner::sql_evaluator::{MemberSymbol, SqlCall};
+use std::rc::Rc;
+
+#[derive(Clone)]
+pub struct CubeJoinItem {
+    pub cube: Rc<Cube>,
+    pub on_sql: Rc<SqlCall>,
+}
+
+impl PrettyPrint for CubeJoinItem {
+    fn pretty_print(&self, result: &mut PrettyPrintResult, state: &PrettyPrintState) {
+        result.println(&format!("CubeJoinItem for cube: {}", self.cube.name), state);
+    }
+}
+
+#[derive(Clone)]
+pub struct SubqueryDimensionJoinItem {
+    pub subquery: Rc<SimpleQuery>,
+    pub dimension: Rc<MemberSymbol>,
+    pub primary_keys_dimensions: Vec<Rc<MemberSymbol>>,
+}
+
+impl PrettyPrint for SubqueryDimensionJoinItem {
+    fn pretty_print(&self, result: &mut PrettyPrintResult, state: &PrettyPrintState) {
+        result.println(
+            &format!(
+                "SubqueryDimensionJoinItem for dimension `{}`: ",
+                self.dimension.full_name()
+            ),
+            state,
+        );
+        result.println("subquery:", state);
+        result.println("primary_keys_dimensions:", state);
+        let state = state.new_level();
+        for dim in self.primary_keys_dimensions.iter() {
+            result.println(&format!("- {}", dim.full_name()), &state);
+        }
+    }
+}
+
+#[derive(Clone)]
+pub enum LogicalJoinItem {
+    CubeJoinItem(CubeJoinItem),
+}
+
+impl PrettyPrint for LogicalJoinItem {
+    fn pretty_print(&self, result: &mut PrettyPrintResult, state: &PrettyPrintState) {
+        match self {
+            LogicalJoinItem::CubeJoinItem(item) => item.pretty_print(result, state),
+        }
+    }
+}
+
+#[derive(Clone)]
+pub struct LogicalJoin {
+    pub root: Rc<Cube>,
+    pub joins: Vec<LogicalJoinItem>,
+}
+
+impl PrettyPrint for LogicalJoin {
+    fn pretty_print(&self, result: &mut PrettyPrintResult, state: &PrettyPrintState) {
+        result.println(&format!("Join: "), state);
+        let state = state.new_level();
+        result.println(&format!("root: {}", self.root.name), &state);
+        result.println(&format!("joins: "), &state);
+        let state = state.new_level();
+        for join in self.joins.iter() {
+            join.pretty_print(result, &state);
+        }
+    }
+}