fix: Match additive pre-aggregations with missing members for views and proxy members (#7433)

Author: paveltiunov

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

@@ -533,6 +533,9 @@ export class PreAggregations {
         ? transformedQuery.timeDimensions
         : transformedQuery.sortedTimeDimensions;
 
+      const backAliasMeasures = backAlias(references.measures);
+      const backAliasSortedDimensions = backAlias(references.sortedDimensions || references.dimensions);
+      const backAliasDimensions = backAlias(references.dimensions);
       return ((
         transformedQuery.hasNoTimeDimensionsWithoutGranularity
       ) && (
@@ -545,13 +548,13 @@ export class PreAggregations {
       ) && (
         filterDimensionsSingleValueEqual &&
         references.dimensions.length === filterDimensionsSingleValueEqual.size &&
-        R.all(d => filterDimensionsSingleValueEqual.has(d), backAlias(references.dimensions)) ||
+        R.all(d => filterDimensionsSingleValueEqual.has(d), backAliasDimensions) ||
         transformedQuery.allFiltersWithinSelectedDimensions &&
-        R.equals(backAlias(references.sortedDimensions || references.dimensions), transformedQuery.sortedDimensions)
+        R.equals(backAliasSortedDimensions, transformedQuery.sortedDimensions)
       ) && (
-        R.all(m => backAlias(references.measures).indexOf(m) !== -1, transformedQuery.measures) ||
+        R.all(m => backAliasMeasures.indexOf(m) !== -1, transformedQuery.measures) ||
         // TODO do we need backAlias here?
-        R.all(m => backAlias(references.measures).indexOf(m) !== -1, transformedQuery.leafMeasures)
+        R.all(m => backAliasMeasures.indexOf(m) !== -1, transformedQuery.leafMeasures)
       ));
     };
 
@@ -619,33 +622,39 @@ export class PreAggregations {
         ? transformedQuery.ownedTimeDimensionsAsIs.map(expandTimeDimension)
         : transformedQuery.ownedTimeDimensionsWithRollupGranularity.map(expandTimeDimension);
 
-      const dimensionsMatch = (dimensions) => R.all(
+      const dimensionsMatch = (dimensions, doBackAlias) => R.all(
         d => (
-          references.sortedDimensions ||
-          references.dimensions
+          doBackAlias ?
+            backAlias(references.sortedDimensions || references.dimensions) :
+            (references.sortedDimensions || references.dimensions)
         ).indexOf(d) !== -1,
         dimensions
       );
 
-      const timeDimensionsMatch = (timeDimensionsList) => R.allPass(
+      const timeDimensionsMatch = (timeDimensionsList, doBackAlias) => R.allPass(
         timeDimensionsList.map(
           tds => R.anyPass(tds.map(td => R.contains(td)))
         )
       )(
-        references.sortedTimeDimensions ||
-        sortTimeDimensions(references.timeDimensions)
+        doBackAlias ?
+          backAlias(references.sortedTimeDimensions || sortTimeDimensions(references.timeDimensions)) :
+          (references.sortedTimeDimensions || sortTimeDimensions(references.timeDimensions))
       );
 
+      const backAliasMeasures = backAlias(references.measures);
       return ((
         windowGranularityMatches(references)
       ) && (
         R.all(
           m => references.measures.indexOf(m) !== -1,
           transformedQuery.leafMeasures,
+        ) || R.all(
+          m => backAliasMeasures.indexOf(m) !== -1,
+          transformedQuery.measures,
         )
       ) && (
-        dimensionsMatch(transformedQuery.sortedDimensions) && timeDimensionsMatch(queryTimeDimensionsList) ||
-        dimensionsMatch(transformedQuery.ownedDimensions) && timeDimensionsMatch(ownedQueryTimeDimensionsList)
+        dimensionsMatch(transformedQuery.sortedDimensions, true) && timeDimensionsMatch(queryTimeDimensionsList, true) ||
+        dimensionsMatch(transformedQuery.ownedDimensions, false) && timeDimensionsMatch(ownedQueryTimeDimensionsList, false)
       ));
     };
 

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

@@ -88,6 +88,10 @@ describe('PreAggregations', () => {
           type: 'string',
           sql: 'source'
         },
+        sourceAndId: {
+          type: 'string',
+          sql: \`\${source} || '_' || \${id}\`,
+        },
         createdAt: {
           type: 'time',
           sql: 'created_at'
@@ -220,6 +224,12 @@ describe('PreAggregations', () => {
           granularity: 'hour',
           partitionGranularity: 'month'
         },
+        sourceAndIdRollup: {
+          measures: [count],
+          dimensions: [sourceAndId, source],
+          timeDimension: createdAt,
+          granularity: 'hour',
+        }
       }
     })
     
@@ -749,6 +759,103 @@ describe('PreAggregations', () => {
     });
   }));
 
+  it('non-leaf additive measure', () => compiler.compile().then(() => {
+    const query = new PostgresQuery({ joinGraph, cubeEvaluator, compiler }, {
+      measures: [
+        'visitors_view.count'
+      ],
+      dimensions: ['visitors_view.sourceAndId'],
+      timezone: 'America/Los_Angeles',
+      order: [{
+        id: 'visitors_view.sourceAndId'
+      }],
+      preAggregationsSchema: ''
+    });
+
+    const queryAndParams = query.buildSqlAndParams();
+    console.log(queryAndParams);
+    const preAggregationsDescription = query.preAggregations?.preAggregationsDescription();
+    console.log(preAggregationsDescription);
+    expect((<any>preAggregationsDescription)[0].loadSql[0]).toMatch(/visitors_source_and_id_rollup/);
+
+    return dbRunner.evaluateQueryWithPreAggregations(query).then(res => {
+      expect(res).toEqual(
+        [
+          {
+            visitors_view__count: '1',
+            visitors_view__source_and_id: 'google_3'
+          },
+          {
+            visitors_view__count: '1',
+            visitors_view__source_and_id: 'some_1'
+          },
+          {
+            visitors_view__count: '1',
+            visitors_view__source_and_id: 'some_2'
+          },
+          {
+            visitors_view__count: '3',
+            visitors_view__source_and_id: null
+          }
+        ]
+      );
+    });
+  }));
+
+  it('non-leaf additive measure with time dimension', () => compiler.compile().then(() => {
+    const query = new PostgresQuery({ joinGraph, cubeEvaluator, compiler }, {
+      measures: [
+        'visitors_view.count'
+      ],
+      dimensions: ['visitors_view.sourceAndId'],
+      timezone: 'America/Los_Angeles',
+      timeDimensions: [{
+        dimension: 'visitors_view.signedUpAt',
+        granularity: 'day',
+        dateRange: ['2017-01-01', '2017-01-30']
+      }],
+      order: [{
+        id: 'visitors_view.createdAt',
+      }, {
+        id: 'visitors_view.sourceAndId'
+      }],
+      preAggregationsSchema: ''
+    });
+
+    const queryAndParams = query.buildSqlAndParams();
+    console.log(queryAndParams);
+    const preAggregationsDescription = query.preAggregations?.preAggregationsDescription();
+    console.log(preAggregationsDescription);
+    expect((<any>preAggregationsDescription)[0].loadSql[0]).toMatch(/visitors_source_and_id_rollup/);
+
+    return dbRunner.evaluateQueryWithPreAggregations(query).then(res => {
+      expect(res).toEqual(
+        [
+          {
+            visitors_view__count: '1',
+            visitors_view__signed_up_at_day: '2017-01-05T00:00:00.000Z',
+            visitors_view__source_and_id: 'google_3'
+          },
+          {
+            visitors_view__count: '1',
+            visitors_view__signed_up_at_day: '2017-01-02T00:00:00.000Z',
+            visitors_view__source_and_id: 'some_1'
+          },
+          {
+            visitors_view__count: '1',
+            visitors_view__signed_up_at_day: '2017-01-04T00:00:00.000Z',
+            visitors_view__source_and_id: 'some_2'
+          },
+          {
+            visitors_view__count: '2',
+            visitors_view__signed_up_at_day: '2017-01-06T00:00:00.000Z',
+            visitors_view__source_and_id: null
+          }
+        ]
+      );
+    });
+  }));
+
   it('inherited original sql', () => compiler.compile().then(() => {
     const query = new PostgresQuery({ joinGraph, cubeEvaluator, compiler }, {
       measures: [