builder for logical plan nodes

Author: waralexrom

rust/cubesqlplanner/.gitignore

@@ -11,3 +11,4 @@ node_modules
 /cubesql/egraph-debug-intermediate
 egraph-debug
 /cubesql/debug-qtrace
+.claude

rust/cubesqlplanner/cubesqlplanner/src/logical_plan/cube.rs

@@ -2,52 +2,73 @@ use super::*;
 use crate::planner::BaseCube;
 use cubenativeutils::CubeError;
 use std::rc::Rc;
+use typed_builder::TypedBuilder;
 
-#[derive(Clone)]
+#[derive(Clone, TypedBuilder)]
 pub struct OriginalSqlPreAggregation {
-    pub name: String,
+    name: String,
+}
+
+impl OriginalSqlPreAggregation {
+    pub fn name(&self) -> &String {
+        &self.name
+    }
 }
 
 impl PrettyPrint for OriginalSqlPreAggregation {
     fn pretty_print(&self, result: &mut PrettyPrintResult, state: &PrettyPrintState) {
-        result.println(&format!("OriginalSqlPreAggregation: {}", self.name), state);
+        result.println(&format!("OriginalSqlPreAggregation: {}", self.name()), state);
     }
 }
 
-#[derive(Clone)]
+#[derive(Clone, TypedBuilder)]
 pub struct Cube {
-    pub name: String,
-    pub cube: Rc<BaseCube>,
-    pub original_sql_pre_aggregation: Option<OriginalSqlPreAggregation>,
+    name: String,
+    cube: Rc<BaseCube>,
+    #[builder(default)]
+    original_sql_pre_aggregation: Option<OriginalSqlPreAggregation>,
+}
+
+impl Cube {
+    pub fn name(&self) -> &String {
+        &self.name
+    }
+
+    pub fn cube(&self) -> &Rc<BaseCube> {
+        &self.cube
+    }
+
+    pub fn original_sql_pre_aggregation(&self) -> &Option<OriginalSqlPreAggregation> {
+        &self.original_sql_pre_aggregation
+    }
 }
 
 impl PrettyPrint for Cube {
     fn pretty_print(&self, result: &mut PrettyPrintResult, state: &PrettyPrintState) {
-        result.println(&format!("Cube: {}", self.name), state);
-        if let Some(original_sql_pre_aggregation) = &self.original_sql_pre_aggregation {
+        result.println(&format!("Cube: {}", self.name()), state);
+        if let Some(original_sql_pre_aggregation) = self.original_sql_pre_aggregation() {
             original_sql_pre_aggregation.pretty_print(result, state);
         }
     }
 }
 
 impl Cube {
     pub fn new(cube: Rc<BaseCube>) -> Rc<Self> {
-        Rc::new(Self {
-            name: cube.name().clone(),
-            cube,
-            original_sql_pre_aggregation: None,
-        })
+        Rc::new(Self::builder()
+            .name(cube.name().clone())
+            .cube(cube)
+            .build())
     }
 
     pub fn with_original_sql_pre_aggregation(
         self: Rc<Self>,
         original_sql_pre_aggregation: OriginalSqlPreAggregation,
     ) -> Rc<Self> {
-        Rc::new(Self {
-            name: self.name.clone(),
-            cube: self.cube.clone(),
-            original_sql_pre_aggregation: Some(original_sql_pre_aggregation),
-        })
+        Rc::new(Self::builder()
+            .name(self.name().clone())
+            .cube(self.cube().clone())
+            .original_sql_pre_aggregation(Some(original_sql_pre_aggregation))
+            .build())
     }
 }
 

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

@@ -2,18 +2,31 @@ use super::*;
 use crate::planner::sql_evaluator::MemberSymbol;
 use cubenativeutils::CubeError;
 use std::rc::Rc;
+use typed_builder::TypedBuilder;
 
+#[derive(TypedBuilder)]
 pub struct MultiStageSubqueryRef {
-    pub name: String,
-    pub symbols: Vec<Rc<MemberSymbol>>,
+    name: String,
+    #[builder(default)]
+    symbols: Vec<Rc<MemberSymbol>>,
+}
+
+impl MultiStageSubqueryRef {
+    pub fn name(&self) -> &String {
+        &self.name
+    }
+
+    pub fn symbols(&self) -> &Vec<Rc<MemberSymbol>> {
+        &self.symbols
+    }
 }
 
 impl PrettyPrint for MultiStageSubqueryRef {
     fn pretty_print(&self, result: &mut PrettyPrintResult, state: &PrettyPrintState) {
-        result.println(&format!("MultiStageSubqueryRef: {}", self.name), state);
+        result.println(&format!("MultiStageSubqueryRef: {}", self.name()), state);
         let state = state.new_level();
         result.println(
-            &format!("symbols: {}", print_symbols(&self.symbols)),
+            &format!("symbols: {}", print_symbols(self.symbols())),
             &state,
         );
     }
@@ -52,12 +65,32 @@ impl PrettyPrint for ResolvedMultipliedMeasures {
     }
 }
 
-#[derive(Clone)]
+#[derive(Clone, TypedBuilder)]
 pub struct FullKeyAggregate {
-    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>>,
+    schema: Rc<LogicalSchema>,
+    use_full_join_and_coalesce: bool,
+    #[builder(default)]
+    multiplied_measures_resolver: Option<ResolvedMultipliedMeasures>,
+    #[builder(default)]
+    multi_stage_subquery_refs: Vec<Rc<MultiStageSubqueryRef>>,
+}
+
+impl FullKeyAggregate {
+    pub fn schema(&self) -> &Rc<LogicalSchema> {
+        &self.schema
+    }
+
+    pub fn use_full_join_and_coalesce(&self) -> bool {
+        self.use_full_join_and_coalesce
+    }
+
+    pub fn multiplied_measures_resolver(&self) -> &Option<ResolvedMultipliedMeasures> {
+        &self.multiplied_measures_resolver
+    }
+
+    pub fn multi_stage_subquery_refs(&self) -> &Vec<Rc<MultiStageSubqueryRef>> {
+        &self.multi_stage_subquery_refs
+    }
 }
 
 impl LogicalNode for FullKeyAggregate {
@@ -66,7 +99,7 @@ impl LogicalNode for FullKeyAggregate {
     }
 
     fn inputs(&self) -> Vec<PlanNode> {
-        if let Some(resolver) = &self.multiplied_measures_resolver {
+        if let Some(resolver) = self.multiplied_measures_resolver() {
             vec![match resolver {
                 ResolvedMultipliedMeasures::ResolveMultipliedMeasures(item) => item.as_plan_node(),
                 ResolvedMultipliedMeasures::PreAggregation(item) => item.as_plan_node(),
@@ -77,14 +110,14 @@ impl LogicalNode for FullKeyAggregate {
     }
 
     fn with_inputs(self: Rc<Self>, inputs: Vec<PlanNode>) -> Result<Rc<Self>, CubeError> {
-        let multiplied_measures_resolver = if self.multiplied_measures_resolver.is_none() {
+        let multiplied_measures_resolver = if self.multiplied_measures_resolver().is_none() {
             check_inputs_len(&inputs, 0, self.node_name())?;
             None
         } else {
             check_inputs_len(&inputs, 1, self.node_name())?;
             let input_source = &inputs[0];
 
-            Some(match self.multiplied_measures_resolver.as_ref().unwrap() {
+            Some(match self.multiplied_measures_resolver().as_ref().unwrap() {
                 ResolvedMultipliedMeasures::ResolveMultipliedMeasures(_) => {
                     ResolvedMultipliedMeasures::ResolveMultipliedMeasures(
                         input_source.clone().into_logical_node()?,
@@ -98,12 +131,12 @@ impl LogicalNode for FullKeyAggregate {
             })
         };
 
-        Ok(Rc::new(Self {
-            schema: self.schema.clone(),
-            use_full_join_and_coalesce: self.use_full_join_and_coalesce,
-            multiplied_measures_resolver,
-            multi_stage_subquery_refs: self.multi_stage_subquery_refs.clone(),
-        }))
+        Ok(Rc::new(Self::builder()
+            .schema(self.schema().clone())
+            .use_full_join_and_coalesce(self.use_full_join_and_coalesce())
+            .multiplied_measures_resolver(multiplied_measures_resolver)
+            .multi_stage_subquery_refs(self.multi_stage_subquery_refs().clone())
+            .build()))
     }
 
     fn node_name(&self) -> &'static str {
@@ -124,22 +157,22 @@ impl PrettyPrint for FullKeyAggregate {
         let state = state.new_level();
         let details_state = state.new_level();
         result.println(&format!("schema:"), &state);
-        self.schema.pretty_print(result, &details_state);
+        self.schema().pretty_print(result, &details_state);
         result.println(
             &format!(
                 "use_full_join_and_coalesce: {}",
-                self.use_full_join_and_coalesce
+                self.use_full_join_and_coalesce()
             ),
             &state,
         );
-        if let Some(resolve_multiplied_measures) = &self.multiplied_measures_resolver {
+        if let Some(resolve_multiplied_measures) = self.multiplied_measures_resolver() {
             result.println("multiplied measures resolver:", &state);
             resolve_multiplied_measures.pretty_print(result, &details_state);
         }
 
-        if !self.multi_stage_subquery_refs.is_empty() {
+        if !self.multi_stage_subquery_refs().is_empty() {
             result.println("multi_stage_subquery_refs:", &state);
-            for subquery_ref in self.multi_stage_subquery_refs.iter() {
+            for subquery_ref in self.multi_stage_subquery_refs().iter() {
                 subquery_ref.pretty_print(result, &details_state);
             }
         }

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

@@ -3,26 +3,53 @@ use super::*;
 use crate::planner::sql_evaluator::SqlCall;
 use cubenativeutils::CubeError;
 use std::rc::Rc;
+use typed_builder::TypedBuilder;
 
-#[derive(Clone)]
+#[derive(Clone, TypedBuilder)]
 pub struct LogicalJoinItem {
-    pub cube: Rc<Cube>,
-    pub on_sql: Rc<SqlCall>,
+    cube: Rc<Cube>,
+    on_sql: Rc<SqlCall>,
+}
+
+impl LogicalJoinItem {
+    pub fn cube(&self) -> &Rc<Cube> {
+        &self.cube
+    }
+
+    pub fn on_sql(&self) -> &Rc<SqlCall> {
+        &self.on_sql
+    }
 }
 
 impl PrettyPrint for LogicalJoinItem {
     fn pretty_print(&self, result: &mut PrettyPrintResult, state: &PrettyPrintState) {
         result.println(&format!("CubeJoinItem: "), state);
         let details_state = state.new_level();
-        self.cube.pretty_print(result, &details_state);
+        self.cube().pretty_print(result, &details_state);
     }
 }
 
-#[derive(Clone)]
+#[derive(Clone, TypedBuilder)]
 pub struct LogicalJoin {
-    pub root: Rc<Cube>,
-    pub joins: Vec<LogicalJoinItem>,
-    pub dimension_subqueries: Vec<Rc<DimensionSubQuery>>,
+    root: Rc<Cube>,
+    #[builder(default)]
+    joins: Vec<LogicalJoinItem>,
+    #[builder(default)]
+    dimension_subqueries: Vec<Rc<DimensionSubQuery>>,
+}
+
+impl LogicalJoin {
+    pub fn root(&self) -> &Rc<Cube> {
+        &self.root
+    }
+
+    pub fn joins(&self) -> &Vec<LogicalJoinItem> {
+        &self.joins
+    }
+
+    pub fn dimension_subqueries(&self) -> &Vec<Rc<DimensionSubQuery>> {
+        &self.dimension_subqueries
+    }
 }
 
 impl LogicalNode for LogicalJoin {
@@ -42,25 +69,25 @@ impl LogicalNode for LogicalJoin {
         } = LogicalJoinInputUnPacker::new(&self, &inputs)?;
 
         let joins = self
-            .joins
+            .joins()
             .iter()
             .zip(joins.iter())
             .map(|(self_item, item)| -> Result<_, CubeError> {
-                Ok(LogicalJoinItem {
-                    cube: item.clone().into_logical_node()?,
-                    on_sql: self_item.on_sql.clone(),
-                })
+                Ok(LogicalJoinItem::builder()
+                    .cube(item.clone().into_logical_node()?)
+                    .on_sql(self_item.on_sql().clone())
+                    .build())
             })
             .collect::<Result<Vec<_>, _>>()?;
 
-        let result = Self {
-            root: root.clone().into_logical_node()?,
-            joins,
-            dimension_subqueries: dimension_subqueries
+        let result = Self::builder()
+            .root(root.clone().into_logical_node()?)
+            .joins(joins)
+            .dimension_subqueries(dimension_subqueries
                 .iter()
                 .map(|itm| itm.clone().into_logical_node())
-                .collect::<Result<Vec<_>, _>>()?,
-        };
+                .collect::<Result<Vec<_>, _>>()?)
+            .build();
 
         Ok(Rc::new(result))
     }
@@ -82,10 +109,10 @@ pub struct LogicalJoinInputPacker;
 impl LogicalJoinInputPacker {
     pub fn pack(join: &LogicalJoin) -> Vec<PlanNode> {
         let mut result = vec![];
-        result.push(join.root.as_plan_node());
-        result.extend(join.joins.iter().map(|item| item.cube.as_plan_node()));
+        result.push(join.root().as_plan_node());
+        result.extend(join.joins().iter().map(|item| item.cube().as_plan_node()));
         result.extend(
-            join.dimension_subqueries
+            join.dimension_subqueries()
                 .iter()
                 .map(|item| item.as_plan_node()),
         );
@@ -105,7 +132,7 @@ impl<'a> LogicalJoinInputUnPacker<'a> {
 
         let root = &inputs[0];
         let joins_start = 1;
-        let joins_end = joins_start + join.joins.len();
+        let joins_end = joins_start + join.joins().len();
         let joins = &inputs[joins_start..joins_end];
         let dimension_subqueries = &inputs[joins_end..];
 
@@ -117,7 +144,7 @@ impl<'a> LogicalJoinInputUnPacker<'a> {
     }
 
     fn inputs_len(join: &LogicalJoin) -> usize {
-        1 + join.joins.len() + join.dimension_subqueries.len()
+        1 + join.joins().len() + join.dimension_subqueries().len()
     }
 }
 
@@ -127,16 +154,16 @@ impl PrettyPrint for LogicalJoin {
         let state = state.new_level();
         let details_state = state.new_level();
         result.println(&format!("root: "), &state);
-        self.root.pretty_print(result, &details_state);
+        self.root().pretty_print(result, &details_state);
         result.println(&format!("joins: "), &state);
         let state = state.new_level();
-        for join in self.joins.iter() {
+        for join in self.joins().iter() {
             join.pretty_print(result, &state);
         }
-        if !self.dimension_subqueries.is_empty() {
+        if !self.dimension_subqueries().is_empty() {
             result.println("dimension_subqueries:", &state);
             let details_state = state.new_level();
-            for subquery in self.dimension_subqueries.iter() {
+            for subquery in self.dimension_subqueries().iter() {
                 subquery.pretty_print(result, &details_state);
             }
         }