@malloydata/malloy 0.0.97-dev231026184251 → 0.0.97

package/dist/lang/ast/elements/pipeline-desc.d.ts

@@ -3,6 +3,8 @@ import { FieldName, FieldSpace } from '../types/field-space';
 import { MalloyElement } from '../types/malloy-element';
 import { QOPDesc } from '../query-properties/qop-desc';
 import { QueryInputSpace } from '../field-space/query-input-space';
+import { ViewFieldReference } from '../query-items/field-references';
+import { Refinement } from '../query-properties/refinements';
 interface AppendResult {
     opList: PipeSegment[];
     structDef: StructDef;
@@ -13,21 +15,19 @@ interface AppendResult {
  * is refers to the first segment of the composed pipeline.
  */
 export declare abstract class PipelineDesc extends MalloyElement {
-    protected withRefinement?: QOPDesc;
+    protected refinements?: Refinement[];
     protected qops: QOPDesc[];
     nestedInQuerySpace?: QueryInputSpace;
     alreadyRefined(): boolean;
-    refineWith(refinement: QOPDesc): void;
+    refineWith(refinements: (QOPDesc | ViewFieldReference)[]): void;
     addSegments(...segDesc: QOPDesc[]): void;
     protected appendOps(pipelineOutput: FieldSpace, modelPipe: PipeSegment[]): AppendResult;
-    private refineSegment;
     protected refinePipeline(fs: FieldSpace, modelPipe: Pipeline): Pipeline;
     protected expandTurtle(turtleName: string, fromStruct: StructDef): {
         pipeline: PipeSegment[];
         location: DocumentLocation | undefined;
         annotation: Annotation | undefined;
     };
-    protected getFinalStruct(walkStruct: StructDef, pipeline: PipeSegment[]): StructDef;
 }
 export declare abstract class TurtleHeadedPipe extends PipelineDesc {
     _turtleName?: FieldName;

package/dist/lang/ast/elements/pipeline-desc.js

@@ -24,10 +24,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TurtleHeadedPipe = exports.PipelineDesc = void 0;
 const malloy_element_1 = require("../types/malloy-element");
-const qop_desc_1 = require("../query-properties/qop-desc");
 const struct_utils_1 = require("../struct-utils");
-const query_property_interface_1 = require("../types/query-property-interface");
-const static_space_1 = require("../field-space/static-space");
+const refinements_1 = require("../query-properties/refinements");
 /**
  * Generic abstract for all pipelines, the first segment might be a reference
  * to an existing pipeline (query or turtle), and if there is a refinement it
@@ -39,11 +37,12 @@ class PipelineDesc extends malloy_element_1.MalloyElement {
         this.qops = [];
     }
     alreadyRefined() {
-        return this.withRefinement !== undefined;
+        return this.refinements !== undefined;
     }
-    refineWith(refinement) {
-        this.withRefinement = refinement;
-        this.has({ withRefinement: refinement });
+    refineWith(refinements) {
+        const ref = refinements.map(refinement => refinements_1.Refinement.from(refinement));
+        this.refinements = ref;
+        this.has({ refinements: ref });
     }
     addSegments(...segDesc) {
         this.qops.push(...segDesc);
@@ -63,12 +62,8 @@ class PipelineDesc extends malloy_element_1.MalloyElement {
             structDef: nextFS.structDef(),
         };
     }
-    refineSegment(fs, refinement, seg) {
-        refinement.refineFrom(seg);
-        return refinement.getOp(fs, this.nestedInQuerySpace).segment;
-    }
     refinePipeline(fs, modelPipe) {
-        if (!this.withRefinement) {
+        if (!this.refinements) {
             return modelPipe;
         }
         let pipeline = [];
@@ -77,43 +72,10 @@ class PipelineDesc extends malloy_element_1.MalloyElement {
             pipeline.push(...turtlePipe);
         }
         pipeline.push(...modelPipe.pipeline);
-        const firstSeg = pipeline[0];
-        if (pipeline.length === 1) {
-            // I could let everything fall through to the head/tail case, it should be the
-            // same, but this does less computation and is the most common case.
-            pipeline = [this.refineSegment(fs, this.withRefinement, firstSeg)];
-            this.withRefinement = undefined;
-        }
-        else {
-            const headRefinements = new qop_desc_1.QOPDesc([]);
-            const tailRefinements = new qop_desc_1.QOPDesc([]);
-            for (const qop of this.withRefinement.list) {
-                switch (qop.queryRefinementStage) {
-                    case query_property_interface_1.LegalRefinementStage.Head:
-                        headRefinements.push(qop);
-                        break;
-                    case query_property_interface_1.LegalRefinementStage.Single:
-                        qop.log('Illegal in refinement of a query with more than one stage');
-                        break;
-                    case query_property_interface_1.LegalRefinementStage.Tail:
-                        tailRefinements.push(qop);
-                        break;
-                    default:
-                        qop.log('Illegal query refinement');
-                }
-            }
-            if (headRefinements.notEmpty()) {
-                this.has({ headRefinements });
-                pipeline[0] = this.refineSegment(fs, headRefinements, firstSeg);
-            }
-            if (tailRefinements.notEmpty()) {
-                const last = pipeline.length - 1;
-                this.has({ tailRefinements });
-                const finalIn = this.getFinalStruct(fs.structDef(), pipeline.slice(-1));
-                pipeline[last] = this.refineSegment(new static_space_1.StaticSpace(finalIn), tailRefinements, pipeline[last]);
-            }
+        for (const refinement of this.refinements) {
+            pipeline = refinement.refine(fs, pipeline);
         }
-        this.withRefinement = undefined;
+        this.refinements = undefined;
         return { pipeline };
     }
     expandTurtle(turtleName, fromStruct) {
@@ -133,12 +95,6 @@ class PipelineDesc extends malloy_element_1.MalloyElement {
         }
         return { pipeline: [], location: undefined, annotation };
     }
-    getFinalStruct(walkStruct, pipeline) {
-        for (const modelQop of pipeline) {
-            walkStruct = (0, struct_utils_1.opOutputStruct)(this, walkStruct, modelQop);
-        }
-        return walkStruct;
-    }
 }
 exports.PipelineDesc = PipelineDesc;
 class TurtleHeadedPipe extends PipelineDesc {

package/dist/lang/ast/elements/source-query-nodes.d.ts

@@ -49,9 +49,9 @@ export declare class SQAppendView extends SourceQueryNode {
 }
 export declare class SQRefinedQuery extends SourceQueryNode {
     readonly toRefine: SourceQueryNode;
-    readonly refine: QOPDesc;
+    readonly refine: QOPDesc | ViewFieldReference;
     elementType: string;
-    constructor(toRefine: SourceQueryNode, refine: QOPDesc);
+    constructor(toRefine: SourceQueryNode, refine: QOPDesc | ViewFieldReference);
     getQuery(): QueryElement | undefined;
     getSource(): QuerySource | undefined;
 }

package/dist/lang/ast/elements/source-query-nodes.js

@@ -118,7 +118,7 @@ class SQLegacyModify extends source_query_1.SourceQueryNode {
                 stmt.log('Unable to add this refinement to query');
             }
         }
-        asQuery.refineWith(new qop_desc_1.QOPDesc(stmts));
+        asQuery.refineWith([new qop_desc_1.QOPDesc(stmts)]);
         this.has({ asQuery });
         return asQuery;
     }
@@ -219,34 +219,15 @@ class SQAppendView extends source_query_1.SourceQueryNode {
             theQuery = new full_query_1.FullQuery(querySrc);
             this.has({ theQuery });
             const head = views[0];
+            const refinements = views.slice(1);
             if (head instanceof field_references_1.ViewFieldReference) {
                 theQuery.turtleName = head.list[0];
-                if (views.length === 1) {
-                    return theQuery;
-                }
-                if (views.length === 2) {
-                    if (views[1] instanceof qop_desc_1.QOPDesc) {
-                        theQuery.refineWith(views[1]);
-                        return theQuery;
-                    }
-                    else {
-                        this.sqLog('Cannot refine with a named view');
-                        return;
-                    }
-                }
-                else {
-                    this.sqLog('Cannot have multiple refinements');
-                }
             }
-            else if (views.length === 1) {
-                if (head instanceof qop_desc_1.QOPDesc) {
-                    theQuery.addSegments(head);
-                    return theQuery;
-                }
+            else if (head instanceof qop_desc_1.QOPDesc) {
+                theQuery.addSegments(head);
             }
-            if (views.length > 0) {
-                this.sqLog('Cannot have multiple refinements');
-                return;
+            if (refinements) {
+                theQuery.refineWith(refinements);
             }
             return theQuery;
         }
@@ -309,7 +290,7 @@ class SQRefinedQuery extends source_query_1.SourceQueryNode {
                 this.sqLog('Cannot refine a refined query');
                 return;
             }
-            refinedQuery.refineWith(this.refine);
+            refinedQuery.refineWith([this.refine]);
             this.has({ query: refinedQuery });
             return refinedQuery;
         }

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

@@ -26,6 +26,7 @@ exports.ExistingQuery = void 0;
 const pipeline_desc_1 = require("../elements/pipeline-desc");
 const error_factory_1 = require("../error-factory");
 const static_space_1 = require("../field-space/static-space");
+const struct_utils_1 = require("../struct-utils");
 const query_head_struct_1 = require("./query-head-struct");
 class ExistingQuery extends pipeline_desc_1.PipelineDesc {
     constructor() {
@@ -63,7 +64,7 @@ class ExistingQuery extends pipeline_desc_1.PipelineDesc {
             const exploreStruct = queryHead.structDef();
             const exploreFS = new static_space_1.StaticSpace(exploreStruct);
             const sourcePipe = this.refinePipeline(exploreFS, head);
-            const walkStruct = this.getFinalStruct(exploreStruct, sourcePipe.pipeline);
+            const walkStruct = (0, struct_utils_1.getFinalStruct)(this, exploreStruct, sourcePipe.pipeline);
             const appended = this.appendOps(new static_space_1.StaticSpace(walkStruct), sourcePipe.pipeline);
             const destPipe = { ...sourcePipe, pipeline: appended.opList };
             const query = {

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

@@ -27,6 +27,7 @@ const malloy_types_1 = require("../../../model/malloy_types");
 const error_factory_1 = require("../error-factory");
 const static_space_1 = require("../field-space/static-space");
 const pipeline_desc_1 = require("../elements/pipeline-desc");
+const struct_utils_1 = require("../struct-utils");
 class FullQuery extends pipeline_desc_1.TurtleHeadedPipe {
     constructor(explore) {
         super({ explore: explore });
@@ -76,7 +77,9 @@ class FullQuery extends pipeline_desc_1.TurtleHeadedPipe {
             const { pipeline, location, annotation } = this.expandTurtle(name, structDef);
             destQuery.location = location;
             let walkPipe = pipeline;
-            if (this.withRefinement) {
+            if (this.refinements &&
+                this.refinements.length > 0 &&
+                pipeline.length !== 0) {
                 const refined = this.refinePipeline(pipeFS, { pipeline }).pipeline;
                 // 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
@@ -90,12 +93,22 @@ class FullQuery extends pipeline_desc_1.TurtleHeadedPipe {
             if (annotation) {
                 destQuery.annotation = annotation;
             }
-            const pipeOutput = this.getFinalStruct(structDef, walkPipe);
+            const pipeOutput = (0, struct_utils_1.getFinalStruct)(this, structDef, walkPipe);
             pipeFS = new static_space_1.StaticSpace(pipeOutput);
         }
         const appended = this.appendOps(pipeFS, destQuery.pipeline);
         destQuery.pipeline = appended.opList;
-        return { outputStruct: appended.structDef, query: destQuery };
+        if (!this.turtleName && this.refinements) {
+            const refined = this.refinePipeline(pipeFS, {
+                pipeline: destQuery.pipeline,
+            }).pipeline;
+            destQuery.pipeline = refined;
+            const pipeOutput = (0, struct_utils_1.getFinalStruct)(this, structDef, refined);
+            return { outputStruct: pipeOutput, query: destQuery };
+        }
+        else {
+            return { outputStruct: appended.structDef, query: destQuery };
+        }
     }
     query() {
         return this.queryComp(true).query;

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

@@ -181,9 +181,7 @@ class ViewFieldReference extends FieldReference {
         super(...arguments);
         this.elementType = 'viewFieldRefernce';
     }
-    typecheck(_type) {
-        this.log('Cannot use a view field in an expression');
-    }
+    typecheck(_type) { }
 }
 exports.ViewFieldReference = ViewFieldReference;
 class WildcardFieldReference extends malloy_element_1.MalloyElement {

package/dist/lang/ast/query-properties/nest.js

@@ -31,6 +31,7 @@ const query_property_interface_1 = require("../types/query-property-interface");
 const query_spaces_1 = require("../field-space/query-spaces");
 const model_1 = require("../../../model");
 const field_references_1 = require("../query-items/field-references");
+const struct_utils_1 = require("../struct-utils");
 function isTurtle(fd) {
     const ret = fd && typeof fd !== 'string' && fd.type === 'turtle';
     return !!ret;
@@ -66,16 +67,22 @@ class TurtleDeclRoot extends pipeline_desc_1.TurtleHeadedPipe {
                 this.log(`Expected '${this.turtleName}' to be a query`);
             }
         }
-        else if (this.withRefinement) {
-            throw this.internalError("Can't refine the head of a view  in its definition");
-        }
         let pipeOutFS = fs;
         if (modelPipe.pipeline.length > 0) {
-            const lastOut = this.getFinalStruct(fs.structDef(), modelPipe.pipeline);
+            const lastOut = (0, struct_utils_1.getFinalStruct)(this, fs.structDef(), modelPipe.pipeline);
             pipeOutFS = new static_space_1.StaticSpace(lastOut);
         }
         const appended = this.appendOps(pipeOutFS, modelPipe.pipeline);
         modelPipe.pipeline = appended.opList;
+        if (this.refinements &&
+            this.refinements.length > 0 &&
+            this.turtleName === undefined) {
+            const refined = this.refinePipeline(fs, {
+                pipeline: modelPipe.pipeline,
+            }).pipeline;
+            modelPipe.pipeline = refined;
+            return modelPipe;
+        }
         return modelPipe;
     }
     getFieldDef(fs, nestParent) {

package/dist/lang/ast/query-properties/refinements.d.ts

@@ -0,0 +1,25 @@
+import { PipeSegment } from '../../../model/malloy_types';
+import { FieldSpace } from '../types/field-space';
+import { MalloyElement } from '../types/malloy-element';
+import { OpDesc } from '../types/op-desc';
+import { ViewFieldReference } from '../query-items/field-references';
+import { QOPDesc } from './qop-desc';
+export declare abstract class Refinement extends MalloyElement {
+    abstract refine(inputFS: FieldSpace, pipeline: PipeSegment[]): PipeSegment[];
+    static from(base: QOPDesc | ViewFieldReference): QOPDescRefinement | NamedRefinement;
+}
+export declare class NamedRefinement extends Refinement {
+    private readonly name;
+    elementType: string;
+    constructor(name: ViewFieldReference);
+    private getRefinementSegment;
+    refine(inputFS: FieldSpace, pipeline: PipeSegment[]): PipeSegment[];
+    getOp(inputFS: FieldSpace, _to: PipeSegment): OpDesc;
+}
+export declare class QOPDescRefinement extends Refinement {
+    private readonly qOpDesc;
+    elementType: string;
+    constructor(qOpDesc: QOPDesc);
+    private getOp;
+    refine(inputFS: FieldSpace, _pipeline: PipeSegment[]): PipeSegment[];
+}

package/dist/lang/ast/query-properties/refinements.js

@@ -0,0 +1,186 @@
+"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.QOPDescRefinement = exports.NamedRefinement = exports.Refinement = void 0;
+const malloy_element_1 = require("../types/malloy-element");
+const struct_utils_1 = require("../struct-utils");
+const static_space_1 = require("../field-space/static-space");
+const query_property_interface_1 = require("../types/query-property-interface");
+const qop_desc_1 = require("./qop-desc");
+const space_field_1 = require("../types/space-field");
+class Refinement extends malloy_element_1.MalloyElement {
+    static from(base) {
+        return base instanceof qop_desc_1.QOPDesc
+            ? new QOPDescRefinement(base)
+            : new NamedRefinement(base);
+    }
+}
+exports.Refinement = Refinement;
+class NamedRefinement extends Refinement {
+    constructor(name) {
+        super({ name });
+        this.name = name;
+        this.elementType = 'namedRefinement';
+    }
+    getRefinementSegment(fs) {
+        const res = this.name.getField(fs);
+        if (!res.found) {
+            this.name.log(`no such view \`${this.name.refString}\``);
+            return;
+        }
+        if (res.found instanceof space_field_1.SpaceField) {
+            const fieldDef = res.found.fieldDef();
+            if ((fieldDef === null || fieldDef === void 0 ? void 0 : fieldDef.type) === 'turtle') {
+                if (fieldDef.pipeline.length > 1 || fieldDef.pipeHead !== undefined) {
+                    this.name.log(`named refinement \`${this.name.refString}\` must have exactly one stage`);
+                    return;
+                }
+                return fieldDef.pipeline[0];
+            }
+        }
+        this.name.log(`named refinement \`${this.name.refString}\` must be a view, found a ${res.found.describeType().dataType}`);
+    }
+    refine(inputFS, pipeline) {
+        if (pipeline.length === 1) {
+            return [this.getOp(inputFS, pipeline[0]).segment];
+        }
+        else {
+            this.name.log('Named refinements of multi-stage views are not supported');
+            // TODO better error pipeline?
+            return pipeline;
+        }
+    }
+    getOp(inputFS, _to) {
+        var _a, _b;
+        const to = { ..._to };
+        const from = this.getRefinementSegment(inputFS);
+        if (from) {
+            if (from.type !== to.type) {
+                this.log(`cannot refine ${to.type} view with ${from.type} view`);
+            }
+            if (from.type !== 'index' && to.type !== 'index') {
+                if (from.orderBy !== undefined || from.by !== undefined) {
+                    if (to.orderBy === undefined && to.by === undefined) {
+                        if (from.orderBy) {
+                            to.orderBy = from.orderBy;
+                        }
+                        else if (from.by) {
+                            to.by = from.by;
+                        }
+                    }
+                    else {
+                        this.log('refinement cannot override existing ordering');
+                    }
+                }
+                if (from.limit !== undefined) {
+                    if (to.limit === undefined) {
+                        to.limit = from.limit;
+                    }
+                    else {
+                        this.log('refinement cannot override existing limit');
+                    }
+                }
+            }
+            to.filterList =
+                to.filterList !== undefined || from.filterList !== undefined
+                    ? [...((_a = to.filterList) !== null && _a !== void 0 ? _a : []), ...((_b = from.filterList) !== null && _b !== void 0 ? _b : [])]
+                    : undefined;
+            const overlappingFields = [];
+            const nonOverlappingFields = [];
+            const existingNames = new Map(to.fields.map((f) => [
+                extractName(f),
+                f,
+            ]));
+            for (const field of from.fields) {
+                if (existingNames.has(extractName(field))) {
+                    overlappingFields.push(field);
+                }
+                else {
+                    nonOverlappingFields.push(field);
+                }
+            }
+            to.fields = [...to.fields, ...nonOverlappingFields];
+            if (overlappingFields.length > 0) {
+                this.log(`overlapping fields in refinement: ${overlappingFields.map(extractName)}`);
+            }
+        }
+        return {
+            segment: to,
+            outputSpace: () => new static_space_1.StaticSpace((0, struct_utils_1.opOutputStruct)(this.name, inputFS.structDef(), to)),
+        };
+    }
+}
+exports.NamedRefinement = NamedRefinement;
+function extractName(f1) {
+    var _a;
+    return typeof f1 === 'string' ? f1 : (_a = f1.as) !== null && _a !== void 0 ? _a : f1.name;
+}
+class QOPDescRefinement extends Refinement {
+    constructor(qOpDesc) {
+        super({ qOpDesc });
+        this.qOpDesc = qOpDesc;
+        this.elementType = 'qopdescRefinement';
+    }
+    getOp(inputFS, headFS, qOpDesc, refineThis) {
+        qOpDesc.refineFrom(refineThis);
+        return qOpDesc.getOp(inputFS, headFS).segment;
+    }
+    refine(inputFS, _pipeline) {
+        const pipeline = [..._pipeline];
+        if (pipeline.length === 1) {
+            this.qOpDesc.refineFrom(pipeline[0]);
+            return [this.getOp(inputFS, undefined, this.qOpDesc, pipeline[0])];
+        }
+        const headRefinements = new qop_desc_1.QOPDesc([]);
+        const tailRefinements = new qop_desc_1.QOPDesc([]);
+        for (const qop of this.qOpDesc.list) {
+            switch (qop.queryRefinementStage) {
+                case query_property_interface_1.LegalRefinementStage.Head:
+                    headRefinements.push(qop);
+                    break;
+                case query_property_interface_1.LegalRefinementStage.Single:
+                    qop.log('Illegal in refinement of a query with more than one stage');
+                    break;
+                case query_property_interface_1.LegalRefinementStage.Tail:
+                    tailRefinements.push(qop);
+                    break;
+                default:
+                    qop.log('Illegal query refinement');
+            }
+        }
+        if (headRefinements.notEmpty()) {
+            this.has({ headRefinements });
+            pipeline[0] = this.getOp(inputFS, undefined, headRefinements, pipeline[0]);
+        }
+        if (tailRefinements.notEmpty()) {
+            const last = pipeline.length - 1;
+            this.has({ tailRefinements });
+            const finalIn = (0, struct_utils_1.getFinalStruct)(this, inputFS.structDef(), pipeline.slice(-1));
+            pipeline[last] = this.getOp(new static_space_1.StaticSpace(finalIn), undefined, tailRefinements, pipeline[last]);
+        }
+        return pipeline;
+    }
+}
+exports.QOPDescRefinement = QOPDescRefinement;
+//# sourceMappingURL=refinements.js.map

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

@@ -1,4 +1,5 @@
 import { FieldDef, PipeSegment, StructDef } from '../../model/malloy_types';
 import { MalloyElement } from './types/malloy-element';
 export declare function opOutputStruct(logTo: MalloyElement, inputStruct: StructDef, opDesc: PipeSegment): StructDef;
+export declare function getFinalStruct(logTo: MalloyElement, walkStruct: StructDef, pipeline: PipeSegment[]): StructDef;
 export declare function getStructFieldDef(s: StructDef, fn: string): FieldDef | undefined;

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

@@ -22,7 +22,7 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getStructFieldDef = exports.opOutputStruct = void 0;
+exports.getStructFieldDef = exports.getFinalStruct = exports.opOutputStruct = void 0;
 const util_1 = require("util");
 const malloy_query_1 = require("../../model/malloy_query");
 const error_factory_1 = require("./error-factory");
@@ -41,6 +41,13 @@ function opOutputStruct(logTo, inputStruct, opDesc) {
     return { ...error_factory_1.ErrorFactory.structDef, dialect: inputStruct.dialect };
 }
 exports.opOutputStruct = opOutputStruct;
+function getFinalStruct(logTo, walkStruct, pipeline) {
+    for (const modelQop of pipeline) {
+        walkStruct = opOutputStruct(logTo, walkStruct, modelQop);
+    }
+    return walkStruct;
+}
+exports.getFinalStruct = getFinalStruct;
 function getStructFieldDef(s, fn) {
     return s.fields.find(fld => (fld.as || fld.name) === fn);
 }

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

@@ -53,7 +53,7 @@ export declare abstract class MalloyElement {
     private varInfo;
     protected internalError(msg: string): Error;
     needs(doc: Document): ModelDataRequest | undefined;
-    inExperiment(experimentID: string): boolean;
+    inExperiment(experimentID: string, silent?: boolean): boolean;
 }
 export declare class Unimplemented extends MalloyElement {
     elementType: string;

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

@@ -262,14 +262,16 @@ class MalloyElement {
                 return childNeeds;
         }
     }
-    inExperiment(experimentID) {
+    inExperiment(experimentID, silent = false) {
         var _a;
         const experimental = (_a = this.translator()) === null || _a === void 0 ? void 0 : _a.compilerFlags.tag('experimental');
         const enabled = experimental && (experimental.bare() || experimental.has(experimentID));
         if (enabled) {
             return true;
         }
-        this.log(`Experimental flag '${experimentID}' is not set, feature not available`);
+        if (!silent) {
+            this.log(`Experimental flag '${experimentID}' is not set, feature not available`);
+        }
         return false;
     }
 }