@malloydata/malloy 0.0.22-dev230126015148 → 0.0.22-dev230202171033

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExprMin = void 0;
+const fragtype_utils_1 = require("../fragtype-utils");
+const expr_aggregate_function_1 = require("./expr-aggregate-function");
+class ExprMin extends expr_aggregate_function_1.ExprAggregateFunction {
+    constructor(expr) {
+        super("min", 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.ExprMin = ExprMin;
+//# sourceMappingURL=expr-min.js.map

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

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

package/dist/lang/ast/expressions/expr-minus.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.ExprMinus = void 0;
+const ast_utils_1 = require("../ast-utils");
+const fragtype_utils_1 = require("../fragtype-utils");
+const expression_def_1 = require("../types/expression-def");
+class ExprMinus extends expression_def_1.ExpressionDef {
+    constructor(expr) {
+        super({ expr });
+        this.expr = expr;
+        this.elementType = "unary minus";
+        this.legalChildTypes = [fragtype_utils_1.FT.numberT];
+    }
+    getExpression(fs) {
+        const expr = this.expr.getExpression(fs);
+        if (this.typeCheck(this.expr, expr)) {
+            if (expr.value.length > 1) {
+                return { ...expr, value: ["-(", ...expr.value, ")"] };
+            }
+            return { ...expr, value: ["-", ...expr.value] };
+        }
+        return (0, ast_utils_1.errorFor)("negate requires number");
+    }
+}
+exports.ExprMinus = ExprMinus;
+//# sourceMappingURL=expr-minus.js.map

package/dist/lang/ast/expressions/expr-mul-div.d.ts

@@ -0,0 +1,4 @@
+import { BinaryNumeric } from "./binary-numeric";
+export declare class ExprMulDiv extends BinaryNumeric<"*" | "/" | "%"> {
+    elementType: string;
+}

package/dist/lang/ast/expressions/expr-mul-div.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExprMulDiv = 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 binary_numeric_1 = require("./binary-numeric");
+class ExprMulDiv extends binary_numeric_1.BinaryNumeric {
+    constructor() {
+        super(...arguments);
+        this.elementType = "*/%";
+    }
+}
+exports.ExprMulDiv = ExprMulDiv;
+//# sourceMappingURL=expr-mul-div.js.map

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

@@ -0,0 +1,10 @@
+import { ExprValue } from "../types/expr-value";
+import { ExpressionDef } from "../types/expression-def";
+import { FieldSpace } from "../types/field-space";
+import { Unary } from "./unary";
+export declare class ExprNot extends Unary {
+    elementType: string;
+    legalChildTypes: import("../types/frag-type").FragType[];
+    constructor(expr: ExpressionDef);
+    getExpression(fs: FieldSpace): ExprValue;
+}

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

@@ -0,0 +1,49 @@
+"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.ExprNot = void 0;
+const ast_utils_1 = require("../ast-utils");
+const fragtype_utils_1 = require("../fragtype-utils");
+const unary_1 = require("./unary");
+const utils_1 = require("./utils");
+class ExprNot extends unary_1.Unary {
+    constructor(expr) {
+        super(expr);
+        this.elementType = "not";
+        this.legalChildTypes = [fragtype_utils_1.FT.boolT, fragtype_utils_1.FT.nullT];
+    }
+    getExpression(fs) {
+        const notThis = this.expr.getExpression(fs);
+        if (this.typeCheck(this.expr, notThis)) {
+            return {
+                ...notThis,
+                dataType: "boolean",
+                value: (0, utils_1.nullsafeNot)(notThis.value),
+            };
+        }
+        return (0, ast_utils_1.errorFor)("not requires boolean");
+    }
+}
+exports.ExprNot = ExprNot;
+//# sourceMappingURL=expr-not.js.map

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

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

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

@@ -0,0 +1,46 @@
+"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.ExprNow = void 0;
+const expression_def_1 = require("../types/expression-def");
+class ExprNow extends expression_def_1.ExpressionDef {
+    constructor() {
+        super(...arguments);
+        this.elementType = "timestamp";
+    }
+    getExpression(_fs) {
+        return {
+            dataType: "timestamp",
+            expressionType: "scalar",
+            value: [
+                {
+                    type: "dialect",
+                    function: "now",
+                },
+            ],
+        };
+    }
+}
+exports.ExprNow = ExprNow;
+//# sourceMappingURL=expr-now.js.map

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

@@ -0,0 +1,6 @@
+import { ExprValue } from "../types/expr-value";
+import { ExpressionDef } from "../types/expression-def";
+export declare class ExprNULL extends ExpressionDef {
+    elementType: string;
+    getExpression(): ExprValue;
+}

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

@@ -0,0 +1,41 @@
+"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.ExprNULL = void 0;
+const expression_def_1 = require("../types/expression-def");
+class ExprNULL extends expression_def_1.ExpressionDef {
+    constructor() {
+        super(...arguments);
+        this.elementType = "NULL";
+    }
+    getExpression() {
+        return {
+            dataType: "null",
+            value: ["NULL"],
+            expressionType: "scalar",
+        };
+    }
+}
+exports.ExprNULL = ExprNULL;
+//# sourceMappingURL=expr-null.js.map

package/dist/lang/ast/expressions/expr-number.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 ExprNumber extends ExpressionDef {
+    readonly n: string;
+    elementType: string;
+    constructor(n: string);
+    getExpression(_fs: FieldSpace): ExprValue;
+    constantExpression(): ExprValue;
+}

package/dist/lang/ast/expressions/expr-number.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.ExprNumber = void 0;
+const fragtype_utils_1 = require("../fragtype-utils");
+const expression_def_1 = require("../types/expression-def");
+class ExprNumber extends expression_def_1.ExpressionDef {
+    constructor(n) {
+        super();
+        this.n = n;
+        this.elementType = "numeric literal";
+    }
+    getExpression(_fs) {
+        return this.constantExpression();
+    }
+    constantExpression() {
+        return { ...fragtype_utils_1.FT.numberT, value: [this.n] };
+    }
+}
+exports.ExprNumber = ExprNumber;
+//# sourceMappingURL=expr-number.js.map

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

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

package/dist/lang/ast/expressions/expr-parens.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.ExprParens = void 0;
+const expression_def_1 = require("../types/expression-def");
+class ExprParens extends expression_def_1.ExpressionDef {
+    constructor(expr) {
+        super({ expr });
+        this.expr = expr;
+        this.elementType = "(expression)";
+    }
+    requestExpression(fs) {
+        return this.expr.requestExpression(fs);
+    }
+    getExpression(fs) {
+        const subExpr = this.expr.getExpression(fs);
+        return { ...subExpr, value: ["(", ...subExpr.value, ")"] };
+    }
+}
+exports.ExprParens = ExprParens;
+//# sourceMappingURL=expr-parens.js.map

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

@@ -0,0 +1,8 @@
+import { ExprValue } from "../types/expr-value";
+import { ExpressionDef } from "../types/expression-def";
+export declare class ExprRegEx extends ExpressionDef {
+    readonly regex: string;
+    elementType: string;
+    constructor(regex: string);
+    getExpression(): ExprValue;
+}

package/dist/lang/ast/expressions/expr-regex.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.ExprRegEx = void 0;
+const expression_def_1 = require("../types/expression-def");
+class ExprRegEx extends expression_def_1.ExpressionDef {
+    constructor(regex) {
+        super();
+        this.regex = regex;
+        this.elementType = "regular expression literal";
+    }
+    getExpression() {
+        return {
+            dataType: "regular expression",
+            expressionType: "scalar",
+            value: [`r'${this.regex}'`],
+        };
+    }
+}
+exports.ExprRegEx = ExprRegEx;
+//# sourceMappingURL=expr-regex.js.map

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

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

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

@@ -0,0 +1,50 @@
+"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.ExprString = void 0;
+const expression_def_1 = require("../types/expression-def");
+const fragtype_utils_1 = require("../fragtype-utils");
+class ExprString extends expression_def_1.ExpressionDef {
+    constructor(src) {
+        super();
+        this.elementType = "string literal";
+        const bareStr = src.slice(1, -1);
+        const val = bareStr.replace(/\\(.)/g, "$1");
+        this.value = val;
+    }
+    getExpression(_fs) {
+        return {
+            ...fragtype_utils_1.FT.stringT,
+            value: [
+                {
+                    type: "dialect",
+                    function: "stringLiteral",
+                    literal: this.value,
+                },
+            ],
+        };
+    }
+}
+exports.ExprString = ExprString;
+//# sourceMappingURL=expr-string.js.map

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

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

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExprSum = void 0;
+const expr_asymmetric_1 = require("./expr-asymmetric");
+class ExprSum extends expr_asymmetric_1.ExprAsymmetric {
+    constructor(expr, source) {
+        super("sum", expr, source);
+        this.has({ source });
+    }
+}
+exports.ExprSum = ExprSum;
+//# sourceMappingURL=expr-sum.js.map

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

@@ -0,0 +1,13 @@
+import { ExtractUnit } from "../../../model/malloy_types";
+import { ExprValue } from "../types/expr-value";
+import { FieldSpace } from "../types/field-space";
+import { ExpressionDef } from "../types/expression-def";
+export declare class ExprTimeExtract extends ExpressionDef {
+    readonly extractText: string;
+    readonly args: ExpressionDef[];
+    elementType: string;
+    static pluralMap: Record<string, ExtractUnit>;
+    static extractor(funcName: string): ExtractUnit | undefined;
+    constructor(extractText: string, args: ExpressionDef[]);
+    getExpression(fs: FieldSpace): ExprValue;
+}

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

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExprTimeExtract = 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 range_1 = require("./range");
+const expression_def_1 = require("../types/expression-def");
+class ExprTimeExtract extends expression_def_1.ExpressionDef {
+    constructor(extractText, args) {
+        super({ args });
+        this.extractText = extractText;
+        this.args = args;
+        this.elementType = "timeExtract";
+    }
+    static extractor(funcName) {
+        const mappedName = ExprTimeExtract.pluralMap[funcName];
+        if (mappedName) {
+            return mappedName;
+        }
+        if ((0, malloy_types_1.isExtractUnit)(funcName)) {
+            return funcName;
+        }
+    }
+    getExpression(fs) {
+        const extractTo = ExprTimeExtract.extractor(this.extractText);
+        if (extractTo) {
+            if (this.args.length !== 1) {
+                this.log(`Extraction function ${extractTo} requires one argument`);
+                return (0, ast_utils_1.errorFor)(`{this.name} arg count`);
+            }
+            const from = this.args[0];
+            if (from instanceof range_1.Range) {
+                const first = from.first.getExpression(fs);
+                const last = from.last.getExpression(fs);
+                if (!(0, malloy_types_1.isTimeFieldType)(first.dataType)) {
+                    from.first.log(`Can't extract ${extractTo} from '${first.dataType}'`);
+                    return (0, ast_utils_1.errorFor)(`${extractTo} bad type ${first.dataType}`);
+                }
+                if (!(0, malloy_types_1.isTimeFieldType)(last.dataType)) {
+                    from.last.log(`Cannot extract ${extractTo} from '${last.dataType}'`);
+                    return (0, ast_utils_1.errorFor)(`${extractTo} bad type ${last.dataType}`);
+                }
+                if (!(0, malloy_types_1.isTimestampUnit)(extractTo)) {
+                    this.log(`Cannot extract ${extractTo} from a range`);
+                    return (0, ast_utils_1.errorFor)(`${extractTo} bad extraction`);
+                }
+                return {
+                    dataType: "number",
+                    expressionType: (0, malloy_types_1.maxExpressionType)(first.expressionType, last.expressionType),
+                    value: [
+                        {
+                            type: "dialect",
+                            function: "timeDiff",
+                            units: extractTo,
+                            left: { valueType: first.dataType, value: first.value },
+                            right: { valueType: last.dataType, value: last.value },
+                        },
+                    ],
+                };
+            }
+            else {
+                const argV = from.getExpression(fs);
+                if ((0, malloy_types_1.isTimeFieldType)(argV.dataType)) {
+                    return {
+                        dataType: "number",
+                        expressionType: argV.expressionType,
+                        value: [
+                            {
+                                type: "dialect",
+                                function: "extract",
+                                expr: { value: argV.value, valueType: argV.dataType },
+                                units: extractTo,
+                            },
+                        ],
+                    };
+                }
+                this.log(`${this.extractText}() requires time type, not '${argV.dataType}'`);
+                return (0, ast_utils_1.errorFor)(`${this.extractText} bad type ${argV.dataType}`);
+            }
+        }
+        throw this.internalError(`Illegal extraction unit '${this.extractText}'`);
+    }
+}
+exports.ExprTimeExtract = ExprTimeExtract;
+ExprTimeExtract.pluralMap = {
+    years: "year",
+    quarters: "quarter",
+    months: "month",
+    weeks: "week",
+    days: "day",
+    hours: "hour",
+    minutes: "minute",
+    seconds: "second",
+};
+//# sourceMappingURL=expr-time-extract.js.map