@malloydata/malloy 0.0.22-dev230207144036 → 0.0.22-dev230207180844

package/dist/lang/ast/executors/project-executor.js

@@ -0,0 +1,68 @@
+"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.ProjectExecutor = void 0;
+const malloy_types_1 = require("../../../model/malloy_types");
+const error_factory_1 = require("../error-factory");
+const measures_1 = require("../query-properties/measures");
+const filters_1 = require("../query-properties/filters");
+const group_by_1 = require("../query-properties/group-by");
+const project_statement_1 = require("../query-properties/project-statement");
+const project_field_space_1 = require("../field-space/project-field-space");
+const reduce_executor_1 = require("./reduce-executor");
+class ProjectExecutor extends reduce_executor_1.ReduceExecutor {
+    getResultSpace(fs) {
+        return new project_field_space_1.ProjectFieldSpace(fs);
+    }
+    execute(qp) {
+        if (qp instanceof project_statement_1.ProjectStatement) {
+            this.resultFS.addMembers(qp.list);
+        }
+        else if ((qp instanceof filters_1.Filter && qp.elementType === "having") ||
+            qp instanceof measures_1.Measures ||
+            qp instanceof group_by_1.GroupBy) {
+            qp.log("Illegal statement in a project query operation");
+        }
+        else {
+            super.execute(qp);
+        }
+    }
+    finalize(fromSeg) {
+        let from;
+        if (fromSeg) {
+            if ((0, malloy_types_1.isProjectSegment)(fromSeg)) {
+                from = fromSeg;
+            }
+            else {
+                this.resultFS.log(`Can't refine project with ${fromSeg.type}`);
+                return error_factory_1.ErrorFactory.projectSegment;
+            }
+        }
+        const projectSegment = this.resultFS.getQuerySegment(from);
+        this.refineFrom(from, projectSegment);
+        return projectSegment;
+    }
+}
+exports.ProjectExecutor = ProjectExecutor;
+//# sourceMappingURL=project-executor.js.map

package/dist/lang/ast/executors/reduce-executor.d.ts

@@ -0,0 +1,21 @@
+import { FilterExpression, PipeSegment, QuerySegment } from "../../../model/malloy_types";
+import { FieldSpace } from "../types/field-space";
+import { Ordering } from "../query-properties/ordering";
+import { Top } from "../query-properties/top";
+import { QueryProperty } from "../types/query-property";
+import { Executor } from "../types/executor";
+import { QueryInputSpace, QuerySpace } from "../field-space/query-spaces";
+import { DynamicSpace } from "../field-space/dynamic-space";
+export declare class ReduceExecutor implements Executor {
+    inputFS: QueryInputSpace;
+    resultFS: QuerySpace;
+    filters: FilterExpression[];
+    order?: Top | Ordering;
+    limit?: number;
+    refinedInputFS?: DynamicSpace;
+    constructor(baseFS: FieldSpace);
+    getResultSpace(fs: FieldSpace): QuerySpace;
+    execute(qp: QueryProperty): void;
+    refineFrom(from: PipeSegment | undefined, to: QuerySegment): void;
+    finalize(fromSeg: PipeSegment | undefined): PipeSegment;
+}

package/dist/lang/ast/executors/reduce-executor.js

@@ -0,0 +1,149 @@
+"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.ReduceExecutor = void 0;
+const malloy_types_1 = require("../../../model/malloy_types");
+const error_factory_1 = require("../error-factory");
+const aggregate_1 = require("../query-properties/aggregate");
+const declare_fields_1 = require("../query-properties/declare-fields");
+const filters_1 = require("../query-properties/filters");
+const group_by_1 = require("../query-properties/group-by");
+const joins_1 = require("../query-properties/joins");
+const limit_1 = require("../query-properties/limit");
+const ordering_1 = require("../query-properties/ordering");
+const top_1 = require("../query-properties/top");
+const nests_1 = require("../query-properties/nests");
+const nest_1 = require("../query-properties/nest");
+const query_spaces_1 = require("../field-space/query-spaces");
+class ReduceExecutor {
+    constructor(baseFS) {
+        this.filters = [];
+        this.resultFS = this.getResultSpace(baseFS);
+        this.inputFS = this.resultFS.exprSpace;
+    }
+    getResultSpace(fs) {
+        return new query_spaces_1.ReduceFieldSpace(fs);
+    }
+    execute(qp) {
+        if (qp instanceof group_by_1.GroupBy ||
+            qp instanceof aggregate_1.Aggregate ||
+            qp instanceof nests_1.Nests) {
+            this.resultFS.addQueryItems(...qp.list);
+        }
+        else if ((0, nest_1.isNestedQuery)(qp)) {
+            this.resultFS.addQueryItems(qp);
+        }
+        else if (qp instanceof filters_1.Filter) {
+            this.filters.push(...qp.getFilterList(this.inputFS));
+        }
+        else if (qp instanceof top_1.Top) {
+            if (this.limit) {
+                qp.log("Query operation already limited");
+            }
+            else {
+                this.limit = qp.limit;
+            }
+            if (qp.by) {
+                if (this.order) {
+                    qp.log("Query operation is already sorted");
+                }
+                else {
+                    this.order = qp;
+                }
+            }
+        }
+        else if (qp instanceof limit_1.Limit) {
+            if (this.limit) {
+                qp.log("Query operation already limited");
+            }
+            else {
+                this.limit = qp.limit;
+            }
+        }
+        else if (qp instanceof ordering_1.Ordering) {
+            if (this.order) {
+                qp.log("Query operation already sorted");
+            }
+            else {
+                this.order = qp;
+            }
+        }
+        else if (qp instanceof joins_1.Joins || qp instanceof declare_fields_1.DeclareFields) {
+            for (const qel of qp.list) {
+                this.inputFS.extendSource(qel);
+            }
+        }
+    }
+    refineFrom(from, to) {
+        if (from && from.type !== "index") {
+            if (!this.order) {
+                if (from.orderBy) {
+                    to.orderBy = from.orderBy;
+                }
+                else if (from.by) {
+                    to.by = from.by;
+                }
+            }
+            if (!this.limit && from.limit) {
+                to.limit = from.limit;
+            }
+        }
+        if (this.limit) {
+            to.limit = this.limit;
+        }
+        if (this.order instanceof top_1.Top) {
+            const topBy = this.order.getBy(this.inputFS);
+            if (topBy) {
+                to.by = topBy;
+            }
+        }
+        if (this.order instanceof ordering_1.Ordering) {
+            to.orderBy = this.order.getOrderBy(this.inputFS);
+        }
+        const oldFilters = (from === null || from === void 0 ? void 0 : from.filterList) || [];
+        if (this.filters.length > 0 && !oldFilters) {
+            to.filterList = this.filters;
+        }
+        else if (oldFilters) {
+            to.filterList = [...oldFilters, ...this.filters];
+        }
+    }
+    finalize(fromSeg) {
+        let from;
+        if (fromSeg) {
+            if ((0, malloy_types_1.isReduceSegment)(fromSeg)) {
+                from = fromSeg;
+            }
+            else {
+                this.inputFS.result.log(`Can't refine reduce with ${fromSeg.type}`);
+                return error_factory_1.ErrorFactory.reduceSegment;
+            }
+        }
+        const reduceSegment = this.resultFS.getQuerySegment(from);
+        this.refineFrom(from, reduceSegment);
+        return reduceSegment;
+    }
+}
+exports.ReduceExecutor = ReduceExecutor;
+//# sourceMappingURL=reduce-executor.js.map

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

@@ -0,0 +1,8 @@
+import { ExprCompare } from "./expr-compare";
+import { ExpressionDef } from "../types/expression-def";
+export declare class Apply extends ExprCompare {
+    readonly left: ExpressionDef;
+    readonly right: ExpressionDef;
+    elementType: string;
+    constructor(left: ExpressionDef, right: ExpressionDef);
+}

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

@@ -0,0 +1,37 @@
+"use strict";
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Apply = void 0;
+const comparison_1 = require("../types/comparison");
+const expr_compare_1 = require("./expr-compare");
+class Apply extends expr_compare_1.ExprCompare {
+    constructor(left, right) {
+        super(left, comparison_1.Comparison.EqualTo, right);
+        this.left = left;
+        this.right = right;
+        this.elementType = "apply";
+    }
+}
+exports.Apply = Apply;
+//# sourceMappingURL=apply.js.map

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

@@ -0,0 +1,12 @@
+import { FieldSpace } from "../types/field-space";
+import { ExprValue } from "../types/expr-value";
+import { ExpressionDef } from "../types/expression-def";
+export declare abstract class BinaryBoolean<opType extends string> extends ExpressionDef {
+    readonly left: ExpressionDef;
+    readonly op: opType;
+    readonly right: ExpressionDef;
+    elementType: string;
+    legalChildTypes: import("../types/type-desc").TypeDesc[];
+    constructor(left: ExpressionDef, op: opType, right: ExpressionDef);
+    getExpression(fs: FieldSpace): ExprValue;
+}

package/dist/lang/ast/expressions/binary-boolean.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.BinaryBoolean = 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");
+const utils_1 = require("./utils");
+class BinaryBoolean extends expression_def_1.ExpressionDef {
+    constructor(left, op, right) {
+        super({ left, right });
+        this.left = left;
+        this.op = op;
+        this.right = right;
+        this.elementType = "abstract boolean binary";
+        this.legalChildTypes = [fragtype_utils_1.FT.boolT];
+    }
+    getExpression(fs) {
+        const left = this.left.getExpression(fs);
+        const right = this.right.getExpression(fs);
+        if (this.typeCheck(this.left, left) && this.typeCheck(this.right, right)) {
+            return {
+                dataType: "boolean",
+                expressionType: (0, malloy_types_1.maxExpressionType)(left.expressionType, right.expressionType),
+                value: (0, utils_1.compose)(left.value, this.op, right.value),
+            };
+        }
+        return (0, ast_utils_1.errorFor)("logial required boolean");
+    }
+}
+exports.BinaryBoolean = BinaryBoolean;
+//# sourceMappingURL=binary-boolean.js.map

package/dist/lang/ast/expressions/binary-numeric.d.ts

@@ -0,0 +1,11 @@
+import { ExprValue } from "../types/expr-value";
+import { FieldSpace } from "../types/field-space";
+import { ExpressionDef } from "../types/expression-def";
+export declare abstract class BinaryNumeric<opType extends string> extends ExpressionDef {
+    readonly left: ExpressionDef;
+    readonly op: opType;
+    readonly right: ExpressionDef;
+    elementType: string;
+    constructor(left: ExpressionDef, op: opType, right: ExpressionDef);
+    getExpression(fs: FieldSpace): ExprValue;
+}

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/type-desc";
+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/type-desc").TypeDesc[];
+    constructor(func: string, expr?: ExpressionDef);
+    returns(_forExpression: ExprValue): FieldValueType;
+    getExpression(fs: FieldSpace): ExprValue;
+}