@malloydata/malloy 0.0.22-dev230207144036 → 0.0.22-dev230207180844

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

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

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

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

@@ -0,0 +1,62 @@
+"use strict";
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExprTime = void 0;
+const malloy_types_1 = require("../../../model/malloy_types");
+const utils_1 = require("./utils");
+const expression_def_1 = require("../types/expression-def");
+class ExprTime extends expression_def_1.ExpressionDef {
+    constructor(timeType, value, expressionType = "scalar") {
+        super();
+        this.elementType = "timestampOrDate";
+        this.elementType = timeType;
+        this.translationValue = {
+            dataType: timeType,
+            expressionType,
+            value: typeof value === "string" ? [value] : value,
+        };
+    }
+    getExpression(_fs) {
+        return this.translationValue;
+    }
+    static fromValue(timeType, expr) {
+        let value = expr.value;
+        if (timeType != expr.dataType) {
+            const toTs = {
+                type: "dialect",
+                function: "cast",
+                safe: false,
+                dstType: timeType,
+                expr: expr.value,
+            };
+            if ((0, malloy_types_1.isTimeFieldType)(expr.dataType)) {
+                toTs.srcType = expr.dataType;
+            }
+            value = (0, utils_1.compressExpr)([toTs]);
+        }
+        return new ExprTime(timeType, value, expr.expressionType);
+    }
+}
+exports.ExprTime = ExprTime;
+//# sourceMappingURL=expr-time.js.map

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

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

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

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExprUngroup = void 0;
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+const malloy_types_1 = require("../../../model/malloy_types");
+const query_spaces_1 = require("../field-space/query-spaces");
+const ast_utils_1 = require("../ast-utils");
+const field_declaration_1 = require("../query-items/field-declaration");
+const fragtype_utils_1 = require("../fragtype-utils");
+const expression_def_1 = require("../types/expression-def");
+class ExprUngroup extends expression_def_1.ExpressionDef {
+    constructor(control, expr, fields) {
+        super({ expr, fields });
+        this.control = control;
+        this.expr = expr;
+        this.fields = fields;
+        this.legalChildTypes = fragtype_utils_1.FT.anyAtomicT;
+        this.elementType = "ungroup";
+    }
+    returns(_forExpression) {
+        return "number";
+    }
+    getExpression(fs) {
+        const exprVal = this.expr.getExpression(fs);
+        if (!(0, malloy_types_1.expressionIsAggregate)(exprVal.expressionType)) {
+            this.expr.log(`${this.control}() expression must be an aggregate`);
+            return (0, ast_utils_1.errorFor)("ungrouped scalar");
+        }
+        const ungroup = { type: this.control, e: exprVal.value };
+        if (this.typeCheck(this.expr, { ...exprVal, expressionType: "scalar" })) {
+            if (this.fields.length > 0) {
+                let qs = fs;
+                if (fs instanceof field_declaration_1.DefSpace) {
+                    qs = fs.realFS;
+                }
+                if (!(qs instanceof query_spaces_1.QueryInputSpace)) {
+                    this.log(`${this.control}() must be in a query -- weird internal error`);
+                    return (0, ast_utils_1.errorFor)("ungroup query check");
+                }
+                const output = qs.result;
+                const dstFields = [];
+                const isExclude = this.control == "exclude";
+                for (const mustBeInOutput of this.fields) {
+                    output.whenComplete(() => {
+                        output.checkUngroup(mustBeInOutput, isExclude);
+                    });
+                    dstFields.push(mustBeInOutput.refString);
+                }
+                ungroup.fields = dstFields;
+            }
+            return {
+                dataType: this.returns(exprVal),
+                expressionType: "analytic",
+                value: [ungroup],
+            };
+        }
+        this.log(`${this.control}() incompatible type`);
+        return (0, ast_utils_1.errorFor)("ungrouped type check");
+    }
+}
+exports.ExprUngroup = ExprUngroup;
+//# sourceMappingURL=expr-ungroup.js.map

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

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

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

@@ -0,0 +1,101 @@
+"use strict";
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ForRange = void 0;
+const ast_utils_1 = require("../ast-utils");
+const fragtype_utils_1 = require("../fragtype-utils");
+const time_utils_1 = require("../time-utils");
+const expression_def_1 = require("../types/expression-def");
+const granular_result_1 = require("../types/granular-result");
+const expr_time_1 = require("./expr-time");
+const range_1 = require("./range");
+/**
+ * TODO: This is sort of a hand clone of the "Range" class, they should
+ * be siblings of a common abstract classs.
+ */
+class ForRange extends expression_def_1.ExpressionDef {
+    constructor(from, duration, timeframe) {
+        super({ from, duration, timeframe });
+        this.from = from;
+        this.duration = duration;
+        this.timeframe = timeframe;
+        this.elementType = "forRange";
+        this.legalChildTypes = [fragtype_utils_1.FT.timestampT, fragtype_utils_1.FT.dateT];
+    }
+    apply(fs, op, expr) {
+        const startV = this.from.getExpression(fs);
+        const checkV = expr.getExpression(fs);
+        if (!this.typeCheck(expr, checkV)) {
+            return (0, ast_utils_1.errorFor)("no time for range");
+        }
+        const nV = this.duration.getExpression(fs);
+        if (nV.dataType !== "number") {
+            this.log(`FOR duration count must be a number, not '${nV.dataType}'`);
+            return (0, ast_utils_1.errorFor)("FOR not number");
+        }
+        const units = this.timeframe.text;
+        // If the duration resolution is smaller than date, we have
+        // to do the computaion with timestamps.
+        const durationRes = (0, time_utils_1.resolution)(units);
+        let rangeType = durationRes;
+        // Next, if the beginning of the range is a timestamp, then we
+        // also have to do the computation as a timestamp
+        if (startV.dataType === "timestamp") {
+            rangeType = "timestamp";
+        }
+        // everything is dates, do date math
+        if (checkV.dataType === "date" && rangeType === "date") {
+            const rangeStart = this.from;
+            const rangeEndV = (0, time_utils_1.timeOffset)("date", startV.value, "+", nV.value, units);
+            const rangeEnd = new expr_time_1.ExprTime("date", rangeEndV);
+            return new range_1.Range(rangeStart, rangeEnd).apply(fs, op, expr);
+        }
+        // Now it doesn't matter if the range is a date or a timestamp,
+        // the comparison will be in timestamp space,
+        const applyTo = expr_time_1.ExprTime.fromValue("timestamp", checkV);
+        let rangeStart = this.from;
+        let from = startV.value;
+        if (startV.dataType === "date") {
+            // Time literals with timestamp units can also be used as timestamps;
+            const alreadyTs = (0, granular_result_1.isGranularResult)(startV) && startV.alsoTimestamp;
+            if (!alreadyTs) {
+                // ... not a literal, need a cast
+                from = (0, time_utils_1.castDateToTimestamp)(from);
+            }
+            rangeStart = new expr_time_1.ExprTime("timestamp", from, startV.expressionType);
+        }
+        const to = (0, time_utils_1.timeOffset)("timestamp", from, "+", nV.value, units);
+        const rangeEnd = new expr_time_1.ExprTime("timestamp", to, startV.expressionType);
+        return new range_1.Range(rangeStart, rangeEnd).apply(fs, op, applyTo);
+    }
+    requestExpression(_fs) {
+        return undefined;
+    }
+    getExpression(_fs) {
+        this.log("A Range is not a value");
+        return (0, ast_utils_1.errorFor)("range has no value");
+    }
+}
+exports.ForRange = ForRange;
+//# sourceMappingURL=for-range.js.map

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

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