@cubejs-backend/schema-compiler 1.7.34 → 1.7.36

package/dist/src/adapter/BaseQuery.js

@@ -250,8 +250,8 @@ class BaseQuery {
             preAggregationQuery: this.options.preAggregationQuery,
             disableExternalPreAggregations: this.options.disableExternalPreAggregations,
             useOriginalSqlPreAggregationsInPreAggregation: this.options.useOriginalSqlPreAggregationsInPreAggregation,
-            cubeLatticeCache: this.options.cubeLatticeCache,
-            historyQueries: this.options.historyQueries,
+            cubeLatticeCache: this.options.cubeLatticeCache, // TODO too heavy for key
+            historyQueries: this.options.historyQueries, // TODO too heavy for key
             ungrouped: this.options.ungrouped,
             memberToAlias: this.options.memberToAlias,
             expressionParams: this.options.expressionParams,
@@ -1436,7 +1436,7 @@ class BaseQuery {
         const fromSubQuery = fromMeasures && this.newSubQuery({
             measures: fromMeasures,
             // TODO get rid of this multiStage filter
-            dimensions: fromDimensions,
+            dimensions: fromDimensions, // .filter(d => !this.newDimension(d).isMultiStage()),
             timeDimensions: fromTimeDimensions,
             multiStageDimensions: withQuery.multiStageDimensions,
             multiStageTimeDimensions: withQuery.multiStageTimeDimensions,
@@ -1447,7 +1447,7 @@ class BaseQuery {
             // them by memberToAlias, producing `invalid identifier` errors.
             memberToAlias: this.options.memberToAlias,
             // TODO do we need it?
-            multiStageQuery: true,
+            multiStageQuery: true, // !!fromDimensions.find(d => this.newDimension(d).isMultiStage())
             disableExternalPreAggregations: true,
         });
         const measures = fromSubQuery && fromMeasures.map(m => fromSubQuery.newMeasure(m));
@@ -3045,6 +3045,9 @@ class BaseQuery {
                 [renderContext.rootMeasure.value];
         };
     }
+    /**
+     * @returns {string[]}
+     */
     collectLeafMeasures(fn) {
         const context = { leafMeasures: {} };
         this.evaluateSymbolSqlWithContext(fn, context);
@@ -3852,7 +3855,7 @@ class BaseQuery {
                 between: '{{ expr }} {% if negated %}NOT {% endif %}BETWEEN {{ low }} AND {{ high }}',
             },
             tesseract: {
-                ilike: '{{ expr }} {% if negated %}NOT {% endif %}ILIKE {{ pattern }}',
+                ilike: '{{ expr }} {% if negated %}NOT {% endif %}ILIKE {{ pattern }}', // May require different overloads in Tesseract than the ilike from expressions used in SQLAPI.
                 series_bounds_cast: '{{ expr }}',
                 bool_param_cast: '{{ expr }}',
                 number_param_cast: '{{ expr }}',
@@ -4373,16 +4376,22 @@ class BaseQuery {
             return newGroupFilter({ operator: filter.operator, values }).filterToWhere();
         }
         const filterParams = filter.filterParams();
-        const filterParamArg = filterParamArgs.filter(p => {
+        const matching = filterParamArgs.filter(p => {
             const member = p.__member();
             return member === filter.measure ||
                 member === filter.dimension ||
                 (aliases[member] && (aliases[member] === filter.measure ||
                     aliases[member] === filter.dimension));
-        })[0];
-        if (!filterParamArg) {
+        });
+        if (!matching.length) {
             throw new Error(`FILTER_PARAMS arg not found for ${filter.measure || filter.dimension}`);
         }
+        // Several args can name the same member, one per time shift it addresses.
+        // Only the one addressing no shift describes the rows this query reads.
+        const filterParamArg = matching.find(p => !(p.__timeShift && p.__timeShift()));
+        if (!filterParamArg) {
+            return BaseFilter_1.BaseFilter.ALWAYS_TRUE;
+        }
         if (typeof filterParamArg.__column() !== 'function') {
             return filter.conditionSql(filterParamArg.__column());
         }
@@ -4429,46 +4438,85 @@ class BaseQuery {
                 // and do not check cube validity as it's part of compilation step.
                 const cubeName = allFilters && cubeEvaluator.cubeNameFromPath(name);
                 return new Proxy({ cube: cubeName }, {
-                    get: (cubeNameObj, propertyName) => ({
-                        filter: (column) => ({
-                            __column() {
-                                return column;
-                            },
-                            __member() {
-                                return cubeEvaluator.pathFromArray([cubeNameObj.cube, propertyName]);
-                            },
-                            toString() {
-                                // Segments should be excluded because they are evaluated separately in cubeReferenceProxy
-                                // In other case this falls into the recursive loop/stack exceeded caused by:
-                                // collectFrom() -> traverseSymbol() -> evaluateSymbolSql() ->
-                                // evaluateSql() -> resolveSymbolsCall() -> cubeReferenceProxy->toString() ->
-                                // evaluateSymbolSql() -> evaluateSql()... -> and got here again
-                                //
-                                // When FILTER_PARAMS is used in dimension/measure SQL - we also hit recursive loop:
-                                // allBackAliasMembersExceptSegments() -> collectFrom() -> traverseSymbol() -> evaluateSymbolSql() ->
-                                // autoPrefixAndEvaluateSql() -> evaluateSql() -> filterProxyFromAllFilters->Proxy->toString()
-                                // and so on...
-                                // For this case aliasGathering flag is added to the context in first iteration and
-                                // is checked below to prevent looping.
-                                const aliases = allFilters ?
-                                    allFilters
-                                        .map(v => (v.query && !v.query.safeEvaluateSymbolContext().aliasGathering ? v.query.allBackAliasMembersExceptSegments() : {}))
-                                        .reduce((a, b) => ({ ...a, ...b }), {})
-                                    : {};
-                                // Filtering aliases that somehow relate to this group member
-                                const groupMember = cubeEvaluator.pathFromArray([cubeNameObj.cube, propertyName]);
-                                const aliasesForGroupMembers = Object.entries(aliases)
-                                    .filter(([key, _value]) => key === groupMember)
-                                    .map(([_key, value]) => value);
-                                const filter = BaseQuery.findAndSubTreeForFilterGroup(newGroupFilter({ operator: 'and', values: allFilters }), [groupMember], newGroupFilter, aliasesForGroupMembers);
-                                return `(${BaseQuery.renderFilterParams(filter, [this], allocateParam, newGroupFilter, aliases)})`;
+                    get: (cubeNameObj, propertyName) => new Proxy({}, {
+                        get: (memberTarget, prop) => {
+                            if (prop === 'filter') {
+                                return (column) => BaseQuery.filterProxyBinding(cubeNameObj.cube, propertyName, false, column, allFilters, cubeEvaluator, allocateParam, newGroupFilter);
                             }
-                        })
+                            // A time shift is addressed only by the native planner. Here the
+                            // binding still has to exist, so that a model written for it
+                            // compiles and FILTER_GROUP can recover its member, but it
+                            // restates nothing.
+                            if (prop === 'time_shifts' || prop === 'timeShifts') {
+                                return new Proxy({}, {
+                                    get: (_shiftTarget, timeShiftName) => {
+                                        // Under `time_shifts` every string reads as the name of a
+                                        // shift, so string coercion and `filter` — the plain form
+                                        // with `time_shifts.` inserted by mistake — are reserved.
+                                        if (typeof timeShiftName !== 'string' || BaseQuery.NOT_SHIFT_NAMES.has(timeShiftName)) {
+                                            return () => {
+                                                throw new UserError_1.UserError(`FILTER_PARAMS.${cubeNameObj.cube}.${propertyName}.time_shifts needs the name of a time shift: ` +
+                                                    'FILTER_PARAMS.<cube>.<member>.time_shifts.<name>.filter(...)');
+                                            };
+                                        }
+                                        return {
+                                            filter: (column) => BaseQuery.filterProxyBinding(cubeNameObj.cube, propertyName, true, column, allFilters, cubeEvaluator, allocateParam, newGroupFilter)
+                                        };
+                                    }
+                                });
+                            }
+                            return Reflect.get(memberTarget, prop);
+                        }
                     })
                 });
             }
         });
     }
+    static get NOT_SHIFT_NAMES() {
+        return new Set(['toString', 'valueOf', 'filter']);
+    }
+    static filterProxyBinding(cubeName, propertyName, isTimeShift, column, allFilters, cubeEvaluator, allocateParam, newGroupFilter) {
+        return {
+            __column() {
+                return column;
+            },
+            __member() {
+                return cubeEvaluator.pathFromArray([cubeName, propertyName]);
+            },
+            __timeShift() {
+                return isTimeShift;
+            },
+            toString() {
+                if (isTimeShift) {
+                    return `(${BaseFilter_1.BaseFilter.ALWAYS_TRUE})`;
+                }
+                // Segments should be excluded because they are evaluated separately in cubeReferenceProxy
+                // In other case this falls into the recursive loop/stack exceeded caused by:
+                // collectFrom() -> traverseSymbol() -> evaluateSymbolSql() ->
+                // evaluateSql() -> resolveSymbolsCall() -> cubeReferenceProxy->toString() ->
+                // evaluateSymbolSql() -> evaluateSql()... -> and got here again
+                //
+                // When FILTER_PARAMS is used in dimension/measure SQL - we also hit recursive loop:
+                // allBackAliasMembersExceptSegments() -> collectFrom() -> traverseSymbol() -> evaluateSymbolSql() ->
+                // autoPrefixAndEvaluateSql() -> evaluateSql() -> filterProxyFromAllFilters->Proxy->toString()
+                // and so on...
+                // For this case aliasGathering flag is added to the context in first iteration and
+                // is checked below to prevent looping.
+                const aliases = allFilters ?
+                    allFilters
+                        .map(v => (v.query && !v.query.safeEvaluateSymbolContext().aliasGathering ? v.query.allBackAliasMembersExceptSegments() : {}))
+                        .reduce((a, b) => ({ ...a, ...b }), {})
+                    : {};
+                // Filtering aliases that somehow relate to this group member
+                const groupMember = cubeEvaluator.pathFromArray([cubeName, propertyName]);
+                const aliasesForGroupMembers = Object.entries(aliases)
+                    .filter(([key, _value]) => key === groupMember)
+                    .map(([_key, value]) => value);
+                const filter = BaseQuery.findAndSubTreeForFilterGroup(newGroupFilter({ operator: 'and', values: allFilters }), [groupMember], newGroupFilter, aliasesForGroupMembers);
+                return `(${BaseQuery.renderFilterParams(filter, [this], allocateParam, newGroupFilter, aliases)})`;
+            }
+        };
+    }
     /**
      *
      * @param {boolean} excludeSegments
@@ -4600,7 +4648,7 @@ class BaseQuery {
     /**
      * Returns a function that constructs the full member path
      * based on the query's join structure.
-     * @returns {(function(member: string): (string))}
+     * @returns {(member: string) => string}
      */
     resolveFullMemberPathFn() {
         const { root: queryJoinRoot } = this.join || {};