feat(tesseract): Subqueries support

Author: waralexrom

packages/cubejs-schema-compiler/test/integration/postgres/sql-generation-logic.test.ts

@@ -453,7 +453,7 @@ describe('SQL Generation', () => {
     }
   });
 
-  it('having filter with operator OR 1', async () => {
+  it('having filter with operator OR', async () => {
     await compiler.compile();
 
     const query = new PostgresQuery({ joinGraph, cubeEvaluator, compiler }, {
@@ -648,7 +648,7 @@ describe('SQL Generation', () => {
     });
   });
 
-  it('where filter with operators OR & AND 1', async () => {
+  it('where filter with operators OR & AND', async () => {
     await compiler.compile();
 
     const query = new PostgresQuery({ joinGraph, cubeEvaluator, compiler }, {

rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/dimension_definition.rs

@@ -17,6 +17,10 @@ pub struct DimenstionDefinitionStatic {
     pub owned_by_cube: Option<bool>,
     #[serde(rename = "multiStage")]
     pub multi_stage: Option<bool>,
+    #[serde(rename = "subQuery")]
+    pub sub_query: Option<bool>,
+    #[serde(rename = "propagateFiltersToSubQuery")]
+    pub propagate_filters_to_sub_query: Option<bool>,
 }
 
 #[nativebridge::native_bridge(DimenstionDefinitionStatic)]

rust/cubesqlplanner/cubesqlplanner/src/plan/builder/select.rs

@@ -40,6 +40,22 @@ impl SelectBuilder {
         }
     }
 
+    pub fn new_from_select(select: Rc<Select>) -> Self {
+        Self {
+            projection_columns: select.projection_columns.clone(),
+            from: select.from.clone(),
+            filter: select.filter.clone(),
+            group_by: select.group_by.clone(),
+            having: select.having.clone(),
+            order_by: select.order_by.clone(),
+            ctes: select.ctes.clone(),
+            is_distinct: select.is_distinct,
+            limit: select.limit,
+            offset: select.offset,
+            result_schema: Schema::clone(&select.schema),
+        }
+    }
+
     pub fn add_projection_member(&mut self, member: &Rc<dyn BaseMember>, alias: Option<String>) {
         let alias = if let Some(alias) = alias {
             alias

rust/cubesqlplanner/cubesqlplanner/src/plan/filter.rs

@@ -36,6 +36,7 @@ pub enum FilterItem {
     Item(Rc<BaseFilter>),
 }
 
+#[derive(Clone)]
 pub struct Filter {
     pub items: Vec<FilterItem>,
 }

rust/cubesqlplanner/cubesqlplanner/src/plan/order.rs

@@ -1,5 +1,6 @@
 use super::Expr;
 
+#[derive(Clone)]
 pub struct OrderBy {
     pub expr: Expr,
     pub pos: usize,

rust/cubesqlplanner/cubesqlplanner/src/plan/schema/schema.rs

@@ -3,7 +3,7 @@ use crate::planner::BaseMember;
 use itertools::Itertools;
 use std::rc::Rc;
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct Schema {
     columns: Vec<SchemaColumn>,
 }

rust/cubesqlplanner/cubesqlplanner/src/plan/select.rs

@@ -7,6 +7,7 @@ use crate::planner::VisitorContext;
 use cubenativeutils::CubeError;
 use std::rc::Rc;
 
+#[derive(Clone)]
 pub struct AliasedExpr {
     pub expr: Expr,
     pub alias: String,
@@ -32,6 +33,7 @@ impl AliasedExpr {
     }
 }
 
+#[derive(Clone)]
 pub struct Select {
     pub(super) projection_columns: Vec<AliasedExpr>,
     pub(super) from: Rc<From>,

rust/cubesqlplanner/cubesqlplanner/src/planner/base_dimension.rs

@@ -1,13 +1,15 @@
 use super::query_tools::QueryTools;
-use super::sql_evaluator::MemberSymbol;
+use super::sql_evaluator::{MemberSymbol, SqlCall};
 use super::{evaluate_with_context, BaseMember, BaseMemberHelper, VisitorContext};
+use crate::cube_bridge::dimension_definition::DimensionDefinition;
 use cubenativeutils::CubeError;
 use std::rc::Rc;
 
 pub struct BaseDimension {
     dimension: String,
     query_tools: Rc<QueryTools>,
     member_evaluator: Rc<MemberSymbol>,
+    definition: Rc<dyn DimensionDefinition>,
     cube_name: String,
     name: String,
     default_alias: String,
@@ -58,6 +60,7 @@ impl BaseDimension {
                     member_evaluator: evaluation_node.clone(),
                     cube_name: s.cube_name().clone(),
                     name: s.name().clone(),
+                    definition: s.definition().clone(),
                     default_alias,
                 }))
             }
@@ -83,7 +86,27 @@ impl BaseDimension {
         self.member_evaluator.clone()
     }
 
+    pub fn sql_call(&self) -> Result<Rc<SqlCall>, CubeError> {
+        match self.member_evaluator.as_ref() {
+            MemberSymbol::Dimension(d) => Ok(d.member_sql().clone()),
+            _ => Err(CubeError::internal(format!(
+                "MemberSymbol::Dimension expected"
+            ))),
+        }
+    }
+
     pub fn dimension(&self) -> &String {
         &self.dimension
     }
+
+    pub fn is_sub_query(&self) -> bool {
+        self.definition.static_data().sub_query.unwrap_or(false)
+    }
+
+    pub fn propagate_filters_to_sub_query(&self) -> bool {
+        self.definition
+            .static_data()
+            .propagate_filters_to_sub_query
+            .unwrap_or(false)
+    }
 }

rust/cubesqlplanner/cubesqlplanner/src/planner/base_measure.rs

@@ -1,5 +1,5 @@
 use super::query_tools::QueryTools;
-use super::sql_evaluator::MemberSymbol;
+use super::sql_evaluator::{MemberSymbol, SqlCall};
 use super::{evaluate_with_context, BaseMember, BaseMemberHelper, VisitorContext};
 use crate::cube_bridge::measure_definition::{
     MeasureDefinition, RollingWindow, TimeShiftReference,
@@ -66,7 +66,7 @@ pub struct BaseMeasure {
     measure: String,
     query_tools: Rc<QueryTools>,
     member_evaluator: Rc<MemberSymbol>,
-    definition: Rc<dyn MeasureDefinition>,
+    definition: Option<Rc<dyn MeasureDefinition>>,
     time_shifts: Vec<MeasureTimeShift>,
     cube_name: String,
     name: String,
@@ -100,6 +100,10 @@ impl BaseMember for BaseMeasure {
         self.clone()
     }
 
+    fn full_name(&self) -> String {
+        format!("{}.{}", self.cube_name, self.name)
+    }
+
     fn cube_name(&self) -> &String {
         &self.cube_name
     }
@@ -127,7 +131,7 @@ impl BaseMeasure {
                     measure: s.full_name(),
                     query_tools: query_tools.clone(),
                     member_evaluator: evaluation_node.clone(),
-                    definition: s.definition().clone(),
+                    definition: Some(s.definition().clone()),
                     cube_name: s.cube_name().clone(),
                     name: s.name().clone(),
                     time_shifts,
@@ -152,6 +156,28 @@ impl BaseMeasure {
         }
     }
 
+    pub fn try_new_from_expression(
+        expression: Rc<SqlCall>,
+        cube_name: String,
+        name: String,
+        query_tools: Rc<QueryTools>,
+    ) -> Result<Self, CubeError> {
+        let full_name = format!("{}.{}", cube_name, name);
+        let member_evaluator = Rc::new(MemberSymbol::SqlCall(expression));
+        let default_alias =
+            BaseMemberHelper::default_alias(&cube_name, &name, &None, query_tools.clone())?;
+        Ok(Self {
+            measure: full_name,
+            query_tools,
+            member_evaluator,
+            definition: None,
+            cube_name,
+            name,
+            default_alias,
+            time_shifts: vec![],
+        })
+    }
+
     fn parse_time_shifts(
         definition: &Rc<dyn MeasureDefinition>,
     ) -> Result<Vec<MeasureTimeShift>, CubeError> {
@@ -177,40 +203,52 @@ impl BaseMeasure {
         &self.cube_name
     }
 
-    pub fn reduce_by(&self) -> &Option<Vec<String>> {
-        &self.definition.static_data().reduce_by_references
+    pub fn reduce_by(&self) -> Option<Vec<String>> {
+        self.definition
+            .as_ref()
+            .map_or(None, |d| d.static_data().reduce_by_references.clone())
     }
 
-    pub fn add_group_by(&self) -> &Option<Vec<String>> {
-        &self.definition.static_data().add_group_by_references
+    pub fn add_group_by(&self) -> Option<Vec<String>> {
+        self.definition
+            .as_ref()
+            .map_or(None, |d| d.static_data().add_group_by_references.clone())
     }
 
-    pub fn group_by(&self) -> &Option<Vec<String>> {
-        &self.definition.static_data().group_by_references
+    pub fn group_by(&self) -> Option<Vec<String>> {
+        self.definition
+            .as_ref()
+            .map_or(None, |d| d.static_data().group_by_references.clone())
     }
 
     //FIXME dublicate with symbol
     pub fn is_calculated(&self) -> bool {
-        match self.definition.static_data().measure_type.as_str() {
+        match self.measure_type() {
             "number" | "string" | "time" | "boolean" => true,
             _ => false,
         }
     }
 
-    pub fn time_shift_references(&self) -> &Option<Vec<TimeShiftReference>> {
-        &self.definition.static_data().time_shift_references
+    pub fn time_shift_references(&self) -> Option<Vec<TimeShiftReference>> {
+        self.definition
+            .as_ref()
+            .map_or(None, |d| d.static_data().time_shift_references.clone())
     }
 
     pub fn time_shifts(&self) -> &Vec<MeasureTimeShift> {
         &self.time_shifts
     }
 
     pub fn is_multi_stage(&self) -> bool {
-        self.definition.static_data().multi_stage.unwrap_or(false)
+        self.definition
+            .as_ref()
+            .map_or(false, |d| d.static_data().multi_stage.unwrap_or(false))
     }
 
-    pub fn rolling_window(&self) -> &Option<RollingWindow> {
-        &self.definition.static_data().rolling_window
+    pub fn rolling_window(&self) -> Option<RollingWindow> {
+        self.definition
+            .as_ref()
+            .map_or(None, |d| d.static_data().rolling_window.clone())
     }
 
     pub fn is_rolling_window(&self) -> bool {
@@ -226,11 +264,13 @@ impl BaseMeasure {
     }
 
     //FIXME dublicate with symbol
-    pub fn measure_type(&self) -> &String {
-        &self.definition.static_data().measure_type
+    pub fn measure_type(&self) -> &str {
+        self.definition
+            .as_ref()
+            .map_or("number", |d| &d.static_data().measure_type)
     }
 
     pub fn is_multi_stage_ungroupped(&self) -> bool {
-        self.is_calculated() || self.definition.static_data().measure_type == "rank"
+        self.is_calculated() || self.measure_type() == "rank"
     }
 }

rust/cubesqlplanner/cubesqlplanner/src/planner/base_query.rs

@@ -1,12 +1,7 @@
-use super::planners::{
-    FullKeyAggregateQueryPlanner, MultiStageQueryPlanner, MultipliedMeasuresQueryPlanner,
-    SimpleQueryPlanner,
-};
+use super::planners::QueryPlanner;
 use super::query_tools::QueryTools;
 use super::QueryProperties;
 use crate::cube_bridge::base_query_options::BaseQueryOptions;
-use crate::plan::Select;
-use crate::planner::sql_evaluator::sql_nodes::SqlNodesFactory;
 use crate::planner::sql_templates::PlanSqlTemplates;
 use cubenativeutils::wrappers::inner_types::InnerTypes;
 use cubenativeutils::wrappers::object::NativeArray;
@@ -45,7 +40,8 @@ impl<IT: InnerTypes> BaseQuery<IT> {
 
     pub fn build_sql_and_params(&self) -> Result<NativeObjectHandle<IT>, CubeError> {
         let templates = PlanSqlTemplates::new(self.query_tools.templates_render());
-        let plan = self.build_sql_and_params_impl(templates.clone())?;
+        let query_planner = QueryPlanner::new(self.request.clone(), self.query_tools.clone());
+        let plan = query_planner.build_sql()?;
 
         let sql = plan.to_sql(&templates)?;
         let (result_sql, params) = self.query_tools.build_sql_and_params(&sql, true)?;
@@ -57,41 +53,4 @@ impl<IT: InnerTypes> BaseQuery<IT> {
 
         Ok(result)
     }
-
-    fn build_sql_and_params_impl(&self, templates: PlanSqlTemplates) -> Result<Select, CubeError> {
-        let mut nodes_factory = SqlNodesFactory::new();
-
-        if self.request.ungrouped() {
-            nodes_factory.set_ungrouped(true)
-        }
-
-        if self.request.is_simple_query()? {
-            let planner = SimpleQueryPlanner::new(
-                self.query_tools.clone(),
-                self.request.clone(),
-                nodes_factory.clone(),
-            );
-            planner.plan()
-        } else {
-            let request = self.request.clone();
-            let multiplied_measures_query_planner = MultipliedMeasuresQueryPlanner::new(
-                self.query_tools.clone(),
-                request.clone(),
-                nodes_factory.clone(),
-            );
-            let multi_stage_query_planner =
-                MultiStageQueryPlanner::new(self.query_tools.clone(), request.clone());
-            let full_key_aggregate_planner = FullKeyAggregateQueryPlanner::new(
-                request.clone(),
-                nodes_factory.clone(),
-                templates,
-            );
-            let mut subqueries = multiplied_measures_query_planner.plan_queries()?;
-            let (multi_stage_ctes, multi_stage_subqueries) =
-                multi_stage_query_planner.plan_queries()?;
-            subqueries.extend(multi_stage_subqueries.into_iter());
-            let result = full_key_aggregate_planner.plan(subqueries, multi_stage_ctes)?;
-            Ok(result)
-        }
-    }
 }