@malloydata/malloy 0.0.22-dev230126015148 → 0.0.22-dev230206094309

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

@@ -1,69 +0,0 @@
-import { TimestampUnit, ExtractUnit, TimeFieldType } from "../../model/malloy_types";
-import { Comparison, ExprValue } from "./ast-types";
-import { ExpressionDef, FieldSpace, MalloyElement } from "./ast-main";
-export declare class Timeframe extends MalloyElement {
-    elementType: string;
-    readonly text: TimestampUnit;
-    constructor(timeframeName: string);
-}
-/**
- * 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;
-}
-export declare class ExprNow extends ExpressionDef {
-    elementType: string;
-    getExpression(_fs: FieldSpace): ExprValue;
-}
-export declare class PartialCompare extends ExpressionDef {
-    readonly op: Comparison;
-    readonly right: ExpressionDef;
-    elementType: string;
-    constructor(op: Comparison, right: ExpressionDef);
-    granular(): boolean;
-    apply(fs: FieldSpace, op: string, expr: ExpressionDef): ExprValue;
-    requestExpression(_fs: FieldSpace): ExprValue | undefined;
-    getExpression(_fs: FieldSpace): ExprValue;
-}
-/**
- * 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("./ast-types").FragType[];
-    constructor(from: ExpressionDef, duration: ExpressionDef, timeframe: Timeframe);
-    apply(fs: FieldSpace, op: string, expr: ExpressionDef): ExprValue;
-    requestExpression(_fs: FieldSpace): ExprValue | undefined;
-    getExpression(_fs: FieldSpace): ExprValue;
-}
-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;
-}
-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/ast-time-expr.js

@@ -1,389 +0,0 @@
-"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 = exports.ExprTimeExtract = exports.ForRange = exports.PartialCompare = exports.ExprNow = exports.GranularLiteral = exports.Timeframe = void 0;
-const luxon_1 = require("luxon");
-const malloy_types_1 = require("../../model/malloy_types");
-const ast_types_1 = require("./ast-types");
-const time_utils_1 = require("./time-utils");
-const ast_main_1 = require("./ast-main");
-class Timeframe extends ast_main_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 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 ast_main_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 ast_main_1.Range(new ast_main_1.ExprTime(rangeType, (0, time_utils_1.timeLiteral)(this.moment, rangeType, "UTC")), new ast_main_1.ExprTime(rangeType, (0, time_utils_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,
-            expressionType: "scalar",
-            value: (0, time_utils_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 ast_main_1.ExpressionDef {
-    constructor() {
-        super(...arguments);
-        this.elementType = "timestamp";
-    }
-    getExpression(_fs) {
-        return {
-            dataType: "timestamp",
-            expressionType: "scalar",
-            value: [
-                {
-                    type: "dialect",
-                    function: "now",
-                },
-            ],
-        };
-    }
-}
-exports.ExprNow = ExprNow;
-class PartialCompare extends ast_main_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, ast_types_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 ast_main_1.ExpressionDef {
-    constructor(from, duration, timeframe) {
-        super({ from, duration, timeframe });
-        this.from = from;
-        this.duration = duration;
-        this.timeframe = timeframe;
-        this.elementType = "forRange";
-        this.legalChildTypes = [ast_types_1.FT.timestampT, ast_types_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_types_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_types_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 ast_main_1.ExprTime("date", rangeEndV);
-            return new ast_main_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 = ast_main_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, ast_types_1.isGranularResult)(startV) && startV.alsoTimestamp;
-            if (!alreadyTs) {
-                // ... not a literal, need a cast
-                from = (0, time_utils_1.castDateToTimestamp)(from);
-            }
-            rangeStart = new ast_main_1.ExprTime("timestamp", from, startV.expressionType);
-        }
-        const to = (0, time_utils_1.timeOffset)("timestamp", from, "+", nV.value, units);
-        const rangeEnd = new ast_main_1.ExprTime("timestamp", to, startV.expressionType);
-        return new ast_main_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_types_1.errorFor)("range has no value");
-    }
-}
-exports.ForRange = ForRange;
-class ExprTimeExtract extends ast_main_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_types_1.errorFor)(`{this.name} arg count`);
-            }
-            const from = this.args[0];
-            if (from instanceof ast_main_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_types_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_types_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_types_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_types_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 ast_main_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, ast_types_1.compressExpr)(funcCall),
-        };
-    }
-}
-exports.ExprFunc = ExprFunc;
-//# sourceMappingURL=ast-time-expr.js.map

package/dist/lang/ast/ast-types.d.ts

@@ -1,83 +0,0 @@
-import { AtomicFieldType, Fragment, TimestampUnit, Expr, TimeFieldType, ExpressionType } from "../../model/malloy_types";
-export declare type ExpressionValueType = AtomicFieldType | "null" | "unknown" | "duration" | "regular expression";
-export declare function isExpressionValueType(fv: FieldValueType): fv is ExpressionValueType;
-export declare type StageFieldType = "turtle";
-export declare type FieldValueType = ExpressionValueType | StageFieldType | "struct";
-export interface FragType {
-    dataType: FieldValueType;
-    expressionType: ExpressionType;
-}
-/**
- * Collects functions which operate on fragtype compatible objects
- */
-export declare class FT {
-    /**
-     * Checks if a given type is in a list
-     * @param check The type to check (can be undefined)
-     * @param from List of types which are OK
-     */
-    static in(check: FragType | undefined, from: FragType[]): boolean;
-    /**
-     * Checks if a possibly undefined candidate matches a type
-     * @param good The real type
-     * @param checkThis The possibly undefined candidate
-     */
-    static eq(good: FragType, checkThis: FragType | undefined): boolean;
-    /**
-     * Checks if the base types, ignoring aggregate, are equal
-     * @param left Left type
-     * @param right Right type
-     * @param nullOk True if a NULL is an acceptable match
-     */
-    static typeEq(left: FragType, right: FragType, nullOk?: boolean): boolean;
-    /**
-     *
-     * For error messages, returns a comma seperated list of readable names
-     * for a list of types.
-     * @param types List of type or objects with types
-     */
-    static inspect(...types: (FragType | undefined)[]): string;
-    static nullT: FragType;
-    static numberT: FragType;
-    static stringT: FragType;
-    static dateT: FragType;
-    static timestampT: FragType;
-    static boolT: FragType;
-    static anyAtomicT: FragType[];
-}
-export declare type ExprValue = ExprResult | GranularResult;
-export interface ExprResult extends FragType {
-    value: Fragment[];
-}
-export interface TimeResult extends ExprResult {
-    dataType: TimeFieldType;
-    alsoTimestamp?: true;
-}
-export interface GranularResult extends TimeResult {
-    timeframe: TimestampUnit;
-}
-export declare function isGranularResult(v: ExprValue): v is GranularResult;
-/**
- * When a translation hits an error, log and return one of these as a value.
- * This will allow the rest of the translation walk to complete. The
- * generated SQL will have a reference to an impossible variable name
- * with the reason embedded in it.
- * @param reason very short phrase, only read by implementers
- * @returns Fragment[] which a debugging humnan will regognize
- */
-export declare function errorFor(reason: string): ExprValue;
-export declare function compressExpr(expr: Expr): Expr;
-/**
- * Compose a binary expression. Tries to write them safely and concisely
- * @param left
- * @param op
- * @param right
- * @returns Fragment list of the composed expression
- */
-export declare function compose(left: Fragment[], op: string, right: Fragment[]): Fragment[];
-export declare function dateOffset(from: Fragment[], op: "+" | "-", n: Fragment[], timeframe: TimestampUnit): Fragment[];
-export declare function timestampOffset(from: Fragment[], op: "+" | "-", n: Fragment[], timeframe: TimestampUnit, fromNotTimestamp?: boolean): Fragment[];
-export declare type Comparison = "~" | "!~" | "<" | "<=" | "=" | ">" | ">=" | "!=";
-export declare function isComparison(s: string): s is Comparison;
-export declare type Equality = "~" | "!~" | "=" | "!=";
-export declare function isEquality(s: string): s is Equality;