in work

Author: waralexrom

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

@@ -13,7 +13,7 @@ pub struct QueryProcessor<'a> {
 
 impl QueryProcessor<'_> {
     fn is_over_full_aggregated_source(&self, logical_plan: &Query) -> bool {
-        match logical_plan.source {
+        match logical_plan.source() {
             QuerySource::FullKeyAggregate(_) => true,
             QuerySource::PreAggregation(_) => false,
             QuerySource::LogicalJoin(_) => false,
@@ -38,7 +38,7 @@ impl<'a> LogicalNodeProcessor<'a, Query> for QueryProcessor<'a> {
         let mut context = context.clone();
         let mut ctes = vec![];
 
-        for multi_stage_member in logical_plan.multistage_members.iter() {
+        for multi_stage_member in logical_plan.multistage_members().iter() {
             let query = self
                 .builder
                 .process_node(&multi_stage_member.member_type, &context)?;
@@ -47,7 +47,7 @@ impl<'a> LogicalNodeProcessor<'a, Query> for QueryProcessor<'a> {
             ctes.push(Rc::new(Cte::new(Rc::new(query), alias)));
         }
 
-        let (from, is_pre_aggregation) = match &logical_plan.source {
+        let (from, is_pre_aggregation) = match logical_plan.source() {
             QuerySource::LogicalJoin(join) => {
                 let from = self.builder.process_node(join.as_ref(), &context)?;
                 let references_builder = ReferencesBuilder::new(from.clone());
@@ -68,7 +68,7 @@ impl<'a> LogicalNodeProcessor<'a, Query> for QueryProcessor<'a> {
                 let res = self
                     .builder
                     .process_node(pre_aggregation.as_ref(), &context)?;
-                for member in logical_plan.schema.time_dimensions.iter() {
+                for member in logical_plan.schema().time_dimensions.iter() {
                     context_factory.add_dimensions_with_ignored_timezone(member.full_name());
                 }
                 context_factory.set_use_local_tz_in_date_range(true);
@@ -86,12 +86,12 @@ impl<'a> LogicalNodeProcessor<'a, Query> for QueryProcessor<'a> {
 
         let mut select_builder = SelectBuilder::new(from);
         select_builder.set_ctes(ctes);
-        context_factory.set_ungrouped(logical_plan.modifers.ungrouped);
+        context_factory.set_ungrouped(logical_plan.modifers().ungrouped);
 
-        let filter = logical_plan.filter.all_filters();
-        let having = logical_plan.filter.measures_filter();
+        let filter = logical_plan.filter().all_filters();
+        let having = logical_plan.filter().measures_filter();
 
-        for member in logical_plan.schema.all_dimensions() {
+        for member in logical_plan.schema().all_dimensions() {
             references_builder.resolve_references_for_member(
                 member.clone(),
                 &None,
@@ -108,7 +108,7 @@ impl<'a> LogicalNodeProcessor<'a, Query> for QueryProcessor<'a> {
 
         for (measure, exists) in self
             .builder
-            .measures_for_query(&logical_plan.schema.measures, &context)
+            .measures_for_query(&logical_plan.schema().measures, &context)
         {
             if exists {
                 references_builder.resolve_references_for_member(
@@ -126,9 +126,9 @@ impl<'a> LogicalNodeProcessor<'a, Query> for QueryProcessor<'a> {
             references_builder.resolve_references_for_filter(&having, &mut render_references)?;
             select_builder.set_filter(having);
         } else {
-            if !logical_plan.modifers.ungrouped {
+            if !logical_plan.modifers().ungrouped {
                 let group_by = logical_plan
-                    .schema
+                    .schema()
                     .all_dimensions()
                     .map(|symbol| -> Result<_, CubeError> {
                         Ok(Expr::Member(MemberExpression::new(symbol.clone())))
@@ -140,21 +140,21 @@ impl<'a> LogicalNodeProcessor<'a, Query> for QueryProcessor<'a> {
             select_builder.set_filter(filter);
         }
 
-        select_builder.set_limit(logical_plan.modifers.limit);
-        select_builder.set_offset(logical_plan.modifers.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());
+            .set_rendered_as_multiplied_measures(logical_plan.schema().multiplied_measures.clone());
         if !is_pre_aggregation {
             context_factory.set_render_references(render_references);
         }
-        if logical_plan.modifers.ungrouped {
+        if logical_plan.modifers().ungrouped {
             context_factory.set_ungrouped(true);
         }
 
         select_builder.set_order_by(
             self.builder
-                .make_order_by(&logical_plan.schema, &logical_plan.modifers.order_by)?,
+                .make_order_by(logical_plan.schema(), &logical_plan.modifers().order_by)?,
         );
 
         let res = Rc::new(select_builder.build(query_tools.clone(), context_factory));

rust/cubesqlplanner/cubesqlplanner/src/planner/planners/full_key_query_aggregate_planner.rs

@@ -74,18 +74,18 @@ impl FullKeyAggregateQueryPlanner {
             measures_filter: self.query_properties.measures_filters().clone(),
             segments: self.query_properties.segments().clone(),
         });
-        let result = Query {
-            schema,
-            multistage_members: all_multistage_members,
-            filter: logical_filter,
-            modifers: Rc::new(LogicalQueryModifiers {
+        let result = Query::builder()
+            .schema(schema)
+            .multistage_members(all_multistage_members)
+            .filter(logical_filter)
+            .modifers(Rc::new(LogicalQueryModifiers {
                 offset: self.query_properties.offset(),
                 limit: self.query_properties.row_limit(),
                 ungrouped: self.query_properties.ungrouped(),
                 order_by: self.query_properties.order_by().clone(),
-            }),
-            source,
-        };
+            }))
+            .source(source)
+            .build();
         Ok(Rc::new(result))
     }
 }

rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multiplied_measures_query_planner.rs

@@ -286,18 +286,17 @@ impl MultipliedMeasuresQueryPlanner {
             segments: self.query_properties.segments().clone(),
         });
 
-        let query = Query {
-            schema,
-            filter: logical_filter,
-            modifers: Rc::new(LogicalQueryModifiers {
+        let query = Query::builder()
+            .schema(schema)
+            .filter(logical_filter)
+            .modifers(Rc::new(LogicalQueryModifiers {
                 offset: None,
                 limit: None,
                 ungrouped: self.query_properties.ungrouped(),
                 order_by: vec![],
-            }),
-            source: source.into(),
-            multistage_members: vec![],
-        };
+            }))
+            .source(source.into())
+            .build();
         Ok(Rc::new(query))
     }
 

rust/cubesqlplanner/cubesqlplanner/src/planner/planners/simple_query_planer.rs

@@ -40,18 +40,17 @@ impl SimpleQueryPlanner {
             measures_filter: self.query_properties.measures_filters().clone(),
             segments: self.query_properties.segments().clone(),
         });
-        let result = Query {
-            multistage_members: vec![],
-            schema,
-            filter: logical_filter,
-            modifers: Rc::new(LogicalQueryModifiers {
+        let result = Query::builder()
+            .schema(schema)
+            .filter(logical_filter)
+            .modifers(Rc::new(LogicalQueryModifiers {
                 offset: self.query_properties.offset(),
                 limit: self.query_properties.row_limit(),
                 ungrouped: self.query_properties.ungrouped(),
                 order_by: self.query_properties.order_by().clone(),
-            }),
-            source: source.into(),
-        };
+            }))
+            .source(source.into())
+            .build();
         Ok(Rc::new(result))
     }