@cubejs-backend/schema-compiler 0.35.10 → 0.35.13

package/dist/src/adapter/BaseQuery.js

@@ -195,13 +195,19 @@ class BaseQuery {
             memberToAlias: this.options.memberToAlias,
             expressionParams: this.options.expressionParams,
             convertTzForRawTimeDimension: this.options.convertTzForRawTimeDimension,
+            from: this.options.from,
+            postAggregateQuery: this.options.postAggregateQuery,
+            postAggregateDimensions: this.options.postAggregateDimensions,
         });
+        this.from = this.options.from;
+        this.postAggregateQuery = this.options.postAggregateQuery;
         this.timezone = this.options.timezone;
         this.rowLimit = this.options.rowLimit;
         this.offset = this.options.offset;
         this.preAggregations = this.newPreAggregations();
         this.measures = (this.options.measures || []).map(this.newMeasure.bind(this));
         this.dimensions = (this.options.dimensions || []).map(this.newDimension.bind(this));
+        this.postAggregateDimensions = (this.options.postAggregateDimensions || []).map(this.newDimension.bind(this));
         this.segments = (this.options.segments || []).map(this.newSegment.bind(this));
         this.order = this.options.order || [];
         const filters = this.extractFiltersAsTree(this.options.filters || []);
@@ -405,6 +411,10 @@ class BaseQuery {
     buildParamAnnotatedSql() {
         let sql;
         let preAggForQuery;
+        // TODO Most probably should be called later than here but avoids errors during pre-aggregation match for now
+        if (this.from) {
+            return this.simpleQuery();
+        }
         if (!this.options.preAggregationQuery) {
             preAggForQuery =
                 this.preAggregations.findPreAggregationForQuery();
@@ -413,7 +423,7 @@ class BaseQuery {
             }
         }
         if (preAggForQuery) {
-            const { multipliedMeasures, regularMeasures, cumulativeMeasures, } = this.fullKeyQueryAggregateMeasures();
+            const { multipliedMeasures, regularMeasures, cumulativeMeasures, withQueries, postAggregateMembers, } = this.fullKeyQueryAggregateMeasures();
             if (cumulativeMeasures.length === 0) {
                 sql = this.preAggregations.rollupPreAggregation(preAggForQuery, this.measures, true);
             }
@@ -564,6 +574,9 @@ class BaseQuery {
         // eslint-disable-next-line prefer-template
         const inlineWhereConditions = [];
         const commonQuery = this.rewriteInlineWhere(() => this.commonQuery(), inlineWhereConditions);
+        if (this.postAggregateQuery) {
+            return `${commonQuery} ${this.baseWhere(this.allFilters.concat(inlineWhereConditions))}`;
+        }
         return `${commonQuery} ${this.baseWhere(this.allFilters.concat(inlineWhereConditions))}` +
             this.groupByClause() +
             this.baseHaving(this.measureFilters) +
@@ -575,10 +588,14 @@ class BaseQuery {
      * @returns {string}
      */
     fullKeyQueryAggregate() {
-        const { multipliedMeasures, regularMeasures, cumulativeMeasures, } = this.fullKeyQueryAggregateMeasures();
-        if (!multipliedMeasures.length && !cumulativeMeasures.length) {
+        if (this.from) {
+            return this.simpleQuery();
+        }
+        const { multipliedMeasures, regularMeasures, cumulativeMeasures, withQueries, postAggregateMembers, } = this.fullKeyQueryAggregateMeasures();
+        if (!multipliedMeasures.length && !cumulativeMeasures.length && !postAggregateMembers.length) {
             return this.simpleQuery();
         }
+        const renderedWithQueries = withQueries.map(q => this.renderWithQuery(q));
         let toJoin;
         if (this.options.preAggregationQuery) {
             const allRegular = regularMeasures.concat(cumulativeMeasures
@@ -600,7 +617,9 @@ class BaseQuery {
                     .concat(ramda_1.default.pipe(ramda_1.default.groupBy(m => m.cube().name), ramda_1.default.toPairs, ramda_1.default.map(([keyCubeName, measures]) => this
                     .withCubeAliasPrefix(`${this.aliasName(keyCubeName)}_key`, () => this.aggregateSubQuery(keyCubeName, measures))))(multipliedMeasures)).concat(ramda_1.default.map(([multiplied, measure]) => this.withCubeAliasPrefix(`${this.aliasName(measure.measure.replace('.', '_'))}_cumulative`, () => this.overTimeSeriesQuery(multiplied
                     ? (measures, filters) => this.aggregateSubQuery(measures[0].cube().name, measures, filters)
-                    : this.regularMeasuresSubQuery.bind(this), measure, false)))(cumulativeMeasures));
+                    : this.regularMeasuresSubQuery.bind(this), measure, false)))(cumulativeMeasures)
+                // TODO SELECT *
+                ).concat(postAggregateMembers.map(m => `SELECT * FROM ${m.alias}`));
         }
         // Move regular measures to multiplied ones if there're same
         // cubes to calculate. Most of the times it'll be much faster to
@@ -631,36 +650,196 @@ class BaseQuery {
                 toJoin = ramda_1.default.pipe(ramda_1.default.groupBy(m => m.cube().name), ramda_1.default.toPairs, ramda_1.default.map(([keyCubeName, measures]) => this.withCubeAliasPrefix(`${keyCubeName}_key`, () => this.aggregateSubQuery(keyCubeName, measures))))(measuresList);
             }
         }
-        return this.joinFullKeyQueryAggregate(multipliedMeasures, regularMeasures, cumulativeMeasures, toJoin);
+        const postAggregateMeasures = ramda_1.default.flatten(postAggregateMembers.map(m => m.measures)).map(m => this.newMeasure(m));
+        return this.withQueries(this.joinFullKeyQueryAggregate(
+        // TODO separate param?
+        multipliedMeasures.concat(postAggregateMeasures), regularMeasures, cumulativeMeasures, toJoin), renderedWithQueries);
     }
     joinFullKeyQueryAggregate(multipliedMeasures, regularMeasures, cumulativeMeasures, toJoin) {
+        return this.outerMeasuresJoinFullKeyQueryAggregate(multipliedMeasures.concat(regularMeasures).concat(cumulativeMeasures.map(([multiplied, measure]) => measure)), this.measures, toJoin);
+    }
+    outerMeasuresJoinFullKeyQueryAggregate(innerMembers, outerMembers, toJoin) {
         const renderedReferenceContext = {
-            renderedReference: ramda_1.default.pipe(ramda_1.default.map(m => [m.measure, m.aliasName()]), ramda_1.default.fromPairs)(multipliedMeasures.concat(regularMeasures).concat(cumulativeMeasures.map(([multiplied, measure]) => measure))),
+            renderedReference: ramda_1.default.pipe(ramda_1.default.map(m => [m.measure || m.dimension, m.aliasName()]), ramda_1.default.fromPairs)(innerMembers),
         };
         const join = ramda_1.default.drop(1, toJoin)
             .map((q, i) => (this.dimensionAliasNames().length ?
-            `INNER JOIN (${q}) as q_${i + 1} ON ${this.dimensionsJoinCondition(`q_${i}`, `q_${i + 1}`)}` :
-            `, (${q}) as q_${i + 1}`)).join('\n');
-        const columnsToSelect = this.evaluateSymbolSqlWithContext(() => this.dimensionColumns('q_0').concat(this.measures.map(m => m.selectColumns())).join(', '), renderedReferenceContext);
-        const queryHasNoRemapping = this.evaluateSymbolSqlWithContext(() => this.dimensionsForSelect().concat(this.measures).every(r => r.hasNoRemapping()), renderedReferenceContext);
+            `INNER JOIN ${this.wrapInParenthesis((q))} as q_${i + 1} ON ${this.dimensionsJoinCondition(`q_${i}`, `q_${i + 1}`)}` :
+            `, ${this.wrapInParenthesis(q)} as q_${i + 1}`)).join('\n');
+        const columnsToSelect = this.evaluateSymbolSqlWithContext(() => this.dimensionColumns('q_0').concat(outerMembers.map(m => m.selectColumns())).join(', '), renderedReferenceContext);
+        const queryHasNoRemapping = this.evaluateSymbolSqlWithContext(() => this.dimensionsForSelect().concat(outerMembers).every(r => r.hasNoRemapping()), renderedReferenceContext);
         const havingFilters = this.evaluateSymbolSqlWithContext(() => this.baseWhere(this.measureFilters), renderedReferenceContext);
         // TODO all having filters should be pushed down
         // subQuery dimensions can introduce projection remapping
         if (toJoin.length === 1 &&
             this.measureFilters.length === 0 &&
-            this.measures.filter(m => m.expression).length === 0 &&
+            outerMembers.filter(m => m.expression).length === 0 &&
             queryHasNoRemapping) {
             return `${toJoin[0].replace(/^SELECT/, `SELECT ${this.topLimit()}`)} ${this.orderBy()}${this.groupByDimensionLimit()}`;
         }
-        return `SELECT ${this.topLimit()}${columnsToSelect} FROM (${toJoin[0]}) as q_0 ${join}${havingFilters}${this.orderBy()}${this.groupByDimensionLimit()}`;
+        return `SELECT ${this.topLimit()}${columnsToSelect} FROM ${this.wrapInParenthesis(toJoin[0])} as q_0 ${join}${havingFilters}${this.orderBy()}${this.groupByDimensionLimit()}`;
+    }
+    wrapInParenthesis(select) {
+        return select.trim().match(/^SELECT/ig) ? `(${select})` : select;
+    }
+    withQueries(select, withQueries) {
+        if (!withQueries || !withQueries.length) {
+            return select;
+        }
+        // TODO escape alias
+        return `WITH\n${withQueries.map(q => `${q.alias} AS (${q.query})`).join(',\n')}\n${select}`;
     }
     fullKeyQueryAggregateMeasures(context) {
         const measureToHierarchy = this.collectRootMeasureToHieararchy(context);
-        const measuresToRender = (multiplied, cumulative) => ramda_1.default.pipe(ramda_1.default.values, ramda_1.default.flatten, ramda_1.default.filter(m => m.multiplied === multiplied && this.newMeasure(m.measure).isCumulative() === cumulative), ramda_1.default.map(m => m.measure), ramda_1.default.uniq, ramda_1.default.map(m => this.newMeasure(m)));
+        const allMemberChildren = this.collectAllMemberChildren(context);
+        const measuresToRender = (multiplied, cumulative) => ramda_1.default.pipe(ramda_1.default.values, ramda_1.default.flatten, ramda_1.default.filter(m => m.multiplied === multiplied && this.newMeasure(m.measure).isCumulative() === cumulative && !m.postAggregate), ramda_1.default.map(m => m.measure), ramda_1.default.uniq, ramda_1.default.map(m => this.newMeasure(m)));
         const multipliedMeasures = measuresToRender(true, false)(measureToHierarchy);
         const regularMeasures = measuresToRender(false, false)(measureToHierarchy);
         const cumulativeMeasures = ramda_1.default.pipe(ramda_1.default.map(multiplied => ramda_1.default.xprod([multiplied], measuresToRender(multiplied, true)(measureToHierarchy))), ramda_1.default.unnest)([false, true]);
-        return { multipliedMeasures, regularMeasures, cumulativeMeasures };
+        const withQueries = [];
+        const postAggregateMembers = (this.allMembersConcat(false))
+            .filter(m => m.definition && m.definition()?.postAggregate)
+            .map(m => m.measure || m.dimension)
+            .map(m => this.postAggregateWithQueries(m, { dimensions: this.dimensions.map(d => d.dimension), postAggregateDimensions: this.dimensions.map(d => d.dimension), filters: this.filters }, allMemberChildren, withQueries));
+        const usedWithQueries = {};
+        postAggregateMembers.forEach(m => this.collectUsedWithQueries(usedWithQueries, m));
+        return {
+            multipliedMeasures,
+            regularMeasures,
+            cumulativeMeasures,
+            postAggregateMembers,
+            withQueries: withQueries.filter(q => usedWithQueries[q.alias])
+        };
+    }
+    collectAllMemberChildren(context) {
+        return this.collectFromMembers(false, (fn) => {
+            const memberChildren = {};
+            this.evaluateSymbolSqlWithContext(fn, { ...context, memberChildren });
+            return memberChildren;
+        }, context ? ['collectAllMemberChildren', JSON.stringify(context)] : 'collectAllMemberChildren').reduce((a, b) => ({ ...a, ...b }), {});
+    }
+    postAggregateWithQueries(member, queryContext, memberChildren, withQueries) {
+        let memberFrom = memberChildren[member]
+            ?.map(child => this.postAggregateWithQueries(child, this.childrenPostAggregateContext(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).isPostAggregate()) };
+        // TODO is calling postAggregateWithQueries twice optimal? If so make sure to keep only used CTE
+        memberFrom = memberChildren[member] &&
+            ramda_1.default.uniqBy(f => f.alias, memberChildren[member].map(child => this.postAggregateWithQueries(child, this.childrenPostAggregateContext(member, unionDimensionsContext), memberChildren, withQueries)));
+        const selfContext = this.selfPostAggregateContext(member, queryContext, unionDimensionsContext);
+        const subQuery = {
+            ...selfContext,
+            ...(this.cubeEvaluator.isMeasure(member) ? { measures: [member] } : { measures: [], dimensions: ramda_1.default.uniq(selfContext.dimensions.concat(member)) }),
+            memberFrom,
+        };
+        if (!memberFrom) {
+            const postAggregateMember = subQuery.measures.find(m => this.newMeasure(m).isPostAggregate()) || subQuery.dimensions.find(m => this.newDimension(m).isPostAggregate());
+            if (postAggregateMember) {
+                throw new Error(`Post aggregate member '${postAggregateMember}' lacks FROM clause in sub query: ${JSON.stringify(subQuery)}`);
+            }
+        }
+        const foundWith = withQueries.find(({ alias, ...q }) => ramda_1.default.equals(subQuery, q));
+        if (foundWith) {
+            return foundWith;
+        }
+        subQuery.alias = `cte_${withQueries.length}`;
+        withQueries.push(subQuery);
+        return subQuery;
+    }
+    collectUsedWithQueries(usedQueries, member) {
+        usedQueries[member.alias] = true;
+        member.memberFrom?.forEach(m => this.collectUsedWithQueries(usedQueries, m));
+    }
+    childrenPostAggregateContext(memberPath, queryContext) {
+        let member;
+        if (this.cubeEvaluator.isMeasure(memberPath)) {
+            member = this.newMeasure(memberPath);
+        }
+        else if (this.cubeEvaluator.isDimension(memberPath)) {
+            member = this.newDimension(memberPath);
+        }
+        const memberDef = member.definition();
+        // TODO can addGroupBy replaced by something else?
+        if (memberDef.addGroupByReferences) {
+            queryContext = { ...queryContext, dimensions: ramda_1.default.uniq(queryContext.dimensions.concat(memberDef.addGroupByReferences)) };
+        }
+        return queryContext;
+    }
+    selfPostAggregateContext(memberPath, queryContext, unionDimensionsContext) {
+        let member;
+        if (this.cubeEvaluator.isMeasure(memberPath)) {
+            member = this.newMeasure(memberPath);
+        }
+        else if (this.cubeEvaluator.isDimension(memberPath)) {
+            member = this.newDimension(memberPath);
+            // TODO is it right place to replace context?
+            // if (member.definition().type === 'rank') {
+            //   queryContext = unionDimensionsContext;
+            // }
+        }
+        const memberDef = member.definition();
+        if (memberDef.reduceByReferences) {
+            queryContext = {
+                ...queryContext,
+                postAggregateDimensions: ramda_1.default.difference(queryContext.postAggregateDimensions, memberDef.reduceByReferences),
+                // dimensions: R.uniq(queryContext.dimensions.concat(memberDef.reduceByReferences))
+            };
+        }
+        if (memberDef.groupByReferences) {
+            queryContext = {
+                ...queryContext,
+                postAggregateDimensions: ramda_1.default.intersection(queryContext.postAggregateDimensions, memberDef.groupByReferences)
+            };
+        }
+        return queryContext;
+    }
+    renderWithQuery(withQuery) {
+        const fromMeasures = withQuery.memberFrom && ramda_1.default.uniq(ramda_1.default.flatten(withQuery.memberFrom.map(f => f.measures)));
+        // TODO get rid of this postAggregate filter
+        const fromDimensions = withQuery.memberFrom && ramda_1.default.uniq(ramda_1.default.flatten(withQuery.memberFrom.map(f => f.dimensions)));
+        const renderedReferenceContext = {
+            renderedReference: withQuery.memberFrom && ramda_1.default.fromPairs(ramda_1.default.unnest(withQuery.memberFrom.map(from => from.measures.map(m => {
+                const measure = this.newMeasure(m);
+                return [m, measure.aliasName()];
+            }).concat(from.dimensions.map(m => {
+                const member = this.newDimension(m);
+                return [m, member.aliasName()];
+            })))))
+        };
+        const fromSubQuery = fromMeasures && this.newSubQuery({
+            measures: fromMeasures,
+            // TODO get rid of this postAggregate filter
+            dimensions: fromDimensions,
+            postAggregateDimensions: withQuery.postAggregateDimensions,
+            filters: withQuery.filters,
+            // TODO do we need it?
+            postAggregateQuery: true // !!fromDimensions.find(d => this.newDimension(d).isPostAggregate())
+        });
+        const measures = fromSubQuery && fromMeasures.map(m => fromSubQuery.newMeasure(m));
+        // TODO get rid of this postAggregate filter
+        const postAggregateDimensions = fromSubQuery && fromDimensions.map(m => fromSubQuery.newDimension(m)).filter(d => d.isPostAggregate());
+        const membersToSelect = measures?.concat(postAggregateDimensions);
+        const select = fromSubQuery && fromSubQuery.outerMeasuresJoinFullKeyQueryAggregate(membersToSelect, membersToSelect, withQuery.memberFrom.map(f => f.alias));
+        const fromSql = select && this.wrapInParenthesis(select);
+        const subQuery = this.newSubQuery({
+            measures: withQuery.measures,
+            dimensions: withQuery.dimensions,
+            postAggregateDimensions: withQuery.postAggregateDimensions,
+            filters: withQuery.filters,
+            from: fromSql && {
+                sql: fromSql,
+                alias: `${withQuery.alias}_join`,
+            },
+            // TODO condition should something else instead of rank
+            postAggregateQuery: !!withQuery.measures.find(d => {
+                const { type } = this.newMeasure(d).definition();
+                return type === 'rank' || type === 'number';
+            }),
+        });
+        return {
+            query: subQuery.evaluateSymbolSqlWithContext(() => subQuery.buildParamAnnotatedSql(), renderedReferenceContext),
+            alias: withQuery.alias
+        };
     }
     dimensionsJoinCondition(leftAlias, rightAlias) {
         const dimensionAliases = this.dimensionAliasNames();
@@ -807,7 +986,7 @@ class BaseQuery {
         }));
     }
     query() {
-        return this.joinQuery(this.join, this.collectFromMembers(false, this.collectSubQueryDimensionsFor.bind(this), 'collectSubQueryDimensionsFor'));
+        return this.from && this.joinSql([this.from]) || this.joinQuery(this.join, this.collectFromMembers(false, this.collectSubQueryDimensionsFor.bind(this), 'collectSubQueryDimensionsFor'));
     }
     rewriteInlineCubeSql(cube, isLeftJoinCondition) {
         const sql = this.cubeSql(cube);
@@ -1048,12 +1227,7 @@ class BaseQuery {
         return this.collectFromMembers(excludeTimeDimensions, this.collectJoinHintsFor.bind(this), 'collectJoinHintsFor');
     }
     collectFromMembers(excludeTimeDimensions, fn, methodName) {
-        const membersToCollectFrom = this.measures
-            .concat(this.dimensions)
-            .concat(this.segments)
-            .concat(this.filters)
-            .concat(this.measureFilters)
-            .concat(excludeTimeDimensions ? [] : this.timeDimensions)
+        const membersToCollectFrom = this.allMembersConcat(excludeTimeDimensions)
             .concat(this.join ? this.join.joins.map(j => ({
             getMembers: () => [{
                     path: () => null,
@@ -1063,6 +1237,14 @@ class BaseQuery {
         })) : []);
         return this.collectFrom(membersToCollectFrom, fn, methodName);
     }
+    allMembersConcat(excludeTimeDimensions) {
+        return this.measures
+            .concat(this.dimensions)
+            .concat(this.segments)
+            .concat(this.filters)
+            .concat(this.measureFilters)
+            .concat(excludeTimeDimensions ? [] : this.timeDimensions);
+    }
     collectFrom(membersToCollectFrom, fn, methodName, cache) {
         const methodCacheKey = Array.isArray(methodName) ? methodName : [methodName];
         return ramda_1.default.pipe(ramda_1.default.map(f => f.getMembers()), ramda_1.default.flatten, ramda_1.default.map(s => ((cache || this.compilerCache).cache(['collectFrom'].concat(methodCacheKey).concat(s.path() ? [s.path().join('.')] : [s.cube().name, s.expression?.toString() || s.expressionName || s.definition().sql]), () => fn(() => this.traverseSymbol(s))))), ramda_1.default.unnest, ramda_1.default.uniq, ramda_1.default.filter(ramda_1.default.identity))(membersToCollectFrom);
@@ -1249,75 +1431,100 @@ class BaseQuery {
         if (!type && this.cubeEvaluator.isSegment(memberPathArray)) {
             type = 'segment';
         }
-        if (type === 'measure') {
-            let parentMeasure;
-            if (this.safeEvaluateSymbolContext().compositeCubeMeasures ||
-                this.safeEvaluateSymbolContext().leafMeasures) {
-                parentMeasure = this.safeEvaluateSymbolContext().currentMeasure;
-                if (this.safeEvaluateSymbolContext().compositeCubeMeasures) {
-                    if (parentMeasure && !memberExpressionType &&
-                        (this.cubeEvaluator.cubeNameFromPath(parentMeasure) !== cubeName ||
-                            this.newMeasure(this.cubeEvaluator.pathFromArray(memberPathArray)).isCumulative())) {
-                        this.safeEvaluateSymbolContext().compositeCubeMeasures[parentMeasure] = true;
+        const parentMember = this.safeEvaluateSymbolContext().currentMember;
+        if (this.safeEvaluateSymbolContext().memberChildren && parentMember) {
+            this.safeEvaluateSymbolContext().memberChildren[parentMember] = this.safeEvaluateSymbolContext().memberChildren[parentMember] || [];
+            if (this.safeEvaluateSymbolContext().memberChildren[parentMember].indexOf(memberPath) === -1) {
+                this.safeEvaluateSymbolContext().memberChildren[parentMember].push(memberPath);
+            }
+        }
+        this.safeEvaluateSymbolContext().currentMember = memberPath;
+        try {
+            if (type === 'measure') {
+                let parentMeasure;
+                if (this.safeEvaluateSymbolContext().compositeCubeMeasures ||
+                    this.safeEvaluateSymbolContext().leafMeasures) {
+                    parentMeasure = this.safeEvaluateSymbolContext().currentMeasure;
+                    if (this.safeEvaluateSymbolContext().compositeCubeMeasures) {
+                        if (parentMeasure && !memberExpressionType &&
+                            (this.cubeEvaluator.cubeNameFromPath(parentMeasure) !== cubeName ||
+                                this.newMeasure(memberPath).isCumulative())) {
+                            this.safeEvaluateSymbolContext().compositeCubeMeasures[parentMeasure] = true;
+                        }
                     }
-                }
-                this.safeEvaluateSymbolContext().currentMeasure = this.cubeEvaluator.pathFromArray(memberPathArray);
-                if (this.safeEvaluateSymbolContext().leafMeasures) {
-                    if (parentMeasure) {
-                        this.safeEvaluateSymbolContext().leafMeasures[parentMeasure] = false;
+                    this.safeEvaluateSymbolContext().currentMeasure = memberPath;
+                    if (this.safeEvaluateSymbolContext().leafMeasures) {
+                        if (parentMeasure) {
+                            this.safeEvaluateSymbolContext().leafMeasures[parentMeasure] = false;
+                        }
+                        this.safeEvaluateSymbolContext().leafMeasures[this.safeEvaluateSymbolContext().currentMeasure] = true;
                     }
-                    this.safeEvaluateSymbolContext().leafMeasures[this.safeEvaluateSymbolContext().currentMeasure] = true;
                 }
-            }
-            const primaryKeys = this.cubeEvaluator.primaryKeys[cubeName];
-            const result = this.renderSqlMeasure(name, this.applyMeasureFilters(this.autoPrefixWithCubeName(cubeName, symbol.sql && this.evaluateSql(cubeName, symbol.sql) ||
-                primaryKeys.length && (primaryKeys.length > 1 ?
-                    this.concatStringsSql(primaryKeys.map((pk) => this.castToString(this.primaryKeySql(pk, cubeName))))
-                    : this.primaryKeySql(primaryKeys[0], cubeName)) || '*'), symbol, cubeName), symbol, cubeName, parentMeasure);
-            if (this.safeEvaluateSymbolContext().compositeCubeMeasures ||
-                this.safeEvaluateSymbolContext().leafMeasures) {
-                this.safeEvaluateSymbolContext().currentMeasure = parentMeasure;
-            }
-            return result;
-        }
-        else if (type === 'dimension') {
-            if ((this.safeEvaluateSymbolContext().renderedReference || {})[memberPath]) {
-                return this.evaluateSymbolContext.renderedReference[memberPath];
-            }
-            if (symbol.subQuery) {
-                if (this.safeEvaluateSymbolContext().subQueryDimensions) {
-                    this.safeEvaluateSymbolContext().subQueryDimensions.push(memberPath);
+                const primaryKeys = this.cubeEvaluator.primaryKeys[cubeName];
+                const orderBySql = (symbol.orderBy || []).map(o => ({ sql: this.evaluateSql(cubeName, o.sql), dir: o.dir }));
+                let sql;
+                if (symbol.type !== 'rank') {
+                    sql = symbol.sql && this.evaluateSql(cubeName, symbol.sql) ||
+                        primaryKeys.length && (primaryKeys.length > 1 ?
+                            this.concatStringsSql(primaryKeys.map((pk) => this.castToString(this.primaryKeySql(pk, cubeName))))
+                            : this.primaryKeySql(primaryKeys[0], cubeName)) || '*';
                 }
-                return this.escapeColumnName(this.aliasName(memberPath));
-            }
-            if (symbol.case) {
-                return this.renderDimensionCase(symbol, cubeName);
+                const result = this.renderSqlMeasure(name, sql && this.applyMeasureFilters(this.autoPrefixWithCubeName(cubeName, sql), symbol, cubeName), symbol, cubeName, parentMeasure, orderBySql);
+                if (this.safeEvaluateSymbolContext().compositeCubeMeasures ||
+                    this.safeEvaluateSymbolContext().leafMeasures) {
+                    this.safeEvaluateSymbolContext().currentMeasure = parentMeasure;
+                }
+                return result;
             }
-            else if (symbol.type === 'geo') {
-                return this.concatStringsSql([
-                    this.autoPrefixAndEvaluateSql(cubeName, symbol.latitude.sql),
-                    '\',\'',
-                    this.autoPrefixAndEvaluateSql(cubeName, symbol.longitude.sql)
-                ]);
+            else if (type === 'dimension') {
+                if ((this.safeEvaluateSymbolContext().renderedReference || {})[memberPath]) {
+                    return this.evaluateSymbolContext.renderedReference[memberPath];
+                }
+                // if (symbol.postAggregate) {
+                //   const orderBySql = (symbol.orderBy || []).map(o => ({ sql: this.evaluateSql(cubeName, o.sql), dir: o.dir }));
+                //   const partitionBy = this.postAggregateDimensions.length ? `PARTITION BY ${this.postAggregateDimensions.map(d => d.dimensionSql()).join(', ')} ` : '';
+                //   if (symbol.type === 'rank') {
+                //     return `${symbol.type}() OVER (${partitionBy}ORDER BY ${orderBySql.map(o => `${o.sql} ${o.dir}`).join(', ')})`;
+                //   }
+                // }
+                if (symbol.subQuery) {
+                    if (this.safeEvaluateSymbolContext().subQueryDimensions) {
+                        this.safeEvaluateSymbolContext().subQueryDimensions.push(memberPath);
+                    }
+                    return this.escapeColumnName(this.aliasName(memberPath));
+                }
+                if (symbol.case) {
+                    return this.renderDimensionCase(symbol, cubeName);
+                }
+                else if (symbol.type === 'geo') {
+                    return this.concatStringsSql([
+                        this.autoPrefixAndEvaluateSql(cubeName, symbol.latitude.sql),
+                        '\',\'',
+                        this.autoPrefixAndEvaluateSql(cubeName, symbol.longitude.sql)
+                    ]);
+                }
+                else {
+                    let res = this.autoPrefixAndEvaluateSql(cubeName, symbol.sql);
+                    if (this.safeEvaluateSymbolContext().convertTzForRawTimeDimension &&
+                        !memberExpressionType &&
+                        symbol.type === 'time' &&
+                        this.cubeEvaluator.byPathAnyType(memberPathArray).ownedByCube) {
+                        res = this.convertTz(res);
+                    }
+                    return res;
+                }
             }
-            else {
-                let res = this.autoPrefixAndEvaluateSql(cubeName, symbol.sql);
-                if (this.safeEvaluateSymbolContext().convertTzForRawTimeDimension &&
-                    !memberExpressionType &&
-                    symbol.type === 'time' &&
-                    this.cubeEvaluator.byPathAnyType(memberPathArray).ownedByCube) {
-                    res = this.convertTz(res);
+            else if (type === 'segment') {
+                if ((this.safeEvaluateSymbolContext().renderedReference || {})[memberPath]) {
+                    return this.evaluateSymbolContext.renderedReference[memberPath];
                 }
-                return res;
+                return this.autoPrefixWithCubeName(cubeName, this.evaluateSql(cubeName, symbol.sql));
             }
+            return this.evaluateSql(cubeName, symbol.sql);
         }
-        else if (type === 'segment') {
-            if ((this.safeEvaluateSymbolContext().renderedReference || {})[memberPath]) {
-                return this.evaluateSymbolContext.renderedReference[memberPath];
-            }
-            return this.autoPrefixWithCubeName(cubeName, this.evaluateSql(cubeName, symbol.sql));
+        finally {
+            this.safeEvaluateSymbolContext().currentMember = parentMember;
         }
-        return this.evaluateSql(cubeName, symbol.sql);
     }
     autoPrefixAndEvaluateSql(cubeName, sql) {
         return this.autoPrefixWithCubeName(cubeName, this.evaluateSql(cubeName, sql));
@@ -1415,7 +1622,7 @@ class BaseQuery {
             this.evaluateSymbolContext = oldContext;
         }
     }
-    renderSqlMeasure(name, evaluateSql, symbol, cubeName, parentMeasure) {
+    renderSqlMeasure(name, evaluateSql, symbol, cubeName, parentMeasure, orderBySql) {
         const multiplied = this.multipliedJoinRowResult(cubeName);
         const measurePath = `${cubeName}.${name}`;
         let resultMultiplied = multiplied;
@@ -1427,10 +1634,10 @@ class BaseQuery {
         if (parentMeasure &&
             (this.safeEvaluateSymbolContext().foundCompositeCubeMeasures || {})[parentMeasure] &&
             !(this.safeEvaluateSymbolContext().foundCompositeCubeMeasures || {})[measurePath]) {
-            this.safeEvaluateSymbolContext().measuresToRender.push({ multiplied: resultMultiplied, measure: measurePath });
+            this.safeEvaluateSymbolContext().measuresToRender.push({ multiplied: resultMultiplied, measure: measurePath, postAggregate: symbol.postAggregate });
         }
         if (this.safeEvaluateSymbolContext().foundCompositeCubeMeasures && !parentMeasure) {
-            this.safeEvaluateSymbolContext().rootMeasure.value = { multiplied: resultMultiplied, measure: measurePath };
+            this.safeEvaluateSymbolContext().rootMeasure.value = { multiplied: resultMultiplied, measure: measurePath, postAggregate: symbol.postAggregate };
         }
         if (((this.evaluateSymbolContext || {}).renderedReference || {})[measurePath]) {
             return this.evaluateSymbolContext.renderedReference[measurePath];
@@ -1459,6 +1666,32 @@ class BaseQuery {
                 return onGroupedColumn;
             }
         }
+        if (symbol.postAggregate) {
+            const partitionBy = this.postAggregateDimensions.length ? `PARTITION BY ${this.postAggregateDimensions.map(d => d.dimensionSql()).join(', ')} ` : '';
+            if (symbol.type === 'rank') {
+                return `${symbol.type}() OVER (${partitionBy}ORDER BY ${orderBySql.map(o => `${o.sql} ${o.dir}`).join(', ')})`;
+            }
+            if (!ramda_1.default.equals(this.postAggregateDimensions.map(d => d.expressionPath()), this.dimensions.map(d => d.expressionPath()))) {
+                let funDef;
+                if (symbol.type === 'countDistinctApprox') {
+                    funDef = this.countDistinctApprox(evaluateSql);
+                }
+                else if (symbol.type === 'countDistinct' || symbol.type === 'count' && !symbol.sql && multiplied) {
+                    funDef = `count(distinct ${evaluateSql})`;
+                }
+                else if (BaseQuery.isCalculatedMeasureType(symbol.type)) {
+                    // TODO calculated measure type will be ungrouped
+                    // if (this.postAggregateDimensions.length !== this.dimensions.length) {
+                    //   throw new UserError(`Calculated measure '${measurePath}' uses group_by or reduce_by context modifiers while it isn't allowed`);
+                    // }
+                    return evaluateSql;
+                }
+                else {
+                    funDef = `${symbol.type}(${symbol.type}(${evaluateSql}))`;
+                }
+                return `${funDef} OVER(${partitionBy})`;
+            }
+        }
         if (symbol.type === 'countDistinctApprox') {
             return this.safeEvaluateSymbolContext().overTimeSeriesAggregate || this.options.preAggregationQuery ?
                 this.hllInit(evaluateSql) :