in work

Author: waralexrom

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

@@ -1,15 +1,11 @@
 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 modifers: Rc<LogicalQueryModifiers>,
     pub source: Rc<FullKeyAggregate>,
 }
 
@@ -29,26 +25,7 @@ impl PrettyPrint for FullKeyAggregateQuery {
         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,
-                );
-            }
-        }
+        self.modifers.pretty_print(result, &state);
         result.println("source:", &state);
         self.source.pretty_print(result, &details_state);
     }

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

@@ -1,7 +1,6 @@
 use super::pretty_print::*;
 use super::Cube;
-use super::SimpleQuery;
-use crate::planner::sql_evaluator::{MemberSymbol, SqlCall};
+use crate::planner::sql_evaluator::SqlCall;
 use std::rc::Rc;
 
 #[derive(Clone)]
@@ -18,31 +17,6 @@ impl PrettyPrint for CubeJoinItem {
     }
 }
 
-#[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),

rust/cubesqlplanner/cubesqlplanner/src/logical_plan/logical_query_modifers.rs

@@ -0,0 +1,36 @@
+use super::*;
+use crate::planner::query_properties::OrderByItem;
+
+pub struct LogicalQueryModifiers {
+    pub offset: Option<usize>,
+    pub limit: Option<usize>,
+    pub ungrouped: bool,
+    pub order_by: Vec<OrderByItem>,
+}
+
+impl PrettyPrint for LogicalQueryModifiers {
+    fn pretty_print(&self, result: &mut PrettyPrintResult, state: &PrettyPrintState) {
+        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() {
+            let details_state = state.new_level();
+            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,
+                );
+            }
+        }
+    }
+}
+

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

@@ -6,6 +6,7 @@ mod full_key_aggregate;
 mod full_key_aggregate_query;
 mod join;
 mod keys_subquery;
+mod logical_query_modifers;
 mod measure_subquery;
 mod multistage;
 pub mod optimizers;
@@ -25,6 +26,7 @@ pub use full_key_aggregate::*;
 pub use full_key_aggregate_query::*;
 pub use join::*;
 pub use keys_subquery::*;
+pub use logical_query_modifers::*;
 pub use measure_subquery::*;
 pub use multistage::*;
 pub use optimizers::*;

rust/cubesqlplanner/cubesqlplanner/src/logical_plan/optimizers/pre_aggregation/optimizer.rs

@@ -114,10 +114,7 @@ impl PreAggregationOptimizer {
                 schema: query.schema.clone(),
                 dimension_subqueries: vec![],
                 filter: query.filter.clone(),
-                offset: query.offset,
-                limit: query.limit,
-                ungrouped: query.ungrouped,
-                order_by: query.order_by.clone(),
+                modifers: query.modifers.clone(),
                 source,
             };
             Ok(Some(Rc::new(Query::SimpleQuery(new_query))))
@@ -170,10 +167,12 @@ impl PreAggregationOptimizer {
                         schema: resolver_multiplied_measures.schema.clone(),
                         dimension_subqueries: vec![],
                         filter: resolver_multiplied_measures.filter.clone(),
-                        offset: None,
-                        limit: None,
-                        ungrouped: false,
-                        order_by: vec![],
+                        modifers: Rc::new(LogicalQueryModifiers {
+                            offset: None,
+                            limit: None,
+                            ungrouped: false,
+                            order_by: vec![],
+                        }),
                         source: SimpleQuerySource::PreAggregation(pre_aggregation_source),
                     };
                     Rc::new(FullKeyAggregate {
@@ -200,10 +199,12 @@ impl PreAggregationOptimizer {
             multistage_members: multi_stages_queries,
             schema: query.schema.clone(),
             filter: query.filter.clone(),
-            offset: query.offset,
-            limit: query.limit,
-            ungrouped: query.ungrouped,
-            order_by: query.order_by.clone(),
+            modifers: Rc::new(LogicalQueryModifiers {
+                offset: query.modifers.offset,
+                limit: query.modifers.limit,
+                ungrouped: query.modifers.ungrouped,
+                order_by: query.modifers.order_by.clone(),
+            }),
             source,
         };
         Ok(Some(Rc::new(Query::FullKeyAggregateQuery(result))))

rust/cubesqlplanner/cubesqlplanner/src/logical_plan/optimizers/pre_aggregation/original_sql_optimizer.rs

@@ -41,10 +41,7 @@ impl OriginalSqlOptimizer {
                 multistage_members: query.multistage_members.clone(),
                 schema: query.schema.clone(),
                 filter: query.filter.clone(),
-                offset: query.offset,
-                limit: query.limit,
-                ungrouped: query.ungrouped,
-                order_by: query.order_by.clone(),
+                modifers: query.modifers.clone(),
                 source: optimized_source.unwrap_or_else(|| query.source.clone()),
             }))
         } else {
@@ -146,10 +143,7 @@ impl OriginalSqlOptimizer {
                     .unwrap_or_else(|| query.dimension_subqueries.clone()),
                 schema: query.schema.clone(),
                 filter: query.filter.clone(),
-                offset: query.offset,
-                limit: query.limit,
-                ungrouped: query.ungrouped,
-                order_by: query.order_by.clone(),
+                modifers: query.modifers.clone(),
             }))
         } else {
             Ok(None)

rust/cubesqlplanner/cubesqlplanner/src/logical_plan/simple_query.rs

@@ -1,5 +1,4 @@
 use super::*;
-use crate::planner::query_properties::OrderByItem;
 use std::rc::Rc;
 
 #[derive(Clone)]
@@ -22,10 +21,7 @@ pub struct SimpleQuery {
     pub schema: Rc<LogicalSchema>,
     pub dimension_subqueries: Vec<Rc<DimensionSubQuery>>,
     pub filter: Rc<LogicalFilter>,
-    pub offset: Option<usize>,
-    pub limit: Option<usize>,
-    pub ungrouped: bool,
-    pub order_by: Vec<OrderByItem>,
+    pub modifers: Rc<LogicalQueryModifiers>,
     pub source: SimpleQuerySource,
 }
 
@@ -44,26 +40,7 @@ impl PrettyPrint for SimpleQuery {
         }
         result.println("filters:", &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,
-                );
-            }
-        }
+        self.modifers.pretty_print(result, &state);
 
         result.println("source:", &state);
         self.source.pretty_print(result, &details_state);

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

@@ -134,7 +134,7 @@ impl PhysicalPlanBuilder {
         };
 
         let mut select_builder = SelectBuilder::new(from);
-        context_factory.set_ungrouped(logical_plan.ungrouped);
+        context_factory.set_ungrouped(logical_plan.modifers.ungrouped);
         context_factory.set_pre_aggregation_measures_references(measure_references);
         context_factory.set_pre_aggregation_dimensions_references(dimensions_references);
 
@@ -143,15 +143,15 @@ impl PhysicalPlanBuilder {
             let member_ref: Rc<dyn BaseMember> =
                 MemberSymbolRef::try_new(member.clone(), self.query_tools.clone())?;
             select_builder.add_projection_member(&member_ref, None);
-            if !logical_plan.ungrouped {
+            if !logical_plan.modifers.ungrouped {
                 group_by.push(Expr::Member(MemberExpression::new(member_ref.clone())));
             }
         }
         for member in logical_plan.schema.time_dimensions.iter() {
             let member_ref: Rc<dyn BaseMember> =
                 MemberSymbolRef::try_new(member.clone(), self.query_tools.clone())?;
             select_builder.add_projection_member(&member_ref, None);
-            if !logical_plan.ungrouped {
+            if !logical_plan.modifers.ungrouped {
                 group_by.push(Expr::Member(MemberExpression::new(member_ref.clone())));
             }
         }
@@ -174,15 +174,15 @@ impl PhysicalPlanBuilder {
         select_builder.set_filter(filter);
         select_builder.set_group_by(group_by);
         select_builder
-            .set_order_by(self.make_order_by(&logical_plan.schema, &logical_plan.order_by)?);
+            .set_order_by(self.make_order_by(&logical_plan.schema, &logical_plan.modifers.order_by)?);
         select_builder.set_having(having);
-        select_builder.set_limit(logical_plan.limit);
-        select_builder.set_offset(logical_plan.offset);
+        select_builder.set_limit(logical_plan.modifers.limit);
+        select_builder.set_offset(logical_plan.modifers.offset);
 
         context_factory
             .set_rendered_as_multiplied_measures(logical_plan.schema.multiplied_measures.clone());
         context_factory.set_render_references(render_references);
-        if logical_plan.ungrouped {
+        if logical_plan.modifers.ungrouped {
             context_factory.set_ungrouped(true);
         }
 
@@ -362,10 +362,10 @@ impl PhysicalPlanBuilder {
         };
 
         select_builder
-            .set_order_by(self.make_order_by(&logical_plan.schema, &logical_plan.order_by)?);
+            .set_order_by(self.make_order_by(&logical_plan.schema, &logical_plan.modifers.order_by)?);
         select_builder.set_filter(having);
-        select_builder.set_limit(logical_plan.limit);
-        select_builder.set_offset(logical_plan.offset);
+        select_builder.set_limit(logical_plan.modifers.limit);
+        select_builder.set_offset(logical_plan.modifers.offset);
         select_builder.set_ctes(ctes);
 
         let mut context_factory = context.make_sql_nodes_factory()?;

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

@@ -0,0 +1,32 @@
+use crate::plan::schema::QualifiedColumnName;
+use crate::planner::planners::multi_stage::TimeShiftState;
+use crate::planner::sql_evaluator::sql_nodes::SqlNodesFactory;
+use std::collections::HashMap;
+
+#[derive(Clone, Debug, Default)]
+pub(super) struct PushDownBuilderContext {
+    pub alias_prefix: Option<String>,
+    pub render_measure_as_state: bool, //Render measure as state, for example hll state for count_approx
+    pub render_measure_for_ungrouped: bool,
+    pub time_shifts: TimeShiftState,
+    pub original_sql_pre_aggregations: HashMap<String, String>,
+}
+
+impl PushDownBuilderContext {
+    pub fn make_sql_nodes_factory(&self) -> SqlNodesFactory {
+        let mut factory = SqlNodesFactory::new();
+        factory.set_time_shifts(self.time_shifts.clone());
+        factory.set_count_approx_as_state(self.render_measure_as_state);
+        factory.set_ungrouped_measure(self.render_measure_for_ungrouped);
+        factory.set_original_sql_pre_aggregations(self.original_sql_pre_aggregations.clone());
+        factory
+    }
+}
+
+#[derive(Clone, Debug, Default)]
+pub(super) struct PullUpBuilderContext {
+    pub render_references: HashMap<String, QualifiedColumnName>,
+    pub measure_references: HashMap<String, QualifiedColumnName>,
+    pub dimensions_references: HashMap<String, QualifiedColumnName>,
+    pub aliases: HashMap<String, String>,
+}

rust/cubesqlplanner/cubesqlplanner/src/physical_plan_builder/mod.rs

@@ -1,2 +1,9 @@
 mod builder;
+mod context;
+mod node_processor;
+mod processors;
+
 pub use builder::*;
+use context::*;
+use node_processor::*;
+use processors::*;