@malloydata/malloy 0.0.22-dev230207144036 → 0.0.22-dev230207180844

package/dist/lang/ast/parameters/constant-parameter.js

@@ -0,0 +1,54 @@
+"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.ConstantParameter = void 0;
+const malloy_types_1 = require("../../../model/malloy_types");
+const has_parameter_1 = require("./has-parameter");
+class ConstantParameter extends has_parameter_1.HasParameter {
+    constructor(name, value) {
+        super({ name, isCondition: false });
+        this.value = value;
+        this.has({ value });
+    }
+    parameter() {
+        const cVal = this.value.constantValue();
+        if (!(0, malloy_types_1.isAtomicFieldType)(cVal.dataType)) {
+            this.log(`Unexpected expression type '${cVal.dataType}'`);
+            return {
+                value: ["XXX-type-mismatch-error-XXX"],
+                type: "string",
+                name: this.name,
+                constant: true,
+            };
+        }
+        return {
+            value: cVal.value,
+            type: cVal.dataType,
+            name: this.name,
+            constant: true,
+        };
+    }
+}
+exports.ConstantParameter = ConstantParameter;
+//# sourceMappingURL=constant-parameter.js.map

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

@@ -0,0 +1,19 @@
+import { AtomicFieldType, Parameter } from "../../../model/malloy_types";
+import { ConstantSubExpression } from "../expressions/constant-sub-expression";
+import { MalloyElement } from "../types/malloy-element";
+interface HasInit {
+    name: string;
+    isCondition: boolean;
+    type?: string;
+    default?: ConstantSubExpression;
+}
+export declare class HasParameter extends MalloyElement {
+    elementType: string;
+    readonly name: string;
+    readonly isCondition: boolean;
+    readonly type?: AtomicFieldType;
+    readonly default?: ConstantSubExpression;
+    constructor(init: HasInit);
+    parameter(): Parameter;
+}
+export {};

package/dist/lang/ast/parameters/has-parameter.js

@@ -0,0 +1,64 @@
+"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.HasParameter = void 0;
+const malloy_types_1 = require("../../../model/malloy_types");
+const malloy_element_1 = require("../types/malloy-element");
+class HasParameter extends malloy_element_1.MalloyElement {
+    constructor(init) {
+        super();
+        this.elementType = "hasParameter";
+        this.name = init.name;
+        this.isCondition = init.isCondition;
+        if (init.type && (0, malloy_types_1.isAtomicFieldType)(init.type)) {
+            this.type = init.type;
+        }
+        if (init.default) {
+            this.default = init.default;
+            this.has({ default: this.default });
+        }
+    }
+    parameter() {
+        var _a, _b;
+        const name = this.name;
+        const type = this.type || "string";
+        if (this.isCondition) {
+            const cCond = ((_a = this.default) === null || _a === void 0 ? void 0 : _a.constantCondition(type).value) || null;
+            return {
+                type,
+                name,
+                condition: cCond,
+            };
+        }
+        const cVal = ((_b = this.default) === null || _b === void 0 ? void 0 : _b.constantValue().value) || null;
+        return {
+            value: cVal,
+            type,
+            name: this.name,
+            constant: false,
+        };
+    }
+}
+exports.HasParameter = HasParameter;
+//# sourceMappingURL=has-parameter.js.map

package/dist/lang/ast/query-elements/anonymous-query.d.ts

@@ -0,0 +1,9 @@
+import { ModelDataRequest } from "../../translate-response";
+import { DocStatement, Document, MalloyElement } from "../types/malloy-element";
+import { QueryElement } from "../types/query-element";
+export declare class AnonymousQuery extends MalloyElement implements DocStatement {
+    readonly theQuery: QueryElement;
+    elementType: string;
+    constructor(theQuery: QueryElement);
+    execute(doc: Document): ModelDataRequest;
+}

package/dist/lang/ast/query-elements/anonymous-query.js

@@ -0,0 +1,41 @@
+"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.AnonymousQuery = void 0;
+const malloy_element_1 = require("../types/malloy-element");
+class AnonymousQuery extends malloy_element_1.MalloyElement {
+    constructor(theQuery) {
+        super();
+        this.theQuery = theQuery;
+        this.elementType = "anonymousQuery";
+        this.has({ query: theQuery });
+    }
+    execute(doc) {
+        const modelQuery = this.theQuery.query();
+        doc.queryList.push(modelQuery);
+        return undefined;
+    }
+}
+exports.AnonymousQuery = AnonymousQuery;
+//# sourceMappingURL=anonymous-query.js.map

package/dist/lang/ast/query-elements/existing-query.d.ts

@@ -0,0 +1,11 @@
+import { Query } from "../../../model/malloy_types";
+import { ModelEntryReference } from "../types/malloy-element";
+import { PipelineDesc } from "../elements/pipeline-desc";
+import { QueryComp } from "../types/query-comp";
+export declare class ExistingQuery extends PipelineDesc {
+    _head?: ModelEntryReference;
+    set head(head: ModelEntryReference | undefined);
+    get head(): ModelEntryReference | undefined;
+    queryComp(): QueryComp;
+    query(): Query;
+}

package/dist/lang/ast/query-elements/existing-query.js

@@ -0,0 +1,79 @@
+"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.ExistingQuery = void 0;
+const error_factory_1 = require("../error-factory");
+const pipeline_desc_1 = require("../elements/pipeline-desc");
+const query_head_struct_1 = require("./query-head-struct");
+const static_space_1 = require("../field-space/static-space");
+class ExistingQuery extends pipeline_desc_1.PipelineDesc {
+    set head(head) {
+        this._head = head;
+        this.has({ head });
+    }
+    get head() {
+        return this._head;
+    }
+    queryComp() {
+        if (!this.head) {
+            throw this.internalError("can't make query from nameless query");
+        }
+        const queryEntry = this.modelEntry(this.head);
+        const seedQuery = queryEntry === null || queryEntry === void 0 ? void 0 : queryEntry.entry;
+        const oops = function () {
+            return {
+                outputStruct: error_factory_1.ErrorFactory.structDef,
+                query: error_factory_1.ErrorFactory.query,
+            };
+        };
+        if (!seedQuery) {
+            this.log(`Reference to undefined query '${this.head}'`);
+            return oops();
+        }
+        if (seedQuery.type !== "query") {
+            this.log(`Illegal reference to '${this.head}', query expected`);
+            return oops();
+        }
+        const queryHead = new query_head_struct_1.QueryHeadStruct(seedQuery.structRef);
+        this.has({ queryHead });
+        const exploreStruct = queryHead.structDef();
+        const exploreFS = new static_space_1.StaticSpace(exploreStruct);
+        const sourcePipe = this.refinePipeline(exploreFS, seedQuery);
+        const walkStruct = this.getOutputStruct(exploreStruct, sourcePipe.pipeline);
+        const appended = this.appendOps(sourcePipe.pipeline, new static_space_1.StaticSpace(walkStruct));
+        const destPipe = { ...sourcePipe, pipeline: appended.opList };
+        const query = {
+            type: "query",
+            ...destPipe,
+            structRef: queryHead.structRef(),
+            location: this.location,
+        };
+        return { outputStruct: appended.structDef, query };
+    }
+    query() {
+        return this.queryComp().query;
+    }
+}
+exports.ExistingQuery = ExistingQuery;
+//# sourceMappingURL=existing-query.js.map

package/dist/lang/ast/query-elements/full-query.d.ts

@@ -0,0 +1,10 @@
+import { Query } from "../../../model/malloy_types";
+import { Source } from "../elements/source";
+import { QueryComp } from "../types/query-comp";
+import { TurtleHeadedPipe } from "../types/turtle-headed-pipe";
+export declare class FullQuery extends TurtleHeadedPipe {
+    readonly explore: Source;
+    constructor(explore: Source);
+    queryComp(): QueryComp;
+    query(): Query;
+}

package/dist/lang/ast/query-elements/full-query.js

@@ -0,0 +1,85 @@
+"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.FullQuery = void 0;
+const malloy_types_1 = require("../../../model/malloy_types");
+const error_factory_1 = require("../error-factory");
+const turtle_headed_pipe_1 = require("../types/turtle-headed-pipe");
+const static_space_1 = require("../field-space/static-space");
+class FullQuery extends turtle_headed_pipe_1.TurtleHeadedPipe {
+    constructor(explore) {
+        super({ explore });
+        this.explore = explore;
+    }
+    queryComp() {
+        const structRef = this.explore.structRef();
+        const destQuery = {
+            type: "query",
+            structRef,
+            pipeline: [],
+            location: this.location,
+        };
+        const structDef = (0, malloy_types_1.refIsStructDef)(structRef)
+            ? structRef
+            : this.explore.structDef();
+        let pipeFs = new static_space_1.StaticSpace(structDef);
+        if (error_factory_1.ErrorFactory.isErrorStructDef(structDef)) {
+            return {
+                outputStruct: structDef,
+                query: {
+                    structRef: structRef,
+                    pipeline: [],
+                },
+            };
+        }
+        if (this.turtleName) {
+            const { error } = this.turtleName.getField(pipeFs);
+            if (error)
+                this.log(error);
+            const name = this.turtleName.refString;
+            const { pipeline, location } = this.expandTurtle(name, structDef);
+            destQuery.location = location;
+            const refined = this.refinePipeline(pipeFs, { pipeline }).pipeline;
+            if (this.headRefinement) {
+                // TODO there is an issue with losing the name of the turtle
+                // which we need to fix, possibly adding a "name:" field to a segment
+                // TODO there was mention of promoting filters to the query
+                destQuery.pipeline = refined;
+            }
+            else {
+                destQuery.pipeHead = { name };
+            }
+            const pipeStruct = this.getOutputStruct(structDef, refined);
+            pipeFs = new static_space_1.StaticSpace(pipeStruct);
+        }
+        const appended = this.appendOps(destQuery.pipeline, pipeFs);
+        destQuery.pipeline = appended.opList;
+        return { outputStruct: appended.structDef, query: destQuery };
+    }
+    query() {
+        return this.queryComp().query;
+    }
+}
+exports.FullQuery = FullQuery;
+//# sourceMappingURL=full-query.js.map

package/dist/lang/ast/query-elements/query-head-struct.d.ts

@@ -0,0 +1,9 @@
+import { StructDef, StructRef } from "../../../model/malloy_types";
+import { Source } from "../elements/source";
+export declare class QueryHeadStruct extends Source {
+    readonly fromRef: StructRef;
+    elementType: string;
+    constructor(fromRef: StructRef);
+    structRef(): StructRef;
+    structDef(): StructDef;
+}

package/dist/lang/ast/query-elements/query-head-struct.js

@@ -0,0 +1,48 @@
+"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.QueryHeadStruct = void 0;
+const malloy_types_1 = require("../../../model/malloy_types");
+const source_1 = require("../elements/source");
+const named_source_1 = require("../sources/named-source");
+class QueryHeadStruct extends source_1.Source {
+    constructor(fromRef) {
+        super();
+        this.fromRef = fromRef;
+        this.elementType = "internalOnlyQueryHead";
+    }
+    structRef() {
+        return this.fromRef;
+    }
+    structDef() {
+        if ((0, malloy_types_1.refIsStructDef)(this.fromRef)) {
+            return this.fromRef;
+        }
+        const ns = new named_source_1.NamedSource(this.fromRef);
+        this.has({ exploreReference: ns });
+        return ns.structDef();
+    }
+}
+exports.QueryHeadStruct = QueryHeadStruct;
+//# sourceMappingURL=query-head-struct.js.map

package/dist/lang/ast/query-items/field-declaration.d.ts

@@ -0,0 +1,31 @@
+import { Dialect } from "../../../dialect/dialect";
+import { FieldTypeDef, StructDef } from "../../../model/malloy_types";
+import { LookupResult } from "../types/lookup-result";
+import { ExpressionDef } from "../types/expression-def";
+import { FieldName, FieldSpace } from "../types/field-space";
+import { MalloyElement } from "../types/malloy-element";
+export declare class FieldDeclaration extends MalloyElement {
+    readonly expr: ExpressionDef;
+    readonly defineName: string;
+    readonly exprSrc?: string | undefined;
+    elementType: string;
+    isMeasure?: boolean;
+    constructor(expr: ExpressionDef, defineName: string, exprSrc?: string | undefined);
+    fieldDef(fs: FieldSpace, exprName: string): FieldTypeDef;
+    queryFieldDef(exprFS: FieldSpace, exprName: string): FieldTypeDef;
+}
+/**
+ * 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(): StructDef;
+    emptyStructDef(): StructDef;
+    lookup(symbol: FieldName[]): LookupResult;
+    dialectObj(): Dialect | undefined;
+    whenComplete(step: () => void): void;
+}

package/dist/lang/ast/query-items/field-declaration.js

@@ -0,0 +1,137 @@
+"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.DefSpace = exports.FieldDeclaration = void 0;
+const malloy_types_1 = require("../../../model/malloy_types");
+const utils_1 = require("../expressions/utils");
+const fragtype_utils_1 = require("../fragtype-utils");
+const malloy_element_1 = require("../types/malloy-element");
+const granular_result_1 = require("../types/granular-result");
+class FieldDeclaration extends malloy_element_1.MalloyElement {
+    constructor(expr, defineName, exprSrc) {
+        super({ expr });
+        this.expr = expr;
+        this.defineName = defineName;
+        this.exprSrc = exprSrc;
+        this.elementType = "fieldDeclaration";
+    }
+    fieldDef(fs, exprName) {
+        /*
+         * In an explore we cannot reference the thing we are defining, you need
+         * to use rename. In a query, the output space is a new thing, and expressions
+         * can reference the outer value in order to make a value with the new name,
+         * and it feels wrong that this is HERE and not somehow in the QueryOperation.
+         * For now, this stops the stack overflow, and passes all tests, but I think
+         * a refactor of QueryFieldSpace might someday be the place where this should
+         * happen.
+         */
+        return this.queryFieldDef(new DefSpace(fs, this), exprName);
+    }
+    queryFieldDef(exprFS, exprName) {
+        let exprValue;
+        try {
+            exprValue = this.expr.getExpression(exprFS);
+        }
+        catch (error) {
+            this.log(`Cannot define '${exprName}', ${error.message}`);
+            return {
+                name: `error_defining_${exprName}`,
+                type: "string",
+            };
+        }
+        const compressValue = (0, utils_1.compressExpr)(exprValue.value);
+        const retType = exprValue.dataType;
+        if ((0, malloy_types_1.isAtomicFieldType)(retType)) {
+            const template = {
+                name: exprName,
+                type: retType,
+                location: this.location,
+            };
+            if (compressValue.length > 0) {
+                template.e = compressValue;
+            }
+            if (exprValue.expressionType) {
+                template.expressionType = exprValue.expressionType;
+            }
+            if (this.exprSrc) {
+                template.code = this.exprSrc;
+            }
+            // TODO this should work for dates too
+            if ((0, granular_result_1.isGranularResult)(exprValue) && template.type === "timestamp") {
+                template.timeframe = exprValue.timeframe;
+            }
+            return template;
+        }
+        const circularDef = exprFS instanceof DefSpace && exprFS.foundCircle;
+        if (!circularDef) {
+            if (exprValue.dataType == "unknown") {
+                this.log(`Cannot define '${exprName}', value has unknown type`);
+            }
+            else {
+                const badType = fragtype_utils_1.FT.inspect(exprValue);
+                this.log(`Cannot define '${exprName}', unexpected type: ${badType}`);
+            }
+        }
+        return {
+            name: `error_defining_${exprName}`,
+            type: "string",
+        };
+    }
+}
+exports.FieldDeclaration = FieldDeclaration;
+/**
+ * Used to detect references to fields in the statement which defines them
+ */
+class DefSpace {
+    constructor(realFS, circular) {
+        this.realFS = realFS;
+        this.circular = circular;
+        this.type = "fieldSpace";
+        this.foundCircle = false;
+    }
+    structDef() {
+        return this.realFS.structDef();
+    }
+    emptyStructDef() {
+        return this.realFS.emptyStructDef();
+    }
+    lookup(symbol) {
+        if (symbol[0] && symbol[0].refString === this.circular.defineName) {
+            this.foundCircle = true;
+            return {
+                error: `Circular reference to '${this.circular.defineName}' in definition`,
+                found: undefined,
+            };
+        }
+        return this.realFS.lookup(symbol);
+    }
+    dialectObj() {
+        return this.realFS.dialectObj();
+    }
+    whenComplete(step) {
+        this.realFS.whenComplete(step);
+    }
+}
+exports.DefSpace = DefSpace;
+//# sourceMappingURL=field-declaration.js.map

package/dist/lang/ast/query-items/field-references.d.ts

@@ -0,0 +1,25 @@
+import { FieldDef } from "../../../model/malloy_types";
+import { FieldName, FieldSpace } from "../types/field-space";
+import { ListOf, MalloyElement } from "../types/malloy-element";
+import { LookupResult } from "../types/lookup-result";
+export declare class FieldReference extends ListOf<FieldName> {
+    elementType: string;
+    constructor(names: FieldName[]);
+    get refString(): string;
+    get outputName(): string;
+    get sourceString(): string | undefined;
+    get nameString(): string;
+    getField(fs: FieldSpace): LookupResult;
+}
+export declare class WildcardFieldReference extends MalloyElement {
+    readonly joinPath: FieldReference | undefined;
+    readonly star: "*" | "**";
+    elementType: string;
+    constructor(joinPath: FieldReference | undefined, star: "*" | "**");
+    getFieldDef(): FieldDef;
+    get refString(): string;
+}
+export declare type FieldReferenceElement = FieldReference | WildcardFieldReference;
+export declare class FieldReferences extends ListOf<FieldReferenceElement> {
+    constructor(members: FieldReferenceElement[]);
+}