@malloydata/malloy 0.0.22-dev230207144036 → 0.0.22-dev230207180844

package/dist/lang/ast/field-space/static-space.js

@@ -0,0 +1,156 @@
+"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.StructSpaceField = exports.StaticSpace = void 0;
+const dialect_map_1 = require("../../../dialect/dialect_map");
+const malloy_types_1 = require("../../../model/malloy_types");
+const space_param_1 = require("../types/space-param");
+const space_field_1 = require("../types/space-field");
+const struct_space_field_base_1 = require("./struct-space-field-base");
+const column_space_field_1 = require("./column-space-field");
+const query_field_struct_1 = require("./query-field-struct");
+class StaticSpace {
+    constructor(sourceStructDef) {
+        this.type = "fieldSpace";
+        this.fromStruct = sourceStructDef;
+    }
+    whenComplete(step) {
+        step();
+    }
+    dialectObj() {
+        try {
+            return (0, dialect_map_1.getDialect)(this.fromStruct.dialect);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    defToSpaceField(from) {
+        if (from.type === "struct") {
+            return new StructSpaceField(from);
+        }
+        else if ((0, malloy_types_1.isTurtleDef)(from)) {
+            return new query_field_struct_1.QueryFieldStruct(this, from);
+        }
+        return new column_space_field_1.ColumnSpaceField(from);
+    }
+    get map() {
+        if (this.memoMap === undefined) {
+            this.memoMap = {};
+            for (const f of this.fromStruct.fields) {
+                const name = f.as || f.name;
+                this.memoMap[name] = this.defToSpaceField(f);
+            }
+            if (this.fromStruct.parameters) {
+                for (const [paramName, paramDef] of Object.entries(this.fromStruct.parameters)) {
+                    if (this.memoMap[paramName]) {
+                        throw new Error(`In struct '${this.fromStruct.as || this.fromStruct.name}': ` +
+                            ` : Field and parameter name conflict '${paramName}`);
+                    }
+                    this.memoMap[paramName] = new space_param_1.DefinedParameter(paramDef);
+                }
+            }
+        }
+        return this.memoMap;
+    }
+    dropEntries() {
+        this.memoMap = {};
+    }
+    dropEntry(name) {
+        delete this.map[name];
+    }
+    entry(name) {
+        return this.map[name];
+    }
+    setEntry(name, value) {
+        this.map[name] = value;
+    }
+    entries() {
+        return Object.entries(this.map);
+    }
+    structDef() {
+        return this.fromStruct;
+    }
+    emptyStructDef() {
+        return { ...this.fromStruct, fields: [] };
+    }
+    lookup(path) {
+        const head = path[0];
+        const rest = path.slice(1);
+        const found = this.entry(head.refString);
+        if (!found) {
+            return { error: `'${head}' is not defined`, found };
+        }
+        if (found instanceof space_field_1.SpaceField) {
+            /*
+             * TODO cache defs, post the addReference call to whenComplete
+             *
+             * In the cleanup phase of query space construction, it may check
+             * the output space for ungrouping variables. However if an
+             * ungrouping variable is a measure, the field expression value
+             * needed to get the definition needs to be computed in the
+             * input space of the query. There is a test which failed which
+             * caused this code to be here, but this is really a bandaid.
+             *
+             * Some re-work of how to get the definition of a SpaceField
+             * no matter what it is contained in needs to be thought out.
+             *
+             * ... or this check would look at the finalized output of
+             * the namespace and not re-compile ...
+             */
+            const definition = found.fieldDef();
+            if (definition) {
+                head.addReference({
+                    type: found instanceof struct_space_field_base_1.StructSpaceFieldBase
+                        ? "joinReference"
+                        : "fieldReference",
+                    definition,
+                    location: head.location,
+                    text: head.refString,
+                });
+            }
+        }
+        if (rest.length) {
+            if (found instanceof struct_space_field_base_1.StructSpaceFieldBase) {
+                return found.fieldSpace.lookup(rest);
+            }
+            return {
+                error: `'${head}' cannot contain a '${rest[0]}'`,
+                found: undefined,
+            };
+        }
+        return { found, error: undefined };
+    }
+}
+exports.StaticSpace = StaticSpace;
+class StructSpaceField extends struct_space_field_base_1.StructSpaceFieldBase {
+    constructor(def) {
+        super(def);
+    }
+    get fieldSpace() {
+        return new StaticSpace(this.sourceDef);
+    }
+}
+exports.StructSpaceField = StructSpaceField;
+//# sourceMappingURL=static-space.js.map

package/dist/lang/ast/field-space/struct-space-field-base.d.ts

@@ -0,0 +1,11 @@
+import { FieldDef, StructDef } from "../../../model/malloy_types";
+import { FieldSpace } from "../types/field-space";
+import { SpaceField } from "../types/space-field";
+import { TypeDesc } from "../types/type-desc";
+export declare abstract class StructSpaceFieldBase extends SpaceField {
+    protected sourceDef: StructDef;
+    constructor(sourceDef: StructDef);
+    abstract get fieldSpace(): FieldSpace;
+    fieldDef(): FieldDef;
+    typeDesc(): TypeDesc;
+}

package/dist/lang/ast/field-space/struct-space-field-base.js

@@ -0,0 +1,40 @@
+"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.StructSpaceFieldBase = void 0;
+const space_field_1 = require("../types/space-field");
+class StructSpaceFieldBase extends space_field_1.SpaceField {
+    constructor(sourceDef) {
+        super();
+        this.sourceDef = sourceDef;
+    }
+    fieldDef() {
+        return this.sourceDef;
+    }
+    typeDesc() {
+        return { dataType: "struct", expressionType: "scalar" };
+    }
+}
+exports.StructSpaceFieldBase = StructSpaceFieldBase;
+//# sourceMappingURL=struct-space-field-base.js.map

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

@@ -0,0 +1,10 @@
+import { QueryFieldDef } from "../../../model/malloy_types";
+import { FieldSpace } from "../types/field-space";
+import { SpaceField } from "../types/space-field";
+import { TypeDesc } from "../types/type-desc";
+export declare class WildSpaceField extends SpaceField {
+    readonly wildText: string;
+    constructor(wildText: string);
+    typeDesc(): TypeDesc;
+    getQueryFieldDef(_fs: FieldSpace): QueryFieldDef;
+}

package/dist/lang/ast/field-space/wild-space-field.js

@@ -0,0 +1,40 @@
+"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.WildSpaceField = void 0;
+const space_field_1 = require("../types/space-field");
+class WildSpaceField extends space_field_1.SpaceField {
+    constructor(wildText) {
+        super();
+        this.wildText = wildText;
+    }
+    typeDesc() {
+        throw new Error("should never ask a wild field for its type");
+    }
+    getQueryFieldDef(_fs) {
+        return this.wildText;
+    }
+}
+exports.WildSpaceField = WildSpaceField;
+//# sourceMappingURL=wild-space-field.js.map

package/dist/lang/ast/fragtype-utils.d.ts

@@ -0,0 +1,39 @@
+import { TypeDesc } from "./types/type-desc";
+/**
+ * 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: TypeDesc | undefined, from: TypeDesc[]): boolean;
+    /**
+     * Checks if a possibly undefined candidate matches a type
+     * @param good The real type
+     * @param checkThis The possibly undefined candidate
+     */
+    static eq(good: TypeDesc, checkThis: TypeDesc | 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: TypeDesc, right: TypeDesc, 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: (TypeDesc | undefined)[]): string;
+    static nullT: TypeDesc;
+    static numberT: TypeDesc;
+    static stringT: TypeDesc;
+    static dateT: TypeDesc;
+    static timestampT: TypeDesc;
+    static boolT: TypeDesc;
+    static anyAtomicT: TypeDesc[];
+}

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

@@ -0,0 +1,100 @@
+"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.FT = void 0;
+function mkFragType(dType) {
+    return { dataType: dType, expressionType: "scalar" };
+}
+/**
+ * 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,
+];
+//# sourceMappingURL=fragtype-utils.js.map

package/dist/lang/ast/index.d.ts

@@ -0,0 +1,90 @@
+export * from "./query-properties/nest";
+export * from "./elements/define-source";
+export * from "./elements/define-query";
+export * from "./elements/source";
+export * from "./elements/refined-source";
+export * from "./source-properties/field-list-edit";
+export * from "./source-properties/primary-key";
+export * from "./source-properties/renames";
+export * from "./source-properties/turtles";
+export * from "./expressions/apply";
+export * from "./expressions/binary-numeric";
+export * from "./expressions/boolean";
+export * from "./expressions/expr-add-sub";
+export * from "./expressions/expr-aggregate-function";
+export * from "./expressions/expr-alternation-tree";
+export * from "./expressions/expr-asymmetric";
+export * from "./expressions/expr-avg";
+export * from "./expressions/expr-cast";
+export * from "./expressions/expr-compare";
+export * from "./expressions/expr-count";
+export * from "./expressions/expr-count-distinct";
+export * from "./expressions/expr-filter";
+export * from "./expressions/expr-func";
+export * from "./expressions/expr-granular-time";
+export * from "./expressions/expr-id-reference";
+export * from "./expressions/expr-logical-op";
+export * from "./expressions/expr-max";
+export * from "./expressions/expr-min";
+export * from "./expressions/expr-minus";
+export * from "./expressions/expr-mul-div";
+export * from "./expressions/expr-not";
+export * from "./expressions/expr-now";
+export * from "./expressions/expr-null";
+export * from "./expressions/expr-number";
+export * from "./expressions/expr-parens";
+export * from "./expressions/expr-regex";
+export * from "./expressions/expr-string";
+export * from "./expressions/expr-sum";
+export * from "./expressions/expr-time-extract";
+export * from "./expressions/expr-ungroup";
+export * from "./expressions/for-range";
+export * from "./expressions/granular-literal";
+export * from "./expressions/partial-compare";
+export * from "./expressions/pick-when";
+export * from "./expressions/range";
+export * from "./expressions/time-frame";
+export * from "./expressions/top-by";
+export * from "./expressions/unary";
+export * from "./expressions/utils";
+export * from "./elements/import-statement";
+export * from "./query-properties/nest-reference";
+export * from "./parameters/has-parameter";
+export * from "./query-elements/anonymous-query";
+export * from "./query-elements/existing-query";
+export * from "./query-elements/full-query";
+export * from "./query-items/field-declaration";
+export * from "./query-items/field-references";
+export * from "./query-properties/aggregate";
+export * from "./query-properties/declare-fields";
+export * from "./query-properties/dimmensions";
+export * from "./query-properties/filters";
+export * from "./query-properties/group-by";
+export * from "./query-properties/indexing";
+export * from "./query-properties/joins";
+export * from "./query-properties/limit";
+export * from "./query-properties/measures";
+export * from "./query-properties/nests";
+export * from "./query-properties/ordering";
+export * from "./query-properties/project-statement";
+export * from "./query-properties/qop-desc";
+export * from "./query-properties/sampling";
+export * from "./query-properties/top";
+export * from "./sources/named-source";
+export * from "./sources/query-source";
+export * from "./sources/sql-source";
+export * from "./sources/table-source";
+export * from "./sql-elements/sql-statement";
+export * from "./sql-elements/sql-string";
+export * from "./types/comparison";
+export * from "./types/explore-desc";
+export * from "./types/source-property";
+export * from "./types/expression-def";
+export * from "./types/field-collection-member";
+export * from "./types/field-space";
+export * from "./types/malloy-element";
+export * from "./types/nested-query";
+export * from "./types/query-element";
+export * from "./types/query-item";
+export * from "./types/query-property";
+export * from "./types/turtle-headed-pipe";

package/dist/lang/ast/index.js

@@ -0,0 +1,129 @@
+"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.
+ */
+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("./query-properties/nest"), exports);
+__exportStar(require("./elements/define-source"), exports);
+__exportStar(require("./elements/define-query"), exports);
+__exportStar(require("./elements/source"), exports);
+__exportStar(require("./elements/refined-source"), exports);
+__exportStar(require("./source-properties/field-list-edit"), exports);
+__exportStar(require("./source-properties/primary-key"), exports);
+__exportStar(require("./source-properties/renames"), exports);
+__exportStar(require("./source-properties/turtles"), exports);
+__exportStar(require("./expressions/apply"), exports);
+__exportStar(require("./expressions/binary-numeric"), exports);
+__exportStar(require("./expressions/boolean"), exports);
+__exportStar(require("./expressions/expr-add-sub"), exports);
+__exportStar(require("./expressions/expr-aggregate-function"), exports);
+__exportStar(require("./expressions/expr-alternation-tree"), exports);
+__exportStar(require("./expressions/expr-asymmetric"), exports);
+__exportStar(require("./expressions/expr-avg"), exports);
+__exportStar(require("./expressions/expr-cast"), exports);
+__exportStar(require("./expressions/expr-compare"), exports);
+__exportStar(require("./expressions/expr-count"), exports);
+__exportStar(require("./expressions/expr-count-distinct"), exports);
+__exportStar(require("./expressions/expr-filter"), exports);
+__exportStar(require("./expressions/expr-func"), exports);
+__exportStar(require("./expressions/expr-granular-time"), exports);
+__exportStar(require("./expressions/expr-id-reference"), exports);
+__exportStar(require("./expressions/expr-logical-op"), exports);
+__exportStar(require("./expressions/expr-max"), exports);
+__exportStar(require("./expressions/expr-min"), exports);
+__exportStar(require("./expressions/expr-minus"), exports);
+__exportStar(require("./expressions/expr-mul-div"), exports);
+__exportStar(require("./expressions/expr-not"), exports);
+__exportStar(require("./expressions/expr-now"), exports);
+__exportStar(require("./expressions/expr-null"), exports);
+__exportStar(require("./expressions/expr-number"), exports);
+__exportStar(require("./expressions/expr-parens"), exports);
+__exportStar(require("./expressions/expr-regex"), exports);
+__exportStar(require("./expressions/expr-string"), exports);
+__exportStar(require("./expressions/expr-sum"), exports);
+__exportStar(require("./expressions/expr-time-extract"), exports);
+__exportStar(require("./expressions/expr-ungroup"), exports);
+__exportStar(require("./expressions/for-range"), exports);
+__exportStar(require("./expressions/granular-literal"), exports);
+__exportStar(require("./expressions/partial-compare"), exports);
+__exportStar(require("./expressions/pick-when"), exports);
+__exportStar(require("./expressions/range"), exports);
+__exportStar(require("./expressions/time-frame"), exports);
+__exportStar(require("./expressions/top-by"), exports);
+__exportStar(require("./expressions/unary"), exports);
+__exportStar(require("./expressions/utils"), exports);
+__exportStar(require("./elements/import-statement"), exports);
+__exportStar(require("./query-properties/nest-reference"), exports);
+__exportStar(require("./parameters/has-parameter"), exports);
+__exportStar(require("./query-elements/anonymous-query"), exports);
+__exportStar(require("./query-elements/existing-query"), exports);
+__exportStar(require("./query-elements/full-query"), exports);
+__exportStar(require("./query-items/field-declaration"), exports);
+__exportStar(require("./query-items/field-references"), exports);
+__exportStar(require("./query-properties/aggregate"), exports);
+__exportStar(require("./query-properties/declare-fields"), exports);
+__exportStar(require("./query-properties/dimmensions"), exports);
+__exportStar(require("./query-properties/filters"), exports);
+__exportStar(require("./query-properties/group-by"), exports);
+__exportStar(require("./query-properties/indexing"), exports);
+__exportStar(require("./query-properties/joins"), exports);
+__exportStar(require("./query-properties/limit"), exports);
+__exportStar(require("./query-properties/measures"), exports);
+__exportStar(require("./query-properties/nests"), exports);
+__exportStar(require("./query-properties/ordering"), exports);
+__exportStar(require("./query-properties/project-statement"), exports);
+__exportStar(require("./query-properties/qop-desc"), exports);
+__exportStar(require("./query-properties/sampling"), exports);
+__exportStar(require("./query-properties/top"), exports);
+__exportStar(require("./sources/named-source"), exports);
+__exportStar(require("./sources/query-source"), exports);
+__exportStar(require("./sources/sql-source"), exports);
+__exportStar(require("./sources/table-source"), exports);
+__exportStar(require("./sql-elements/sql-statement"), exports);
+__exportStar(require("./sql-elements/sql-string"), exports);
+__exportStar(require("./types/comparison"), exports);
+__exportStar(require("./types/explore-desc"), exports);
+__exportStar(require("./types/source-property"), exports);
+__exportStar(require("./types/expression-def"), exports);
+__exportStar(require("./types/field-collection-member"), exports);
+__exportStar(require("./types/field-space"), exports);
+__exportStar(require("./types/malloy-element"), exports);
+__exportStar(require("./types/nested-query"), exports);
+__exportStar(require("./types/query-element"), exports);
+__exportStar(require("./types/query-item"), exports);
+__exportStar(require("./types/query-property"), exports);
+__exportStar(require("./types/turtle-headed-pipe"), exports);
+//# sourceMappingURL=index.js.map

package/dist/lang/ast/parameters/constant-parameter.d.ts

@@ -0,0 +1,8 @@
+import { Parameter } from "../../../model/malloy_types";
+import { ConstantSubExpression } from "../expressions/constant-sub-expression";
+import { HasParameter } from "./has-parameter";
+export declare class ConstantParameter extends HasParameter {
+    readonly value: ConstantSubExpression;
+    constructor(name: string, value: ConstantSubExpression);
+    parameter(): Parameter;
+}