@malloydata/malloy 0.0.2 → 0.0.4

package/dist/lang/ast/ast-types.js

@@ -1,215 +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.isEquality = exports.isComparison = exports.timestampOffset = exports.dateOffset = exports.compose = exports.compressExpr = exports.errorFor = exports.isGranularResult = exports.FT = exports.isExpressionValueType = void 0;
-const malloy_types_1 = require("../../model/malloy_types");
-function isExpressionValueType(fv) {
-    return ((0, malloy_types_1.isAtomicFieldType)(fv) ||
-        ["null", "unknown", "duration", "regular expression"].includes(fv));
-}
-exports.isExpressionValueType = isExpressionValueType;
-/**
- * Collects functions which operate on fragtype compatible objects
- */
-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, from) {
-        if (check) {
-            const found = from.find((okType) => FT.eq(okType, check));
-            return found !== undefined;
-        }
-        return false;
-    }
-    /**
-     * Checks if a possibly undefined candidate matches a type
-     * @param good The real type
-     * @param checkThis The possibly undefined candidate
-     */
-    static eq(good, checkThis) {
-        return (checkThis !== undefined &&
-            good.dataType === checkThis.dataType &&
-            good.aggregate === checkThis.aggregate);
-    }
-    /**
-     * 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, right, nullOk = false) {
-        const maybeEq = left.dataType === right.dataType;
-        const nullEq = nullOk && (left.dataType === "null" || right.dataType === "null");
-        return maybeEq || nullEq;
-    }
-    /**
-     *
-     * 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) {
-        const strings = types.map((type) => {
-            if (type) {
-                let inspected = type.dataType;
-                if (type.aggregate) {
-                    inspected = `aggregate ${inspected}`;
-                }
-                return inspected;
-            }
-            return "undefined";
-        });
-        return strings.join(",");
-    }
-}
-exports.FT = FT;
-FT.nullT = mkFragType("null");
-FT.numberT = mkFragType("number");
-FT.stringT = mkFragType("string");
-FT.dateT = mkFragType("date");
-FT.timestampT = mkFragType("timestamp");
-FT.boolT = mkFragType("boolean");
-FT.anyAtomicT = [
-    FT.numberT,
-    FT.stringT,
-    FT.dateT,
-    FT.timestampT,
-    FT.boolT,
-];
-function mkFragType(dType) {
-    return { dataType: dType, aggregate: false };
-}
-function isGranularResult(v) {
-    if (v.dataType !== "date" && v.dataType !== "timestamp") {
-        return false;
-    }
-    return v.timeframe !== undefined;
-}
-exports.isGranularResult = isGranularResult;
-/**
- * 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
- */
-function errorFor(reason) {
-    return {
-        dataType: "unknown",
-        aggregate: false,
-        value: [`_ERROR_${reason.replace(/ /g, "_")}`],
-    };
-}
-exports.errorFor = errorFor;
-/**
- * If the passed expresion is not a single term, wrap it in parens
- * @param f expression fragment
- */
-function term(f) {
-    if (f.length > 1) {
-        return ["(", ...f, ")"];
-    }
-    if (f.length === 0) {
-        // Trying to compose a binary expresion with an entity that has no value
-        // this should at least cause the generated SQL to error, but likely
-        // there has already been a semantic error reported.
-        return ["__MISSING_VALUE__"];
-    }
-    return f;
-}
-function compressExpr(expr) {
-    // compress all adjacent strings
-    const compressValue = [];
-    let buildString;
-    for (const fragment of expr.flat()) {
-        if (typeof fragment === "string") {
-            buildString = buildString ? buildString + fragment : fragment;
-        }
-        else {
-            if (buildString) {
-                compressValue.push(buildString);
-                buildString = undefined;
-            }
-            compressValue.push(fragment);
-        }
-    }
-    if (buildString) {
-        compressValue.push(buildString);
-    }
-    return compressValue;
-}
-exports.compressExpr = compressExpr;
-/**
- * Compose a binary expression. Tries to write them safely and concisely
- * @param left
- * @param op
- * @param right
- * @returns Fragment list of the composed expression
- */
-function compose(left, op, right) {
-    const opAlpha = op.match(/^[A-Za-z]/);
-    const leftSpace = left.length === 1 && opAlpha ? " " : "";
-    const rightSpace = right.length === 1 && opAlpha ? " " : "";
-    const newOp = leftSpace + op + rightSpace;
-    return [...term(left), newOp, ...term(right)];
-}
-exports.compose = compose;
-function dateOffset(from, op, n, timeframe) {
-    const add = op === "+" ? "_ADD" : "_SUB";
-    const units = timeframe.toUpperCase();
-    return compressExpr([
-        `DATE${add}(`,
-        ...from,
-        `,INTERVAL `,
-        ...n,
-        ` ${units})`,
-    ]);
-}
-exports.dateOffset = dateOffset;
-function timestampOffset(from, op, n, timeframe, fromNotTimestamp = false) {
-    const useDatetime = ["week", "month", "quarter", "year"].includes(timeframe);
-    const add = op === "+" ? "_ADD" : "_SUB";
-    const units = timeframe.toUpperCase();
-    if (useDatetime) {
-        return [
-            `TIMESTAMP(DATETIME${add}(DATETIME(`,
-            ...from,
-            `),INTERVAL `,
-            ...n,
-            ` ${units}))`,
-        ];
-    }
-    const typeFrom = fromNotTimestamp ? ["TIMESTAMP(", ...from, ")"] : from;
-    return compressExpr([
-        `TIMESTAMP${add}(`,
-        ...typeFrom,
-        `,INTERVAL `,
-        ...n,
-        ` ${units})`,
-    ]);
-}
-exports.timestampOffset = timestampOffset;
-function isComparison(s) {
-    return ["~", "!~", "<", "<=", "=", ">", ">=", "!="].includes(s);
-}
-exports.isComparison = isComparison;
-function isEquality(s) {
-    return ["~", "!~", "=", "!="].includes(s);
-}
-exports.isEquality = isEquality;
-//# sourceMappingURL=ast-types.js.map

package/dist/lang/ast/index.js

@@ -1,34 +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.
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./ast-types"), exports);
-__exportStar(require("./ast-main"), exports);
-__exportStar(require("./ast-expr"), exports);
-__exportStar(require("./ast-time-expr"), exports);
-__exportStar(require("./time-utils"), exports);
-//# sourceMappingURL=index.js.map

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

@@ -1,94 +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.timeLiteral = exports.timeResult = exports.resolution = exports.castDateToTimestamp = exports.castTimestampToDate = exports.castTo = exports.timeOffset = void 0;
-function timeOffset(timeType, from, op, n, timeframe) {
-    return [
-        {
-            type: "dialect",
-            function: "delta",
-            base: { valueType: timeType, value: from },
-            op,
-            delta: n,
-            units: timeframe,
-        },
-    ];
-}
-exports.timeOffset = timeOffset;
-function castTo(castType, from, safe = false) {
-    const cast = {
-        type: "dialect",
-        function: "cast",
-        dstType: castType,
-        expr: from,
-        safe,
-    };
-    return [cast];
-}
-exports.castTo = castTo;
-function castTimestampToDate(from, safe = false) {
-    const cast = {
-        type: "dialect",
-        function: "cast",
-        dstType: "date",
-        srcType: "timestamp",
-        expr: from,
-        safe,
-    };
-    return [cast];
-}
-exports.castTimestampToDate = castTimestampToDate;
-function castDateToTimestamp(from, safe = false) {
-    const cast = {
-        type: "dialect",
-        function: "cast",
-        dstType: "timestamp",
-        srcType: "date",
-        expr: from,
-        safe,
-    };
-    return [cast];
-}
-exports.castDateToTimestamp = castDateToTimestamp;
-function resolution(timeframe) {
-    switch (timeframe) {
-        case "hour":
-        case "minute":
-        case "second":
-        case "microsecond":
-        case "millisecond":
-            return "timestamp";
-    }
-    return "date";
-}
-exports.resolution = resolution;
-function timeResult(t, tt) {
-    if (tt) {
-        return { ...t, timeframe: tt };
-    }
-    return t;
-}
-exports.timeResult = timeResult;
-function timeLiteral(literalStr, timeType, tz) {
-    const fragment = {
-        type: "dialect",
-        function: "timeLiteral",
-        literal: literalStr,
-        literalType: timeType,
-        timezone: tz,
-    };
-    return [fragment];
-}
-exports.timeLiteral = timeLiteral;
-//# sourceMappingURL=time-utils.js.map