@malloydata/malloy 0.0.270 → 0.0.271-experiment-250430155127

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

@@ -23,7 +23,6 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.errorFor = void 0;
-const composite_source_utils_1 = require("../../model/composite_source_utils");
 /**
  * When a translation hits an error, log and return one of these as a value.
  * This will allow the rest of the translation walk to complete. The
@@ -38,7 +37,7 @@ function errorFor(reason) {
         expressionType: 'scalar',
         value: { node: 'error', message: reason },
         evalSpace: 'constant',
-        compositeFieldUsage: (0, composite_source_utils_1.emptyCompositeFieldUsage)(),
+        fieldUsage: [],
     };
 }
 exports.errorFor = errorFor;

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

@@ -55,6 +55,7 @@ const field_references_1 = require("../query-items/field-references");
 const expression_def_1 = require("../types/expression-def");
 const space_field_1 = require("../types/space-field");
 const expr_id_reference_1 = require("./expr-id-reference");
+const composite_source_utils_1 = require("../../../model/composite_source_utils");
 class ExprAggregateFunction extends expression_def_1.ExpressionDef {
     constructor(func, expr, explicitSource) {
         super();
@@ -84,15 +85,24 @@ class ExprAggregateFunction extends expression_def_1.ExpressionDef {
                 const footType = sourceFoot.typeDesc();
                 if (!(sourceFoot instanceof static_space_1.StructSpaceField)) {
                     if ((0, malloy_types_1.isAtomicFieldType)(footType.type)) {
+                        const footPath = this.source.list.map(x => x.refString);
                         expr = this.source;
                         exprVal = {
                             ...TDU.atomicDef(footType),
                             expressionType: footType.expressionType,
                             value: footType.evalSpace === 'output'
                                 ? { node: 'outputField', name: this.source.refString }
-                                : { node: 'field', path: this.source.path },
+                                : {
+                                    node: 'field',
+                                    path: this.source.path,
+                                    at: this.source.location,
+                                },
                             evalSpace: footType.evalSpace,
-                            compositeFieldUsage: footType.compositeFieldUsage,
+                            // TODO ensure that when there's an `expr` but no `source`, that `fieldUsage`
+                            // still comes along correctly
+                            fieldUsage: (0, composite_source_utils_1.mergeFieldUsage)(footType.fieldUsage, [
+                                { path: footPath, at: this.source.location },
+                            ]),
                         };
                         structPath = this.source.path.slice(0, -1);
                         // Here we handle a special case where you write `foo.agg()` and `foo` is a
@@ -157,6 +167,7 @@ class ExprAggregateFunction extends expression_def_1.ExpressionDef {
                 node: 'aggregate',
                 function: this.func,
                 e: exprVal.value,
+                at: this.location,
             };
             if (structPath && structPath.length > 0) {
                 f.structPath = structPath;
@@ -178,7 +189,11 @@ class ExprAggregateFunction extends expression_def_1.ExpressionDef {
         if (this.source) {
             const lookup = this.source.getField(fs);
             if (lookup.found) {
-                const sfd = { node: 'field', path: this.source.path };
+                const sfd = {
+                    node: 'field',
+                    path: this.source.path,
+                    at: this.source.location,
+                };
                 result.push(...getJoinUsage(fs, sfd));
             }
         }

package/dist/lang/ast/expressions/expr-count-distinct.js

@@ -60,7 +60,7 @@ class ExprCountDistinct extends expr_aggregate_function_1.ExprAggregateFunction
             evalSpace: ev.evalSpace,
             expressionType: 'aggregate',
             value: ev.value,
-            compositeFieldUsage: ev.compositeFieldUsage,
+            fieldUsage: ev.fieldUsage,
         };
     }
 }

package/dist/lang/ast/expressions/expr-count.js

@@ -23,7 +23,6 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExprCount = void 0;
-const composite_source_utils_1 = require("../../../model/composite_source_utils");
 const expr_aggregate_function_1 = require("./expr-aggregate-function");
 class ExprCount extends expr_aggregate_function_1.ExprAggregateFunction {
     constructor(source) {
@@ -45,7 +44,7 @@ class ExprCount extends expr_aggregate_function_1.ExprAggregateFunction {
             evalSpace: ev.evalSpace,
             expressionType: 'aggregate',
             value: ev.value,
-            compositeFieldUsage: ev.compositeFieldUsage,
+            fieldUsage: ev.fieldUsage,
         };
     }
     getExpression(_fs) {
@@ -53,6 +52,7 @@ class ExprCount extends expr_aggregate_function_1.ExprAggregateFunction {
             node: 'aggregate',
             function: 'count',
             e: { node: '' },
+            at: this.location,
         };
         if (this.source) {
             ret.structPath = this.source.path;
@@ -63,7 +63,7 @@ class ExprCount extends expr_aggregate_function_1.ExprAggregateFunction {
             expressionType: 'aggregate',
             value: ret,
             evalSpace: 'output',
-            compositeFieldUsage: (0, composite_source_utils_1.emptyCompositeFieldUsage)(),
+            fieldUsage: [],
         };
     }
 }

package/dist/lang/ast/expressions/expr-filter-expr.js

@@ -20,7 +20,7 @@ class ExprFilterExpression extends expression_def_1.ExpressionDef {
             value: { node: 'filterLiteral', filterSrc: this.filterText },
             expressionType: 'scalar',
             evalSpace: 'constant',
-            compositeFieldUsage: { fields: [], joinedUsage: {} },
+            fieldUsage: [],
         };
     }
 }

package/dist/lang/ast/expressions/expr-func.js

@@ -140,9 +140,13 @@ class ExprFunc extends expression_def_1.ExpressionDef {
                     implicitExpr = {
                         ...TDU.atomicDef(footType),
                         expressionType: footType.expressionType,
-                        value: { node: 'field', path: this.source.path },
+                        value: {
+                            node: 'field',
+                            path: this.source.path,
+                            at: this.source.location,
+                        },
                         evalSpace: footType.evalSpace,
-                        compositeFieldUsage: footType.compositeFieldUsage,
+                        fieldUsage: footType.fieldUsage,
                     };
                     structPath = this.source.path.slice(0, -1);
                 }
@@ -316,7 +320,11 @@ class ExprFunc extends expression_def_1.ExpressionDef {
                             expr.push({ node: 'parameter', path: [part.name] });
                         }
                         else {
-                            expr.push({ node: 'field', path: [part.name] });
+                            expr.push({
+                                node: 'field',
+                                path: [part.name],
+                                at: this.args[0].location,
+                            });
                         }
                     }
                 }
@@ -342,7 +350,7 @@ class ExprFunc extends expression_def_1.ExpressionDef {
             expressionType,
             value: funcCall,
             evalSpace,
-            compositeFieldUsage: (0, composite_source_utils_1.mergeCompositeFieldUsage)(...argExprs.map(e => e.compositeFieldUsage)),
+            fieldUsage: (0, composite_source_utils_1.mergeFieldUsage)(...argExprs.map(e => e.fieldUsage)),
         };
     }
 }

package/dist/lang/ast/expressions/expr-id-reference.js

@@ -25,7 +25,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExprIdReference = void 0;
 const malloy_types_1 = require("../../../model/malloy_types");
 const expression_def_1 = require("../types/expression-def");
-const composite_source_utils_1 = require("../../../model/composite_source_utils");
 class ExprIdReference extends expression_def_1.ExpressionDef {
     constructor(fieldReference) {
         super();
@@ -38,30 +37,44 @@ class ExprIdReference extends expression_def_1.ExpressionDef {
     }
     getExpression(fs) {
         const def = this.fieldReference.getField(fs);
-        // TODO Currently the join usage is always equivalent to the reference path here;
-        // if/when we add namespaces, this will not be the case, and we will need to get the
-        // join path from `getField` / `lookup`
-        const compositeJoinUsage = this.fieldReference.list
-            .map(n => n.name)
-            .slice(0, -1);
         if (def.found) {
+            // TODO Currently the join usage is always equivalent to the reference path here;
+            // if/when we add namespaces, this will not be the case, and we will need to get the
+            // join path from `getField` / `lookup`
+            const fieldUsage = def.found.refType === 'field'
+                ? [
+                    {
+                        path: this.fieldReference.list.map(n => n.name),
+                        at: this.fieldReference.location,
+                    },
+                ]
+                : [];
             const td = def.found.typeDesc();
-            const compositeFieldUsage = (0, composite_source_utils_1.joinedCompositeFieldUsage)(compositeJoinUsage, td.compositeFieldUsage);
             if (def.isOutputField) {
                 return {
                     ...td,
                     // TODO what about literal??
                     evalSpace: td.evalSpace === 'constant' ? 'constant' : 'output',
                     value: { node: 'outputField', name: this.refString },
-                    compositeFieldUsage,
+                    fieldUsage,
                 };
             }
-            const value = { node: def.found.refType, path: this.fieldReference.path };
+            const value = {
+                node: def.found.refType,
+                path: this.fieldReference.path,
+                at: this.fieldReference.location,
+            };
             // We think that aggregates are more 'output' like, but maybe we will reconsider that...
             const evalSpace = (0, malloy_types_1.expressionIsAggregate)(td.expressionType)
                 ? 'output'
                 : td.evalSpace;
-            return { ...td, value, evalSpace, compositeFieldUsage };
+            return {
+                ...td,
+                value,
+                evalSpace,
+                fieldUsage,
+                requiresGroupBy: undefined,
+            };
         }
         return this.loggedErrorExpr(def.error.code, def.error.message);
     }

package/dist/lang/ast/expressions/expr-now.js

@@ -24,7 +24,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExprNow = void 0;
 const expression_def_1 = require("../types/expression-def");
-const composite_source_utils_1 = require("../../../model/composite_source_utils");
 class ExprNow extends expression_def_1.ExpressionDef {
     constructor() {
         super(...arguments);
@@ -37,7 +36,7 @@ class ExprNow extends expression_def_1.ExpressionDef {
             // `now` is considered to be a constant, at least in the dialects we support today
             evalSpace: 'constant',
             value: { node: 'now', typeDef: { type: 'timestamp' } },
-            compositeFieldUsage: (0, composite_source_utils_1.emptyCompositeFieldUsage)(),
+            fieldUsage: [],
         };
     }
 }

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

@@ -1,7 +1,8 @@
-import type { ExprValue } from '../types/expr-value';
+import { type ExprValue } from '../types/expr-value';
 import { ExpressionDef } from '../types/expression-def';
 import type { FieldPropStatement } from '../types/field-prop-statement';
 import type { FieldSpace } from '../types/field-space';
+import { GroupedBy } from './grouped_by';
 export declare class ExprProps extends ExpressionDef {
     readonly expr: ExpressionDef;
     readonly statements: FieldPropStatement[];
@@ -10,4 +11,171 @@ export declare class ExprProps extends ExpressionDef {
     constructor(expr: ExpressionDef, statements: FieldPropStatement[]);
     private getFilteredExpression;
     getExpression(fs: FieldSpace): ExprValue;
+    getGroupedBys(fs: FieldSpace, expr: ExprValue, groupedBys: GroupedBy[]): {
+        requiresGroupBy: import("../../../model/malloy_types").RequiredGroupBy[] | undefined;
+        type: "string";
+        bucketFilter?: string | undefined;
+        bucketOther?: string | undefined;
+        expressionType: import("../../../model/malloy_types").ExpressionType;
+        evalSpace: import("../../../model/malloy_types").EvalSpace;
+        fieldUsage: import("../../../model/malloy_types").FieldUsage[];
+        ungroupings?: import("../../../model/malloy_types").AggregateUngrouping[] | undefined;
+        value: import("../../../model/malloy_types").Expr;
+        morphic?: {
+            [x: string]: import("../../../model/malloy_types").Expr;
+        } | undefined;
+    } | {
+        requiresGroupBy: import("../../../model/malloy_types").RequiredGroupBy[] | undefined;
+        type: "date";
+        timeframe?: import("../../../model/malloy_types").DateUnit | undefined;
+        expressionType: import("../../../model/malloy_types").ExpressionType;
+        evalSpace: import("../../../model/malloy_types").EvalSpace;
+        fieldUsage: import("../../../model/malloy_types").FieldUsage[];
+        ungroupings?: import("../../../model/malloy_types").AggregateUngrouping[] | undefined;
+        value: import("../../../model/malloy_types").Expr;
+        morphic?: {
+            [x: string]: import("../../../model/malloy_types").Expr;
+        } | undefined;
+    } | {
+        requiresGroupBy: import("../../../model/malloy_types").RequiredGroupBy[] | undefined;
+        type: "timestamp";
+        timeframe?: import("../../../model/malloy_types").TimestampUnit | undefined;
+        expressionType: import("../../../model/malloy_types").ExpressionType;
+        evalSpace: import("../../../model/malloy_types").EvalSpace;
+        fieldUsage: import("../../../model/malloy_types").FieldUsage[];
+        ungroupings?: import("../../../model/malloy_types").AggregateUngrouping[] | undefined;
+        value: import("../../../model/malloy_types").Expr;
+        morphic?: {
+            [x: string]: import("../../../model/malloy_types").Expr;
+        } | undefined;
+    } | {
+        requiresGroupBy: import("../../../model/malloy_types").RequiredGroupBy[] | undefined;
+        type: "number";
+        numberType?: "integer" | "float" | undefined;
+        expressionType: import("../../../model/malloy_types").ExpressionType;
+        evalSpace: import("../../../model/malloy_types").EvalSpace;
+        fieldUsage: import("../../../model/malloy_types").FieldUsage[];
+        ungroupings?: import("../../../model/malloy_types").AggregateUngrouping[] | undefined;
+        value: import("../../../model/malloy_types").Expr;
+        morphic?: {
+            [x: string]: import("../../../model/malloy_types").Expr;
+        } | undefined;
+    } | {
+        requiresGroupBy: import("../../../model/malloy_types").RequiredGroupBy[] | undefined;
+        type: "boolean";
+        expressionType: import("../../../model/malloy_types").ExpressionType;
+        evalSpace: import("../../../model/malloy_types").EvalSpace;
+        fieldUsage: import("../../../model/malloy_types").FieldUsage[];
+        ungroupings?: import("../../../model/malloy_types").AggregateUngrouping[] | undefined;
+        value: import("../../../model/malloy_types").Expr;
+        morphic?: {
+            [x: string]: import("../../../model/malloy_types").Expr;
+        } | undefined;
+    } | {
+        requiresGroupBy: import("../../../model/malloy_types").RequiredGroupBy[] | undefined;
+        type: "json";
+        expressionType: import("../../../model/malloy_types").ExpressionType;
+        evalSpace: import("../../../model/malloy_types").EvalSpace;
+        fieldUsage: import("../../../model/malloy_types").FieldUsage[];
+        ungroupings?: import("../../../model/malloy_types").AggregateUngrouping[] | undefined;
+        value: import("../../../model/malloy_types").Expr;
+        morphic?: {
+            [x: string]: import("../../../model/malloy_types").Expr;
+        } | undefined;
+    } | {
+        requiresGroupBy: import("../../../model/malloy_types").RequiredGroupBy[] | undefined;
+        type: "sql native";
+        rawType?: string | undefined;
+        expressionType: import("../../../model/malloy_types").ExpressionType;
+        evalSpace: import("../../../model/malloy_types").EvalSpace;
+        fieldUsage: import("../../../model/malloy_types").FieldUsage[];
+        ungroupings?: import("../../../model/malloy_types").AggregateUngrouping[] | undefined;
+        value: import("../../../model/malloy_types").Expr;
+        morphic?: {
+            [x: string]: import("../../../model/malloy_types").Expr;
+        } | undefined;
+    } | {
+        requiresGroupBy: import("../../../model/malloy_types").RequiredGroupBy[] | undefined;
+        type: "error";
+        expressionType: import("../../../model/malloy_types").ExpressionType;
+        evalSpace: import("../../../model/malloy_types").EvalSpace;
+        fieldUsage: import("../../../model/malloy_types").FieldUsage[];
+        ungroupings?: import("../../../model/malloy_types").AggregateUngrouping[] | undefined;
+        value: import("../../../model/malloy_types").Expr;
+        morphic?: {
+            [x: string]: import("../../../model/malloy_types").Expr;
+        } | undefined;
+    } | {
+        requiresGroupBy: import("../../../model/malloy_types").RequiredGroupBy[] | undefined;
+        type: "array";
+        elementTypeDef: import("../../../model/malloy_types").BasicAtomicTypeDef | import("../../../model/malloy_types").BasicArrayTypeDef | import("../../../model/malloy_types").RepeatedRecordTypeDef;
+        expressionType: import("../../../model/malloy_types").ExpressionType;
+        evalSpace: import("../../../model/malloy_types").EvalSpace;
+        fieldUsage: import("../../../model/malloy_types").FieldUsage[];
+        ungroupings?: import("../../../model/malloy_types").AggregateUngrouping[] | undefined;
+        value: import("../../../model/malloy_types").Expr;
+        morphic?: {
+            [x: string]: import("../../../model/malloy_types").Expr;
+        } | undefined;
+    } | {
+        requiresGroupBy: import("../../../model/malloy_types").RequiredGroupBy[] | undefined;
+        type: "record";
+        fields: import("../../../model/malloy_types").FieldDef[];
+        expressionType: import("../../../model/malloy_types").ExpressionType;
+        evalSpace: import("../../../model/malloy_types").EvalSpace;
+        fieldUsage: import("../../../model/malloy_types").FieldUsage[];
+        ungroupings?: import("../../../model/malloy_types").AggregateUngrouping[] | undefined;
+        value: import("../../../model/malloy_types").Expr;
+        morphic?: {
+            [x: string]: import("../../../model/malloy_types").Expr;
+        } | undefined;
+    } | {
+        requiresGroupBy: import("../../../model/malloy_types").RequiredGroupBy[] | undefined;
+        type: "array";
+        elementTypeDef: import("../../../model/malloy_types").RecordElementTypeDef;
+        fields: import("../../../model/malloy_types").FieldDef[];
+        expressionType: import("../../../model/malloy_types").ExpressionType;
+        evalSpace: import("../../../model/malloy_types").EvalSpace;
+        fieldUsage: import("../../../model/malloy_types").FieldUsage[];
+        ungroupings?: import("../../../model/malloy_types").AggregateUngrouping[] | undefined;
+        value: import("../../../model/malloy_types").Expr;
+        morphic?: {
+            [x: string]: import("../../../model/malloy_types").Expr;
+        } | undefined;
+    } | {
+        requiresGroupBy: import("../../../model/malloy_types").RequiredGroupBy[] | undefined;
+        type: import("../../../model/malloy_types").NonAtomicType;
+        expressionType: import("../../../model/malloy_types").ExpressionType;
+        evalSpace: import("../../../model/malloy_types").EvalSpace;
+        fieldUsage: import("../../../model/malloy_types").FieldUsage[];
+        ungroupings?: import("../../../model/malloy_types").AggregateUngrouping[] | undefined;
+        value: import("../../../model/malloy_types").Expr;
+        morphic?: {
+            [x: string]: import("../../../model/malloy_types").Expr;
+        } | undefined;
+    } | {
+        requiresGroupBy: import("../../../model/malloy_types").RequiredGroupBy[] | undefined;
+        type: "date";
+        timeframe?: "day" | "week" | "month" | "quarter" | "year" | undefined;
+        expressionType: import("../../../model/malloy_types").ExpressionType;
+        evalSpace: import("../../../model/malloy_types").EvalSpace;
+        fieldUsage: import("../../../model/malloy_types").FieldUsage[];
+        ungroupings?: import("../../../model/malloy_types").AggregateUngrouping[] | undefined;
+        value: import("../../../model/malloy_types").Expr;
+        morphic?: {
+            [x: string]: import("../../../model/malloy_types").Expr;
+        } | undefined;
+    } | {
+        requiresGroupBy: import("../../../model/malloy_types").RequiredGroupBy[] | undefined;
+        type: "timestamp";
+        timeframe?: import("../../../model/malloy_types").TimestampUnit | undefined;
+        expressionType: import("../../../model/malloy_types").ExpressionType;
+        evalSpace: import("../../../model/malloy_types").EvalSpace;
+        fieldUsage: import("../../../model/malloy_types").FieldUsage[];
+        ungroupings?: import("../../../model/malloy_types").AggregateUngrouping[] | undefined;
+        value: import("../../../model/malloy_types").Expr;
+        morphic?: {
+            [x: string]: import("../../../model/malloy_types").Expr;
+        } | undefined;
+    };
 }

package/dist/lang/ast/expressions/expr-props.js

@@ -52,9 +52,11 @@ const TDU = __importStar(require("../typedesc-utils"));
 const function_ordering_1 = require("./function-ordering");
 const limit_1 = require("../query-properties/limit");
 const partition_by_1 = require("./partition_by");
+const expr_value_1 = require("../types/expr-value");
 const expression_def_1 = require("../types/expression-def");
 const expr_func_1 = require("./expr-func");
 const composite_source_utils_1 = require("../../../model/composite_source_utils");
+const grouped_by_1 = require("./grouped_by");
 class ExprProps extends expression_def_1.ExpressionDef {
     constructor(expr, statements) {
         super({ expr, statements });
@@ -81,7 +83,7 @@ class ExprProps extends expression_def_1.ExpressionDef {
             if (this.typeCheck(this.expr, { ...expr, expressionType: 'scalar' })) {
                 return {
                     ...expr,
-                    compositeFieldUsage: (0, composite_source_utils_1.mergeCompositeFieldUsage)(expr.compositeFieldUsage, ...filterList.map(f => f.compositeFieldUsage)),
+                    fieldUsage: (0, composite_source_utils_1.mergeFieldUsage)(expr.fieldUsage, ...filterList.map(f => { var _a; return (_a = f.fieldUsage) !== null && _a !== void 0 ? _a : []; })),
                     value: {
                         node: 'filteredExpr',
                         kids: { e: expr.value, filterList },
@@ -98,6 +100,7 @@ class ExprProps extends expression_def_1.ExpressionDef {
         let limit;
         const orderBys = [];
         const wheres = [];
+        const groupedBys = [];
         for (const statement of this.statements) {
             if (statement instanceof partition_by_1.PartitionBy) {
                 if (!this.expr.canSupportPartitionBy()) {
@@ -126,6 +129,9 @@ class ExprProps extends expression_def_1.ExpressionDef {
                     orderBys.push(statement);
                 }
             }
+            else if (statement instanceof grouped_by_1.GroupedBy) {
+                groupedBys.push(statement);
+            }
             else {
                 wheres.push(statement);
             }
@@ -137,7 +143,34 @@ class ExprProps extends expression_def_1.ExpressionDef {
                 orderBys,
             })
             : this.expr.getExpression(fs);
-        return this.getFilteredExpression(fs, resultExpr, wheres);
+        const filteredExpr = this.getFilteredExpression(fs, resultExpr, wheres);
+        return this.getGroupedBys(fs, filteredExpr, groupedBys);
+    }
+    getGroupedBys(fs, expr, groupedBys) {
+        const groupedByFields = [];
+        for (const requiredGroupBy of groupedBys) {
+            for (const field of requiredGroupBy.groupedByFields) {
+                const e = field.getField(fs);
+                if (e.found === undefined) {
+                    field.logError('grouped-by-not-found', `${field.refString} is not defined`);
+                }
+                else if ((0, malloy_types_1.expressionIsAnalytic)(e.found.typeDesc().expressionType) ||
+                    (0, malloy_types_1.expressionIsAggregate)(e.found.typeDesc().expressionType)) {
+                    field.logError('non-scalar-grouped-by', '`grouped_by:` field must be a dimension');
+                }
+                else {
+                    groupedByFields.push(field.nameString);
+                }
+            }
+        }
+        const allRequiredGroupBys = (0, expr_value_1.mergeGroupedBys)(expr.requiresGroupBy, groupedByFields.map(name => ({
+            path: [name],
+            at: this.location,
+        })));
+        return {
+            ...expr,
+            requiresGroupBy: allRequiredGroupBys,
+        };
     }
 }
 exports.ExprProps = ExprProps;

package/dist/lang/ast/expressions/expr-ungroup.js

@@ -48,6 +48,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExprUngroup = void 0;
 const malloy_types_1 = require("../../../model/malloy_types");
 const query_spaces_1 = require("../field-space/query-spaces");
+const reference_field_1 = require("../field-space/reference-field");
 const TDU = __importStar(require("../typedesc-utils"));
 const expression_def_1 = require("../types/expression-def");
 class ExprUngroup extends expression_def_1.ExpressionDef {
@@ -60,6 +61,7 @@ class ExprUngroup extends expression_def_1.ExpressionDef {
         this.elementType = 'ungroup';
     }
     getExpression(fs) {
+        var _a, _b;
         const exprVal = this.expr.getExpression(fs);
         if (!(0, malloy_types_1.expressionIsAggregate)(exprVal.expressionType)) {
             return this.expr.loggedErrorExpr('ungroup-of-non-aggregate', `${this.control}() expression must be an aggregate`);
@@ -71,13 +73,14 @@ class ExprUngroup extends expression_def_1.ExpressionDef {
             node: this.control,
             e: exprVal.value,
         };
+        const ungroupFields = [];
         if (this.typeCheck(this.expr, { ...exprVal, expressionType: 'scalar' })) {
+            const isExclude = this.control === 'exclude';
             // Now every mentioned field must be in the output space of one of the queries
             // of the nest tree leading to this query. If this is a source definition,
             // this is not checked until sql generation time.
             if (fs.isQueryFieldSpace() && this.fields.length > 0) {
                 const dstFields = [];
-                const isExclude = this.control === 'exclude';
                 for (const mentionedField of this.fields) {
                     let ofs = fs.outputSpace();
                     let notFound = true;
@@ -85,6 +88,9 @@ class ExprUngroup extends expression_def_1.ExpressionDef {
                         const entryInfo = ofs.lookup([mentionedField]);
                         if (entryInfo.found && entryInfo.isOutputField) {
                             dstFields.push(mentionedField.refString);
+                            if (entryInfo.found instanceof reference_field_1.ReferenceField) {
+                                ungroupFields.push(entryInfo.found.fieldRef.list.map(n => n.refString));
+                            }
                             notFound = false;
                         }
                         else if (ofs instanceof query_spaces_1.QuerySpace) {
@@ -106,7 +112,14 @@ class ExprUngroup extends expression_def_1.ExpressionDef {
                 expressionType: 'ungrouped_aggregate',
                 value: ungroup,
                 evalSpace: 'output',
-                compositeFieldUsage: exprVal.compositeFieldUsage,
+                fieldUsage: exprVal.fieldUsage,
+                ungroupings: [
+                    {
+                        requiresGroupBy: (_a = exprVal.requiresGroupBy) !== null && _a !== void 0 ? _a : [],
+                        fieldUsage: (_b = exprVal.fieldUsage) !== null && _b !== void 0 ? _b : [],
+                        ungroupedFields: isExclude ? ungroupFields !== null && ungroupFields !== void 0 ? ungroupFields : [] : '*',
+                    },
+                ],
             };
         }
         return this.loggedErrorExpr('ungroup-with-non-scalar', `${this.control}() incompatible type`);

package/dist/lang/ast/expressions/grouped_by.d.ts

@@ -0,0 +1,7 @@
+import type { GroupedByReference } from '../query-items/field-references';
+import { ListOf } from '../types/malloy-element';
+export declare class GroupedBy extends ListOf<GroupedByReference> {
+    readonly groupedByFields: GroupedByReference[];
+    elementType: string;
+    constructor(groupedByFields: GroupedByReference[]);
+}

package/dist/lang/ast/expressions/grouped_by.js

@@ -0,0 +1,19 @@
+"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.GroupedBy = void 0;
+const malloy_element_1 = require("../types/malloy-element");
+class GroupedBy extends malloy_element_1.ListOf {
+    constructor(groupedByFields) {
+        super(groupedByFields);
+        this.groupedByFields = groupedByFields;
+        this.elementType = 'require_group_by';
+    }
+}
+exports.GroupedBy = GroupedBy;
+//# sourceMappingURL=grouped_by.js.map

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

@@ -53,18 +53,17 @@ class IndexFieldSpace extends query_spaces_1.QueryOperationSpace {
             this.logError('refinement-of-index-segment', 'index query operations cannot be refined');
             return { type: 'index', indexFields: [] };
         }
-        let compositeFieldUsage = (0, composite_source_utils_1.emptyCompositeFieldUsage)();
-        let narrowedCompositeFieldResolution = (0, composite_source_utils_1.emptyNarrowedCompositeFieldResolution)();
+        let fieldUsage = (0, composite_source_utils_1.emptyFieldUsage)();
         const indexFields = [];
         const source = this.inputSpace().structDef();
         for (const [name, field] of this.entries()) {
             if (field instanceof space_field_1.SpaceField) {
-                let nextCompositeFieldUsage = undefined;
+                let nextFieldUsage = undefined;
                 let logTo = undefined;
                 const wild = this.expandedWild[name];
                 if (wild) {
-                    indexFields.push({ type: 'fieldref', path: wild.path });
-                    nextCompositeFieldUsage = wild.entry.typeDesc().compositeFieldUsage;
+                    indexFields.push({ type: 'fieldref', path: wild.path, at: wild.at });
+                    nextFieldUsage = wild.entry.typeDesc().fieldUsage;
                 }
                 else if (field instanceof reference_field_1.ReferenceField) {
                     // attempt to cause a type check
@@ -75,18 +74,14 @@ class IndexFieldSpace extends query_spaces_1.QueryOperationSpace {
                     }
                     else {
                         indexFields.push(fieldRef.refToField);
-                        nextCompositeFieldUsage =
-                            check.found.typeDesc().compositeFieldUsage;
+                        nextFieldUsage = check.found.typeDesc().fieldUsage;
                         logTo = fieldRef;
                     }
                 }
-                const next = this.applyNextCompositeFieldUsage(source, compositeFieldUsage, narrowedCompositeFieldResolution, nextCompositeFieldUsage, logTo);
-                compositeFieldUsage = next.compositeFieldUsage;
-                narrowedCompositeFieldResolution =
-                    next.narrowedCompositeFieldResolution;
+                fieldUsage = this.applyNextFieldUsage(source, fieldUsage, nextFieldUsage, logTo);
             }
         }
-        this._compositeFieldUsage = compositeFieldUsage;
+        this._fieldUsage = fieldUsage;
         return { type: 'index', indexFields };
     }
     addRefineFromFields(_refineThis) { }
@@ -142,6 +137,7 @@ class IndexFieldSpace extends query_spaces_1.QueryOperationSpace {
                     this.expandedWild[indexName] = {
                         path: joinPath.concat(name),
                         entry,
+                        at: wild.location,
                     };
                 }
             }