@malloydata/malloy 0.0.412 → 0.0.413

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, 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,17 @@ 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 filter = filterSQL ? ` AND ${filterSQL}` : '';
+        const collectExpr = `COLLECT_LIST(${namedStruct}) FILTER (WHERE group_set=${groupSet}${filter})`;
+        // 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

@@ -99,6 +99,7 @@ export declare abstract class Dialect {
     cantPartitionWindowFunctionsOnExpressions: boolean;
     sqlLateralJoinBag(_expressions: LateralJoinExpression[]): string;
     supportsPipelinesInViews: boolean;
+    supportsNestedProjectionLimit: boolean;
     supportsArraysInData: boolean;
     hasTimestamptz: boolean;
     readsNestedData: boolean;
@@ -175,7 +176,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, 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

@@ -73,6 +73,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, 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,17 @@ 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 filter = filterSQL ? ` AND ${filterSQL}` : '';
+        const list = `LIST({${fields}} ${orderByClause}) FILTER (WHERE group_set=${groupSet}${filter})`;
+        // 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, 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,11 +161,12 @@ 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) : '';
+        const filter = filterSQL ? ` AND ${filterSQL}` : '';
         let gc = `GROUP_CONCAT(
-      IF(group_set=${groupSet},
+      IF(group_set=${groupSet}${filter},
         JSON_OBJECT(${this.mapFields(fieldList)})
         , null
         )

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, 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,15 @@ 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 filter = filterSQL ? ` AND ${filterSQL}` : '';
+        const arrayAgg = `(ARRAY_AGG((SELECT TO_JSONB(__x) FROM (SELECT ${fields}\n  ) as __x) ${orderByClause} ) FILTER (WHERE group_set=${groupSet}${filter}))`;
+        // 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, 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,18 @@ 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 filter = filterSQL ? ` AND ${filterSQL}` : '';
+        const aggClause = `ARRAY_AGG(CASE WHEN group_set=${groupSet}${filter} THEN OBJECT_CONSTRUCT_KEEP_NULL(${fields}) END)${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, 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,15 @@ 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 filter = filterSQL ? ` AND ${filterSQL}` : '';
+        return `ARRAY_AGG(CASE WHEN group_set=${groupSet}${filter} THEN STRUCT(${fields}\n  ) END 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, 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

@@ -76,6 +76,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 +226,14 @@ 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 filter = filterSQL ? ` AND ${filterSQL}` : '';
+        const arrayAgg = `ARRAY_AGG(CAST(ROW(${expressions}) AS ROW(${definitions})) ${orderByClause}) FILTER (WHERE group_set=${groupSet}${filter})`;
+        // 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);

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 {

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

@@ -7,8 +7,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.FieldReferences = exports.WildcardFieldReference = exports.ViewOrScalarFieldReference = exports.DimensionFieldReference = exports.MeasureFieldReference = exports.DeclareFieldReference = exports.ProjectFieldReference = exports.GroupByFieldReference = exports.AggregateFieldReference = exports.IndexFieldReference = exports.CalculateFieldReference = exports.DrillFieldReference = exports.ParameterFieldReference = exports.GroupedByReference = exports.PartitionByFieldReference = exports.RefineFromFieldReference = exports.ExpressionFieldReference = exports.AccessModifierFieldReference = exports.AcceptExceptFieldReference = exports.FieldReference = void 0;
 const reference_field_1 = require("../field-space/reference-field");
 const definition_list_1 = require("../types/definition-list");
+const field_space_1 = require("../types/field-space");
 const malloy_element_1 = require("../types/malloy-element");
 const noteable_1 = require("../types/noteable");
+const expr_id_reference_1 = require("../expressions/expr-id-reference");
+const field_declaration_1 = require("./field-declaration");
 const typecheck_utils_1 = require("./typecheck_utils");
 class FieldReference extends malloy_element_1.ListOf {
     constructor(names) {
@@ -16,16 +19,64 @@ class FieldReference extends malloy_element_1.ListOf {
         this.isNoteableObj = true;
         this.extendNote = noteable_1.extendNoteMethod;
     }
+    // The `name is path` declaration constructor used to auto-resolve an output
+    // name collision for this kind of reference, or undefined if this reference
+    // does not produce an output column named for its last path element (e.g.
+    // index references, view references). Overridden by the references that do.
+    autoRenameDeclarationCtor() {
+        return undefined;
+    }
     makeEntry(fs) {
         const refName = this.outputName;
-        if (fs.entry(refName)) {
-            this.logError('output-name-conflict', `Output already has a field named '${refName}'`);
-        }
-        else {
+        if (fs.entry(refName) === undefined) {
             // In a QuerySpace, this needs to be able to find the thing to which it refers
             const fromFS = fs.isQueryFieldSpace() ? fs.inputSpace() : fs;
             fs.newEntry(refName, this, new reference_field_1.ReferenceField(this, fromFS));
+            return;
         }
+        // The natural (last-segment) name is taken. A dotted reference can be
+        // auto-renamed using its full path; a single-name reference has no prefix
+        // to disambiguate with, so it stays a hard error.
+        const declCtor = this.autoRenameDeclarationCtor();
+        if (declCtor && this.list.length > 1 && fs.isQueryFieldSpace()) {
+            this.autoRename(fs, fs.outputSpace().synthesizedNames, declCtor, refName);
+            return;
+        }
+        if (fs.isQueryFieldSpace() &&
+            fs.outputSpace().synthesizedNames.has(refName)) {
+            this.logError('output-name-conflict', `Output already has a field named '${refName}', which was ` +
+                'auto-generated by renaming an ambiguous reference; name one of the ' +
+                "conflicting references explicitly with 'is' to resolve this");
+        }
+        else {
+            this.logError('output-name-conflict', `Output already has a field named '${refName}'`);
+        }
+    }
+    // Rewrite `path.to.field` into the equivalent `autoName is path.to.field`
+    // declaration — the same AST the user would write to fix it by hand — and
+    // let its normal makeEntry produce the (renamed) output field.
+    autoRename(fs, synthesizedNames, declCtor, refName) {
+        // `path.join('_')`, then `_2`, `_3`, ... until free. The synthetic name
+        // yields to whatever is already in the output, so a user-written name wins.
+        const base = this.path.join('_');
+        let autoName = base;
+        let n = 2;
+        while (fs.entry(autoName) !== undefined) {
+            autoName = `${base}_${n++}`;
+        }
+        synthesizedNames.add(autoName);
+        this.logWarning('output-field-auto-renamed', `Output already has a field named '${refName}', so '${this.refString}' ` +
+            `was renamed to '${autoName}'. Write '${autoName} is ${this.refString}' ` +
+            'to set the name explicitly and silence this warning.');
+        const renamedRef = new ExpressionFieldReference(this.list.map(n => new field_space_1.FieldName(n.refString)));
+        const decl = new declCtor(new expr_id_reference_1.ExprIdReference(renamedRef), autoName);
+        if (this.note) {
+            decl.note = this.note;
+        }
+        // Attach under this reference so the synthetic nodes inherit its location
+        // and resolve back to the translator for logging.
+        this.has({ autoRenamed: decl });
+        decl.makeEntry(fs);
     }
     getName() {
         return this.nameString;
@@ -161,6 +212,9 @@ class CalculateFieldReference extends FieldReference {
         super(...arguments);
         this.elementType = 'calculateFieldReference';
     }
+    autoRenameDeclarationCtor() {
+        return field_declaration_1.CalculateFieldDeclaration;
+    }
     typecheck(type) {
         (0, typecheck_utils_1.typecheckCalculate)(type, this);
     }
@@ -188,6 +242,9 @@ class AggregateFieldReference extends FieldReference {
         super(...arguments);
         this.elementType = 'aggregateFieldReference';
     }
+    autoRenameDeclarationCtor() {
+        return field_declaration_1.AggregateFieldDeclaration;
+    }
     typecheck(type) {
         (0, typecheck_utils_1.typecheckAggregate)(type, this);
     }
@@ -198,6 +255,9 @@ class GroupByFieldReference extends FieldReference {
         super(...arguments);
         this.elementType = 'groupByFieldReference';
     }
+    autoRenameDeclarationCtor() {
+        return field_declaration_1.GroupByFieldDeclaration;
+    }
     typecheck(type) {
         (0, typecheck_utils_1.typecheckGroupBy)(type, this);
     }
@@ -208,6 +268,9 @@ class ProjectFieldReference extends FieldReference {
         super(...arguments);
         this.elementType = 'projectFieldReference';
     }
+    autoRenameDeclarationCtor() {
+        return field_declaration_1.ProjectFieldDeclaration;
+    }
     typecheck(type) {
         (0, typecheck_utils_1.typecheckProject)(type, this);
     }

package/dist/lang/ast/query-properties/nest.js

@@ -39,6 +39,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NestFieldDeclaration = void 0;
 const model = __importStar(require("../../../model/malloy_types"));
+const nest_capability_1 = require("../../../model/nest-capability");
 const query_utils_1 = require("../query-utils");
 const view_field_declaration_1 = require("../source-properties/view-field-declaration");
 const query_property_interface_1 = require("../types/query-property-interface");
@@ -63,6 +64,20 @@ class NestFieldDeclaration extends view_field_declaration_1.ViewFieldDeclaration
                 ? pipeline[0].refSummary
                 : undefined;
             const checkedPipeline = (0, query_utils_1.detectAndRemovePartialStages)(pipeline, this);
+            // Reject — at translate time, with a located message — any stage of this
+            // nest the compiler can't emit for this dialect, rather than producing
+            // broken SQL. The compiler asks segment-at-a-time as it recurses; the
+            // translator holds the whole pipeline, so it asks every stage.
+            const dialect = fs.dialectObj();
+            if (dialect) {
+                for (let i = 0; i < checkedPipeline.length; i++) {
+                    const strategy = (0, nest_capability_1.nestStrategy)(checkedPipeline[i], dialect, i < checkedPipeline.length - 1);
+                    if (strategy.kind === 'unsupported') {
+                        this.logError(strategy.reason, { dialect: dialect.name });
+                        break;
+                    }
+                }
+            }
             const pipelineWithDrillPaths = (0, drill_1.attachDrillPaths)(checkedPipeline, this.name);
             this.turtleDef = {
                 type: 'turtle',

package/dist/lang/parse-log.d.ts

@@ -61,6 +61,15 @@ type MessageParameterTypes = {
     'experimental-dialect-not-enabled': {
         dialect: string;
     };
+    'nesting-unsupported': {
+        dialect: string;
+    };
+    'nested-multi-stage-unsupported': {
+        dialect: string;
+    };
+    'nested-projection-limit-unsupported': {
+        dialect: string;
+    };
     'sql-native-not-allowed-in-expression': {
         rawType: string | undefined;
     };
@@ -185,6 +194,7 @@ type MessageParameterTypes = {
     'invalid-type-for-field-definition': string;
     'circular-reference-in-field-definition': string;
     'output-name-conflict': string;
+    'output-field-auto-renamed': string;
     'select-of-view': string;
     'select-of-analytic': string;
     'select-of-aggregate': string;

package/dist/lang/parse-log.js

@@ -55,6 +55,9 @@ exports.MESSAGE_FORMATTERS = {
         tag: 'pick-values-must-match',
     }),
     'experimental-dialect-not-enabled': e => `Requires compiler flag '##! experimental.dialect.${e.dialect}'`,
+    'nesting-unsupported': e => `'${e.dialect}' does not support nested queries`,
+    'nested-multi-stage-unsupported': e => `'${e.dialect}' does not support a multi-stage pipeline ('->') in a nested query`,
+    'nested-projection-limit-unsupported': e => `'${e.dialect}' does not support 'limit:' on a nested 'select:'`,
     'pick-missing-else': "pick incomplete, missing 'else'",
     'pick-missing-value': 'pick with no value can only be used with apply',
     'pick-illegal-partial': 'pick with partial when can only be used with apply',