in work

waralexrom · waralexrom · commit e1e6200c6946 · 2025-07-24T11:22:19.000+02:00
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/logical_plan/aggregate_multiplied_subquery.rs b/rust/cubesqlplanner/cubesqlplanner/src/logical_plan/aggregate_multiplied_subquery.rs
@@ -73,14 +73,14 @@ impl LogicalNode for AggregateMultipliedSubquery {
         Ok(Rc::new(result))
     }
 
-    fn node_name() -> &'static str {
+    fn node_name(&self) -> &'static str {
         "AggregateMultipliedSubquery"
     }
     fn try_from_plan_node(plan_node: PlanNode) -> Result<Rc<Self>, CubeError> {
         if let PlanNode::AggregateMultipliedSubquery(item) = plan_node {
             Ok(item)
         } else {
-            Err(cast_error::<Self>(&plan_node))
+            Err(cast_error(&plan_node, "AggregateMultipliedSubquery"))
         }
     }
 }
@@ -99,7 +99,7 @@ impl NodeInputs for AggregateMultipliedSubqueryInput {
                 .chain(self.dimension_subqueries.iter()),
         )
     }
-    
+
     fn iter_mut(&mut self) -> Box<dyn Iterator<Item = &mut PlanNode> + '_> {
         Box::new(
             std::iter::once(&mut self.keys_subquery)
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/logical_plan/cube.rs b/rust/cubesqlplanner/cubesqlplanner/src/logical_plan/cube.rs
@@ -66,14 +66,14 @@ impl LogicalNode for Cube {
         Ok(self)
     }
 
-    fn node_name() -> &'static str {
+    fn node_name(&self) -> &'static str {
         "Cube"
     }
     fn try_from_plan_node(plan_node: PlanNode) -> Result<Rc<Self>, CubeError> {
         if let PlanNode::Cube(item) = plan_node {
             Ok(item)
         } else {
-            Err(cast_error::<Self>(&plan_node))
+            Err(cast_error(&plan_node, "Cube"))
         }
     }
 }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/logical_plan/dimension_subquery.rs b/rust/cubesqlplanner/cubesqlplanner/src/logical_plan/dimension_subquery.rs
@@ -32,14 +32,14 @@ impl LogicalNode for DimensionSubQuery {
         }))
     }
 
-    fn node_name() -> &'static str {
+    fn node_name(&self) -> &'static str {
         "DimensionSubQuery"
     }
     fn try_from_plan_node(plan_node: PlanNode) -> Result<Rc<Self>, CubeError> {
         if let PlanNode::DimensionSubQuery(query) = plan_node {
             Ok(query)
         } else {
-            Err(cast_error::<Self>(&plan_node))
+            Err(cast_error(&plan_node, "DimensionSubQuery"))
         }
     }
 }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/logical_plan/full_key_aggregate.rs b/rust/cubesqlplanner/cubesqlplanner/src/logical_plan/full_key_aggregate.rs
@@ -108,14 +108,14 @@ impl LogicalNode for FullKeyAggregate {
         }))
     }
 
-    fn node_name() -> &'static str {
+    fn node_name(&self) -> &'static str {
         "FullKeyAggregate"
     }
     fn try_from_plan_node(plan_node: PlanNode) -> Result<Rc<Self>, CubeError> {
         if let PlanNode::FullKeyAggregate(item) = plan_node {
             Ok(item)
         } else {
-            Err(cast_error::<Self>(&plan_node))
+            Err(cast_error(&plan_node, "FullKeyAggregate"))
         }
     }
 }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/logical_plan/join.rs b/rust/cubesqlplanner/cubesqlplanner/src/logical_plan/join.rs
@@ -59,12 +59,13 @@ impl LogicalNode for LogicalJoin {
             dimension_subqueries,
         } = inputs;
 
-        check_inputs_len::<Self>("joins", &joins, self.joins.len())?;
+        check_inputs_len("joins", &joins, self.joins.len(), self.node_name())?;
 
-        check_inputs_len::<Self>(
+        check_inputs_len(
             "dimension_subqueries",
             &dimension_subqueries,
             self.dimension_subqueries.len(),
+            self.node_name(),
         )?;
 
         let joins = self
@@ -91,14 +92,14 @@ impl LogicalNode for LogicalJoin {
         Ok(Rc::new(result))
     }
 
-    fn node_name() -> &'static str {
+    fn node_name(&self) -> &'static str {
         "LogicalJoin"
     }
     fn try_from_plan_node(plan_node: PlanNode) -> Result<Rc<Self>, CubeError> {
         if let PlanNode::LogicalJoin(item) = plan_node {
             Ok(item)
         } else {
-            Err(cast_error::<Self>(&plan_node))
+            Err(cast_error(&plan_node, "LogicalJoin"))
         }
     }
 }
@@ -117,7 +118,7 @@ impl NodeInputs for LogicalJoinInput {
                 .chain(self.dimension_subqueries.iter()),
         )
     }
-    
+
     fn iter_mut(&mut self) -> Box<dyn Iterator<Item = &mut PlanNode> + '_> {
         Box::new(
             std::iter::once(&mut self.root)
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/logical_plan/keys_subquery.rs b/rust/cubesqlplanner/cubesqlplanner/src/logical_plan/keys_subquery.rs
@@ -39,14 +39,14 @@ impl LogicalNode for KeysSubQuery {
         Ok(Rc::new(res))
     }
 
-    fn node_name() -> &'static str {
+    fn node_name(&self) -> &'static str {
         "KeysSubQuery"
     }
     fn try_from_plan_node(plan_node: PlanNode) -> Result<Rc<Self>, CubeError> {
         if let PlanNode::KeysSubQuery(query) = plan_node {
             Ok(query)
         } else {
-            Err(cast_error::<Self>(&plan_node))
+            Err(cast_error(&plan_node, "KeysSubQuery"))
         }
     }
 }
@@ -60,7 +60,7 @@ 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)))
     }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/logical_plan/logical_node.rs b/rust/cubesqlplanner/cubesqlplanner/src/logical_plan/logical_node.rs
@@ -18,7 +18,7 @@ impl NodeInputs for EmptyNodeInput {
     fn iter(&self) -> Box<dyn Iterator<Item = &PlanNode> + '_> {
         Box::new(std::iter::empty())
     }
-    
+
     fn iter_mut(&mut self) -> Box<dyn Iterator<Item = &mut PlanNode> + '_> {
         Box::new(std::iter::empty())
     }
@@ -42,7 +42,7 @@ impl NodeInputs for SingleNodeInput {
     fn iter(&self) -> Box<dyn Iterator<Item = &PlanNode> + '_> {
         Box::new(std::iter::once(&self.item))
     }
-    
+
     fn iter_mut(&mut self) -> Box<dyn Iterator<Item = &mut PlanNode> + '_> {
         Box::new(std::iter::once(&mut self.item))
     }
@@ -70,7 +70,7 @@ impl NodeInputs for OptionNodeInput {
             Box::new(std::iter::empty())
         }
     }
-    
+
     fn iter_mut(&mut self) -> Box<dyn Iterator<Item = &mut PlanNode> + '_> {
         if let Some(item) = &mut self.item {
             Box::new(std::iter::once(item))
@@ -98,7 +98,7 @@ impl NodeInputs for VecNodeInput {
     fn iter(&self) -> Box<dyn Iterator<Item = &PlanNode> + '_> {
         Box::new(self.items.iter())
     }
-    
+
     fn iter_mut(&mut self) -> Box<dyn Iterator<Item = &mut PlanNode> + '_> {
         Box::new(self.items.iter_mut())
     }
@@ -115,7 +115,7 @@ pub trait LogicalNode {
 
     fn as_plan_node(self: &Rc<Self>) -> PlanNode;
 
-    fn node_name() -> &'static str;
+    fn node_name(&self) -> &'static str;
 }
 
 pub enum PlanNode {
@@ -140,22 +140,22 @@ pub enum PlanNode {
 impl PlanNode {
     pub fn node_name(&self) -> &'static str {
         match self {
-            PlanNode::Query(_) => Query::node_name(),
-            PlanNode::LogicalJoin(_) => LogicalJoin::node_name(),
-            PlanNode::FullKeyAggregate(_) => FullKeyAggregate::node_name(),
-            PlanNode::PreAggregation(_) => PreAggregation::node_name(),
-            PlanNode::ResolveMultipliedMeasures(_) => ResolveMultipliedMeasures::node_name(),
-            PlanNode::AggregateMultipliedSubquery(_) => AggregateMultipliedSubquery::node_name(),
-            PlanNode::Cube(_) => Cube::node_name(),
-            PlanNode::MeasureSubquery(_) => MeasureSubquery::node_name(),
-            PlanNode::DimensionSubQuery(_) => DimensionSubQuery::node_name(),
-            PlanNode::KeysSubQuery(_) => KeysSubQuery::node_name(),
-            PlanNode::MultiStageGetDateRange(_) => MultiStageGetDateRange::node_name(),
-            PlanNode::MultiStageLeafMeasure(_) => MultiStageLeafMeasure::node_name(),
-            PlanNode::MultiStageMeasureCalculation(_) => MultiStageMeasureCalculation::node_name(),
-            PlanNode::MultiStageTimeSeries(_) => MultiStageTimeSeries::node_name(),
-            PlanNode::MultiStageRollingWindow(_) => MultiStageRollingWindow::node_name(),
-            PlanNode::LogicalMultiStageMember(_) => LogicalMultiStageMember::node_name(),
+            PlanNode::Query(node) => node.node_name(),
+            PlanNode::LogicalJoin(node) => node.node_name(),
+            PlanNode::FullKeyAggregate(node) => node.node_name(),
+            PlanNode::PreAggregation(node) => node.node_name(),
+            PlanNode::ResolveMultipliedMeasures(node) => node.node_name(),
+            PlanNode::AggregateMultipliedSubquery(node) => node.node_name(),
+            PlanNode::Cube(node) => node.node_name(),
+            PlanNode::MeasureSubquery(node) => node.node_name(),
+            PlanNode::DimensionSubQuery(node) => node.node_name(),
+            PlanNode::KeysSubQuery(node) => node.node_name(),
+            PlanNode::MultiStageGetDateRange(node) => node.node_name(),
+            PlanNode::MultiStageLeafMeasure(node) => node.node_name(),
+            PlanNode::MultiStageMeasureCalculation(node) => node.node_name(),
+            PlanNode::MultiStageTimeSeries(node) => node.node_name(),
+            PlanNode::MultiStageRollingWindow(node) => node.node_name(),
+            PlanNode::LogicalMultiStageMember(node) => node.node_name(),
         }
     }
 
@@ -164,26 +164,27 @@ impl PlanNode {
     }
 }
 
-pub(super) fn cast_error<T: LogicalNode>(plan_node: &PlanNode) -> CubeError {
+pub(super) fn cast_error(plan_node: &PlanNode, target_type: &str) -> CubeError {
     CubeError::internal(format!(
         "Can't cast {} PlanNode into {}",
         plan_node.node_name(),
-        T::node_name(),
+        target_type,
     ))
 }
 
-pub(super) fn check_inputs_len<T: LogicalNode>(
+pub(super) fn check_inputs_len(
     input_name: &str,
     inputs: &Vec<PlanNode>,
     expected: usize,
+    node_type: &str,
 ) -> Result<(), CubeError> {
     if inputs.len() == expected {
         Ok(())
     } else {
         Err(CubeError::internal(format!(
             "For input {} for node {} expected {} inputs but received {}",
             input_name,
-            T::node_name(),
+            node_type,
             expected,
             inputs.len()
         )))
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/logical_plan/measure_subquery.rs b/rust/cubesqlplanner/cubesqlplanner/src/logical_plan/measure_subquery.rs
@@ -26,14 +26,14 @@ impl LogicalNode for MeasureSubquery {
         }))
     }
 
-    fn node_name() -> &'static str {
+    fn node_name(&self) -> &'static str {
         "MeasureSubquery"
     }
     fn try_from_plan_node(plan_node: PlanNode) -> Result<Rc<Self>, CubeError> {
         if let PlanNode::MeasureSubquery(query) = plan_node {
             Ok(query)
         } else {
-            Err(cast_error::<Self>(&plan_node))
+            Err(cast_error(&plan_node, "MeasureSubquery"))
         }
     }
 }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/logical_plan/multistage/calculation.rs b/rust/cubesqlplanner/cubesqlplanner/src/logical_plan/multistage/calculation.rs
@@ -123,15 +123,15 @@ impl LogicalNode for MultiStageMeasureCalculation {
         }))
     }
 
-    fn node_name() -> &'static str {
+    fn node_name(&self) -> &'static str {
         "MultiStageMeasureCalculation"
     }
 
     fn try_from_plan_node(plan_node: PlanNode) -> Result<Rc<Self>, CubeError> {
         if let PlanNode::MultiStageMeasureCalculation(item) = plan_node {
             Ok(item)
         } else {
-            Err(cast_error::<Self>(&plan_node))
+            Err(cast_error(&plan_node, "MultiStageMeasureCalculation"))
         }
     }
 }
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
@@ -28,15 +28,15 @@ impl LogicalNode for MultiStageGetDateRange {
         }))
     }
 
-    fn node_name() -> &'static str {
+    fn node_name(&self) -> &'static str {
         "MultiStageGetDateRange"
     }
 
     fn try_from_plan_node(plan_node: PlanNode) -> Result<Rc<Self>, CubeError> {
         if let PlanNode::MultiStageGetDateRange(item) = plan_node {
             Ok(item)
         } else {
-            Err(cast_error::<Self>(&plan_node))
+            Err(cast_error(&plan_node, "MultiStageGetDateRange"))
         }
     }
 }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/logical_plan/multistage/leaf_measure.rs b/rust/cubesqlplanner/cubesqlplanner/src/logical_plan/multistage/leaf_measure.rs
@@ -62,7 +62,7 @@ impl LogicalNode for MultiStageLeafMeasure {
 
     fn with_inputs(self: Rc<Self>, inputs: Self::InputsType) -> Result<Rc<Self>, CubeError> {
         let query = inputs.unpack();
-        
+
         Ok(Rc::new(Self {
             measure: self.measure.clone(),
             render_measure_as_state: self.render_measure_as_state,
@@ -72,15 +72,15 @@ impl LogicalNode for MultiStageLeafMeasure {
         }))
     }
 
-    fn node_name() -> &'static str {
+    fn node_name(&self) -> &'static str {
         "MultiStageLeafMeasure"
     }
 
     fn try_from_plan_node(plan_node: PlanNode) -> Result<Rc<Self>, CubeError> {
         if let PlanNode::MultiStageLeafMeasure(item) = plan_node {
             Ok(item)
         } else {
-            Err(cast_error::<Self>(&plan_node))
+            Err(cast_error(&plan_node, "MultiStageLeafMeasure"))
         }
     }
 }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/logical_plan/multistage/member.rs b/rust/cubesqlplanner/cubesqlplanner/src/logical_plan/multistage/member.rs
@@ -20,7 +20,7 @@ impl MultiStageMemberLogicalType {
             Self::RollingWindow(item) => item.as_plan_node(),
         }
     }
-    
+
     fn with_plan_node(&self, plan_node: PlanNode) -> Result<Self, CubeError> {
         Ok(match self {
             Self::LeafMeasure(_) => Self::LeafMeasure(plan_node.into_logical_node()?),
@@ -62,22 +62,22 @@ impl LogicalNode for LogicalMultiStageMember {
 
     fn with_inputs(self: Rc<Self>, inputs: Self::InputsType) -> Result<Rc<Self>, CubeError> {
         let input = inputs.unpack();
-        
+
         Ok(Rc::new(Self {
             name: self.name.clone(),
             member_type: self.member_type.with_plan_node(input)?,
         }))
     }
 
-    fn node_name() -> &'static str {
+    fn node_name(&self) -> &'static str {
         "LogicalMultiStageMember"
     }
 
     fn try_from_plan_node(plan_node: PlanNode) -> Result<Rc<Self>, CubeError> {
         if let PlanNode::LogicalMultiStageMember(item) = plan_node {
             Ok(item)
         } else {
-            Err(cast_error::<Self>(&plan_node))
+            Err(cast_error(&plan_node, "LogicalMultiStageMember"))
         }
     }
 }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/logical_plan/multistage/rolling_window.rs b/rust/cubesqlplanner/cubesqlplanner/src/logical_plan/multistage/rolling_window.rs
@@ -127,15 +127,15 @@ impl LogicalNode for MultiStageRollingWindow {
         Ok(self)
     }
 
-    fn node_name() -> &'static str {
+    fn node_name(&self) -> &'static str {
         "MultiStageRollingWindow"
     }
 
     fn try_from_plan_node(plan_node: PlanNode) -> Result<Rc<Self>, CubeError> {
         if let PlanNode::MultiStageRollingWindow(item) = plan_node {
             Ok(item)
         } else {
-            Err(cast_error::<Self>(&plan_node))
+            Err(cast_error(&plan_node, "MultiStageRollingWindow"))
         }
     }
 }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/logical_plan/multistage/time_series.rs b/rust/cubesqlplanner/cubesqlplanner/src/logical_plan/multistage/time_series.rs
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/logical_plan/pre_aggregation.rs b/rust/cubesqlplanner/cubesqlplanner/src/logical_plan/pre_aggregation.rs
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/logical_plan/query.rs b/rust/cubesqlplanner/cubesqlplanner/src/logical_plan/query.rs
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/logical_plan/resolve_multiplied_measures.rs b/rust/cubesqlplanner/cubesqlplanner/src/logical_plan/resolve_multiplied_measures.rs
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/logical_plan/visitor/mod.rs b/rust/cubesqlplanner/cubesqlplanner/src/logical_plan/visitor/mod.rs
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/logical_plan/visitor/visitor.rs b/rust/cubesqlplanner/cubesqlplanner/src/logical_plan/visitor/visitor.rs

Original file line number	Diff line number	Diff line change
`@@ -73,14 +73,14 @@ impl LogicalNode for AggregateMultipliedSubquery {`
`73`	`73`	`Ok(Rc::new(result))`
`74`	`74`	`}`
`75`	`75`
`76`		`- fn node_name() -> &'static str {`
	`76`	`+ fn node_name(&self) -> &'static str {`
`77`	`77`	`"AggregateMultipliedSubquery"`
`78`	`78`	`}`
`79`	`79`	`fn try_from_plan_node(plan_node: PlanNode) -> Result<Rc<Self>, CubeError> {`
`80`	`80`	`if let PlanNode::AggregateMultipliedSubquery(item) = plan_node {`
`81`	`81`	`Ok(item)`
`82`	`82`	`} else {`
`83`		`- Err(cast_error::<Self>(&plan_node))`
	`83`	`+ Err(cast_error(&plan_node, "AggregateMultipliedSubquery"))`
`84`	`84`	`}`
`85`	`85`	`}`
`86`	`86`	`}`
`@@ -99,7 +99,7 @@ impl NodeInputs for AggregateMultipliedSubqueryInput {`
`99`	`99`	`.chain(self.dimension_subqueries.iter()),`
`100`	`100`	`)`
`101`	`101`	`}`
`102`		`-`
	`102`	`+`
`103`	`103`	`fn iter_mut(&mut self) -> Box<dyn Iterator<Item = &mut PlanNode> + '_> {`
`104`	`104`	`Box::new(`
`105`	`105`	`std::iter::once(&mut self.keys_subquery)`
Original file line number	Diff line number	Diff line change
`@@ -66,14 +66,14 @@ impl LogicalNode for Cube {`
`66`	`66`	`Ok(self)`
`67`	`67`	`}`
`68`	`68`
`69`		`- fn node_name() -> &'static str {`
	`69`	`+ fn node_name(&self) -> &'static str {`
`70`	`70`	`"Cube"`
`71`	`71`	`}`
`72`	`72`	`fn try_from_plan_node(plan_node: PlanNode) -> Result<Rc<Self>, CubeError> {`
`73`	`73`	`if let PlanNode::Cube(item) = plan_node {`
`74`	`74`	`Ok(item)`
`75`	`75`	`} else {`
`76`		`- Err(cast_error::<Self>(&plan_node))`
	`76`	`+ Err(cast_error(&plan_node, "Cube"))`
`77`	`77`	`}`
`78`	`78`	`}`
`79`	`79`	`}`
Original file line number	Diff line number	Diff line change
`@@ -32,14 +32,14 @@ impl LogicalNode for DimensionSubQuery {`
`32`	`32`	`}))`
`33`	`33`	`}`
`34`	`34`
`35`		`- fn node_name() -> &'static str {`
	`35`	`+ fn node_name(&self) -> &'static str {`
`36`	`36`	`"DimensionSubQuery"`
`37`	`37`	`}`
`38`	`38`	`fn try_from_plan_node(plan_node: PlanNode) -> Result<Rc<Self>, CubeError> {`
`39`	`39`	`if let PlanNode::DimensionSubQuery(query) = plan_node {`
`40`	`40`	`Ok(query)`
`41`	`41`	`} else {`
`42`		`- Err(cast_error::<Self>(&plan_node))`
	`42`	`+ Err(cast_error(&plan_node, "DimensionSubQuery"))`
`43`	`43`	`}`
`44`	`44`	`}`
`45`	`45`	`}`
Original file line number	Diff line number	Diff line change
`@@ -108,14 +108,14 @@ impl LogicalNode for FullKeyAggregate {`
`108`	`108`	`}))`
`109`	`109`	`}`
`110`	`110`
`111`		`- fn node_name() -> &'static str {`
	`111`	`+ fn node_name(&self) -> &'static str {`
`112`	`112`	`"FullKeyAggregate"`
`113`	`113`	`}`
`114`	`114`	`fn try_from_plan_node(plan_node: PlanNode) -> Result<Rc<Self>, CubeError> {`
`115`	`115`	`if let PlanNode::FullKeyAggregate(item) = plan_node {`
`116`	`116`	`Ok(item)`
`117`	`117`	`} else {`
`118`		`- Err(cast_error::<Self>(&plan_node))`
	`118`	`+ Err(cast_error(&plan_node, "FullKeyAggregate"))`
`119`	`119`	`}`
`120`	`120`	`}`
`121`	`121`	`}`
Original file line number	Diff line number	Diff line change
`@@ -59,12 +59,13 @@ impl LogicalNode for LogicalJoin {`
`59`	`59`	`dimension_subqueries,`
`60`	`60`	`} = inputs;`
`61`	`61`
`62`		`- check_inputs_len::<Self>("joins", &joins, self.joins.len())?;`
	`62`	`+ check_inputs_len("joins", &joins, self.joins.len(), self.node_name())?;`
`63`	`63`
`64`		`- check_inputs_len::<Self>(`
	`64`	`+ check_inputs_len(`
`65`	`65`	`"dimension_subqueries",`
`66`	`66`	`&dimension_subqueries,`
`67`	`67`	`self.dimension_subqueries.len(),`
	`68`	`+ self.node_name(),`
`68`	`69`	`)?;`
`69`	`70`
`70`	`71`	`let joins = self`
`@@ -91,14 +92,14 @@ impl LogicalNode for LogicalJoin {`
`91`	`92`	`Ok(Rc::new(result))`
`92`	`93`	`}`
`93`	`94`
`94`		`- fn node_name() -> &'static str {`
	`95`	`+ fn node_name(&self) -> &'static str {`
`95`	`96`	`"LogicalJoin"`
`96`	`97`	`}`
`97`	`98`	`fn try_from_plan_node(plan_node: PlanNode) -> Result<Rc<Self>, CubeError> {`
`98`	`99`	`if let PlanNode::LogicalJoin(item) = plan_node {`
`99`	`100`	`Ok(item)`
`100`	`101`	`} else {`
`101`		`- Err(cast_error::<Self>(&plan_node))`
	`102`	`+ Err(cast_error(&plan_node, "LogicalJoin"))`
`102`	`103`	`}`
`103`	`104`	`}`
`104`	`105`	`}`
`@@ -117,7 +118,7 @@ impl NodeInputs for LogicalJoinInput {`
`117`	`118`	`.chain(self.dimension_subqueries.iter()),`
`118`	`119`	`)`
`119`	`120`	`}`
`120`		`-`
	`121`	`+`
`121`	`122`	`fn iter_mut(&mut self) -> Box<dyn Iterator<Item = &mut PlanNode> + '_> {`
`122`	`123`	`Box::new(`
`123`	`124`	`std::iter::once(&mut self.root)`
Original file line number	Diff line number	Diff line change
`@@ -39,14 +39,14 @@ impl LogicalNode for KeysSubQuery {`
`39`	`39`	`Ok(Rc::new(res))`
`40`	`40`	`}`
`41`	`41`
`42`		`- fn node_name() -> &'static str {`
	`42`	`+ fn node_name(&self) -> &'static str {`
`43`	`43`	`"KeysSubQuery"`
`44`	`44`	`}`
`45`	`45`	`fn try_from_plan_node(plan_node: PlanNode) -> Result<Rc<Self>, CubeError> {`
`46`	`46`	`if let PlanNode::KeysSubQuery(query) = plan_node {`
`47`	`47`	`Ok(query)`
`48`	`48`	`} else {`
`49`		`- Err(cast_error::<Self>(&plan_node))`
	`49`	`+ Err(cast_error(&plan_node, "KeysSubQuery"))`
`50`	`50`	`}`
`51`	`51`	`}`
`52`	`52`	`}`
`@@ -60,7 +60,7 @@ impl NodeInputs for KeysSubQueryInputs {`
`60`	`60`	`fn iter(&self) -> Box<dyn Iterator<Item = &PlanNode> + '_> {`
`61`	`61`	`Box::new(std::iter::once(&self.pk_cube).chain(std::iter::once(&self.source)))`
`62`	`62`	`}`
`63`		`-`
	`63`	`+`
`64`	`64`	`fn iter_mut(&mut self) -> Box<dyn Iterator<Item = &mut PlanNode> + '_> {`
`65`	`65`	`Box::new(std::iter::once(&mut self.pk_cube).chain(std::iter::once(&mut self.source)))`
`66`	`66`	`}`
Original file line number	Diff line number	Diff line change
`@@ -26,14 +26,14 @@ impl LogicalNode for MeasureSubquery {`
`26`	`26`	`}))`
`27`	`27`	`}`
`28`	`28`
`29`		`- fn node_name() -> &'static str {`
	`29`	`+ fn node_name(&self) -> &'static str {`
`30`	`30`	`"MeasureSubquery"`
`31`	`31`	`}`
`32`	`32`	`fn try_from_plan_node(plan_node: PlanNode) -> Result<Rc<Self>, CubeError> {`
`33`	`33`	`if let PlanNode::MeasureSubquery(query) = plan_node {`
`34`	`34`	`Ok(query)`
`35`	`35`	`} else {`
`36`		`- Err(cast_error::<Self>(&plan_node))`
	`36`	`+ Err(cast_error(&plan_node, "MeasureSubquery"))`
`37`	`37`	`}`
`38`	`38`	`}`
`39`	`39`	`}`
Original file line number	Diff line number	Diff line change
`@@ -123,15 +123,15 @@ impl LogicalNode for MultiStageMeasureCalculation {`
`123`	`123`	`}))`
`124`	`124`	`}`
`125`	`125`
`126`		`- fn node_name() -> &'static str {`
	`126`	`+ fn node_name(&self) -> &'static str {`
`127`	`127`	`"MultiStageMeasureCalculation"`
`128`	`128`	`}`
`129`	`129`
`130`	`130`	`fn try_from_plan_node(plan_node: PlanNode) -> Result<Rc<Self>, CubeError> {`
`131`	`131`	`if let PlanNode::MultiStageMeasureCalculation(item) = plan_node {`
`132`	`132`	`Ok(item)`
`133`	`133`	`} else {`
`134`		`- Err(cast_error::<Self>(&plan_node))`
	`134`	`+ Err(cast_error(&plan_node, "MultiStageMeasureCalculation"))`
`135`	`135`	`}`
`136`	`136`	`}`
`137`	`137`	`}`
Original file line number	Diff line number	Diff line change
`@@ -28,15 +28,15 @@ impl LogicalNode for MultiStageGetDateRange {`
`28`	`28`	`}))`
`29`	`29`	`}`
`30`	`30`
`31`		`- fn node_name() -> &'static str {`
	`31`	`+ fn node_name(&self) -> &'static str {`
`32`	`32`	`"MultiStageGetDateRange"`
`33`	`33`	`}`
`34`	`34`
`35`	`35`	`fn try_from_plan_node(plan_node: PlanNode) -> Result<Rc<Self>, CubeError> {`
`36`	`36`	`if let PlanNode::MultiStageGetDateRange(item) = plan_node {`
`37`	`37`	`Ok(item)`
`38`	`38`	`} else {`
`39`		`- Err(cast_error::<Self>(&plan_node))`
	`39`	`+ Err(cast_error(&plan_node, "MultiStageGetDateRange"))`
`40`	`40`	`}`
`41`	`41`	`}`
`42`	`42`	`}`