@malloydata/malloy 0.0.22-dev230126015148 → 0.0.22-dev230202171033

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

@@ -0,0 +1,11 @@
+import { ExpressionType, Fragment, TimeFieldType } from "../../../model/malloy_types";
+import { FieldSpace } from "../types/field-space";
+import { ExprValue } from "../types/expr-value";
+import { ExpressionDef } from "../types/expression-def";
+export declare class ExprTime extends ExpressionDef {
+    elementType: string;
+    readonly translationValue: ExprValue;
+    constructor(timeType: TimeFieldType, value: Fragment[] | string, expressionType?: ExpressionType);
+    getExpression(_fs: FieldSpace): ExprValue;
+    static fromValue(timeType: TimeFieldType, expr: ExprValue): ExprTime;
+}

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

@@ -0,0 +1,62 @@
+"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.ExprTime = void 0;
+const malloy_types_1 = require("../../../model/malloy_types");
+const utils_1 = require("./utils");
+const expression_def_1 = require("../types/expression-def");
+class ExprTime extends expression_def_1.ExpressionDef {
+    constructor(timeType, value, expressionType = "scalar") {
+        super();
+        this.elementType = "timestampOrDate";
+        this.elementType = timeType;
+        this.translationValue = {
+            dataType: timeType,
+            expressionType,
+            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, utils_1.compressExpr)([toTs]);
+        }
+        return new ExprTime(timeType, value, expr.expressionType);
+    }
+}
+exports.ExprTime = ExprTime;
+//# sourceMappingURL=expr-time.js.map

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

@@ -0,0 +1,14 @@
+import { ExprValue } from "../types/expr-value";
+import { FieldValueType } from "../types/field-value-type";
+import { FieldName, FieldSpace } from "../types/field-space";
+import { ExpressionDef } from "../types/expression-def";
+export declare class ExprUngroup extends ExpressionDef {
+    readonly control: "all" | "exclude";
+    readonly expr: ExpressionDef;
+    readonly fields: FieldName[];
+    legalChildTypes: import("../types/frag-type").FragType[];
+    elementType: string;
+    constructor(control: "all" | "exclude", expr: ExpressionDef, fields: FieldName[]);
+    returns(_forExpression: ExprValue): FieldValueType;
+    getExpression(fs: FieldSpace): ExprValue;
+}

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

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExprUngroup = 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 ast_main_1 = require("../ast-main");
+const ast_utils_1 = require("../ast-utils");
+const field_declaration_1 = require("../query-items/field-declaration");
+const fragtype_utils_1 = require("../fragtype-utils");
+const expression_def_1 = require("../types/expression-def");
+class ExprUngroup extends expression_def_1.ExpressionDef {
+    constructor(control, expr, fields) {
+        super({ expr, fields });
+        this.control = control;
+        this.expr = expr;
+        this.fields = fields;
+        this.legalChildTypes = fragtype_utils_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_utils_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 field_declaration_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_utils_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_utils_1.errorFor)("ungrouped type check");
+    }
+}
+exports.ExprUngroup = ExprUngroup;
+//# sourceMappingURL=expr-ungroup.js.map

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

@@ -0,0 +1,19 @@
+import { FieldSpace } from "../types/field-space";
+import { ExprValue } from "../types/expr-value";
+import { ExpressionDef } from "../types/expression-def";
+import { Timeframe } from "./time-frame";
+/**
+ * TODO: This is sort of a hand clone of the "Range" class, they should
+ * be siblings of a common abstract classs.
+ */
+export declare class ForRange extends ExpressionDef {
+    readonly from: ExpressionDef;
+    readonly duration: ExpressionDef;
+    readonly timeframe: Timeframe;
+    elementType: string;
+    legalChildTypes: import("../types/frag-type").FragType[];
+    constructor(from: ExpressionDef, duration: ExpressionDef, timeframe: Timeframe);
+    apply(fs: FieldSpace, op: string, expr: ExpressionDef): ExprValue;
+    requestExpression(_fs: FieldSpace): ExprValue | undefined;
+    getExpression(_fs: FieldSpace): ExprValue;
+}

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

@@ -0,0 +1,101 @@
+"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.ForRange = void 0;
+const ast_utils_1 = require("../ast-utils");
+const fragtype_utils_1 = require("../fragtype-utils");
+const time_utils_1 = require("../time-utils");
+const expression_def_1 = require("../types/expression-def");
+const granular_result_1 = require("../types/granular-result");
+const expr_time_1 = require("./expr-time");
+const range_1 = require("./range");
+/**
+ * TODO: This is sort of a hand clone of the "Range" class, they should
+ * be siblings of a common abstract classs.
+ */
+class ForRange extends expression_def_1.ExpressionDef {
+    constructor(from, duration, timeframe) {
+        super({ from, duration, timeframe });
+        this.from = from;
+        this.duration = duration;
+        this.timeframe = timeframe;
+        this.elementType = "forRange";
+        this.legalChildTypes = [fragtype_utils_1.FT.timestampT, fragtype_utils_1.FT.dateT];
+    }
+    apply(fs, op, expr) {
+        const startV = this.from.getExpression(fs);
+        const checkV = expr.getExpression(fs);
+        if (!this.typeCheck(expr, checkV)) {
+            return (0, ast_utils_1.errorFor)("no time for range");
+        }
+        const nV = this.duration.getExpression(fs);
+        if (nV.dataType !== "number") {
+            this.log(`FOR duration count must be a number, not '${nV.dataType}'`);
+            return (0, ast_utils_1.errorFor)("FOR not number");
+        }
+        const units = this.timeframe.text;
+        // If the duration resolution is smaller than date, we have
+        // to do the computaion with timestamps.
+        const durationRes = (0, time_utils_1.resolution)(units);
+        let rangeType = durationRes;
+        // Next, if the beginning of the range is a timestamp, then we
+        // also have to do the computation as a timestamp
+        if (startV.dataType === "timestamp") {
+            rangeType = "timestamp";
+        }
+        // everything is dates, do date math
+        if (checkV.dataType === "date" && rangeType === "date") {
+            const rangeStart = this.from;
+            const rangeEndV = (0, time_utils_1.timeOffset)("date", startV.value, "+", nV.value, units);
+            const rangeEnd = new expr_time_1.ExprTime("date", rangeEndV);
+            return new range_1.Range(rangeStart, rangeEnd).apply(fs, op, expr);
+        }
+        // Now it doesn't matter if the range is a date or a timestamp,
+        // the comparison will be in timestamp space,
+        const applyTo = expr_time_1.ExprTime.fromValue("timestamp", checkV);
+        let rangeStart = this.from;
+        let from = startV.value;
+        if (startV.dataType === "date") {
+            // Time literals with timestamp units can also be used as timestamps;
+            const alreadyTs = (0, granular_result_1.isGranularResult)(startV) && startV.alsoTimestamp;
+            if (!alreadyTs) {
+                // ... not a literal, need a cast
+                from = (0, time_utils_1.castDateToTimestamp)(from);
+            }
+            rangeStart = new expr_time_1.ExprTime("timestamp", from, startV.expressionType);
+        }
+        const to = (0, time_utils_1.timeOffset)("timestamp", from, "+", nV.value, units);
+        const rangeEnd = new expr_time_1.ExprTime("timestamp", to, startV.expressionType);
+        return new range_1.Range(rangeStart, rangeEnd).apply(fs, op, applyTo);
+    }
+    requestExpression(_fs) {
+        return undefined;
+    }
+    getExpression(_fs) {
+        this.log("A Range is not a value");
+        return (0, ast_utils_1.errorFor)("range has no value");
+    }
+}
+exports.ForRange = ForRange;
+//# sourceMappingURL=for-range.js.map

package/dist/lang/ast/expressions/granular-literal.d.ts

@@ -0,0 +1,20 @@
+import { TimeFieldType, TimestampUnit } from "../../../model/malloy_types";
+import { ExprValue } from "../types/expr-value";
+import { FieldSpace } from "../types/field-space";
+import { ExpressionDef } from "../types/expression-def";
+/**
+ * GranularTime made from a literal. Funky because it doesn't know if it
+ * is a date or a timestamp in many cases until it is applied.
+ */
+export declare class GranularLiteral extends ExpressionDef {
+    readonly moment: string;
+    readonly until: string;
+    readonly units: TimestampUnit;
+    elementType: string;
+    timeType?: TimeFieldType;
+    constructor(moment: string, until: string, units: TimestampUnit);
+    granular(): boolean;
+    static parse(possibleLiteral: string): GranularLiteral | undefined;
+    apply(fs: FieldSpace, op: string, left: ExpressionDef): ExprValue;
+    getExpression(_fs: FieldSpace): ExprValue;
+}

package/dist/lang/ast/expressions/granular-literal.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GranularLiteral = 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 luxon_1 = require("luxon");
+const malloy_types_1 = require("../../../model/malloy_types");
+const range_1 = require("./range");
+const expr_time_1 = require("./expr-time");
+const time_utils_1 = require("../time-utils");
+const expression_def_1 = require("../types/expression-def");
+/**
+ * GranularTime made from a literal. Funky because it doesn't know if it
+ * is a date or a timestamp in many cases until it is applied.
+ */
+class GranularLiteral extends expression_def_1.ExpressionDef {
+    constructor(moment, until, units) {
+        super();
+        this.moment = moment;
+        this.until = until;
+        this.units = units;
+        this.elementType = "timeLiteral";
+    }
+    granular() {
+        return true;
+    }
+    static parse(possibleLiteral) {
+        const s = possibleLiteral.slice(1);
+        const fYear = "yyyy";
+        const fMonth = `${fYear}-LL`;
+        const fDay = `${fMonth}-dd`;
+        const fMinute = `${fDay} HH:mm`;
+        const fSecond = `${fMinute}:ss`;
+        const tss = luxon_1.DateTime.fromFormat(s, fSecond);
+        if (tss.isValid) {
+            const nextSecond = tss.plus({ second: 1 }).toFormat(fSecond);
+            const tsLit = new GranularLiteral(s, nextSecond, "second");
+            tsLit.timeType = "timestamp";
+            return tsLit;
+        }
+        const tsm = luxon_1.DateTime.fromFormat(s, fMinute);
+        if (tsm.isValid) {
+            // working around a weird bigquery bug ...
+            const thisMin = s + ":00";
+            const nextMinute = tsm.plus({ minute: 1 }).toFormat(fMinute) + ":00";
+            const tsLit = new GranularLiteral(thisMin, nextMinute, "minute");
+            tsLit.timeType = "timestamp";
+            return tsLit;
+        }
+        const quarter = s.match(/(\d{4})-[qQ](\d)$/);
+        if (quarter) {
+            const qplus = Number.parseInt(quarter[2]) - 1;
+            let qstart = luxon_1.DateTime.fromFormat(quarter[1], "yyyy");
+            if (qplus > 0) {
+                qstart = qstart.plus({ quarters: qplus });
+            }
+            const qend = qstart.plus({ quarter: 1 });
+            return new GranularLiteral(`${qstart.toFormat(fDay)}`, `${qend.toFormat(fDay)}`, "quarter");
+        }
+        const yyyymmdd = luxon_1.DateTime.fromFormat(s, fDay);
+        if (yyyymmdd.isValid) {
+            const next = yyyymmdd.plus({ days: 1 });
+            return new GranularLiteral(`${yyyymmdd.toFormat(fDay)}`, `${next.toFormat(fDay)}`, "day");
+        }
+        const yyyymm = luxon_1.DateTime.fromFormat(s, fMonth);
+        if (yyyymm.isValid) {
+            const next = yyyymm.plus({ months: 1 });
+            return new GranularLiteral(`${yyyymm.toFormat(fDay)}`, `${next.toFormat(fDay)}`, "month");
+        }
+        const yyyy = luxon_1.DateTime.fromFormat(s, fYear);
+        if (yyyy.isValid) {
+            const year = yyyy.toFormat(`yyyy-01-01`);
+            const nextYear = yyyy.plus({ year: 1 }).toFormat(`yyyy-01-01`);
+            return new GranularLiteral(year, nextYear, "year");
+        }
+        if (s.startsWith("WK")) {
+            const yyyymmdd = luxon_1.DateTime.fromFormat(s.slice(2), fDay);
+            if (yyyymmdd.isValid) {
+                // wonky because luxon uses monday weeks and bigquery uses sunday weeks
+                let sunday = yyyymmdd;
+                if (yyyymmdd.weekday !== 7) {
+                    sunday = yyyymmdd.startOf("week").minus({ day: 1 });
+                }
+                const next = sunday.plus({ days: 7 });
+                return new GranularLiteral(`${sunday.toFormat(fDay)}`, `${next.toFormat(fDay)}`, "week");
+            }
+        }
+        return undefined;
+    }
+    apply(fs, op, left) {
+        const lhs = left.getExpression(fs);
+        if ((0, malloy_types_1.isTimeFieldType)(lhs.dataType)) {
+            let rangeType = "timestamp";
+            if (lhs.dataType === "date" && !this.timeType) {
+                rangeType = "date";
+            }
+            const range = new range_1.Range(new expr_time_1.ExprTime(rangeType, (0, time_utils_1.timeLiteral)(this.moment, rangeType, "UTC")), new expr_time_1.ExprTime(rangeType, (0, time_utils_1.timeLiteral)(this.until, rangeType, "UTC")));
+            return range.apply(fs, op, left);
+        }
+        return super.apply(fs, op, left);
+    }
+    getExpression(_fs) {
+        const dataType = this.timeType || "date";
+        const value = {
+            dataType,
+            expressionType: "scalar",
+            value: (0, time_utils_1.timeLiteral)(this.moment, dataType, "UTC"),
+        };
+        // Literals with date resolution can be used as timestamps or dates,
+        // this is the third attempt to make that work. It still feels like
+        // there should be a better way to make this happen, but the point
+        // at which the data is needed, the handle is gone to the ExpressionDef
+        // which would allow a method call into this class. I think the second
+        // if clause is redundant (see "parse" above, but I'm paranoid)
+        if (dataType == "date" && (0, malloy_types_1.isDateUnit)(this.units)) {
+            value.alsoTimestamp = true;
+        }
+        if (this.units != "second") {
+            return {
+                ...value,
+                timeframe: this.units,
+            };
+        }
+        return value;
+    }
+}
+exports.GranularLiteral = GranularLiteral;
+//# sourceMappingURL=granular-literal.js.map

package/dist/lang/ast/expressions/partial-compare.d.ts

@@ -0,0 +1,14 @@
+import { Comparison } from "../types/comparison";
+import { ExprValue } from "../types/expr-value";
+import { FieldSpace } from "../types/field-space";
+import { ExpressionDef } from "../types/expression-def";
+export declare class PartialCompare extends ExpressionDef {
+    readonly op: Comparison;
+    readonly right: ExpressionDef;
+    elementType: string;
+    constructor(op: Comparison, right: ExpressionDef);
+    granular(): boolean;
+    apply(fs: FieldSpace, op: string, expr: ExpressionDef): ExprValue;
+    requestExpression(_fs: FieldSpace): ExprValue | undefined;
+    getExpression(_fs: FieldSpace): ExprValue;
+}

package/dist/lang/ast/expressions/partial-compare.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PartialCompare = 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 ast_utils_1 = require("../ast-utils");
+const expression_def_1 = require("../types/expression-def");
+class PartialCompare extends expression_def_1.ExpressionDef {
+    constructor(op, right) {
+        super({ right });
+        this.op = op;
+        this.right = right;
+        this.elementType = "<=> a";
+    }
+    granular() {
+        return this.right.granular();
+    }
+    apply(fs, op, expr) {
+        return this.right.apply(fs, this.op, expr);
+    }
+    requestExpression(_fs) {
+        return undefined;
+    }
+    getExpression(_fs) {
+        this.log(`Partial comparison does not have a value`);
+        return (0, ast_utils_1.errorFor)("no value for partial compare");
+    }
+}
+exports.PartialCompare = PartialCompare;
+//# sourceMappingURL=partial-compare.js.map

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

@@ -0,0 +1,19 @@
+import { ExprValue } from "../types/expr-value";
+import { FieldSpace } from "../types/field-space";
+import { MalloyElement } from "../types/malloy-element";
+import { ExpressionDef } from "../types/expression-def";
+export declare class Pick extends ExpressionDef {
+    readonly choices: PickWhen[];
+    readonly elsePick?: ExpressionDef | undefined;
+    elementType: string;
+    constructor(choices: PickWhen[], elsePick?: ExpressionDef | undefined);
+    requestExpression(fs: FieldSpace): ExprValue | undefined;
+    apply(fs: FieldSpace, op: string, expr: ExpressionDef): ExprValue;
+    getExpression(fs: FieldSpace): ExprValue;
+}
+export declare class PickWhen extends MalloyElement {
+    readonly pick: ExpressionDef | undefined;
+    readonly when: ExpressionDef;
+    elementType: string;
+    constructor(pick: ExpressionDef | undefined, when: ExpressionDef);
+}