@malloydata/malloy 0.0.412 → 0.0.414

package/dist/api/foundation/core.d.ts

@@ -119,6 +119,27 @@ export declare class Explore extends Entity implements Taggable {
      *  model annotations. */
     get _modelDef(): ModelDef;
     get source(): Explore | undefined;
+    /**
+     * THIS IS A HIGHLY EXPERIMENTAL API AND MAY VANISH OR CHANGE WITHOUT NOTICE
+     *
+     * If this source was created as an unmodified reference to another source, a
+     * stable identifier of the source it refers to; undefined when this source
+     * defines its own shape. Two sources that refer to the same thing share this
+     * id, so it can be compared to tell whether two otherwise un-nameable sources
+     * are the same — even when the referenced source can't be named here.
+     */
+    get referenceSourceID(): string | undefined;
+    /**
+     * THIS IS A HIGHLY EXPERIMENTAL API AND MAY VANISH OR CHANGE WITHOUT NOTICE
+     *
+     * If this source was created as an unmodified reference to a source that is in
+     * this model's namespace (`source: a is b`, or a plain join), return that
+     * source as it appears in the namespace — read `.name` for the name it goes by
+     * here. Returns undefined when this source defines its own shape (a table,
+     * SQL, query, or modified/extended source), or when the referenced source is
+     * not in this model's namespace.
+     */
+    referencedSource(): Explore | undefined;
     isIntrinsic(): boolean;
     isExploreField(): this is ExploreField;
     /** @deprecated Use `.annotations.parseAsTag(route)`. */

package/dist/api/foundation/core.js

@@ -172,6 +172,36 @@ class Explore extends Entity {
     get source() {
         return this.sourceExplore;
     }
+    /**
+     * THIS IS A HIGHLY EXPERIMENTAL API AND MAY VANISH OR CHANGE WITHOUT NOTICE
+     *
+     * If this source was created as an unmodified reference to another source, a
+     * stable identifier of the source it refers to; undefined when this source
+     * defines its own shape. Two sources that refer to the same thing share this
+     * id, so it can be compared to tell whether two otherwise un-nameable sources
+     * are the same — even when the referenced source can't be named here.
+     */
+    get referenceSourceID() {
+        return (0, model_1.isSourceDef)(this._structDef)
+            ? this._structDef.referenceID
+            : undefined;
+    }
+    /**
+     * THIS IS A HIGHLY EXPERIMENTAL API AND MAY VANISH OR CHANGE WITHOUT NOTICE
+     *
+     * If this source was created as an unmodified reference to a source that is in
+     * this model's namespace (`source: a is b`, or a plain join), return that
+     * source as it appears in the namespace — read `.name` for the name it goes by
+     * here. Returns undefined when this source defines its own shape (a table,
+     * SQL, query, or modified/extended source), or when the referenced source is
+     * not in this model's namespace.
+     */
+    referencedSource() {
+        if (!(0, model_1.isSourceDef)(this._structDef))
+            return undefined;
+        const ref = (0, source_def_utils_1.sourceNamespaceReference)(this._ownerModelDef, this._structDef);
+        return ref ? new Explore(this._ownerModelDef, ref.source) : undefined;
+    }
     isIntrinsic() {
         if ((0, model_1.isAtomicFieldType)(this._structDef.type)) {
             return !('e' in this._structDef);

package/dist/dialect/databricks/databricks.d.ts

@@ -25,6 +25,7 @@ export declare class DatabricksDialect extends Dialect {
     dontUnionIndex: boolean;
     supportsQualify: boolean;
     supportsNesting: boolean;
+    supportsNestedProjectionLimit: boolean;
     hasLateralColumnAliasInSelect: boolean;
     cantPartitionWindowFunctionsOnExpressions: boolean;
     experimental: boolean;
@@ -48,7 +49,7 @@ export declare class DatabricksDialect extends Dialect {
     sqlOrderBy(orderTerms: string[], obr?: OrderByRequest): string;
     sqlAnyValue(groupSet: number, fieldName: string): string;
     private buildNamedStructExpression;
-    sqlAggregateTurtle(groupSet: number, fieldList: DialectFieldList, orderBy: CompiledOrderBy[] | undefined): string;
+    sqlAggregateTurtle(groupSet: number | undefined, fieldList: DialectFieldList, orderBy: CompiledOrderBy[] | undefined, limit?: number, filterSQL?: string): string;
     private buildArraySortComparator;
     sqlAnyValueTurtle(groupSet: number, fieldList: DialectFieldList): string;
     sqlAnyValueLastTurtle(name: string, groupSet: number, sqlName: string): string;

package/dist/dialect/databricks/databricks.js

@@ -62,6 +62,7 @@ class DatabricksDialect extends dialect_1.Dialect {
         this.dontUnionIndex = false;
         this.supportsQualify = false;
         this.supportsNesting = true;
+        this.supportsNestedProjectionLimit = true;
         this.hasLateralColumnAliasInSelect = true;
         this.cantPartitionWindowFunctionsOnExpressions = true;
         this.experimental = false;
@@ -169,13 +170,18 @@ class DatabricksDialect extends dialect_1.Dialect {
                 .join(', ') +
             ')');
     }
-    sqlAggregateTurtle(groupSet, fieldList, orderBy) {
+    sqlAggregateTurtle(groupSet, fieldList, orderBy, limit, filterSQL) {
         const namedStruct = this.buildNamedStructExpression(fieldList);
-        const collectExpr = `COLLECT_LIST(${namedStruct}) FILTER (WHERE group_set=${groupSet})`;
-        if (!orderBy || orderBy.length === 0) {
-            return collectExpr;
-        }
-        return `ARRAY_SORT(${collectExpr}, (l, r) -> ${this.buildArraySortComparator(orderBy)})`;
+        const cond = (0, dialect_1.turtleGroupSetCondition)(groupSet, filterSQL);
+        const filterClause = cond ? ` FILTER (WHERE ${cond})` : '';
+        const collectExpr = `COLLECT_LIST(${namedStruct})${filterClause}`;
+        // COLLECT_LIST is unordered, so ordering is done post-aggregation via
+        // ARRAY_SORT — the limit must slice the *ordered* array.
+        const ordered = !orderBy || orderBy.length === 0
+            ? collectExpr
+            : `ARRAY_SORT(${collectExpr}, (l, r) -> ${this.buildArraySortComparator(orderBy)})`;
+        // SLICE(array, start, length) is 1-based; length n keeps the first n.
+        return limit !== undefined ? `SLICE(${ordered}, 1, ${limit})` : ordered;
     }
     // Build a lambda comparator for ARRAY_SORT that handles multi-field
     // mixed-direction ordering. Each field comparison returns -1/0/1;

package/dist/dialect/dialect.d.ts

@@ -63,6 +63,16 @@ export type FieldReferenceType = 'table' | 'nest source' | 'array[scalar]' | 'ar
 export declare const dayIndex: number;
 export declare function inDays(units: string): boolean;
 export declare function qtz(qi: QueryInfo): string | undefined;
+/**
+ * The per-element condition for an aggregate turtle (sqlAggregateTurtle). On
+ * the normal path it gates each row by its group_set (and a projection's own
+ * `where:`). On the single-group-set fast path `groupSet` is `undefined` --
+ * there is no group_set column, every row is in the one group -- so the
+ * condition is just the `where:`, or `undefined` to include unconditionally.
+ * Callers wrap the result in whatever form the dialect uses (`FILTER (WHERE
+ * ...)`, `CASE WHEN ... THEN`, `IF(...)`).
+ */
+export declare function turtleGroupSetCondition(groupSet: number | undefined, filterSQL: string | undefined): string | undefined;
 export type OrderByClauseType = 'output_name' | 'ordinal' | 'expression';
 export type OrderByRequest = 'query' | 'turtle' | 'analytical';
 export type BooleanTypeSupport = 'supported' | 'simulated' | 'none';
@@ -99,6 +109,7 @@ export declare abstract class Dialect {
     cantPartitionWindowFunctionsOnExpressions: boolean;
     sqlLateralJoinBag(_expressions: LateralJoinExpression[]): string;
     supportsPipelinesInViews: boolean;
+    supportsNestedProjectionLimit: boolean;
     supportsArraysInData: boolean;
     hasTimestamptz: boolean;
     readsNestedData: boolean;
@@ -175,7 +186,7 @@ export declare abstract class Dialect {
     sqlValidateTableName(input: string): ValidateTablePathResult;
     abstract sqlGroupSetTable(groupSetCount: number): string;
     abstract sqlAnyValue(groupSet: number, fieldName: string): string;
-    abstract sqlAggregateTurtle(groupSet: number, fieldList: DialectFieldList, orderBy: CompiledOrderBy[] | undefined): string;
+    abstract sqlAggregateTurtle(groupSet: number | undefined, fieldList: DialectFieldList, orderBy: CompiledOrderBy[] | undefined, limit?: number, filterSQL?: string): string;
     sqlTurtleOrderByClause(orderBy: CompiledOrderBy[]): string;
     abstract sqlAnyValueTurtle(groupSet: number, fieldList: DialectFieldList): string;
     abstract sqlAnyValueLastTurtle(name: string, groupSet: number, sqlName: string): string;

package/dist/dialect/dialect.js

@@ -7,6 +7,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Dialect = exports.dayIndex = exports.EscapeStyle = exports.MAX_DECIMAL38 = exports.MIN_DECIMAL38 = exports.MAX_INT128 = exports.MIN_INT128 = exports.MAX_INT64 = exports.MIN_INT64 = exports.MAX_INT32 = exports.MIN_INT32 = void 0;
 exports.inDays = inDays;
 exports.qtz = qtz;
+exports.turtleGroupSetCondition = turtleGroupSetCondition;
 const malloy_types_1 = require("../model/malloy_types");
 const table_path_1 = require("./table-path");
 /*
@@ -61,6 +62,23 @@ function qtz(qi) {
     }
     return tz;
 }
+/**
+ * The per-element condition for an aggregate turtle (sqlAggregateTurtle). On
+ * the normal path it gates each row by its group_set (and a projection's own
+ * `where:`). On the single-group-set fast path `groupSet` is `undefined` --
+ * there is no group_set column, every row is in the one group -- so the
+ * condition is just the `where:`, or `undefined` to include unconditionally.
+ * Callers wrap the result in whatever form the dialect uses (`FILTER (WHERE
+ * ...)`, `CASE WHEN ... THEN`, `IF(...)`).
+ */
+function turtleGroupSetCondition(groupSet, filterSQL) {
+    if (groupSet === undefined) {
+        return filterSQL;
+    }
+    return filterSQL
+        ? `group_set=${groupSet} AND ${filterSQL}`
+        : `group_set=${groupSet}`;
+}
 class Dialect {
     constructor() {
         // -- we should add flags with default values from now on so as to not break
@@ -73,6 +91,13 @@ class Dialect {
         this.cantPartitionWindowFunctionsOnExpressions = false;
         // Snowflake can't yet support pipelines in nested views.
         this.supportsPipelinesInViews = true;
+        // Can the dialect apply a `limit:` to a nested `select:` (a projection
+        // nest)? A projection has no group-by keys to ROW_NUMBER-shave on, so the
+        // limit is applied by limiting/slicing the aggregated array inside
+        // `sqlAggregateTurtle`. Defaults false so a new dialect must consciously
+        // opt in (and implement the slice) rather than silently dropping the limit;
+        // the compiler rejects projection `limit:` when this is false.
+        this.supportsNestedProjectionLimit = false;
         // Some dialects don't supporrt arrays (mysql)
         this.supportsArraysInData = true;
         // Does the dialect support timestamptz (TIMESTAMP WITH TIME ZONE)?

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

@@ -22,6 +22,7 @@ export declare class DuckDBDialect extends PostgresBase {
     supportsQualify: boolean;
     supportsSafeCast: boolean;
     supportsNesting: boolean;
+    supportsNestedProjectionLimit: boolean;
     supportsCountApprox: boolean;
     requiresExplicitUnnestOrdering: boolean;
     integerTypeMappings: IntegerTypeMapping[];
@@ -31,7 +32,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: CompiledOrderBy[] | undefined): string;
+    sqlAggregateTurtle(groupSet: number | undefined, fieldList: DialectFieldList, orderBy: CompiledOrderBy[] | undefined, limit?: number, filterSQL?: string): 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

@@ -55,6 +55,7 @@ class DuckDBDialect extends pg_impl_1.PostgresBase {
         this.supportsQualify = true;
         this.supportsSafeCast = true;
         this.supportsNesting = true;
+        this.supportsNestedProjectionLimit = true;
         this.supportsCountApprox = true;
         // DuckDB UNNEST in LATERAL JOINs doesn't preserve array element order
         this.requiresExplicitUnnestOrdering = true;
@@ -91,12 +92,18 @@ class DuckDBDialect extends pg_impl_1.PostgresBase {
     mapFields(fieldList) {
         return fieldList.join(', ');
     }
-    sqlAggregateTurtle(groupSet, fieldList, orderBy) {
+    sqlAggregateTurtle(groupSet, fieldList, orderBy, limit, filterSQL) {
         const fields = fieldList
             .map(f => `\n  ${f.sqlOutputName}: ${f.sqlExpression}`)
             .join(', ');
         const orderByClause = orderBy ? this.sqlTurtleOrderByClause(orderBy) : '';
-        return `COALESCE(LIST({${fields}} ${orderByClause}) FILTER (WHERE group_set=${groupSet}),[])`;
+        const cond = (0, dialect_1.turtleGroupSetCondition)(groupSet, filterSQL);
+        const list = `LIST({${fields}} ${orderByClause})` +
+            (cond ? ` FILTER (WHERE ${cond})` : '');
+        // A projection nest's limit is applied by slicing the aggregated array
+        // (duckdb lists are 1-based, inclusive).
+        const limited = limit !== undefined ? `(${list})[1:${limit}]` : list;
+        return `COALESCE(${limited},[])`;
     }
     sqlAnyValueTurtle(groupSet, fieldList) {
         const fields = fieldList

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

@@ -31,6 +31,7 @@ export declare class MySQLDialect extends Dialect {
     readsNestedData: boolean;
     supportsComplexFilteredSources: boolean;
     supportsArraysInData: boolean;
+    supportsNestedProjectionLimit: boolean;
     compoundObjectInSchema: boolean;
     booleanType: BooleanTypeSupport;
     orderByClause: OrderByClauseType;
@@ -41,7 +42,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: CompiledOrderBy[] | undefined): string;
+    sqlAggregateTurtle(groupSet: number | undefined, fieldList: DialectFieldList, orderBy: CompiledOrderBy[] | undefined, _limit?: number, filterSQL?: string): 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

@@ -102,6 +102,10 @@ class MySQLDialect extends dialect_1.Dialect {
         this.readsNestedData = false;
         this.supportsComplexFilteredSources = false;
         this.supportsArraysInData = false;
+        // MySQL builds nested arrays with GROUP_CONCAT (not an array type), which has
+        // no in-expression slice; limiting would need query-level ROW_NUMBER plumbing
+        // the sqlAggregateTurtle seam doesn't expose. Left false (default) explicitly.
+        this.supportsNestedProjectionLimit = false;
         this.compoundObjectInSchema = false;
         this.booleanType = 'simulated';
         this.orderByClause = 'ordinal';
@@ -157,14 +161,19 @@ class MySQLDialect extends dialect_1.Dialect {
             .map(f => `${this.sqlLiteralString(f.rawName)}, ${f.sqlExpression}`)
             .join(', ');
     }
-    sqlAggregateTurtle(groupSet, fieldList, orderBy) {
+    sqlAggregateTurtle(groupSet, fieldList, orderBy, _limit, filterSQL) {
         const separator = ',';
         const orderByClause = orderBy ? this.sqlTurtleOrderByClause(orderBy) : '';
-        let gc = `GROUP_CONCAT(
-      IF(group_set=${groupSet},
-        JSON_OBJECT(${this.mapFields(fieldList)})
+        const cond = (0, dialect_1.turtleGroupSetCondition)(groupSet, filterSQL);
+        const json = `JSON_OBJECT(${this.mapFields(fieldList)})`;
+        const element = cond
+            ? `IF(${cond},
+        ${json}
         , null
-        )
+        )`
+            : json;
+        let gc = `GROUP_CONCAT(
+      ${element}
       ${orderByClause}
       SEPARATOR '${separator}'
     )`;

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

@@ -21,6 +21,7 @@ export declare class PostgresDialect extends PostgresBase {
     dontUnionIndex: boolean;
     supportsQualify: boolean;
     supportsNesting: boolean;
+    supportsNestedProjectionLimit: boolean;
     experimental: boolean;
     readsNestedData: boolean;
     supportsComplexFilteredSources: boolean;
@@ -31,7 +32,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: CompiledOrderBy[] | undefined): string;
+    sqlAggregateTurtle(groupSet: number | undefined, fieldList: DialectFieldList, orderBy: CompiledOrderBy[] | undefined, limit?: number, filterSQL?: string): 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

@@ -75,6 +75,7 @@ class PostgresDialect extends pg_impl_1.PostgresBase {
         this.dontUnionIndex = false;
         this.supportsQualify = false;
         this.supportsNesting = true;
+        this.supportsNestedProjectionLimit = true;
         this.experimental = false;
         this.readsNestedData = false;
         this.supportsComplexFilteredSources = false;
@@ -96,10 +97,16 @@ 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) {
+    sqlAggregateTurtle(groupSet, fieldList, orderBy, limit, filterSQL) {
         const fields = this.mapFields(fieldList);
         const orderByClause = orderBy ? this.sqlTurtleOrderByClause(orderBy) : '';
-        return `COALESCE(TO_JSONB((ARRAY_AGG((SELECT TO_JSONB(__x) FROM (SELECT ${fields}\n  ) as __x) ${orderByClause} ) FILTER (WHERE group_set=${groupSet}))),'[]'::JSONB)`;
+        const cond = (0, dialect_1.turtleGroupSetCondition)(groupSet, filterSQL);
+        const filterClause = cond ? ` FILTER (WHERE ${cond})` : '';
+        const arrayAgg = `(ARRAY_AGG((SELECT TO_JSONB(__x) FROM (SELECT ${fields}\n  ) as __x) ${orderByClause} )${filterClause})`;
+        // Slice the native ARRAY (1-based, inclusive) before TO_JSONB turns it into
+        // a single jsonb value — a jsonb scalar can't be range-sliced.
+        const limited = limit !== undefined ? `${arrayAgg}[1:${limit}]` : arrayAgg;
+        return `COALESCE(TO_JSONB(${limited}),'[]'::JSONB)`;
     }
     sqlAnyValueTurtle(groupSet, fieldList) {
         const fields = fieldList

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

@@ -17,6 +17,7 @@ export declare class SnowflakeDialect extends Dialect {
     supportsSumDistinctFunction: boolean;
     supportsSafeCast: boolean;
     supportsNesting: boolean;
+    supportsNestedProjectionLimit: boolean;
     defaultSampling: {
         rows: number;
     };
@@ -35,7 +36,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: CompiledOrderBy[] | undefined): string;
+    sqlAggregateTurtle(groupSet: number | undefined, fieldList: DialectFieldList, orderBy: CompiledOrderBy[] | undefined, limit?: number, filterSQL?: string): 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

@@ -71,6 +71,7 @@ class SnowflakeDialect extends dialect_1.Dialect {
         this.supportsSumDistinctFunction = true;
         this.supportsSafeCast = true;
         this.supportsNesting = true;
+        this.supportsNestedProjectionLimit = true;
         this.defaultSampling = { rows: 50000 };
         this.supportsHyperLogLog = true;
         // NOTE: safely setting all these to false for now
@@ -107,13 +108,20 @@ class SnowflakeDialect extends dialect_1.Dialect {
             .map(f => `${this.sqlLiteralString(f.rawName)}, (${f.sqlExpression})`)
             .join(', ');
     }
-    sqlAggregateTurtle(groupSet, fieldList, orderBy) {
+    sqlAggregateTurtle(groupSet, fieldList, orderBy, limit, filterSQL) {
         const fields = this.mapFieldsForObjectConstruct(fieldList);
         const orderByClause = orderBy
             ? ` WITHIN GROUP (${this.sqlTurtleOrderByClause(orderBy)})`
             : '';
-        const aggClause = `ARRAY_AGG(CASE WHEN group_set=${groupSet} THEN OBJECT_CONSTRUCT_KEEP_NULL(${fields}) END)${orderByClause}`;
-        return `COALESCE(${aggClause}, [])`;
+        const cond = (0, dialect_1.turtleGroupSetCondition)(groupSet, filterSQL);
+        const struct = `OBJECT_CONSTRUCT_KEEP_NULL(${fields})`;
+        const element = cond ? `CASE WHEN ${cond} THEN ${struct} END` : struct;
+        const aggClause = `ARRAY_AGG(${element})${orderByClause}`;
+        // ARRAY_SLICE is 0-based, end-exclusive, so (0, n) keeps the first n.
+        const limited = limit !== undefined
+            ? `ARRAY_SLICE(${aggClause}, 0, ${limit})`
+            : aggClause;
+        return `COALESCE(${limited}, [])`;
     }
     sqlAnyValueTurtle(groupSet, fieldList) {
         const fields = this.mapFieldsForObjectConstruct(fieldList);

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

@@ -25,6 +25,7 @@ export declare class StandardSQLDialect extends Dialect {
     supportsQualify: boolean;
     supportsSafeCast: boolean;
     supportsNesting: boolean;
+    supportsNestedProjectionLimit: boolean;
     cantPartitionWindowFunctionsOnExpressions: boolean;
     hasModOperator: boolean;
     sqlLateralJoinBag(expressions: LateralJoinExpression[]): string;
@@ -42,7 +43,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: CompiledOrderBy[] | undefined): string;
+    sqlAggregateTurtle(groupSet: number | undefined, fieldList: DialectFieldList, orderBy: CompiledOrderBy[] | undefined, limit?: number, filterSQL?: string): 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

@@ -77,6 +77,7 @@ class StandardSQLDialect extends dialect_1.Dialect {
         this.supportsQualify = true;
         this.supportsSafeCast = true;
         this.supportsNesting = true;
+        this.supportsNestedProjectionLimit = true;
         this.cantPartitionWindowFunctionsOnExpressions = true;
         this.hasModOperator = false;
         this.nestedArrays = false; // Can't have an array of arrays for some reason
@@ -147,12 +148,17 @@ 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) {
+    sqlAggregateTurtle(groupSet, fieldList, orderBy, limit, filterSQL) {
         const fields = fieldList
             .map(f => `\n  ${f.sqlExpression} as ${f.sqlOutputName}`)
             .join(', ');
         const orderByClause = orderBy ? this.sqlTurtleOrderByClause(orderBy) : '';
-        return `ARRAY_AGG(CASE WHEN group_set=${groupSet} THEN STRUCT(${fields}\n  ) END IGNORE NULLS ${orderByClause})`;
+        // BigQuery ARRAY_AGG takes LIMIT as its final sub-clause, after ORDER BY.
+        const limitClause = limit !== undefined ? ` LIMIT ${limit}` : '';
+        const cond = (0, dialect_1.turtleGroupSetCondition)(groupSet, filterSQL);
+        const struct = `STRUCT(${fields}\n  )`;
+        const element = cond ? `CASE WHEN ${cond} THEN ${struct} END` : struct;
+        return `ARRAY_AGG(${element} IGNORE NULLS ${orderByClause}${limitClause})`;
     }
     sqlAnyValueTurtle(groupSet, fieldList) {
         const fields = fieldList

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

@@ -22,6 +22,7 @@ export declare class TrinoDialect extends PostgresBase {
     supportsQualify: boolean;
     supportsSafeCast: boolean;
     supportsNesting: boolean;
+    supportsNestedProjectionLimit: boolean;
     cantPartitionWindowFunctionsOnExpressions: boolean;
     orderByClause: OrderByClauseType;
     nullMatchesFunctionSignature: boolean;
@@ -35,7 +36,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: CompiledOrderBy[] | undefined): string;
+    sqlAggregateTurtle(groupSet: number | undefined, fieldList: DialectFieldList, orderBy: CompiledOrderBy[] | undefined, limit?: number, filterSQL?: string): 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

@@ -8,6 +8,7 @@ exports.PrestoDialect = exports.TrinoDialect = void 0;
 const utils_1 = require("../../model/utils");
 const malloy_types_1 = require("../../model/malloy_types");
 const functions_1 = require("../functions");
+const dialect_1 = require("../dialect");
 const pg_impl_1 = require("../pg_impl");
 const dialect_functions_1 = require("./dialect_functions");
 const function_overrides_1 = require("./function_overrides");
@@ -76,6 +77,7 @@ class TrinoDialect extends pg_impl_1.PostgresBase {
         this.supportsQualify = true;
         this.supportsSafeCast = true;
         this.supportsNesting = true;
+        this.supportsNestedProjectionLimit = true;
         this.cantPartitionWindowFunctionsOnExpressions = false;
         this.orderByClause = 'output_name';
         this.nullMatchesFunctionSignature = false;
@@ -225,11 +227,15 @@ class TrinoDialect extends pg_impl_1.PostgresBase {
             .join(', \n');
     }
     // can array agg or any_value a struct...
-    sqlAggregateTurtle(groupSet, fieldList, orderBy) {
+    sqlAggregateTurtle(groupSet, fieldList, orderBy, limit, filterSQL) {
         const expressions = fieldList.map(f => f.sqlExpression).join(',\n ');
         const definitions = this.buildTypeExpression(fieldList);
         const orderByClause = orderBy ? this.sqlTurtleOrderByClause(orderBy) : '';
-        return `ARRAY_AGG(CAST(ROW(${expressions}) AS ROW(${definitions})) ${orderByClause}) FILTER (WHERE group_set=${groupSet})`;
+        const cond = (0, dialect_1.turtleGroupSetCondition)(groupSet, filterSQL);
+        const filterClause = cond ? ` FILTER (WHERE ${cond})` : '';
+        const arrayAgg = `ARRAY_AGG(CAST(ROW(${expressions}) AS ROW(${definitions})) ${orderByClause})${filterClause}`;
+        // SLICE(array, start, length) is 1-based; length n keeps the first n.
+        return limit !== undefined ? `SLICE(${arrayAgg}, 1, ${limit})` : arrayAgg;
     }
     sqlAnyValueTurtle(groupSet, fieldList) {
         const expressions = fieldList.map(f => f.sqlExpression).join(',\n ');

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

@@ -79,7 +79,15 @@ class DynamicSpace extends static_space_1.StaticSpace {
     }
     newEntry(name, logTo, entry) {
         if (this.entry(name)) {
-            logTo.logError('definition-name-conflict', `Cannot redefine '${name}'`);
+            if (this.isQueryFieldSpace() &&
+                this.outputSpace().synthesizedNames.has(name)) {
+                logTo.logError('definition-name-conflict', `Cannot redefine '${name}', which was auto-generated by renaming an ` +
+                    'ambiguous reference; name one of the conflicting references ' +
+                    "explicitly with 'is' to resolve this");
+            }
+            else {
+                logTo.logError('definition-name-conflict', `Cannot redefine '${name}'`);
+            }
             return;
         }
         this.setEntry(name, entry);
@@ -106,6 +114,10 @@ class DynamicSpace extends static_space_1.StaticSpace {
                 }
             }
             this.sourceDef = { ...this.fromSource, fields: [] };
+            // This is a freshly built (modified) source: it presents a new exported
+            // shape, so it is no longer a reference to the source it was built from.
+            // DefineSource resets referenceID to this source's own sourceID.
+            delete this.sourceDef.referenceID;
             this.sourceDef.parameters = parameters;
             const fieldIndices = new Map();
             // Need to process the entities in specific order
@@ -188,6 +200,7 @@ class DynamicSpace extends static_space_1.StaticSpace {
     emptyStructDef() {
         const ret = { ...this.fromSource };
         ret.fields = [];
+        delete ret.referenceID;
         return ret;
     }
 }

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

@@ -43,6 +43,7 @@ export declare abstract class QueryOperationSpace extends RefinedSpace implement
         name: string;
         field: SpaceField;
     })[];
+    synthesizedNames: Set<string>;
     private _refSummary;
     private _refSummaryComputed;
     get refSummary(): model.RefSummary | undefined;

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

@@ -80,6 +80,11 @@ class QueryOperationSpace extends refined_space_1.RefinedSpace {
         this.expandedWild = new Map();
         this.drillDimensions = [];
         this.compositeFieldUsers = [];
+        // Output names this space generated by auto-renaming an ambiguous reference
+        // (e.g. `user.name` -> `user_name`). Tracked here, on the namespace that
+        // minted them, rather than on the entries: a later explicit definition that
+        // lands on a synthesized name is a hard error, not a silent shadow.
+        this.synthesizedNames = new Set();
         // Reference summary is not computed until `queryFieldDefs` is called
         // (or `getPipeSegment` for index segments). Reading it before that throws;
         // assigning to it (via the setter) flips the computed flag.

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

@@ -1,19 +1,24 @@
 import type { AnnotationsDef, FieldDef, RefToField, TypeDesc } from '../../../model/malloy_types';
 import type { DynamicSpace } from '../field-space/dynamic-space';
 import { DefinitionList } from '../types/definition-list';
-import type { FieldName, FieldSpace } from '../types/field-space';
+import type { FieldSpace } from '../types/field-space';
+import { FieldName } from '../types/field-space';
 import type { LookupResult } from '../types/lookup-result';
 import { ListOf, MalloyElement } from '../types/malloy-element';
 import type { Noteable } from '../types/noteable';
 import { extendNoteMethod } from '../types/noteable';
 import type { MakeEntry } from '../types/space-entry';
+import type { FieldDeclarationConstructor } from './field-declaration';
+import { AggregateFieldDeclaration, CalculateFieldDeclaration, GroupByFieldDeclaration, ProjectFieldDeclaration } from './field-declaration';
 export type FieldReferenceConstructor = new (names: FieldName[]) => FieldReference;
 export declare abstract class FieldReference extends ListOf<FieldName> implements Noteable, MakeEntry {
     readonly isNoteableObj = true;
     note?: AnnotationsDef;
     extendNote: typeof extendNoteMethod;
     constructor(names: FieldName[]);
+    protected autoRenameDeclarationCtor(): FieldDeclarationConstructor | undefined;
     makeEntry(fs: DynamicSpace): void;
+    private autoRename;
     getName(): string;
     get refToField(): RefToField;
     get refString(): string;
@@ -58,6 +63,7 @@ export declare class DrillFieldReference extends FieldReference {
 }
 export declare class CalculateFieldReference extends FieldReference {
     elementType: string;
+    protected autoRenameDeclarationCtor(): typeof CalculateFieldDeclaration;
     typecheck(type: TypeDesc): void;
 }
 export declare class IndexFieldReference extends FieldReference {
@@ -68,14 +74,17 @@ export declare class IndexFieldReference extends FieldReference {
 }
 export declare class AggregateFieldReference extends FieldReference {
     elementType: string;
+    protected autoRenameDeclarationCtor(): typeof AggregateFieldDeclaration;
     typecheck(type: TypeDesc): void;
 }
 export declare class GroupByFieldReference extends FieldReference {
     elementType: string;
+    protected autoRenameDeclarationCtor(): typeof GroupByFieldDeclaration;
     typecheck(type: TypeDesc): void;
 }
 export declare class ProjectFieldReference extends FieldReference {
     elementType: string;
+    protected autoRenameDeclarationCtor(): typeof ProjectFieldDeclaration;
     typecheck(type: TypeDesc): void;
 }
 export declare class DeclareFieldReference extends FieldReference {