fix(schema-compiler): Handle pre-aggregations matching in presence of join paths

Author: mcheshkov

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

@@ -430,6 +430,13 @@ export class PreAggregations {
     };
   }
 
+  /**
+   *
+   * @param query
+   * @param members
+   * @param {Map<string, Array<string>>} cubeToJoinPrefix
+   * @returns {Array<string>}
+   */
   static ownedMembers(query, members) {
     return R.pipe(R.uniq, R.sortBy(R.identity))(
       query
@@ -495,6 +502,33 @@ export class PreAggregations {
     //  query can have same members as pre-agg, but different calculated join path
     //  `refs` will come from preagg references, and would contain full join paths
 
+    // TODO remove this in favor of matching with join path
+    /**
+     * @param {PreAggregationReferences} references
+     * @returns {PreAggregationReferences}
+     */
+    function trimmedReferences(references) {
+      const timeDimensionsTrimmed = references
+        .timeDimensions
+        .map(td => ({
+          ...td,
+          dimension: CubeSymbols.joinHintFromPath(td.dimension).path,
+        }));
+      const measuresTrimmed = references
+        .measures
+        .map(m => CubeSymbols.joinHintFromPath(m).path);
+      const dimensionsTrimmed = references
+        .dimensions
+        .map(d => CubeSymbols.joinHintFromPath(d).path);
+
+      return {
+        ...references,
+        dimensions: dimensionsTrimmed,
+        measures: measuresTrimmed,
+        timeDimensions: timeDimensionsTrimmed,
+      };
+    }
+
     /**
      * Returns an array of 2-elements arrays with the dimension and granularity
      * sorted by the concatenated dimension + granularity key.
@@ -534,18 +568,19 @@ export class PreAggregations {
 
     /**
      * Determine whether pre-aggregation can be used or not.
-     * @param {*} references
+     * @param {PreAggregationReferences} references
      * @returns {boolean}
      */
     const canUsePreAggregationNotAdditive = (references) => {
-      const refTimeDimensions =
-        backAlias(references.sortedTimeDimensions || sortTimeDimensions(references.timeDimensions));
+      // TODO remove this in favor of matching with join path
+      const referencesTrimmed = trimmedReferences(references);
+
+      const refTimeDimensions = backAlias(sortTimeDimensions(referencesTrimmed.timeDimensions));
       const qryTimeDimensions = references.allowNonStrictDateRangeMatch
         ? transformedQuery.timeDimensions
         : transformedQuery.sortedTimeDimensions;
-      const backAliasMeasures = backAlias(references.measures);
-      const backAliasSortedDimensions = backAlias(references.sortedDimensions || references.dimensions);
-      const backAliasDimensions = backAlias(references.dimensions);
+      const backAliasMeasures = backAlias(referencesTrimmed.measures);
+      const backAliasDimensions = backAlias(referencesTrimmed.dimensions);
       return ((
         transformedQuery.hasNoTimeDimensionsWithoutGranularity
       ) && (
@@ -557,10 +592,10 @@ export class PreAggregations {
         R.equals(transformedQuery.timeDimensions, refTimeDimensions)
       ) && (
         filterDimensionsSingleValueEqual &&
-        references.dimensions.length === filterDimensionsSingleValueEqual.size &&
+        referencesTrimmed.dimensions.length === filterDimensionsSingleValueEqual.size &&
         R.all(d => filterDimensionsSingleValueEqual.has(d), backAliasDimensions) ||
         transformedQuery.allFiltersWithinSelectedDimensions &&
-        R.equals(backAliasSortedDimensions, transformedQuery.sortedDimensions)
+        R.equals(backAliasDimensions, transformedQuery.sortedDimensions)
       ) && (
         R.all(m => backAliasMeasures.indexOf(m) !== -1, transformedQuery.measures) ||
         // TODO do we need backAlias here?
@@ -581,16 +616,15 @@ export class PreAggregations {
 
     /**
      * Determine whether time dimensions match to the window granularity or not.
-     * @param {*} references
+     * @param {PreAggregationReferences} references
      * @returns {boolean}
      */
     const windowGranularityMatches = (references) => {
       if (!transformedQuery.windowGranularity) {
         return true;
       }
-      const sortedTimeDimensions =
-        references.sortedTimeDimensions ||
-        sortTimeDimensions(references.timeDimensions);
+      // Beware that sortedTimeDimensions contain full join paths
+      const sortedTimeDimensions = sortTimeDimensions(references.timeDimensions);
 
       return sortedTimeDimensions
         .map(td => expandGranularity(td[0], transformedQuery.windowGranularity))
@@ -620,7 +654,7 @@ export class PreAggregations {
     /**
      * Determine whether pre-aggregation can be used or not.
      * TODO: revisit cumulative leaf measure matches.
-     * @param {*} references
+     * @param {PreAggregationReferences} references
      * @returns {boolean}
      */
     const canUsePreAggregationLeafMeasureAdditive = (references) => {
@@ -636,11 +670,14 @@ export class PreAggregations {
         ? transformedQuery.ownedTimeDimensionsAsIs.map(expandTimeDimension)
         : transformedQuery.ownedTimeDimensionsWithRollupGranularity.map(expandTimeDimension);
 
+      // TODO remove this in favor of matching with join path
+      const referencesTrimmed = trimmedReferences(references);
+
       const dimensionsMatch = (dimensions, doBackAlias) => R.all(
         d => (
           doBackAlias ?
-            backAlias(references.sortedDimensions || references.dimensions) :
-            (references.sortedDimensions || references.dimensions)
+            backAlias(referencesTrimmed.dimensions) :
+            (referencesTrimmed.dimensions)
         ).indexOf(d) !== -1,
         dimensions
       );
@@ -657,13 +694,13 @@ export class PreAggregations {
         )
       )(
         doBackAlias ?
-          backAlias(references.sortedTimeDimensions || sortTimeDimensions(references.timeDimensions)) :
-          (references.sortedTimeDimensions || sortTimeDimensions(references.timeDimensions))
+          backAlias(sortTimeDimensions(referencesTrimmed.timeDimensions)) :
+          (sortTimeDimensions(referencesTrimmed.timeDimensions))
       );
 
       if (transformedQuery.ungrouped) {
         const allReferenceCubes = R.pipe(R.map(m => (m.dimension || m).split('.')[0]), R.uniq, R.sortBy(R.identity))(
-          references.measures.concat(references.dimensions).concat(references.timeDimensions)
+          referencesTrimmed.measures.concat(referencesTrimmed.dimensions).concat(referencesTrimmed.timeDimensions)
         );
         if (
           !R.equals(transformedQuery.sortedAllCubeNames, allReferenceCubes) ||
@@ -675,12 +712,12 @@ export class PreAggregations {
         }
       }
 
-      const backAliasMeasures = backAlias(references.measures);
+      const backAliasMeasures = backAlias(referencesTrimmed.measures);
       return ((
         windowGranularityMatches(references)
       ) && (
         R.all(
-          m => references.measures.indexOf(m) !== -1,
+          m => referencesTrimmed.measures.indexOf(m) !== -1,
           transformedQuery.leafMeasures,
         ) || R.all(
           m => backAliasMeasures.indexOf(m) !== -1,
@@ -1151,6 +1188,10 @@ export class PreAggregations {
    * @returns {PreAggregationReferences}
    */
   evaluateAllReferences(cube, aggregation, preAggregationName) {
+    // TODO build a join tree for all references, so they would always include full join path
+    //  Even for preaggregation references without join path
+    //  It is necessary to be able to match query and preaggregation based on full join tree
+
     const evaluateReferences = () => {
       const references = this.query.cubeEvaluator.evaluatePreAggregationReferences(cube, aggregation);
       if (aggregation.type === 'rollupLambda') {