@malloydata/malloy 0.0.303 → 0.0.305

package/dist/dialect/dialect.d.ts

@@ -70,7 +70,7 @@ export declare abstract class Dialect {
     abstract quoteTablePath(tablePath: string): string;
     abstract sqlGroupSetTable(groupSetCount: number): string;
     abstract sqlAnyValue(groupSet: number, fieldName: string): string;
-    abstract sqlAggregateTurtle(groupSet: number, fieldList: DialectFieldList, orderBy: string | undefined, limit: number | undefined): string;
+    abstract sqlAggregateTurtle(groupSet: number, fieldList: DialectFieldList, orderBy: string | undefined): string;
     abstract sqlAnyValueTurtle(groupSet: number, fieldList: DialectFieldList): string;
     abstract sqlAnyValueLastTurtle(name: string, groupSet: number, sqlName: string): string;
     abstract sqlCoaleseMeasuresInline(groupSet: number, fieldList: DialectFieldList): string;

package/dist/dialect/duckdb/duckdb.d.ts

@@ -28,7 +28,7 @@ export declare class DuckDBDialect extends PostgresBase {
     sqlAnyValue(groupSet: number, fieldName: string): string;
     sqlLiteralNumber(literal: string): string;
     mapFields(fieldList: DialectFieldList): string;
-    sqlAggregateTurtle(groupSet: number, fieldList: DialectFieldList, orderBy: string | undefined, limit: number | undefined): string;
+    sqlAggregateTurtle(groupSet: number, fieldList: DialectFieldList, orderBy: string | undefined): string;
     sqlAnyValueTurtle(groupSet: number, fieldList: DialectFieldList): string;
     sqlAnyValueLastTurtle(name: string, groupSet: number, sqlName: string): string;
     sqlCoaleseMeasuresInline(groupSet: number, fieldList: DialectFieldList): string;

package/dist/dialect/duckdb/duckdb.js

@@ -96,15 +96,11 @@ class DuckDBDialect extends pg_impl_1.PostgresBase {
     mapFields(fieldList) {
         return fieldList.join(', ');
     }
-    sqlAggregateTurtle(groupSet, fieldList, orderBy, limit) {
-        let tail = '';
-        if (limit !== undefined) {
-            tail += `[1:${limit}]`;
-        }
+    sqlAggregateTurtle(groupSet, fieldList, orderBy) {
         const fields = fieldList
             .map(f => `\n  ${f.sqlOutputName}: ${f.sqlExpression}`)
             .join(', ');
-        return `COALESCE(LIST({${fields}} ${orderBy}) FILTER (WHERE group_set=${groupSet})${tail},[])`;
+        return `COALESCE(LIST({${fields}} ${orderBy}) FILTER (WHERE group_set=${groupSet}),[])`;
     }
     sqlAnyValueTurtle(groupSet, fieldList) {
         const fields = fieldList

package/dist/dialect/mysql/mysql.d.ts

@@ -37,7 +37,7 @@ export declare class MySQLDialect extends Dialect {
     sqlGroupSetTable(groupSetCount: number): string;
     sqlAnyValue(_groupSet: number, fieldName: string): string;
     private mapFields;
-    sqlAggregateTurtle(groupSet: number, fieldList: DialectFieldList, orderBy: string | undefined, limit: number | undefined): string;
+    sqlAggregateTurtle(groupSet: number, fieldList: DialectFieldList, orderBy: string | undefined): string;
     sqlAnyValueTurtle(groupSet: number, fieldList: DialectFieldList): string;
     sqlAnyValueLastTurtle(name: string, groupSet: number, sqlName: string): string;
     sqlCoaleseMeasuresInline(groupSet: number, fieldList: DialectFieldList): string;

package/dist/dialect/mysql/mysql.js

@@ -135,8 +135,8 @@ class MySQLDialect extends dialect_1.Dialect {
     mapFields(fieldList) {
         return fieldList.map(f => `"${f.rawName}", ${f.sqlExpression}`).join(', ');
     }
-    sqlAggregateTurtle(groupSet, fieldList, orderBy, limit) {
-        const separator = limit ? ',xrmmex' : ',';
+    sqlAggregateTurtle(groupSet, fieldList, orderBy) {
+        const separator = ',';
         let gc = `GROUP_CONCAT(
       IF(group_set=${groupSet},
         JSON_OBJECT(${this.mapFields(fieldList)})
@@ -145,10 +145,6 @@ class MySQLDialect extends dialect_1.Dialect {
       ${orderBy}
       SEPARATOR '${separator}'
     )`;
-        if (limit) {
-            gc = `SUBSTRING_INDEX(${gc}, '${separator}', ${limit})`;
-            gc = `REPLACE(${gc},'${separator}',',')`;
-        }
         gc = `COALESCE(JSON_EXTRACT(CONCAT('[',${gc},']'),'$'),JSON_ARRAY())`;
         return gc;
     }

package/dist/dialect/postgres/postgres.d.ts

@@ -30,7 +30,7 @@ export declare class PostgresDialect extends PostgresBase {
     sqlGroupSetTable(groupSetCount: number): string;
     sqlAnyValue(groupSet: number, fieldName: string): string;
     mapFields(fieldList: DialectFieldList): string;
-    sqlAggregateTurtle(groupSet: number, fieldList: DialectFieldList, orderBy: string | undefined, limit: number | undefined): string;
+    sqlAggregateTurtle(groupSet: number, fieldList: DialectFieldList, orderBy: string | undefined): string;
     sqlAnyValueTurtle(groupSet: number, fieldList: DialectFieldList): string;
     sqlAnyValueLastTurtle(name: string, groupSet: number, sqlName: string): string;
     sqlCoaleseMeasuresInline(groupSet: number, fieldList: DialectFieldList): string;

package/dist/dialect/postgres/postgres.js

@@ -113,13 +113,9 @@ class PostgresDialect extends pg_impl_1.PostgresBase {
             .map(f => `\n  ${f.sqlExpression}${f.typeDef.type === 'number' ? `::${this.defaultNumberType}` : ''} as ${f.sqlOutputName}`)
             .join(', ');
     }
-    sqlAggregateTurtle(groupSet, fieldList, orderBy, limit) {
-        let tail = '';
-        if (limit !== undefined) {
-            tail += `[1:${limit}]`;
-        }
+    sqlAggregateTurtle(groupSet, fieldList, orderBy) {
         const fields = this.mapFields(fieldList);
-        return `COALESCE(TO_JSONB((ARRAY_AGG((SELECT TO_JSONB(__x) FROM (SELECT ${fields}\n  ) as __x) ${orderBy} ) FILTER (WHERE group_set=${groupSet}))${tail}),'[]'::JSONB)`;
+        return `COALESCE(TO_JSONB((ARRAY_AGG((SELECT TO_JSONB(__x) FROM (SELECT ${fields}\n  ) as __x) ${orderBy} ) FILTER (WHERE group_set=${groupSet}))),'[]'::JSONB)`;
     }
     sqlAnyValueTurtle(groupSet, fieldList) {
         const fields = fieldList

package/dist/dialect/snowflake/snowflake.d.ts

@@ -30,7 +30,7 @@ export declare class SnowflakeDialect extends Dialect {
     sqlAnyValue(groupSet: number, fieldName: string): string;
     mapFields(fieldList: DialectFieldList): string;
     mapFieldsForObjectConstruct(fieldList: DialectFieldList): string;
-    sqlAggregateTurtle(groupSet: number, fieldList: DialectFieldList, orderBy: string | undefined, limit: number | undefined): string;
+    sqlAggregateTurtle(groupSet: number, fieldList: DialectFieldList, orderBy: string | undefined): string;
     sqlAnyValueTurtle(groupSet: number, fieldList: DialectFieldList): string;
     sqlAnyValueLastTurtle(name: string, groupSet: number, sqlName: string): string;
     sqlCoaleseMeasuresInline(groupSet: number, fieldList: DialectFieldList): string;

package/dist/dialect/snowflake/snowflake.js

@@ -119,14 +119,11 @@ class SnowflakeDialect extends dialect_1.Dialect {
             .map(f => `'${f.rawName}', (${f.sqlExpression})`)
             .join(', ');
     }
-    sqlAggregateTurtle(groupSet, fieldList, orderBy, limit) {
+    sqlAggregateTurtle(groupSet, fieldList, orderBy) {
         const fields = this.mapFieldsForObjectConstruct(fieldList);
         const orderByClause = orderBy ? ` WITHIN GROUP (${orderBy})` : '';
         const aggClause = `ARRAY_AGG(CASE WHEN group_set=${groupSet} THEN OBJECT_CONSTRUCT_KEEP_NULL(${fields}) END)${orderByClause}`;
-        if (limit === undefined) {
-            return `COALESCE(${aggClause}, [])`;
-        }
-        return `COALESCE(ARRAY_SLICE(${aggClause}, 0, ${limit}), [])`;
+        return `COALESCE(${aggClause}, [])`;
     }
     sqlAnyValueTurtle(groupSet, fieldList) {
         const fields = this.mapFieldsForObjectConstruct(fieldList);

package/dist/dialect/standardsql/standardsql.d.ts

@@ -31,7 +31,7 @@ export declare class StandardSQLDialect extends Dialect {
     sqlGroupSetTable(groupSetCount: number): string;
     sqlAnyValue(groupSet: number, fieldName: string): string;
     sqlOrderBy(orderTerms: string[], obr?: OrderByRequest): string;
-    sqlAggregateTurtle(groupSet: number, fieldList: DialectFieldList, orderBy: string | undefined, limit: number | undefined): string;
+    sqlAggregateTurtle(groupSet: number, fieldList: DialectFieldList, orderBy: string | undefined): string;
     sqlAnyValueTurtle(groupSet: number, fieldList: DialectFieldList): string;
     sqlAnyValueLastTurtle(name: string, groupSet: number, sqlName: string): string;
     sqlCoaleseMeasuresInline(groupSet: number, fieldList: DialectFieldList): string;

package/dist/dialect/standardsql/standardsql.js

@@ -117,15 +117,11 @@ class StandardSQLDialect extends dialect_1.Dialect {
         return `ORDER BY ${orderTerms.map(t => `${t} NULLS LAST`).join(',')}`;
     }
     // can array agg or any_value a struct...
-    sqlAggregateTurtle(groupSet, fieldList, orderBy, limit) {
-        let tail = '';
-        if (limit !== undefined) {
-            tail += ` LIMIT ${limit}`;
-        }
+    sqlAggregateTurtle(groupSet, fieldList, orderBy) {
         const fields = fieldList
             .map(f => `\n  ${f.sqlExpression} as ${f.sqlOutputName}`)
             .join(', ');
-        return `ARRAY_AGG(CASE WHEN group_set=${groupSet} THEN STRUCT(${fields}\n  ) END IGNORE NULLS ${orderBy} ${tail})`;
+        return `ARRAY_AGG(CASE WHEN group_set=${groupSet} THEN STRUCT(${fields}\n  ) END IGNORE NULLS ${orderBy})`;
     }
     sqlAnyValueTurtle(groupSet, fieldList) {
         const fields = fieldList

package/dist/dialect/trino/trino.d.ts

@@ -35,7 +35,7 @@ export declare class TrinoDialect extends PostgresBase {
     exprToSQL(qi: QueryInfo, df: Expr): string | undefined;
     sqlAnyValue(groupSet: number, fieldName: string): string;
     buildTypeExpression(fieldList: DialectFieldList): string;
-    sqlAggregateTurtle(groupSet: number, fieldList: DialectFieldList, orderBy: string | undefined, limit: number | undefined): string;
+    sqlAggregateTurtle(groupSet: number, fieldList: DialectFieldList, orderBy: string | undefined): string;
     sqlAnyValueTurtle(groupSet: number, fieldList: DialectFieldList): string;
     sqlAnyValueLastTurtle(name: string, groupSet: number, sqlName: string): string;
     sqlCoaleseMeasuresInline(groupSet: number, fieldList: DialectFieldList): string;

package/dist/dialect/trino/trino.js

@@ -227,14 +227,10 @@ class TrinoDialect extends pg_impl_1.PostgresBase {
             .join(', \n');
     }
     // can array agg or any_value a struct...
-    sqlAggregateTurtle(groupSet, fieldList, orderBy, limit) {
+    sqlAggregateTurtle(groupSet, fieldList, orderBy) {
         const expressions = fieldList.map(f => f.sqlExpression).join(',\n ');
         const definitions = this.buildTypeExpression(fieldList);
-        let ret = `ARRAY_AGG(CAST(ROW(${expressions}) AS ROW(${definitions})) ${orderBy}) FILTER (WHERE group_set=${groupSet})`;
-        if (limit !== undefined) {
-            ret = `SLICE(${ret}, 1, ${limit})`;
-        }
-        return ret;
+        return `ARRAY_AGG(CAST(ROW(${expressions}) AS ROW(${definitions})) ${orderBy}) FILTER (WHERE group_set=${groupSet})`;
     }
     sqlAnyValueTurtle(groupSet, fieldList) {
         const expressions = fieldList.map(f => f.sqlExpression).join(',\n ');

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 export { DuckDBDialect, StandardSQLDialect, TrinoDialect, PostgresDialect, SnowflakeDialect, MySQLDialect, registerDialect, arg, qtz, overload, minScalar, anyExprType, minAggregate, maxScalar, sql, makeParam, param, variadicParam, literal, spread, Dialect, TinyParser, } from './dialect';
 export type { DialectFieldList, DialectFunctionOverloadDef, QueryInfo, MalloyStandardFunctionImplementations, DefinitionBlueprint, DefinitionBlueprintMap, OverloadedDefinitionBlueprint, TinyToken, } from './dialect';
 export type { QueryDataRow, StructDef, TableSourceDef, SQLSourceDef, SourceDef, JoinFieldDef, NamedSourceDefs, MalloyQueryData, DateUnit, ExtractUnit, TimestampUnit, TemporalFieldType, QueryData, QueryValue, Expr, FilterCondition, Argument, Parameter, FieldDef, PipeSegment, QueryFieldDef, IndexFieldDef, TurtleDef, SearchValueMapResult, SearchIndexResult, ModelDef, Query, QueryResult, QueryResultDef, QueryRunStats, QueryScalar, NamedQuery, NamedModelObject, ExpressionType, FunctionDef, FunctionOverloadDef, FunctionParameterDef, ExpressionValueType, TypeDesc, FunctionParamTypeDesc, DocumentLocation, DocumentRange, DocumentPosition, Sampling, Annotation, BasicAtomicTypeDef, BasicAtomicDef, AtomicTypeDef, AtomicFieldDef, ArrayDef, ArrayTypeDef, RecordTypeDef, RepeatedRecordTypeDef, RecordDef, RepeatedRecordDef, RecordLiteralNode, StringLiteralNode, ArrayLiteralNode, SourceComponentInfo, } from './model';
-export { isSourceDef, Segment, isBasicAtomic, isJoined, isJoinedSource, isSamplingEnable, isSamplingPercent, isSamplingRows, isRepeatedRecord, isBasicArray, mkArrayDef, mkFieldDef, expressionIsAggregate, expressionIsAnalytic, expressionIsCalculation, expressionIsScalar, expressionIsUngroupedAggregate, indent, composeSQLExpr, isTimestampUnit, isDateUnit, } from './model';
+export { isSourceDef, isBasicAtomic, isJoined, isJoinedSource, isSamplingEnable, isSamplingPercent, isSamplingRows, isRepeatedRecord, isBasicArray, mkArrayDef, mkFieldDef, expressionIsAggregate, expressionIsAnalytic, expressionIsCalculation, expressionIsScalar, expressionIsUngroupedAggregate, indent, composeSQLExpr, isTimestampUnit, isDateUnit, } from './model';
 export { malloyToQuery, MalloyTranslator, } from './lang';
 export type { LogMessage, TranslateResponse } from './lang';
 export { Model, Malloy, Runtime, AtomicFieldType, ConnectionRuntime, SingleConnectionRuntime, EmptyURLReader, InMemoryURLReader, FixedConnectionMap, MalloyError, JoinRelationship, SourceRelationship, DateTimeframe, TimestampTimeframe, PreparedResult, Result, QueryMaterializer, CSVWriter, JSONWriter, Parse, DataWriter, Explore, InMemoryModelCache, CacheManager, } from './malloy';

package/dist/index.js

@@ -33,8 +33,8 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConnectionRuntime = exports.AtomicFieldType = exports.Runtime = exports.Malloy = exports.Model = exports.MalloyTranslator = exports.malloyToQuery = exports.isDateUnit = exports.isTimestampUnit = exports.composeSQLExpr = exports.indent = exports.expressionIsUngroupedAggregate = exports.expressionIsScalar = exports.expressionIsCalculation = exports.expressionIsAnalytic = exports.expressionIsAggregate = exports.mkFieldDef = exports.mkArrayDef = exports.isBasicArray = exports.isRepeatedRecord = exports.isSamplingRows = exports.isSamplingPercent = exports.isSamplingEnable = exports.isJoinedSource = exports.isJoined = exports.isBasicAtomic = exports.Segment = exports.isSourceDef = exports.TinyParser = exports.Dialect = exports.spread = exports.literal = exports.variadicParam = exports.param = exports.makeParam = exports.sql = exports.maxScalar = exports.minAggregate = exports.anyExprType = exports.minScalar = exports.overload = exports.qtz = exports.arg = exports.registerDialect = exports.MySQLDialect = exports.SnowflakeDialect = exports.PostgresDialect = exports.TrinoDialect = exports.StandardSQLDialect = exports.DuckDBDialect = void 0;
-exports.annotationToTaglines = exports.annotationToTag = exports.sqlKey = exports.API = exports.extractMalloyObjectFromTag = exports.writeMalloyObjectToTag = exports.sourceDefToSourceInfo = exports.modelDefToModelInfo = exports.toAsyncGenerator = exports.CacheManager = exports.InMemoryModelCache = exports.Explore = exports.DataWriter = exports.Parse = exports.JSONWriter = exports.CSVWriter = exports.QueryMaterializer = exports.Result = exports.PreparedResult = exports.TimestampTimeframe = exports.DateTimeframe = exports.SourceRelationship = exports.JoinRelationship = exports.MalloyError = exports.FixedConnectionMap = exports.InMemoryURLReader = exports.EmptyURLReader = exports.SingleConnectionRuntime = void 0;
+exports.SingleConnectionRuntime = exports.ConnectionRuntime = exports.AtomicFieldType = exports.Runtime = exports.Malloy = exports.Model = exports.MalloyTranslator = exports.malloyToQuery = exports.isDateUnit = exports.isTimestampUnit = exports.composeSQLExpr = exports.indent = exports.expressionIsUngroupedAggregate = exports.expressionIsScalar = exports.expressionIsCalculation = exports.expressionIsAnalytic = exports.expressionIsAggregate = exports.mkFieldDef = exports.mkArrayDef = exports.isBasicArray = exports.isRepeatedRecord = exports.isSamplingRows = exports.isSamplingPercent = exports.isSamplingEnable = exports.isJoinedSource = exports.isJoined = exports.isBasicAtomic = exports.isSourceDef = exports.TinyParser = exports.Dialect = exports.spread = exports.literal = exports.variadicParam = exports.param = exports.makeParam = exports.sql = exports.maxScalar = exports.minAggregate = exports.anyExprType = exports.minScalar = exports.overload = exports.qtz = exports.arg = exports.registerDialect = exports.MySQLDialect = exports.SnowflakeDialect = exports.PostgresDialect = exports.TrinoDialect = exports.StandardSQLDialect = exports.DuckDBDialect = void 0;
+exports.annotationToTaglines = exports.annotationToTag = exports.sqlKey = exports.API = exports.extractMalloyObjectFromTag = exports.writeMalloyObjectToTag = exports.sourceDefToSourceInfo = exports.modelDefToModelInfo = exports.toAsyncGenerator = exports.CacheManager = exports.InMemoryModelCache = exports.Explore = exports.DataWriter = exports.Parse = exports.JSONWriter = exports.CSVWriter = exports.QueryMaterializer = exports.Result = exports.PreparedResult = exports.TimestampTimeframe = exports.DateTimeframe = exports.SourceRelationship = exports.JoinRelationship = exports.MalloyError = exports.FixedConnectionMap = exports.InMemoryURLReader = exports.EmptyURLReader = void 0;
 /*
  * Copyright 2023 Google LLC
  *
@@ -83,7 +83,6 @@ Object.defineProperty(exports, "TinyParser", { enumerable: true, get: function (
 var model_1 = require("./model");
 Object.defineProperty(exports, "isSourceDef", { enumerable: true, get: function () { return model_1.isSourceDef; } });
 // Used in Composer Demo
-Object.defineProperty(exports, "Segment", { enumerable: true, get: function () { return model_1.Segment; } });
 Object.defineProperty(exports, "isBasicAtomic", { enumerable: true, get: function () { return model_1.isBasicAtomic; } });
 Object.defineProperty(exports, "isJoined", { enumerable: true, get: function () { return model_1.isJoined; } });
 Object.defineProperty(exports, "isJoinedSource", { enumerable: true, get: function () { return model_1.isJoinedSource; } });

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

@@ -106,7 +106,7 @@ class ExprAggregateFunction extends expression_def_1.ExpressionDef {
                                     at: this.source.location,
                                 },
                             evalSpace: footType.evalSpace,
-                            fieldUsage: footType.fieldUsage,
+                            fieldUsage: [{ path: this.source.path, 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
@@ -176,8 +176,18 @@ class ExprAggregateFunction extends expression_def_1.ExpressionDef {
             if (structPath && structPath.length > 0) {
                 f.structPath = structPath;
             }
+            const returnExpr = this.returns(exprVal);
+            if (!this.isSymmetricFunction()) {
+                if (returnExpr.fieldUsage === undefined) {
+                    returnExpr.fieldUsage = [];
+                }
+                returnExpr.fieldUsage.push({
+                    path: structPath || [],
+                    uniqueKeyRequirement: { isCount: false },
+                });
+            }
             return {
-                ...this.returns(exprVal),
+                ...returnExpr,
                 expressionType: 'aggregate',
                 value: f,
                 evalSpace: 'output',

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

@@ -63,7 +63,9 @@ class ExprCount extends expr_aggregate_function_1.ExprAggregateFunction {
             expressionType: 'aggregate',
             value: ret,
             evalSpace: 'output',
-            fieldUsage: [],
+            fieldUsage: [
+                { path: ret.structPath || [], uniqueKeyRequirement: { isCount: true } },
+            ],
         };
     }
 }

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

@@ -64,7 +64,7 @@ const expression_def_1 = require("../types/expression-def");
 const field_space_1 = require("../types/field-space");
 const utils_1 = require("../../../model/utils");
 const TDU = __importStar(require("../typedesc-utils"));
-const composite_source_utils_1 = require("../../../model/composite_source_utils");
+const composite_source_utils_1 = require("../../composite-source-utils");
 class ExprFunc extends expression_def_1.ExpressionDef {
     constructor(name, args, isRaw, rawType, source) {
         super({ args: args });
@@ -111,7 +111,7 @@ class ExprFunc extends expression_def_1.ExpressionDef {
         return { found: func, error: undefined };
     }
     getPropsExpression(fs, props) {
-        var _a, _b, _c, _d, _e;
+        var _a, _b, _c, _d;
         const argExprsWithoutImplicit = this.args.map(arg => arg.getExpression(fs));
         if (this.isRaw) {
             const funcCall = [`${this.name}(`];
@@ -156,7 +156,7 @@ class ExprFunc extends expression_def_1.ExpressionDef {
                             at: this.source.location,
                         },
                         evalSpace: footType.evalSpace,
-                        fieldUsage: footType.fieldUsage,
+                        fieldUsage: [{ path: this.source.path, at: this.source.location }],
                     };
                     structPath = this.source.path.slice(0, -1);
                 }
@@ -232,11 +232,13 @@ class ExprFunc extends expression_def_1.ExpressionDef {
             structPath,
         };
         let funcCall = frag;
+        const isAnalytic = (0, malloy_types_1.expressionIsAnalytic)(overload.returnType.expressionType);
+        const isAsymmetric = !overload.isSymmetric;
+        const orderByUsage = [];
         // TODO add in an error if you use an asymmetric function in BQ
         // and the function uses joins
         // TODO add in an error if you use an illegal join pattern
         if ((props === null || props === void 0 ? void 0 : props.orderBys) && props.orderBys.length > 0) {
-            const isAnalytic = (0, malloy_types_1.expressionIsAnalytic)(overload.returnType.expressionType);
             if (!isAnalytic) {
                 if (!this.inExperiment('aggregate_order_by', true)) {
                     props.orderBys[0].logError('aggregate-order-by-experiment-not-enabled', 'Enable experiment `aggregate_order_by` to use `order_by` with an aggregate function');
@@ -244,10 +246,17 @@ class ExprFunc extends expression_def_1.ExpressionDef {
             }
             if (overload.supportsOrderBy || isAnalytic) {
                 const allowExpression = overload.supportsOrderBy !== 'only_default';
-                const allObs = props.orderBys.flatMap(orderBy => isAnalytic
-                    ? orderBy.getAnalyticOrderBy(fs)
-                    : orderBy.getAggregateOrderBy(fs, allowExpression));
-                frag.kids.orderBy = allObs;
+                const allOrderBy = [];
+                for (const ordering of props.orderBys) {
+                    const { orderBy, fieldUsage } = isAnalytic
+                        ? ordering.getAnalyticOrderBy(fs)
+                        : ordering.getAggregateOrderBy(fs, allowExpression);
+                    if (fieldUsage) {
+                        orderByUsage.push(...fieldUsage);
+                    }
+                    allOrderBy.push(...orderBy);
+                }
+                frag.kids.orderBy = allOrderBy;
             }
             else {
                 props.orderBys[0].logError('function-does-not-support-order-by', `Function \`${this.name}\` does not support \`order_by\``);
@@ -317,11 +326,14 @@ class ExprFunc extends expression_def_1.ExpressionDef {
                         if (typeDesc.type === 'filter expression') {
                             return this.loggedErrorExpr('filter-expression-error', 'Filter expressions cannot be used in sql_ functions');
                         }
-                        sqlFunctionFieldUsage.push(...((_e = typeDesc.fieldUsage) !== null && _e !== void 0 ? _e : []));
                         if (result.found.refType === 'parameter') {
                             expr.push({ node: 'parameter', path: part.path });
                         }
                         else {
+                            sqlFunctionFieldUsage.push({
+                                path: part.path,
+                                at: this.args[0].location,
+                            });
                             expr.push({
                                 node: 'field',
                                 // TODO when we have namespaces, this will need to be replaced with the resolved path
@@ -345,6 +357,17 @@ class ExprFunc extends expression_def_1.ExpressionDef {
             : (0, malloy_types_1.expressionIsScalar)(expressionType)
                 ? maxEvalSpace
                 : 'output';
+        const aggregateFunctionUsage = [];
+        if (isAsymmetric || isAnalytic) {
+            const funcUsage = { path: structPath || [], at: this.location };
+            if (isAsymmetric)
+                funcUsage.uniqueKeyRequirement = { isCount: false };
+            if (isAnalytic)
+                funcUsage.analyticFunctionUse = true;
+            aggregateFunctionUsage.push(funcUsage);
+        }
+        const fieldUsage = (0, composite_source_utils_1.mergeFieldUsage)(...argExprs.map(ae => ae.fieldUsage), orderByUsage, sqlFunctionFieldUsage, aggregateFunctionUsage);
+        const ungroupings = argExprs.reduce((ug, a) => { var _a; return (_a = a.ungroupings) !== null && _a !== void 0 ? _a : ug; }, []);
         // TODO consider if I can use `computedExprValue` here...
         // seems like the rules for the evalSpace is a bit different from normal though
         return {
@@ -353,7 +376,8 @@ class ExprFunc extends expression_def_1.ExpressionDef {
             expressionType,
             value: funcCall,
             evalSpace,
-            fieldUsage: (0, composite_source_utils_1.mergeFieldUsage)(...argExprs.map(e => e.fieldUsage), sqlFunctionFieldUsage),
+            fieldUsage,
+            ungroupings,
         };
     }
 }

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

@@ -65,7 +65,7 @@ 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 composite_source_utils_1 = require("../../composite-source-utils");
 const grouped_by_1 = require("./grouped_by");
 class ExprProps extends expression_def_1.ExpressionDef {
     constructor(expr, statements) {

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

@@ -71,7 +71,7 @@ class ExprUngroup extends expression_def_1.ExpressionDef {
         this.elementType = 'ungroup';
     }
     getExpression(fs) {
-        var _a, _b;
+        var _a;
         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`);
@@ -117,17 +117,21 @@ class ExprUngroup extends expression_def_1.ExpressionDef {
                 }
                 ungroup.fields = dstFields;
             }
+            const fieldUsage = exprVal.fieldUsage;
             return {
                 ...TDU.atomicDef(exprVal),
                 expressionType: 'ungrouped_aggregate',
                 value: ungroup,
                 evalSpace: 'output',
-                fieldUsage: exprVal.fieldUsage,
+                fieldUsage,
                 ungroupings: [
                     {
                         requiresGroupBy: (_a = exprVal.requiresGroupBy) !== null && _a !== void 0 ? _a : [],
-                        fieldUsage: (_b = exprVal.fieldUsage) !== null && _b !== void 0 ? _b : [],
+                        fieldUsage: fieldUsage !== null && fieldUsage !== void 0 ? fieldUsage : [],
                         ungroupedFields: isExclude ? ungroupFields !== null && ungroupFields !== void 0 ? ungroupFields : [] : '*',
+                        path: [],
+                        exclude: isExclude,
+                        refFields: ungroup.fields,
                     },
                 ],
             };

package/dist/lang/ast/expressions/function-ordering.d.ts

@@ -1,18 +1,32 @@
-import type { FunctionOrderBy as ModelFunctionOrderBy } from '../../../model/malloy_types';
+import type { FieldUsage, FunctionOrderBy as ModelFunctionOrderBy } from '../../../model/malloy_types';
 import type { ExpressionDef } from '../types/expression-def';
 import type { FieldSpace } from '../types/field-space';
 import { ListOf, MalloyElement } from '../types/malloy-element';
+type FieldUsageSummary = FieldUsage[] | undefined;
 export declare class FunctionOrderBy extends MalloyElement {
     readonly field?: ExpressionDef | undefined;
     readonly dir?: "asc" | "desc" | undefined;
     elementType: string;
     constructor(field?: ExpressionDef | undefined, dir?: "asc" | "desc" | undefined);
-    getAnalyticOrderBy(fs: FieldSpace): ModelFunctionOrderBy;
-    getAggregateOrderBy(fs: FieldSpace, allowExpression: boolean): ModelFunctionOrderBy;
+    computeAnalyticOrderBy(fs: FieldSpace): {
+        modelFunctionOrderBy: ModelFunctionOrderBy;
+        fieldUsage: FieldUsageSummary;
+    };
+    computeAggregateOrderByWithUsage(fs: FieldSpace, allowExpression: boolean): {
+        modelFunctionOrderBy: ModelFunctionOrderBy;
+        fieldUsage: FieldUsageSummary;
+    };
 }
 export declare class FunctionOrdering extends ListOf<FunctionOrderBy> {
     elementType: string;
     constructor(list: FunctionOrderBy[]);
-    getAnalyticOrderBy(fs: FieldSpace): ModelFunctionOrderBy[];
-    getAggregateOrderBy(fs: FieldSpace, allowExpression: boolean): ModelFunctionOrderBy[];
+    getAnalyticOrderBy(fs: FieldSpace): {
+        orderBy: ModelFunctionOrderBy[];
+        fieldUsage: FieldUsageSummary;
+    };
+    getAggregateOrderBy(fs: FieldSpace, allowExpression: boolean): {
+        orderBy: ModelFunctionOrderBy[];
+        fieldUsage: FieldUsageSummary;
+    };
 }
+export {};

package/dist/lang/ast/expressions/function-ordering.js

@@ -26,6 +26,7 @@ exports.FunctionOrdering = exports.FunctionOrderBy = void 0;
 const malloy_types_1 = require("../../../model/malloy_types");
 const malloy_element_1 = require("../types/malloy-element");
 const expr_id_reference_1 = require("./expr-id-reference");
+const composite_source_utils_1 = require("../../composite-source-utils");
 class FunctionOrderBy extends malloy_element_1.MalloyElement {
     constructor(field, dir) {
         super();
@@ -35,12 +36,21 @@ class FunctionOrderBy extends malloy_element_1.MalloyElement {
         if (field)
             this.has({ field });
     }
-    getAnalyticOrderBy(fs) {
+    computeAnalyticOrderBy(fs) {
+        let fieldUsage = undefined;
         if (!this.field) {
             this.logError('analytic-order-by-missing-field', 'analytic `order_by` must specify an aggregate expression or output field reference');
-            return { node: 'functionOrderBy', e: { node: 'error' }, dir: this.dir };
+            return {
+                modelFunctionOrderBy: {
+                    node: 'functionOrderBy',
+                    e: { node: 'error' },
+                    dir: this.dir,
+                },
+                fieldUsage,
+            };
         }
         const expr = this.field.getExpression(fs);
+        fieldUsage = expr.fieldUsage;
         if ((0, malloy_types_1.expressionIsAggregate)(expr.expressionType)) {
             // Aggregates are okay
         }
@@ -53,26 +63,48 @@ class FunctionOrderBy extends malloy_element_1.MalloyElement {
         else {
             this.field.logError('analytic-order-by-not-aggregate-or-output', 'analytic `order_by` must be scalar or aggregate');
         }
-        return { node: 'functionOrderBy', e: expr.value, dir: this.dir };
+        return {
+            modelFunctionOrderBy: {
+                node: 'functionOrderBy',
+                e: expr.value,
+                dir: this.dir,
+            },
+            fieldUsage,
+        };
     }
-    getAggregateOrderBy(fs, allowExpression) {
+    computeAggregateOrderByWithUsage(fs, allowExpression) {
+        let fieldUsage = undefined;
+        const dir = this.dir || 'asc';
         if (this.field) {
             const expr = this.field.getExpression(fs);
+            fieldUsage = expr.fieldUsage;
             if (!(0, malloy_types_1.expressionIsScalar)(expr.expressionType)) {
                 this.field.logError('aggregate-order-by-not-scalar', 'aggregate `order_by` must be scalar');
             }
             if (!allowExpression) {
                 this.field.logError('aggregate-order-by-expression-not-allowed', '`order_by` must be only `asc` or `desc` with no expression');
             }
-            return { node: 'functionOrderBy', e: expr.value, dir: this.dir };
+            return {
+                modelFunctionOrderBy: {
+                    node: 'functionOrderBy',
+                    e: expr.value,
+                    dir,
+                },
+                fieldUsage,
+            };
         }
         else {
             if (this.dir === undefined) {
                 // This error should technically never happen because it can't parse this way
                 this.logError('aggregate-order-by-without-field-or-direction', 'field or order direction must be specified');
-                return { node: 'functionDefaultOrderBy', dir: 'asc' };
             }
-            return { node: 'functionDefaultOrderBy', dir: this.dir };
+            return {
+                modelFunctionOrderBy: {
+                    node: 'functionDefaultOrderBy',
+                    dir,
+                },
+                fieldUsage,
+            };
         }
     }
 }
@@ -83,10 +115,30 @@ class FunctionOrdering extends malloy_element_1.ListOf {
         this.elementType = 'function-ordering';
     }
     getAnalyticOrderBy(fs) {
-        return this.list.map(el => el.getAnalyticOrderBy(fs));
+        const ret = [];
+        const fieldUsage = [];
+        for (const ob of this.list) {
+            const computed = ob.computeAnalyticOrderBy(fs);
+            ret.push(computed.modelFunctionOrderBy);
+            fieldUsage.push(computed.fieldUsage);
+        }
+        return {
+            orderBy: ret,
+            fieldUsage: (0, composite_source_utils_1.mergeFieldUsage)(...fieldUsage),
+        };
     }
     getAggregateOrderBy(fs, allowExpression) {
-        return this.list.map(el => el.getAggregateOrderBy(fs, allowExpression));
+        const ret = [];
+        const fieldUsage = [];
+        for (const ob of this.list) {
+            const computed = ob.computeAggregateOrderByWithUsage(fs, allowExpression);
+            ret.push(computed.modelFunctionOrderBy);
+            fieldUsage.push(computed.fieldUsage);
+        }
+        return {
+            orderBy: ret,
+            fieldUsage: (0, composite_source_utils_1.mergeFieldUsage)(...fieldUsage),
+        };
     }
 }
 exports.FunctionOrdering = FunctionOrdering;

package/dist/lang/ast/field-space/include-utils.js

@@ -11,7 +11,7 @@ exports.processIncludeList = processIncludeList;
 const malloy_types_1 = require("../../../model/malloy_types");
 const include_item_1 = require("../source-query-elements/include-item");
 const field_references_1 = require("../query-items/field-references");
-const composite_source_utils_1 = require("../../../model/composite_source_utils");
+const composite_source_utils_1 = require("../../composite-source-utils");
 function getJoinFields(from, joinPath, logTo) {
     let fields = from.fields;
     for (const joinName of joinPath) {

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

@@ -23,7 +23,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IndexFieldSpace = void 0;
-const composite_source_utils_1 = require("../../../model/composite_source_utils");
+const composite_source_utils_1 = require("../../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");
@@ -79,6 +79,7 @@ class IndexFieldSpace extends query_spaces_1.QueryOperationSpace {
                 const wild = this.expandedWild[name];
                 if (wild) {
                     indexFields.push({ type: 'fieldref', path: wild.path, at: wild.at });
+                    fieldUsage.push({ path: wild.path });
                     nextFieldUsage = wild.entry.typeDesc().fieldUsage;
                 }
                 else if (field instanceof reference_field_1.ReferenceField) {
@@ -91,6 +92,7 @@ class IndexFieldSpace extends query_spaces_1.QueryOperationSpace {
                     else {
                         indexFields.push(fieldRef.refToField);
                         nextFieldUsage = check.found.typeDesc().fieldUsage;
+                        fieldUsage.push({ path: fieldRef.path });
                     }
                 }
                 fieldUsage = (_a = (0, composite_source_utils_1.mergeFieldUsage)(fieldUsage, nextFieldUsage)) !== null && _a !== void 0 ? _a : [];