in work

Author: waralexrom

packages/cubejs-schema-compiler/src/adapter/BaseQuery.js

@@ -3250,6 +3250,7 @@ export class BaseQuery {
         group_by_exprs: '{{ group_by | map(attribute=\'index\') | join(\', \') }}',
       },
       expressions: {
+        column_reference: '{% if table_name %}{{ table_name }}.{% endif %}{{ name }}',
         column_aliased: '{{expr}} {{quoted_alias}}',
         case: 'CASE{% if expr %} {{ expr }}{% endif %}{% for when, then in when_then %} WHEN {{ when }} THEN {{ then }}{% endfor %}{% if else_expr %} ELSE {{ else_expr }}{% endif %} END',
         is_null: '{{ expr }} IS {% if negate %}NOT {% endif %}NULL',

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

@@ -538,7 +538,7 @@ describe('SQL Generation', () => {
     });
     `);
 
-  it('simple join', async () => {
+  it('simple join 1', async () => {
     await compiler.compile();
 
     console.log(joinGraph.buildJoin(['visitor_checkins', 'visitors']));
@@ -2372,7 +2372,7 @@ describe('SQL Generation', () => {
     }]
   ));
 
-  it('multi stage measure with multiple dependencies', async () => runQueryTest(
+  it('multi stage measure with multiple dependencies 1', async () => runQueryTest(
     {
       measures: ['visitors.second_rank_sum', 'visitors.visitor_revenue', 'visitors.revenue_rank'],
       dimensions: ['visitors.source'],

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

@@ -0,0 +1,125 @@
+use crate::plan::{Join, JoinCondition, JoinItem, QueryPlan, Schema, Select, SingleAliasedSource};
+use crate::planner::BaseCube;
+use std::rc::Rc;
+
+pub struct JoinBuilder {
+    root: SingleAliasedSource,
+    joins: Vec<JoinItem>,
+}
+
+impl JoinBuilder {
+    pub fn new(root: SingleAliasedSource) -> Self {
+        Self {
+            root,
+            joins: vec![],
+        }
+    }
+
+    pub fn new_from_cube(cube: Rc<BaseCube>, alias: Option<String>) -> Self {
+        Self::new(SingleAliasedSource::new_from_cube(cube, alias))
+    }
+
+    pub fn new_from_table_reference(
+        reference: String,
+        schema: Rc<Schema>,
+        alias: Option<String>,
+    ) -> Self {
+        Self::new(SingleAliasedSource::new_from_table_reference(
+            reference, schema, alias,
+        ))
+    }
+
+    pub fn new_from_subquery(plan: Rc<QueryPlan>, alias: String) -> Self {
+        Self::new(SingleAliasedSource::new_from_subquery(plan, alias))
+    }
+
+    pub fn new_from_subselect(plan: Rc<Select>, alias: String) -> Self {
+        Self::new(SingleAliasedSource::new_from_subquery(
+            Rc::new(QueryPlan::Select(plan)),
+            alias,
+        ))
+    }
+
+    pub fn left_join_subselect(&mut self, subquery: Rc<Select>, alias: String, on: JoinCondition) {
+        self.join_subselect(subquery, alias, on, false)
+    }
+
+    pub fn inner_join_subselect(&mut self, subquery: Rc<Select>, alias: String, on: JoinCondition) {
+        self.join_subselect(subquery, alias, on, true)
+    }
+
+    pub fn left_join_cube(&mut self, cube: Rc<BaseCube>, alias: Option<String>, on: JoinCondition) {
+        self.join_cube(cube, alias, on, false)
+    }
+
+    pub fn inner_join_cube(
+        &mut self,
+        cube: Rc<BaseCube>,
+        alias: Option<String>,
+        on: JoinCondition,
+    ) {
+        self.join_cube(cube, alias, on, true)
+    }
+
+    pub fn left_join_table_reference(
+        &mut self,
+        reference: String,
+        schema: Rc<Schema>,
+        alias: Option<String>,
+        on: JoinCondition,
+    ) {
+        self.join_table_reference(reference, schema, alias, on, false)
+    }
+
+    pub fn inner_join_table_reference(
+        &mut self,
+        reference: String,
+        schema: Rc<Schema>,
+        alias: Option<String>,
+        on: JoinCondition,
+    ) {
+        self.join_table_reference(reference, schema, alias, on, true)
+    }
+
+    pub fn build(self) -> Rc<Join> {
+        Rc::new(Join {
+            root: self.root,
+            joins: self.joins,
+        })
+    }
+
+    fn join_subselect(
+        &mut self,
+        subquery: Rc<Select>,
+        alias: String,
+        on: JoinCondition,
+        is_inner: bool,
+    ) {
+        let subquery = Rc::new(QueryPlan::Select(subquery));
+        let from = SingleAliasedSource::new_from_subquery(subquery, alias);
+        self.joins.push(JoinItem { from, on, is_inner })
+    }
+
+    fn join_cube(
+        &mut self,
+        cube: Rc<BaseCube>,
+        alias: Option<String>,
+        on: JoinCondition,
+        is_inner: bool,
+    ) {
+        let from = SingleAliasedSource::new_from_cube(cube, alias);
+        self.joins.push(JoinItem { from, on, is_inner })
+    }
+
+    fn join_table_reference(
+        &mut self,
+        reference: String,
+        schema: Rc<Schema>,
+        alias: Option<String>,
+        on: JoinCondition,
+        is_inner: bool,
+    ) {
+        let from = SingleAliasedSource::new_from_table_reference(reference, schema, alias);
+        self.joins.push(JoinItem { from, on, is_inner })
+    }
+}

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

@@ -0,0 +1,5 @@
+pub mod join;
+pub mod select;
+
+pub use join::JoinBuilder;
+pub use select::SelectBuilder;

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

@@ -0,0 +1,107 @@
+use crate::plan::{
+    AliasedExpr, Cte, Expr, Filter, From, MemberExpression, OrderBy, Schema, Select,
+};
+use crate::planner::{BaseMember, VisitorContext};
+use std::rc::Rc;
+
+pub struct SelectBuilder {
+    projection_columns: Vec<AliasedExpr>,
+    from: From,
+    filter: Option<Filter>,
+    group_by: Vec<Expr>,
+    having: Option<Filter>,
+    order_by: Vec<OrderBy>,
+    context: Rc<VisitorContext>,
+    ctes: Vec<Rc<Cte>>,
+    is_distinct: bool,
+    limit: Option<usize>,
+    offset: Option<usize>,
+    input_schema: Rc<Schema>,
+}
+
+impl SelectBuilder {
+    pub fn new(from: From, context: VisitorContext) -> Self {
+        let input_schema = from.schema.clone();
+        Self {
+            projection_columns: vec![],
+            from,
+            filter: None,
+            group_by: vec![],
+            having: None,
+            order_by: vec![],
+            context: Rc::new(context),
+            ctes: vec![],
+            is_distinct: false,
+            limit: None,
+            offset: None,
+            input_schema,
+        }
+    }
+
+    pub fn add_projection_member(
+        &mut self,
+        member: &Rc<dyn BaseMember>,
+        source: Option<String>,
+        alias: Option<String>,
+    ) {
+        let alias = if let Some(alias) = alias {
+            alias
+        } else {
+            self.input_schema.resolve_member_alias(&member, &source)
+        };
+        let expr = Expr::Member(MemberExpression::new(member.clone(), source));
+        let aliased_expr = AliasedExpr {
+            expr,
+            alias: alias.clone(),
+        };
+
+        self.projection_columns.push(aliased_expr);
+    }
+
+    pub fn set_filter(&mut self, filter: Option<Filter>) {
+        self.filter = filter;
+    }
+
+    pub fn set_group_by(&mut self, group_by: Vec<Expr>) {
+        self.group_by = group_by;
+    }
+
+    pub fn set_having(&mut self, having: Option<Filter>) {
+        self.having = having;
+    }
+
+    pub fn set_order_by(&mut self, order_by: Vec<OrderBy>) {
+        self.order_by = order_by;
+    }
+
+    pub fn set_distinct(&mut self) {
+        self.is_distinct = true;
+    }
+
+    pub fn set_limit(&mut self, limit: Option<usize>) {
+        self.limit = limit;
+    }
+
+    pub fn set_offset(&mut self, offset: Option<usize>) {
+        self.offset = offset;
+    }
+    pub fn set_ctes(&mut self, ctes: Vec<Rc<Cte>>) {
+        self.ctes = ctes;
+    }
+
+    pub fn build(self) -> Select {
+        Select {
+            projection_columns: self.projection_columns,
+            from: self.from,
+            filter: self.filter,
+            group_by: self.group_by,
+            having: self.having,
+            order_by: self.order_by,
+            context: self.context.clone(),
+            ctes: self.ctes,
+            is_distinct: self.is_distinct,
+            limit: self.limit,
+            offset: self.offset,
+        }
+    }
+}

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

@@ -0,0 +1,41 @@
+use super::{QueryPlan, Schema, Select};
+use crate::planner::sql_templates::PlanSqlTemplates;
+use cubenativeutils::CubeError;
+
+use std::rc::Rc;
+
+#[derive(Clone)]
+pub struct Cte {
+    query: Rc<QueryPlan>,
+    name: String,
+}
+
+impl Cte {
+    pub fn new(query: Rc<QueryPlan>, name: String) -> Self {
+        Self { query, name }
+    }
+
+    pub fn new_from_select(select: Rc<Select>, name: String) -> Self {
+        Self {
+            query: Rc::new(QueryPlan::Select(select)),
+            name,
+        }
+    }
+
+    pub fn make_schema(&self) -> Schema {
+        self.query.make_schema(Some(self.name().clone()))
+    }
+
+    pub fn query(&self) -> &Rc<QueryPlan> {
+        &self.query
+    }
+
+    pub fn name(&self) -> &String {
+        &self.name
+    }
+
+    pub fn to_sql(&self, templates: &PlanSqlTemplates) -> Result<String, CubeError> {
+        let sql = format!("({})", self.query.to_sql(templates)?);
+        Ok(sql)
+    }
+}

rust/cubesqlplanner/cubesqlplanner/src/plan/cte.rs

@@ -1,34 +1,51 @@
+use super::Schema;
 use crate::planner::sql_templates::PlanSqlTemplates;
 use crate::planner::{BaseMember, VisitorContext};
 use cubenativeutils::CubeError;
 use std::rc::Rc;
 
+#[derive(Clone)]
+pub struct MemberExpression {
+    pub member: Rc<dyn BaseMember>,
+    pub source: Option<String>,
+}
+
+impl MemberExpression {
+    pub fn new(member: Rc<dyn BaseMember>, source: Option<String>) -> Self {
+        Self { member, source }
+    }
+
+    pub fn to_sql(
+        &self,
+        templates: &PlanSqlTemplates,
+        context: Rc<VisitorContext>,
+        schema: Rc<Schema>,
+    ) -> Result<String, CubeError> {
+        if let Some(reference_column) = context
+            .source_schema()
+            .find_column_for_member(&self.member.full_name(), &self.source)
+        {
+            templates.column_reference(&reference_column.table_name, &reference_column.alias)
+        } else {
+            self.member.to_sql(context, schema)
+        }
+    }
+}
+
 #[derive(Clone)]
 pub enum Expr {
-    Field(Rc<dyn BaseMember>),
-    Reference(Option<String>, String),
-    Asterix,
+    Member(MemberExpression),
 }
 
 impl Expr {
     pub fn to_sql(
         &self,
         templates: &PlanSqlTemplates,
         context: Rc<VisitorContext>,
+        schema: Rc<Schema>,
     ) -> Result<String, CubeError> {
         match self {
-            Expr::Field(field) => {
-                let sql = field.to_sql(context)?;
-                Ok(sql)
-            }
-            Expr::Reference(cube_alias, field_alias) => {
-                if let Some(cube_alias) = cube_alias {
-                    Ok(format!("{}.{}", cube_alias, field_alias))
-                } else {
-                    Ok(field_alias.clone())
-                }
-            }
-            Expr::Asterix => Ok("*".to_string()),
+            Expr::Member(member) => member.to_sql(templates, context, schema),
         }
     }
 }