@cubejs-backend/schema-compiler 1.3.11 → 1.3.13

package/dist/src/adapter/PreAggregations.js

@@ -5,15 +5,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PreAggregations = void 0;
 const ramda_1 = __importDefault(require("ramda"));
-const shared_1 = require("@cubejs-backend/shared");
 const CubeSymbols_1 = require("../compiler/CubeSymbols");
 const UserError_1 = require("../compiler/UserError");
+const BaseMeasure_1 = require("./BaseMeasure");
 class PreAggregations {
-    /**
-     * @param {import('../adapter/BaseQuery').BaseQuery} query
-     * @param historyQueries
-     * @param cubeLatticeCache
-     */
+    query;
+    historyQueries;
+    cubeLatticeCache;
+    cubeLattices;
+    hasCumulativeMeasuresValue = false;
+    preAggregationForQuery = undefined;
     constructor(query, historyQueries, cubeLatticeCache) {
         this.query = query;
         this.historyQueries = historyQueries;
@@ -21,7 +22,7 @@ class PreAggregations {
         this.cubeLattices = {};
     }
     /**
-     * @return {unknown[]}
+     * It returns full pre-aggregation object (with keyQueries, previewSql, loadSql, and so on.
      */
     preAggregationsDescription() {
         const preAggregations = [this.preAggregationsDescriptionLocal()].concat(this.query.subQueryDimensions.map(d => this.query.subQueryDescription(d).subQuery)
@@ -41,7 +42,7 @@ class PreAggregations {
             return ramda_1.default.pipe(ramda_1.default.map(cube => {
                 const { preAggregations } = this.collectOriginalSqlPreAggregations(() => this.query.cubeSql(cube));
                 return ramda_1.default.unnest(preAggregations.map(p => this.preAggregationDescriptionsFor(p)));
-            }), ramda_1.default.filter(ramda_1.default.identity), ramda_1.default.unnest)(this.preAggregationCubes());
+            }), ramda_1.default.filter((x) => Boolean(x)), ramda_1.default.unnest)(this.preAggregationCubes());
         }
         return [];
     }
@@ -52,10 +53,10 @@ class PreAggregations {
     preAggregationDescriptionsFor(foundPreAggregation) {
         let preAggregations = [foundPreAggregation];
         if (foundPreAggregation.preAggregation.type === 'rollupJoin') {
-            preAggregations = foundPreAggregation.preAggregationsToJoin;
+            preAggregations = foundPreAggregation.preAggregationsToJoin || [];
         }
         if (foundPreAggregation.preAggregation.type === 'rollupLambda') {
-            preAggregations = foundPreAggregation.referencedPreAggregations;
+            preAggregations = foundPreAggregation.referencedPreAggregations || [];
         }
         return preAggregations.map(preAggregation => {
             if (this.canPartitionsBeUsed(preAggregation)) {
@@ -66,28 +67,29 @@ class PreAggregations {
         }).reduce((a, b) => a.concat(b), []);
     }
     canPartitionsBeUsed(foundPreAggregation) {
-        return foundPreAggregation.preAggregation.partitionGranularity &&
-            foundPreAggregation.references.timeDimensions &&
-            foundPreAggregation.references.timeDimensions.length;
+        return !!foundPreAggregation.preAggregation.partitionGranularity &&
+            !!foundPreAggregation.references.timeDimensions?.length;
     }
     addPartitionRangeTo(foundPreAggregation, dimension, range, boundaryDateRange) {
-        return Object.assign({}, foundPreAggregation, {
-            preAggregation: Object.assign({}, foundPreAggregation.preAggregation, {
+        return {
+            ...foundPreAggregation,
+            preAggregation: {
+                ...foundPreAggregation.preAggregation,
                 partitionTimeDimensions: [{
                         dimension,
                         dateRange: range,
                         boundaryDateRange
                     }],
-            })
-        });
+            }
+        };
     }
     partitionDimension(foundPreAggregation) {
         const { dimension } = foundPreAggregation.references.timeDimensions[0];
         const partitionDimension = this.query.newTimeDimension({
             dimension,
             granularity: this.castGranularity(foundPreAggregation.preAggregation.partitionGranularity),
-            dateRange: this.query.timeDimensions[0] && this.query.timeDimensions[0].dateRange,
-            boundaryDateRange: this.query.timeDimensions[0] && this.query.timeDimensions[0].boundaryDateRange
+            dateRange: this.query.timeDimensions[0]?.dateRange,
+            boundaryDateRange: this.query.timeDimensions[0]?.boundaryDateRange
         });
         return { dimension, partitionDimension };
     }
@@ -96,7 +98,7 @@ class PreAggregations {
         const descriptions = query !== this.query ? query.preAggregations.preAggregationsDescription() : [];
         return descriptions.concat(this.preAggregationDescriptionFor(cube, foundPreAggregation));
     }
-    get hasCumulativeMeasures() {
+    hasCumulativeMeasures() {
         if (!this.hasCumulativeMeasuresValue) {
             this.hasCumulativeMeasuresValue = PreAggregations.hasCumulativeMeasures(this.query);
         }
@@ -128,10 +130,10 @@ class PreAggregations {
         const tableName = this.preAggregationTableName(cube, preAggregationName, preAggregation);
         const invalidateKeyQueries = this.query.preAggregationInvalidateKeyQueries(cube, preAggregation, preAggregationName);
         const queryForSqlEvaluation = this.query.preAggregationQueryForSqlEvaluation(cube, preAggregation);
-        const partitionInvalidateKeyQueries = queryForSqlEvaluation.partitionInvalidateKeyQueries?.(cube, preAggregation);
         const allBackAliasMembers = this.query.allBackAliasMembers();
-        const matchedTimeDimension = preAggregation.partitionGranularity && !this.hasCumulativeMeasures &&
-            this.query.timeDimensions.find(td => {
+        let matchedTimeDimension;
+        if (preAggregation.partitionGranularity && !this.hasCumulativeMeasures()) {
+            matchedTimeDimension = this.query.timeDimensions.find(td => {
                 if (!td.dateRange) {
                     return false;
                 }
@@ -139,7 +141,6 @@ class PreAggregations {
                     foundPreAggregation.references.timeDimensions;
                 const timeDimensionReference = timeDimensionsReference[0];
                 // timeDimensionsReference[*].dimension can contain full join path, so we should trim it
-                // TODO check full join path match here
                 const timeDimensionReferenceDimension = CubeSymbols_1.CubeSymbols.joinHintFromPath(timeDimensionReference.dimension).path;
                 if (td.dimension === timeDimensionReferenceDimension) {
                     return true;
@@ -147,17 +148,21 @@ class PreAggregations {
                 // Handling for views
                 return td.dimension === allBackAliasMembers[timeDimensionReferenceDimension];
             });
-        const filters = preAggregation.partitionGranularity && this.query.filters.filter(td => {
-            // TODO support all date operators
-            if (td.isDateOperator() && td.camelizeOperator === 'inDateRange') {
-                if (td.dimension === foundPreAggregation.references.timeDimensions[0].dimension) {
-                    return true;
+        }
+        let filters;
+        if (preAggregation.partitionGranularity) {
+            filters = this.query.filters?.filter((td) => {
+                // TODO support all date operators
+                if (td.isDateOperator() && 'camelizeOperator' in td && td.camelizeOperator === 'inDateRange') {
+                    if (td.dimension === foundPreAggregation.references.timeDimensions[0].dimension) {
+                        return true;
+                    }
+                    // Handling for views
+                    return td.dimension === allBackAliasMembers[foundPreAggregation.references.timeDimensions[0].dimension];
                 }
-                // Handling for views
-                return td.dimension === allBackAliasMembers[foundPreAggregation.references.timeDimensions[0].dimension];
-            }
-            return false;
-        });
+                return false;
+            });
+        }
         const uniqueKeyColumnsDefault = () => null;
         const uniqueKeyColumns = ({
             rollup: () => queryForSqlEvaluation.preAggregationUniqueKeyColumns(cube, preAggregation),
@@ -166,12 +171,11 @@ class PreAggregations {
         const aggregationsColumns = this.aggregationsColumns(cube, preAggregation);
         return {
             preAggregationId: `${cube}.${preAggregationName}`,
-            timezone: this.query.options && this.query.options.timezone,
+            timezone: this.query.options?.timezone,
             timestampFormat: queryForSqlEvaluation.timestampFormat(),
             timestampPrecision: queryForSqlEvaluation.timestampPrecision(),
             tableName,
             invalidateKeyQueries,
-            partitionInvalidateKeyQueries,
             type: preAggregation.type,
             external: preAggregation.external,
             previewSql: queryForSqlEvaluation.preAggregationPreviewSql(tableName),
@@ -182,15 +186,17 @@ class PreAggregations {
             uniqueKeyColumns,
             aggregationsColumns,
             dataSource: queryForSqlEvaluation.dataSource,
-            // in fact we can reference preAggregation.granularity however accessing timeDimensions is more strict and consistent
+            // in fact, we can reference preAggregation.granularity however accessing timeDimensions is more strict and consistent
             granularity: references.timeDimensions[0]?.granularity,
             partitionGranularity: preAggregation.partitionGranularity,
-            updateWindowSeconds: preAggregation.refreshKey && preAggregation.refreshKey.updateWindow &&
+            updateWindowSeconds: preAggregation.refreshKey &&
+                'updateWindow' in preAggregation.refreshKey &&
+                preAggregation.refreshKey?.updateWindow &&
                 queryForSqlEvaluation.parseSecondDuration(preAggregation.refreshKey.updateWindow),
             preAggregationStartEndQueries: (preAggregation.partitionGranularity || references.timeDimensions[0]?.granularity) &&
                 this.refreshRangeQuery(cube).preAggregationStartEndQueries(cube, preAggregation),
-            matchedTimeDimensionDateRange: preAggregation.partitionGranularity && (matchedTimeDimension && matchedTimeDimension.boundaryDateRangeFormatted() ||
-                filters && filters[0] && filters[0].formattedDateRange() // TODO intersect all date ranges
+            matchedTimeDimensionDateRange: preAggregation.partitionGranularity && (matchedTimeDimension?.boundaryDateRangeFormatted() ||
+                filters?.[0]?.formattedDateRange() // TODO intersect all date ranges
             ),
             indexesSql: Object.keys(preAggregation.indexes || {})
                 .map(index => {
@@ -198,7 +204,7 @@ class PreAggregations {
                 const indexName = this.preAggregationTableName(cube, `${foundPreAggregation.sqlAlias || preAggregationName}_${index}`, preAggregation, true);
                 return {
                     indexName,
-                    sql: queryForSqlEvaluation.indexSql(cube, preAggregation, preAggregation.indexes[index], indexName, tableName)
+                    sql: queryForSqlEvaluation.indexSql(cube, preAggregation, preAggregation.indexes?.[index], indexName, tableName)
                 };
             }),
             createTableIndexes: Object.keys(preAggregation.indexes || {})
@@ -207,8 +213,8 @@ class PreAggregations {
                 const indexName = this.preAggregationTableName(cube, `${foundPreAggregation.sqlAlias || preAggregationName}_${index}`, preAggregation, true);
                 return {
                     indexName,
-                    type: preAggregation.indexes[index].type,
-                    columns: queryForSqlEvaluation.evaluateIndexColumns(cube, preAggregation.indexes[index])
+                    type: preAggregation.indexes?.[index].type,
+                    columns: queryForSqlEvaluation.evaluateIndexColumns(cube, preAggregation.indexes?.[index])
                 };
             }),
             readOnly: preAggregation.readOnly || queryForSqlEvaluation.preAggregationReadOnly(cube, preAggregation),
@@ -218,7 +224,7 @@ class PreAggregations {
             lastRollupLambda: preAggregation.lastRollupLambda,
         };
     }
-    preAggregationTableName(cube, preAggregationName, preAggregation, skipSchema) {
+    preAggregationTableName(cube, preAggregationName, preAggregation, skipSchema = false) {
         const name = preAggregation.sqlAlias || preAggregationName;
         return this.query.preAggregationTableName(cube, name, skipSchema);
     }
@@ -238,10 +244,10 @@ class PreAggregations {
     }
     static transformQueryToCanUseForm(query) {
         const flattenDimensionMembers = this.flattenDimensionMembers(query);
-        const sortedDimensions = this.squashDimensions(query, flattenDimensionMembers);
+        const sortedDimensions = this.squashDimensions(flattenDimensionMembers);
         const allBackAliasMembers = query.allBackAliasMembers();
-        const measures = query.measures.concat(query.measureFilters);
-        const measurePaths = ramda_1.default.uniq(this.flattenMembers(measures).map(m => m.expressionPath()));
+        const measures = [...query.measures, ...query.measureFilters];
+        const measurePaths = ramda_1.default.uniq(this.flattenMembers(measures).filter((m) => m instanceof BaseMeasure_1.BaseMeasure).map(m => m.expressionPath()));
         const collectLeafMeasures = query.collectLeafMeasures.bind(query);
         const dimensionsList = query.dimensions.map(dim => dim.expressionPath());
         const segmentsList = query.segments.map(s => s.expressionPath());
@@ -270,7 +276,7 @@ class PreAggregations {
             sortedUsedCubePrimaryKeys.sort();
         }
         const measureToLeafMeasures = {};
-        const leafMeasurePaths = ramda_1.default.pipe(ramda_1.default.map(m => {
+        const leafMeasurePaths = ramda_1.default.pipe(ramda_1.default.map((m) => {
             const leafMeasures = query.collectFrom([m], collectLeafMeasures, 'collectLeafMeasures');
             measureToLeafMeasures[m.measure] = leafMeasures.map((measure) => {
                 const baseMeasure = query.newMeasure(measure);
@@ -297,7 +303,7 @@ class PreAggregations {
         const ownedTimeDimensionsWithRollupGranularity = PreAggregations.sortTimeDimensionsWithRollupGranularity(ownedTimeDimensions);
         const ownedTimeDimensionsAsIs = PreAggregations.timeDimensionsAsIs(ownedTimeDimensions);
         const hasNoTimeDimensionsWithoutGranularity = !query.timeDimensions.filter(d => !d.granularity).length;
-        const allFiltersWithinSelectedDimensions = ramda_1.default.all(d => dimensionsList.indexOf(d) !== -1)(ramda_1.default.flatten(query.filters.map(f => f.getMembers())).map(f => query.cubeEvaluator.pathFromArray(f.path())));
+        const allFiltersWithinSelectedDimensions = ramda_1.default.all((d) => dimensionsList.indexOf(d) !== -1)(ramda_1.default.flatten(query.filters.map(f => f.getMembers())).map(f => query.cubeEvaluator.pathFromArray(f.path())));
         const isAdditive = ramda_1.default.all(m => m.isAdditive(), query.measures);
         const hasMultiStage = ramda_1.default.any(m => m.isMultiStage(), query.measures);
         const leafMeasures = leafMeasurePaths.map(path => query.newMeasure(path));
@@ -339,23 +345,16 @@ class PreAggregations {
             hasMultiStage
         };
     }
-    /**
-     *
-     * @param query
-     * @param members
-     * @param {Map<string, Array<string>>} cubeToJoinPrefix
-     * @returns {Array<string>}
-     */
     static ownedMembers(query, members) {
         return ramda_1.default.pipe(ramda_1.default.uniq, ramda_1.default.sortBy(ramda_1.default.identity))(query
             .collectFrom(members, query.collectMemberNamesFor.bind(query), 'collectMemberNamesFor')
             .filter(d => query.cubeEvaluator.byPathAnyType(d).ownedByCube));
     }
     static sortTimeDimensionsWithRollupGranularity(timeDimensions) {
-        return timeDimensions && ramda_1.default.sortBy(ramda_1.default.prop(0), timeDimensions.map(d => [d.expressionPath(), d.rollupGranularity()])) || [];
+        return timeDimensions && ramda_1.default.sortBy(([exprPath]) => exprPath, timeDimensions.map(d => [d.expressionPath(), d.rollupGranularity()])) || [];
     }
     static timeDimensionsAsIs(timeDimensions) {
-        return timeDimensions && ramda_1.default.sortBy(ramda_1.default.prop(0), timeDimensions.map(d => [d.expressionPath(), d.resolvedGranularity()])) || [];
+        return timeDimensions && ramda_1.default.sortBy(([exprPath]) => exprPath, timeDimensions.map(d => [d.expressionPath(), d.resolvedGranularity()])) || [];
     }
     static collectFilterDimensionsWithSingleValueEqual(filters, map) {
         // eslint-disable-next-line no-restricted-syntax
@@ -374,6 +373,7 @@ class PreAggregations {
         }
         return map;
     }
+    // FIXME: It seems to be not used at all
     static transformedQueryToReferences(query) {
         return {
             measures: query.measures,
@@ -381,25 +381,18 @@ class PreAggregations {
             timeDimensions: query.sortedTimeDimensions.map(([dimension, granularity]) => ({ dimension, granularity }))
         };
     }
-    canUsePreAggregationFn(query, refs) {
+    canUsePreAggregationFn(query, refs = null) {
         return PreAggregations.canUsePreAggregationForTransformedQueryFn(PreAggregations.transformQueryToCanUseForm(query), refs);
     }
     /**
      * Returns function to determine whether pre-aggregation can be used or not
      * for specified query, or its value for `refs` if specified.
-     * @param {Object} transformedQuery transformed query
-     * @param {PreAggregationReferences?} refs pre-aggs reference
-     * @returns {function(preagg: Object): boolean}
      */
-    static canUsePreAggregationForTransformedQueryFn(transformedQuery, refs) {
+    static canUsePreAggregationForTransformedQueryFn(transformedQuery, refs = null) {
         // TODO this needs to check not only members list, but their join paths as well:
         //  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
+        //  `refs` will come from pre-agg 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
@@ -413,27 +406,25 @@ class PreAggregations {
             const dimensionsTrimmed = references
                 .dimensions
                 .map(d => CubeSymbols_1.CubeSymbols.joinHintFromPath(d).path);
+            const multipliedMeasuresTrimmed = references
+                .multipliedMeasures?.map(m => CubeSymbols_1.CubeSymbols.joinHintFromPath(m).path) || [];
             return {
                 ...references,
                 dimensions: dimensionsTrimmed,
                 measures: measuresTrimmed,
                 timeDimensions: timeDimensionsTrimmed,
+                multipliedMeasures: multipliedMeasuresTrimmed,
             };
         }
         /**
          * Returns an array of 2-elements arrays with the dimension and granularity
          * sorted by the concatenated dimension + granularity key.
-         * @param {Array<{dimension: string, granularity: string}>} timeDimensions
-         * @returns {Array<Array<string>>}
          */
         const sortTimeDimensions = (timeDimensions) => (timeDimensions &&
             ramda_1.default.sortBy(d => d.join('.'), timeDimensions.map(d => [
                 d.dimension,
                 d.granularity || 'day', // TODO granularity shouldn't be null?
             ])) || []);
-        /**
-         * @type {Set<string>}
-         */
         const filterDimensionsSingleValueEqual = transformedQuery.filterDimensionsSingleValueEqual && (transformedQuery.filterDimensionsSingleValueEqual instanceof Set
             ? transformedQuery.filterDimensionsSingleValueEqual
             : new Set(Object.keys(transformedQuery.filterDimensionsSingleValueEqual || {})));
@@ -442,8 +433,6 @@ class PreAggregations {
             transformedQuery.allBackAliasMembers[r] || r));
         /**
          * Determine whether pre-aggregation can be used or not.
-         * @param {PreAggregationReferences} references
-         * @returns {boolean}
          */
         const canUsePreAggregationNotAdditive = (references) => {
             // TODO remove this in favor of matching with join path
@@ -499,12 +488,6 @@ class PreAggregations {
             return expandGranularity(dimension, resolvedGranularity)
                 .map((newGranularity) => [dimension, newGranularity]);
         };
-        /**
-         * Determine whether pre-aggregation can be used or not.
-         * TODO: revisit cumulative leaf measure matches.
-         * @param {PreAggregationReferences} references
-         * @returns {boolean}
-         */
         const canUsePreAggregationLeafMeasureAdditive = (references) => {
             /**
              * Array of 2-element arrays with dimension and granularity.
@@ -518,12 +501,22 @@ class PreAggregations {
                 : transformedQuery.ownedTimeDimensionsWithRollupGranularity.map(expandTimeDimension);
             // TODO remove this in favor of matching with join path
             const referencesTrimmed = trimmedReferences(references);
+            // Even if there are no multiplied measures in the query (because no multiplier dimensions are requested)
+            // but the same measures are multiplied in the pre-aggregation, we can't use pre-aggregation
+            // for such queries.
+            if (referencesTrimmed.multipliedMeasures) {
+                const backAliasMultipliedMeasures = backAlias(referencesTrimmed.multipliedMeasures);
+                if (transformedQuery.leafMeasures.some(m => referencesTrimmed.multipliedMeasures?.includes(m)) ||
+                    transformedQuery.measures.some(m => backAliasMultipliedMeasures.includes(m))) {
+                    return false;
+                }
+            }
             const dimensionsMatch = (dimensions, doBackAlias) => ramda_1.default.all(d => (doBackAlias ?
                 backAlias(referencesTrimmed.dimensions) :
                 (referencesTrimmed.dimensions)).indexOf(d) !== -1, dimensions);
-            const timeDimensionsMatch = (timeDimensionsList, doBackAlias) => ramda_1.default.allPass(timeDimensionsList.map(tds => ramda_1.default.anyPass(tds.map(td => {
+            const timeDimensionsMatch = (timeDimensionsList, doBackAlias) => ramda_1.default.allPass(timeDimensionsList.map(tds => ramda_1.default.anyPass(tds.map((td) => {
                 if (td[1] === '*') {
-                    return ramda_1.default.any(tdtc => tdtc[0] === td[0]); // need to match the dimension at least
+                    return ramda_1.default.any((tdtc) => tdtc[0] === td[0]); // need to match the dimension at least
                 }
                 else {
                     return ramda_1.default.contains(td);
@@ -532,44 +525,47 @@ class PreAggregations {
                 backAlias(sortTimeDimensions(referencesTrimmed.timeDimensions)) :
                 (sortTimeDimensions(referencesTrimmed.timeDimensions)));
             if (transformedQuery.ungrouped) {
-                const allReferenceCubes = ramda_1.default.pipe(ramda_1.default.map(m => (m.dimension || m).split('.')[0]), ramda_1.default.uniq, ramda_1.default.sortBy(ramda_1.default.identity))(referencesTrimmed.measures.concat(referencesTrimmed.dimensions).concat(referencesTrimmed.timeDimensions));
+                const allReferenceCubes = ramda_1.default.pipe(ramda_1.default.map((name) => name?.split('.')[0]), ramda_1.default.uniq, ramda_1.default.sortBy(ramda_1.default.identity))([
+                    ...referencesTrimmed.measures,
+                    ...referencesTrimmed.dimensions,
+                    ...referencesTrimmed.timeDimensions.map(td => td.dimension),
+                ]);
                 if (!ramda_1.default.equals(transformedQuery.sortedAllCubeNames, allReferenceCubes) ||
                     !(dimensionsMatch(transformedQuery.sortedUsedCubePrimaryKeys, true) || dimensionsMatch(transformedQuery.sortedUsedCubePrimaryKeys, false))) {
                     return false;
                 }
             }
             const backAliasMeasures = backAlias(referencesTrimmed.measures);
-            return ((windowGranularityMatches(references)) && (ramda_1.default.all(m => referencesTrimmed.measures.indexOf(m) !== -1, transformedQuery.leafMeasures) || ramda_1.default.all(m => backAliasMeasures.indexOf(m) !== -1, transformedQuery.measures)) && (dimensionsMatch(transformedQuery.sortedDimensions, true) && timeDimensionsMatch(queryTimeDimensionsList, true) ||
+            return ((windowGranularityMatches(references)) && (ramda_1.default.all((m) => referencesTrimmed.measures.indexOf(m) !== -1, transformedQuery.leafMeasures) || ramda_1.default.all(m => backAliasMeasures.indexOf(m) !== -1, transformedQuery.measures)) && (dimensionsMatch(transformedQuery.sortedDimensions, true) && timeDimensionsMatch(queryTimeDimensionsList, true) ||
                 dimensionsMatch(transformedQuery.ownedDimensions, false) && timeDimensionsMatch(ownedQueryTimeDimensionsList, false)));
         };
-        /**
-         * Determine whether pre-aggregation can be used or not.
-         * @returns {boolean}
-         */
-        const canUseFn = (transformedQuery.leafMeasureAdditive && !transformedQuery.hasMultipliedMeasures && !transformedQuery.hasMultiStage || transformedQuery.ungrouped) ? (r) => canUsePreAggregationLeafMeasureAdditive(r) ||
-            canUsePreAggregationNotAdditive(r)
+        const canUseFn = (transformedQuery.leafMeasureAdditive && !transformedQuery.hasMultipliedMeasures && !transformedQuery.hasMultiStage || transformedQuery.ungrouped) ? ((r) => canUsePreAggregationLeafMeasureAdditive(r) ||
+            canUsePreAggregationNotAdditive(r))
             : canUsePreAggregationNotAdditive;
         if (refs) {
+            // @ts-ignore TS think it is boolean here
             return canUseFn(refs);
         }
         else {
             return canUseFn;
         }
     }
-    static squashDimensions(query, flattenDimensionMembers) {
-        return ramda_1.default.pipe(ramda_1.default.uniq, ramda_1.default.sortBy(ramda_1.default.identity))(flattenDimensionMembers.map(d => d.expressionPath()));
+    static squashDimensions(flattenDimensionMembers) {
+        return ramda_1.default.pipe(ramda_1.default.uniq, ramda_1.default.sortBy(ramda_1.default.identity))(flattenDimensionMembers
+            .filter((member) => typeof member.expressionPath === 'function')
+            .map(d => d.expressionPath()));
     }
     static flattenMembers(members) {
         return ramda_1.default.flatten(members.map(m => m.getMembers()));
     }
     static flattenDimensionMembers(query) {
-        return this.flattenMembers(query.dimensions
-            .concat(query.filters)
-            .concat(query.segments));
+        return this.flattenMembers([
+            ...query.dimensions,
+            ...query.filters,
+            ...query.segments,
+        ]);
     }
-    // eslint-disable-next-line no-unused-vars
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    getCubeLattice(cube, preAggregationName, preAggregation) {
+    getCubeLattice(_cube, _preAggregationName, _preAggregation) {
         throw new UserError_1.UserError('Auto rollups supported only in Enterprise version');
     }
     /**
@@ -577,22 +573,32 @@ class PreAggregations {
      * from the list of potentially applicable pre-aggs). The order of the
      * potentially applicable pre-aggs is the same as the order in which these
      * pre-aggs appear in the schema file.
-     * @returns {Object}
      */
     findPreAggregationForQuery() {
         if (!this.preAggregationForQuery) {
-            this.preAggregationForQuery =
-                this
-                    .rollupMatchResults()
-                    // Refresh worker can access specific pre-aggregations even in case those hidden by others
-                    .find(p => p.canUsePreAggregation && (!this.query.options.preAggregationId || p.preAggregationId === this.query.options.preAggregationId));
+            if (this.query.useNativeSqlPlanner && this.query.canUseNativeSqlPlannerPreAggregation) {
+                this.preAggregationForQuery = this.query.findPreAggregationForQueryRust();
+            }
+            else {
+                this.preAggregationForQuery =
+                    this
+                        .rollupMatchResults()
+                        // Refresh worker can access specific pre-aggregations even in case those hidden by others
+                        .find(p => p.canUsePreAggregation && (!this.query.options.preAggregationId || p.preAggregationId === this.query.options.preAggregationId));
+            }
         }
         return this.preAggregationForQuery;
     }
     findAutoRollupPreAggregationsForCube(cube, preAggregations) {
-        if (ramda_1.default.any(m => m.path() && m.path()[0] === cube, this.query.measures) ||
+        if (this.query.measures.some((m) => {
+            const path = m.path();
+            return path !== null && path[0] === cube;
+        }) ||
             !this.query.measures.length && !this.query.timeDimensions.length &&
-                ramda_1.default.all(d => d.path() && d.path()[0] === cube, this.query.dimensions)) {
+                this.query.dimensions.every((d) => {
+                    const path = d.path();
+                    return path !== null && path[0] === cube;
+                })) {
             return ramda_1.default.pipe(ramda_1.default.toPairs, 
             // eslint-disable-next-line no-unused-vars
             // eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -600,7 +606,7 @@ class PreAggregations {
                 const cubeLattice = this.getCubeLattice(cube, preAggregationName, preAggregation);
                 const optimalPreAggregation = cubeLattice.findOptimalPreAggregationFromLattice(this.query);
                 return optimalPreAggregation && {
-                    preAggregationName: preAggregationName + this.autoRollupNameSuffix(cube, optimalPreAggregation),
+                    preAggregationName: preAggregationName + this.autoRollupNameSuffix(optimalPreAggregation),
                     preAggregation: Object.assign(optimalPreAggregation, preAggregation),
                     cube,
                     canUsePreAggregation: true,
@@ -611,14 +617,13 @@ class PreAggregations {
         return [];
     }
     /**
-     * Returns an array of potentially applicable for the query preaggs in the
+     * Returns an array of potentially applicable for the query pre-aggs in the
      * same order they appear in the schema file.
-     * @returns {Array<Object>}
      */
     rollupMatchResults() {
         const { query } = this;
         const canUsePreAggregation = this.canUsePreAggregationFn(query);
-        return ramda_1.default.pipe(ramda_1.default.map(cube => {
+        return ramda_1.default.pipe(ramda_1.default.map((cube) => {
             const preAggregations = this.query.cubeEvaluator.preAggregationsForCube(cube);
             let rollupPreAggregations = this.findRollupPreAggregationsForCube(cube, canUsePreAggregation, preAggregations);
             rollupPreAggregations = rollupPreAggregations.concat(this.findAutoRollupPreAggregationsForCube(cube, preAggregations));
@@ -631,6 +636,21 @@ class PreAggregations {
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
         ramda_1.default.filter(([k, a]) => a.type === 'rollup' || a.type === 'rollupJoin' || a.type === 'rollupLambda'), ramda_1.default.map(([preAggregationName, preAggregation]) => this.evaluatedPreAggregationObj(cube, preAggregationName, preAggregation, canUsePreAggregation)))(preAggregations);
     }
+    getRollupPreAggregationByName(cube, preAggregationName) {
+        const canUsePreAggregation = () => true;
+        const preAggregation = ramda_1.default.pipe(ramda_1.default.toPairs, ramda_1.default.filter(([_, a]) => a.type === 'rollup' || a.type === 'rollupJoin' || a.type === 'rollupLambda'), ramda_1.default.find(([k, _]) => k === preAggregationName))(this.query.cubeEvaluator.preAggregationsForCube(cube));
+        if (preAggregation) {
+            const tableName = this.preAggregationTableName(cube, preAggregation[0], preAggregation[1]);
+            const preAggObj = preAggregation ? this.evaluatedPreAggregationObj(cube, preAggregation[0], preAggregation[1], canUsePreAggregation) : {};
+            return {
+                tableName,
+                ...preAggObj
+            };
+        }
+        else {
+            return {};
+        }
+    }
     // TODO check multiplication factor didn't change
     buildRollupJoin(preAggObj, preAggObjsToJoin) {
         return this.query.cacheValue(['buildRollupJoin', JSON.stringify(preAggObj), JSON.stringify(preAggObjsToJoin)], () => {
@@ -768,14 +788,21 @@ class PreAggregations {
         return preAggregation.preAggregation.partitionGranularity;
     }
     static memberNameMismatchValidation(preAggA, preAggB, memberType) {
-        const preAggAMemberNames = PreAggregations.memberShortNames(preAggA.references[memberType], memberType === 'timeDimensions');
-        const preAggBMemberNames = PreAggregations.memberShortNames(preAggB.references[memberType], memberType === 'timeDimensions');
+        const preAggAMemberNames = PreAggregations.memberShortNames(preAggA.references[memberType]);
+        const preAggBMemberNames = PreAggregations.memberShortNames(preAggB.references[memberType]);
         if (!ramda_1.default.equals(preAggAMemberNames, preAggBMemberNames)) {
             throw new UserError_1.UserError(`Names for ${memberType} doesn't match between '${preAggA.cube}.${preAggA.preAggregationName}' and '${preAggB.cube}.${preAggB.preAggregationName}': ${JSON.stringify(preAggAMemberNames)} does not equal to ${JSON.stringify(preAggBMemberNames)}`);
         }
     }
-    static memberShortNames(memberArray, isTimeDimension) {
-        return memberArray.map(member => (isTimeDimension ? `${member.dimension.split('.')[1]}.${member.granularity}` : member.split('.')[1]));
+    static memberShortNames(memberArray) {
+        return memberArray.map(member => {
+            if (typeof member !== 'string') {
+                return `${member.dimension.split('.')[1]}.${member.granularity}`;
+            }
+            else {
+                return member.split('.')[1];
+            }
+        });
     }
     rollupMatchResultDescriptions() {
         return this.rollupMatchResults().map(p => ({
@@ -789,7 +816,7 @@ class PreAggregations {
         return PreAggregations.transformQueryToCanUseForm(this.query);
     }
     static hasCumulativeMeasures(query) {
-        const measures = (query.measures.concat(query.measureFilters));
+        const measures = [...query.measures, ...query.measureFilters];
         const collectLeafMeasures = query.collectLeafMeasures.bind(query);
         return ramda_1.default.pipe(ramda_1.default.map(m => query.collectFrom([m], collectLeafMeasures, 'collectLeafMeasures')), ramda_1.default.unnest, ramda_1.default.uniq, ramda_1.default.map(p => query.newMeasure(p)), ramda_1.default.any(m => m.isCumulative()))(measures);
     }
@@ -816,11 +843,11 @@ class PreAggregations {
             preAggregationQuery: true,
         });
     }
-    rollupPreAggregationQuery(cube, aggregation) {
+    rollupPreAggregationQuery(cube, aggregation, context = {}) {
         // `this.evaluateAllReferences` will retain not only members, but their join path as well, and pass join hints
         // to subquery. Otherwise, members in subquery would regenerate new join tree from clean state,
         // and it can be different from expected by join path in pre-aggregation declaration
-        const references = this.evaluateAllReferences(cube, aggregation);
+        const references = this.evaluateAllReferences(cube, aggregation, null, context);
         const cubeQuery = this.query.newSubQueryForCube(cube, {});
         return this.query.newSubQueryForCube(cube, {
             rowLimit: null,
@@ -861,7 +888,7 @@ class PreAggregations {
             return toMerge ? { ...d, dateRange: toMerge.dateRange, boundaryDateRange: toMerge.boundaryDateRange } : d;
         });
     }
-    autoRollupNameSuffix(cube, aggregation) {
+    autoRollupNameSuffix(aggregation) {
         // eslint-disable-next-line prefer-template
         return '_' + aggregation.dimensions.concat(aggregation.timeDimensions.map(d => `${d.dimension}${d.granularity.substring(0, 1)}`)).map(s => {
             const path = s.split('.');
@@ -870,19 +897,17 @@ class PreAggregations {
             .replace(/[.]/g, '')
             .toLowerCase();
     }
-    /**
-     *
-     * @param {string} cube
-     * @param aggregation
-     * @param {string} [preAggregationName]
-     * @returns {PreAggregationReferences}
-     */
-    evaluateAllReferences(cube, aggregation, preAggregationName) {
+    evaluateAllReferences(cube, aggregation, preAggregationName = null, context = {}) {
         // 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 (!context.inPreAggEvaluation) {
+                const preAggQuery = this.query.preAggregationQueryForSqlEvaluation(cube, aggregation, { inPreAggEvaluation: true });
+                const aggregateMeasures = preAggQuery?.fullKeyQueryAggregateMeasures({ hasMultipliedForPreAggregation: true });
+                references.multipliedMeasures = aggregateMeasures?.multipliedMeasures?.map(m => m.measure);
+            }
             if (aggregation.type === 'rollupLambda') {
                 if (references.rollups.length > 0) {
                     const [firstLambdaCube] = this.query.cubeEvaluator.parsePath('preAggregations', references.rollups[0]);
@@ -909,7 +934,7 @@ class PreAggregations {
         // eslint-disable-next-line prefer-const
         let { preAggregationName, preAggregation } = preAggregationDescription;
         // @todo Dont use sqlAlias directly, we needed to move it in preAggregationTableName
-        if (preAggregation && preAggregation.sqlAlias) {
+        if (preAggregation?.sqlAlias) {
             preAggregationName = preAggregation.sqlAlias;
         }
         return this.query.preAggregationTableName(preAggregationDescription.cube, preAggregationName);
@@ -984,10 +1009,9 @@ class PreAggregations {
             toJoin = [sqlAndAlias(preAggregationForQuery)];
         }
         const from = this.query.joinSql(toJoin);
-        const replacedFilters = filters || this.query.segments
-            .concat(this.query.filters).concat(this.query.timeDimensions.map(dimension => dimension.dateRange && ({
-            filterToWhere: () => this.query.timeRangeFilter(this.query.dimensionSql(dimension), dimension.localDateTimeFromParam(), dimension.localDateTimeToParam()),
-        }))).filter(f => !!f);
+        const replacedFilters = filters || [...this.query.segments, ...this.query.filters, ...(this.query.timeDimensions.map(dimension => dimension.dateRange && ({
+                filterToWhere: () => this.query.timeRangeFilter(this.query.dimensionSql(dimension), dimension.localDateTimeFromParam(), dimension.localDateTimeToParam()),
+            })))].filter(f => !!f);
         const renderedReference = {
             ...(this.measuresRenderedReference(preAggregationForQuery)),
             ...(this.dimensionsRenderedReference(preAggregationForQuery)),
@@ -1007,43 +1031,76 @@ class PreAggregations {
         });
     }
     measuresRenderedReference(preAggregationForQuery) {
-        return ramda_1.default.pipe(ramda_1.default.map(path => {
+        const measures = this.rollupMeasures(preAggregationForQuery);
+        return Object.fromEntries(measures
+            .flatMap(path => {
             const measure = this.query.newMeasure(path);
+            const measurePath = measure.path();
+            const column = this.query.ungrouped ? measure.aliasName() : (this.query.aggregateOnGroupedColumn(measure.measureDefinition(), measure.aliasName(), !this.query.safeEvaluateSymbolContext().overTimeSeriesAggregate, path) || `sum(${measure.aliasName()})`);
+            if (measurePath === null) {
+                return [[path, column]];
+            }
+            const memberPath = this.query.cubeEvaluator.pathFromArray(measurePath);
+            // Return both full join path and measure path
             return [
-                path,
-                this.query.ungrouped ? measure.aliasName() : (this.query.aggregateOnGroupedColumn(measure.measureDefinition(), measure.aliasName(), !this.query.safeEvaluateSymbolContext().overTimeSeriesAggregate, path) || `sum(${measure.aliasName()})`),
+                [path, column],
+                [memberPath, column],
             ];
-        }), ramda_1.default.fromPairs)(this.rollupMeasures(preAggregationForQuery));
+        }));
     }
     measureAliasesRenderedReference(preAggregationForQuery) {
-        return ramda_1.default.pipe(ramda_1.default.map(path => {
+        const measures = this.rollupMeasures(preAggregationForQuery);
+        return Object.fromEntries(measures
+            .flatMap(path => {
             const measure = this.query.newMeasure(path);
+            const measurePath = measure.path();
+            const alias = measure.aliasName();
+            if (measurePath === null) {
+                return [[path, alias]];
+            }
+            const memberPath = this.query.cubeEvaluator.pathFromArray(measurePath);
+            // Return both full join path and measure path
             return [
-                path,
-                measure.aliasName(),
+                [path, alias],
+                [memberPath, alias],
             ];
-        }), ramda_1.default.fromPairs)(this.rollupMeasures(preAggregationForQuery));
+        }));
     }
     dimensionsRenderedReference(preAggregationForQuery) {
-        return ramda_1.default.pipe(ramda_1.default.map(path => {
+        const dimensions = this.rollupDimensions(preAggregationForQuery);
+        return Object.fromEntries(dimensions
+            .flatMap(path => {
             const dimension = this.query.newDimension(path);
+            const dimensionPath = dimension.path();
+            const column = this.query.escapeColumnName(dimension.unescapedAliasName());
+            if (dimensionPath === null) {
+                return [[path, column]];
+            }
+            const memberPath = this.query.cubeEvaluator.pathFromArray(dimensionPath);
+            // Return both full join path and dimension path
             return [
-                path,
-                this.query.escapeColumnName(dimension.unescapedAliasName()),
+                [path, column],
+                [memberPath, column],
             ];
-        }), ramda_1.default.fromPairs)(this.rollupDimensions(preAggregationForQuery));
+        }));
     }
     timeDimensionsRenderedReference(rollupGranularity, preAggregationForQuery) {
-        return ramda_1.default.pipe(ramda_1.default.map((td) => {
+        const timeDimensions = this.rollupTimeDimensions(preAggregationForQuery);
+        return Object.fromEntries(timeDimensions
+            .flatMap(td => {
             const timeDimension = this.query.newTimeDimension(td);
+            const column = this.query.escapeColumnName(timeDimension.unescapedAliasName(rollupGranularity));
+            const memberPath = this.query.cubeEvaluator.pathFromArray(timeDimension.path());
+            // Return both full join path and dimension path
             return [
-                td.dimension,
-                this.query.escapeColumnName(timeDimension.unescapedAliasName(rollupGranularity)),
+                [td.dimension, column],
+                [memberPath, column],
             ];
-        }), ramda_1.default.fromPairs)(this.rollupTimeDimensions(preAggregationForQuery));
+        }));
     }
     rollupMembers(preAggregationForQuery, type) {
         return preAggregationForQuery.preAggregation.type === 'autoRollup' ?
+            // TODO proper types
             preAggregationForQuery.preAggregation[type] :
             this.evaluateAllReferences(preAggregationForQuery.cube, preAggregationForQuery.preAggregation, preAggregationForQuery.preAggregationName)[type];
     }