@malloydata/malloy 0.0.22-dev230207144036 → 0.0.22-dev230207180844

package/dist/lang/ast/expressions/utils.js

@@ -0,0 +1,87 @@
+"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.nullsafeNot = exports.compressExpr = exports.compose = void 0;
+const malloy_types_1 = require("../../../model/malloy_types");
+/**
+ * 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;
+}
+/**
+ * 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 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;
+function nullsafeNot(expr, op) {
+    if (op === undefined || op === "!=" || op === "!~") {
+        return (0, malloy_types_1.mkExpr) `COALESCE(NOT(${expr}),FALSE)`;
+    }
+    return expr;
+}
+exports.nullsafeNot = nullsafeNot;
+//# sourceMappingURL=utils.js.map

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

@@ -0,0 +1,9 @@
+import { FieldDef, FieldTypeDef } from "../../../model/malloy_types";
+import { SpaceField } from "../types/space-field";
+import { TypeDesc } from "../types/type-desc";
+export declare class ColumnSpaceField extends SpaceField {
+    protected def: FieldTypeDef;
+    constructor(def: FieldTypeDef);
+    fieldDef(): FieldDef;
+    typeDesc(): TypeDesc;
+}

package/dist/lang/ast/field-space/column-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.ColumnSpaceField = void 0;
+const space_field_1 = require("../types/space-field");
+class ColumnSpaceField extends space_field_1.SpaceField {
+    constructor(def) {
+        super();
+        this.def = def;
+    }
+    fieldDef() {
+        return this.def;
+    }
+    typeDesc() {
+        return this.fieldTypeFromFieldDef(this.def);
+    }
+}
+exports.ColumnSpaceField = ColumnSpaceField;
+//# sourceMappingURL=column-space-field.js.map

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

@@ -0,0 +1,22 @@
+import * as model from "../../../model/malloy_types";
+import { SpaceEntry } from "../types/space-entry";
+import { FieldSpace } from "../types/field-space";
+import { HasParameter } from "../parameters/has-parameter";
+import { MalloyElement } from "../types/malloy-element";
+import { SpaceSeed, SourceSpec } from "../space-seed";
+import { StaticSpace } from "./static-space";
+export declare abstract class DynamicSpace extends StaticSpace {
+    protected final: model.StructDef | undefined;
+    protected source: SpaceSeed;
+    outputFS?: FieldSpace;
+    completions: (() => void)[];
+    private complete;
+    constructor(extending: SourceSpec);
+    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;
+    addFieldDef(fd: model.FieldDef): void;
+    structDef(): model.StructDef;
+}

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

@@ -0,0 +1,140 @@
+"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.DynamicSpace = void 0;
+const lodash_1 = require("lodash");
+const field_utils_1 = require("../../field-utils");
+const error_factory_1 = require("../error-factory");
+const space_field_1 = require("../types/space-field");
+const join_space_field_1 = require("./join-space-field");
+const query_space_field_1 = require("./query-space-field");
+const space_param_1 = require("../types/space-param");
+const space_seed_1 = require("../space-seed");
+const static_space_1 = require("./static-space");
+const struct_space_field_base_1 = require("./struct-space-field-base");
+class DynamicSpace extends static_space_1.StaticSpace {
+    constructor(extending) {
+        const source = new space_seed_1.SpaceSeed(extending);
+        super((0, lodash_1.cloneDeep)(source.structDef));
+        this.completions = [];
+        this.complete = false;
+        this.final = undefined;
+        this.source = source;
+    }
+    whenComplete(finalizeStep) {
+        if (this.complete) {
+            finalizeStep();
+        }
+        else {
+            this.completions.push(finalizeStep);
+        }
+    }
+    isComplete() {
+        this.complete = true;
+        for (const step of this.completions) {
+            step();
+        }
+        this.completions = [];
+    }
+    setEntry(name, value) {
+        if (this.final) {
+            throw new Error("Space already final");
+        }
+        super.setEntry(name, value);
+    }
+    addParameters(params) {
+        for (const oneP of params) {
+            this.setEntry(oneP.name, new space_param_1.AbstractParameter(oneP));
+        }
+        return this;
+    }
+    newEntry(name, astEl, entry) {
+        if (this.entry(name)) {
+            astEl.log(`Cannot redefine '${name}'`);
+            return;
+        }
+        this.setEntry(name, entry);
+    }
+    addFieldDef(fd) {
+        this.setEntry((0, field_utils_1.nameOf)(fd), this.defToSpaceField(fd));
+    }
+    structDef() {
+        const parameters = this.fromStruct.parameters || {};
+        if (this.final === undefined) {
+            this.final = {
+                ...this.fromStruct,
+                fields: [],
+            };
+            // Need to process the entities in specific order
+            const fields = [];
+            const joins = [];
+            const turtles = [];
+            const fixupJoins = [];
+            for (const [name, spaceEntry] of this.entries()) {
+                if (spaceEntry instanceof struct_space_field_base_1.StructSpaceFieldBase) {
+                    joins.push([name, spaceEntry]);
+                }
+                else if (spaceEntry instanceof query_space_field_1.QueryField) {
+                    turtles.push([name, spaceEntry]);
+                }
+                else if (spaceEntry instanceof space_field_1.SpaceField) {
+                    fields.push([name, spaceEntry]);
+                }
+                else if (spaceEntry instanceof space_param_1.SpaceParam) {
+                    parameters[name] = spaceEntry.parameter();
+                }
+            }
+            const reorderFields = [...fields, ...joins, ...turtles];
+            for (const [fieldName, field] of reorderFields) {
+                if (field instanceof join_space_field_1.JoinSpaceField) {
+                    const joinStruct = field.join.structDef();
+                    if (!error_factory_1.ErrorFactory.isErrorStructDef(joinStruct)) {
+                        this.final.fields.push(joinStruct);
+                        fixupJoins.push([field.join, joinStruct]);
+                    }
+                }
+                else {
+                    const fieldDef = field.fieldDef();
+                    if (fieldDef) {
+                        this.final.fields.push(fieldDef);
+                    }
+                    else {
+                        throw new Error(`'${fieldName}' doesn't have a FieldDef`);
+                    }
+                }
+            }
+            if (Object.entries(parameters).length > 0) {
+                this.final.parameters = parameters;
+            }
+            // If we have join expressions, we need to now go back and fill them in
+            for (const [join, missingOn] of fixupJoins) {
+                join.fixupJoinOn(this, missingOn);
+            }
+        }
+        this.isComplete();
+        return this.final;
+    }
+}
+exports.DynamicSpace = DynamicSpace;
+//# sourceMappingURL=dynamic-space.js.map

package/dist/lang/ast/field-space/field-definition-value.d.ts

@@ -0,0 +1,16 @@
+import * as model from "../../../model/malloy_types";
+import { FieldDeclaration } from "../query-items/field-declaration";
+import { FieldSpace } from "../types/field-space";
+import { SpaceField } from "../types/space-field";
+import { TypeDesc } from "../types/type-desc";
+export declare class FieldDefinitionValue extends SpaceField {
+    readonly space: FieldSpace;
+    readonly exprDef: FieldDeclaration;
+    fieldName: string;
+    defType?: TypeDesc;
+    constructor(space: FieldSpace, exprDef: FieldDeclaration);
+    get name(): string;
+    fieldDef(): model.FieldDef;
+    getQueryFieldDef(fs: FieldSpace): model.QueryFieldDef;
+    typeDesc(): TypeDesc;
+}

package/dist/lang/ast/field-space/field-definition-value.js

@@ -0,0 +1,55 @@
+"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.FieldDefinitionValue = void 0;
+const space_field_1 = require("../types/space-field");
+class FieldDefinitionValue extends space_field_1.SpaceField {
+    constructor(space, exprDef) {
+        super();
+        this.space = space;
+        this.exprDef = exprDef;
+        this.fieldName = exprDef.defineName;
+    }
+    get name() {
+        return this.fieldName;
+    }
+    fieldDef() {
+        const def = this.exprDef.fieldDef(this.space, this.name);
+        this.defType = this.fieldTypeFromFieldDef(def);
+        return def;
+    }
+    getQueryFieldDef(fs) {
+        const def = this.exprDef.queryFieldDef(fs, this.name);
+        this.defType = this.fieldTypeFromFieldDef(def);
+        return def;
+    }
+    typeDesc() {
+        if (this.defType) {
+            return this.defType;
+        }
+        return this.fieldTypeFromFieldDef(this.fieldDef());
+    }
+}
+exports.FieldDefinitionValue = FieldDefinitionValue;
+//# sourceMappingURL=field-definition-value.js.map

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

@@ -0,0 +1,10 @@
+import { IndexSegment, PipeSegment } from "../../../model/malloy_types";
+import { FieldReference, WildcardFieldReference } from "../query-items/field-references";
+import { QuerySpace } from "./query-spaces";
+export declare class IndexFieldSpace extends QuerySpace {
+    readonly segmentType = "index";
+    fieldList: Set<string>;
+    addReference(ref: FieldReference): void;
+    addWild(wild: WildcardFieldReference): void;
+    getPipeSegment(refineIndex?: PipeSegment): IndexSegment;
+}

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

@@ -0,0 +1,57 @@
+"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.IndexFieldSpace = void 0;
+const query_spaces_1 = require("./query-spaces");
+class IndexFieldSpace extends query_spaces_1.QuerySpace {
+    constructor() {
+        super(...arguments);
+        this.segmentType = "index";
+        this.fieldList = new Set();
+    }
+    addReference(ref) {
+        if (ref.getField(this.exprSpace).found) {
+            this.fieldList.add(ref.refString);
+        }
+    }
+    addWild(wild) {
+        this.fieldList.add(wild.refString);
+    }
+    getPipeSegment(refineIndex) {
+        if (refineIndex && refineIndex.fields) {
+            for (const exists of refineIndex.fields) {
+                if (typeof exists == "string") {
+                    this.fieldList.add(exists);
+                }
+            }
+        }
+        this.isComplete();
+        return {
+            type: "index",
+            fields: Array.from(this.fieldList.values()),
+        };
+    }
+}
+exports.IndexFieldSpace = IndexFieldSpace;
+//# sourceMappingURL=index-field-space.js.map

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

@@ -0,0 +1,8 @@
+import { FieldSpace } from "../types/field-space";
+import { Join } from "../query-properties/joins";
+import { StructSpaceField } from "./static-space";
+export declare class JoinSpaceField extends StructSpaceField {
+    readonly intoFS: FieldSpace;
+    readonly join: Join;
+    constructor(intoFS: FieldSpace, join: Join);
+}

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

@@ -0,0 +1,35 @@
+"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.JoinSpaceField = void 0;
+const static_space_1 = require("./static-space");
+class JoinSpaceField extends static_space_1.StructSpaceField {
+    constructor(intoFS, join) {
+        super(join.structDef());
+        this.intoFS = intoFS;
+        this.join = join;
+    }
+}
+exports.JoinSpaceField = JoinSpaceField;
+//# sourceMappingURL=join-space-field.js.map

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

@@ -0,0 +1,6 @@
+import { QueryFieldDef } from "../../../model/malloy_types";
+import { QuerySpace } from "./query-spaces";
+export declare class ProjectFieldSpace extends QuerySpace {
+    readonly segmentType = "project";
+    canContain(qd: QueryFieldDef): boolean;
+}

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

@@ -0,0 +1,51 @@
+"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.ProjectFieldSpace = void 0;
+const malloy_types_1 = require("../../../model/malloy_types");
+const query_spaces_1 = require("./query-spaces");
+class ProjectFieldSpace extends query_spaces_1.QuerySpace {
+    constructor() {
+        super(...arguments);
+        this.segmentType = "project";
+    }
+    canContain(qd) {
+        if (typeof qd !== "string") {
+            if ((0, malloy_types_1.isFilteredAliasedName)(qd)) {
+                return true;
+            }
+            if (qd.type === "turtle") {
+                this.log("Cannot nest queries in project");
+                return false;
+            }
+            if ((0, malloy_types_1.expressionIsAggregate)(qd.expressionType)) {
+                this.log("Cannot add aggregate measures to project");
+                return false;
+            }
+        }
+        return true;
+    }
+}
+exports.ProjectFieldSpace = ProjectFieldSpace;
+//# sourceMappingURL=project-field-space.js.map

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

@@ -0,0 +1,10 @@
+import { QueryFieldDef, TurtleDef } from "../../../model/malloy_types";
+import { QueryField } from "./query-space-field";
+import { FieldSpace } from "../types/field-space";
+export declare class QueryFieldStruct extends QueryField {
+    protected turtleDef: TurtleDef;
+    constructor(fs: FieldSpace, turtleDef: TurtleDef);
+    rename(name: string): void;
+    fieldDef(): TurtleDef;
+    getQueryFieldDef(_fs: FieldSpace): QueryFieldDef | undefined;
+}

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

@@ -0,0 +1,46 @@
+"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.QueryFieldStruct = void 0;
+const query_space_field_1 = require("./query-space-field");
+class QueryFieldStruct extends query_space_field_1.QueryField {
+    constructor(fs, turtleDef) {
+        super(fs);
+        this.turtleDef = turtleDef;
+    }
+    rename(name) {
+        this.turtleDef = {
+            ...this.turtleDef,
+            as: name,
+        };
+    }
+    fieldDef() {
+        return this.turtleDef;
+    }
+    getQueryFieldDef(_fs) {
+        return this.fieldDef();
+    }
+}
+exports.QueryFieldStruct = QueryFieldStruct;
+//# sourceMappingURL=query-field-struct.js.map

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

@@ -0,0 +1,11 @@
+import { FieldDef, 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 abstract class QueryField extends SpaceField {
+    protected inSpace: FieldSpace;
+    constructor(inSpace: FieldSpace);
+    abstract getQueryFieldDef(fs: FieldSpace): QueryFieldDef | undefined;
+    abstract fieldDef(): FieldDef;
+    typeDesc(): TypeDesc;
+}

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

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