in work

Author: waralexrom

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

@@ -32,41 +32,28 @@ pub struct AggregateMultipliedSubquery {
 }
 
 impl LogicalNode for AggregateMultipliedSubquery {
-    type InputsType = AggregateMultipliedSubqueryInput;
-
     fn as_plan_node(self: &Rc<Self>) -> PlanNode {
         PlanNode::AggregateMultipliedSubquery(self.clone())
     }
 
-    fn inputs(&self) -> Self::InputsType {
-        let keys_subquery = self.keys_subquery.as_plan_node();
-        let source = self.source.as_plan_node();
-        let dimension_subqueries = self
-            .dimension_subqueries
-            .iter()
-            .map(|itm| itm.as_plan_node())
-            .collect_vec();
-        AggregateMultipliedSubqueryInput {
-            keys_subquery,
-            source,
-            dimension_subqueries,
-        }
+    fn inputs(&self) -> Vec<PlanNode> {
+        AggregateMultipliedSubqueryInputPacker::pack(self)
     }
 
-    fn with_inputs(self: Rc<Self>, inputs: Self::InputsType) -> Result<Rc<Self>, CubeError> {
-        let AggregateMultipliedSubqueryInput {
+    fn with_inputs(self: Rc<Self>, inputs: Vec<PlanNode>) -> Result<Rc<Self>, CubeError> {
+        let AggregateMultipliedSubqueryInputUnPacker {
             keys_subquery,
             source,
             dimension_subqueries,
-        } = inputs;
+        } = AggregateMultipliedSubqueryInputUnPacker::new(&self, &inputs)?;
 
         let result = Self {
             schema: self.schema.clone(),
-            keys_subquery: keys_subquery.into_logical_node()?,
-            source: self.source.with_plan_node(source)?,
+            keys_subquery: keys_subquery.clone().into_logical_node()?,
+            source: self.source.with_plan_node(source.clone())?,
             dimension_subqueries: dimension_subqueries
                 .into_iter()
-                .map(|itm| itm.into_logical_node())
+                .map(|itm| itm.clone().into_logical_node())
                 .collect::<Result<Vec<_>, _>>()?,
         };
 
@@ -85,27 +72,41 @@ impl LogicalNode for AggregateMultipliedSubquery {
     }
 }
 
-pub struct AggregateMultipliedSubqueryInput {
-    pub keys_subquery: PlanNode,
-    pub source: PlanNode,
-    pub dimension_subqueries: Vec<PlanNode>,
-}
+pub struct AggregateMultipliedSubqueryInputPacker;
 
-impl NodeInputs for AggregateMultipliedSubqueryInput {
-    fn iter(&self) -> Box<dyn Iterator<Item = &PlanNode> + '_> {
-        Box::new(
-            std::iter::once(&self.keys_subquery)
-                .chain(std::iter::once(&self.source))
-                .chain(self.dimension_subqueries.iter()),
-        )
+impl AggregateMultipliedSubqueryInputPacker {
+    pub fn pack(aggregate: &AggregateMultipliedSubquery) -> Vec<PlanNode> {
+        let mut result = vec![];
+        result.push(aggregate.keys_subquery.as_plan_node());
+        result.push(aggregate.source.as_plan_node());
+        result.extend(aggregate.dimension_subqueries.iter().map(|itm| itm.as_plan_node()));
+        result
     }
+}
 
-    fn iter_mut(&mut self) -> Box<dyn Iterator<Item = &mut PlanNode> + '_> {
-        Box::new(
-            std::iter::once(&mut self.keys_subquery)
-                .chain(std::iter::once(&mut self.source))
-                .chain(self.dimension_subqueries.iter_mut()),
-        )
+pub struct AggregateMultipliedSubqueryInputUnPacker<'a> {
+    keys_subquery: &'a PlanNode,
+    source: &'a PlanNode,
+    dimension_subqueries: &'a [PlanNode],
+}
+
+impl<'a> AggregateMultipliedSubqueryInputUnPacker<'a> {
+    pub fn new(aggregate: &AggregateMultipliedSubquery, inputs: &'a Vec<PlanNode>) -> Result<Self, CubeError> {
+        check_inputs_len(&inputs, Self::inputs_len(aggregate), aggregate.node_name())?;
+        
+        let keys_subquery = &inputs[0];
+        let source = &inputs[1];
+        let dimension_subqueries = &inputs[2..];
+        
+        Ok(Self {
+            keys_subquery,
+            source,
+            dimension_subqueries,
+        })
+    }
+    
+    fn inputs_len(aggregate: &AggregateMultipliedSubquery) -> usize {
+        2 + aggregate.dimension_subqueries.len()
     }
 }
 

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

@@ -27,65 +27,39 @@ pub struct LogicalJoin {
 }
 
 impl LogicalNode for LogicalJoin {
-    type InputsType = LogicalJoinInput;
-
     fn as_plan_node(self: &Rc<Self>) -> PlanNode {
         PlanNode::LogicalJoin(self.clone())
     }
 
-    fn inputs(&self) -> Self::InputsType {
-        let root = self.root.as_plan_node();
-        let joins = self
-            .joins
-            .iter()
-            .map(|itm| itm.cube.as_plan_node())
-            .collect_vec();
-        let dimension_subqueries = self
-            .dimension_subqueries
-            .iter()
-            .map(|itm| itm.as_plan_node())
-            .collect_vec();
-        LogicalJoinInput {
-            root,
-            joins,
-            dimension_subqueries,
-        }
+    fn inputs(&self) -> Vec<PlanNode> {
+        LogicalJoinInputPacker::pack(self)
     }
 
-    fn with_inputs(self: Rc<Self>, inputs: Self::InputsType) -> Result<Rc<Self>, CubeError> {
-        let LogicalJoinInput {
+    fn with_inputs(self: Rc<Self>, inputs: Vec<PlanNode>) -> Result<Rc<Self>, CubeError> {
+        let LogicalJoinInputUnPacker {
             root,
             joins,
             dimension_subqueries,
-        } = inputs;
-
-        check_inputs_len("joins", &joins, self.joins.len(), self.node_name())?;
-
-        check_inputs_len(
-            "dimension_subqueries",
-            &dimension_subqueries,
-            self.dimension_subqueries.len(),
-            self.node_name(),
-        )?;
+        } = LogicalJoinInputUnPacker::new(&self, &inputs)?;
 
         let joins = self
             .joins
             .iter()
             .zip(joins.into_iter())
             .map(|(self_item, item)| -> Result<_, CubeError> {
                 Ok(LogicalJoinItem {
-                    cube: item.into_logical_node()?,
+                    cube: item.clone().into_logical_node()?,
                     on_sql: self_item.on_sql.clone(),
                 })
             })
             .collect::<Result<Vec<_>, _>>()?;
 
         let result = Self {
-            root: root.into_logical_node()?,
+            root: root.clone().into_logical_node()?,
             joins,
             dimension_subqueries: dimension_subqueries
                 .into_iter()
-                .map(|itm| itm.into_logical_node())
+                .map(|itm| itm.clone().into_logical_node())
                 .collect::<Result<Vec<_>, _>>()?,
         };
 
@@ -104,27 +78,43 @@ impl LogicalNode for LogicalJoin {
     }
 }
 
-pub struct LogicalJoinInput {
-    pub root: PlanNode,
-    pub joins: Vec<PlanNode>,
-    pub dimension_subqueries: Vec<PlanNode>,
-}
+pub struct LogicalJoinInputPacker;
 
-impl NodeInputs for LogicalJoinInput {
-    fn iter(&self) -> Box<dyn Iterator<Item = &PlanNode> + '_> {
-        Box::new(
-            std::iter::once(&self.root)
-                .chain(self.joins.iter())
-                .chain(self.dimension_subqueries.iter()),
-        )
+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.extend(join.dimension_subqueries.iter().map(|item| item.as_plan_node()));
+        result
     }
+}
+
+pub struct LogicalJoinInputUnPacker<'a> {
+    root: &'a PlanNode,
+    joins: &'a [PlanNode],
+    dimension_subqueries: &'a [PlanNode],
+}
 
-    fn iter_mut(&mut self) -> Box<dyn Iterator<Item = &mut PlanNode> + '_> {
-        Box::new(
-            std::iter::once(&mut self.root)
-                .chain(self.joins.iter_mut())
-                .chain(self.dimension_subqueries.iter_mut()),
-        )
+impl<'a> LogicalJoinInputUnPacker<'a> {
+    pub fn new(join: &LogicalJoin, inputs: &'a Vec<PlanNode>) -> Result<Self, CubeError> {
+        check_inputs_len(&inputs, Self::inputs_len(join), join.node_name())?;
+        
+        let root = &inputs[0];
+        let joins_start = 1;
+        let joins_end = joins_start + join.joins.len();
+        let joins = &inputs[joins_start..joins_end];
+        let dimension_subqueries = &inputs[joins_end..];
+        
+        Ok(Self {
+            root,
+            joins,
+            dimension_subqueries,
+        })
+    }
+    
+    fn inputs_len(join: &LogicalJoin) -> usize {
+        1 + join.joins.len() + join.dimension_subqueries.len()
     }
 }
 

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

@@ -13,28 +13,25 @@ pub struct KeysSubQuery {
 }
 
 impl LogicalNode for KeysSubQuery {
-    type InputsType = KeysSubQueryInputs;
-
     fn as_plan_node(self: &Rc<Self>) -> PlanNode {
         PlanNode::KeysSubQuery(self.clone())
     }
 
-    fn inputs(&self) -> Self::InputsType {
-        KeysSubQueryInputs {
-            pk_cube: self.pk_cube.as_plan_node(),
-            source: self.source.as_plan_node(),
-        }
+    fn inputs(&self) -> Vec<PlanNode> {
+        vec![self.pk_cube.as_plan_node(), self.source.as_plan_node()]
     }
 
-    fn with_inputs(self: Rc<Self>, inputs: Self::InputsType) -> Result<Rc<Self>, CubeError> {
-        let KeysSubQueryInputs { pk_cube, source } = inputs;
+    fn with_inputs(self: Rc<Self>, inputs: Vec<PlanNode>) -> Result<Rc<Self>, CubeError> {
+        check_inputs_len(&inputs, 2, self.node_name())?;
+        let pk_cube = &inputs[0];
+        let source = &inputs[1];
 
         let res = Self {
-            pk_cube: pk_cube.into_logical_node()?,
+            pk_cube: pk_cube.clone().into_logical_node()?,
             schema: self.schema.clone(),
             primary_keys_dimensions: self.primary_keys_dimensions.clone(),
             filter: self.filter.clone(),
-            source: source.into_logical_node()?,
+            source: source.clone().into_logical_node()?,
         };
         Ok(Rc::new(res))
     }
@@ -51,20 +48,6 @@ impl LogicalNode for KeysSubQuery {
     }
 }
 
-pub struct KeysSubQueryInputs {
-    pub pk_cube: PlanNode,
-    pub source: PlanNode,
-}
-
-impl NodeInputs for KeysSubQueryInputs {
-    fn iter(&self) -> Box<dyn Iterator<Item = &PlanNode> + '_> {
-        Box::new(std::iter::once(&self.pk_cube).chain(std::iter::once(&self.source)))
-    }
-
-    fn iter_mut(&mut self) -> Box<dyn Iterator<Item = &mut PlanNode> + '_> {
-        Box::new(std::iter::once(&mut self.pk_cube).chain(std::iter::once(&mut self.source)))
-    }
-}
 
 impl PrettyPrint for KeysSubQuery {
     fn pretty_print(&self, result: &mut PrettyPrintResult, state: &PrettyPrintState) {