more tests

Author: KSDaemon

packages/cubejs-schema-compiler/test/integration/postgres/pre-aggregations.test.ts

@@ -789,6 +789,142 @@ describe('PreAggregations', () => {
       }
     });
 
+    cube('cube_a', {
+      sql: \`SELECT 1 as id, 'dim_a' as dim_a\`,
+
+      joins: {
+        cube_b: {
+          relationship: 'many_to_one',
+          sql: \`\${CUBE.dim_a} = \${cube_b.dim_a}\`
+        },
+        cube_c: {
+          relationship: 'many_to_one',
+          sql: \`\${CUBE.dim_a} = \${cube_c.dim_a}\`
+        }
+      },
+
+      dimensions: {
+        id: {
+          sql: 'id',
+          type: 'string',
+          primary_key: true
+        },
+
+        dim_a: {
+          sql: 'dim_a',
+          type: 'string'
+        },
+
+        dim_b: {
+          sql: 'dim_b',
+          type: 'string'
+        },
+      },
+
+      pre_aggregations: {
+        aaa_rollup: {
+          dimensions: [
+            dim_a
+          ]
+        },
+        rollupJoinAB: {
+          type: 'rollupJoin',
+          dimensions: [
+            dim_a,
+            cube_b.dim_b,
+            cube_c.dim_c
+          ],
+          rollups: [
+            aaa_rollup,
+            cube_b.bbb_rollup
+          ]
+        }
+      }
+    });
+
+    cube('cube_b', {
+      sql: \`SELECT 2 as id, 'dim_a' as dim_a, 'dim_b' as dim_b\`,
+
+      joins: {
+        cube_c: {
+          relationship: 'many_to_one',
+          sql: \`\${CUBE.dim_b} = \${cube_c.dim_b}\`
+        }
+      },
+
+      dimensions: {
+        id: {
+          sql: 'id',
+          type: 'string',
+          primary_key: true
+        },
+
+        dim_a: {
+          sql: 'dim_a',
+          type: 'string'
+        },
+
+        dim_b: {
+          sql: 'dim_b',
+          type: 'string'
+        },
+      },
+
+      pre_aggregations: {
+        bbb_rollup: {
+          dimensions: [
+            dim_a,
+            dim_b,
+            cube_c.dim_c
+          ]
+        }
+      }
+    });
+
+    cube('cube_c', {
+      sql: \`SELECT 3 as id, 'dim_a' as dim_a, 'dim_b' as dim_b, 'dim_c' as dim_c\`,
+
+      dimensions: {
+        id: {
+          sql: 'id',
+          type: 'string',
+          primary_key: true
+        },
+
+        dim_a: {
+          sql: 'dim_a',
+          type: 'string'
+        },
+
+        dim_b: {
+          sql: 'dim_b',
+          type: 'string'
+        },
+
+        dim_c: {
+          sql: 'dim_c',
+          type: 'string'
+        },
+      }
+    });
+
+    view('view_abc', {
+      cubes: [
+        {
+          join_path: cube_a,
+          includes: ['dim_a']
+        },
+        {
+          join_path: cube_a.cube_b,
+          includes: ['dim_b']
+        },
+        {
+          join_path: cube_a.cube_b.cube_c,
+          includes: ['dim_c']
+        }
+      ]
+    });
+
   `);
 
   it('simple pre-aggregation', async () => {
@@ -3030,4 +3166,65 @@ describe('PreAggregations', () => {
       );
     });
   });
+
+  it('rollupJoin pre-aggregation with nested joins via view (A->B->C)', async () => {
+    await compiler.compile();
+
+    const query = new PostgresQuery({ joinGraph, cubeEvaluator, compiler }, {
+      dimensions: ['view_abc.dim_a', 'view_abc.dim_b', 'view_abc.dim_c'],
+      timezone: 'America/Los_Angeles',
+      preAggregationsSchema: ''
+    });
+
+    const queryAndParams = query.buildSqlAndParams();
+    console.log(queryAndParams);
+    const preAggregationsDescription: any = query.preAggregations?.preAggregationsDescription();
+    console.log(preAggregationsDescription);
+    expect(preAggregationsDescription.length).toBe(2);
+    const aaa = preAggregationsDescription.find(p => p.preAggregationId === 'cube_a.aaa_rollup');
+    const bbb = preAggregationsDescription.find(p => p.preAggregationId === 'cube_b.bbb_rollup');
+    expect(aaa).toBeDefined();
+    expect(bbb).toBeDefined();
+
+    expect(query.preAggregations?.preAggregationForQuery?.canUsePreAggregation).toEqual(true);
+    expect(query.preAggregations?.preAggregationForQuery?.preAggregationName).toEqual('rollupJoinAB');
+
+    return dbRunner.evaluateQueryWithPreAggregations(query).then(res => {
+      expect(res).toEqual(
+        [{
+          view_abc__dim_a: 'dim_a',
+          view_abc__dim_b: 'dim_b',
+          view_abc__dim_c: 'dim_c',
+        }]
+      );
+    });
+  });
+
+  it('rollupJoin pre-aggregation with nested joins via cube (A->B->C)', async () => {
+    await compiler.compile();
+
+    const query = new PostgresQuery({ joinGraph, cubeEvaluator, compiler }, {
+      dimensions: ['cube_a.dim_a', 'cube_b.dim_b', 'cube_c.dim_c'],
+      timezone: 'America/Los_Angeles',
+      preAggregationsSchema: ''
+    });
+
+    const queryAndParams = query.buildSqlAndParams();
+    console.log(queryAndParams);
+    const preAggregationsDescription: any = query.preAggregations?.preAggregationsDescription();
+    console.log(preAggregationsDescription);
+    expect(preAggregationsDescription.length).toBe(0);
+
+    expect(query.preAggregations?.preAggregationForQuery).toBeUndefined();
+
+    return dbRunner.evaluateQueryWithPreAggregations(query).then(res => {
+      expect(res).toEqual(
+        [{
+          cube_a__dim_a: 'dim_a',
+          cube_b__dim_b: 'dim_b',
+          cube_c__dim_c: 'dim_c',
+        }]
+      );
+    });
+  });
 });