@malloydata/malloy 0.0.61-dev230721212958 → 0.0.61-dev230724132807

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

@@ -1,8 +1,8 @@
 import { Annotation, DocumentLocation, PipeSegment, Pipeline, StructDef } from '../../../model/malloy_types';
-import { FieldSpace } from '../types/field-space';
+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-spaces';
+import { QueryInputSpace } from '../field-space/query-input-space';
 interface AppendResult {
     opList: PipeSegment[];
     structDef: StructDef;
@@ -13,19 +13,24 @@ interface AppendResult {
  * is refers to the first segment of the composed pipeline.
  */
 export declare abstract class PipelineDesc extends MalloyElement {
-    elementType: string;
-    protected headRefinement?: QOPDesc;
+    protected withRefinement?: QOPDesc;
     protected qops: QOPDesc[];
     nestedInQuerySpace?: QueryInputSpace;
-    refineHead(refinement: QOPDesc): void;
+    refineWith(refinement: QOPDesc): void;
     addSegments(...segDesc: QOPDesc[]): void;
-    protected appendOps(modelPipe: PipeSegment[], existingEndSpace: FieldSpace): AppendResult;
+    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 getOutputStruct(walkStruct: StructDef, pipeline: PipeSegment[]): StructDef;
+    protected getFinalStruct(walkStruct: StructDef, pipeline: PipeSegment[]): StructDef;
+}
+export declare abstract class TurtleHeadedPipe extends PipelineDesc {
+    _turtleName?: FieldName;
+    set turtleName(turtleName: FieldName | undefined);
+    get turtleName(): FieldName | undefined;
 }
 export {};

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

@@ -22,9 +22,12 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PipelineDesc = void 0;
+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");
 /**
  * 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
@@ -33,49 +36,81 @@ const struct_utils_1 = require("../struct-utils");
 class PipelineDesc extends malloy_element_1.MalloyElement {
     constructor() {
         super(...arguments);
-        this.elementType = 'pipelineDesc';
         this.qops = [];
     }
-    refineHead(refinement) {
-        this.headRefinement = refinement;
-        this.has({ headRefinement: refinement });
+    refineWith(refinement) {
+        this.withRefinement = refinement;
+        this.has({ withRefinement: refinement });
     }
     addSegments(...segDesc) {
         this.qops.push(...segDesc);
         this.has({ segments: this.qops });
     }
-    appendOps(modelPipe, existingEndSpace) {
-        let nextFS = existingEndSpace;
-        let returnPipe;
+    appendOps(pipelineOutput, modelPipe) {
+        const returnPipe = [...modelPipe];
+        const nestedIn = modelPipe.length === 0 ? this.nestedInQuerySpace : undefined;
+        let nextFS = pipelineOutput;
         for (const qop of this.qops) {
-            const qopIsNested = modelPipe.length === 0;
-            const next = qop.getOp(nextFS, qopIsNested ? this : null);
-            if (returnPipe === undefined) {
-                returnPipe = [...modelPipe];
-            }
+            const next = qop.getOp(nextFS, nestedIn);
             returnPipe.push(next.segment);
             nextFS = next.outputSpace();
         }
         return {
-            opList: returnPipe || modelPipe,
+            opList: returnPipe,
             structDef: nextFS.structDef(),
         };
     }
+    refineSegment(fs, refinement, seg) {
+        refinement.refineFrom(seg);
+        return refinement.getOp(fs, this.nestedInQuerySpace).segment;
+    }
     refinePipeline(fs, modelPipe) {
-        if (!this.headRefinement) {
+        if (!this.withRefinement) {
             return modelPipe;
         }
-        const pipeline = [];
+        let pipeline = [];
         if (modelPipe.pipeHead) {
             const { pipeline: turtlePipe } = this.expandTurtle(modelPipe.pipeHead.name, fs.structDef());
             pipeline.push(...turtlePipe);
         }
         pipeline.push(...modelPipe.pipeline);
         const firstSeg = pipeline[0];
-        if (firstSeg) {
-            this.headRefinement.refineFrom(firstSeg);
+        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]);
+            }
         }
-        pipeline[0] = this.headRefinement.getOp(fs, this).segment;
+        this.withRefinement = undefined;
         return { pipeline };
     }
     expandTurtle(turtleName, fromStruct) {
@@ -95,7 +130,7 @@ class PipelineDesc extends malloy_element_1.MalloyElement {
         }
         return { pipeline: [], location: undefined, annotation };
     }
-    getOutputStruct(walkStruct, pipeline) {
+    getFinalStruct(walkStruct, pipeline) {
         for (const modelQop of pipeline) {
             walkStruct = (0, struct_utils_1.opOutputStruct)(this, walkStruct, modelQop);
         }
@@ -103,4 +138,14 @@ class PipelineDesc extends malloy_element_1.MalloyElement {
     }
 }
 exports.PipelineDesc = PipelineDesc;
+class TurtleHeadedPipe extends PipelineDesc {
+    set turtleName(turtleName) {
+        this._turtleName = turtleName;
+        this.has({ turtleName: turtleName });
+    }
+    get turtleName() {
+        return this._turtleName;
+    }
+}
+exports.TurtleHeadedPipe = TurtleHeadedPipe;
 //# sourceMappingURL=pipeline-desc.js.map

package/dist/lang/ast/elements/refined-source.js

@@ -34,11 +34,11 @@ const filters_1 = require("../query-properties/filters");
 const joins_1 = require("../query-properties/joins");
 const field_list_edit_1 = require("../source-properties/field-list-edit");
 const primary_key_1 = require("../source-properties/primary-key");
-const renames_1 = require("../source-properties/renames");
 const turtles_1 = require("../source-properties/turtles");
 const source_1 = require("./source");
 const timezone_statement_1 = require("../source-properties/timezone-statement");
-const malloy_element_1 = require("../types/malloy-element");
+const annotation_elements_1 = require("../types/annotation-elements");
+const renames_1 = require("../source-properties/renames");
 /**
  * A Source made from a source reference and a set of refinements
  */
@@ -59,8 +59,8 @@ class RefinedSource extends source_1.Source {
         const filters = [];
         let newTimezone;
         for (const el of this.refinement.list) {
-            if (el instanceof malloy_element_1.ObjectAnnotation) {
-                // Silently ignoring unclaimed annotations
+            if (el instanceof annotation_elements_1.ObjectAnnotation) {
+                // Treat lone annotations as comments
                 continue;
             }
             const errTo = el;
@@ -102,7 +102,7 @@ class RefinedSource extends source_1.Source {
         if (newTimezone) {
             fs.setTimezone(newTimezone);
         }
-        fs.addField(...fields);
+        fs.pushFields(...fields);
         if (pList) {
             fs.addParameters(pList);
         }

package/dist/lang/ast/expressions/expr-aggregate-function.js

@@ -25,7 +25,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExprAggregateFunction = void 0;
 const malloy_types_1 = require("../../../model/malloy_types");
 const ast_utils_1 = require("../ast-utils");
-const query_spaces_1 = require("../field-space/query-spaces");
 const reference_field_1 = require("../field-space/reference-field");
 const struct_space_field_base_1 = require("../field-space/struct-space-field-base");
 const fragtype_utils_1 = require("../fragtype-utils");
@@ -71,9 +70,8 @@ class ExprAggregateFunction extends expression_def_1.ExpressionDef {
                     };
                     // If you reference an output field as the foot, then we need to get the
                     // source from that field, rather than using the default source.
-                    if (sourceFoot instanceof query_spaces_1.OutputSpaceEntry &&
-                        sourceFoot.inputSpaceEntry instanceof reference_field_1.ReferenceField) {
-                        structPath = sourceFoot.inputSpaceEntry.fieldRef.sourceString;
+                    if (sourceFoot.outputField && sourceFoot instanceof reference_field_1.ReferenceField) {
+                        structPath = sourceFoot.fieldRef.sourceString;
                     }
                     else {
                         structPath = this.source.sourceString;

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

@@ -4,5 +4,5 @@ export declare class ColumnSpaceField extends SpaceField {
     haveFieldDef: FieldDef;
     constructor(def: FieldTypeDef);
     fieldDef(): FieldDef;
-    typeDesc(): TypeDesc;
+    describeType(): TypeDesc;
 }

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

@@ -32,7 +32,7 @@ class ColumnSpaceField extends space_field_1.SpaceField {
     fieldDef() {
         return this.haveFieldDef;
     }
-    typeDesc() {
+    describeType() {
         return this.fieldTypeFromFieldDef(this.haveFieldDef);
     }
 }

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

@@ -1,6 +1,5 @@
 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 { SourceSpec, SpaceSeed } from '../space-seed';
@@ -8,7 +7,6 @@ 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;
     protected newTimezone?: string;
@@ -17,7 +15,8 @@ export declare abstract class DynamicSpace extends StaticSpace {
     isComplete(): void;
     protected setEntry(name: string, value: SpaceEntry): void;
     addParameters(params: HasParameter[]): DynamicSpace;
-    newEntry(name: string, astEl: MalloyElement, entry: SpaceEntry): void;
+    newEntry(name: string, logTo: MalloyElement, entry: SpaceEntry): void;
+    renameEntry(oldName: string, newName: string, entry: SpaceEntry): void;
     addFieldDef(fd: model.FieldDef): void;
     setTimezone(tz: string): void;
     structDef(): model.StructDef;

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

@@ -72,13 +72,17 @@ class DynamicSpace extends static_space_1.StaticSpace {
         }
         return this;
     }
-    newEntry(name, astEl, entry) {
+    newEntry(name, logTo, entry) {
         if (this.entry(name)) {
-            astEl.log(`Cannot redefine '${name}'`);
+            logTo.log(`Cannot redefine '${name}'`);
             return;
         }
         this.setEntry(name, entry);
     }
+    renameEntry(oldName, newName, entry) {
+        this.dropEntry(oldName);
+        this.setEntry(newName, entry);
+    }
     addFieldDef(fd) {
         this.setEntry((0, field_utils_1.nameOf)(fd), this.defToSpaceField(fd));
     }

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

@@ -1,10 +1,9 @@
 import { IndexSegment, PipeSegment } from '../../../model/malloy_types';
-import { FieldReference, WildcardFieldReference } from '../query-items/field-references';
+import { MalloyElement } from '../types/malloy-element';
 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;
+    pushFields(...defs: MalloyElement[]): void;
     getPipeSegment(refineIndex?: PipeSegment): IndexSegment;
 }

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

@@ -23,6 +23,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IndexFieldSpace = void 0;
+const field_references_1 = require("../query-items/field-references");
 const query_spaces_1 = require("./query-spaces");
 class IndexFieldSpace extends query_spaces_1.QuerySpace {
     constructor() {
@@ -30,14 +31,22 @@ class IndexFieldSpace extends query_spaces_1.QuerySpace {
         this.segmentType = 'index';
         this.fieldList = new Set();
     }
-    addReference(ref) {
-        if (ref.getField(this.exprSpace).found) {
-            this.fieldList.add(ref.refString);
+    pushFields(...defs) {
+        for (const indexField of defs) {
+            if (indexField instanceof field_references_1.FieldReference) {
+                if (indexField.getField(this.inputSpace()).found) {
+                    this.fieldList.add(indexField.refString);
+                }
+                // mtoy TODO else error ???
+            }
+            else if (indexField instanceof field_references_1.WildcardFieldReference) {
+                this.fieldList.add(indexField.refString);
+            }
+            else {
+                indexField.log('Internal error, not expected in index query');
+            }
         }
     }
-    addWild(wild) {
-        this.fieldList.add(wild.refString);
-    }
     getPipeSegment(refineIndex) {
         if (refineIndex && refineIndex.fields) {
             for (const exists of refineIndex.fields) {

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

@@ -0,0 +1,28 @@
+/**
+ * Unlike a source, which is a refinement of a namespace, a query
+ * is creating a new unrelated namespace. The query starts with a
+ * source, which it might modify. This set of fields used to resolve
+ * expressions in the query is called the "input space". There is a
+ * specialized QuerySpace for each type of query operation.
+ */
+import { FieldDeclaration } from '../query-items/field-declaration';
+import { Join } from '../query-properties/joins';
+import { SourceSpec } from '../space-seed';
+import { FieldSpace, QueryFieldSpace } from '../types/field-space';
+import { RefinedSpace } from './refined-space';
+export declare class QueryInputSpace extends RefinedSpace implements QueryFieldSpace {
+    private queryOutput;
+    nestParent?: QueryInputSpace;
+    extendList: string[];
+    /**
+     * Because of circularity concerns this constructor is not typed
+     * properly ...
+     * @param input The source which might be extended
+     * @param queryOutput MUST BE A QuerySpace
+     */
+    constructor(input: SourceSpec, queryOutput: FieldSpace);
+    extendSource(extendField: Join | FieldDeclaration): void;
+    isQueryFieldSpace(): boolean;
+    outputSpace(): FieldSpace;
+    inputSpace(): this;
+}

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

@@ -0,0 +1,47 @@
+"use strict";
+/**
+ * Unlike a source, which is a refinement of a namespace, a query
+ * is creating a new unrelated namespace. The query starts with a
+ * source, which it might modify. This set of fields used to resolve
+ * expressions in the query is called the "input space". There is a
+ * specialized QuerySpace for each type of query operation.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryInputSpace = void 0;
+const joins_1 = require("../query-properties/joins");
+const space_seed_1 = require("../space-seed");
+const refined_space_1 = require("./refined-space");
+class QueryInputSpace extends refined_space_1.RefinedSpace {
+    /**
+     * Because of circularity concerns this constructor is not typed
+     * properly ...
+     * @param input The source which might be extended
+     * @param queryOutput MUST BE A QuerySpace
+     */
+    constructor(input, queryOutput) {
+        const inputSpace = new space_seed_1.SpaceSeed(input);
+        super(inputSpace.structDef);
+        this.queryOutput = queryOutput;
+        this.extendList = [];
+    }
+    extendSource(extendField) {
+        this.pushFields(extendField);
+        if (extendField instanceof joins_1.Join) {
+            this.extendList.push(extendField.name.refString);
+        }
+        else {
+            this.extendList.push(extendField.defineName);
+        }
+    }
+    isQueryFieldSpace() {
+        return true;
+    }
+    outputSpace() {
+        return this.queryOutput;
+    }
+    inputSpace() {
+        return this;
+    }
+}
+exports.QueryInputSpace = QueryInputSpace;
+//# sourceMappingURL=query-input-space.js.map

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

@@ -6,5 +6,5 @@ export declare abstract class QueryField extends SpaceField {
     constructor(inSpace: FieldSpace);
     abstract getQueryFieldDef(fs: FieldSpace): QueryFieldDef | undefined;
     abstract fieldDef(): FieldDef;
-    typeDesc(): TypeDesc;
+    describeType(): TypeDesc;
 }

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

@@ -29,7 +29,7 @@ class QueryField extends space_field_1.SpaceField {
         super();
         this.inSpace = inSpace;
     }
-    typeDesc() {
+    describeType() {
         return { dataType: 'turtle', expressionType: 'scalar', evalSpace: 'input' };
     }
 }

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

@@ -1,42 +1,28 @@
 import * as model from '../../../model/malloy_types';
-import { FieldDeclaration } from '../query-items/field-declaration';
-import { FieldName, FieldSpace } from '../types/field-space';
+import { FieldName, FieldSpace, QueryFieldSpace } from '../types/field-space';
 import { MalloyElement } from '../types/malloy-element';
-import { Join } from '../query-properties/joins';
-import { SourceSpec } from '../space-seed';
-import { FieldReference, WildcardFieldReference } from '../query-items/field-references';
-import { FieldCollectionMember } from '../types/field-collection-member';
-import { QueryItem } from '../types/query-item';
+import { WildcardFieldReference } from '../query-items/field-references';
 import { RefinedSpace } from './refined-space';
 import { LookupResult } from '../types/lookup-result';
+import { QueryInputSpace } from './query-input-space';
 import { SpaceEntry } from '../types/space-entry';
 /**
- * Unlike a source, which is a refinement of a namespace, a query
- * is creating a new unrelated namespace. The query starts with a
- * source, which it might modify. This set of fields used to resolve
- * expressions in the query is called the "input space". There is a
- * specialized QuerySpace for each type of query operation.
+ * The output space of a query operation, it is not named "QueryOutputSpace"
+ * because this is the namespace of the Query. This is the one which is constructed
+ * with the query. The QueryInputSpace is created and paired when a
+ * QuerySpace is created.
  */
-export declare class QueryInputSpace extends RefinedSpace {
-    readonly result: QuerySpace;
-    nestParent?: QueryInputSpace;
-    extendList: string[];
-    constructor(input: SourceSpec, result: QuerySpace);
-    extendSource(extendField: Join | FieldDeclaration): void;
-    isQueryFieldSpace(): boolean;
-    outputSpace(): QuerySpace;
-}
-export declare abstract class QuerySpace extends RefinedSpace {
+export declare abstract class QuerySpace extends RefinedSpace implements QueryFieldSpace {
     readonly queryInputSpace: FieldSpace;
-    readonly exprSpace: QueryInputSpace;
+    private exprSpace;
     astEl?: MalloyElement | undefined;
     abstract readonly segmentType: 'reduce' | 'project' | 'index';
     constructor(queryInputSpace: FieldSpace, refineThis: model.PipeSegment | undefined);
     private addRefineFromFields;
     log(s: string): void;
-    addMembers(members: FieldCollectionMember[]): void;
-    addReference(ref: FieldReference): void;
-    addWild(wild: WildcardFieldReference): void;
+    pushFields(...defs: MalloyElement[]): void;
+    setEntry(name: string, value: SpaceEntry): void;
+    protected addWild(wild: WildcardFieldReference): void;
     /**
      * Check for the definition of an ungrouping reference in the result space,
      * or in the case of an exclude reference, if this query is nested
@@ -44,7 +30,6 @@ export declare abstract class QuerySpace extends RefinedSpace {
      * is nested inside of.
      */
     checkUngroup(fn: FieldName, isExclude: boolean): void;
-    addQueryItems(...qiList: QueryItem[]): void;
     canContain(_typeDesc: model.TypeDesc): boolean;
     protected queryFieldDefs(): model.QueryFieldDef[];
     getQuerySegment(rf: model.QuerySegment | undefined): model.QuerySegment;
@@ -52,13 +37,8 @@ export declare abstract class QuerySpace extends RefinedSpace {
     lookup(path: FieldName[]): LookupResult;
     isQueryFieldSpace(): boolean;
     outputSpace(): this;
+    inputSpace(): QueryInputSpace;
 }
 export declare class ReduceFieldSpace extends QuerySpace {
     readonly segmentType = "reduce";
 }
-export declare class OutputSpaceEntry extends SpaceEntry {
-    readonly inputSpaceEntry: SpaceEntry;
-    refType: 'field' | 'parameter';
-    constructor(inputSpaceEntry: SpaceEntry);
-    typeDesc(): model.TypeDesc;
-}