in work

Author: waralexrom

rust/cubesqlplanner/cubesqlplanner/src/logical_plan/dimension_subquery.rs

@@ -12,20 +12,19 @@ pub struct DimensionSubQuery {
 }
 
 impl LogicalNode for DimensionSubQuery {
-    type InputsType = SingleNodeInput;
-
     fn as_plan_node(self: &Rc<Self>) -> PlanNode {
         PlanNode::DimensionSubQuery(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 {
-            query: query.into_logical_node()?,
+            query: query.clone().into_logical_node()?,
             primary_keys_dimensions: self.primary_keys_dimensions.clone(),
             subquery_dimension: self.subquery_dimension.clone(),
             measure_for_subquery_dimension: self.measure_for_subquery_dimension.clone(),

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

@@ -58,46 +58,39 @@ pub struct FullKeyAggregate {
 }
 
 impl LogicalNode for FullKeyAggregate {
-    type InputsType = OptionNodeInput;
-
     fn as_plan_node(self: &Rc<Self>) -> PlanNode {
         PlanNode::FullKeyAggregate(self.clone())
     }
 
-    fn inputs(&self) -> Self::InputsType {
-        let plan_node = self
-            .multiplied_measures_resolver
-            .as_ref()
-            .map(|resolver| match resolver {
+    fn inputs(&self) -> Vec<PlanNode> {
+        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(),
-            });
-        OptionNodeInput::new(plan_node)
+            }]
+        } else {
+            vec![]
+        }
     }
 
-    fn with_inputs(self: Rc<Self>, inputs: Self::InputsType) -> Result<Rc<Self>, CubeError> {
-        let input = inputs.unpack();
-        let multiplied_measures_resolver = if self.multiplied_measures_resolver.is_none()
-            && input.is_none()
-        {
+    fn with_inputs(self: Rc<Self>, inputs: Vec<PlanNode>) -> Result<Rc<Self>, CubeError> {
+        let multiplied_measures_resolver = if self.multiplied_measures_resolver.is_none() {
+            check_inputs_len(&inputs, 0, self.node_name())?;
             None
-        } else if let (Some(self_source), Some(input_source)) =
-            (&self.multiplied_measures_resolver, input)
-        {
-            Some(match self_source {
+        } else {
+            check_inputs_len(&inputs, 1, self.node_name())?;
+            let input_source = &inputs[0];
+            
+            Some(match self.multiplied_measures_resolver.as_ref().unwrap() {
                 ResolvedMultipliedMeasures::ResolveMultipliedMeasures(_) => {
                     ResolvedMultipliedMeasures::ResolveMultipliedMeasures(
-                        input_source.into_logical_node()?,
+                        input_source.clone().into_logical_node()?,
                     )
                 }
                 ResolvedMultipliedMeasures::PreAggregation(_) => {
-                    ResolvedMultipliedMeasures::PreAggregation(input_source.into_logical_node()?)
+                    ResolvedMultipliedMeasures::PreAggregation(input_source.clone().into_logical_node()?)
                 }
             })
-        } else {
-            return Err(CubeError::internal(format!(
-                "Wrong inputs for FullKeyAggregate node"
-            )));
         };
 
         Ok(Rc::new(Self {

rust/cubesqlplanner/cubesqlplanner/src/logical_plan/measure_subquery.rs

@@ -8,21 +8,20 @@ pub struct MeasureSubquery {
 }
 
 impl LogicalNode for MeasureSubquery {
-    type InputsType = SingleNodeInput;
-
     fn as_plan_node(self: &Rc<Self>) -> PlanNode {
         PlanNode::MeasureSubquery(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(),
-            source: source.into_logical_node()?,
+            source: source.clone().into_logical_node()?,
         }))
     }