in work

waralexrom · waralexrom · commit 552e54c27e13 · 2025-07-24T11:22:20.000+02:00
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/logical_plan/cube.rs b/rust/cubesqlplanner/cubesqlplanner/src/logical_plan/cube.rs
@@ -52,17 +52,16 @@ impl Cube {
 }
 
 impl LogicalNode for Cube {
-    type InputsType = EmptyNodeInput;
-
     fn as_plan_node(self: &Rc<Self>) -> PlanNode {
         PlanNode::Cube(self.clone())
     }
 
-    fn inputs(&self) -> Self::InputsType {
-        EmptyNodeInput::new()
+    fn inputs(&self) -> Vec<PlanNode> {
+        vec![] // Cube has no inputs
     }
 
-    fn with_inputs(self: Rc<Self>, inputs: Self::InputsType) -> Result<Rc<Self>, CubeError> {
+    fn with_inputs(self: Rc<Self>, inputs: Vec<PlanNode>) -> Result<Rc<Self>, CubeError> {
+        check_inputs_len(&inputs, 0, self.node_name())?;
         Ok(self)
     }
 
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/logical_plan/multistage/calculation.rs b/rust/cubesqlplanner/cubesqlplanner/src/logical_plan/multistage/calculation.rs
@@ -99,18 +99,17 @@ impl PrettyPrint for MultiStageMeasureCalculation {
 }
 
 impl LogicalNode for MultiStageMeasureCalculation {
-    type InputsType = SingleNodeInput;
-
     fn as_plan_node(self: &Rc<Self>) -> PlanNode {
         PlanNode::MultiStageMeasureCalculation(self.clone())
     }
 
-    fn inputs(&self) -> Self::InputsType {
-        SingleNodeInput::new(self.source.as_plan_node())
+    fn inputs(&self) -> Vec<PlanNode> {
+        vec![self.source.as_plan_node()]
     }
 
-    fn with_inputs(self: Rc<Self>, inputs: Self::InputsType) -> Result<Rc<Self>, CubeError> {
-        let source = inputs.unpack();
+    fn with_inputs(self: Rc<Self>, inputs: Vec<PlanNode>) -> Result<Rc<Self>, CubeError> {
+        check_inputs_len(&inputs, 1, self.node_name())?;
+        let source = &inputs[0];
 
         Ok(Rc::new(Self {
             schema: self.schema.clone(),
@@ -119,7 +118,7 @@ impl LogicalNode for MultiStageMeasureCalculation {
             partition_by: self.partition_by.clone(),
             window_function_to_use: self.window_function_to_use.clone(),
             order_by: self.order_by.clone(),
-            source: source.into_logical_node()?,
+            source: source.clone().into_logical_node()?,
         }))
     }
 
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/logical_plan/multistage/get_date_range.rs b/rust/cubesqlplanner/cubesqlplanner/src/logical_plan/multistage/get_date_range.rs
@@ -9,22 +9,21 @@ pub struct MultiStageGetDateRange {
 }
 
 impl LogicalNode for MultiStageGetDateRange {
-    type InputsType = SingleNodeInput;
-
     fn as_plan_node(self: &Rc<Self>) -> PlanNode {
         PlanNode::MultiStageGetDateRange(self.clone())
     }
 
-    fn inputs(&self) -> Self::InputsType {
-        SingleNodeInput::new(self.source.as_plan_node())
+    fn inputs(&self) -> Vec<PlanNode> {
+        vec![self.source.as_plan_node()]
     }
 
-    fn with_inputs(self: Rc<Self>, inputs: Self::InputsType) -> Result<Rc<Self>, CubeError> {
-        let source = inputs.unpack();
+    fn with_inputs(self: Rc<Self>, inputs: Vec<PlanNode>) -> Result<Rc<Self>, CubeError> {
+        check_inputs_len(&inputs, 1, self.node_name())?;
+        let source = &inputs[0];
 
         Ok(Rc::new(Self {
             time_dimension: self.time_dimension.clone(),
-            source: source.into_logical_node()?,
+            source: source.clone().into_logical_node()?,
         }))
     }
 
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/logical_plan/multistage/leaf_measure.rs b/rust/cubesqlplanner/cubesqlplanner/src/logical_plan/multistage/leaf_measure.rs
@@ -50,25 +50,24 @@ impl PrettyPrint for MultiStageLeafMeasure {
 }
 
 impl LogicalNode for MultiStageLeafMeasure {
-    type InputsType = SingleNodeInput;
-
     fn as_plan_node(self: &Rc<Self>) -> PlanNode {
         PlanNode::MultiStageLeafMeasure(self.clone())
     }
 
-    fn inputs(&self) -> Self::InputsType {
-        SingleNodeInput::new(self.query.as_plan_node())
+    fn inputs(&self) -> Vec<PlanNode> {
+        vec![self.query.as_plan_node()]
     }
 
-    fn with_inputs(self: Rc<Self>, inputs: Self::InputsType) -> Result<Rc<Self>, CubeError> {
-        let query = inputs.unpack();
+    fn with_inputs(self: Rc<Self>, inputs: Vec<PlanNode>) -> Result<Rc<Self>, CubeError> {
+        check_inputs_len(&inputs, 1, self.node_name())?;
+        let query = &inputs[0];
 
         Ok(Rc::new(Self {
             measure: self.measure.clone(),
             render_measure_as_state: self.render_measure_as_state,
             render_measure_for_ungrouped: self.render_measure_for_ungrouped,
             time_shifts: self.time_shifts.clone(),
-            query: query.into_logical_node()?,
+            query: query.clone().into_logical_node()?,
         }))
     }
 
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/logical_plan/multistage/member.rs b/rust/cubesqlplanner/cubesqlplanner/src/logical_plan/multistage/member.rs
@@ -50,18 +50,17 @@ pub struct LogicalMultiStageMember {
 }
 
 impl LogicalNode for LogicalMultiStageMember {
-    type InputsType = SingleNodeInput;
-
     fn as_plan_node(self: &Rc<Self>) -> PlanNode {
         PlanNode::LogicalMultiStageMember(self.clone())
     }
 
-    fn inputs(&self) -> Self::InputsType {
-        SingleNodeInput::new(self.member_type.as_plan_node())
+    fn inputs(&self) -> Vec<PlanNode> {
+        vec![self.member_type.as_plan_node()]
     }
 
-    fn with_inputs(self: Rc<Self>, inputs: Self::InputsType) -> Result<Rc<Self>, CubeError> {
-        let input = inputs.unpack();
+    fn with_inputs(self: Rc<Self>, inputs: Vec<PlanNode>) -> Result<Rc<Self>, CubeError> {
+        check_inputs_len(&inputs, 1, self.node_name())?;
+        let input = inputs[0].clone();
 
         Ok(Rc::new(Self {
             name: self.name.clone(),
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/logical_plan/multistage/rolling_window.rs b/rust/cubesqlplanner/cubesqlplanner/src/logical_plan/multistage/rolling_window.rs
@@ -113,17 +113,16 @@ impl PrettyPrint for MultiStageRollingWindow {
 }
 
 impl LogicalNode for MultiStageRollingWindow {
-    type InputsType = EmptyNodeInput;
-
     fn as_plan_node(self: &Rc<Self>) -> PlanNode {
         PlanNode::MultiStageRollingWindow(self.clone())
     }
 
-    fn inputs(&self) -> Self::InputsType {
-        EmptyNodeInput::new()
+    fn inputs(&self) -> Vec<PlanNode> {
+        vec![] // MultiStageRollingWindow has no inputs
     }
 
-    fn with_inputs(self: Rc<Self>, _inputs: Self::InputsType) -> Result<Rc<Self>, CubeError> {
+    fn with_inputs(self: Rc<Self>, inputs: Vec<PlanNode>) -> Result<Rc<Self>, CubeError> {
+        check_inputs_len(&inputs, 0, self.node_name())?;
         Ok(self)
     }
 
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/logical_plan/multistage/time_series.rs b/rust/cubesqlplanner/cubesqlplanner/src/logical_plan/multistage/time_series.rs
@@ -35,17 +35,16 @@ impl PrettyPrint for MultiStageTimeSeries {
 }
 
 impl LogicalNode for MultiStageTimeSeries {
-    type InputsType = EmptyNodeInput;
-
     fn as_plan_node(self: &Rc<Self>) -> PlanNode {
         PlanNode::MultiStageTimeSeries(self.clone())
     }
 
-    fn inputs(&self) -> Self::InputsType {
-        EmptyNodeInput::new()
+    fn inputs(&self) -> Vec<PlanNode> {
+        vec![] // MultiStageTimeSeries has no inputs
     }
 
-    fn with_inputs(self: Rc<Self>, _inputs: Self::InputsType) -> Result<Rc<Self>, CubeError> {
+    fn with_inputs(self: Rc<Self>, inputs: Vec<PlanNode>) -> Result<Rc<Self>, CubeError> {
+        check_inputs_len(&inputs, 0, self.node_name())?;
         Ok(self)
     }
 
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/logical_plan/pre_aggregation.rs b/rust/cubesqlplanner/cubesqlplanner/src/logical_plan/pre_aggregation.rs
@@ -17,17 +17,16 @@ pub struct PreAggregation {
 }
 
 impl LogicalNode for PreAggregation {
-    type InputsType = EmptyNodeInput;
-
     fn as_plan_node(self: &Rc<Self>) -> PlanNode {
         PlanNode::PreAggregation(self.clone())
     }
 
-    fn inputs(&self) -> Self::InputsType {
-        EmptyNodeInput::new()
+    fn inputs(&self) -> Vec<PlanNode> {
+        vec![] // PreAggregation has no inputs
     }
 
-    fn with_inputs(self: Rc<Self>, _inputs: Self::InputsType) -> Result<Rc<Self>, CubeError> {
+    fn with_inputs(self: Rc<Self>, inputs: Vec<PlanNode>) -> Result<Rc<Self>, CubeError> {
+        check_inputs_len(&inputs, 0, self.node_name())?;
         Ok(self)
     }
 
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/logical_plan/query.rs b/rust/cubesqlplanner/cubesqlplanner/src/logical_plan/query.rs
@@ -86,7 +86,7 @@ impl LogicalNode for Query {
     }
 }
 
-pub struct QueryInputPacker {}
+pub struct QueryInputPacker;
 
 impl QueryInputPacker {
     pub fn pack(query: &Query) -> Vec<PlanNode> {

Original file line number	Diff line number	Diff line change
`@@ -52,17 +52,16 @@ impl Cube {`
`52`	`52`	`}`
`53`	`53`
`54`	`54`	`impl LogicalNode for Cube {`
`55`		`- type InputsType = EmptyNodeInput;`
`56`		`-`
`57`	`55`	`fn as_plan_node(self: &Rc<Self>) -> PlanNode {`
`58`	`56`	`PlanNode::Cube(self.clone())`
`59`	`57`	`}`
`60`	`58`
`61`		`- fn inputs(&self) -> Self::InputsType {`
`62`		`- EmptyNodeInput::new()`
	`59`	`+ fn inputs(&self) -> Vec<PlanNode> {`
	`60`	`+ vec![] // Cube has no inputs`
`63`	`61`	`}`
`64`	`62`
`65`		`- fn with_inputs(self: Rc<Self>, inputs: Self::InputsType) -> Result<Rc<Self>, CubeError> {`
	`63`	`+ fn with_inputs(self: Rc<Self>, inputs: Vec<PlanNode>) -> Result<Rc<Self>, CubeError> {`
	`64`	`+ check_inputs_len(&inputs, 0, self.node_name())?;`
`66`	`65`	`Ok(self)`
`67`	`66`	`}`
`68`	`67`
Original file line number	Diff line number	Diff line change
`@@ -9,22 +9,21 @@ pub struct MultiStageGetDateRange {`
`9`	`9`	`}`
`10`	`10`
`11`	`11`	`impl LogicalNode for MultiStageGetDateRange {`
`12`		`- type InputsType = SingleNodeInput;`
`13`		`-`
`14`	`12`	`fn as_plan_node(self: &Rc<Self>) -> PlanNode {`
`15`	`13`	`PlanNode::MultiStageGetDateRange(self.clone())`
`16`	`14`	`}`
`17`	`15`
`18`		`- fn inputs(&self) -> Self::InputsType {`
`19`		`- SingleNodeInput::new(self.source.as_plan_node())`
	`16`	`+ fn inputs(&self) -> Vec<PlanNode> {`
	`17`	`+ vec![self.source.as_plan_node()]`
`20`	`18`	`}`
`21`	`19`
`22`		`- fn with_inputs(self: Rc<Self>, inputs: Self::InputsType) -> Result<Rc<Self>, CubeError> {`
`23`		`- let source = inputs.unpack();`
	`20`	`+ fn with_inputs(self: Rc<Self>, inputs: Vec<PlanNode>) -> Result<Rc<Self>, CubeError> {`
	`21`	`+ check_inputs_len(&inputs, 1, self.node_name())?;`
	`22`	`+ let source = &inputs[0];`
`24`	`23`
`25`	`24`	`Ok(Rc::new(Self {`
`26`	`25`	`time_dimension: self.time_dimension.clone(),`
`27`		`- source: source.into_logical_node()?,`
	`26`	`+ source: source.clone().into_logical_node()?,`
`28`	`27`	`}))`
`29`	`28`	`}`
`30`	`29`
Original file line number	Diff line number	Diff line change
`@@ -113,17 +113,16 @@ impl PrettyPrint for MultiStageRollingWindow {`
`113`	`113`	`}`
`114`	`114`
`115`	`115`	`impl LogicalNode for MultiStageRollingWindow {`
`116`		`- type InputsType = EmptyNodeInput;`
`117`		`-`
`118`	`116`	`fn as_plan_node(self: &Rc<Self>) -> PlanNode {`
`119`	`117`	`PlanNode::MultiStageRollingWindow(self.clone())`
`120`	`118`	`}`
`121`	`119`
`122`		`- fn inputs(&self) -> Self::InputsType {`
`123`		`- EmptyNodeInput::new()`
	`120`	`+ fn inputs(&self) -> Vec<PlanNode> {`
	`121`	`+ vec![] // MultiStageRollingWindow has no inputs`
`124`	`122`	`}`
`125`	`123`
`126`		`- fn with_inputs(self: Rc<Self>, _inputs: Self::InputsType) -> Result<Rc<Self>, CubeError> {`
	`124`	`+ fn with_inputs(self: Rc<Self>, inputs: Vec<PlanNode>) -> Result<Rc<Self>, CubeError> {`
	`125`	`+ check_inputs_len(&inputs, 0, self.node_name())?;`
`127`	`126`	`Ok(self)`
`128`	`127`	`}`
`129`	`128`
Original file line number	Diff line number	Diff line change
`@@ -35,17 +35,16 @@ impl PrettyPrint for MultiStageTimeSeries {`
`35`	`35`	`}`
`36`	`36`
`37`	`37`	`impl LogicalNode for MultiStageTimeSeries {`
`38`		`- type InputsType = EmptyNodeInput;`
`39`		`-`
`40`	`38`	`fn as_plan_node(self: &Rc<Self>) -> PlanNode {`
`41`	`39`	`PlanNode::MultiStageTimeSeries(self.clone())`
`42`	`40`	`}`
`43`	`41`
`44`		`- fn inputs(&self) -> Self::InputsType {`
`45`		`- EmptyNodeInput::new()`
	`42`	`+ fn inputs(&self) -> Vec<PlanNode> {`
	`43`	`+ vec![] // MultiStageTimeSeries has no inputs`
`46`	`44`	`}`
`47`	`45`
`48`		`- fn with_inputs(self: Rc<Self>, _inputs: Self::InputsType) -> Result<Rc<Self>, CubeError> {`
	`46`	`+ fn with_inputs(self: Rc<Self>, inputs: Vec<PlanNode>) -> Result<Rc<Self>, CubeError> {`
	`47`	`+ check_inputs_len(&inputs, 0, self.node_name())?;`
`49`	`48`	`Ok(self)`
`50`	`49`	`}`
`51`	`50`
Original file line number	Diff line number	Diff line change
`@@ -17,17 +17,16 @@ pub struct PreAggregation {`
`17`	`17`	`}`
`18`	`18`
`19`	`19`	`impl LogicalNode for PreAggregation {`
`20`		`- type InputsType = EmptyNodeInput;`
`21`		`-`
`22`	`20`	`fn as_plan_node(self: &Rc<Self>) -> PlanNode {`
`23`	`21`	`PlanNode::PreAggregation(self.clone())`
`24`	`22`	`}`
`25`	`23`
`26`		`- fn inputs(&self) -> Self::InputsType {`
`27`		`- EmptyNodeInput::new()`
	`24`	`+ fn inputs(&self) -> Vec<PlanNode> {`
	`25`	`+ vec![] // PreAggregation has no inputs`
`28`	`26`	`}`
`29`	`27`
`30`		`- fn with_inputs(self: Rc<Self>, _inputs: Self::InputsType) -> Result<Rc<Self>, CubeError> {`
	`28`	`+ fn with_inputs(self: Rc<Self>, inputs: Vec<PlanNode>) -> Result<Rc<Self>, CubeError> {`
	`29`	`+ check_inputs_len(&inputs, 0, self.node_name())?;`
`31`	`30`	`Ok(self)`
`32`	`31`	`}`
`33`	`32`
Original file line number	Diff line number	Diff line change
`@@ -86,7 +86,7 @@ impl LogicalNode for Query {`
`86`	`86`	`}`
`87`	`87`	`}`
`88`	`88`
`89`		`-pub struct QueryInputPacker {}`
	`89`	`+pub struct QueryInputPacker;`
`90`	`90`
`91`	`91`	`impl QueryInputPacker {`
`92`	`92`	`pub fn pack(query: &Query) -> Vec<PlanNode> {`