plywood/build/expressions/sqlAggregateExpression.js

A query planner and executor

import { __extends } from "tslib";
import { SqlExpression } from 'druid-query-toolkit';
import { ChainableExpression, Expression } from './baseExpression';
import { Aggregate } from './mixins/aggregate';
var SqlAggregateExpression = (function (_super) {
    __extends(SqlAggregateExpression, _super);
    function SqlAggregateExpression(parameters) {
        var _this = _super.call(this, parameters, dummyObject) || this;
        _this.sql = parameters.sql;
        _this._ensureOp('sqlAggregate');
        _this._checkOperandTypes('DATASET');
        _this.type = 'NUMBER';
        _this.parsedSql = SqlExpression.parse(_this.sql);
        return _this;
    }
    SqlAggregateExpression.registerKnownAggregation = function (aggregation) {
        if (SqlAggregateExpression.KNOWN_AGGREGATIONS.includes(aggregation))
            return;
        SqlAggregateExpression.KNOWN_AGGREGATIONS.push(aggregation);
    };
    SqlAggregateExpression.substituteFilter = function (sqlExpression, condition) {
        return sqlExpression.addFilterToAggregations(condition, SqlAggregateExpression.KNOWN_AGGREGATIONS);
    };
    SqlAggregateExpression.fromJS = function (parameters) {
        var value = ChainableExpression.jsToValue(parameters);
        value.sql = parameters.sql;
        return new SqlAggregateExpression(value);
    };
    SqlAggregateExpression.prototype.valueOf = function () {
        var value = _super.prototype.valueOf.call(this);
        value.sql = this.sql;
        return value;
    };
    SqlAggregateExpression.prototype.toJS = function () {
        var js = _super.prototype.toJS.call(this);
        js.sql = this.sql;
        return js;
    };
    SqlAggregateExpression.prototype.equals = function (other) {
        return _super.prototype.equals.call(this, other) && this.sql === other.sql;
    };
    SqlAggregateExpression.prototype._toStringParameters = function (_indent) {
        return [this.sql];
    };
    SqlAggregateExpression.prototype._calcChainableHelper = function (_operandValue) {
        throw new Error('can not compute on SQL aggregate');
    };
    SqlAggregateExpression.prototype._getSQLChainableHelper = function (dialect, operandSQL) {
        var sql = this.sql;
        if (operandSQL.includes(' WHERE ')) {
            var filterParse = SqlExpression.parse(operandSQL.split(' WHERE ')[1]);
            sql = String(SqlAggregateExpression.substituteFilter(this.parsedSql, filterParse));
        }
        return "(".concat(sql, ")");
    };
    SqlAggregateExpression.op = 'SqlAggregate';
    SqlAggregateExpression.KNOWN_AGGREGATIONS = [
        'COUNT',
        'SUM',
        'MIN',
        'MAX',
        'AVG',
        'APPROX_COUNT_DISTINCT',
        'APPROX_COUNT_DISTINCT_DS_HLL',
        'APPROX_COUNT_DISTINCT_DS_THETA',
        'DS_HLL',
        'DS_THETA',
        'APPROX_QUANTILE',
        'APPROX_QUANTILE_DS',
        'APPROX_QUANTILE_FIXED_BUCKETS',
        'DS_QUANTILES_SKETCH',
        'BLOOM_FILTER',
        'TDIGEST_QUANTILE',
        'TDIGEST_GENERATE_SKETCH',
        'VAR_POP',
        'VAR_SAMP',
        'VARIANCE',
        'STDDEV_POP',
        'STDDEV_SAMP',
        'STDDEV',
        'EARLIEST',
        'LATEST',
        'ANY_VALUE',
    ];
    return SqlAggregateExpression;
}(ChainableExpression));
export { SqlAggregateExpression };
Expression.applyMixins(SqlAggregateExpression, [Aggregate]);
Expression.register(SqlAggregateExpression);