@malloydata/malloy 0.0.22-dev230207144036 → 0.0.22-dev230207180844

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

@@ -0,0 +1,99 @@
+"use strict";
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExprAggregateFunction = void 0;
+const malloy_types_1 = require("../../../model/malloy_types");
+const ast_utils_1 = require("../ast-utils");
+const fragtype_utils_1 = require("../fragtype-utils");
+const struct_space_field_base_1 = require("../field-space/struct-space-field-base");
+const expression_def_1 = require("../types/expression-def");
+class ExprAggregateFunction extends expression_def_1.ExpressionDef {
+    constructor(func, expr) {
+        super();
+        this.func = func;
+        this.legalChildTypes = [fragtype_utils_1.FT.numberT];
+        this.elementType = func;
+        if (expr) {
+            this.expr = expr;
+            this.has({ expr });
+        }
+    }
+    returns(_forExpression) {
+        return "number";
+    }
+    getExpression(fs) {
+        var _a, _b;
+        let exprVal = (_a = this.expr) === null || _a === void 0 ? void 0 : _a.getExpression(fs);
+        let structPath = (_b = this.source) === null || _b === void 0 ? void 0 : _b.refString;
+        if (this.source) {
+            const sourceFoot = this.source.getField(fs).found;
+            if (sourceFoot) {
+                const footType = sourceFoot.typeDesc();
+                if ((0, malloy_types_1.isAtomicFieldType)(footType.dataType)) {
+                    exprVal = {
+                        dataType: footType.dataType,
+                        expressionType: footType.expressionType,
+                        value: [{ type: "field", path: this.source.refString }],
+                    };
+                    structPath = this.source.sourceString;
+                }
+                else {
+                    if (!(sourceFoot instanceof struct_space_field_base_1.StructSpaceFieldBase)) {
+                        this.log(`Aggregate source cannot be a ${footType.dataType}`);
+                        return (0, ast_utils_1.errorFor)(`Aggregate source cannot be a ${footType.dataType}`);
+                    }
+                }
+            }
+            else {
+                this.log(`Reference to undefined value ${this.source.refString}`);
+                return (0, ast_utils_1.errorFor)(`Reference to undefined value ${this.source.refString}`);
+            }
+        }
+        if (exprVal === undefined) {
+            this.log("Missing expression for aggregate function");
+            return (0, ast_utils_1.errorFor)("agggregate without expression");
+        }
+        if (this.typeCheck(this.expr || this, {
+            ...exprVal,
+            expressionType: "scalar",
+        })) {
+            const f = {
+                type: "aggregate",
+                function: this.func,
+                e: exprVal.value,
+            };
+            if (structPath) {
+                f.structPath = structPath;
+            }
+            return {
+                dataType: this.returns(exprVal),
+                expressionType: "aggregate",
+                value: [f],
+            };
+        }
+        return (0, ast_utils_1.errorFor)("aggregate type check");
+    }
+}
+exports.ExprAggregateFunction = ExprAggregateFunction;
+//# sourceMappingURL=expr-aggregate-function.js.map

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

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

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

@@ -0,0 +1,54 @@
+"use strict";
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExprAlternationTree = void 0;
+const malloy_types_1 = require("../../../model/malloy_types");
+const ast_utils_1 = require("../ast-utils");
+const binary_boolean_1 = require("./binary-boolean");
+const utils_1 = require("./utils");
+class ExprAlternationTree extends binary_boolean_1.BinaryBoolean {
+    constructor(left, op, right) {
+        super(left, op, right);
+        this.elementType = "alternation";
+        this.elementType = `${op}alternation${op}`;
+    }
+    apply(fs, applyOp, expr) {
+        const choice1 = this.left.apply(fs, applyOp, expr);
+        const choice2 = this.right.apply(fs, applyOp, expr);
+        return {
+            dataType: "boolean",
+            expressionType: (0, malloy_types_1.maxExpressionType)(choice1.expressionType, choice2.expressionType),
+            value: (0, utils_1.compose)(choice1.value, this.op === "&" ? "and" : "or", choice2.value),
+        };
+    }
+    requestExpression(_fs) {
+        return undefined;
+    }
+    getExpression(_fs) {
+        this.log(`Alternation tree has no value`);
+        return (0, ast_utils_1.errorFor)("no value from alternation tree");
+    }
+}
+exports.ExprAlternationTree = ExprAlternationTree;
+//# sourceMappingURL=expr-alternation-tree.js.map

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

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

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExprAsymmetric = void 0;
+const expr_aggregate_function_1 = require("./expr-aggregate-function");
+class ExprAsymmetric extends expr_aggregate_function_1.ExprAggregateFunction {
+    constructor(func, expr, source) {
+        super(func, expr);
+        this.func = func;
+        this.expr = expr;
+        this.source = source;
+        this.has({ source });
+    }
+    defaultFieldName() {
+        if (this.source && this.expr === undefined) {
+            const tag = this.source.nameString;
+            switch (this.func) {
+                case "sum":
+                    return `total_${tag}`;
+                case "avg":
+                    return `avg_${tag}`;
+            }
+        }
+        return undefined;
+    }
+}
+exports.ExprAsymmetric = ExprAsymmetric;
+//# sourceMappingURL=expr-asymmetric.js.map

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

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

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

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

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

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

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

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExprCast = exports.isCastType = void 0;
+const time_utils_1 = require("../time-utils");
+const expression_def_1 = require("../types/expression-def");
+const utils_1 = require("./utils");
+function isCastType(t) {
+    return ["string", "number", "boolean", "date", "timestamp"].includes(t);
+}
+exports.isCastType = isCastType;
+class ExprCast extends expression_def_1.ExpressionDef {
+    constructor(expr, castType, safe = false) {
+        super({ expr });
+        this.expr = expr;
+        this.castType = castType;
+        this.safe = safe;
+        this.elementType = "cast";
+    }
+    getExpression(fs) {
+        const expr = this.expr.getExpression(fs);
+        return {
+            dataType: this.castType,
+            expressionType: expr.expressionType,
+            value: (0, utils_1.compressExpr)((0, time_utils_1.castTo)(this.castType, expr.value, this.safe)),
+        };
+    }
+}
+exports.ExprCast = ExprCast;
+//# sourceMappingURL=expr-cast.js.map

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,58 @@
+"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 binary_boolean_1 = require("./binary-boolean");
+const fragtype_utils_1 = require("../fragtype-utils");
+const compareTypes = {
+    "~": [fragtype_utils_1.FT.stringT],
+    "!~": [fragtype_utils_1.FT.stringT],
+    "<": [fragtype_utils_1.FT.numberT, fragtype_utils_1.FT.stringT, fragtype_utils_1.FT.dateT, fragtype_utils_1.FT.timestampT],
+    "<=": [fragtype_utils_1.FT.numberT, fragtype_utils_1.FT.stringT, fragtype_utils_1.FT.dateT, fragtype_utils_1.FT.timestampT],
+    "=": [fragtype_utils_1.FT.numberT, fragtype_utils_1.FT.stringT, fragtype_utils_1.FT.dateT, fragtype_utils_1.FT.timestampT],
+    "!=": [fragtype_utils_1.FT.numberT, fragtype_utils_1.FT.stringT, fragtype_utils_1.FT.dateT, fragtype_utils_1.FT.timestampT],
+    ">=": [fragtype_utils_1.FT.numberT, fragtype_utils_1.FT.stringT, fragtype_utils_1.FT.dateT, fragtype_utils_1.FT.timestampT],
+    ">": [fragtype_utils_1.FT.numberT, fragtype_utils_1.FT.stringT, fragtype_utils_1.FT.dateT, fragtype_utils_1.FT.timestampT],
+};
+class ExprCompare extends binary_boolean_1.BinaryBoolean {
+    constructor(left, op, right) {
+        super(left, op, right);
+        this.elementType = "a<=>b";
+        this.legalChildTypes = 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/type-desc").TypeDesc[];
+    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/type-desc").TypeDesc[];
+    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/type-desc").TypeDesc[];
+    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;
+}