@malloydata/malloy 0.0.3 → 0.0.4

package/dist/lang/ast/ast-expr.js

@@ -1,1041 +0,0 @@
-"use strict";
-/*
- * Copyright 2021 Google LLC
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * version 2 as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Pick = exports.PickWhen = exports.Range = exports.TopBy = exports.ExprCast = exports.isCastType = exports.ExprFilter = exports.ExprCase = exports.WhenClause = exports.ExprUngroup = exports.ExprSum = exports.ExprAvg = exports.ExprCount = exports.ExprCountDistinct = exports.ExprMax = exports.ExprMin = exports.ExprAlternationTree = exports.ExprMulDiv = exports.ExprAddSub = exports.BinaryNumeric = exports.ExprMinus = exports.ExprParens = exports.ExprNULL = exports.ExprIdReference = exports.ExprLogicalOp = exports.BinaryBoolean = exports.Boolean = exports.ExprNot = exports.ExprTime = exports.ExprRegEx = exports.ExprNumber = exports.ExprString = exports.TypeMistmatch = exports.FieldDeclaration = exports.ConstantSubExpression = exports.ExpressionDef = void 0;
-/*
- ** This file is the general framework for expression nodes and expression
- ** evaluation.
- */
-const malloy_types_1 = require("../../model/malloy_types");
-const field_space_1 = require("../field-space");
-const index_1 = require("./index");
-const apply_expr_1 = require("./apply-expr");
-const space_field_1 = require("../space-field");
-const time_utils_1 = require("./time-utils");
-/**
- * Root node for any element in an expression. These essentially
- * create a sub-tree in the larger AST. Expression nodes know
- * how to write themselves as SQL (or rather, generate the
- * template for SQL required by the query writer)
- */
-class ExpressionDef extends index_1.MalloyElement {
-    constructor() {
-        super(...arguments);
-        this.legalChildTypes = index_1.FT.anyAtomicT;
-    }
-    granular() {
-        return false;
-    }
-    /**
-     * Some operators want to give the right hand value a chance to
-     * rewrite itself. This requests a translation for a rewrite,
-     * or returns undefined if that request should be denied.
-     * @param fs FieldSpace
-     * @returns Translated expression or undefined
-     */
-    requestExpression(fs) {
-        return this.getExpression(fs);
-    }
-    defaultFieldName() {
-        return undefined;
-    }
-    /**
-     * Check an expression for type compatibility
-     * @param _eNode currently unused, will be used to get error location
-     * @param eVal ...list of expressions that must match legalChildTypes
-     */
-    typeCheck(eNode, eVal) {
-        if (!index_1.FT.in(eVal, this.legalChildTypes)) {
-            eNode.log(`'${this.elementType}' Can't use type ${index_1.FT.inspect(eVal)}`);
-            return false;
-        }
-        return true;
-    }
-    /**
-     * This is the operation which makes partial comparison and value trees work
-     * The default implemention merely constructs LEFT OP RIGHT, but specialized
-     * nodes like alternation trees or or partial comparison can control how
-     * the appplication gets generated
-     * @param fs The symbol table
-     * @param op The operator being applied
-     * @param expr The "other" (besdies 'this') value
-     * @returns The translated expression
-     */
-    apply(fs, op, left) {
-        return (0, apply_expr_1.applyBinary)(fs, left, op, this);
-    }
-}
-exports.ExpressionDef = ExpressionDef;
-class DollarReference extends ExpressionDef {
-    constructor(refType) {
-        super();
-        this.refType = refType;
-        this.elementType = "$";
-    }
-    getExpression(_fs) {
-        return {
-            dataType: this.refType,
-            value: [{ type: "applyVal" }],
-            aggregate: false,
-        };
-    }
-}
-class ConstantFieldSpace {
-    constructor() {
-        this.type = "fieldSpace";
-    }
-    structDef() {
-        throw new Error("ConstantFieldSpace cannot generate a structDef");
-    }
-    emptyStructDef() {
-        throw new Error("ConstantFieldSpace cannot generate a structDef");
-    }
-    lookup(_name) {
-        return {
-            error: "Only constants allowed in parameter expressions",
-            found: undefined,
-        };
-    }
-    dialectObj() {
-        return undefined;
-    }
-    whenComplete(step) {
-        step();
-    }
-}
-class ConstantSubExpression extends ExpressionDef {
-    constructor(expr) {
-        super({ expr });
-        this.expr = expr;
-        this.elementType = "constantExpression";
-    }
-    getExpression(_fs) {
-        return this.constantValue();
-    }
-    get constantFs() {
-        if (!this.cfs) {
-            this.cfs = new ConstantFieldSpace();
-        }
-        return this.cfs;
-    }
-    constantValue() {
-        return this.expr.getExpression(this.constantFs);
-    }
-    constantCondition(type) {
-        const compareAndContrast = new index_1.ExprCompare(new DollarReference(type), "=", this.expr);
-        const application = compareAndContrast.getExpression(this.constantFs);
-        return { ...application, value: (0, index_1.compressExpr)(application.value) };
-    }
-    apply(fs, op, expr) {
-        return this.expr.apply(fs, op, expr);
-    }
-    requestExpression(fs) {
-        return this.expr.requestExpression(fs);
-    }
-}
-exports.ConstantSubExpression = ConstantSubExpression;
-class FieldDeclaration extends index_1.MalloyElement {
-    constructor(expr, defineName, exprSrc) {
-        super({ expr });
-        this.expr = expr;
-        this.defineName = defineName;
-        this.exprSrc = exprSrc;
-        this.elementType = "fieldDeclaration";
-    }
-    fieldDef(fs, exprName) {
-        /*
-         * In an explore we cannot reference the thing we are defining, you need
-         * to use rename. In a query, the output space is a new thing, and expressions
-         * can reference the outer value in order to make a value with the new name,
-         * and it feels wrong that this is HERE and not somehow in the QueryOperation.
-         * For now, this stops the stack overflow, and passes all tests, but I think
-         * a refactor of QueryFieldSpace might someday be the place where this should
-         * happen.
-         */
-        return this.queryFieldDef(new field_space_1.DefSpace(fs, this), exprName);
-    }
-    queryFieldDef(exprFS, exprName) {
-        let exprValue;
-        try {
-            exprValue = this.expr.getExpression(exprFS);
-        }
-        catch (error) {
-            this.log(`Cannot define '${exprName}', ${error.message}`);
-            return {
-                name: `error_defining_${exprName}`,
-                type: "string",
-            };
-        }
-        const compressValue = (0, index_1.compressExpr)(exprValue.value);
-        const retType = exprValue.dataType;
-        if ((0, malloy_types_1.isAtomicFieldType)(retType)) {
-            const template = {
-                name: exprName,
-                type: retType,
-                location: this.location,
-            };
-            if (compressValue.length > 0) {
-                template.e = compressValue;
-            }
-            if (exprValue.aggregate) {
-                template.aggregate = true;
-            }
-            if (this.exprSrc) {
-                template.code = this.exprSrc;
-            }
-            // TODO this should work for dates too
-            if ((0, index_1.isGranularResult)(exprValue) && template.type === "timestamp") {
-                template.timeframe = exprValue.timeframe;
-            }
-            return template;
-        }
-        const circularDef = exprFS instanceof field_space_1.DefSpace && exprFS.foundCircle;
-        if (!circularDef) {
-            if (exprValue.dataType == "unknown") {
-                this.log(`Cannot define '${exprName}', value has unknown type`);
-            }
-            else {
-                const badType = index_1.FT.inspect(exprValue);
-                this.log(`Cannot define '${exprName}', unexpected type: ${badType}`);
-            }
-        }
-        return {
-            name: `error_defining_${exprName}`,
-            type: "string",
-        };
-    }
-}
-exports.FieldDeclaration = FieldDeclaration;
-class TypeMistmatch extends Error {
-}
-exports.TypeMistmatch = TypeMistmatch;
-class ExprString extends ExpressionDef {
-    constructor(value) {
-        super();
-        this.value = value;
-        this.elementType = "string literal";
-    }
-    getExpression(_fs) {
-        return { ...index_1.FT.stringT, value: [this.value] };
-    }
-}
-exports.ExprString = ExprString;
-class ExprNumber extends ExpressionDef {
-    constructor(n) {
-        super();
-        this.n = n;
-        this.elementType = "numeric literal";
-    }
-    getExpression(_fs) {
-        return this.constantExpression();
-    }
-    constantExpression() {
-        return { ...index_1.FT.numberT, value: [this.n] };
-    }
-}
-exports.ExprNumber = ExprNumber;
-class ExprRegEx extends ExpressionDef {
-    constructor(regex) {
-        super();
-        this.regex = regex;
-        this.elementType = "regular expression literal";
-    }
-    getExpression() {
-        return {
-            dataType: "regular expression",
-            aggregate: false,
-            value: [`r'${this.regex}'`],
-        };
-    }
-}
-exports.ExprRegEx = ExprRegEx;
-class ExprTime extends ExpressionDef {
-    constructor(timeType, value, aggregate = false) {
-        super();
-        this.elementType = "timestampOrDate";
-        this.elementType = timeType;
-        this.translationValue = {
-            dataType: timeType,
-            aggregate: aggregate,
-            value: typeof value === "string" ? [value] : value,
-        };
-    }
-    getExpression(_fs) {
-        return this.translationValue;
-    }
-    static fromValue(timeType, expr) {
-        let value = expr.value;
-        if (timeType != expr.dataType) {
-            const toTs = {
-                type: "dialect",
-                function: "cast",
-                safe: false,
-                dstType: timeType,
-                expr: expr.value,
-            };
-            if ((0, malloy_types_1.isTimeFieldType)(expr.dataType)) {
-                toTs.srcType = expr.dataType;
-            }
-            value = (0, index_1.compressExpr)([toTs]);
-        }
-        return new ExprTime(timeType, value, expr.aggregate);
-    }
-}
-exports.ExprTime = ExprTime;
-class Unary extends ExpressionDef {
-    constructor(expr) {
-        super({ expr });
-        this.expr = expr;
-    }
-}
-class ExprNot extends Unary {
-    constructor(expr) {
-        super(expr);
-        this.elementType = "not";
-        this.legalChildTypes = [index_1.FT.boolT, index_1.FT.nullT];
-    }
-    getExpression(fs) {
-        const notThis = this.expr.getExpression(fs);
-        if (this.typeCheck(this.expr, notThis)) {
-            return {
-                ...notThis,
-                dataType: "boolean",
-                value: (0, apply_expr_1.nullsafeNot)(notThis.value),
-            };
-        }
-        return (0, index_1.errorFor)("not requires boolean");
-    }
-}
-exports.ExprNot = ExprNot;
-class Boolean extends ExpressionDef {
-    constructor(value) {
-        super();
-        this.value = value;
-        this.elementType = "boolean literal";
-    }
-    getExpression() {
-        return { ...index_1.FT.boolT, value: [this.value] };
-    }
-}
-exports.Boolean = Boolean;
-class BinaryBoolean extends ExpressionDef {
-    constructor(left, op, right) {
-        super({ left, right });
-        this.left = left;
-        this.op = op;
-        this.right = right;
-        this.elementType = "abstract boolean binary";
-        this.legalChildTypes = [index_1.FT.boolT];
-    }
-    getExpression(fs) {
-        const left = this.left.getExpression(fs);
-        const right = this.right.getExpression(fs);
-        if (this.typeCheck(this.left, left) && this.typeCheck(this.right, right)) {
-            return {
-                dataType: "boolean",
-                aggregate: left.aggregate || right.aggregate,
-                value: (0, index_1.compose)(left.value, this.op, right.value),
-            };
-        }
-        return (0, index_1.errorFor)("logial required boolean");
-    }
-}
-exports.BinaryBoolean = BinaryBoolean;
-class ExprLogicalOp extends BinaryBoolean {
-    constructor() {
-        super(...arguments);
-        this.elementType = "logical operator";
-        this.legalChildTypes = [index_1.FT.boolT, { ...index_1.FT.boolT, aggregate: true }];
-    }
-}
-exports.ExprLogicalOp = ExprLogicalOp;
-class ExprIdReference extends ExpressionDef {
-    constructor(fieldReference) {
-        super();
-        this.fieldReference = fieldReference;
-        this.elementType = "ExpressionIdReference";
-        this.has({ fieldPath: fieldReference });
-    }
-    get refString() {
-        return this.fieldReference.refString;
-    }
-    getExpression(fs) {
-        const def = this.fieldReference.getField(fs);
-        if (def.found) {
-            // TODO if type is a query or a struct this should fail nicely
-            const typeMixin = def.found.type();
-            const dataType = typeMixin.type;
-            const aggregate = !!typeMixin.aggregate;
-            const value = [{ type: def.found.refType, path: this.refString }];
-            return { dataType, aggregate, value };
-        }
-        this.log(def.error);
-        return (0, index_1.errorFor)(def.error);
-    }
-    apply(fs, op, expr) {
-        const entry = this.fieldReference.getField(fs).found;
-        if (entry instanceof space_field_1.SpaceParam) {
-            const cParam = entry.parameter();
-            if ((0, malloy_types_1.isConditionParameter)(cParam)) {
-                const lval = expr.getExpression(fs);
-                return {
-                    dataType: "boolean",
-                    aggregate: lval.aggregate,
-                    value: [
-                        {
-                            type: "apply",
-                            value: lval.value,
-                            to: [{ type: "parameter", path: this.refString }],
-                        },
-                    ],
-                };
-            }
-        }
-        return super.apply(fs, op, expr);
-    }
-}
-exports.ExprIdReference = ExprIdReference;
-class ExprNULL extends ExpressionDef {
-    constructor() {
-        super(...arguments);
-        this.elementType = "NULL";
-    }
-    getExpression() {
-        return {
-            dataType: "null",
-            value: ["NULL"],
-            aggregate: false,
-        };
-    }
-}
-exports.ExprNULL = ExprNULL;
-class ExprParens extends ExpressionDef {
-    constructor(expr) {
-        super({ expr });
-        this.expr = expr;
-        this.elementType = "(expression)";
-    }
-    apply(fs, op, expr) {
-        return this.expr.apply(fs, op, expr);
-    }
-    requestExpression(fs) {
-        return this.expr.requestExpression(fs);
-    }
-    getExpression(fs) {
-        const subExpr = this.expr.getExpression(fs);
-        return { ...subExpr, value: ["(", ...subExpr.value, ")"] };
-    }
-}
-exports.ExprParens = ExprParens;
-class ExprMinus extends ExpressionDef {
-    constructor(expr) {
-        super({ expr });
-        this.expr = expr;
-        this.elementType = "unary minus";
-        this.legalChildTypes = [index_1.FT.numberT];
-    }
-    getExpression(fs) {
-        const expr = this.expr.getExpression(fs);
-        if (this.typeCheck(this.expr, expr)) {
-            if (expr.value.length > 1) {
-                return { ...expr, value: ["-(", ...expr.value, ")"] };
-            }
-            return { ...expr, value: ["-", ...expr.value] };
-        }
-        return (0, index_1.errorFor)("negate requires number");
-    }
-}
-exports.ExprMinus = ExprMinus;
-class BinaryNumeric extends ExpressionDef {
-    constructor(left, op, right) {
-        super({ left, right });
-        this.left = left;
-        this.op = op;
-        this.right = right;
-        this.elementType = "numeric binary abstract";
-        this.legalChildTypes = [index_1.FT.numberT];
-    }
-    getExpression(fs) {
-        return this.right.apply(fs, this.op, this.left);
-    }
-}
-exports.BinaryNumeric = BinaryNumeric;
-class ExprAddSub extends BinaryNumeric {
-    constructor() {
-        super(...arguments);
-        this.elementType = "+-";
-    }
-}
-exports.ExprAddSub = ExprAddSub;
-class ExprMulDiv extends BinaryNumeric {
-    constructor() {
-        super(...arguments);
-        this.elementType = "*/";
-    }
-}
-exports.ExprMulDiv = ExprMulDiv;
-class ExprAlternationTree extends BinaryBoolean {
-    constructor(left, op, right) {
-        super(left, op, right);
-        this.elementType = "alternation";
-        this.elementType = `${op}alternation${op}`;
-    }
-    apply(fs, applyOp, expr) {
-        const choice1 = this.left.apply(fs, applyOp, expr);
-        const choice2 = this.right.apply(fs, applyOp, expr);
-        return {
-            dataType: "boolean",
-            aggregate: choice1.aggregate || choice2.aggregate,
-            value: (0, index_1.compose)(choice1.value, this.op === "&" ? "and" : "or", choice2.value),
-        };
-    }
-    requestExpression(_fs) {
-        return undefined;
-    }
-    getExpression(_fs) {
-        this.log(`Alternation tree has no value`);
-        return (0, index_1.errorFor)("no value from alternation tree");
-    }
-}
-exports.ExprAlternationTree = ExprAlternationTree;
-class ExprAggregateFunction extends ExpressionDef {
-    constructor(func, expr) {
-        super();
-        this.func = func;
-        this.legalChildTypes = [index_1.FT.numberT];
-        this.elementType = func;
-        if (expr) {
-            this.expr = expr;
-            this.has({ expr });
-        }
-    }
-    returns(_forExpression) {
-        return "number";
-    }
-    getExpression(fs) {
-        var _a, _b;
-        let exprVal = (_a = this.expr) === null || _a === void 0 ? void 0 : _a.getExpression(fs);
-        let structPath = (_b = this.source) === null || _b === void 0 ? void 0 : _b.refString;
-        if (this.source) {
-            const sourceFoot = this.source.getField(fs).found;
-            if (sourceFoot) {
-                const footType = sourceFoot.type();
-                if ((0, malloy_types_1.isAtomicFieldType)(footType.type)) {
-                    exprVal = {
-                        dataType: footType.type,
-                        aggregate: !!footType.aggregate,
-                        value: [{ type: "field", path: this.source.refString }],
-                    };
-                    structPath = this.source.sourceString;
-                }
-                else {
-                    if (!(sourceFoot instanceof space_field_1.StructSpaceField)) {
-                        this.log(`Aggregate source cannot be a ${footType.type}`);
-                        return (0, index_1.errorFor)(`Aggregate source cannot be a ${footType.type}`);
-                    }
-                }
-            }
-            else {
-                this.log(`Reference to undefined value ${this.source.refString}`);
-                return (0, index_1.errorFor)(`Reference to undefined value ${this.source.refString}`);
-            }
-        }
-        if (exprVal === undefined) {
-            this.log("Missing expression for aggregate function");
-            return (0, index_1.errorFor)("agggregate without expression");
-        }
-        if (this.typeCheck(this.expr || this, { ...exprVal, aggregate: false })) {
-            const f = {
-                type: "aggregate",
-                function: this.func,
-                e: exprVal.value,
-            };
-            if (structPath) {
-                f.structPath = structPath;
-            }
-            return {
-                dataType: this.returns(exprVal),
-                aggregate: true,
-                value: [f],
-            };
-        }
-        return (0, index_1.errorFor)("aggregate type check");
-    }
-}
-class ExprMin extends ExprAggregateFunction {
-    constructor(expr) {
-        super("min", expr);
-        this.legalChildTypes = [index_1.FT.numberT, index_1.FT.stringT, index_1.FT.dateT, index_1.FT.timestampT];
-    }
-    returns(forExpression) {
-        return forExpression.dataType;
-    }
-}
-exports.ExprMin = ExprMin;
-class ExprMax extends ExprAggregateFunction {
-    constructor(expr) {
-        super("max", expr);
-        this.legalChildTypes = [index_1.FT.numberT, index_1.FT.stringT, index_1.FT.dateT, index_1.FT.timestampT];
-    }
-    returns(forExpression) {
-        return forExpression.dataType;
-    }
-}
-exports.ExprMax = ExprMax;
-class ExprCountDistinct extends ExprAggregateFunction {
-    constructor(expr) {
-        super("count_distinct", expr);
-        this.legalChildTypes = [index_1.FT.numberT, index_1.FT.stringT, index_1.FT.dateT, index_1.FT.timestampT];
-    }
-}
-exports.ExprCountDistinct = ExprCountDistinct;
-class ExprAsymmetric extends ExprAggregateFunction {
-    constructor(func, expr, source) {
-        super(func, expr);
-        this.func = func;
-        this.expr = expr;
-        this.source = source;
-        this.has({ source });
-    }
-    defaultFieldName() {
-        if (this.source && this.expr === undefined) {
-            const tag = this.source.nameString;
-            switch (this.func) {
-                case "sum":
-                    return `total_${tag}`;
-                case "avg":
-                    return `avg_${tag}`;
-            }
-        }
-        return undefined;
-    }
-}
-class ExprCount extends ExprAggregateFunction {
-    constructor(source) {
-        super("count");
-        this.source = source;
-        this.elementType = "count";
-        this.has({ source });
-    }
-    defaultFieldName() {
-        if (this.source) {
-            return "count_" + this.source.nameString;
-        }
-        return undefined;
-    }
-    getExpression(_fs) {
-        const ret = {
-            type: "aggregate",
-            function: "count",
-            e: [],
-        };
-        if (this.source) {
-            ret.structPath = this.source.refString;
-        }
-        return {
-            dataType: "number",
-            aggregate: true,
-            value: [ret],
-        };
-    }
-}
-exports.ExprCount = ExprCount;
-class ExprAvg extends ExprAsymmetric {
-    constructor(expr, source) {
-        super("avg", expr, source);
-        this.has({ source });
-    }
-}
-exports.ExprAvg = ExprAvg;
-class ExprSum extends ExprAsymmetric {
-    constructor(expr, source) {
-        super("sum", expr, source);
-        this.has({ source });
-    }
-}
-exports.ExprSum = ExprSum;
-class ExprUngroup extends ExpressionDef {
-    constructor(control, expr, fields) {
-        super({ expr, fields });
-        this.control = control;
-        this.expr = expr;
-        this.fields = fields;
-        this.legalChildTypes = index_1.FT.anyAtomicT;
-        this.elementType = "ungroup";
-    }
-    returns(_forExpression) {
-        return "number";
-    }
-    getExpression(fs) {
-        const exprVal = this.expr.getExpression(fs);
-        if (!exprVal.aggregate) {
-            this.expr.log(`${this.control}() expression must be an aggregate`);
-            return (0, index_1.errorFor)("ungrouped scalar");
-        }
-        const ungroup = { type: this.control, e: exprVal.value };
-        if (this.typeCheck(this.expr, { ...exprVal, aggregate: false })) {
-            if (this.fields.length > 0) {
-                let qs = fs;
-                if (fs instanceof field_space_1.DefSpace) {
-                    qs = fs.realFS;
-                }
-                if (!(qs instanceof field_space_1.QuerySpace)) {
-                    this.log(`${this.control}() must be in a query -- weird internal error`);
-                    return (0, index_1.errorFor)("ungroup query check");
-                }
-                const output = qs.result;
-                const dstFields = [];
-                const isExclude = this.control == "exclude";
-                for (const mustBeInOutput of this.fields) {
-                    output.whenComplete(() => {
-                        output.checkUngroup(mustBeInOutput, isExclude);
-                    });
-                    dstFields.push(mustBeInOutput.refString);
-                }
-                ungroup.fields = dstFields;
-            }
-            return {
-                dataType: this.returns(exprVal),
-                aggregate: true,
-                value: [ungroup],
-            };
-        }
-        this.log(`${this.control}() incompatible type`);
-        return (0, index_1.errorFor)("ungrouped type check");
-    }
-}
-exports.ExprUngroup = ExprUngroup;
-class WhenClause extends ExpressionDef {
-    constructor(whenThis, thenThis) {
-        super({ whenThis, thenThis });
-        this.whenThis = whenThis;
-        this.thenThis = thenThis;
-        this.elementType = "when clause";
-    }
-    getExpression(_fs) {
-        throw new Error("expression did something unxpected with 'WHEN'");
-    }
-}
-exports.WhenClause = WhenClause;
-class ExprCase extends ExpressionDef {
-    constructor(when, elseClause) {
-        super({ when });
-        this.when = when;
-        this.elseClause = elseClause;
-        this.elementType = "case statement";
-        this.has({ elseClause });
-    }
-    getExpression(fs) {
-        let retType;
-        let aggregate = false;
-        const caseExpr = ["CASE "];
-        for (const clause of this.when) {
-            const whenExpr = clause.whenThis.getExpression(fs);
-            const thenExpr = clause.thenThis.getExpression(fs);
-            aggregate || (aggregate = whenExpr.aggregate || thenExpr.aggregate);
-            if (thenExpr.dataType !== "null") {
-                if (retType && !index_1.FT.typeEq(retType, thenExpr)) {
-                    this.log(`Mismatched THEN clause types, ${index_1.FT.inspect(retType, thenExpr)}`);
-                    return (0, index_1.errorFor)("then typecheck");
-                }
-                else {
-                    retType = thenExpr;
-                }
-            }
-            caseExpr.push("WHEN ", ...whenExpr.value, " THEN ", ...thenExpr.value);
-        }
-        if (this.elseClause) {
-            const elseExpr = this.elseClause.getExpression(fs);
-            aggregate || (aggregate = elseExpr.aggregate);
-            caseExpr.push(" ELSE ", ...elseExpr.value);
-            if (elseExpr.dataType !== "null") {
-                if (retType && !index_1.FT.typeEq(retType, elseExpr)) {
-                    this.log(`Mismatched ELSE clause type, ${index_1.FT.inspect(retType, elseExpr)}`);
-                    return (0, index_1.errorFor)("else typecheck");
-                }
-                else {
-                    retType = elseExpr;
-                }
-            }
-        }
-        if (retType === undefined) {
-            this.log("case statement type not computable");
-            return (0, index_1.errorFor)("typeless case");
-        }
-        caseExpr.push(" END");
-        return {
-            dataType: retType.dataType,
-            aggregate: aggregate,
-            value: caseExpr,
-        };
-    }
-}
-exports.ExprCase = ExprCase;
-class ExprFilter extends ExpressionDef {
-    constructor(expr, filter) {
-        super({ expr, filter });
-        this.expr = expr;
-        this.filter = filter;
-        this.elementType = "filtered expression";
-        this.legalChildTypes = index_1.FT.anyAtomicT;
-    }
-    getExpression(fs) {
-        const testList = this.filter.getFilterList(fs);
-        const resultExpr = this.expr.getExpression(fs);
-        for (const cond of testList) {
-            if (cond.aggregate) {
-                this.filter.log("Cannot filter a field with an aggregate computation");
-                return (0, index_1.errorFor)("no filter on aggregate");
-            }
-        }
-        if (!resultExpr.aggregate) {
-            // TODO could log a warning, but I have a problem with the
-            // idea of warnings, so for now ...
-            return resultExpr;
-        }
-        if (this.typeCheck(this.expr, { ...resultExpr, aggregate: false })) {
-            return {
-                ...resultExpr,
-                value: [
-                    {
-                        type: "filterExpression",
-                        e: resultExpr.value,
-                        filterList: testList,
-                    },
-                ],
-            };
-        }
-        this.expr.log(`Cannot filter '${resultExpr.dataType}' data`);
-        return (0, index_1.errorFor)("cannot filter type");
-    }
-}
-exports.ExprFilter = ExprFilter;
-function isCastType(t) {
-    return ["string", "number", "boolean", "date", "timestamp"].includes(t);
-}
-exports.isCastType = isCastType;
-class ExprCast extends ExpressionDef {
-    constructor(expr, castType, safe = false) {
-        super({ expr });
-        this.expr = expr;
-        this.castType = castType;
-        this.safe = safe;
-        this.elementType = "cast";
-    }
-    getExpression(fs) {
-        const expr = this.expr.getExpression(fs);
-        return {
-            dataType: this.castType,
-            aggregate: expr.aggregate,
-            value: (0, index_1.compressExpr)((0, time_utils_1.castTo)(this.castType, expr.value, this.safe)),
-        };
-    }
-}
-exports.ExprCast = ExprCast;
-class TopBy extends index_1.MalloyElement {
-    constructor(by) {
-        super();
-        this.by = by;
-        this.elementType = "topBy";
-        if (by instanceof ExpressionDef) {
-            this.has({ by });
-        }
-    }
-    getBy(fs) {
-        if (this.by instanceof ExpressionDef) {
-            const byExpr = this.by.getExpression(fs);
-            if (!byExpr.aggregate) {
-                this.log("top by expression must be an aggregate");
-            }
-            return { by: "expression", e: (0, index_1.compressExpr)(byExpr.value) };
-        }
-        return { by: "name", name: this.by };
-    }
-}
-exports.TopBy = TopBy;
-class Range extends ExpressionDef {
-    constructor(first, last) {
-        super({ first, last });
-        this.first = first;
-        this.last = last;
-        this.elementType = "range";
-    }
-    apply(fs, op, expr) {
-        switch (op) {
-            case "=":
-            case "!=": {
-                const op1 = op === "=" ? ">=" : "<";
-                const op2 = op === "=" ? "and" : "or";
-                const op3 = op === "=" ? "<" : ">=";
-                const fromValue = this.first.apply(fs, op1, expr);
-                const toValue = this.last.apply(fs, op3, expr);
-                return {
-                    dataType: "boolean",
-                    aggregate: fromValue.aggregate || toValue.aggregate,
-                    value: (0, index_1.compose)(fromValue.value, op2, toValue.value),
-                };
-            }
-            /**
-             * This is a little surprising, but is actually how you comapre a
-             * value to a range ...
-             *
-             * val > begin to end     val >= end
-             * val >= begin to end    val >= begin
-             * val < begin to end     val < begin
-             * val <= begin to end    val < end
-             */
-            case ">":
-                return this.last.apply(fs, ">=", expr);
-            case ">=":
-                return this.first.apply(fs, ">=", expr);
-            case "<":
-                return this.first.apply(fs, "<", expr);
-            case "<=":
-                return this.last.apply(fs, "<", expr);
-        }
-        throw new Error("mysterious error in range computation");
-    }
-    requestExpression(_fs) {
-        return undefined;
-    }
-    getExpression(_fs) {
-        return (0, index_1.errorFor)("a range is not a value");
-    }
-}
-exports.Range = Range;
-class PickWhen extends index_1.MalloyElement {
-    constructor(pick, when) {
-        super({ when });
-        this.pick = pick;
-        this.when = when;
-        this.elementType = "pickWhen";
-        this.has({ pick });
-    }
-}
-exports.PickWhen = PickWhen;
-class Pick extends ExpressionDef {
-    constructor(choices, elsePick) {
-        super({ choices });
-        this.choices = choices;
-        this.elsePick = elsePick;
-        this.elementType = "pick";
-        this.has({ elsePick });
-    }
-    requestExpression(fs) {
-        // pick statements are sometimes partials which must be applied
-        // and sometimes have a value.
-        if (this.elsePick === undefined) {
-            return undefined;
-        }
-        for (const c of this.choices) {
-            if (c.pick == undefined) {
-                return undefined;
-            }
-            const whenResp = c.when.requestExpression(fs);
-            if (whenResp == undefined || whenResp.dataType != "boolean") {
-                // If when is not a boolean, we'll treat it like a partial compare
-                return undefined;
-            }
-        }
-        return this.getExpression(fs);
-    }
-    apply(fs, op, expr) {
-        const caseValue = ["CASE"];
-        let returnType;
-        let anyAggregate = false;
-        for (const choice of this.choices) {
-            const whenExpr = choice.when.apply(fs, "=", expr);
-            const thenExpr = choice.pick
-                ? choice.pick.getExpression(fs)
-                : expr.getExpression(fs);
-            anyAggregate || (anyAggregate = whenExpr.aggregate || thenExpr.aggregate);
-            if (returnType) {
-                if (!index_1.FT.typeEq(returnType, thenExpr, true)) {
-                    const whenType = index_1.FT.inspect(thenExpr);
-                    this.log(`pick type '${whenType}', expected '${returnType.dataType}'`);
-                    return (0, index_1.errorFor)("pick when type");
-                }
-            }
-            else {
-                returnType = thenExpr;
-            }
-            caseValue.push(" WHEN ", ...whenExpr.value, " THEN ", ...thenExpr.value);
-        }
-        const elsePart = this.elsePick || expr;
-        const elseVal = elsePart.getExpression(fs);
-        returnType || (returnType = elseVal);
-        if (!index_1.FT.typeEq(returnType, elseVal, true)) {
-            const errSrc = this.elsePick ? "else" : "pick default";
-            this.log(`${errSrc} type '${index_1.FT.inspect(elseVal)}', expected '${returnType.dataType}'`);
-            return (0, index_1.errorFor)("pick else type");
-        }
-        return {
-            dataType: returnType.dataType,
-            aggregate: anyAggregate || elseVal.aggregate,
-            value: (0, index_1.compressExpr)([...caseValue, " ELSE ", ...elseVal.value, " END"]),
-        };
-    }
-    getExpression(fs) {
-        if (this.elsePick === undefined) {
-            this.log("pick incomplete, missing 'else'");
-            return (0, index_1.errorFor)("no value for partial pick");
-        }
-        const choiceValues = [];
-        for (const c of this.choices) {
-            if (c.pick === undefined) {
-                this.log("pick with no value can only be used with apply");
-                return (0, index_1.errorFor)("no value for partial pick");
-            }
-            const pickWhen = c.when.requestExpression(fs);
-            if (pickWhen === undefined) {
-                this.log("pick with partial when can only be used with apply");
-                return (0, index_1.errorFor)("partial when");
-            }
-            choiceValues.push({
-                pick: c.pick.getExpression(fs),
-                when: c.when.getExpression(fs),
-            });
-        }
-        const returnType = choiceValues[0].pick;
-        const caseValue = ["CASE"];
-        let anyAggregate = returnType.aggregate;
-        for (const aChoice of choiceValues) {
-            if (!index_1.FT.typeEq(aChoice.when, index_1.FT.boolT)) {
-                this.log(`when expression must be boolean, not '${index_1.FT.inspect(aChoice.when)}`);
-                return (0, index_1.errorFor)("pick when type");
-            }
-            if (!index_1.FT.typeEq(returnType, aChoice.pick, true)) {
-                const whenType = index_1.FT.inspect(aChoice.pick);
-                this.log(`pick type '${whenType}', expected '${returnType.dataType}'`);
-                return (0, index_1.errorFor)("pick value type");
-            }
-            anyAggregate || (anyAggregate = aChoice.pick.aggregate || aChoice.when.aggregate);
-            caseValue.push(" WHEN ", ...aChoice.when.value, " THEN ", ...aChoice.pick.value);
-        }
-        const defVal = this.elsePick.getExpression(fs);
-        anyAggregate || (anyAggregate = defVal.aggregate);
-        if (!index_1.FT.typeEq(returnType, defVal, true)) {
-            this.elsePick.log(`else type '${index_1.FT.inspect(defVal)}', expected '${returnType.dataType}'`);
-            return (0, index_1.errorFor)("pick value type mismatch");
-        }
-        caseValue.push(" ELSE ", ...defVal.value, " END");
-        return {
-            dataType: returnType.dataType,
-            aggregate: !!anyAggregate,
-            value: (0, index_1.compressExpr)(caseValue),
-        };
-    }
-}
-exports.Pick = Pick;
-//# sourceMappingURL=ast-expr.js.map