@malloydata/malloy 0.0.412 → 0.0.413

package/dist/model/field_instance.js

@@ -222,6 +222,15 @@ class FieldInstanceResult {
                         maxDepth = r.maxDepth;
                     }
                 }
+                else if (fir.firstSegment.type === 'project') {
+                    // A projection nest is grain-preserving (one array element per
+                    // in-scope row), so it rides on the enclosing scope's group_set
+                    // rather than getting its own. Without this it pins to group_set 0,
+                    // and inside a deeper nest its array-agg FILTER never lines up with
+                    // the enclosing group_set, producing empty arrays. (A first-stage
+                    // projection; any following stages recurse in their own scope.)
+                    fir.groupSet = this.groupSet;
+                }
             }
         }
         this.childGroups = children;

package/dist/model/nest-capability.d.ts

@@ -0,0 +1,37 @@
+import type { Dialect } from '../dialect/dialect';
+import type { PipeSegment } from './malloy_types';
+/**
+ * Why the compiler can't emit a segment for a dialect. The translator maps each
+ * reason to a located, user-facing message (these values are also parse-log
+ * codes); the compiler throws a `MalloyCompileError` with the reason.
+ */
+export type NestUnsupported = 'nesting-unsupported' | 'nested-multi-stage-unsupported' | 'nested-projection-limit-unsupported';
+/**
+ * How the compiler should emit one stage of a nest's pipeline — or, if the
+ * dialect can't, why not. This is THE single decision shared by the two callers
+ * that hold a dialect: the compiler (`generateTurtleSQL`) dispatches on `kind`
+ * and reads `limit`; the translator (`nest.ts`) turns `unsupported` into a
+ * located error. "How do I emit this" and "can I emit this" are one answer, so
+ * neither side can drift from the other.
+ *
+ * It is a *segment* question, not a pipeline one. The compiler compiles the
+ * first stage of a pipeline and recurses on the rest, so every stage is asked
+ * in turn as "the first stage" — pipeline length is irrelevant. `hasSuccessor`
+ * (is a stage materialized after this one?) is the only positional input, and
+ * it is what the multi-stage gate keys on.
+ *
+ * The dialect-free half of this — "is this stage an inline projection?" — is a
+ * plain `segment.type === 'project'`, used directly by the structural callers
+ * (group_set assignment, where-clause placement) that legitimately have no
+ * dialect; group_set numbering is not dialect-dependent.
+ */
+export type NestStrategy = {
+    kind: 'reduce';
+} | {
+    kind: 'project';
+    limit: number | undefined;
+} | {
+    kind: 'unsupported';
+    reason: NestUnsupported;
+};
+export declare function nestStrategy(segment: PipeSegment, dialect: Dialect, hasSuccessor: boolean): NestStrategy;

package/dist/model/nest-capability.js

@@ -0,0 +1,31 @@
+"use strict";
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nestStrategy = nestStrategy;
+const malloy_types_1 = require("./malloy_types");
+function nestStrategy(segment, dialect, hasSuccessor) {
+    if (!dialect.supportsNesting) {
+        return { kind: 'unsupported', reason: 'nesting-unsupported' };
+    }
+    // A stage with another stage after it must be materialized as a nested
+    // pipeline stage, which not every dialect can do inside a view.
+    if (hasSuccessor && !dialect.supportsPipelinesInViews) {
+        return { kind: 'unsupported', reason: 'nested-multi-stage-unsupported' };
+    }
+    if ((0, malloy_types_1.isProjectSegment)(segment)) {
+        // A projection applies `limit:` by slicing its aggregated array; some
+        // dialects can't slice an aggregate (see sqlAggregateTurtle).
+        if (segment.limit !== undefined && !dialect.supportsNestedProjectionLimit) {
+            return {
+                kind: 'unsupported',
+                reason: 'nested-projection-limit-unsupported',
+            };
+        }
+        return { kind: 'project', limit: segment.limit };
+    }
+    return { kind: 'reduce' };
+}
+//# sourceMappingURL=nest-capability.js.map

package/dist/model/query_query.d.ts

@@ -14,11 +14,14 @@ type StageGroupMaping = {
     fromGroup: number;
     toGroup: number;
 };
+interface StageOutputColumn {
+    sql: string;
+    name: string;
+    isDimension: boolean;
+}
 type StageOutputContext = {
-    sql: string[];
+    columns: StageOutputColumn[];
     lateralJoinSQLExpressions: LateralJoinExpression[];
-    dimensionIndexes: number[];
-    fieldIndex: number;
     groupsAggregated: StageGroupMaping[];
     outputPipelinedSQL: OutputPipelinedSQL[];
 };
@@ -89,7 +92,7 @@ export declare class QueryQuery extends QueryField {
     collectArrayJoins(ji: JoinInstance): JoinInstance[];
     genereateSQLOrderBy(queryDef: QuerySegment, resultStruct: FieldInstanceResult): string;
     generateSimpleSQL(stageWriter: StageWriter): string;
-    generatePipelinedStages(outputPipelinedSQL: OutputPipelinedSQL[], lastStageName: string, stageWriter: StageWriter): string;
+    generatePipelinedStages(outputPipelinedSQL: OutputPipelinedSQL[], lastStageName: string, stageWriter: StageWriter, priorStageColumns: StageOutputColumn[]): string;
     generateStage0Fields(resultSet: FieldInstanceResult, output: StageOutputContext, stageWriter: StageWriter): void;
     generateSQLWhereChildren(resultStruct: FieldInstanceResult): AndChain;
     generateSQLWhereTurtled(): string;

package/dist/model/query_query.js

@@ -14,9 +14,26 @@ const field_instance_1 = require("./field_instance");
 const sql_compiled_1 = require("./sql_compiled");
 const source_def_utils_1 = require("./source_def_utils");
 const malloy_compile_error_1 = require("./malloy_compile_error");
+const nest_capability_1 = require("./nest-capability");
 function pathToCol(path) {
     return path.map(el => encodeURIComponent(el)).join('/');
 }
+/**
+ * Is this result's row limit applied by the ROW_NUMBER "shave" in
+ * generateSQLHavingLimit? A nested projection's is not: its limit slices its
+ * array-agg (see sqlAggregateTurtle), because a projection has no group-by
+ * columns for the shave to partition and order on.
+ */
+function usesShaveLimit(result) {
+    if (result.getLimit() === undefined)
+        return false;
+    const isNestedProjection = result.parent !== undefined && result.firstSegment.type === 'project';
+    return !isNestedProjection;
+}
+// 1-based SELECT positions of the dimension columns, for `GROUP BY 1,2,...`.
+function groupByPositions(columns) {
+    return columns.flatMap((c, i) => (c.isDimension ? [i + 1] : []));
+}
 function pushDialectField(dl, f) {
     const { sqlExpression, sqlOutputName, rawName } = f;
     if ((0, malloy_types_1.isAtomic)(f.fieldDef)) {
@@ -925,25 +942,29 @@ class QueryQuery extends query_node_1.QueryField {
     }
     // This probably should be generated in a dialect independat way.
     //  but for now, it is just googleSQL.
-    generatePipelinedStages(outputPipelinedSQL, lastStageName, stageWriter) {
+    generatePipelinedStages(outputPipelinedSQL, lastStageName, stageWriter, 
+    // Every column `lastStageName` produces. The replaced turtle columns (in
+    // outputPipelinedSQL) are dropped and re-added by the pipeline expressions;
+    // everything else is carried through unchanged by its emitted name -- for a
+    // grouped stage that is the group-set-suffixed form (e.g. `f1__0`), not the
+    // final output name.
+    priorStageColumns) {
         if (outputPipelinedSQL.length === 0) {
             return lastStageName;
         }
+        const pipelinesSQL = outputPipelinedSQL
+            .map(o => `${o.pipelineSQL} as ${o.sqlFieldName}`)
+            .join(',\n');
         let retSQL;
         if (this.parent.dialect.supportsSelectReplace) {
-            const pipelinesSQL = outputPipelinedSQL
-                .map(o => `${o.pipelineSQL} as ${o.sqlFieldName}`)
-                .join(',\n');
             retSQL = `SELECT * replace (${pipelinesSQL}) FROM ${lastStageName}
         `;
         }
         else {
-            const pipelinesSQL = outputPipelinedSQL
-                .map(o => `${o.pipelineSQL} as ${o.sqlFieldName}`)
-                .join(',\n');
             const outputFields = outputPipelinedSQL.map(f => f.sqlFieldName);
-            const allFields = Array.from(this.rootResult.allFields.keys()).map(f => this.parent.dialect.sqlQuoteIdentifier(f));
-            const fields = allFields.filter(f => outputFields.indexOf(f) === -1);
+            const fields = priorStageColumns
+                .map(c => c.name)
+                .filter(name => outputFields.indexOf(name) === -1);
             retSQL = `SELECT ${fields.length > 0 ? fields.join(', ') + ',' : ''} ${pipelinesSQL} FROM ${lastStageName}`;
         }
         return stageWriter.addStage(retSQL);
@@ -978,12 +999,19 @@ class QueryQuery extends query_node_1.QueryField {
                                 sql: exp,
                                 name: outputName,
                             });
-                            output.sql.push(outputFieldName);
+                            output.columns.push({
+                                sql: outputFieldName,
+                                name: outputName,
+                                isDimension: true,
+                            });
                             if (fi.f.fieldDef.type === 'number') {
                                 const outputNameString = this.parent.dialect.sqlQuoteIdentifier(`${name}__${resultSet.groupSet}_string`);
                                 const outputFieldNameString = `__lateral_join_bag.${outputNameString}`;
-                                output.sql.push(outputFieldNameString);
-                                output.dimensionIndexes.push(output.fieldIndex++);
+                                output.columns.push({
+                                    sql: outputFieldNameString,
+                                    name: outputNameString,
+                                    isDimension: true,
+                                });
                                 output.lateralJoinSQLExpressions.push({
                                     sql: `CAST(${exp} as STRING)`,
                                     name: outputNameString,
@@ -993,13 +1021,19 @@ class QueryQuery extends query_node_1.QueryField {
                         }
                         else {
                             // just treat it like a regular field.
-                            output.sql.push(`${exp} as ${outputName}`);
+                            output.columns.push({
+                                sql: `${exp} as ${outputName}`,
+                                name: outputName,
+                                isDimension: true,
+                            });
                         }
-                        output.dimensionIndexes.push(output.fieldIndex++);
                     }
                     else if ((0, query_node_1.isBasicCalculation)(fi.f)) {
-                        output.sql.push(`${exp} as ${outputName}`);
-                        output.fieldIndex++;
+                        output.columns.push({
+                            sql: `${exp} as ${outputName}`,
+                            name: outputName,
+                            isDimension: false,
+                        });
                     }
                 }
             }
@@ -1009,8 +1043,11 @@ class QueryQuery extends query_node_1.QueryField {
                 }
                 else if (fi.firstSegment.type === 'project') {
                     const s = this.generateTurtleSQL(fi, stageWriter, outputName, output.outputPipelinedSQL);
-                    output.sql.push(`${s} as ${outputName}`);
-                    output.fieldIndex++;
+                    output.columns.push({
+                        sql: `${s} as ${outputName}`,
+                        name: outputName,
+                        isDimension: false,
+                    });
                 }
             }
         }
@@ -1028,8 +1065,11 @@ class QueryQuery extends query_node_1.QueryField {
             }
             else {
                 resultSet.hasHaving = true;
-                output.sql.push(`CASE WHEN group_set=${resultSet.groupSet} THEN CASE WHEN ${having.sql()} THEN 0 ELSE 1 END END as __delete__${resultSet.groupSet}`);
-                output.fieldIndex++;
+                output.columns.push({
+                    sql: `CASE WHEN group_set=${resultSet.groupSet} THEN CASE WHEN ${having.sql()} THEN 0 ELSE 1 END END as __delete__${resultSet.groupSet}`,
+                    name: `__delete__${resultSet.groupSet}`,
+                    isDimension: false,
+                });
             }
         }
     }
@@ -1038,11 +1078,18 @@ class QueryQuery extends query_node_1.QueryField {
         for (const [, field] of resultStruct.allFields) {
             if (field.type === 'query') {
                 const fir = field;
-                const turtleWhere = this.generateSQLFilters(fir, 'where');
-                if (turtleWhere.present()) {
-                    const groupSets = fir.childGroups.join(',');
-                    wheres.add(`(group_set NOT IN (${groupSets})` +
-                        ` OR (group_set IN (${groupSets}) AND ${turtleWhere.sql()}))`);
+                // A projection first stage's `where:` folds into its array-agg
+                // condition (see generateTurtleSQL / sqlAggregateTurtle), not a
+                // scan-level WHERE: it rides its enclosing group_set, so a WHERE here
+                // can't isolate it from the parent, and its childGroups is empty (no
+                // group_set of its own) which would emit a broken `group_set IN ()`.
+                if (fir.firstSegment.type !== 'project') {
+                    const turtleWhere = this.generateSQLFilters(fir, 'where');
+                    if (turtleWhere.present()) {
+                        const groupSets = fir.childGroups.join(',');
+                        wheres.add(`(group_set NOT IN (${groupSets})` +
+                            ` OR (group_set IN (${groupSets}) AND ${turtleWhere.sql()}))`);
+                    }
                 }
                 wheres.addChain(this.generateSQLWhereChildren(fir));
             }
@@ -1079,11 +1126,11 @@ class QueryQuery extends query_node_1.QueryField {
         const partitionSQL = [];
         let hasAnyLimits = false;
         let hasResultsWithChildren = false;
-        const resultsWithHavingOrLimit = this.rootResult.selectStructs([], (result) => result.hasHaving || result.getLimit() !== undefined);
+        const resultsWithHavingOrLimit = this.rootResult.selectStructs([], (result) => result.hasHaving || usesShaveLimit(result));
         if (resultsWithHavingOrLimit.length > 0) {
             // loop through an generate the partitions
             for (const result of this.rootResult.selectStructs([], (_result) => true)) {
-                const hasLimit = result.getLimit() !== undefined;
+                const hasLimit = usesShaveLimit(result);
                 hasResultsWithChildren || (hasResultsWithChildren = result.childGroups.length > 1 && (hasLimit || result.hasHaving));
                 hasAnyLimits || (hasAnyLimits = hasLimit);
                 // find all the parent dimension names.
@@ -1201,9 +1248,7 @@ class QueryQuery extends query_node_1.QueryField {
         let from = this.generateSQLJoins(stageWriter);
         const wheres = this.generateSQLWhereTurtled();
         const f = {
-            dimensionIndexes: [1],
-            fieldIndex: 2,
-            sql: ['group_set'],
+            columns: [{ sql: 'group_set', name: 'group_set', isDimension: true }],
             lateralJoinSQLExpressions: [],
             groupsAggregated: [],
             outputPipelinedSQL: [],
@@ -1213,9 +1258,9 @@ class QueryQuery extends query_node_1.QueryField {
             throw new malloy_compile_error_1.MalloyCompileError("Cannot use 'select:' in a stage that contains nested views. " +
                 'Use `group_by:` or restructure the pipeline.', 'compiler-project-with-turtles', this.fieldDef.location);
         }
-        const groupBy = 'GROUP BY ' + f.dimensionIndexes.join(',') + '\n';
+        const groupBy = 'GROUP BY ' + groupByPositions(f.columns).join(',') + '\n';
         from += this.parent.dialect.sqlGroupSetTable(this.maxGroupSet) + '\n';
-        s += (0, utils_1.indent)(f.sql.join(',\n')) + '\n';
+        s += (0, utils_1.indent)(f.columns.map(c => c.sql).join(',\n')) + '\n';
         if (f.lateralJoinSQLExpressions.length > 0) {
             from += this.parent.dialect.sqlLateralJoinBag(f.lateralJoinSQLExpressions);
         }
@@ -1224,7 +1269,7 @@ class QueryQuery extends query_node_1.QueryField {
         const resultStage = stageWriter.addStage(s);
         // generate stages for havings and limits
         this.resultStage = this.generateSQLHavingLimit(stageWriter, resultStage);
-        this.resultStage = this.generatePipelinedStages(f.outputPipelinedSQL, this.resultStage, stageWriter);
+        this.resultStage = this.generatePipelinedStages(f.outputPipelinedSQL, this.resultStage, stageWriter, f.columns);
         return this.resultStage;
     }
     generateDepthNFields(depth, resultSet, output, stageWriter) {
@@ -1235,13 +1280,19 @@ class QueryQuery extends query_node_1.QueryField {
                 if (fi.fieldUsage.type === 'result') {
                     if ((0, query_node_1.isScalarField)(fi.f)) {
                         const exp = (0, utils_1.caseGroup)(resultSet.groupSet > 0 ? resultSet.childGroups : [], sqlFieldName);
-                        output.sql.push(`${exp} as ${sqlFieldName}`);
-                        output.dimensionIndexes.push(output.fieldIndex++);
+                        output.columns.push({
+                            sql: `${exp} as ${sqlFieldName}`,
+                            name: sqlFieldName,
+                            isDimension: true,
+                        });
                     }
                     else if ((0, query_node_1.isBasicCalculation)(fi.f)) {
                         const exp = this.parent.dialect.sqlAnyValue(resultSet.groupSet, sqlFieldName);
-                        output.sql.push(`${exp} as ${sqlFieldName}`);
-                        output.fieldIndex++;
+                        output.columns.push({
+                            sql: `${exp} as ${sqlFieldName}`,
+                            name: sqlFieldName,
+                            isDimension: false,
+                        });
                     }
                 }
             }
@@ -1256,8 +1307,11 @@ class QueryQuery extends query_node_1.QueryField {
                         toGroup: resultSet.groupSet,
                     });
                     groupsToMap.push(fi.groupSet);
-                    output.sql.push(`${s} as ${sqlFieldName}`);
-                    output.fieldIndex++;
+                    output.columns.push({
+                        sql: `${s} as ${sqlFieldName}`,
+                        name: sqlFieldName,
+                        isDimension: false,
+                    });
                 }
                 else {
                     this.generateDepthNFields(depth, fi, output, stageWriter);
@@ -1267,14 +1321,19 @@ class QueryQuery extends query_node_1.QueryField {
         if (output.groupsAggregated.length > 0) {
             if (!this.parent.dialect.hasLateralColumnAliasInSelect) {
                 // Safe to remap in-place; aggregate expressions won't see the alias.
-                // This runs on every recursive return but sql[0] replacement is
+                // This runs on every recursive return but column[0] replacement is
                 // idempotent — last call builds the full CASE from all accumulated
-                // groupsAggregated entries.
-                output.sql[0] = 'CASE ';
+                // groupsAggregated entries. The output is still named group_set.
+                let groupSetSQL = 'CASE ';
                 for (const m of output.groupsAggregated) {
-                    output.sql[0] += `WHEN group_set=${m.fromGroup} THEN ${m.toGroup} `;
+                    groupSetSQL += `WHEN group_set=${m.fromGroup} THEN ${m.toGroup} `;
                 }
-                output.sql[0] += 'ELSE group_set END as group_set';
+                groupSetSQL += 'ELSE group_set END as group_set';
+                output.columns[0] = {
+                    sql: groupSetSQL,
+                    name: 'group_set',
+                    isDimension: true,
+                };
             }
             // For hasLateralColumnAliasInSelect, the remap is handled in
             // generateSQLDepthN to avoid adding it multiple times from recursion.
@@ -1283,88 +1342,100 @@ class QueryQuery extends query_node_1.QueryField {
     generateSQLDepthN(depth, stageWriter, stageName) {
         let s = 'SELECT \n';
         const f = {
-            dimensionIndexes: [1],
-            fieldIndex: 2,
-            sql: ['group_set'],
+            columns: [{ sql: 'group_set', name: 'group_set', isDimension: true }],
             lateralJoinSQLExpressions: [],
             groupsAggregated: [],
             outputPipelinedSQL: [],
         };
         this.generateDepthNFields(depth, this.rootResult, f, stageWriter);
         // When column aliases are visible in the same SELECT (e.g. Databricks),
-        // replace sql[0] with the remap CASE aliased as __remapped_group_set
-        // (not group_set). This avoids shadowing the input group_set column
-        // that aggregate expressions reference. GROUP BY still uses position 1
-        // (the remapped value), so rows with different original group_sets
-        // collapse correctly. A follow-up CTE renames it to group_set.
+        // replace column[0]'s SQL with the remap CASE aliased as
+        // __remapped_group_set (not group_set). This avoids shadowing the input
+        // group_set column that aggregate expressions reference. GROUP BY still
+        // uses position 1 (the remapped value), so rows with different original
+        // group_sets collapse correctly. A follow-up CTE renames it back, so the
+        // column's carried-forward name stays group_set.
         const needsRemapStage = f.groupsAggregated.length > 0 &&
             this.parent.dialect.hasLateralColumnAliasInSelect;
         if (needsRemapStage) {
-            f.sql[0] = 'CASE ';
+            let groupSetSQL = 'CASE ';
             for (const m of f.groupsAggregated) {
-                f.sql[0] += `WHEN group_set=${m.fromGroup} THEN ${m.toGroup} `;
+                groupSetSQL += `WHEN group_set=${m.fromGroup} THEN ${m.toGroup} `;
             }
-            f.sql[0] += 'ELSE group_set END as __remapped_group_set';
+            groupSetSQL += 'ELSE group_set END as __remapped_group_set';
+            f.columns[0] = { sql: groupSetSQL, name: 'group_set', isDimension: true };
         }
-        s += (0, utils_1.indent)(f.sql.join(',\n')) + '\n';
+        s += (0, utils_1.indent)(f.columns.map(c => c.sql).join(',\n')) + '\n';
         s += `FROM ${stageName}\n`;
         const where = this.rootResult.eliminateComputeGroupsSQL();
         if (where.length > 0) {
             s += `WHERE ${where}\n`;
         }
-        if (f.dimensionIndexes.length > 0) {
-            s += `GROUP BY ${f.dimensionIndexes.join(',')}\n`;
+        const dimensionPositions = groupByPositions(f.columns);
+        if (dimensionPositions.length > 0) {
+            s += `GROUP BY ${dimensionPositions.join(',')}\n`;
         }
         this.resultStage = stageWriter.addStage(s);
         if (needsRemapStage) {
-            const cols = f.sql.slice(1).map(col => {
-                const asMatch = col.match(/as\s+(\S+)\s*$/i);
-                return asMatch ? asMatch[1] : '*';
-            });
+            const cols = f.columns.slice(1).map(c => c.name);
             const remapSQL = `SELECT \n${(0, utils_1.indent)(['__remapped_group_set as group_set', ...cols].join(',\n'))}\nFROM ${this.resultStage}\n`;
             this.resultStage = stageWriter.addStage(remapSQL);
         }
-        this.resultStage = this.generatePipelinedStages(f.outputPipelinedSQL, this.resultStage, stageWriter);
+        this.resultStage = this.generatePipelinedStages(f.outputPipelinedSQL, this.resultStage, stageWriter, f.columns);
         return this.resultStage;
     }
     genereateSQLCombineTurtles(stageWriter, stage0Name) {
         let s = 'SELECT\n';
-        const fieldsSQL = [];
-        let fieldIndex = 1;
+        // Columns this combine stage emits. Unlike the grouped stages above, these
+        // are the final output names (unsuffixed), not the group-set-suffixed form.
+        // A following pipelined stage carries them forward by name.
+        const columns = [];
         const outputPipelinedSQL = [];
-        const dimensionIndexes = [];
         for (const [name, fi] of this.rootResult.allFields) {
             const sqlName = this.parent.dialect.sqlQuoteIdentifier(name);
             if (fi instanceof field_instance_1.FieldInstanceField) {
                 if (fi.fieldUsage.type === 'result') {
                     if ((0, query_node_1.isScalarField)(fi.f)) {
-                        fieldsSQL.push(this.parent.dialect.sqlQuoteIdentifier(`${name}__${this.rootResult.groupSet}`) + ` as ${sqlName}`);
-                        dimensionIndexes.push(fieldIndex++);
+                        columns.push({
+                            sql: this.parent.dialect.sqlQuoteIdentifier(`${name}__${this.rootResult.groupSet}`) + ` as ${sqlName}`,
+                            name: sqlName,
+                            isDimension: true,
+                        });
                     }
                     else if ((0, query_node_1.isBasicCalculation)(fi.f)) {
-                        fieldsSQL.push(this.parent.dialect.sqlAnyValueLastTurtle(this.parent.dialect.sqlQuoteIdentifier(`${name}__${this.rootResult.groupSet}`), this.rootResult.groupSet, sqlName));
-                        fieldIndex++;
+                        columns.push({
+                            sql: this.parent.dialect.sqlAnyValueLastTurtle(this.parent.dialect.sqlQuoteIdentifier(`${name}__${this.rootResult.groupSet}`), this.rootResult.groupSet, sqlName),
+                            name: sqlName,
+                            isDimension: false,
+                        });
                     }
                 }
             }
             else if (fi instanceof field_instance_1.FieldInstanceResult) {
                 if (fi.firstSegment.type === 'reduce') {
-                    fieldsSQL.push(`${this.generateTurtleSQL(fi, stageWriter, sqlName, outputPipelinedSQL)} as ${sqlName}`);
-                    fieldIndex++;
+                    columns.push({
+                        sql: `${this.generateTurtleSQL(fi, stageWriter, sqlName, outputPipelinedSQL)} as ${sqlName}`,
+                        name: sqlName,
+                        isDimension: false,
+                    });
                 }
                 else if (fi.firstSegment.type === 'project') {
-                    fieldsSQL.push(this.parent.dialect.sqlAnyValueLastTurtle(this.parent.dialect.sqlQuoteIdentifier(`${name}__${this.rootResult.groupSet}`), this.rootResult.groupSet, sqlName));
-                    fieldIndex++;
+                    columns.push({
+                        sql: this.parent.dialect.sqlAnyValueLastTurtle(this.parent.dialect.sqlQuoteIdentifier(`${name}__${this.rootResult.groupSet}`), this.rootResult.groupSet, sqlName),
+                        name: sqlName,
+                        isDimension: false,
+                    });
                 }
             }
         }
-        s += (0, utils_1.indent)(fieldsSQL.join(',\n')) + `\nFROM ${stage0Name}\n`;
+        s += (0, utils_1.indent)(columns.map(c => c.sql).join(',\n')) + `\nFROM ${stage0Name}\n`;
         const where = this.rootResult.eliminateComputeGroupsSQL();
         if (where.length > 0) {
             s += `WHERE ${where}\n`;
         }
-        if (dimensionIndexes.length > 0) {
-            s += `GROUP BY ${dimensionIndexes.join(',')}\n`;
+        const dimensionPositions = groupByPositions(columns);
+        if (dimensionPositions.length > 0) {
+            s += `GROUP BY ${dimensionPositions.join(',')}\n`;
         }
         // order by
         s += this.genereateSQLOrderBy(this.firstSegment, this.rootResult);
@@ -1373,7 +1444,7 @@ class QueryQuery extends query_node_1.QueryField {
             s += `LIMIT ${this.firstSegment.limit}\n`;
         }
         this.resultStage = stageWriter.addStage(s);
-        this.resultStage = this.generatePipelinedStages(outputPipelinedSQL, this.resultStage, stageWriter);
+        this.resultStage = this.generatePipelinedStages(outputPipelinedSQL, this.resultStage, stageWriter, columns);
         return this.resultStage;
     }
     // create a simplified version of the StructDef for dialects.
@@ -1439,6 +1510,15 @@ class QueryQuery extends query_node_1.QueryField {
         return dialectFieldList;
     }
     generateTurtleSQL(resultStruct, stageWriter, sqlFieldName, outputPipelinedSQL) {
+        // How to emit this nest's first stage — and the last line of defense before
+        // broken SQL for IR that didn't pass through the translator (cached,
+        // deserialized, or query-builder IR). Same `nestStrategy` the translator
+        // uses, so the two can't disagree.
+        const pipeline = resultStruct.turtleDef.pipeline;
+        const strategy = (0, nest_capability_1.nestStrategy)(pipeline[0], this.parent.dialect, pipeline.length > 1);
+        if (strategy.kind === 'unsupported') {
+            throw new malloy_compile_error_1.MalloyCompileError(`dialect '${this.parent.dialect.name}' cannot emit this nested query (${strategy.reason})`, strategy.reason, resultStruct.turtleDef.location);
+        }
         // calculate the ordering.
         const compiledOrderBy = [];
         let orderingField;
@@ -1483,7 +1563,24 @@ class QueryQuery extends query_node_1.QueryField {
             }
         }
         else {
-            ret = this.parent.dialect.sqlAggregateTurtle(resultStruct.groupSet, dialectFieldList, orderBy);
+            // A projection first stage applies its own `limit:` by slicing the
+            // array-agg (it has no group-by keys to ROW_NUMBER-shave on) and its
+            // `where:` by folding into the array-agg's group_set condition (it rides
+            // the enclosing group_set, so a scan-level WHERE can't isolate it). This
+            // is a first-stage question: if more stages follow, they consume this
+            // (limited/filtered) array via the recursion in generateTurtlePipelineSQL.
+            // A reduce first stage keeps the shave and the scan-level WHERE.
+            let limit;
+            let filterSQL;
+            if (strategy.kind === 'project') {
+                limit = strategy.limit;
+                const where = this.generateSQLFilters(resultStruct, 'where');
+                if (where.present()) {
+                    filterSQL = where.sql();
+                }
+            }
+            // (capability is guarded by nestStrategy at the top of this method)
+            ret = this.parent.dialect.sqlAggregateTurtle(resultStruct.groupSet, dialectFieldList, orderBy, limit, filterSQL);
         }
         // If the turtle is a pipeline, generate a UDF to compute it.
         const newStageWriter = new stage_writer_1.StageWriter(this.parent.dialect.supportsCTEinCoorelatedSubQueries, stageWriter);

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const MALLOY_VERSION = "0.0.412";
+export declare const MALLOY_VERSION = "0.0.413";

package/dist/version.js

@@ -2,5 +2,5 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MALLOY_VERSION = void 0;
 // generated with 'generate-version-file' script; do not edit manually
-exports.MALLOY_VERSION = '0.0.412';
+exports.MALLOY_VERSION = '0.0.413';
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/malloy",
-  "version": "0.0.412",
+  "version": "0.0.413",
   "license": "MIT",
   "exports": {
     ".": "./dist/index.js",
@@ -51,9 +51,9 @@
     "generate-version-file": "VERSION=$(npm pkg get version --workspaces=false | tr -d \\\")\necho \"// generated with 'generate-version-file' script; do not edit manually\\nexport const MALLOY_VERSION = '$VERSION';\" > src/version.ts"
   },
   "dependencies": {
-    "@malloydata/malloy-filter": "0.0.412",
-    "@malloydata/malloy-interfaces": "0.0.412",
-    "@malloydata/malloy-tag": "0.0.412",
+    "@malloydata/malloy-filter": "0.0.413",
+    "@malloydata/malloy-interfaces": "0.0.413",
+    "@malloydata/malloy-tag": "0.0.413",
     "@noble/hashes": "^1.8.0",
     "antlr4ts": "^0.5.0-alpha.4",
     "assert": "^2.0.0",