@malloydata/malloy 0.0.22-dev230126015148 → 0.0.22-dev230202171033

package/dist/lang/ast/expressions/binary-numeric.js

@@ -0,0 +1,42 @@
+"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.BinaryNumeric = void 0;
+const fragtype_utils_1 = require("../fragtype-utils");
+const expression_def_1 = require("../types/expression-def");
+class BinaryNumeric extends expression_def_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 = [fragtype_utils_1.FT.numberT];
+    }
+    getExpression(fs) {
+        return this.right.apply(fs, this.op, this.left);
+    }
+}
+exports.BinaryNumeric = BinaryNumeric;
+//# sourceMappingURL=binary-numeric.js.map

package/dist/lang/ast/expressions/boolean.d.ts

@@ -0,0 +1,8 @@
+import { ExprValue } from "../types/expr-value";
+import { ExpressionDef } from "../types/expression-def";
+export declare class Boolean extends ExpressionDef {
+    readonly value: "true" | "false";
+    elementType: string;
+    constructor(value: "true" | "false");
+    getExpression(): ExprValue;
+}

package/dist/lang/ast/expressions/boolean.js

@@ -0,0 +1,39 @@
+"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.Boolean = void 0;
+const expression_def_1 = require("../types/expression-def");
+const fragtype_utils_1 = require("../fragtype-utils");
+class Boolean extends expression_def_1.ExpressionDef {
+    constructor(value) {
+        super();
+        this.value = value;
+        this.elementType = "boolean literal";
+    }
+    getExpression() {
+        return { ...fragtype_utils_1.FT.boolT, value: [this.value] };
+    }
+}
+exports.Boolean = Boolean;
+//# sourceMappingURL=boolean.js.map

package/dist/lang/ast/expressions/constant-sub-expression.d.ts

@@ -0,0 +1,16 @@
+import { AtomicFieldType } from "../../../model/malloy_types";
+import { ExprValue } from "../types/expr-value";
+import { ExpressionDef } from "../types/expression-def";
+import { FieldSpace } from "../types/field-space";
+export declare class ConstantSubExpression extends ExpressionDef {
+    readonly expr: ExpressionDef;
+    elementType: string;
+    private cfs?;
+    constructor(expr: ExpressionDef);
+    getExpression(_fs: FieldSpace): ExprValue;
+    private get constantFs();
+    constantValue(): ExprValue;
+    constantCondition(type: AtomicFieldType): ExprValue;
+    apply(fs: FieldSpace, op: string, expr: ExpressionDef): ExprValue;
+    requestExpression(fs: FieldSpace): ExprValue | undefined;
+}

package/dist/lang/ast/expressions/constant-sub-expression.js

@@ -0,0 +1,98 @@
+"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.ConstantSubExpression = void 0;
+const comparison_1 = require("../types/comparison");
+const expr_compare_1 = require("./expr-compare");
+const expression_def_1 = require("../types/expression-def");
+const utils_1 = require("./utils");
+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 DollarReference extends expression_def_1.ExpressionDef {
+    constructor(refType) {
+        super();
+        this.refType = refType;
+        this.elementType = "$";
+    }
+    getExpression(_fs) {
+        return {
+            dataType: this.refType,
+            value: [{ type: "applyVal" }],
+            expressionType: "scalar",
+        };
+    }
+}
+class ConstantSubExpression extends expression_def_1.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 expr_compare_1.ExprCompare(new DollarReference(type), comparison_1.Comparison.EqualTo, this.expr);
+        const application = compareAndContrast.getExpression(this.constantFs);
+        return { ...application, value: (0, utils_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;
+//# sourceMappingURL=constant-sub-expression.js.map

package/dist/lang/ast/expressions/expr-add-sub.d.ts

@@ -0,0 +1,4 @@
+import { BinaryNumeric } from "./binary-numeric";
+export declare class ExprAddSub extends BinaryNumeric<"+" | "-"> {
+    elementType: string;
+}

package/dist/lang/ast/expressions/expr-add-sub.js

@@ -0,0 +1,34 @@
+"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.ExprAddSub = void 0;
+const binary_numeric_1 = require("./binary-numeric");
+class ExprAddSub extends binary_numeric_1.BinaryNumeric {
+    constructor() {
+        super(...arguments);
+        this.elementType = "+-";
+    }
+}
+exports.ExprAddSub = ExprAddSub;
+//# sourceMappingURL=expr-add-sub.js.map

package/dist/lang/ast/expressions/expr-aggregate-function.d.ts

@@ -0,0 +1,15 @@
+import { ExprValue } from "../types/expr-value";
+import { FieldValueType } from "../types/field-value-type";
+import { FieldReference } from "../query-items/field-references";
+import { FieldSpace } from "../types/field-space";
+import { ExpressionDef } from "../types/expression-def";
+export declare abstract class ExprAggregateFunction extends ExpressionDef {
+    readonly func: string;
+    elementType: string;
+    source?: FieldReference;
+    expr?: ExpressionDef;
+    legalChildTypes: import("../types/frag-type").FragType[];
+    constructor(func: string, expr?: ExpressionDef);
+    returns(_forExpression: ExprValue): FieldValueType;
+    getExpression(fs: FieldSpace): ExprValue;
+}

package/dist/lang/ast/expressions/expr-aggregate-function.js

@@ -0,0 +1,99 @@
+"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.ExprAggregateFunction = void 0;
+const malloy_types_1 = require("../../../model/malloy_types");
+const ast_utils_1 = require("../ast-utils");
+const fragtype_utils_1 = require("../fragtype-utils");
+const static_space_1 = require("../static-space");
+const expression_def_1 = require("../types/expression-def");
+class ExprAggregateFunction extends expression_def_1.ExpressionDef {
+    constructor(func, expr) {
+        super();
+        this.func = func;
+        this.legalChildTypes = [fragtype_utils_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 static_space_1.StructSpaceField)) {
+                        this.log(`Aggregate source cannot be a ${footType.type}`);
+                        return (0, ast_utils_1.errorFor)(`Aggregate source cannot be a ${footType.type}`);
+                    }
+                }
+            }
+            else {
+                this.log(`Reference to undefined value ${this.source.refString}`);
+                return (0, ast_utils_1.errorFor)(`Reference to undefined value ${this.source.refString}`);
+            }
+        }
+        if (exprVal === undefined) {
+            this.log("Missing expression for aggregate function");
+            return (0, ast_utils_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_utils_1.errorFor)("aggregate type check");
+    }
+}
+exports.ExprAggregateFunction = ExprAggregateFunction;
+//# sourceMappingURL=expr-aggregate-function.js.map

package/dist/lang/ast/expressions/expr-alternation-tree.d.ts

@@ -0,0 +1,11 @@
+import { ExprValue } from "../types/expr-value";
+import { BinaryBoolean } from "./binary-boolean";
+import { FieldSpace } from "../types/field-space";
+import { ExpressionDef } from "../types/expression-def";
+export declare class ExprAlternationTree extends BinaryBoolean<"|" | "&"> {
+    elementType: string;
+    constructor(left: ExpressionDef, op: "|" | "&", right: ExpressionDef);
+    apply(fs: FieldSpace, applyOp: string, expr: ExpressionDef): ExprValue;
+    requestExpression(_fs: FieldSpace): ExprValue | undefined;
+    getExpression(_fs: FieldSpace): ExprValue;
+}

package/dist/lang/ast/expressions/expr-alternation-tree.js

@@ -0,0 +1,54 @@
+"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.ExprAlternationTree = void 0;
+const malloy_types_1 = require("../../../model/malloy_types");
+const ast_utils_1 = require("../ast-utils");
+const binary_boolean_1 = require("./binary-boolean");
+const utils_1 = require("./utils");
+class ExprAlternationTree extends binary_boolean_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, utils_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_utils_1.errorFor)("no value from alternation tree");
+    }
+}
+exports.ExprAlternationTree = ExprAlternationTree;
+//# sourceMappingURL=expr-alternation-tree.js.map

package/dist/lang/ast/expressions/expr-asymmetric.d.ts

@@ -0,0 +1,10 @@
+import { FieldReference } from "../query-items/field-references";
+import { ExprAggregateFunction } from "./expr-aggregate-function";
+import { ExpressionDef } from "../types/expression-def";
+export declare abstract class ExprAsymmetric extends ExprAggregateFunction {
+    readonly func: "sum" | "avg";
+    readonly expr: ExpressionDef | undefined;
+    readonly source?: FieldReference | undefined;
+    constructor(func: "sum" | "avg", expr: ExpressionDef | undefined, source?: FieldReference | undefined);
+    defaultFieldName(): undefined | string;
+}

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExprAsymmetric = void 0;
+const expr_aggregate_function_1 = require("./expr-aggregate-function");
+class ExprAsymmetric extends expr_aggregate_function_1.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;
+    }
+}
+exports.ExprAsymmetric = ExprAsymmetric;
+//# sourceMappingURL=expr-asymmetric.js.map

package/dist/lang/ast/expressions/expr-avg.d.ts

@@ -0,0 +1,6 @@
+import { ExpressionDef } from "../types/expression-def";
+import { FieldReference } from "../query-items/field-references";
+import { ExprAsymmetric } from "./expr-asymmetric";
+export declare class ExprAvg extends ExprAsymmetric {
+    constructor(expr: ExpressionDef | undefined, source?: FieldReference);
+}

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

@@ -0,0 +1,34 @@
+"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.ExprAvg = void 0;
+const expr_asymmetric_1 = require("./expr-asymmetric");
+class ExprAvg extends expr_asymmetric_1.ExprAsymmetric {
+    constructor(expr, source) {
+        super("avg", expr, source);
+        this.has({ source });
+    }
+}
+exports.ExprAvg = ExprAvg;
+//# sourceMappingURL=expr-avg.js.map

package/dist/lang/ast/expressions/expr-case.d.ts

@@ -0,0 +1,11 @@
+import { ExprValue } from "../types/expr-value";
+import { FieldSpace } from "../types/field-space";
+import { ExpressionDef } from "../types/expression-def";
+import { WhenClause } from "./when-clause";
+export declare class ExprCase extends ExpressionDef {
+    readonly when: WhenClause[];
+    readonly elseClause?: ExpressionDef | undefined;
+    elementType: string;
+    constructor(when: WhenClause[], elseClause?: ExpressionDef | undefined);
+    getExpression(fs: FieldSpace): ExprValue;
+}

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

@@ -0,0 +1,84 @@
+"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.ExprCase = void 0;
+const malloy_types_1 = require("../../../model/malloy_types");
+const ast_utils_1 = require("../ast-utils");
+const fragtype_utils_1 = require("../fragtype-utils");
+const expression_def_1 = require("../types/expression-def");
+class ExprCase extends expression_def_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 && !fragtype_utils_1.FT.typeEq(retType, thenExpr)) {
+                    this.log(`Mismatched THEN clause types, ${fragtype_utils_1.FT.inspect(retType, thenExpr)}`);
+                    return (0, ast_utils_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 && !fragtype_utils_1.FT.typeEq(retType, elseExpr)) {
+                    this.log(`Mismatched ELSE clause type, ${fragtype_utils_1.FT.inspect(retType, elseExpr)}`);
+                    return (0, ast_utils_1.errorFor)("else typecheck");
+                }
+                else {
+                    retType = elseExpr;
+                }
+            }
+        }
+        if (retType === undefined) {
+            this.log("case statement type not computable");
+            return (0, ast_utils_1.errorFor)("typeless case");
+        }
+        caseExpr.push(" END");
+        return {
+            dataType: retType.dataType,
+            expressionType,
+            value: caseExpr,
+        };
+    }
+}
+exports.ExprCase = ExprCase;
+//# sourceMappingURL=expr-case.js.map

package/dist/lang/ast/expressions/expr-cast.d.ts

@@ -0,0 +1,13 @@
+import { ExprValue } from "../types/expr-value";
+import { FieldSpace } from "../types/field-space";
+import { ExpressionDef } from "../types/expression-def";
+export declare type CastType = "string" | "number" | "boolean" | "date" | "timestamp";
+export declare function isCastType(t: string): t is CastType;
+export declare class ExprCast extends ExpressionDef {
+    readonly expr: ExpressionDef;
+    readonly castType: CastType;
+    readonly safe: boolean;
+    elementType: string;
+    constructor(expr: ExpressionDef, castType: CastType, safe?: boolean);
+    getExpression(fs: FieldSpace): ExprValue;
+}

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

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExprCast = exports.isCastType = void 0;
+const time_utils_1 = require("../time-utils");
+const expression_def_1 = require("../types/expression-def");
+const utils_1 = require("./utils");
+function isCastType(t) {
+    return ["string", "number", "boolean", "date", "timestamp"].includes(t);
+}
+exports.isCastType = isCastType;
+class ExprCast extends expression_def_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, utils_1.compressExpr)((0, time_utils_1.castTo)(this.castType, expr.value, this.safe)),
+        };
+    }
+}
+exports.ExprCast = ExprCast;
+//# sourceMappingURL=expr-cast.js.map