@malloydata/malloy 0.0.22-dev230126015148 → 0.0.22-dev230202171033

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

@@ -1,225 +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.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.expressionType === checkThis.expressionType);
-    }
-    /**
-     * 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.expressionType != "scalar") {
-                    inspected = `${type.expressionType} ${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, expressionType: "scalar" };
-}
-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",
-        expressionType: "scalar",
-        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