@malloydata/malloy 0.0.22-dev230126015148 → 0.0.22-dev230202171033

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

@@ -1,781 +0,0 @@
-"use strict";
-/*
- * Copyright 2023 Google LLC
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files
- * (the "Software"), to deal in the Software without restriction,
- * including without limitation the rights to use, copy, modify, merge,
- * publish, distribute, sublicense, and/or sell copies of the Software,
- * and to permit persons to whom the Software is furnished to do so,
- * subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
- * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Apply = exports.Pick = exports.PickWhen = 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.Boolean = exports.ExprNot = exports.ExprRegEx = exports.ExprNumber = exports.ExprString = void 0;
-/*
- ** This file is the general framework for expression nodes and expression
- ** evaluation.
- */
-const malloy_types_1 = require("../../model/malloy_types");
-const ast_main_1 = require("./ast-main");
-const ast_types_1 = require("./ast-types");
-const apply_expr_1 = require("./apply-expr");
-const time_utils_1 = require("./time-utils");
-class ExprString extends ast_main_1.ExpressionDef {
-    constructor(src) {
-        super();
-        this.elementType = "string literal";
-        const bareStr = src.slice(1, -1);
-        const val = bareStr.replace(/\\(.)/g, "$1");
-        this.value = val;
-    }
-    getExpression(_fs) {
-        return {
-            ...ast_types_1.FT.stringT,
-            value: [
-                {
-                    type: "dialect",
-                    function: "stringLiteral",
-                    literal: this.value,
-                },
-            ],
-        };
-    }
-}
-exports.ExprString = ExprString;
-class ExprNumber extends ast_main_1.ExpressionDef {
-    constructor(n) {
-        super();
-        this.n = n;
-        this.elementType = "numeric literal";
-    }
-    getExpression(_fs) {
-        return this.constantExpression();
-    }
-    constantExpression() {
-        return { ...ast_types_1.FT.numberT, value: [this.n] };
-    }
-}
-exports.ExprNumber = ExprNumber;
-class ExprRegEx extends ast_main_1.ExpressionDef {
-    constructor(regex) {
-        super();
-        this.regex = regex;
-        this.elementType = "regular expression literal";
-    }
-    getExpression() {
-        return {
-            dataType: "regular expression",
-            expressionType: "scalar",
-            value: [`r'${this.regex}'`],
-        };
-    }
-}
-exports.ExprRegEx = ExprRegEx;
-class Unary extends ast_main_1.ExpressionDef {
-    constructor(expr) {
-        super({ expr });
-        this.expr = expr;
-    }
-}
-class ExprNot extends Unary {
-    constructor(expr) {
-        super(expr);
-        this.elementType = "not";
-        this.legalChildTypes = [ast_types_1.FT.boolT, ast_types_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, ast_types_1.errorFor)("not requires boolean");
-    }
-}
-exports.ExprNot = ExprNot;
-class Boolean extends ast_main_1.ExpressionDef {
-    constructor(value) {
-        super();
-        this.value = value;
-        this.elementType = "boolean literal";
-    }
-    getExpression() {
-        return { ...ast_types_1.FT.boolT, value: [this.value] };
-    }
-}
-exports.Boolean = Boolean;
-class ExprLogicalOp extends ast_main_1.BinaryBoolean {
-    constructor() {
-        super(...arguments);
-        this.elementType = "logical operator";
-        this.legalChildTypes = [ast_types_1.FT.boolT, { ...ast_types_1.FT.boolT, aggregate: true }];
-    }
-}
-exports.ExprLogicalOp = ExprLogicalOp;
-class ExprIdReference extends ast_main_1.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 expressionType = typeMixin.expressionType || "scalar";
-            const value = [{ type: def.found.refType, path: this.refString }];
-            return { dataType, expressionType, value };
-        }
-        this.log(def.error);
-        return (0, ast_types_1.errorFor)(def.error);
-    }
-    apply(fs, op, expr) {
-        const entry = this.fieldReference.getField(fs).found;
-        if (entry instanceof ast_main_1.SpaceParam) {
-            const cParam = entry.parameter();
-            if ((0, malloy_types_1.isConditionParameter)(cParam)) {
-                const lval = expr.getExpression(fs);
-                return {
-                    dataType: "boolean",
-                    expressionType: lval.expressionType,
-                    value: [
-                        {
-                            type: "apply",
-                            value: lval.value,
-                            to: [{ type: "parameter", path: this.refString }],
-                        },
-                    ],
-                };
-            }
-        }
-        return super.apply(fs, op, expr);
-    }
-}
-exports.ExprIdReference = ExprIdReference;
-class ExprNULL extends ast_main_1.ExpressionDef {
-    constructor() {
-        super(...arguments);
-        this.elementType = "NULL";
-    }
-    getExpression() {
-        return {
-            dataType: "null",
-            value: ["NULL"],
-            expressionType: "scalar",
-        };
-    }
-}
-exports.ExprNULL = ExprNULL;
-class ExprParens extends ast_main_1.ExpressionDef {
-    constructor(expr) {
-        super({ expr });
-        this.expr = expr;
-        this.elementType = "(expression)";
-    }
-    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 ast_main_1.ExpressionDef {
-    constructor(expr) {
-        super({ expr });
-        this.expr = expr;
-        this.elementType = "unary minus";
-        this.legalChildTypes = [ast_types_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, ast_types_1.errorFor)("negate requires number");
-    }
-}
-exports.ExprMinus = ExprMinus;
-class BinaryNumeric extends ast_main_1.ExpressionDef {
-    constructor(left, op, right) {
-        super({ left, right });
-        this.left = left;
-        this.op = op;
-        this.right = right;
-        this.elementType = "numeric binary abstract";
-        this.legalChildTypes = [ast_types_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 ast_main_1.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",
-            expressionType: (0, malloy_types_1.maxExpressionType)(choice1.expressionType, choice2.expressionType),
-            value: (0, ast_types_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, ast_types_1.errorFor)("no value from alternation tree");
-    }
-}
-exports.ExprAlternationTree = ExprAlternationTree;
-class ExprAggregateFunction extends ast_main_1.ExpressionDef {
-    constructor(func, expr) {
-        super();
-        this.func = func;
-        this.legalChildTypes = [ast_types_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,
-                        expressionType: footType.expressionType || "scalar",
-                        value: [{ type: "field", path: this.source.refString }],
-                    };
-                    structPath = this.source.sourceString;
-                }
-                else {
-                    if (!(sourceFoot instanceof ast_main_1.StructSpaceField)) {
-                        this.log(`Aggregate source cannot be a ${footType.type}`);
-                        return (0, ast_types_1.errorFor)(`Aggregate source cannot be a ${footType.type}`);
-                    }
-                }
-            }
-            else {
-                this.log(`Reference to undefined value ${this.source.refString}`);
-                return (0, ast_types_1.errorFor)(`Reference to undefined value ${this.source.refString}`);
-            }
-        }
-        if (exprVal === undefined) {
-            this.log("Missing expression for aggregate function");
-            return (0, ast_types_1.errorFor)("agggregate without expression");
-        }
-        if (this.typeCheck(this.expr || this, {
-            ...exprVal,
-            expressionType: "scalar",
-        })) {
-            const f = {
-                type: "aggregate",
-                function: this.func,
-                e: exprVal.value,
-            };
-            if (structPath) {
-                f.structPath = structPath;
-            }
-            return {
-                dataType: this.returns(exprVal),
-                expressionType: "aggregate",
-                value: [f],
-            };
-        }
-        return (0, ast_types_1.errorFor)("aggregate type check");
-    }
-}
-class ExprMin extends ExprAggregateFunction {
-    constructor(expr) {
-        super("min", expr);
-        this.legalChildTypes = [ast_types_1.FT.numberT, ast_types_1.FT.stringT, ast_types_1.FT.dateT, ast_types_1.FT.timestampT];
-    }
-    returns(forExpression) {
-        return forExpression.dataType;
-    }
-}
-exports.ExprMin = ExprMin;
-class ExprMax extends ExprAggregateFunction {
-    constructor(expr) {
-        super("max", expr);
-        this.legalChildTypes = [ast_types_1.FT.numberT, ast_types_1.FT.stringT, ast_types_1.FT.dateT, ast_types_1.FT.timestampT];
-    }
-    returns(forExpression) {
-        return forExpression.dataType;
-    }
-}
-exports.ExprMax = ExprMax;
-class ExprCountDistinct extends ExprAggregateFunction {
-    constructor(expr) {
-        super("count_distinct", expr);
-        this.legalChildTypes = [ast_types_1.FT.numberT, ast_types_1.FT.stringT, ast_types_1.FT.dateT, ast_types_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",
-            expressionType: "aggregate",
-            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 ast_main_1.ExpressionDef {
-    constructor(control, expr, fields) {
-        super({ expr, fields });
-        this.control = control;
-        this.expr = expr;
-        this.fields = fields;
-        this.legalChildTypes = ast_types_1.FT.anyAtomicT;
-        this.elementType = "ungroup";
-    }
-    returns(_forExpression) {
-        return "number";
-    }
-    getExpression(fs) {
-        const exprVal = this.expr.getExpression(fs);
-        if (!(0, malloy_types_1.expressionIsAggregate)(exprVal.expressionType)) {
-            this.expr.log(`${this.control}() expression must be an aggregate`);
-            return (0, ast_types_1.errorFor)("ungrouped scalar");
-        }
-        const ungroup = { type: this.control, e: exprVal.value };
-        if (this.typeCheck(this.expr, { ...exprVal, expressionType: "scalar" })) {
-            if (this.fields.length > 0) {
-                let qs = fs;
-                if (fs instanceof ast_main_1.DefSpace) {
-                    qs = fs.realFS;
-                }
-                if (!(qs instanceof ast_main_1.QuerySpace)) {
-                    this.log(`${this.control}() must be in a query -- weird internal error`);
-                    return (0, ast_types_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),
-                expressionType: "analytic",
-                value: [ungroup],
-            };
-        }
-        this.log(`${this.control}() incompatible type`);
-        return (0, ast_types_1.errorFor)("ungrouped type check");
-    }
-}
-exports.ExprUngroup = ExprUngroup;
-class WhenClause extends ast_main_1.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 ast_main_1.ExpressionDef {
-    constructor(when, elseClause) {
-        super({ when });
-        this.when = when;
-        this.elseClause = elseClause;
-        this.elementType = "case statement";
-        this.has({ elseClause });
-    }
-    getExpression(fs) {
-        let retType;
-        let expressionType = "scalar";
-        const caseExpr = ["CASE "];
-        for (const clause of this.when) {
-            const whenExpr = clause.whenThis.getExpression(fs);
-            const thenExpr = clause.thenThis.getExpression(fs);
-            expressionType = (0, malloy_types_1.maxExpressionType)(expressionType, (0, malloy_types_1.maxExpressionType)(whenExpr.expressionType, thenExpr.expressionType));
-            if (thenExpr.dataType !== "null") {
-                if (retType && !ast_types_1.FT.typeEq(retType, thenExpr)) {
-                    this.log(`Mismatched THEN clause types, ${ast_types_1.FT.inspect(retType, thenExpr)}`);
-                    return (0, ast_types_1.errorFor)("then typecheck");
-                }
-                else {
-                    retType = thenExpr;
-                }
-            }
-            caseExpr.push("WHEN ", ...whenExpr.value, " THEN ", ...thenExpr.value);
-        }
-        if (this.elseClause) {
-            const elseExpr = this.elseClause.getExpression(fs);
-            expressionType = (0, malloy_types_1.maxExpressionType)(expressionType, elseExpr.expressionType);
-            caseExpr.push(" ELSE ", ...elseExpr.value);
-            if (elseExpr.dataType !== "null") {
-                if (retType && !ast_types_1.FT.typeEq(retType, elseExpr)) {
-                    this.log(`Mismatched ELSE clause type, ${ast_types_1.FT.inspect(retType, elseExpr)}`);
-                    return (0, ast_types_1.errorFor)("else typecheck");
-                }
-                else {
-                    retType = elseExpr;
-                }
-            }
-        }
-        if (retType === undefined) {
-            this.log("case statement type not computable");
-            return (0, ast_types_1.errorFor)("typeless case");
-        }
-        caseExpr.push(" END");
-        return {
-            dataType: retType.dataType,
-            expressionType,
-            value: caseExpr,
-        };
-    }
-}
-exports.ExprCase = ExprCase;
-class ExprFilter extends ast_main_1.ExpressionDef {
-    constructor(expr, filter) {
-        super({ expr, filter });
-        this.expr = expr;
-        this.filter = filter;
-        this.elementType = "filtered expression";
-        this.legalChildTypes = ast_types_1.FT.anyAtomicT;
-    }
-    getExpression(fs) {
-        const testList = this.filter.getFilterList(fs);
-        const resultExpr = this.expr.getExpression(fs);
-        for (const cond of testList) {
-            if ((0, malloy_types_1.expressionIsCalculation)(cond.expressionType)) {
-                this.filter.log("Cannot filter a field with an aggregate or analytical computation");
-                return (0, ast_types_1.errorFor)("no filter on aggregate");
-            }
-        }
-        if (resultExpr.expressionType === "scalar") {
-            // 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, expressionType: "scalar" })) {
-            return {
-                ...resultExpr,
-                value: [
-                    {
-                        type: "filterExpression",
-                        e: resultExpr.value,
-                        filterList: testList,
-                    },
-                ],
-            };
-        }
-        this.expr.log(`Cannot filter '${resultExpr.dataType}' data`);
-        return (0, ast_types_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 ast_main_1.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,
-            expressionType: expr.expressionType,
-            value: (0, ast_types_1.compressExpr)((0, time_utils_1.castTo)(this.castType, expr.value, this.safe)),
-        };
-    }
-}
-exports.ExprCast = ExprCast;
-class TopBy extends ast_main_1.MalloyElement {
-    constructor(by) {
-        super();
-        this.by = by;
-        this.elementType = "topBy";
-        if (by instanceof ast_main_1.ExpressionDef) {
-            this.has({ by });
-        }
-    }
-    getBy(fs) {
-        if (this.by instanceof ast_main_1.ExpressionDef) {
-            const byExpr = this.by.getExpression(fs);
-            if (!(0, malloy_types_1.expressionIsAggregate)(byExpr.expressionType)) {
-                this.log("top by expression must be an aggregate");
-            }
-            return { by: "expression", e: (0, ast_types_1.compressExpr)(byExpr.value) };
-        }
-        return { by: "name", name: this.by };
-    }
-}
-exports.TopBy = TopBy;
-class PickWhen extends ast_main_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 ast_main_1.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 anyExpressionType = "scalar";
-        for (const choice of this.choices) {
-            const whenExpr = choice.when.apply(fs, "=", expr);
-            const thenExpr = choice.pick
-                ? choice.pick.getExpression(fs)
-                : expr.getExpression(fs);
-            anyExpressionType = (0, malloy_types_1.maxExpressionType)(anyExpressionType, (0, malloy_types_1.maxExpressionType)(whenExpr.expressionType, thenExpr.expressionType));
-            if (returnType) {
-                if (!ast_types_1.FT.typeEq(returnType, thenExpr, true)) {
-                    const whenType = ast_types_1.FT.inspect(thenExpr);
-                    this.log(`pick type '${whenType}', expected '${returnType.dataType}'`);
-                    return (0, ast_types_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 (!ast_types_1.FT.typeEq(returnType, elseVal, true)) {
-            const errSrc = this.elsePick ? "else" : "pick default";
-            this.log(`${errSrc} type '${ast_types_1.FT.inspect(elseVal)}', expected '${returnType.dataType}'`);
-            return (0, ast_types_1.errorFor)("pick else type");
-        }
-        return {
-            dataType: returnType.dataType,
-            expressionType: (0, malloy_types_1.maxExpressionType)(anyExpressionType, elseVal.expressionType),
-            value: (0, ast_types_1.compressExpr)([...caseValue, " ELSE ", ...elseVal.value, " END"]),
-        };
-    }
-    getExpression(fs) {
-        if (this.elsePick === undefined) {
-            this.log("pick incomplete, missing 'else'");
-            return (0, ast_types_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, ast_types_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, ast_types_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 anyExpressionType = returnType.expressionType;
-        for (const aChoice of choiceValues) {
-            if (!ast_types_1.FT.typeEq(aChoice.when, ast_types_1.FT.boolT)) {
-                this.log(`when expression must be boolean, not '${ast_types_1.FT.inspect(aChoice.when)}`);
-                return (0, ast_types_1.errorFor)("pick when type");
-            }
-            if (!ast_types_1.FT.typeEq(returnType, aChoice.pick, true)) {
-                const whenType = ast_types_1.FT.inspect(aChoice.pick);
-                this.log(`pick type '${whenType}', expected '${returnType.dataType}'`);
-                return (0, ast_types_1.errorFor)("pick value type");
-            }
-            anyExpressionType = (0, malloy_types_1.maxExpressionType)(anyExpressionType, (0, malloy_types_1.maxExpressionType)(aChoice.pick.expressionType, aChoice.when.expressionType));
-            caseValue.push(" WHEN ", ...aChoice.when.value, " THEN ", ...aChoice.pick.value);
-        }
-        const defVal = this.elsePick.getExpression(fs);
-        anyExpressionType = (0, malloy_types_1.maxExpressionType)(anyExpressionType, defVal.expressionType);
-        if (!ast_types_1.FT.typeEq(returnType, defVal, true)) {
-            this.elsePick.log(`else type '${ast_types_1.FT.inspect(defVal)}', expected '${returnType.dataType}'`);
-            return (0, ast_types_1.errorFor)("pick value type mismatch");
-        }
-        caseValue.push(" ELSE ", ...defVal.value, " END");
-        return {
-            dataType: returnType.dataType,
-            expressionType: anyExpressionType,
-            value: (0, ast_types_1.compressExpr)(caseValue),
-        };
-    }
-}
-exports.Pick = Pick;
-function nullCompare(left, op, right) {
-    const not = op === "!=" || op === "!~";
-    if (left.dataType === "null" || right.dataType === "null") {
-        const maybeNot = not ? " NOT" : "";
-        if (left.dataType !== "null") {
-            return [...left.value, ` IS${maybeNot} NULL`];
-        }
-        if (right.dataType !== "null") {
-            return [...right.value, `IS${maybeNot} NULL`];
-        }
-        return [not ? "false" : "true"];
-    }
-    return undefined;
-}
-class Apply extends ast_main_1.ExprCompare {
-    constructor(left, right) {
-        super(left, "=", right);
-        this.left = left;
-        this.right = right;
-        this.elementType = "apply";
-    }
-}
-exports.Apply = Apply;
-//# sourceMappingURL=ast-expr.js.map