@malloydata/malloy 0.0.119-dev240123183113 → 0.0.119-dev240124170348

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

@@ -14,9 +14,4 @@ export declare class ReferenceField extends SpaceField {
     get referenceTo(): SpaceEntry | undefined;
     getQueryFieldDef(fs: FieldSpace): QueryFieldDef | undefined;
     typeDesc(): TypeDesc;
-    /**
-     * If the referenced field has any annotations, replace the reference
-     * with something which can hold an annotation
-     */
-    maybeAnnotate(): QueryFieldDef;
 }

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

@@ -23,7 +23,6 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ReferenceField = void 0;
-const malloy_types_1 = require("../../../model/malloy_types");
 const space_field_1 = require("../types/space-field");
 class ReferenceField extends space_field_1.SpaceField {
     constructor(fieldRef, inFS) {
@@ -45,7 +44,22 @@ class ReferenceField extends space_field_1.SpaceField {
             if (check.error) {
                 this.fieldRef.log(check.error);
             }
-            this.queryFieldDef = this.maybeAnnotate();
+            this.queryFieldDef = {
+                type: 'fieldref',
+                path: this.fieldRef.list.map(f => f.name),
+            };
+            const refTo = this.referenceTo;
+            if (refTo instanceof space_field_1.SpaceField && refTo.haveFieldDef) {
+                const origFd = refTo.haveFieldDef;
+                const notes = this.fieldRef.note;
+                if (origFd.annotation || notes) {
+                    const annotation = notes || {};
+                    if (origFd.annotation) {
+                        annotation.inherits = origFd.annotation;
+                    }
+                    this.queryFieldDef.annotation = annotation;
+                }
+            }
         }
         return this.queryFieldDef;
     }
@@ -59,50 +73,6 @@ class ReferenceField extends space_field_1.SpaceField {
         }
         return { dataType: 'error', expressionType: 'scalar', evalSpace: 'input' };
     }
-    /**
-     * If the referenced field has any annotations, replace the reference
-     * with something which can hold an annotation
-     */
-    maybeAnnotate() {
-        const path = this.fieldRef.refString;
-        const refTo = this.referenceTo;
-        if (refTo instanceof space_field_1.SpaceField &&
-            refTo.haveFieldDef &&
-            typeof refTo.haveFieldDef !== 'string') {
-            const origFd = refTo.haveFieldDef;
-            if ((0, malloy_types_1.isFilteredAliasedName)(origFd)) {
-                return origFd;
-            }
-            const notes = this.fieldRef.note;
-            if (origFd.annotation || notes) {
-                const annotation = notes || {};
-                if (origFd.annotation) {
-                    annotation.inherits = origFd.annotation;
-                }
-                if (this.fieldRef.list.length > 1) {
-                    // This is a field inside a join or a record, create an expression
-                    // and annotate the expression.
-                    if ((0, malloy_types_1.isAtomicFieldType)(origFd.type)) {
-                        const newField = {
-                            name: this.fieldRef.list[this.fieldRef.list.length - 1].refString,
-                            type: origFd.type,
-                            e: [{ type: 'field', path }],
-                            annotation,
-                        };
-                        if ((0, malloy_types_1.hasExpression)(origFd)) {
-                            newField.expressionType = origFd.expressionType;
-                        }
-                        return newField;
-                    }
-                    // maybe ok, this likely is some field which cannot be referenced
-                    // in a query and will error, so there would be nothing to annotate
-                    return path;
-                }
-                return { ...origFd, annotation };
-            }
-        }
-        return path;
-    }
 }
 exports.ReferenceField = ReferenceField;
 //# sourceMappingURL=reference-field.js.map

package/dist/lang/ast/query-builders/index-builder.d.ts

@@ -5,7 +5,7 @@ import { IndexFieldSpace } from '../field-space/index-field-space';
 import { QueryProperty } from '../types/query-property';
 import { QueryBuilder } from '../types/query-builder';
 import { QueryInputSpace } from '../field-space/query-input-space';
-import { QuerySpace } from '../field-space/query-spaces';
+import { QueryOperationSpace } from '../field-space/query-spaces';
 import { MalloyElement } from '../types/malloy-element';
 export declare class IndexBuilder implements QueryBuilder {
     filters: FilterExpression[];
@@ -15,7 +15,7 @@ export declare class IndexBuilder implements QueryBuilder {
     resultFS: IndexFieldSpace;
     inputFS: QueryInputSpace;
     readonly type = "index";
-    constructor(inputFS: FieldSpace, refineThis: PipeSegment | undefined, isNestIn: QuerySpace | undefined, astEl: MalloyElement);
+    constructor(inputFS: FieldSpace, refineThis: PipeSegment | undefined, isNestIn: QueryOperationSpace | undefined, astEl: MalloyElement);
     execute(qp: QueryProperty): void;
     finalize(from: PipeSegment | undefined): PipeSegment;
 }

package/dist/lang/ast/query-builders/partial-builder.js

@@ -1,11 +1,38 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PartialBuilder = void 0;
+/*
+ * 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.
+ */
+const model_1 = require("../../../model");
 const reduce_builder_1 = require("./reduce-builder");
 class PartialBuilder extends reduce_builder_1.ReduceBuilder {
     finalize(fromSeg) {
         const seg = super.finalize(fromSeg);
-        return { ...seg, type: 'partial' };
+        if ((0, model_1.isQuerySegment)(seg)) {
+            return { ...seg, type: 'partial' };
+        }
+        // TODO index, raw, ??
+        throw new Error(`Partial Builder cannot finalize from ${seg.type}`);
     }
 }
 exports.PartialBuilder = PartialBuilder;

package/dist/lang/ast/query-builders/project-builder.d.ts

@@ -2,12 +2,16 @@ import { PipeSegment } from '../../../model/malloy_types';
 import { FieldSpace } from '../types/field-space';
 import { ProjectFieldSpace } from '../field-space/project-field-space';
 import { QueryProperty } from '../types/query-property';
-import { ReduceBuilder } from './reduce-builder';
-import { QuerySpace } from '../field-space/query-spaces';
+import { QuerySegmentBuilder } from './reduce-builder';
+import { QueryOperationSpace } from '../field-space/query-spaces';
 import { MalloyElement } from '../types/malloy-element';
-export declare class ProjectBuilder extends ReduceBuilder {
+import { QueryBuilder } from '../types/query-builder';
+import { QueryInputSpace } from '../field-space/query-input-space';
+export declare class ProjectBuilder extends QuerySegmentBuilder implements QueryBuilder {
+    resultFS: ProjectFieldSpace;
+    inputFS: QueryInputSpace;
     readonly type = "project";
-    getResultSpace(fs: FieldSpace, refineThis: PipeSegment | undefined, isNestIn: QuerySpace | undefined, astEl: MalloyElement): ProjectFieldSpace;
+    constructor(baseFS: FieldSpace, refineThis: PipeSegment | undefined, isNestIn: QueryOperationSpace | undefined, astEl: MalloyElement);
     execute(qp: QueryProperty): void;
     finalize(fromSeg: PipeSegment | undefined): PipeSegment;
 }

package/dist/lang/ast/query-builders/project-builder.js

@@ -28,13 +28,12 @@ const error_factory_1 = require("../error-factory");
 const group_by_1 = require("../query-properties/group-by");
 const project_field_space_1 = require("../field-space/project-field-space");
 const reduce_builder_1 = require("./reduce-builder");
-class ProjectBuilder extends reduce_builder_1.ReduceBuilder {
-    constructor() {
-        super(...arguments);
+class ProjectBuilder extends reduce_builder_1.QuerySegmentBuilder {
+    constructor(baseFS, refineThis, isNestIn, astEl) {
+        super();
         this.type = 'project';
-    }
-    getResultSpace(fs, refineThis, isNestIn, astEl) {
-        return new project_field_space_1.ProjectFieldSpace(fs, refineThis, isNestIn, astEl);
+        this.resultFS = new project_field_space_1.ProjectFieldSpace(baseFS, refineThis, isNestIn, astEl);
+        this.inputFS = this.resultFS.inputSpace();
     }
     execute(qp) {
         if (qp.elementType === 'having' || qp instanceof group_by_1.GroupBy) {

package/dist/lang/ast/query-builders/reduce-builder.d.ts

@@ -4,19 +4,24 @@ import { Ordering } from '../query-properties/ordering';
 import { Top } from '../query-properties/top';
 import { QueryProperty } from '../types/query-property';
 import { QueryBuilder } from '../types/query-builder';
-import { QuerySpace } from '../field-space/query-spaces';
+import { QueryOperationSpace, ReduceFieldSpace } from '../field-space/query-spaces';
 import { QueryInputSpace } from '../field-space/query-input-space';
 import { MalloyElement } from '../types/malloy-element';
-export declare class ReduceBuilder implements QueryBuilder {
-    inputFS: QueryInputSpace;
-    resultFS: QuerySpace;
-    filters: FilterExpression[];
+export declare abstract class QuerySegmentBuilder implements QueryBuilder {
     order?: Top | Ordering;
     limit?: number;
-    type: 'grouping' | 'project';
-    constructor(baseFS: FieldSpace, refineThis: PipeSegment | undefined, isNestIn: QuerySpace | undefined, astEl: MalloyElement);
-    getResultSpace(fs: FieldSpace, refineThis: PipeSegment | undefined, isNestIn: QuerySpace | undefined, astEl: MalloyElement): QuerySpace;
+    abstract inputFS: QueryInputSpace;
+    abstract resultFS: QueryOperationSpace;
+    abstract readonly type: 'grouping' | 'project';
+    filters: FilterExpression[];
     execute(qp: QueryProperty): void;
+    abstract finalize(fromSeg: PipeSegment | undefined): PipeSegment;
     refineFrom(from: PipeSegment | undefined, to: QuerySegment): void;
+}
+export declare class ReduceBuilder extends QuerySegmentBuilder implements QueryBuilder {
+    inputFS: QueryInputSpace;
+    resultFS: ReduceFieldSpace;
+    readonly type = "grouping";
+    constructor(baseFS: FieldSpace, refineThis: PipeSegment | undefined, isNestIn: QueryOperationSpace | undefined, astEl: MalloyElement);
     finalize(fromSeg: PipeSegment | undefined): PipeSegment;
 }

package/dist/lang/ast/query-builders/reduce-builder.js

@@ -22,7 +22,7 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ReduceBuilder = void 0;
+exports.ReduceBuilder = exports.QuerySegmentBuilder = void 0;
 const malloy_types_1 = require("../../../model/malloy_types");
 const error_factory_1 = require("../error-factory");
 const filters_1 = require("../query-properties/filters");
@@ -31,15 +31,9 @@ const ordering_1 = require("../query-properties/ordering");
 const top_1 = require("../query-properties/top");
 const query_spaces_1 = require("../field-space/query-spaces");
 const definition_list_1 = require("../types/definition-list");
-class ReduceBuilder {
-    constructor(baseFS, refineThis, isNestIn, astEl) {
+class QuerySegmentBuilder {
+    constructor() {
         this.filters = [];
-        this.resultFS = this.getResultSpace(baseFS, refineThis, isNestIn, astEl);
-        this.inputFS = this.resultFS.inputSpace();
-        this.type = 'grouping';
-    }
-    getResultSpace(fs, refineThis, isNestIn, astEl) {
-        return new query_spaces_1.ReduceFieldSpace(fs, refineThis, isNestIn, astEl);
     }
     execute(qp) {
         if (qp.queryExecute) {
@@ -120,6 +114,15 @@ class ReduceBuilder {
             to.filterList = [...oldFilters, ...this.filters];
         }
     }
+}
+exports.QuerySegmentBuilder = QuerySegmentBuilder;
+class ReduceBuilder extends QuerySegmentBuilder {
+    constructor(baseFS, refineThis, isNestIn, astEl) {
+        super();
+        this.type = 'grouping';
+        this.resultFS = new query_spaces_1.ReduceFieldSpace(baseFS, refineThis, isNestIn, astEl);
+        this.inputFS = this.resultFS.inputSpace();
+    }
     finalize(fromSeg) {
         let from;
         if (fromSeg) {

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

@@ -69,7 +69,7 @@ export declare class DefSpace implements FieldSpace {
     entries(): [string, SpaceEntry][];
     dialectObj(): Dialect | undefined;
     isQueryFieldSpace(): this is QueryFieldSpace;
-    outputSpace(): import("../field-space/query-spaces").QuerySpace;
+    outputSpace(): import("../field-space/query-spaces").QueryOperationSpace;
     inputSpace(): FieldSpace;
 }
 export declare class FieldDefinitionValue extends SpaceField {

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

@@ -1,4 +1,4 @@
-import { Annotation, FieldDef, TypeDesc } from '../../../model/malloy_types';
+import { Annotation, FieldDef, RefToField, TypeDesc } from '../../../model/malloy_types';
 import { DynamicSpace } from '../field-space/dynamic-space';
 import { DefinitionList } from '../types/definition-list';
 import { FieldName, FieldSpace } from '../types/field-space';
@@ -13,7 +13,9 @@ export declare abstract class FieldReference extends ListOf<FieldName> implement
     extendNote: typeof extendNoteMethod;
     constructor(names: FieldName[]);
     makeEntry(fs: DynamicSpace): void;
+    get refToField(): RefToField;
     get refString(): string;
+    get path(): string[];
     get outputName(): string;
     get sourceString(): string | undefined;
     get nameString(): string;
@@ -35,6 +37,8 @@ export declare class CalculateFieldReference extends FieldReference {
 export declare class IndexFieldReference extends FieldReference {
     elementType: string;
     typecheck(type: TypeDesc): void;
+    static indexOutputName(path: string[]): string;
+    get outputName(): string;
 }
 export declare class AggregateFieldReference extends FieldReference {
     elementType: string;

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

@@ -45,8 +45,17 @@ class FieldReference extends malloy_element_1.ListOf {
             fs.newEntry(refName, this, new reference_field_1.ReferenceField(this, fromFS));
         }
     }
+    get refToField() {
+        return {
+            type: 'fieldref',
+            path: this.list.map(n => n.refString),
+        };
+    }
     get refString() {
-        return this.list.map(n => n.refString).join('.');
+        return this.path.join('.');
+    }
+    get path() {
+        return this.list.map(n => n.refString);
     }
     get outputName() {
         const last = this.list[this.list.length - 1];
@@ -114,6 +123,13 @@ class IndexFieldReference extends FieldReference {
     typecheck(type) {
         (0, typecheck_utils_1.typecheckIndex)(type, this);
     }
+    // Index entries are expected to be unique on path
+    static indexOutputName(path) {
+        return path.map(pe => encodeURIComponent(pe)).join('/');
+    }
+    get outputName() {
+        return IndexFieldReference.indexOutputName(this.path);
+    }
 }
 exports.IndexFieldReference = IndexFieldReference;
 class AggregateFieldReference extends FieldReference {

package/dist/lang/ast/query-properties/qop-desc.d.ts

@@ -4,7 +4,7 @@ import { ListOf } from '../types/malloy-element';
 import { OpDesc } from '../types/op-desc';
 import { QueryProperty } from '../types/query-property';
 import { QueryClass } from '../types/query-property-interface';
-import { QuerySpace } from '../field-space/query-spaces';
+import { QueryOperationSpace } from '../field-space/query-spaces';
 export declare class QOpDesc extends ListOf<QueryProperty> {
     elementType: string;
     opClass: QueryClass | undefined;
@@ -12,5 +12,5 @@ export declare class QOpDesc extends ListOf<QueryProperty> {
     protected computeType(): QueryClass | undefined;
     refineFrom(existing: PipeSegment): void;
     private getBuilder;
-    getOp(inputFS: FieldSpace, isNestIn: QuerySpace | undefined): OpDesc;
+    getOp(inputFS: FieldSpace, isNestIn: QueryOperationSpace | undefined): OpDesc;
 }

package/dist/lang/ast/source-properties/joins.js

@@ -95,7 +95,7 @@ class KeyJoin extends Join {
                         onExpression: [
                             {
                                 type: 'field',
-                                path: `${this.name}.${inStruct.primaryKey}`,
+                                path: [this.name.refString, inStruct.primaryKey],
                             },
                             '=',
                             ...exprX.value,

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

@@ -1,6 +1,6 @@
 import { Dialect } from '../../../dialect/dialect';
 import { StructDef } from '../../../model/malloy_types';
-import { QuerySpace } from '../field-space/query-spaces';
+import { QueryOperationSpace } from '../field-space/query-spaces';
 import { LookupResult } from './lookup-result';
 import { MalloyElement } from './malloy-element';
 import { SpaceEntry } from './space-entry';
@@ -19,7 +19,7 @@ export interface FieldSpace {
     isQueryFieldSpace(): this is QueryFieldSpace;
 }
 export interface QueryFieldSpace extends FieldSpace {
-    outputSpace(): QuerySpace;
+    outputSpace(): QueryOperationSpace;
     inputSpace(): FieldSpace;
 }
 export declare class FieldName extends MalloyElement {

package/dist/lang/ast/types/query-builder.d.ts

@@ -1,11 +1,11 @@
 import { PipeSegment } from '../../../model/malloy_types';
 import { QueryProperty } from './query-property';
 import { QueryInputSpace } from '../field-space/query-input-space';
-import { QuerySpace } from '../field-space/query-spaces';
+import { QueryOperationSpace } from '../field-space/query-spaces';
 export interface QueryBuilder {
     type: 'grouping' | 'index' | 'project';
     inputFS: QueryInputSpace;
-    resultFS: QuerySpace;
+    resultFS: QueryOperationSpace;
     execute(qp: QueryProperty): void;
     finalize(refineFrom: PipeSegment | undefined): PipeSegment;
 }

package/dist/lang/ast/view-elements/qop-desc-view.d.ts

@@ -1,5 +1,5 @@
 import { PipeSegment } from '../../../model/malloy_types';
-import { QuerySpace } from '../field-space/query-spaces';
+import { QueryOperationSpace } from '../field-space/query-spaces';
 import { QOpDesc } from '../query-properties/qop-desc';
 import { FieldSpace } from '../types/field-space';
 import { PipelineComp } from '../types/pipeline-comp';
@@ -13,7 +13,7 @@ export declare class QOpDescView extends View {
     readonly operation: QOpDesc;
     elementType: string;
     constructor(operation: QOpDesc);
-    pipelineComp(fs: FieldSpace, isNestIn?: QuerySpace): PipelineComp;
+    pipelineComp(fs: FieldSpace, isNestIn?: QueryOperationSpace): PipelineComp;
     private getOp;
-    refine(inputFS: FieldSpace, _pipeline: PipeSegment[], isNestIn: QuerySpace | undefined): PipeSegment[];
+    refine(inputFS: FieldSpace, _pipeline: PipeSegment[], isNestIn: QueryOperationSpace | undefined): PipeSegment[];
 }

package/dist/lang/ast/view-elements/reference-view.d.ts

@@ -1,5 +1,5 @@
 import { PipeSegment } from '../../../model/malloy_types';
-import { QuerySpace } from '../field-space/query-spaces';
+import { QueryOperationSpace } from '../field-space/query-spaces';
 import { ViewOrScalarFieldReference } from '../query-items/field-references';
 import { FieldSpace } from '../types/field-space';
 import { PipelineComp } from '../types/pipeline-comp';
@@ -16,12 +16,12 @@ export declare class ReferenceView extends View {
     readonly reference: ViewOrScalarFieldReference;
     elementType: string;
     constructor(reference: ViewOrScalarFieldReference);
-    pipelineComp(fs: FieldSpace, _isNestIn: QuerySpace): PipelineComp;
+    pipelineComp(fs: FieldSpace, _isNestIn: QueryOperationSpace): PipelineComp;
     _pipelineComp(fs: FieldSpace, { forRefinement }?: {
         forRefinement: boolean;
     }): PipelineComp & {
         error?: boolean;
     };
     private getRefinementSegment;
-    refine(inputFS: FieldSpace, pipeline: PipeSegment[], _isNestIn: QuerySpace | undefined): PipeSegment[];
+    refine(inputFS: FieldSpace, pipeline: PipeSegment[], _isNestIn: QueryOperationSpace | undefined): PipeSegment[];
 }

package/dist/lang/ast/view-elements/reference-view.js

@@ -81,7 +81,7 @@ class ReferenceView extends view_1.View {
             }
             const newSegment = {
                 type: 'reduce',
-                fields: [this.reference.refString],
+                queryFields: [this.reference.refToField],
             };
             const { dialect, queryTimezone, structRelationship } = fs.structDef();
             const name = this.reference.nameString;

package/dist/lang/ast/view-elements/refine-utils.js

@@ -24,6 +24,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.refine = void 0;
 const model_1 = require("../../../model");
+const field_utils_1 = require("../../field-utils");
 function refine(logTo, refineTo, refineFrom) {
     var _a, _b;
     // TODO we should probably support this
@@ -72,30 +73,31 @@ function refine(logTo, refineTo, refineFrom) {
             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);
+        if ((0, model_1.isQuerySegment)(from) && (0, model_1.isQuerySegment)(to)) {
+            const overlappingFields = [];
+            const nonOverlappingFields = [];
+            const existingNames = new Map(to.queryFields.map((f) => [
+                (0, field_utils_1.nameFromDef)(f),
+                f,
+            ]));
+            for (const field of from.queryFields) {
+                if (existingNames.has((0, field_utils_1.nameFromDef)(field))) {
+                    overlappingFields.push(field);
+                }
+                else {
+                    nonOverlappingFields.push(field);
+                }
             }
-            else {
-                nonOverlappingFields.push(field);
+            to.queryFields = [...to.queryFields, ...nonOverlappingFields];
+            if (overlappingFields.length > 0) {
+                logTo.log(`overlapping fields in refinement: ${overlappingFields.map(field_utils_1.nameFromDef)}`);
             }
         }
-        to.fields = [...to.fields, ...nonOverlappingFields];
-        if (overlappingFields.length > 0) {
-            logTo.log(`overlapping fields in refinement: ${overlappingFields.map(extractName)}`);
+        else if (from.type === 'index' && to.type === 'index') {
+            to.indexFields = [...from.indexFields, ...to.indexFields];
         }
     }
     return [to];
 }
 exports.refine = refine;
-function extractName(f1) {
-    var _a;
-    return typeof f1 === 'string' ? f1 : (_a = f1.as) !== null && _a !== void 0 ? _a : f1.name;
-}
 //# sourceMappingURL=refine-utils.js.map

package/dist/lang/ast/view-elements/view-arrow.d.ts

@@ -1,5 +1,5 @@
 import { PipeSegment } from '../../../model/malloy_types';
-import { QuerySpace } from '../field-space/query-spaces';
+import { QueryOperationSpace } from '../field-space/query-spaces';
 import { FieldSpace } from '../types/field-space';
 import { PipelineComp } from '../types/pipeline-comp';
 import { View } from './view';
@@ -15,5 +15,5 @@ export declare class ViewArrow extends View {
     elementType: string;
     constructor(base: View, operation: View);
     pipelineComp(fs: FieldSpace): PipelineComp;
-    refine(_inputFS: FieldSpace, _pipeline: PipeSegment[], _isNestIn: QuerySpace | undefined): PipeSegment[];
+    refine(_inputFS: FieldSpace, _pipeline: PipeSegment[], _isNestIn: QueryOperationSpace | undefined): PipeSegment[];
 }

package/dist/lang/ast/view-elements/view-refine.d.ts

@@ -1,5 +1,5 @@
 import { PipeSegment } from '../../../model';
-import { QuerySpace } from '../field-space/query-spaces';
+import { QueryOperationSpace } from '../field-space/query-spaces';
 import { FieldSpace } from '../types/field-space';
 import { PipelineComp } from '../types/pipeline-comp';
 import { View } from './view';
@@ -14,6 +14,6 @@ export declare class ViewRefine extends View {
     readonly refinement: View;
     elementType: string;
     constructor(base: View, refinement: View);
-    pipelineComp(fs: FieldSpace, isNestIn?: QuerySpace): PipelineComp;
-    refine(inputFS: FieldSpace, pipeline: PipeSegment[], isNestIn: QuerySpace | undefined): PipeSegment[];
+    pipelineComp(fs: FieldSpace, isNestIn?: QueryOperationSpace): PipelineComp;
+    refine(inputFS: FieldSpace, pipeline: PipeSegment[], isNestIn: QueryOperationSpace | undefined): PipeSegment[];
 }

package/dist/lang/ast/view-elements/view.d.ts

@@ -1,5 +1,5 @@
 import { PipeSegment } from '../../../model/malloy_types';
-import { QuerySpace } from '../field-space/query-spaces';
+import { QueryOperationSpace } from '../field-space/query-spaces';
 import { FieldSpace } from '../types/field-space';
 import { MalloyElement } from '../types/malloy-element';
 import { PipelineComp } from '../types/pipeline-comp';
@@ -19,7 +19,7 @@ import { PipelineComp } from '../types/pipeline-comp';
  * e.g. after the arrow in `run: flights -> by_carrier`
  */
 export declare abstract class View extends MalloyElement {
-    abstract pipelineComp(fs: FieldSpace, isNestIn?: QuerySpace): PipelineComp;
-    pipeline(fs: FieldSpace, isNestIn?: QuerySpace): PipeSegment[];
-    abstract refine(inputFS: FieldSpace, pipeline: PipeSegment[], isNestIn: QuerySpace | undefined): PipeSegment[];
+    abstract pipelineComp(fs: FieldSpace, isNestIn?: QueryOperationSpace): PipelineComp;
+    pipeline(fs: FieldSpace, isNestIn?: QueryOperationSpace): PipeSegment[];
+    abstract refine(inputFS: FieldSpace, pipeline: PipeSegment[], isNestIn: QueryOperationSpace | undefined): PipeSegment[];
 }

package/dist/lang/field-utils.d.ts

@@ -1,5 +1,5 @@
 import { FieldDef, QueryFieldDef } from '../model/malloy_types';
-type Field = QueryFieldDef | FieldDef;
-export declare function nameOf(qfd: Field): string;
-export declare function mergeFields<T extends Field>(older: T[] | undefined, newer: T[]): T[];
+type NamedFieldThing = FieldDef | QueryFieldDef;
+export declare function nameFromDef(f1: NamedFieldThing): string;
+export declare function mergeFields<T extends NamedFieldThing>(older: T[] | undefined, newer: T[]): T[];
 export {};

package/dist/lang/field-utils.js

@@ -22,20 +22,21 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.mergeFields = exports.nameOf = void 0;
-function nameOf(qfd) {
-    if (typeof qfd === 'string') {
-        return qfd;
+exports.mergeFields = exports.nameFromDef = void 0;
+function nameFromDef(f1) {
+    var _a;
+    if (f1.type === 'fieldref') {
+        return f1.path[f1.path.length - 1];
     }
-    return qfd.as || qfd.name;
+    return (_a = f1.as) !== null && _a !== void 0 ? _a : f1.name;
 }
-exports.nameOf = nameOf;
+exports.nameFromDef = nameFromDef;
 function mergeFields(older, newer) {
     if (older === undefined) {
         return newer;
     }
-    const redefined = new Set(newer.map(f => nameOf(f)));
-    const merged = older.filter(f => !redefined.has(nameOf(f)));
+    const redefined = new Set(newer.map(f => nameFromDef(f)));
+    const merged = older.filter(f => !redefined.has(nameFromDef(f)));
     merged.push(...newer);
     return merged;
 }