@malloydata/malloy 0.0.22-dev230125205605 → 0.0.22-dev230202171033

package/dist/lang/ast/expressions/pick-when.js

@@ -0,0 +1,156 @@
+"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.PickWhen = exports.Pick = 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 malloy_element_1 = require("../types/malloy-element");
+const expression_def_1 = require("../types/expression-def");
+const utils_1 = require("./utils");
+class Pick extends expression_def_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 (!fragtype_utils_1.FT.typeEq(returnType, thenExpr, true)) {
+                    const whenType = fragtype_utils_1.FT.inspect(thenExpr);
+                    this.log(`pick type '${whenType}', expected '${returnType.dataType}'`);
+                    return (0, ast_utils_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 (!fragtype_utils_1.FT.typeEq(returnType, elseVal, true)) {
+            const errSrc = this.elsePick ? "else" : "pick default";
+            this.log(`${errSrc} type '${fragtype_utils_1.FT.inspect(elseVal)}', expected '${returnType.dataType}'`);
+            return (0, ast_utils_1.errorFor)("pick else type");
+        }
+        return {
+            dataType: returnType.dataType,
+            expressionType: (0, malloy_types_1.maxExpressionType)(anyExpressionType, elseVal.expressionType),
+            value: (0, utils_1.compressExpr)([...caseValue, " ELSE ", ...elseVal.value, " END"]),
+        };
+    }
+    getExpression(fs) {
+        if (this.elsePick === undefined) {
+            this.log("pick incomplete, missing 'else'");
+            return (0, ast_utils_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_utils_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_utils_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 (!fragtype_utils_1.FT.typeEq(aChoice.when, fragtype_utils_1.FT.boolT)) {
+                this.log(`when expression must be boolean, not '${fragtype_utils_1.FT.inspect(aChoice.when)}`);
+                return (0, ast_utils_1.errorFor)("pick when type");
+            }
+            if (!fragtype_utils_1.FT.typeEq(returnType, aChoice.pick, true)) {
+                const whenType = fragtype_utils_1.FT.inspect(aChoice.pick);
+                this.log(`pick type '${whenType}', expected '${returnType.dataType}'`);
+                return (0, ast_utils_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 (!fragtype_utils_1.FT.typeEq(returnType, defVal, true)) {
+            this.elsePick.log(`else type '${fragtype_utils_1.FT.inspect(defVal)}', expected '${returnType.dataType}'`);
+            return (0, ast_utils_1.errorFor)("pick value type mismatch");
+        }
+        caseValue.push(" ELSE ", ...defVal.value, " END");
+        return {
+            dataType: returnType.dataType,
+            expressionType: anyExpressionType,
+            value: (0, utils_1.compressExpr)(caseValue),
+        };
+    }
+}
+exports.Pick = Pick;
+class PickWhen extends malloy_element_1.MalloyElement {
+    constructor(pick, when) {
+        super({ when });
+        this.pick = pick;
+        this.when = when;
+        this.elementType = "pickWhen";
+        this.has({ pick });
+    }
+}
+exports.PickWhen = PickWhen;
+//# sourceMappingURL=pick-when.js.map

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

@@ -0,0 +1,12 @@
+import { ExprValue } from "../types/expr-value";
+import { ExpressionDef } from "../types/expression-def";
+import { FieldSpace } from "../types/field-space";
+export declare class Range extends ExpressionDef {
+    readonly first: ExpressionDef;
+    readonly last: ExpressionDef;
+    elementType: string;
+    constructor(first: ExpressionDef, last: ExpressionDef);
+    apply(fs: FieldSpace, op: string, expr: ExpressionDef): ExprValue;
+    requestExpression(_fs: FieldSpace): ExprValue | undefined;
+    getExpression(_fs: FieldSpace): ExprValue;
+}

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

@@ -0,0 +1,80 @@
+"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.Range = void 0;
+const malloy_types_1 = require("../../../model/malloy_types");
+const ast_utils_1 = require("../ast-utils");
+const expression_def_1 = require("../types/expression-def");
+const utils_1 = require("./utils");
+class Range extends expression_def_1.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",
+                    expressionType: (0, malloy_types_1.maxExpressionType)(fromValue.expressionType, toValue.expressionType),
+                    value: (0, utils_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, ast_utils_1.errorFor)("a range is not a value");
+    }
+}
+exports.Range = Range;
+//# sourceMappingURL=range.js.map

package/dist/lang/ast/expressions/time-frame.d.ts

@@ -0,0 +1,7 @@
+import { TimestampUnit } from "../../../model/malloy_types";
+import { MalloyElement } from "../types/malloy-element";
+export declare class Timeframe extends MalloyElement {
+    elementType: string;
+    readonly text: TimestampUnit;
+    constructor(timeframeName: string);
+}

package/dist/lang/ast/expressions/time-frame.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Timeframe = void 0;
+/*
+ * 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.
+ */
+const malloy_types_1 = require("../../../model/malloy_types");
+const malloy_element_1 = require("../types/malloy-element");
+class Timeframe extends malloy_element_1.MalloyElement {
+    constructor(timeframeName) {
+        super();
+        this.elementType = "timeframe";
+        let tf = timeframeName.toLowerCase();
+        if (tf.endsWith("s")) {
+            tf = tf.slice(0, -1);
+        }
+        this.text = (0, malloy_types_1.isTimestampUnit)(tf) ? tf : "second";
+    }
+}
+exports.Timeframe = Timeframe;
+//# sourceMappingURL=time-frame.js.map

package/dist/lang/ast/expressions/top-by.d.ts

@@ -0,0 +1,10 @@
+import { By } from "../../../model/malloy_types";
+import { FieldSpace } from "../types/field-space";
+import { MalloyElement } from "../types/malloy-element";
+import { ExpressionDef } from "../types/expression-def";
+export declare class TopBy extends MalloyElement {
+    readonly by: string | ExpressionDef;
+    elementType: string;
+    constructor(by: string | ExpressionDef);
+    getBy(fs: FieldSpace): By;
+}

package/dist/lang/ast/expressions/top-by.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TopBy = void 0;
+/*
+ * 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.
+ */
+const malloy_types_1 = require("../../../model/malloy_types");
+const malloy_element_1 = require("../types/malloy-element");
+const expression_def_1 = require("../types/expression-def");
+const utils_1 = require("./utils");
+class TopBy extends malloy_element_1.MalloyElement {
+    constructor(by) {
+        super();
+        this.by = by;
+        this.elementType = "topBy";
+        if (by instanceof expression_def_1.ExpressionDef) {
+            this.has({ by });
+        }
+    }
+    getBy(fs) {
+        if (this.by instanceof expression_def_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, utils_1.compressExpr)(byExpr.value) };
+        }
+        return { by: "name", name: this.by };
+    }
+}
+exports.TopBy = TopBy;
+//# sourceMappingURL=top-by.js.map

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

@@ -0,0 +1,5 @@
+import { ExpressionDef } from "../types/expression-def";
+export declare abstract class Unary extends ExpressionDef {
+    readonly expr: ExpressionDef;
+    constructor(expr: ExpressionDef);
+}

package/dist/lang/ast/expressions/unary.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.Unary = void 0;
+const expression_def_1 = require("../types/expression-def");
+class Unary extends expression_def_1.ExpressionDef {
+    constructor(expr) {
+        super({ expr });
+        this.expr = expr;
+    }
+}
+exports.Unary = Unary;
+//# sourceMappingURL=unary.js.map

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

@@ -0,0 +1,15 @@
+import { Expr, Fragment } from "../../../model/malloy_types";
+import { Equality } from "../types/equality";
+import { ExpressionValueType } from "../types/expression-value-type";
+import { FieldValueType } from "../types/field-value-type";
+export declare function isExpressionValueType(fv: FieldValueType): fv is ExpressionValueType;
+/**
+ * Compose a binary expression. Tries to write them safely and concisely
+ * @param left
+ * @param op
+ * @param right
+ * @returns Fragment list of the composed expression
+ */
+export declare function compose(left: Fragment[], op: string, right: Fragment[]): Fragment[];
+export declare function compressExpr(expr: Expr): Expr;
+export declare function nullsafeNot(expr: Expr, op?: Equality): Expr;

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

@@ -0,0 +1,106 @@
+"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.nullsafeNot = exports.compressExpr = exports.compose = exports.isExpressionValueType = void 0;
+const malloy_types_1 = require("../../../model/malloy_types");
+function isExpressionValueType(fv) {
+    return ((0, malloy_types_1.isAtomicFieldType)(fv) ||
+        ["null", "unknown", "duration", "regular expression"].includes(fv));
+}
+exports.isExpressionValueType = isExpressionValueType;
+/**
+ * If the passed expresion is not a single term, wrap it in parens
+ * @param f expression fragment
+ */
+function term(f) {
+    if (f.length > 1) {
+        return ["(", ...f, ")"];
+    }
+    if (f.length === 0) {
+        // Trying to compose a binary expresion with an entity that has no value
+        // this should at least cause the generated SQL to error, but likely
+        // there has already been a semantic error reported.
+        return ["__MISSING_VALUE__"];
+    }
+    return f;
+}
+/**
+ * Compose a binary expression. Tries to write them safely and concisely
+ * @param left
+ * @param op
+ * @param right
+ * @returns Fragment list of the composed expression
+ */
+function compose(left, op, right) {
+    const opAlpha = op.match(/^[A-Za-z]/);
+    const leftSpace = left.length === 1 && opAlpha ? " " : "";
+    const rightSpace = right.length === 1 && opAlpha ? " " : "";
+    const newOp = leftSpace + op + rightSpace;
+    return [...term(left), newOp, ...term(right)];
+}
+exports.compose = compose;
+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;
+}
+function compressExpr(expr) {
+    // compress all adjacent strings
+    const compressValue = [];
+    let buildString;
+    for (const fragment of expr.flat()) {
+        if (typeof fragment === "string") {
+            buildString = buildString ? buildString + fragment : fragment;
+        }
+        else {
+            if (buildString) {
+                compressValue.push(buildString);
+                buildString = undefined;
+            }
+            compressValue.push(fragment);
+        }
+    }
+    if (buildString) {
+        compressValue.push(buildString);
+    }
+    return compressValue;
+}
+exports.compressExpr = compressExpr;
+function nullsafeNot(expr, op) {
+    if (op === undefined || op === "!=" || op === "!~") {
+        return (0, malloy_types_1.mkExpr) `COALESCE(NOT(${expr}),FALSE)`;
+    }
+    return expr;
+}
+exports.nullsafeNot = nullsafeNot;
+//# sourceMappingURL=utils.js.map

package/dist/lang/ast/expressions/when-clause.d.ts

@@ -0,0 +1,10 @@
+import { ExprValue } from "../types/expr-value";
+import { FieldSpace } from "../types/field-space";
+import { ExpressionDef } from "../types/expression-def";
+export declare class WhenClause extends ExpressionDef {
+    readonly whenThis: ExpressionDef;
+    readonly thenThis: ExpressionDef;
+    elementType: string;
+    constructor(whenThis: ExpressionDef, thenThis: ExpressionDef);
+    getExpression(_fs: FieldSpace): ExprValue;
+}

package/dist/lang/ast/expressions/when-clause.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WhenClause = void 0;
+const expression_def_1 = require("../types/expression-def");
+class WhenClause extends expression_def_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;
+//# sourceMappingURL=when-clause.js.map

package/dist/lang/ast/fragtype-utils.d.ts

@@ -0,0 +1,39 @@
+import { FragType } from "./types/frag-type";
+/**
+ * Collects functions which operate on fragtype compatible objects
+ */
+export declare class FT {
+    /**
+     * Checks if a given type is in a list
+     * @param check The type to check (can be undefined)
+     * @param from List of types which are OK
+     */
+    static in(check: FragType | undefined, from: FragType[]): boolean;
+    /**
+     * Checks if a possibly undefined candidate matches a type
+     * @param good The real type
+     * @param checkThis The possibly undefined candidate
+     */
+    static eq(good: FragType, checkThis: FragType | undefined): boolean;
+    /**
+     * Checks if the base types, ignoring aggregate, are equal
+     * @param left Left type
+     * @param right Right type
+     * @param nullOk True if a NULL is an acceptable match
+     */
+    static typeEq(left: FragType, right: FragType, nullOk?: boolean): boolean;
+    /**
+     *
+     * For error messages, returns a comma seperated list of readable names
+     * for a list of types.
+     * @param types List of type or objects with types
+     */
+    static inspect(...types: (FragType | undefined)[]): string;
+    static nullT: FragType;
+    static numberT: FragType;
+    static stringT: FragType;
+    static dateT: FragType;
+    static timestampT: FragType;
+    static boolT: FragType;
+    static anyAtomicT: FragType[];
+}