@malloydata/malloy 0.0.299 → 0.0.300

package/dist/api/asynchronous.d.ts

@@ -10,4 +10,4 @@ export interface CompilerNeedFetch<T extends InfoConnection> {
 export declare function compileModel(request: Malloy.CompileModelRequest, fetchers: CompilerNeedFetch<InfoConnection>): Promise<Malloy.CompileModelResponse>;
 export declare function compileSource(request: Malloy.CompileSourceRequest, fetchers: CompilerNeedFetch<InfoConnection>): Promise<Malloy.CompileSourceResponse>;
 export declare function compileQuery(request: Malloy.CompileQueryRequest, fetchers: CompilerNeedFetch<InfoConnection>): Promise<Malloy.CompileQueryResponse>;
-export declare function runQuery(request: Malloy.CompileQueryRequest, fetchers: CompilerNeedFetch<Connection>): Promise<Malloy.CompileQueryResponse>;
+export declare function runQuery(request: Malloy.RunQueryRequest, fetchers: CompilerNeedFetch<Connection>): Promise<Malloy.RunQueryResponse>;

package/dist/api/core.js

@@ -258,14 +258,15 @@ function updateCompileModelState(state, needs) {
     const update = compilerNeedsToUpdate(needs);
     performUpdate(state, update);
 }
-function _newCompileModelState(modelURL, compilerNeeds, extendURL, excludeReferences = false) {
+function _newCompileModelState(modelURL, compilerNeeds, parseUpdate, extendURL, excludeReferences = false) {
     var _a, _b, _c, _d;
-    const translator = new lang_1.MalloyTranslator(modelURL, null, compilerNeedsToUpdate(compilerNeeds));
+    parseUpdate !== null && parseUpdate !== void 0 ? parseUpdate : (parseUpdate = compilerNeedsToUpdate(compilerNeeds));
+    const translator = new lang_1.MalloyTranslator(modelURL, null, parseUpdate);
     const hasSource = ((_b = (_a = compilerNeeds === null || compilerNeeds === void 0 ? void 0 : compilerNeeds.files) === null || _a === void 0 ? void 0 : _a.some(f => f.url === modelURL)) !== null && _b !== void 0 ? _b : false) ||
         ((_d = (_c = compilerNeeds === null || compilerNeeds === void 0 ? void 0 : compilerNeeds.translations) === null || _c === void 0 ? void 0 : _c.some(t => t.url === modelURL)) !== null && _d !== void 0 ? _d : false);
     if (extendURL) {
         return {
-            extending: _newCompileModelState(extendURL, compilerNeeds, undefined, excludeReferences),
+            extending: _newCompileModelState(extendURL, compilerNeeds, parseUpdate, undefined, excludeReferences),
             translator,
             done: false,
             hasSource,
@@ -282,10 +283,10 @@ function _newCompileModelState(modelURL, compilerNeeds, extendURL, excludeRefere
     }
 }
 function newCompileModelState(request) {
-    return _newCompileModelState(request.model_url, request.compiler_needs, request.extend_model_url, request.exclude_references);
+    return _newCompileModelState(request.model_url, request.compiler_needs, undefined, request.extend_model_url, request.exclude_references);
 }
 function newCompileSourceState(request) {
-    return _newCompileModelState(request.model_url, request.compiler_needs, request.extend_model_url, request.exclude_references);
+    return _newCompileModelState(request.model_url, request.compiler_needs, undefined, request.extend_model_url, request.exclude_references);
 }
 // function hasNeeds(needs: Malloy.CompilerNeeds | undefined): boolean {
 //   if (needs === undefined) return false;
@@ -427,10 +428,13 @@ function hasErrors(log) {
     return (_a = log === null || log === void 0 ? void 0 : log.some(m => m.severity === 'error')) !== null && _a !== void 0 ? _a : false;
 }
 function newCompileQueryState(request) {
-    var _a, _b;
-    const queryMalloy = Malloy.queryToMalloy(request.query);
+    var _a, _b, _c;
+    const queryMalloy = (_a = request.query_malloy) !== null && _a !== void 0 ? _a : (request.query ? Malloy.queryToMalloy(request.query) : undefined);
+    if (queryMalloy === undefined) {
+        throw new Error('Expected either query or query_malloy');
+    }
     const needs = {
-        ...((_a = request.compiler_needs) !== null && _a !== void 0 ? _a : {}),
+        ...((_b = request.compiler_needs) !== null && _b !== void 0 ? _b : {}),
     };
     const queryURL = 'internal://query.malloy';
     needs.files = [
@@ -438,10 +442,10 @@ function newCompileQueryState(request) {
             url: queryURL,
             contents: queryMalloy,
         },
-        ...((_b = needs.files) !== null && _b !== void 0 ? _b : []),
+        ...((_c = needs.files) !== null && _c !== void 0 ? _c : []),
     ];
     return {
-        ..._newCompileModelState(queryURL, needs, request.model_url, request.exclude_references),
+        ..._newCompileModelState(queryURL, needs, undefined, request.model_url, request.exclude_references),
         defaultRowLimit: request.default_row_limit,
     };
 }

package/dist/api/sessioned.js

@@ -242,7 +242,11 @@ class SessionManager {
         }
     }
     compileQuery(request, options) {
-        const queryString = Malloy.queryToMalloy(request.query);
+        var _a;
+        const queryString = (_a = request.query_malloy) !== null && _a !== void 0 ? _a : (request.query ? Malloy.queryToMalloy(request.query) : undefined);
+        if (queryString === undefined) {
+            throw new Error('Expected query_malloy or query');
+        }
         const sessionInfo = {
             type: 'compile_query',
             modelURL: request.model_url,

package/dist/dialect/functions/util.js

@@ -233,9 +233,12 @@ function expandReturnTypeBlueprint(blueprint) {
     else if ('sql_native' in blueprint) {
         return anyExprType({ type: 'sql native', rawType: blueprint.sql_native });
     }
-    else {
+    else if ('calculation' in blueprint) {
         return minAnalytic(expandTypeDescElementBlueprint(blueprint.calculation, false));
     }
+    else {
+        throw new Error('Invalid function blueprint');
+    }
 }
 function isTypeDescBlueprint(blueprint) {
     return (typeof blueprint === 'string' ||
@@ -291,9 +294,12 @@ function expandParamTypeBlueprint(blueprint) {
     else if ('sql_native' in blueprint) {
         return anyExprType({ type: 'sql native', rawType: blueprint.sql_native });
     }
-    else {
+    else if ('calculation' in blueprint) {
         return maxAnalytic(expandTypeDescElementBlueprint(blueprint.calculation));
     }
+    else {
+        throw new Error('Invalid function blueprint');
+    }
 }
 function expandParamTypeBlueprints(blueprints) {
     return blueprints.map(blueprint => expandParamTypeBlueprint(blueprint));

package/dist/lang/ast/error-factory.js

@@ -61,13 +61,27 @@ class ErrorFactory {
         };
     }
     static get reduceSegment() {
-        return { type: 'reduce', queryFields: [] };
+        return {
+            type: 'reduce',
+            queryFields: [],
+            outputStruct: ErrorFactory.structDef,
+            isRepeated: false,
+        };
     }
     static get projectSegment() {
-        return { type: 'project', queryFields: [] };
+        return {
+            type: 'project',
+            queryFields: [],
+            outputStruct: ErrorFactory.structDef,
+            isRepeated: true,
+        };
     }
     static get indexSegment() {
-        return { type: 'index', indexFields: [] };
+        return {
+            type: 'index',
+            indexFields: [],
+            outputStruct: ErrorFactory.structDef,
+        };
     }
 }
 exports.ErrorFactory = ErrorFactory;

package/dist/lang/ast/expressions/constant-expression.d.ts

@@ -14,6 +14,7 @@ export declare class ConstantFieldSpace implements FieldSpace {
     entry(): undefined;
     dialectName(): string;
     dialectObj(): undefined;
+    connectionName(): string;
     isQueryFieldSpace(): this is QueryFieldSpace;
     accessProtectionLevel(): AccessModifierLabel;
 }

package/dist/lang/ast/expressions/constant-expression.js

@@ -55,6 +55,9 @@ class ConstantFieldSpace {
     dialectObj() {
         return undefined;
     }
+    connectionName() {
+        return '~constant-space-unknown-connection~';
+    }
     isQueryFieldSpace() {
         return false;
     }

package/dist/lang/ast/expressions/expr-props.d.ts

@@ -153,6 +153,18 @@ export declare class ExprProps extends ExpressionDef {
         morphic?: {
             [x: string]: import("../../../model/malloy_types").Expr;
         };
+    } | {
+        requiresGroupBy: import("../../../model/malloy_types").RequiredGroupBy[] | undefined;
+        type: "turtle";
+        pipeline: import("../../../model/malloy_types").PipeSegment[];
+        expressionType: import("../../../model/malloy_types").ExpressionType;
+        evalSpace: import("../../../model/malloy_types").EvalSpace;
+        fieldUsage: import("../../../model/malloy_types").FieldUsage[];
+        ungroupings?: import("../../../model/malloy_types").AggregateUngrouping[];
+        value: import("../../../model/malloy_types").Expr;
+        morphic?: {
+            [x: string]: import("../../../model/malloy_types").Expr;
+        };
     } | {
         requiresGroupBy: import("../../../model/malloy_types").RequiredGroupBy[] | undefined;
         type: "date";

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

@@ -68,7 +68,7 @@ const struct_space_field_base_1 = require("./struct-space-field-base");
 const parameter_space_1 = require("./parameter-space");
 class DynamicSpace extends static_space_1.StaticSpace {
     constructor(extending) {
-        super(structuredClone(extending), extending.dialect);
+        super({ ...extending }, extending.dialect, extending.connection);
         this.complete = false;
         this.parameters = [];
         this.newAccessModifiers = new Map();

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

@@ -1,10 +1,11 @@
-import type { IndexSegment, PipeSegment } from '../../../model/malloy_types';
+import type { IndexSegment, PipeSegment, SourceDef } from '../../../model/malloy_types';
 import { WildcardFieldReference } from '../query-items/field-references';
 import type { MalloyElement } from '../types/malloy-element';
 import { QueryOperationSpace } from './query-spaces';
 export declare class IndexFieldSpace extends QueryOperationSpace {
     readonly segmentType = "index";
     pushFields(...defs: MalloyElement[]): void;
+    structDef(): SourceDef;
     getPipeSegment(refineIndex?: PipeSegment): IndexSegment;
     addRefineFromFields(_refineThis: never): void;
     protected addWild(wild: WildcardFieldReference): void;

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

@@ -25,6 +25,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.IndexFieldSpace = void 0;
 const composite_source_utils_1 = require("../../../model/composite_source_utils");
 const malloy_types_1 = require("../../../model/malloy_types");
+const error_factory_1 = require("../error-factory");
 const field_references_1 = require("../query-items/field-references");
 const space_field_1 = require("../types/space-field");
 const query_spaces_1 = require("./query-spaces");
@@ -48,11 +49,27 @@ class IndexFieldSpace extends query_spaces_1.QueryOperationSpace {
             }
         }
     }
+    structDef() {
+        const connection = this.inputSpace().connectionName();
+        return {
+            type: 'query_result',
+            name: 'result',
+            dialect: this.dialectName(),
+            fields: [
+                { type: 'string', name: 'fieldName' },
+                { type: 'string', name: 'fieldPath' },
+                { type: 'string', name: 'fieldValue' },
+                { type: 'string', name: 'fieldType' },
+                { type: 'number', name: 'weight', numberType: 'integer' },
+            ],
+            connection,
+        };
+    }
     getPipeSegment(refineIndex) {
         var _a;
         if (refineIndex) {
             this.logError('refinement-of-index-segment', 'index query operations cannot be refined');
-            return { type: 'index', indexFields: [] };
+            return error_factory_1.ErrorFactory.indexSegment;
         }
         let fieldUsage = (0, composite_source_utils_1.emptyFieldUsage)();
         const indexFields = [];
@@ -80,7 +97,8 @@ class IndexFieldSpace extends query_spaces_1.QueryOperationSpace {
             }
         }
         this._fieldUsage = fieldUsage;
-        return { type: 'index', indexFields };
+        const outputStruct = this.structDef();
+        return { type: 'index', indexFields, outputStruct };
     }
     addRefineFromFields(_refineThis) { }
     addWild(wild) {

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

@@ -4,5 +4,5 @@ import { StructSpaceField } from './static-space';
 export declare class JoinSpaceField extends StructSpaceField {
     readonly parameterSpace: ParameterSpace;
     readonly join: Join;
-    constructor(parameterSpace: ParameterSpace, join: Join, forDialect: string);
+    constructor(parameterSpace: ParameterSpace, join: Join, forDialect: string, forConnection: string);
 }

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

@@ -25,8 +25,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.JoinSpaceField = void 0;
 const static_space_1 = require("./static-space");
 class JoinSpaceField extends static_space_1.StructSpaceField {
-    constructor(parameterSpace, join, forDialect) {
-        super(join.getStructDef(parameterSpace), forDialect);
+    constructor(parameterSpace, join, forDialect, forConnection) {
+        super(join.getStructDef(parameterSpace), forDialect, forConnection);
         this.parameterSpace = parameterSpace;
         this.join = join;
     }

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

@@ -14,6 +14,7 @@ export declare class ParameterSpace implements FieldSpace {
     lookup(symbol: FieldName[]): LookupResult;
     entries(): [string, SpaceEntry][];
     dialectName(): string;
+    connectionName(): string;
     dialectObj(): Dialect | undefined;
     isQueryFieldSpace(): this is QueryFieldSpace;
     accessProtectionLevel(): AccessModifierLabel;

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

@@ -70,6 +70,9 @@ class ParameterSpace {
     dialectName() {
         return '~parameter-space-unknown-dialect~';
     }
+    connectionName() {
+        return '~parameter-space-unknown-connection~';
+    }
     dialectObj() {
         return undefined;
     }

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

@@ -18,4 +18,5 @@ export declare class PassthroughSpace implements FieldSpace {
     outputSpace(): import("./query-spaces").QueryOperationSpace;
     inputSpace(): import("../types/field-space").SourceFieldSpace;
     accessProtectionLevel(): AccessModifierLabel;
+    connectionName(): string;
 }

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

@@ -51,6 +51,9 @@ class PassthroughSpace {
     accessProtectionLevel() {
         return this.realFS.accessProtectionLevel();
     }
+    connectionName() {
+        return this.realFS.connectionName();
+    }
 }
 exports.PassthroughSpace = PassthroughSpace;
 //# sourceMappingURL=passthrough-space.js.map

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

@@ -27,4 +27,5 @@ export declare class QueryInputSpace extends RefinedSpace implements QueryFieldS
     outputSpace(): QueryOperationSpace;
     inputSpace(): this;
     accessProtectionLevel(): AccessModifierLabel;
+    isQueryOutputSpace(): boolean;
 }

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

@@ -59,6 +59,9 @@ class QueryInputSpace extends refined_space_1.RefinedSpace {
     accessProtectionLevel() {
         return this._accessProtectionLevel;
     }
+    isQueryOutputSpace() {
+        return false;
+    }
 }
 exports.QueryInputSpace = QueryInputSpace;
 //# sourceMappingURL=query-input-space.js.map

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

@@ -9,6 +9,10 @@ import type { LookupResult } from '../types/lookup-result';
 import { QueryInputSpace } from './query-input-space';
 import type { SpaceEntry } from '../types/space-entry';
 import type { LogMessageOptions, MessageCode, MessageParameterType } from '../../parse-log';
+type TranslatedQueryField = {
+    queryFieldDef: model.QueryFieldDef;
+    typeDesc: model.TypeDesc;
+};
 /**
  * The output space of a query operation. It is not named "QueryOutputSpace"
  * because this is the namespace of the Query which is a layer of an output and
@@ -48,21 +52,29 @@ export declare abstract class QueryOperationSpace extends RefinedSpace implement
     accessProtectionLevel(): model.AccessModifierLabel;
     inputSpace(): QueryInputSpace;
     outputSpace(): QueryOperationSpace;
+    isQueryOutputSpace(): boolean;
     protected addWild(wild: WildcardFieldReference): void;
     protected addValidatedCompositeFieldUserFromEntry(name: string, entry: SpaceEntry): void;
     addFieldUserFromFilter(filter: model.FilterCondition): void;
     newEntry(name: string, logTo: MalloyElement, entry: SpaceEntry): void;
+    isQueryFieldSpace(): this is QueryFieldSpace;
 }
 export declare abstract class QuerySpace extends QueryOperationSpace {
     addRefineFromFields(refineThis: model.PipeSegment): void;
     pushFields(...defs: MalloyElement[]): void;
     canContain(_typeDescResult: model.TypeDesc | undefined): boolean;
     protected queryFieldDefs(): model.QueryFieldDef[];
+    protected getOutputFieldDef(queryFieldDef: model.QueryFieldDef, typeDesc: model.TypeDesc): model.FieldDef;
+    protected getPrimaryKey(fields: TranslatedQueryField[]): string | undefined;
+    structDef(): model.SourceDef;
+    translatedQueryFields: TranslatedQueryField[] | undefined;
+    protected translateQueryFields(): TranslatedQueryField[];
     getQuerySegment(rf: model.QuerySegment | undefined): model.QuerySegment;
+    protected isRepeated(): boolean;
     getPipeSegment(refineFrom: model.QuerySegment | undefined): model.PipeSegment;
     lookup(path: FieldName[]): LookupResult;
-    isQueryFieldSpace(): this is QueryFieldSpace;
 }
 export declare class ReduceFieldSpace extends QuerySpace {
     readonly segmentType = "reduce";
 }
+export {};

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

@@ -62,10 +62,12 @@ const field_space_1 = require("../types/field-space");
 const space_field_1 = require("../types/space-field");
 const field_references_1 = require("../query-items/field-references");
 const refined_space_1 = require("./refined-space");
-const column_space_field_1 = require("./column-space-field");
 const static_space_1 = require("./static-space");
 const query_input_space_1 = require("./query-input-space");
 const composite_source_utils_1 = require("../../../model/composite_source_utils");
+const error_factory_1 = require("../error-factory");
+const reference_field_1 = require("./reference-field");
+const refine_from_space_field_1 = require("./refine-from-space-field");
 /**
  * The output space of a query operation. It is not named "QueryOutputSpace"
  * because this is the namespace of the Query which is a layer of an output and
@@ -110,6 +112,9 @@ class QueryOperationSpace extends refined_space_1.RefinedSpace {
     outputSpace() {
         return this;
     }
+    isQueryOutputSpace() {
+        return true;
+    }
     addWild(wild) {
         var _a;
         let current = this.exprSpace;
@@ -187,6 +192,9 @@ class QueryOperationSpace extends refined_space_1.RefinedSpace {
         }
         super.newEntry(name, logTo, entry);
     }
+    isQueryFieldSpace() {
+        return true;
+    }
 }
 exports.QueryOperationSpace = QueryOperationSpace;
 // Project and Reduce or "QuerySegments" are built from a QuerySpace
@@ -204,17 +212,15 @@ class QuerySpace extends QueryOperationSpace {
         }
         for (const field of refineThis.queryFields) {
             if (field.type === 'fieldref') {
-                const refTo = this.exprSpace.lookup(field.path.map(f => new field_space_1.FieldName(f)));
-                if (refTo.found) {
-                    const name = field.path[field.path.length - 1];
-                    this.setEntry(name, refTo.found);
-                    this.addValidatedCompositeFieldUserFromEntry(name, refTo.found);
-                }
+                const fieldReference = new field_references_1.RefineFromFieldReference(field.path.map(f => new field_space_1.FieldName(f)));
+                this.astEl.has({ fieldReference });
+                const referenceField = new reference_field_1.ReferenceField(fieldReference, this.exprSpace);
+                const name = field.path[field.path.length - 1];
+                this.setEntry(name, referenceField);
+                this.addValidatedCompositeFieldUserFromEntry(name, referenceField);
             }
-            else if (field.type !== 'turtle') {
-                // TODO can you reference fields in a turtle as fields in the output space,
-                // e.g. order_by: my_turtle.foo, or lag(my_turtle.foo)
-                const entry = new column_space_field_1.ColumnSpaceField(field);
+            else {
+                const entry = new refine_from_space_field_1.RefineFromSpaceField(field);
                 const name = (_a = field.as) !== null && _a !== void 0 ? _a : field.name;
                 this.setEntry(name, entry);
                 this.addValidatedCompositeFieldUserFromEntry(name, entry);
@@ -235,7 +241,91 @@ class QuerySpace extends QueryOperationSpace {
         return true;
     }
     queryFieldDefs() {
+        const fields = this.translateQueryFields();
+        return fields.map(f => f.queryFieldDef);
+    }
+    getOutputFieldDef(queryFieldDef, typeDesc) {
+        var _a, _b;
+        const name = queryFieldDef.type === 'fieldref'
+            ? queryFieldDef.path[queryFieldDef.path.length - 1]
+            : (_a = queryFieldDef.as) !== null && _a !== void 0 ? _a : queryFieldDef.name;
+        if (typeDesc.type === 'turtle') {
+            const pipeline = typeDesc.pipeline;
+            const lastSegment = pipeline[pipeline.length - 1];
+            const outputStruct = (_b = lastSegment === null || lastSegment === void 0 ? void 0 : lastSegment.outputStruct) !== null && _b !== void 0 ? _b : error_factory_1.ErrorFactory.structDef;
+            const isRepeated = lastSegment
+                ? model.isQuerySegment(lastSegment)
+                    ? lastSegment.isRepeated
+                    : true
+                : true;
+            if (isRepeated) {
+                return {
+                    ...outputStruct,
+                    elementTypeDef: { type: 'record_element' },
+                    name: name,
+                    type: 'array',
+                    join: 'many',
+                    as: undefined,
+                };
+            }
+            else {
+                return {
+                    ...outputStruct,
+                    name: name,
+                    type: 'record',
+                    join: 'one',
+                    as: undefined,
+                };
+            }
+        }
+        else if (model.TD.isAtomic(typeDesc)) {
+            const td = model.mkFieldDef(typeDesc, name);
+            return {
+                ...td,
+                expressionType: 'scalar',
+                e: undefined,
+            };
+        }
+        else {
+            throw new Error('Invalid type for fieldref');
+        }
+    }
+    // Gets the primary key field for the output struct of this query;
+    // If there is exactly one scalar field, that is the primary key
+    getPrimaryKey(fields) {
+        var _a;
+        const dimensions = fields.filter(f => model.TD.isAtomic(f.typeDesc) &&
+            model.expressionIsScalar(f.typeDesc.expressionType));
+        if (dimensions.length !== 1)
+            return undefined;
+        const primaryKeyField = dimensions[0].queryFieldDef;
+        if (primaryKeyField.type === 'fieldref') {
+            return primaryKeyField.path[primaryKeyField.path.length - 1];
+        }
+        else {
+            return (_a = primaryKeyField.as) !== null && _a !== void 0 ? _a : primaryKeyField.name;
+        }
+    }
+    // This returns the OUTPUT struct of this query space
+    structDef() {
+        const fields = this.translateQueryFields();
+        const sourceDef = {
+            type: 'query_result',
+            // TODO to match the compiler, does this need to be the name of the query?
+            name: 'query_result',
+            dialect: this.dialectName(),
+            // TODO need to get this in a less expensive way?
+            connection: this.inputSpace().connectionName(),
+            fields: fields.map(f => this.getOutputFieldDef(f.queryFieldDef, f.typeDesc)),
+            primaryKey: this.getPrimaryKey(fields),
+        };
+        return sourceDef;
+    }
+    translateQueryFields() {
         var _a;
+        if (this.translatedQueryFields) {
+            return this.translatedQueryFields;
+        }
         const fields = [];
         let fieldUsage = (0, composite_source_utils_1.emptyFieldUsage)();
         for (const user of this.compositeFieldUsers) {
@@ -249,12 +339,20 @@ class QuerySpace extends QueryOperationSpace {
                 const { name, field } = user;
                 const wildPath = this.expandedWild[name];
                 if (wildPath) {
-                    fields.push({ type: 'fieldref', path: wildPath.path, at: wildPath.at });
-                    nextFieldUsage = wildPath.entry.typeDesc().fieldUsage;
+                    const typeDesc = wildPath.entry.typeDesc();
+                    fields.push({
+                        queryFieldDef: {
+                            type: 'fieldref',
+                            path: wildPath.path,
+                            at: wildPath.at,
+                        },
+                        typeDesc,
+                    });
+                    nextFieldUsage = typeDesc.fieldUsage;
                 }
                 else {
-                    const fieldQueryDef = field.getQueryFieldDef(this.exprSpace);
-                    if (fieldQueryDef) {
+                    const queryFieldDef = field.getQueryFieldDef(this.exprSpace);
+                    if (queryFieldDef) {
                         const typeDesc = field.typeDesc();
                         nextFieldUsage = typeDesc.fieldUsage;
                         // Filter out fields whose type is 'error', which means that a totally bad field
@@ -264,17 +362,13 @@ class QuerySpace extends QueryOperationSpace {
                         if (typeDesc &&
                             typeDesc.type !== 'error' &&
                             this.canContain(typeDesc) &&
-                            !isEmptyNest(fieldQueryDef)) {
-                            fields.push(fieldQueryDef);
+                            !isEmptyNest(queryFieldDef)) {
+                            fields.push({ queryFieldDef, typeDesc });
                         }
                     }
-                    // TODO I removed the error here because during calculation of the refinement space,
-                    // (see creation of a QuerySpace) we add references to all the fields from
-                    // the refinement, but they don't have definitions. So in the case where we
-                    // don't have a field def, we "know" that that field is already in the query,
-                    // and we don't need to worry about actually adding it. Previously, this was also true for
-                    // project statements, where we added "*" as a field and also all the individual
-                    // fields, but the individual fields didn't have field defs.
+                    else {
+                        throw new Error('Expected query field to have a definition');
+                    }
                 }
             }
             fieldUsage = (_a = (0, composite_source_utils_1.mergeFieldUsage)(fieldUsage, nextFieldUsage)) !== null && _a !== void 0 ? _a : [];
@@ -285,6 +379,7 @@ class QuerySpace extends QueryOperationSpace {
                 drillDimension.firstDrill.logError('illegal-drill', `Must provide a value for all dimensions in a view when drilling: missing \`${drillDimension.dimensionPath.join('.')}\``);
             }
         }
+        this.translatedQueryFields = fields;
         return fields;
     }
     getQuerySegment(rf) {
@@ -294,17 +389,24 @@ class QuerySpace extends QueryOperationSpace {
         }
         throw new Error('TODO NOT POSSIBLE');
     }
+    isRepeated() {
+        const fields = this.translateQueryFields();
+        const dimensions = fields.filter(f => model.TD.isAtomic(f.typeDesc) &&
+            model.expressionIsScalar(f.typeDesc.expressionType));
+        return dimensions.length > 0;
+    }
     getPipeSegment(refineFrom) {
         if (this.segmentType === 'index') {
             // come coding error made this "impossible" thing happen
             this.logError('unexpected-index-segment', 'internal error generating index segment from non index query');
-            return { type: 'reduce', queryFields: [] };
+            return error_factory_1.ErrorFactory.reduceSegment;
         }
         const segment = {
             type: this.segmentType,
             queryFields: this.queryFieldDefs(),
+            outputStruct: this.structDef(),
+            isRepeated: this.isRepeated(),
         };
-        segment.queryFields = (0, field_utils_1.mergeFields)(refineFrom === null || refineFrom === void 0 ? void 0 : refineFrom.queryFields, segment.queryFields);
         if (refineFrom === null || refineFrom === void 0 ? void 0 : refineFrom.extendSource) {
             segment.extendSource = refineFrom.extendSource;
         }
@@ -331,9 +433,6 @@ class QuerySpace extends QueryOperationSpace {
         }
         return this.exprSpace.lookup(path);
     }
-    isQueryFieldSpace() {
-        return true;
-    }
 }
 exports.QuerySpace = QuerySpace;
 class ReduceFieldSpace extends QuerySpace {

package/dist/lang/ast/field-space/refine-from-space-field.d.ts

@@ -0,0 +1,9 @@
+import type { TypeDesc, AtomicFieldDef, QueryFieldDef, TurtleDef } from '../../../model/malloy_types';
+import type { FieldSpace } from '../types/field-space';
+import { SpaceField } from '../types/space-field';
+export declare class RefineFromSpaceField extends SpaceField {
+    private readonly refineFromFieldDef;
+    constructor(refineFromFieldDef: AtomicFieldDef | TurtleDef);
+    getQueryFieldDef(_fs: FieldSpace): QueryFieldDef | undefined;
+    typeDesc(): TypeDesc;
+}

package/dist/lang/ast/field-space/refine-from-space-field.js

@@ -0,0 +1,24 @@
+"use strict";
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RefineFromSpaceField = void 0;
+const space_field_1 = require("../types/space-field");
+class RefineFromSpaceField extends space_field_1.SpaceField {
+    constructor(refineFromFieldDef) {
+        super();
+        this.refineFromFieldDef = refineFromFieldDef;
+    }
+    getQueryFieldDef(_fs) {
+        return this.refineFromFieldDef;
+    }
+    typeDesc() {
+        return this.typeFromFieldDef(this.refineFromFieldDef);
+    }
+}
+exports.RefineFromSpaceField = RefineFromSpaceField;
+//# sourceMappingURL=refine-from-space-field.js.map