@malloydata/malloy 0.0.2 → 0.0.4

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

@@ -1,549 +0,0 @@
-"use strict";
-/*
- * Copyright 2021 Google LLC
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * version 2 as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExprFunc = exports.ExprTimeExtract = exports.ForRange = exports.PartialCompare = exports.Apply = exports.ExprCompare = exports.ExprDuration = exports.ExprNow = exports.GranularLiteral = exports.ExprGranularTime = exports.Timeframe = void 0;
-const luxon_1 = require("luxon");
-const malloy_types_1 = require("../../model/malloy_types");
-const index_1 = require("./index");
-class Timeframe extends index_1.MalloyElement {
-    constructor(timeframeName) {
-        super();
-        this.elementType = "timeframe";
-        let tf = timeframeName.toLowerCase();
-        if (tf.endsWith("s")) {
-            tf = tf.slice(0, -1);
-        }
-        this.text = (0, malloy_types_1.isTimestampUnit)(tf) ? tf : "second";
-    }
-}
-exports.Timeframe = Timeframe;
-/**
- * GranularTime is a moment in time which ALSO has a "granularity"
- * commonly this are created by applying ".datePart" to an expression
- * 1) They have a value, which is the moment in time
- * 2) When used in a comparison, they act like a range, for the
- *    duration of 1 unit of granularity
- */
-class ExprGranularTime extends index_1.ExpressionDef {
-    constructor(expr, units, truncate) {
-        super({ expr });
-        this.expr = expr;
-        this.units = units;
-        this.truncate = truncate;
-        this.elementType = "granularTime";
-        this.legalChildTypes = [index_1.FT.timestampT, index_1.FT.dateT];
-    }
-    granular() {
-        return true;
-    }
-    getExpression(fs) {
-        const timeframe = this.units;
-        const exprVal = this.expr.getExpression(fs);
-        if ((0, malloy_types_1.isTimeFieldType)(exprVal.dataType)) {
-            const tsVal = {
-                ...exprVal,
-                dataType: exprVal.dataType,
-                timeframe: timeframe,
-            };
-            if (this.truncate) {
-                tsVal.value = [
-                    {
-                        type: "dialect",
-                        function: "trunc",
-                        expr: { value: exprVal.value, valueType: exprVal.dataType },
-                        units: timeframe,
-                    },
-                ];
-            }
-            return tsVal;
-        }
-        this.log(`Cannot do time truncation on type '${exprVal.dataType}'`);
-        return (0, index_1.errorFor)(`granularity typecheck`);
-    }
-    apply(fs, op, left) {
-        const rangeType = this.getExpression(fs).dataType;
-        const _valueType = left.getExpression(fs).dataType;
-        const granularityType = (0, malloy_types_1.isDateUnit)(this.units) ? "date" : "timestamp";
-        if (rangeType == "date" && granularityType == "date") {
-            return this.dateRange(fs, op, left);
-        }
-        return this.timestampRange(fs, op, left);
-        /*
-          write tests for each of these cases ....
-    
-          vt  rt  gt  use
-          dt  dt  dt  dateRange
-          dt  dt  ts  == or timeStampRange
-          dt  ts  dt  timestampRange
-          dt  ts  ts  timeStampRange
-    
-          ts  ts  ts  timestampRange
-          ts  ts  dt  timestampRange
-          ts  dt  ts  timestampRange
-          ts  dt  dt  either
-    
-        */
-    }
-    timestampRange(fs, op, expr) {
-        const begin = this.getExpression(fs);
-        const beginTime = index_1.ExprTime.fromValue("timestamp", begin);
-        const endTime = new index_1.ExprTime("timestamp", (0, index_1.timeOffset)("timestamp", begin.value, "+", (0, malloy_types_1.mkExpr) `1`, this.units), begin.aggregate);
-        const range = new index_1.Range(beginTime, endTime);
-        return range.apply(fs, op, expr);
-    }
-    dateRange(fs, op, expr) {
-        const begin = this.getExpression(fs);
-        const beginTime = new index_1.ExprTime("date", begin.value, begin.aggregate);
-        const endAt = (0, index_1.timeOffset)("date", begin.value, "+", ["1"], this.units);
-        const end = new index_1.ExprTime("date", endAt, begin.aggregate);
-        const range = new index_1.Range(beginTime, end);
-        return range.apply(fs, op, expr);
-    }
-}
-exports.ExprGranularTime = ExprGranularTime;
-/**
- * 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.
- */
-class GranularLiteral extends index_1.ExpressionDef {
-    constructor(moment, until, units) {
-        super();
-        this.moment = moment;
-        this.until = until;
-        this.units = units;
-        this.elementType = "timeLiteral";
-    }
-    granular() {
-        return true;
-    }
-    static parse(possibleLiteral) {
-        const s = possibleLiteral.slice(1);
-        const fYear = "yyyy";
-        const fMonth = `${fYear}-LL`;
-        const fDay = `${fMonth}-dd`;
-        const fMinute = `${fDay} HH:mm`;
-        const fSecond = `${fMinute}:ss`;
-        const tss = luxon_1.DateTime.fromFormat(s, fSecond);
-        if (tss.isValid) {
-            const nextSecond = tss.plus({ second: 1 }).toFormat(fSecond);
-            const tsLit = new GranularLiteral(s, nextSecond, "second");
-            tsLit.timeType = "timestamp";
-            return tsLit;
-        }
-        const tsm = luxon_1.DateTime.fromFormat(s, fMinute);
-        if (tsm.isValid) {
-            // working around a weird bigquery bug ...
-            const thisMin = s + ":00";
-            const nextMinute = tsm.plus({ minute: 1 }).toFormat(fMinute) + ":00";
-            const tsLit = new GranularLiteral(thisMin, nextMinute, "minute");
-            tsLit.timeType = "timestamp";
-            return tsLit;
-        }
-        const quarter = s.match(/(\d{4})-[qQ](\d)$/);
-        if (quarter) {
-            const qplus = Number.parseInt(quarter[2]) - 1;
-            let qstart = luxon_1.DateTime.fromFormat(quarter[1], "yyyy");
-            if (qplus > 0) {
-                qstart = qstart.plus({ quarters: qplus });
-            }
-            const qend = qstart.plus({ quarter: 1 });
-            return new GranularLiteral(`${qstart.toFormat(fDay)}`, `${qend.toFormat(fDay)}`, "quarter");
-        }
-        const yyyymmdd = luxon_1.DateTime.fromFormat(s, fDay);
-        if (yyyymmdd.isValid) {
-            const next = yyyymmdd.plus({ days: 1 });
-            return new GranularLiteral(`${yyyymmdd.toFormat(fDay)}`, `${next.toFormat(fDay)}`, "day");
-        }
-        const yyyymm = luxon_1.DateTime.fromFormat(s, fMonth);
-        if (yyyymm.isValid) {
-            const next = yyyymm.plus({ months: 1 });
-            return new GranularLiteral(`${yyyymm.toFormat(fDay)}`, `${next.toFormat(fDay)}`, "month");
-        }
-        const yyyy = luxon_1.DateTime.fromFormat(s, fYear);
-        if (yyyy.isValid) {
-            const year = yyyy.toFormat(`yyyy-01-01`);
-            const nextYear = yyyy.plus({ year: 1 }).toFormat(`yyyy-01-01`);
-            return new GranularLiteral(year, nextYear, "year");
-        }
-        if (s.startsWith("WK")) {
-            const yyyymmdd = luxon_1.DateTime.fromFormat(s.slice(2), fDay);
-            if (yyyymmdd.isValid) {
-                // wonky because luxon uses monday weeks and bigquery uses sunday weeks
-                let sunday = yyyymmdd;
-                if (yyyymmdd.weekday !== 7) {
-                    sunday = yyyymmdd.startOf("week").minus({ day: 1 });
-                }
-                const next = sunday.plus({ days: 7 });
-                return new GranularLiteral(`${sunday.toFormat(fDay)}`, `${next.toFormat(fDay)}`, "week");
-            }
-        }
-        return undefined;
-    }
-    apply(fs, op, left) {
-        const lhs = left.getExpression(fs);
-        if ((0, malloy_types_1.isTimeFieldType)(lhs.dataType)) {
-            let rangeType = "timestamp";
-            if (lhs.dataType === "date" && !this.timeType) {
-                rangeType = "date";
-            }
-            const range = new index_1.Range(new index_1.ExprTime(rangeType, (0, index_1.timeLiteral)(this.moment, rangeType, "UTC")), new index_1.ExprTime(rangeType, (0, index_1.timeLiteral)(this.until, rangeType, "UTC")));
-            return range.apply(fs, op, left);
-        }
-        return super.apply(fs, op, left);
-    }
-    getExpression(_fs) {
-        const dataType = this.timeType || "date";
-        const value = {
-            dataType,
-            aggregate: false,
-            value: (0, index_1.timeLiteral)(this.moment, dataType, "UTC"),
-        };
-        // Literals with date resolution can be used as timestamps or dates,
-        // this is the third attempt to make that work. It still feels like
-        // there should be a better way to make this happen, but the point
-        // at which the data is needed, the handle is gone to the ExpressionDef
-        // which would allow a method call into this class. I think the second
-        // if clause is redundant (see "parse" above, but I'm paranoid)
-        if (dataType == "date" && (0, malloy_types_1.isDateUnit)(this.units)) {
-            value.alsoTimestamp = true;
-        }
-        if (this.units != "second") {
-            return {
-                ...value,
-                timeframe: this.units,
-            };
-        }
-        return value;
-    }
-}
-exports.GranularLiteral = GranularLiteral;
-class ExprNow extends index_1.ExpressionDef {
-    constructor() {
-        super(...arguments);
-        this.elementType = "timestamp";
-    }
-    getExpression(_fs) {
-        return {
-            dataType: "timestamp",
-            aggregate: false,
-            value: [
-                {
-                    type: "dialect",
-                    function: "now",
-                },
-            ],
-        };
-    }
-}
-exports.ExprNow = ExprNow;
-class ExprDuration extends index_1.ExpressionDef {
-    constructor(n, timeframe) {
-        super({ n });
-        this.n = n;
-        this.timeframe = timeframe;
-        this.elementType = "duration";
-        this.legalChildTypes = [index_1.FT.timestampT, index_1.FT.dateT];
-    }
-    apply(fs, op, left) {
-        const lhs = left.getExpression(fs);
-        this.typeCheck(this, lhs);
-        if ((0, malloy_types_1.isTimeFieldType)(lhs.dataType) && (op === "+" || op === "-")) {
-            const num = this.n.getExpression(fs);
-            if (!index_1.FT.typeEq(num, index_1.FT.numberT)) {
-                this.log(`Duration units needs number not '${num.dataType}`);
-                return (0, index_1.errorFor)("illegal unit expression");
-            }
-            let resultGranularity;
-            // Only allow the output of this to be granular if the
-            // granularities match, this is still an area where
-            // more thought is required.
-            if ((0, index_1.isGranularResult)(lhs) && lhs.timeframe == this.timeframe) {
-                resultGranularity = lhs.timeframe;
-            }
-            if (lhs.dataType === "timestamp") {
-                const result = (0, index_1.timeOffset)("timestamp", lhs.value, op, num.value, this.timeframe);
-                return (0, index_1.timeResult)({
-                    dataType: "timestamp",
-                    aggregate: lhs.aggregate || num.aggregate,
-                    value: result,
-                }, resultGranularity);
-            }
-            return (0, index_1.timeResult)({
-                dataType: "date",
-                aggregate: lhs.aggregate || num.aggregate,
-                value: (0, index_1.timeOffset)("date", lhs.value, op, num.value, this.timeframe),
-            }, resultGranularity);
-        }
-        return super.apply(fs, op, left);
-    }
-    getExpression(_fs) {
-        return {
-            dataType: "duration",
-            aggregate: false,
-            value: ["__ERROR_DURATION_IS_NOT_A_VALUE__"],
-        };
-    }
-}
-exports.ExprDuration = ExprDuration;
-class ExprCompare extends index_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, index_1.isGranularResult)(rhs)) {
-                const newRight = new 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;
-class Apply extends ExprCompare {
-    constructor(left, right) {
-        super(left, "=", right);
-        this.left = left;
-        this.right = right;
-        this.elementType = "apply";
-    }
-}
-exports.Apply = Apply;
-const compareTypes = {
-    "~": [index_1.FT.stringT],
-    "!~": [index_1.FT.stringT],
-    "<": [index_1.FT.numberT, index_1.FT.stringT, index_1.FT.dateT, index_1.FT.timestampT],
-    "<=": [index_1.FT.numberT, index_1.FT.stringT, index_1.FT.dateT, index_1.FT.timestampT],
-    "=": [index_1.FT.numberT, index_1.FT.stringT, index_1.FT.dateT, index_1.FT.timestampT],
-    "!=": [index_1.FT.numberT, index_1.FT.stringT, index_1.FT.dateT, index_1.FT.timestampT],
-    ">=": [index_1.FT.numberT, index_1.FT.stringT, index_1.FT.dateT, index_1.FT.timestampT],
-    ">": [index_1.FT.numberT, index_1.FT.stringT, index_1.FT.dateT, index_1.FT.timestampT],
-};
-class PartialCompare extends index_1.ExpressionDef {
-    constructor(op, right) {
-        super({ right });
-        this.op = op;
-        this.right = right;
-        this.elementType = "<=> a";
-    }
-    granular() {
-        return this.right.granular();
-    }
-    apply(fs, op, expr) {
-        return this.right.apply(fs, this.op, expr);
-    }
-    requestExpression(_fs) {
-        return undefined;
-    }
-    getExpression(_fs) {
-        this.log(`Partial comparison does not have a value`);
-        return (0, index_1.errorFor)("no value for partial compare");
-    }
-}
-exports.PartialCompare = PartialCompare;
-/**
- * TODO: This is sort of a hand clone of the "Range" class, they should
- * be siblings of a common abstract classs.
- */
-class ForRange extends index_1.ExpressionDef {
-    constructor(from, duration, timeframe) {
-        super({ from, duration, timeframe });
-        this.from = from;
-        this.duration = duration;
-        this.timeframe = timeframe;
-        this.elementType = "forRange";
-        this.legalChildTypes = [index_1.FT.timestampT, index_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, index_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, index_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, index_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, index_1.timeOffset)("date", startV.value, "+", nV.value, units);
-            const rangeEnd = new index_1.ExprTime("date", rangeEndV);
-            return new index_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 = index_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, index_1.isGranularResult)(startV) && startV.alsoTimestamp;
-            if (!alreadyTs) {
-                // ... not a literal, need a cast
-                from = (0, index_1.castDateToTimestamp)(from);
-            }
-            rangeStart = new index_1.ExprTime("timestamp", from, startV.aggregate);
-        }
-        const to = (0, index_1.timeOffset)("timestamp", from, "+", nV.value, units);
-        const rangeEnd = new index_1.ExprTime("timestamp", to, startV.aggregate);
-        return new index_1.Range(rangeStart, rangeEnd).apply(fs, op, applyTo);
-    }
-    requestExpression(_fs) {
-        return undefined;
-    }
-    getExpression(_fs) {
-        this.log("A Range is not a value");
-        return (0, index_1.errorFor)("range has no value");
-    }
-}
-exports.ForRange = ForRange;
-class ExprTimeExtract extends index_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, index_1.errorFor)(`{this.name} arg count`);
-            }
-            const from = this.args[0];
-            if (from instanceof index_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, index_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, index_1.errorFor)(`${extractTo} bad type ${last.dataType}`);
-                }
-                if (!(0, malloy_types_1.isTimestampUnit)(extractTo)) {
-                    this.log(`Cannot extract ${extractTo} from a range`);
-                    return (0, index_1.errorFor)(`${extractTo} bad extraction`);
-                }
-                return {
-                    dataType: "number",
-                    aggregate: first.aggregate || last.aggregate,
-                    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",
-                        aggregate: argV.aggregate,
-                        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, index_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",
-};
-class ExprFunc extends index_1.ExpressionDef {
-    constructor(name, args) {
-        super({ args });
-        this.name = name;
-        this.args = args;
-        this.elementType = "function call()";
-    }
-    getExpression(fs) {
-        var _a, _b, _c;
-        let anyAggregate = false;
-        let collectType;
-        const funcCall = [`${this.name}(`];
-        for (const fexpr of this.args) {
-            const expr = fexpr.getExpression(fs);
-            if (expr.aggregate) {
-                anyAggregate = true;
-            }
-            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,
-            aggregate: anyAggregate,
-            value: (0, index_1.compressExpr)(funcCall),
-        };
-    }
-}
-exports.ExprFunc = ExprFunc;
-//# sourceMappingURL=ast-time-expr.js.map