multi stage

Author: waralexrom

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

@@ -237,6 +237,7 @@ export class BaseQuery {
     this.multiStageTimeDimensions = (this.options.multiStageTimeDimensions || []).map(this.newTimeDimension.bind(this));
     this.segments = (this.options.segments || []).map(this.newSegment.bind(this));
 
+
     const filters = this.extractFiltersAsTree(this.options.filters || []);
 
     // measure_filter (the one extracted from filters parameter on measure and
@@ -639,6 +640,9 @@ export class BaseQuery {
       cubeEvaluator: this.cubeEvaluator,
       order: this.options.order,
       filters: this.options.filters,
+      limit: this.options.limit ? this.options.limit.toString() : null,
+      rowLimit: this.options.rowLimit ? this.options.rowLimit.toString() : null,
+      offset: this.options.offset ? this.options.offset.toString() : null,
       baseTools: this,
 
     };
@@ -2463,7 +2467,6 @@ export class BaseQuery {
       fn,
       context
     );
-
     return context.joinHints;
   }
 

packages/cubejs-schema-compiler/src/compiler/JoinGraph.js

@@ -96,34 +96,29 @@ export class JoinGraph {
   }
 
   buildJoin(cubesToJoin) {
-    console.log("!!!! here ", cubesToJoin);
-    try {
-      if (!cubesToJoin.length) {
-        return null;
-      }
-      const key = JSON.stringify(cubesToJoin);
-      if (!this.builtJoins[key]) {
-        const join = R.pipe(
-          R.map(
-            cube => this.buildJoinTreeForRoot(cube, R.without([cube], cubesToJoin))
-          ),
-          R.filter(R.identity),
-          R.sortBy(joinTree => joinTree.joins.length)
-        )(cubesToJoin)[0];
-        if (!join) {
-          throw new UserError(`Can't find join path to join ${cubesToJoin.map(v => `'${v}'`).join(', ')}`);
-        }
-        this.builtJoins[key] = Object.assign(join, {
-          multiplicationFactor: R.compose(
-            R.fromPairs,
-            R.map(v => [this.cubeFromPath(v), this.findMultiplicationFactorFor(this.cubeFromPath(v), join.joins)])
-          )(cubesToJoin)
-        });
+    if (!cubesToJoin.length) {
+      return null;
+    }
+    const key = JSON.stringify(cubesToJoin);
+    if (!this.builtJoins[key]) {
+      const join = R.pipe(
+        R.map(
+          cube => this.buildJoinTreeForRoot(cube, R.without([cube], cubesToJoin))
+        ),
+        R.filter(R.identity),
+        R.sortBy(joinTree => joinTree.joins.length)
+      )(cubesToJoin)[0];
+      if (!join) {
+        throw new UserError(`Can't find join path to join ${cubesToJoin.map(v => `'${v}'`).join(', ')}`);
       }
-    return this.builtJoins[key];
-    } catch (e) {
-      console.log("!!!! errr ", e);
+      this.builtJoins[key] = Object.assign(join, {
+        multiplicationFactor: R.compose(
+          R.fromPairs,
+          R.map(v => [this.cubeFromPath(v), this.findMultiplicationFactorFor(this.cubeFromPath(v), join.joins)])
+        )(cubesToJoin)
+      });
     }
+    return this.builtJoins[key];
   }
 
   cubeFromPath(cubePath) {

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

@@ -97,7 +97,7 @@ describe('SQL Generation', () => {
             type: 'prior',
           }]
         },
-        cagr_1d: {
+        cagr_day: {
           multi_stage: true,
           sql: \`ROUND(100 * \${revenue} / NULLIF(\${revenue_day_ago}, 0))\`,
           type: 'number',
@@ -603,7 +603,7 @@ describe('SQL Generation', () => {
 
     //console.log(query.buildSqlAndParams());
 
-    const res = await dbRunner.testQuery(query.buildSqlAndParamsTest());
+    const res = await dbRunner.testQuery(query.buildSqlAndParams());
     console.log(JSON.stringify(res));
 
     expect(res).toEqual(
@@ -836,7 +836,7 @@ describe('SQL Generation', () => {
     measures: [
       'visitors.revenue',
       'visitors.revenue_day_ago',
-      'visitors.cagr_1d'
+      'visitors.cagr_day'
     ],
     timeDimensions: [{
       dimension: 'visitors.created_at',
@@ -848,8 +848,8 @@ describe('SQL Generation', () => {
     }],
     timezone: 'America/Los_Angeles'
   }, [
-    { visitors__created_at_day: '2017-01-05T00:00:00.000Z', visitors__cagr_1d: '150', visitors__revenue: '300', visitors__revenue_day_ago: '200' },
-    { visitors__created_at_day: '2017-01-06T00:00:00.000Z', visitors__cagr_1d: '300', visitors__revenue: '900', visitors__revenue_day_ago: '300' }
+    { visitors__created_at_day: '2017-01-05T00:00:00.000Z', visitors__cagr_day: '150', visitors__revenue: '300', visitors__revenue_day_ago: '200' },
+    { visitors__created_at_day: '2017-01-06T00:00:00.000Z', visitors__cagr_day: '300', visitors__revenue: '900', visitors__revenue_day_ago: '300' }
   ]));
 
   it('sql utils', async () => runQueryTest({
@@ -2529,7 +2529,7 @@ describe('SQL Generation', () => {
     }]
   ));
 
-  it('multi stage complex graph with time dimension through view 1', async () => runQueryTest(
+  it('multi stage complex graph with time dimension through view', async () => runQueryTest(
     {
       measures: ['visitors_multi_stage.adjusted_rank_sum', 'visitors_multi_stage.visitor_revenue'],
       dimensions: ['visitors_multi_stage.source'],

rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/base_query_options.rs

@@ -56,6 +56,10 @@ pub struct BaseQueryOptionsStatic {
     pub timezone: Option<String>,
     pub filters: Option<Vec<FilterItem>>,
     pub order: Option<Vec<OrderByItem>>,
+    pub limit: Option<String>,
+    #[serde(rename = "rowLimit")]
+    pub row_limit: Option<String>,
+    pub offset: Option<String>,
 }
 
 #[nativebridge::native_bridge(BaseQueryOptionsStatic)]

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

@@ -13,6 +13,7 @@ use std::rc::Rc;
 pub struct DimenstionDefinitionStatic {
     #[serde(rename = "type")]
     pub dimension_type: String,
+    #[serde(rename = "ownedByCube")]
     pub owned_by_cube: Option<bool>,
     #[serde(rename = "multiStage")]
     pub multi_stage: Option<bool>,

rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/measure_definition.rs

@@ -12,10 +12,20 @@ use serde::{Deserialize, Serialize};
 use std::any::Any;
 use std::rc::Rc;
 
+#[derive(Serialize, Deserialize, Debug, PartialEq, Eq, Clone)]
+pub struct TimeShiftReference {
+    pub interval: String,
+    #[serde(rename = "type")]
+    pub shift_type: Option<String>,
+    #[serde(rename = "timeDimension")]
+    pub time_dimension: String,
+}
+
 #[derive(Serialize, Deserialize, Debug)]
 pub struct MeasureDefinitionStatic {
     #[serde(rename = "type")]
     pub measure_type: String,
+    #[serde(rename = "ownedByCube")]
     pub owned_by_cube: Option<bool>,
     #[serde(rename = "multiStage")]
     pub multi_stage: Option<bool>,
@@ -25,6 +35,8 @@ pub struct MeasureDefinitionStatic {
     pub add_group_by_references: Option<Vec<String>>,
     #[serde(rename = "groupByReferences")]
     pub group_by_references: Option<Vec<String>>,
+    #[serde(rename = "timeShiftReferences")]
+    pub time_shift_references: Option<Vec<TimeShiftReference>>,
 }
 
 #[nativebridge::native_bridge(MeasureDefinitionStatic)]

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

@@ -4,14 +4,16 @@ use cubenativeutils::CubeError;
 use std::fmt;
 use std::rc::Rc;
 
+#[derive(Clone)]
 pub enum FilterGroupOperator {
     Or,
     And,
 }
 
+#[derive(Clone)]
 pub struct FilterGroup {
-    operator: FilterGroupOperator,
-    items: Vec<FilterItem>,
+    pub operator: FilterGroupOperator,
+    pub items: Vec<FilterItem>,
 }
 
 impl FilterGroup {
@@ -49,7 +51,11 @@ impl FilterItem {
                     .iter()
                     .map(|itm| itm.to_sql(context.clone()))
                     .collect::<Result<Vec<_>, _>>()?;
-                format!("({})", items_sql.join(&operator))
+                if items_sql.is_empty() {
+                    format!("( 1 = 1 )")
+                } else {
+                    format!("({})", items_sql.join(&operator))
+                }
             }
             FilterItem::Item(item) => {
                 let sql = item.to_sql(context.clone())?;

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

@@ -10,7 +10,7 @@ pub mod subquery;
 pub mod union;
 
 pub use expression::Expr;
-pub use filter::{Filter, FilterItem};
+pub use filter::{Filter, FilterGroup, FilterItem};
 pub use from::{From, FromSource};
 pub use join::{Join, JoinItem, JoinSource};
 pub use order::OrderBy;

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

@@ -15,6 +15,8 @@ pub struct Select {
     pub context: Rc<VisitorContext>,
     pub ctes: Vec<Rc<Subquery>>,
     pub is_distinct: bool,
+    pub limit: Option<usize>,
+    pub offset: Option<usize>,
 }
 
 impl Select {
@@ -77,12 +79,22 @@ impl Select {
 
         let distinct = if self.is_distinct { "DISTINCT " } else { "" };
         let from = self.from.to_sql(self.context.clone())?;
+        let limit = if let Some(limit) = self.limit {
+            format!(" LIMIT {limit}")
+        } else {
+            format!("")
+        };
+        let offset = if let Some(offset) = self.offset {
+            format!(" OFFSET {offset}")
+        } else {
+            format!("")
+        };
 
         let res = format!(
             "{ctes}SELECT\
             \n      {distinct}{projection}\
             \n    FROM\
-            \n{from}{where_condition}{group_by}{having}{order_by}",
+            \n{from}{where_condition}{group_by}{having}{order_by}{limit}{offset}",
         );
         Ok(res)
     }