@cubejs-backend/schema-compiler 1.3.11 → 1.3.12

package/dist/src/adapter/BaseQuery.js

@@ -85,6 +85,24 @@ const SecondsDurations = {
  * and {@code CompilerApi} configuration.
  */
 class BaseQuery {
+    /** @type {import('./PreAggregations').PreAggregations} */
+    preAggregations;
+    /** @type {import('./BaseMeasure').BaseMeasure[]} */
+    measures;
+    /** @type {import('./BaseDimension').BaseDimension[]} */
+    dimensions;
+    /** @type {import('./BaseDimension').BaseDimension[]} */
+    multiStageDimensions;
+    /** @type {import('./BaseTimeDimension').BaseTimeDimension[]} */
+    multiStageTimeDimensions;
+    /** @type {import('./BaseSegment').BaseSegment[]} */
+    segments;
+    /** @type {(BaseFilter|BaseGroupFilter)[]} */
+    filters;
+    /** @type {(BaseFilter|BaseGroupFilter)[]} */
+    measureFilters;
+    /** @type {import('./BaseTimeDimension').BaseTimeDimension[]} */
+    timeDimensions;
     /**
      * BaseQuery class constructor.
      * @param {Compilers|*} compilers
@@ -218,7 +236,7 @@ class BaseQuery {
             rowLimit: this.options.rowLimit,
             preAggregationsSchema: this.options.preAggregationsSchema,
             className: this.constructor.name,
-            externalClassName: this.options.externalQueryClass && this.options.externalQueryClass.name,
+            externalClassName: this.options.externalQueryClass?.name,
             preAggregationQuery: this.options.preAggregationQuery,
             disableExternalPreAggregations: this.options.disableExternalPreAggregations,
             useOriginalSqlPreAggregationsInPreAggregation: this.options.useOriginalSqlPreAggregationsInPreAggregation,
@@ -239,18 +257,26 @@ class BaseQuery {
         this.timezone = this.options.timezone;
         this.rowLimit = this.options.rowLimit;
         this.offset = this.options.offset;
+        /** @type {import('./PreAggregations').PreAggregations} */
         this.preAggregations = this.newPreAggregations();
+        /** @type {import('./BaseMeasure').BaseMeasure[]} */
         this.measures = (this.options.measures || []).map(this.newMeasure.bind(this));
+        /** @type {import('./BaseDimension').BaseDimension[]} */
         this.dimensions = (this.options.dimensions || []).map(this.newDimension.bind(this));
+        /** @type {import('./BaseDimension').BaseDimension[]} */
         this.multiStageDimensions = (this.options.multiStageDimensions || []).map(this.newDimension.bind(this));
+        /** @type {import('./BaseTimeDimension').BaseTimeDimension[]} */
         this.multiStageTimeDimensions = (this.options.multiStageTimeDimensions || []).map(this.newTimeDimension.bind(this));
+        /** @type {import('./BaseSegment').BaseSegment[]} */
         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
-        // used in drill downs) should go to WHERE instead of HAVING
+        // used in drill-downs) should go to WHERE instead of HAVING
         /** @type {(BaseFilter|BaseGroupFilter)[]} */
         this.filters = filters.filter(f => f.dimensionGroup || f.dimension || f.operator === 'measure_filter' || f.operator === 'measureFilter').map(this.initFilter.bind(this));
+        /** @type {(BaseFilter|BaseGroupFilter)[]} */
         this.measureFilters = filters.filter(f => (f.measureGroup || f.measure) && f.operator !== 'measure_filter' && f.operator !== 'measureFilter').map(this.initFilter.bind(this));
+        /** @type {import('./BaseTimeDimension').BaseTimeDimension[]} */
         this.timeDimensions = (this.options.timeDimensions || []).map(dimension => {
             if (!dimension.dimension) {
                 const join = this.joinGraph.buildJoin(this.collectJoinHints(true));
@@ -267,6 +293,11 @@ class BaseQuery {
         }).filter(ramda_1.default.identity).map(this.newTimeDimension.bind(this));
         this.allFilters = this.timeDimensions.concat(this.segments).concat(this.filters);
         this.useNativeSqlPlanner = this.options.useNativeSqlPlanner ?? (0, shared_1.getEnv)('nativeSqlPlanner');
+        this.canUseNativeSqlPlannerPreAggregation = false;
+        if (this.useNativeSqlPlanner) {
+            const hasMultiStageMeasures = this.fullKeyQueryAggregateMeasures({ hasMultipliedForPreAggregation: true }).multiStageMembers.length > 0;
+            this.canUseNativeSqlPlannerPreAggregation = hasMultiStageMeasures;
+        }
         this.prebuildJoin();
         this.cubeAliasPrefix = this.options.cubeAliasPrefix;
         this.preAggregationsSchemaOption = this.options.preAggregationsSchema ?? DEFAULT_PREAGGREGATIONS_SCHEMA;
@@ -414,12 +445,38 @@ class BaseQuery {
         }
         return res;
     }
+    /**
+     *
+     * @param measurePath
+     * @returns {BaseMeasure}
+     */
     newMeasure(measurePath) {
         return new BaseMeasure_1.BaseMeasure(this, measurePath);
     }
+    /**
+     *
+     * @param dimensionPath
+     * @returns {BaseDimension}
+     */
     newDimension(dimensionPath) {
+        if (typeof dimensionPath === 'string') {
+            const memberArr = dimensionPath.split('.');
+            if (memberArr.length > 3 &&
+                memberArr[memberArr.length - 2] === 'granularities' &&
+                this.cubeEvaluator.isDimension(memberArr.slice(0, -2))) {
+                return this.newTimeDimension({
+                    dimension: this.cubeEvaluator.pathFromArray(memberArr.slice(0, -2)),
+                    granularity: memberArr[memberArr.length - 1]
+                });
+            }
+        }
         return new BaseDimension_1.BaseDimension(this, dimensionPath);
     }
+    /**
+     *
+     * @param segmentPath
+     * @returns {BaseSegment}
+     */
     newSegment(segmentPath) {
         return new BaseSegment_1.BaseSegment(this, segmentPath);
     }
@@ -439,6 +496,11 @@ class BaseQuery {
     newFilter(filter) {
         return new BaseFilter_1.BaseFilter(this, filter);
     }
+    /**
+     *
+     * @param filter
+     * @returns {BaseGroupFilter}
+     */
     newGroupFilter(filter) {
         return new BaseGroupFilter_1.BaseGroupFilter(filter);
     }
@@ -449,9 +511,18 @@ class BaseQuery {
     newTimeDimension(timeDimension) {
         return new BaseTimeDimension_1.BaseTimeDimension(this, timeDimension);
     }
+    /**
+     *
+     * @param expressionParams
+     * @returns {ParamAllocator}
+     */
     newParamAllocator(expressionParams) {
         return new ParamAllocator_1.ParamAllocator(expressionParams);
     }
+    /**
+     *
+     * @returns {PreAggregations}
+     */
     newPreAggregations() {
         return new PreAggregations_1.PreAggregations(this, this.options.historyQueries || [], this.options.cubeLatticeCache);
     }
@@ -477,7 +548,7 @@ class BaseQuery {
         if (!this.options.preAggregationQuery) {
             preAggForQuery =
                 this.preAggregations.findPreAggregationForQuery();
-            if (this.options.disableExternalPreAggregations && preAggForQuery && preAggForQuery.preAggregation.external) {
+            if (this.options.disableExternalPreAggregations && preAggForQuery?.preAggregation.external) {
                 preAggForQuery = undefined;
             }
         }
@@ -536,35 +607,35 @@ class BaseQuery {
      * @returns {[string, Array<unknown>]}
      */
     buildSqlAndParams(exportAnnotatedSql) {
-        if (!this.options.preAggregationQuery && !this.options.disableExternalPreAggregations && this.externalQueryClass) {
-            if (this.externalPreAggregationQuery()) { // TODO performance
-                return this.externalQuery().buildSqlAndParams(exportAnnotatedSql);
-            }
-        }
         if (this.useNativeSqlPlanner) {
             let isRelatedToPreAggregation = false;
-            if (this.options.preAggregationQuery) {
-                isRelatedToPreAggregation = true;
-            }
-            else if (!this.options.disableExternalPreAggregations && this.externalQueryClass) {
-                if (this.externalPreAggregationQuery()) {
+            if (!this.canUseNativeSqlPlannerPreAggregation) {
+                if (this.options.preAggregationQuery) {
                     isRelatedToPreAggregation = true;
                 }
-            }
-            else {
-                let preAggForQuery = this.preAggregations.findPreAggregationForQuery();
-                if (this.options.disableExternalPreAggregations && preAggForQuery && preAggForQuery.preAggregation.external) {
-                    preAggForQuery = undefined;
-                }
-                if (preAggForQuery) {
+                else if (!this.options.disableExternalPreAggregations && this.externalQueryClass && this.externalPreAggregationQuery()) {
                     isRelatedToPreAggregation = true;
                 }
-            }
-            if (isRelatedToPreAggregation) {
-                return this.newQueryWithoutNative().buildSqlAndParams(exportAnnotatedSql);
+                else {
+                    let preAggForQuery = this.preAggregations.findPreAggregationForQuery();
+                    if (this.options.disableExternalPreAggregations && preAggForQuery && preAggForQuery.preAggregation.external) {
+                        preAggForQuery = undefined;
+                    }
+                    if (preAggForQuery) {
+                        isRelatedToPreAggregation = true;
+                    }
+                }
+                if (isRelatedToPreAggregation) {
+                    return this.newQueryWithoutNative().buildSqlAndParams(exportAnnotatedSql);
+                }
             }
             return this.buildSqlAndParamsRust(exportAnnotatedSql);
         }
+        if (!this.options.preAggregationQuery && !this.options.disableExternalPreAggregations && this.externalQueryClass) {
+            if (this.externalPreAggregationQuery()) { // TODO performance
+                return this.externalQuery().buildSqlAndParams(exportAnnotatedSql);
+            }
+        }
         return this.compilers.compiler.withQuery(this, () => this.cacheValue(['buildSqlAndParams', exportAnnotatedSql], () => this.paramAllocator.buildSqlAndParams(this.buildParamAnnotatedSql(), exportAnnotatedSql, this.shouldReuseParams), { cache: this.queryCache }));
     }
     buildSqlAndParamsRust(exportAnnotatedSql) {
@@ -584,7 +655,8 @@ class BaseQuery {
             offset: this.options.offset ? this.options.offset.toString() : null,
             baseTools: this,
             ungrouped: this.options.ungrouped,
-            exportAnnotatedSql: exportAnnotatedSql === true
+            exportAnnotatedSql: exportAnnotatedSql === true,
+            preAggregationQuery: this.options.preAggregationQuery
         };
         const buildResult = (0, native_1.buildSqlAndParams)(queryParams);
         if (buildResult.error) {
@@ -596,9 +668,50 @@ class BaseQuery {
             }
         }
         const res = buildResult.result;
+        const [query, params, preAggregation] = res;
         // FIXME
-        res[1] = [...res[1]];
-        return res;
+        const paramsArray = [...params];
+        if (preAggregation) {
+            this.preAggregations.preAggregationForQuery = preAggregation;
+        }
+        return [query, paramsArray];
+    }
+    // FIXME Temporary solution
+    findPreAggregationForQueryRust() {
+        let optionsOrder = this.options.order;
+        if (optionsOrder && !Array.isArray(optionsOrder)) {
+            optionsOrder = [optionsOrder];
+        }
+        const order = optionsOrder ? ramda_1.default.pipe(ramda_1.default.map((hash) => ((!hash || !hash.id) ? null : hash)), ramda_1.default.reject(ramda_1.default.isNil))(optionsOrder) : undefined;
+        const queryParams = {
+            measures: this.options.measures,
+            dimensions: this.options.dimensions,
+            segments: this.options.segments,
+            timeDimensions: this.options.timeDimensions,
+            timezone: this.options.timezone,
+            joinGraph: this.joinGraph,
+            cubeEvaluator: this.cubeEvaluator,
+            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,
+            ungrouped: this.options.ungrouped,
+            exportAnnotatedSql: false,
+            preAggregationQuery: this.options.preAggregationQuery
+        };
+        const buildResult = (0, native_1.buildSqlAndParams)(queryParams);
+        if (buildResult.error) {
+            if (buildResult.error.cause === 'User') {
+                throw new UserError_1.UserError(buildResult.error.message);
+            }
+            else {
+                throw new Error(buildResult.error.message);
+            }
+        }
+        const [, , preAggregation] = buildResult.result;
+        return preAggregation;
     }
     allCubeMembers(path) {
         const fromPath = this.cubeEvaluator.cubeFromPath(path);
@@ -615,6 +728,9 @@ class BaseQuery {
     generateCustomTimeSeries(granularityInterval, dateRange, origin) {
         return (0, shared_1.timeSeriesFromCustomInterval)(granularityInterval, dateRange, (0, moment_timezone_1.default)(origin), { timestampPrecision: 3 });
     }
+    getPreAggregationByName(cube, preAggregationName) {
+        return this.preAggregations.getRollupPreAggregationByName(cube, preAggregationName);
+    }
     get shouldReuseParams() {
         return false;
     }
@@ -860,7 +976,7 @@ class BaseQuery {
         return `WITH\n${withQueries.map(q => `${q.alias} AS (${q.query})`).join(',\n')}\n${select}`;
     }
     fullKeyQueryAggregateMeasures(context) {
-        const measureToHierarchy = this.collectRootMeasureToHieararchy(context);
+        const measureToHierarchy = this.collectRootMeasureToHierarchy(context);
         const allMemberChildren = this.collectAllMemberChildren(context);
         const memberToIsMultiStage = this.collectAllMultiStageMembers(allMemberChildren);
         const hasMultiStageMembers = (m) => {
@@ -936,12 +1052,12 @@ class BaseQuery {
         // TODO calculate based on remove_filter in future
         const wouldNodeApplyFilters = !memberChildren[member];
         let memberFrom = memberChildren[member]
-            ?.map(child => this.multiStageWithQueries(child, this.childrenMultiStageContext(member, queryContext, wouldNodeApplyFilters), memberChildren, withQueries));
+            ?.map(child => this.multiStageWithQueries(child, this.childrenMultiStageContext(member, queryContext), memberChildren, withQueries));
         const unionFromDimensions = memberFrom ? ramda_1.default.uniq(ramda_1.default.flatten(memberFrom.map(f => f.dimensions))) : queryContext.dimensions;
         const unionDimensionsContext = { ...queryContext, dimensions: unionFromDimensions.filter(d => !this.newDimension(d).isMultiStage()) };
         // TODO is calling multiStageWithQueries twice optimal?
         memberFrom = memberChildren[member] &&
-            ramda_1.default.uniqBy(f => f.alias, memberChildren[member].map(child => this.multiStageWithQueries(child, this.childrenMultiStageContext(member, unionDimensionsContext, wouldNodeApplyFilters), memberChildren, withQueries)));
+            ramda_1.default.uniqBy(f => f.alias, memberChildren[member].map(child => this.multiStageWithQueries(child, this.childrenMultiStageContext(member, unionDimensionsContext), memberChildren, withQueries)));
         const selfContext = this.selfMultiStageContext(member, queryContext, wouldNodeApplyFilters);
         const subQuery = {
             ...selfContext,
@@ -960,7 +1076,7 @@ class BaseQuery {
         usedQueries[member.alias] = true;
         member.memberFrom?.forEach(m => this.collectUsedWithQueries(usedQueries, m));
     }
-    childrenMultiStageContext(memberPath, queryContext, wouldNodeApplyFilters) {
+    childrenMultiStageContext(memberPath, queryContext) {
         let member;
         if (this.cubeEvaluator.isMeasure(memberPath)) {
             member = this.newMeasure(memberPath);
@@ -973,13 +1089,29 @@ class BaseQuery {
         if (memberDef.addGroupByReferences) {
             queryContext = { ...queryContext, dimensions: ramda_1.default.uniq(queryContext.dimensions.concat(memberDef.addGroupByReferences)) };
         }
-        if (memberDef.timeShiftReferences) {
-            queryContext = {
-                ...queryContext,
-                timeDimensions: queryContext.timeDimensions.map(td => {
-                    const timeShift = memberDef.timeShiftReferences.find(r => r.timeDimension === td.dimension);
+        if (memberDef.timeShiftReferences?.length) {
+            let mapFn;
+            if (memberDef.timeShiftReferences.length === 1 && !memberDef.timeShiftReferences[0].timeDimension) {
+                const timeShift = memberDef.timeShiftReferences[0];
+                mapFn = (td) => {
+                    if (td.shiftInterval) {
+                        throw new UserError_1.UserError(`Hierarchical time shift is not supported but was provided for '${td.dimension}'. Parent time shift is '${td.shiftInterval}' and current is '${timeShift.interval}'`);
+                    }
+                    return {
+                        ...td,
+                        shiftInterval: timeShift.type === 'next' ? this.negateInterval(timeShift.interval) : timeShift.interval
+                    };
+                };
+            }
+            else {
+                const allBackAliasMembers = this.allBackAliasTimeDimensions();
+                mapFn = (td) => {
+                    const timeShift = memberDef.timeShiftReferences.find(r => r.timeDimension === td.dimension || td.dimension === allBackAliasMembers[r.timeDimension]);
                     if (timeShift) {
-                        if (td.shiftInterval) {
+                        // We need to ignore aliased td, because it will match and insert shiftInterval on first
+                        // occurrence, but later during recursion it will hit the original td but shiftInterval will be
+                        // present and simple check for td.shiftInterval will always result in error.
+                        if (td.shiftInterval && !td.dimension === allBackAliasMembers[timeShift.timeDimension]) {
                             throw new UserError_1.UserError(`Hierarchical time shift is not supported but was provided for '${td.dimension}'. Parent time shift is '${td.shiftInterval}' and current is '${timeShift.interval}'`);
                         }
                         return {
@@ -988,7 +1120,11 @@ class BaseQuery {
                         };
                     }
                     return td;
-                })
+                };
+            }
+            queryContext = {
+                ...queryContext,
+                timeDimensions: queryContext.timeDimensions.map(mapFn)
             };
         }
         queryContext = {
@@ -1340,7 +1476,7 @@ class BaseQuery {
                     measure: attachedMeasure,
                 }]];
     }
-    collectRootMeasureToHieararchy(context) {
+    collectRootMeasureToHierarchy(context) {
         const notAddedMeasureFilters = ramda_1.default.flatten(this.measureFilters.map(f => f.getMembers()))
             .filter(f => ramda_1.default.none(m => m.measure === f.measure, this.measures));
         return ramda_1.default.fromPairs(this.measures.concat(notAddedMeasureFilters).map(m => {
@@ -1659,8 +1795,12 @@ class BaseQuery {
             return this.evaluateSql(s.cube().name, s.definition().sql);
         }
     }
-    collectCubeNames(excludeTimeDimensions) {
-        return this.collectFromMembers(excludeTimeDimensions, this.collectCubeNamesFor.bind(this), 'collectCubeNamesFor');
+    /**
+     *
+     * @returns {Array<string>}
+     */
+    collectCubeNames() {
+        return this.collectFromMembers([], this.collectCubeNamesFor.bind(this), 'collectCubeNamesFor');
     }
     /**
      *
@@ -1744,6 +1884,11 @@ class BaseQuery {
         const dimensionNames = dimensionColumns.map((c, i) => `${i + 1}`);
         return this.rollupGroupByClause(dimensionNames);
     }
+    /**
+     * XXX: String as return value is added because of HiveQuery.getFieldIndex()
+     * @param id
+     * @returns {number|string|null}
+     */
     getFieldIndex(id) {
         const equalIgnoreCase = (a, b) => (typeof a === 'string' && typeof b === 'string' && a.toUpperCase() === b.toUpperCase());
         let index;
@@ -2131,6 +2276,11 @@ class BaseQuery {
             ? prefix + '__' + this.aliasName(cubeName)
             : cubeName}`));
     }
+    /**
+     *
+     * @param fn
+     * @returns {Array<string>}
+     */
     collectCubeNamesFor(fn) {
         const context = { cubeNames: [] };
         this.evaluateSymbolSqlWithContext(fn, context);
@@ -2141,6 +2291,11 @@ class BaseQuery {
         this.evaluateSymbolSqlWithContext(fn, context);
         return context.joinHints;
     }
+    /**
+     *
+     * @param fn
+     * @returns {Array<string>}
+     */
     collectMemberNamesFor(fn) {
         const context = { memberNames: [] };
         this.evaluateSymbolSqlWithContext(fn, context);
@@ -2367,6 +2522,10 @@ class BaseQuery {
         const primaryKeyDimension = this.cubeEvaluator.dimensionByPath([cubeName, primaryKeyName]);
         return this.evaluateSymbolSql(cubeName, primaryKeyName, primaryKeyDimension);
     }
+    /**
+     * @param cubeName
+     * @returns Boolean
+     */
     multipliedJoinRowResult(cubeName) {
         // this.join not initialized on collectCubeNamesForSql
         return this.join && this.join.multiplicationFactor[cubeName];
@@ -2490,12 +2649,17 @@ class BaseQuery {
         // use single underscore for pre-aggregations to avoid fail of pre-aggregation name replace
         return inflection_1.default.underscore(name).replace(/\./g, isPreAggregationName ? '_' : '__');
     }
+    /**
+     *
+     * @param options
+     * @returns {BaseQuery}
+     */
     newSubQuery(options) {
         const QueryClass = this.constructor;
         return new QueryClass(this.compilers, this.subQueryOptions(options));
     }
     newSubQueryForCube(cube, options) {
-        options = { ...options, useNativeSqlPlanner: false }; // We don't use tesseract for pre-aggregations generation yet
+        options = { ...options };
         if (this.options.queryFactory) {
             // When dealing with rollup joins, it's crucial to use the correct parameter allocator for the specific cube in use.
             // By default, we'll use BaseQuery, but it's important to note that different databases (Oracle, PostgreSQL, MySQL, Druid, etc.)
@@ -2903,13 +3067,19 @@ class BaseQuery {
             },
         };
     }
+    /**
+     *
+     * @param cube
+     * @param preAggregation
+     * @returns {BaseQuery}
+     */
     // eslint-disable-next-line consistent-return
-    preAggregationQueryForSqlEvaluation(cube, preAggregation) {
+    preAggregationQueryForSqlEvaluation(cube, preAggregation, context = {}) {
         if (preAggregation.type === 'autoRollup') {
             return this.preAggregations.autoRollupPreAggregationQuery(cube, preAggregation);
         }
         else if (preAggregation.type === 'rollup') {
-            return this.preAggregations.rollupPreAggregationQuery(cube, preAggregation);
+            return this.preAggregations.rollupPreAggregationQuery(cube, preAggregation, context);
         }
         else if (preAggregation.type === 'originalSql') {
             return this;
@@ -3395,9 +3565,22 @@ class BaseQuery {
             .concat(this.timeDimensions)
             .map(m => m.getMembers()));
     }
+    /**
+     * @returns {Record<string, string>}
+     */
+    allBackAliasTimeDimensions() {
+        const members = ramda_1.default.flatten(this.timeDimensions.map(m => m.getMembers()));
+        return this.backAliasMembers(members);
+    }
+    /**
+     * @returns {Record<string, string>}
+     */
     allBackAliasMembersExceptSegments() {
         return this.backAliasMembers(this.flattenAllMembers(true));
     }
+    /**
+     * @returns {Record<string, string>}
+     */
     allBackAliasMembers() {
         return this.backAliasMembers(this.flattenAllMembers());
     }