@malloydata/malloy 0.0.22-dev230126015148 → 0.0.22-dev230202171033

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

@@ -0,0 +1,10 @@
+import { Comparison } from "../types/comparison";
+import { FieldSpace } from "../types/field-space";
+import { ExprValue } from "../types/expr-value";
+import { ExpressionDef } from "../types/expression-def";
+import { BinaryBoolean } from "./binary-boolean";
+export declare class ExprCompare extends BinaryBoolean<Comparison> {
+    elementType: string;
+    constructor(left: ExpressionDef, op: Comparison, right: ExpressionDef);
+    getExpression(fs: FieldSpace): ExprValue;
+}

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

@@ -0,0 +1,48 @@
+"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.ExprCompare = void 0;
+const expr_granular_time_1 = require("./expr-granular-time");
+const granular_result_1 = require("../types/granular-result");
+const compart_types_1 = require("../types/compart-types");
+const binary_boolean_1 = require("./binary-boolean");
+class ExprCompare extends binary_boolean_1.BinaryBoolean {
+    constructor(left, op, right) {
+        super(left, op, right);
+        this.elementType = "a<=>b";
+        this.legalChildTypes = compart_types_1.compareTypes[op];
+    }
+    getExpression(fs) {
+        if (!this.right.granular()) {
+            const rhs = this.right.requestExpression(fs);
+            if (rhs && (0, granular_result_1.isGranularResult)(rhs)) {
+                const newRight = new expr_granular_time_1.ExprGranularTime(this.right, rhs.timeframe, false);
+                return newRight.apply(fs, this.op, this.left);
+            }
+        }
+        return this.right.apply(fs, this.op, this.left);
+    }
+}
+exports.ExprCompare = ExprCompare;
+//# sourceMappingURL=expr-compare.js.map

package/dist/lang/ast/expressions/expr-count-distinct.d.ts

@@ -0,0 +1,6 @@
+import { ExprAggregateFunction } from "./expr-aggregate-function";
+import { ExpressionDef } from "../types/expression-def";
+export declare class ExprCountDistinct extends ExprAggregateFunction {
+    legalChildTypes: import("../types/frag-type").FragType[];
+    constructor(expr: ExpressionDef);
+}

package/dist/lang/ast/expressions/expr-count-distinct.js

@@ -0,0 +1,35 @@
+"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.ExprCountDistinct = void 0;
+const fragtype_utils_1 = require("../fragtype-utils");
+const expr_aggregate_function_1 = require("./expr-aggregate-function");
+class ExprCountDistinct extends expr_aggregate_function_1.ExprAggregateFunction {
+    constructor(expr) {
+        super("count_distinct", expr);
+        this.legalChildTypes = [fragtype_utils_1.FT.numberT, fragtype_utils_1.FT.stringT, fragtype_utils_1.FT.dateT, fragtype_utils_1.FT.timestampT];
+    }
+}
+exports.ExprCountDistinct = ExprCountDistinct;
+//# sourceMappingURL=expr-count-distinct.js.map

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

@@ -0,0 +1,11 @@
+import { ExprValue } from "../types/expr-value";
+import { FieldReference } from "../query-items/field-references";
+import { FieldSpace } from "../types/field-space";
+import { ExprAggregateFunction } from "./expr-aggregate-function";
+export declare class ExprCount extends ExprAggregateFunction {
+    readonly source?: FieldReference | undefined;
+    elementType: string;
+    constructor(source?: FieldReference | undefined);
+    defaultFieldName(): string | undefined;
+    getExpression(_fs: FieldSpace): ExprValue;
+}

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

@@ -0,0 +1,57 @@
+"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.ExprCount = void 0;
+const expr_aggregate_function_1 = require("./expr-aggregate-function");
+class ExprCount extends expr_aggregate_function_1.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;
+//# sourceMappingURL=expr-count.js.map

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

@@ -0,0 +1,12 @@
+import { ExprValue } from "../types/expr-value";
+import { FieldSpace } from "../types/field-space";
+import { Filter } from "../query-properties/filters";
+import { ExpressionDef } from "../types/expression-def";
+export declare class ExprFilter extends ExpressionDef {
+    readonly expr: ExpressionDef;
+    readonly filter: Filter;
+    elementType: string;
+    legalChildTypes: import("../types/frag-type").FragType[];
+    constructor(expr: ExpressionDef, filter: Filter);
+    getExpression(fs: FieldSpace): ExprValue;
+}

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

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExprFilter = 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_utils_1 = require("../ast-utils");
+const fragtype_utils_1 = require("../fragtype-utils");
+const expression_def_1 = require("../types/expression-def");
+class ExprFilter extends expression_def_1.ExpressionDef {
+    constructor(expr, filter) {
+        super({ expr, filter });
+        this.expr = expr;
+        this.filter = filter;
+        this.elementType = "filtered expression";
+        this.legalChildTypes = fragtype_utils_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_utils_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_utils_1.errorFor)("cannot filter type");
+    }
+}
+exports.ExprFilter = ExprFilter;
+//# sourceMappingURL=expr-filter.js.map

package/dist/lang/ast/expressions/expr-func.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 ExprFunc extends ExpressionDef {
+    readonly name: string;
+    readonly args: ExpressionDef[];
+    elementType: string;
+    constructor(name: string, args: ExpressionDef[]);
+    getExpression(fs: FieldSpace): ExprValue;
+}

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

@@ -0,0 +1,63 @@
+"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.ExprFunc = void 0;
+const malloy_types_1 = require("../../../model/malloy_types");
+const expression_def_1 = require("../types/expression-def");
+const utils_1 = require("./utils");
+class ExprFunc extends expression_def_1.ExpressionDef {
+    constructor(name, args) {
+        super({ args });
+        this.name = name;
+        this.args = args;
+        this.elementType = "function call()";
+    }
+    getExpression(fs) {
+        var _a, _b, _c;
+        let expressionType = "scalar";
+        let collectType;
+        const funcCall = [`${this.name}(`];
+        for (const fexpr of this.args) {
+            const expr = fexpr.getExpression(fs);
+            expressionType = (0, malloy_types_1.maxExpressionType)(expressionType, expr.expressionType);
+            if (collectType) {
+                funcCall.push(",");
+            }
+            else {
+                collectType = expr.dataType;
+            }
+            funcCall.push(...expr.value);
+        }
+        funcCall.push(")");
+        const dialect = fs.dialectObj();
+        const dataType = (_c = (_b = (_a = dialect === null || dialect === void 0 ? void 0 : dialect.getFunctionInfo(this.name)) === null || _a === void 0 ? void 0 : _a.returnType) !== null && _b !== void 0 ? _b : collectType) !== null && _c !== void 0 ? _c : "number";
+        return {
+            dataType: dataType,
+            expressionType,
+            value: (0, utils_1.compressExpr)(funcCall),
+        };
+    }
+}
+exports.ExprFunc = ExprFunc;
+//# sourceMappingURL=expr-func.js.map

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

@@ -0,0 +1,24 @@
+import { TimestampUnit } from "../../../model/malloy_types";
+import { FieldSpace } from "../types/field-space";
+import { ExprValue } from "../types/expr-value";
+import { ExpressionDef } from "../types/expression-def";
+/**
+ * GranularTime is a moment in time which ALSO has a "granularity"
+ * commonly this are created by applying ".datePart" to an expression
+ * 1) They have a value, which is the moment in time
+ * 2) When used in a comparison, they act like a range, for the
+ *    duration of 1 unit of granularity
+ */
+export declare class ExprGranularTime extends ExpressionDef {
+    readonly expr: ExpressionDef;
+    readonly units: TimestampUnit;
+    readonly truncate: boolean;
+    elementType: string;
+    legalChildTypes: import("../types/frag-type").FragType[];
+    constructor(expr: ExpressionDef, units: TimestampUnit, truncate: boolean);
+    granular(): boolean;
+    getExpression(fs: FieldSpace): ExprValue;
+    apply(fs: FieldSpace, op: string, left: ExpressionDef): ExprValue;
+    protected timestampRange(fs: FieldSpace, op: string, expr: ExpressionDef): ExprValue;
+    protected dateRange(fs: FieldSpace, op: string, expr: ExpressionDef): ExprValue;
+}

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

@@ -0,0 +1,117 @@
+"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.ExprGranularTime = void 0;
+const malloy_types_1 = require("../../../model/malloy_types");
+const ast_utils_1 = require("../ast-utils");
+const expr_time_1 = require("./expr-time");
+const fragtype_utils_1 = require("../fragtype-utils");
+const range_1 = require("./range");
+const time_utils_1 = require("../time-utils");
+const expression_def_1 = require("../types/expression-def");
+/**
+ * GranularTime is a moment in time which ALSO has a "granularity"
+ * commonly this are created by applying ".datePart" to an expression
+ * 1) They have a value, which is the moment in time
+ * 2) When used in a comparison, they act like a range, for the
+ *    duration of 1 unit of granularity
+ */
+class ExprGranularTime extends expression_def_1.ExpressionDef {
+    constructor(expr, units, truncate) {
+        super({ expr });
+        this.expr = expr;
+        this.units = units;
+        this.truncate = truncate;
+        this.elementType = "granularTime";
+        this.legalChildTypes = [fragtype_utils_1.FT.timestampT, fragtype_utils_1.FT.dateT];
+    }
+    granular() {
+        return true;
+    }
+    getExpression(fs) {
+        const timeframe = this.units;
+        const exprVal = this.expr.getExpression(fs);
+        if ((0, malloy_types_1.isTimeFieldType)(exprVal.dataType)) {
+            const tsVal = {
+                ...exprVal,
+                dataType: exprVal.dataType,
+                timeframe: timeframe,
+            };
+            if (this.truncate) {
+                tsVal.value = [
+                    {
+                        type: "dialect",
+                        function: "trunc",
+                        expr: { value: exprVal.value, valueType: exprVal.dataType },
+                        units: timeframe,
+                    },
+                ];
+            }
+            return tsVal;
+        }
+        this.log(`Cannot do time truncation on type '${exprVal.dataType}'`);
+        return (0, ast_utils_1.errorFor)(`granularity typecheck`);
+    }
+    apply(fs, op, left) {
+        const rangeType = this.getExpression(fs).dataType;
+        const _valueType = left.getExpression(fs).dataType;
+        const granularityType = (0, malloy_types_1.isDateUnit)(this.units) ? "date" : "timestamp";
+        if (rangeType == "date" && granularityType == "date") {
+            return this.dateRange(fs, op, left);
+        }
+        return this.timestampRange(fs, op, left);
+        /*
+          write tests for each of these cases ....
+    
+          vt  rt  gt  use
+          dt  dt  dt  dateRange
+          dt  dt  ts  == or timeStampRange
+          dt  ts  dt  timestampRange
+          dt  ts  ts  timeStampRange
+    
+          ts  ts  ts  timestampRange
+          ts  ts  dt  timestampRange
+          ts  dt  ts  timestampRange
+          ts  dt  dt  either
+    
+        */
+    }
+    timestampRange(fs, op, expr) {
+        const begin = this.getExpression(fs);
+        const beginTime = expr_time_1.ExprTime.fromValue("timestamp", begin);
+        const endTime = new expr_time_1.ExprTime("timestamp", (0, time_utils_1.timeOffset)("timestamp", begin.value, "+", (0, malloy_types_1.mkExpr) `1`, this.units), begin.expressionType);
+        const range = new range_1.Range(beginTime, endTime);
+        return range.apply(fs, op, expr);
+    }
+    dateRange(fs, op, expr) {
+        const begin = this.getExpression(fs);
+        const beginTime = new expr_time_1.ExprTime("date", begin.value, begin.expressionType);
+        const endAt = (0, time_utils_1.timeOffset)("date", begin.value, "+", ["1"], this.units);
+        const end = new expr_time_1.ExprTime("date", endAt, begin.expressionType);
+        const range = new range_1.Range(beginTime, end);
+        return range.apply(fs, op, expr);
+    }
+}
+exports.ExprGranularTime = ExprGranularTime;
+//# sourceMappingURL=expr-granular-time.js.map

package/dist/lang/ast/expressions/expr-id-reference.d.ts

@@ -0,0 +1,12 @@
+import { ExprValue } from "../types/expr-value";
+import { FieldReference } from "../query-items/field-references";
+import { FieldSpace } from "../types/field-space";
+import { ExpressionDef } from "../types/expression-def";
+export declare class ExprIdReference extends ExpressionDef {
+    readonly fieldReference: FieldReference;
+    elementType: string;
+    constructor(fieldReference: FieldReference);
+    get refString(): string;
+    getExpression(fs: FieldSpace): ExprValue;
+    apply(fs: FieldSpace, op: string, expr: ExpressionDef): ExprValue;
+}

package/dist/lang/ast/expressions/expr-id-reference.js

@@ -0,0 +1,76 @@
+"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.ExprIdReference = void 0;
+const malloy_types_1 = require("../../../model/malloy_types");
+const ast_utils_1 = require("../ast-utils");
+const space_param_1 = require("../types/space-param");
+const expression_def_1 = require("../types/expression-def");
+class ExprIdReference extends expression_def_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_utils_1.errorFor)(def.error);
+    }
+    apply(fs, op, expr) {
+        const entry = this.fieldReference.getField(fs).found;
+        if (entry instanceof space_param_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;
+//# sourceMappingURL=expr-id-reference.js.map

package/dist/lang/ast/expressions/expr-logical-op.d.ts

@@ -0,0 +1,9 @@
+import { BinaryBoolean } from "./binary-boolean";
+export declare class ExprLogicalOp extends BinaryBoolean<"and" | "or"> {
+    elementType: string;
+    legalChildTypes: (import("../types/frag-type").FragType | {
+        aggregate: boolean;
+        dataType: import("../types/field-value-type").FieldValueType;
+        expressionType: import("../../..").ExpressionType;
+    })[];
+}

package/dist/lang/ast/expressions/expr-logical-op.js

@@ -0,0 +1,36 @@
+"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.ExprLogicalOp = void 0;
+const binary_boolean_1 = require("./binary-boolean");
+const fragtype_utils_1 = require("../fragtype-utils");
+class ExprLogicalOp extends binary_boolean_1.BinaryBoolean {
+    constructor() {
+        super(...arguments);
+        this.elementType = "logical operator";
+        this.legalChildTypes = [fragtype_utils_1.FT.boolT, { ...fragtype_utils_1.FT.boolT, aggregate: true }];
+    }
+}
+exports.ExprLogicalOp = ExprLogicalOp;
+//# sourceMappingURL=expr-logical-op.js.map

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

@@ -0,0 +1,9 @@
+import { ExprValue } from "../types/expr-value";
+import { FieldValueType } from "../types/field-value-type";
+import { ExprAggregateFunction } from "./expr-aggregate-function";
+import { ExpressionDef } from "../types/expression-def";
+export declare class ExprMax extends ExprAggregateFunction {
+    legalChildTypes: import("../types/frag-type").FragType[];
+    constructor(expr: ExpressionDef);
+    returns(forExpression: ExprValue): FieldValueType;
+}

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExprMax = void 0;
+const fragtype_utils_1 = require("../fragtype-utils");
+const expr_aggregate_function_1 = require("./expr-aggregate-function");
+class ExprMax extends expr_aggregate_function_1.ExprAggregateFunction {
+    constructor(expr) {
+        super("max", expr);
+        this.legalChildTypes = [fragtype_utils_1.FT.numberT, fragtype_utils_1.FT.stringT, fragtype_utils_1.FT.dateT, fragtype_utils_1.FT.timestampT];
+    }
+    returns(forExpression) {
+        return forExpression.dataType;
+    }
+}
+exports.ExprMax = ExprMax;
+//# sourceMappingURL=expr-max.js.map

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

@@ -0,0 +1,9 @@
+import { ExprValue } from "../types/expr-value";
+import { FieldValueType } from "../types/field-value-type";
+import { ExprAggregateFunction } from "./expr-aggregate-function";
+import { ExpressionDef } from "../types/expression-def";
+export declare class ExprMin extends ExprAggregateFunction {
+    legalChildTypes: import("../types/frag-type").FragType[];
+    constructor(expr: ExpressionDef);
+    returns(forExpression: ExprValue): FieldValueType;
+}