fix

Author: waralexrom

rust/cubesqlplanner/cubesqlplanner/src/logical_plan/calc_groups_cross_join.rs

@@ -0,0 +1,74 @@
+use crate::planner::sql_evaluator::MemberSymbol;
+
+use super::*;
+use cubenativeutils::CubeError;
+use std::rc::Rc;
+
+#[derive(Clone)]
+pub struct CalcGroupDescription {
+    symbol: Rc<MemberSymbol>,
+    values: Vec<String>,
+}
+
+impl PrettyPrint for CalcGroupDescription {
+    fn pretty_print(&self, result: &mut PrettyPrintResult, state: &PrettyPrintState) {
+        let state = state.new_level();
+        result.println(
+            &format!("{}:{}", self.symbol.full_name(), self.values.join(", ")),
+            &state,
+        );
+    }
+}
+
+#[derive(Clone)]
+pub struct CalcGroupsCrossJoin {
+    source: QuerySource,
+    calc_groups: Vec<Rc<CalcGroupDescription>>,
+}
+
+impl LogicalNode for CalcGroupsCrossJoin {
+    fn as_plan_node(self: &Rc<Self>) -> PlanNode {
+        PlanNode::CalcGroupsCrossJoin(self.clone())
+    }
+
+    fn inputs(&self) -> Vec<PlanNode> {
+        vec![self.source.as_plan_node()]
+    }
+
+    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 {
+            calc_groups: self.calc_groups.clone(),
+            source: self.source.with_plan_node(source.clone())?,
+        }))
+    }
+
+    fn node_name(&self) -> &'static str {
+        "MultiStageGetDateRange"
+    }
+
+    fn try_from_plan_node(plan_node: PlanNode) -> Result<Rc<Self>, CubeError> {
+        if let PlanNode::CalcGroupsCrossJoin(item) = plan_node {
+            Ok(item)
+        } else {
+            Err(cast_error(&plan_node, "MultiStageGetDateRange"))
+        }
+    }
+}
+
+impl PrettyPrint for CalcGroupsCrossJoin {
+    fn pretty_print(&self, result: &mut PrettyPrintResult, state: &PrettyPrintState) {
+        let state = state.new_level();
+        result.println("CaclGroupsCrossJoin: ", &state);
+        let state = state.new_level();
+        result.println("Groups: ", &state);
+        let details_state = state.new_level();
+        for group in &self.calc_groups {
+            group.pretty_print(result, &details_state);
+        }
+        result.println("Source: ", &state);
+        self.source.pretty_print(result, &details_state);
+    }
+}

rust/cubesqlplanner/cubesqlplanner/src/logical_plan/logical_node.rs

@@ -26,6 +26,7 @@ pub enum PlanNode {
     MeasureSubquery(Rc<MeasureSubquery>),
     DimensionSubQuery(Rc<DimensionSubQuery>),
     KeysSubQuery(Rc<KeysSubQuery>),
+    CalcGroupsCrossJoin(Rc<CalcGroupsCrossJoin>),
     MultiStageGetDateRange(Rc<MultiStageGetDateRange>),
     MultiStageLeafMeasure(Rc<MultiStageLeafMeasure>),
     MultiStageMeasureCalculation(Rc<MultiStageMeasureCalculation>),
@@ -48,6 +49,7 @@ macro_rules! match_plan_node {
             PlanNode::MeasureSubquery($node) => $block,
             PlanNode::DimensionSubQuery($node) => $block,
             PlanNode::KeysSubQuery($node) => $block,
+            PlanNode::CalcGroupsCrossJoin($node) => $block,
             PlanNode::MultiStageGetDateRange($node) => $block,
             PlanNode::MultiStageLeafMeasure($node) => $block,
             PlanNode::MultiStageMeasureCalculation($node) => $block,

rust/cubesqlplanner/cubesqlplanner/src/logical_plan/logical_source.rs

@@ -0,0 +1,42 @@
+use super::*;
+use cubenativeutils::CubeError;
+use std::rc::Rc;
+
+pub trait LogicalSource: Sized {
+    fn as_plan_node(&self) -> PlanNode;
+    fn with_plan_node(&self, plan_node: PlanNode) -> Result<Self, CubeError>;
+}
+
+/* test example */
+
+pub enum TestSouce {
+    Cube(Rc<Cube>),
+    MeasureSubquery(Rc<MeasureSubquery>),
+}
+
+impl LogicalSource for TestSouce {
+    fn as_plan_node(&self) -> PlanNode {
+        match self {
+            Self::Cube(item) => item.as_plan_node(),
+            Self::MeasureSubquery(item) => item.as_plan_node(),
+        }
+    }
+    fn with_plan_node(&self, plan_node: PlanNode) -> Result<Self, CubeError> {
+        Ok(match self {
+            Self::Cube(_) => Self::Cube(plan_node.into_logical_node()?),
+            Self::MeasureSubquery(_) => Self::MeasureSubquery(plan_node.into_logical_node()?),
+        })
+    }
+}
+
+impl From<Rc<Cube>> for TestSouce {
+    fn from(value: Rc<Cube>) -> Self {
+        Self::Cube(value)
+    }
+}
+
+impl From<Rc<MeasureSubquery>> for TestSouce {
+    fn from(value: Rc<MeasureSubquery>) -> Self {
+        Self::MeasureSubquery(value)
+    }
+}

rust/cubesqlplanner/cubesqlplanner/src/logical_plan/mod.rs

@@ -1,4 +1,5 @@
 mod aggregate_multiplied_subquery;
+mod calc_groups_cross_join;
 mod cube;
 mod dimension_subquery;
 mod filter;
@@ -7,17 +8,20 @@ mod join;
 mod keys_subquery;
 mod logical_node;
 mod logical_query_modifers;
+mod logical_source;
 mod measure_subquery;
 mod multistage;
 pub mod optimizers;
 mod pre_aggregation;
 pub mod pretty_print;
 mod query;
+mod query_source;
 mod resolve_multiplied_measures;
 mod schema;
 pub mod visitor;
 
 pub use aggregate_multiplied_subquery::*;
+pub use calc_groups_cross_join::*;
 pub use cube::*;
 pub use dimension_subquery::*;
 pub use filter::*;
@@ -26,11 +30,13 @@ pub use join::*;
 pub use keys_subquery::*;
 pub use logical_node::*;
 pub use logical_query_modifers::*;
+pub use logical_source::*;
 pub use measure_subquery::*;
 pub use multistage::*;
 pub use optimizers::*;
 pub use pre_aggregation::*;
 pub use pretty_print::*;
 pub use query::*;
+pub use query_source::*;
 pub use resolve_multiplied_measures::*;
 pub use schema::*;

rust/cubesqlplanner/cubesqlplanner/src/logical_plan/query.rs

@@ -2,41 +2,6 @@ use super::*;
 use cubenativeutils::CubeError;
 use std::rc::Rc;
 
-#[derive(Clone)]
-pub enum QuerySource {
-    LogicalJoin(Rc<LogicalJoin>),
-    FullKeyAggregate(Rc<FullKeyAggregate>),
-    PreAggregation(Rc<PreAggregation>),
-}
-
-impl QuerySource {
-    fn as_plan_node(&self) -> PlanNode {
-        match self {
-            Self::LogicalJoin(item) => item.as_plan_node(),
-            Self::FullKeyAggregate(item) => item.as_plan_node(),
-            Self::PreAggregation(item) => item.as_plan_node(),
-        }
-    }
-    fn with_plan_node(&self, plan_node: PlanNode) -> Result<Self, CubeError> {
-        Ok(match self {
-            Self::LogicalJoin(_) => Self::LogicalJoin(plan_node.into_logical_node()?),
-            Self::FullKeyAggregate(_) => Self::FullKeyAggregate(plan_node.into_logical_node()?),
-            Self::PreAggregation(_) => Self::PreAggregation(plan_node.into_logical_node()?),
-        })
-    }
-}
-
-impl PrettyPrint for QuerySource {
-    fn pretty_print(&self, result: &mut PrettyPrintResult, state: &PrettyPrintState) {
-        match self {
-            QuerySource::LogicalJoin(join) => join.pretty_print(result, state),
-            QuerySource::FullKeyAggregate(full_key) => full_key.pretty_print(result, state),
-            QuerySource::PreAggregation(pre_aggregation) => {
-                pre_aggregation.pretty_print(result, state)
-            }
-        }
-    }
-}
 #[derive(Clone)]
 pub struct Query {
     pub multistage_members: Vec<Rc<LogicalMultiStageMember>>,

rust/cubesqlplanner/cubesqlplanner/src/logical_plan/query_source.rs

@@ -0,0 +1,39 @@
+use super::*;
+use cubenativeutils::CubeError;
+use std::rc::Rc;
+
+#[derive(Clone)]
+pub enum QuerySource {
+    LogicalJoin(Rc<LogicalJoin>),
+    FullKeyAggregate(Rc<FullKeyAggregate>),
+    PreAggregation(Rc<PreAggregation>),
+}
+
+impl QuerySource {
+    pub fn as_plan_node(&self) -> PlanNode {
+        match self {
+            Self::LogicalJoin(item) => item.as_plan_node(),
+            Self::FullKeyAggregate(item) => item.as_plan_node(),
+            Self::PreAggregation(item) => item.as_plan_node(),
+        }
+    }
+    pub fn with_plan_node(&self, plan_node: PlanNode) -> Result<Self, CubeError> {
+        Ok(match self {
+            Self::LogicalJoin(_) => Self::LogicalJoin(plan_node.into_logical_node()?),
+            Self::FullKeyAggregate(_) => Self::FullKeyAggregate(plan_node.into_logical_node()?),
+            Self::PreAggregation(_) => Self::PreAggregation(plan_node.into_logical_node()?),
+        })
+    }
+}
+
+impl PrettyPrint for QuerySource {
+    fn pretty_print(&self, result: &mut PrettyPrintResult, state: &PrettyPrintState) {
+        match self {
+            QuerySource::LogicalJoin(join) => join.pretty_print(result, state),
+            QuerySource::FullKeyAggregate(full_key) => full_key.pretty_print(result, state),
+            QuerySource::PreAggregation(pre_aggregation) => {
+                pre_aggregation.pretty_print(result, state)
+            }
+        }
+    }
+}