@malloydata/malloy 0.0.1

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

@@ -0,0 +1,83 @@
+import { AtomicFieldType, Fragment, TimestampUnit, Expr, TimeFieldType } 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;
+    aggregate: boolean;
+}
+/**
+ * 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;

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

@@ -0,0 +1,215 @@
+"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.d.ts

@@ -0,0 +1,5 @@
+export * from "./ast-types";
+export * from "./ast-main";
+export * from "./ast-expr";
+export * from "./ast-time-expr";
+export * from "./time-utils";

package/dist/lang/ast/index.js

@@ -0,0 +1,34 @@
+"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.d.ts

@@ -0,0 +1,8 @@
+import { TimestampUnit, Expr, TimeFieldType, AtomicFieldType } from "../../model/malloy_types";
+import { GranularResult, TimeResult } from "./ast-types";
+export declare function timeOffset(timeType: TimeFieldType, from: Expr, op: "+" | "-", n: Expr, timeframe: TimestampUnit): Expr;
+export declare function castTo(castType: AtomicFieldType, from: Expr, safe?: boolean): Expr;
+export declare function castTimestampToDate(from: Expr, safe?: boolean): Expr;
+export declare function castDateToTimestamp(from: Expr, safe?: boolean): Expr;
+export declare function resolution(timeframe: string): TimeFieldType;
+export declare function timeResult(t: TimeResult, tt: TimestampUnit | undefined): TimeResult | GranularResult;

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

@@ -0,0 +1,83 @@
+"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.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;
+//# sourceMappingURL=time-utils.js.map

package/dist/lang/field-space.d.ts

@@ -0,0 +1,157 @@
+import { Dialect } from "../dialect";
+import * as model from "../model/malloy_types";
+import { ExploreField, FieldListEdit, FieldDeclaration, WildcardFieldReference, Join, FieldName, HasParameter, FieldCollectionMember, QueryItem, MalloyElement, FieldReference } from "./ast";
+import { SpaceField, SpaceEntry } from "./space-field";
+interface LookupFound {
+    found: SpaceEntry;
+    error: undefined;
+}
+interface LookupError {
+    error: string;
+    found: undefined;
+}
+export declare type LookupResult = LookupFound | LookupError;
+/**
+ * A FieldSpace is a hierarchy of namespaces, where the leaf nodes
+ * are fields. A FieldSpace can lookup fields, and generate a StructDef
+ */
+export interface FieldSpace {
+    type: "fieldSpace";
+    structDef(): model.StructDef;
+    emptyStructDef(): model.StructDef;
+    lookup(symbol: FieldName[]): LookupResult;
+    getDialect(): Dialect;
+    whenComplete: (step: () => void) => void;
+}
+/**
+ * The father of all FieldSpaces is a wrapper for a StructDef.
+ */
+export declare class StaticSpace implements FieldSpace {
+    readonly type = "fieldSpace";
+    private memoMap?;
+    protected fromStruct: model.StructDef;
+    constructor(sourceStructDef: model.StructDef);
+    whenComplete(step: () => void): void;
+    getDialect(): Dialect;
+    fromFieldDef(from: model.FieldDef): SpaceField;
+    private get map();
+    protected dropEntries(): void;
+    protected dropEntry(name: string): void;
+    protected entry(name: string): SpaceEntry | undefined;
+    protected setEntry(name: string, value: SpaceEntry): void;
+    protected entries(): [string, SpaceEntry][];
+    structDef(): model.StructDef;
+    emptyStructDef(): model.StructDef;
+    lookup(path: FieldName[]): LookupResult;
+}
+export declare type SourceSpec = model.StructDef | FieldSpace;
+/**
+ * Based on how things are constructed, the starting field space
+ * can either be another field space or an existing structdef.
+ * Using a SourceSpace allows a class to accept either one
+ * and use either version at some future time.
+ */
+declare class SourceSpace {
+    readonly sourceSpec: SourceSpec;
+    private spaceSpec;
+    private asFS?;
+    private asStruct?;
+    constructor(sourceSpec: SourceSpec);
+    get structDef(): model.StructDef;
+    get fieldSpace(): FieldSpace;
+}
+/**
+ * A FieldSpace which may undergo modification
+ */
+export declare class DynamicSpace extends StaticSpace {
+    protected final: model.StructDef | undefined;
+    protected source: SourceSpace;
+    outputFS?: QuerySpace;
+    completions: (() => void)[];
+    private complete;
+    constructor(extending: SourceSpec);
+    /**
+     * Factory for DynamicSpace when there are accept/except edits
+     * @param from A structdef which seeds this space
+     * @param choose A accept/except edit of the "from" fields
+     */
+    static filteredFrom(from: model.StructDef, choose?: FieldListEdit): DynamicSpace;
+    whenComplete(finalizeStep: () => void): void;
+    isComplete(): void;
+    protected setEntry(name: string, value: SpaceEntry): void;
+    addParameters(params: HasParameter[]): DynamicSpace;
+    newEntry(name: string, astEl: MalloyElement, entry: SpaceEntry): void;
+    addField(...defs: ExploreField[]): void;
+    addFieldDef(fd: model.FieldDef): void;
+    structDef(): model.StructDef;
+}
+declare type QuerySegType = "reduce" | "project" | "index";
+/**
+ * A namespace for Query operations. The have an input and an
+ * output set of fields.
+ */
+export declare abstract class QueryOperationSpace extends DynamicSpace {
+    abstract segType: QuerySegType;
+    astEl?: MalloyElement | undefined;
+    readonly queryInput: SourceSpace;
+    nestParent?: QuerySpace;
+    constructor(input: SourceSpec);
+    inputFS(): FieldSpace;
+    structDef(): model.StructDef;
+    abstract getPipeSegment(refineFrom: model.PipeSegment | undefined): model.PipeSegment;
+    addMembers(members: FieldCollectionMember[]): void;
+    addReference(ref: FieldReference): void;
+    addWild(wild: WildcardFieldReference): void;
+    log(s: string): void;
+}
+/**
+ * Reduce and project queries use a "QuerySpace"
+ */
+export declare abstract class QuerySpace extends QueryOperationSpace {
+    extendedInput?: DynamicSpace;
+    extendedFields: string[];
+    extendSource(extendField: Join | FieldDeclaration): void;
+    inputFS(): FieldSpace;
+    qfs(): FSPair;
+    checkUngroup(fn: FieldName, isExclude: boolean): void;
+    private extendInto;
+    getPipeSegment(refineFrom: model.QuerySegment | undefined): model.QuerySegment;
+    addQueryItems(...qiList: QueryItem[]): void;
+    canContain(_qd: model.QueryFieldDef): boolean;
+    protected queryFieldDefs(): model.QueryFieldDef[];
+}
+export declare class ReduceFieldSpace extends QuerySpace {
+    segType: QuerySegType;
+}
+export declare class ProjectFieldSpace extends QuerySpace {
+    segType: QuerySegType;
+    canContain(qd: model.QueryFieldDef): boolean;
+}
+export declare class IndexFieldSpace extends QueryOperationSpace {
+    segType: QuerySegType;
+    fieldList: Set<string>;
+    addReference(ref: FieldReference): void;
+    addWild(wild: WildcardFieldReference): void;
+    getPipeSegment(refineIndex?: model.PipeSegment): model.IndexSegment;
+}
+/**
+ * Used to detect references to fields in the statement which defines them
+ */
+export declare class DefSpace implements FieldSpace {
+    readonly realFS: FieldSpace;
+    readonly circular: FieldDeclaration;
+    readonly type = "fieldSpace";
+    foundCircle: boolean;
+    constructor(realFS: FieldSpace, circular: FieldDeclaration);
+    structDef(): model.StructDef;
+    emptyStructDef(): model.StructDef;
+    lookup(symbol: FieldName[]): LookupResult;
+    getDialect(): Dialect;
+    whenComplete(step: () => void): void;
+}
+export interface FSPair {
+    in: FieldSpace;
+    out: FieldSpace;
+}
+export declare function fsPair(inFS: FieldSpace, outFS?: FieldSpace): FSPair;
+export {};