@malloydata/malloy 0.0.412 → 0.0.414

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/ast/source-elements/named-source.js

@@ -91,7 +91,10 @@ class NamedSource extends source_1.Source {
         else {
             (_a = this.document()) === null || _a === void 0 ? void 0 : _a.checkExperimentalDialect(this, entry.dialect);
             if ((0, malloy_types_1.isSourceDef)(entry)) {
-                return { ...entry };
+                // This struct is created as an unmodified reference to `entry`. Mark it
+                // with entry's own identity; the modification path (DynamicSpace) clears
+                // this so only true references carry a referenceID.
+                return { ...entry, referenceID: entry.sourceID };
             }
         }
         // I think this is now a never

package/dist/lang/ast/statements/define-source.js

@@ -58,9 +58,16 @@ class DefineSource extends malloy_element_1.MalloyElement {
                 }
                 : { ...this.note };
         }
-        if ((0, malloy_types_1.isPersistableSourceDef)(entry)) {
+        if ((0, malloy_types_1.isSourceDef)(entry)) {
+            // Every source gets a stable identity for its own definition. referenceID
+            // is left as it arrived: set to the referenced source's sourceID for an
+            // unmodified rename (`source: a is b`), and absent for a source that
+            // defines its own shape (table/sql/query, or a modified/extended source,
+            // which DynamicSpace cleared).
             entry.sourceID = (0, source_def_utils_1.mkSourceID)(this.name, (_b = this.location) === null || _b === void 0 ? void 0 : _b.url);
-            entry.persistent = (0, persist_utils_1.checkPersistAnnotation)(entry).persist;
+            if ((0, malloy_types_1.isPersistableSourceDef)(entry)) {
+                entry.persistent = (0, persist_utils_1.checkPersistAnnotation)(entry).persist;
+            }
         }
         entry.partitionComposite =
             (_d = (0, composite_source_utils_1.getPartitionCompositeDesc)(this.note, structDef, (_c = this.sourceExpr) !== null && _c !== void 0 ? _c : this)) !== null && _d !== void 0 ? _d : structDef.partitionComposite;

package/dist/lang/ast/types/malloy-element.js

@@ -665,10 +665,9 @@ class Document extends MalloyElement {
             this.modelWasModified = true;
         }
         this.documentModel.set(str, ent);
-        // Maintain sourceRegistry for persistable sources with sourceID
-        if ((0, malloy_types_1.isSourceDef)(ent.entry) &&
-            (0, malloy_types_1.isPersistableSourceDef)(ent.entry) &&
-            ent.entry.sourceID) {
+        // Maintain the source-id table so sourceID/referenceID values resolve to
+        // their SourceDef. Every named source is registered by its sourceID.
+        if ((0, malloy_types_1.isSourceDef)(ent.entry) && ent.entry.sourceID) {
             this.documentSrcRegistry[ent.entry.sourceID] = {
                 entry: {
                     type: 'source_registry_reference',

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',

package/dist/model/expression_compiler.js

@@ -143,7 +143,7 @@ function compileExpr(resultSet, context, expr, state = new utils_1.GenerateState
                 else {
                     throw new Error(`Internal Error: Unknown aggregate function ${expr.function}`);
                 }
-                if (resultSet.root().isComplexQuery) {
+                if (resultSet.root().isComplexQuery && resultSet.root().emitsGroupSet) {
                     let groupSet = resultSet.groupSet;
                     if (state.totalGroupSet !== -1) {
                         groupSet = state.totalGroupSet;
@@ -411,7 +411,7 @@ function generateAsymmetricStringAggExpression(resultSet, context, value, separa
     return context.dialect.sqlStringAggDistinct(distinctKey, valueSQL, separatorSQL);
 }
 function generateAnalyticFragment(dialect, resultStruct, context, expr, overload, state, args, partitionByFields, funcOrdering) {
-    const isComplex = resultStruct.root().isComplexQuery;
+    const isComplex = resultStruct.root().isComplexQuery && resultStruct.root().emitsGroupSet;
     const partitionFields = getAnalyticPartitions(resultStruct, partitionByFields);
     const allPartitions = [
         ...(isComplex ? ['group_set'] : []),

package/dist/model/field_instance.d.ts

@@ -96,6 +96,7 @@ export declare class FieldInstanceResultRoot extends FieldInstanceResult {
     joins: Map<string, JoinInstance>;
     havings: AndChain;
     isComplexQuery: boolean;
+    emitsGroupSet: boolean;
     queryUsesPartitioning: boolean;
     computeOnlyGroups: number[];
     elimatedComputeGroups: boolean;

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;
@@ -401,6 +410,11 @@ class FieldInstanceResultRoot extends FieldInstanceResult {
         this.joins = new Map();
         this.havings = new utils_1.AndChain();
         this.isComplexQuery = false;
+        // True when the query emits a `group_set` column to demux fanned-out rows
+        // (the general path). The single-group-set fast path (generateSingleGroupSetSQL)
+        // sets this false: there is no group_set column, so aggregate and window
+        // expressions must not wrap themselves in `CASE WHEN group_set=N`.
+        this.emitsGroupSet = true;
         this.queryUsesPartitioning = false;
         this.computeOnlyGroups = [];
         this.elimatedComputeGroups = false;

package/dist/model/index.d.ts

@@ -9,4 +9,5 @@ export { getModelAnnotations } from './annotation_utils';
 export { constantExprToSQL } from './constant_expression_compiler';
 export { getCompiledSQL } from './sql_compiled';
 export { MalloyCompileError } from './malloy_compile_error';
-export { mkSourceID, mkBuildID, mkQuerySourceDef, mkSQLSourceDef, mkTableSourceDef, resolveSourceID, registerSource, hasSourceRegistryEntry, } from './source_def_utils';
+export { mkSourceID, mkBuildID, mkQuerySourceDef, mkSQLSourceDef, mkTableSourceDef, resolveSourceID, resolveSourceRef, sourceNamespaceReference, registerSource, hasSourceRegistryEntry, } from './source_def_utils';
+export type { NamespaceReference } from './source_def_utils';

package/dist/model/index.js

@@ -18,7 +18,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.hasSourceRegistryEntry = exports.registerSource = exports.resolveSourceID = exports.mkTableSourceDef = exports.mkSQLSourceDef = exports.mkQuerySourceDef = exports.mkBuildID = exports.mkSourceID = exports.MalloyCompileError = exports.getCompiledSQL = exports.constantExprToSQL = exports.getModelAnnotations = exports.typeDefToString = exports.pathToKey = exports.mkModelID = exports.mkModelDef = exports.makeDigest = exports.composeSQLExpr = exports.indent = exports.getResultStructDefForView = exports.getResultStructDefForQuery = exports.QueryModel = exports.QueryQuery = exports.QueryStruct = exports.QueryField = void 0;
+exports.hasSourceRegistryEntry = exports.registerSource = exports.sourceNamespaceReference = exports.resolveSourceRef = exports.resolveSourceID = exports.mkTableSourceDef = exports.mkSQLSourceDef = exports.mkQuerySourceDef = exports.mkBuildID = exports.mkSourceID = exports.MalloyCompileError = exports.getCompiledSQL = exports.constantExprToSQL = exports.getModelAnnotations = exports.typeDefToString = exports.pathToKey = exports.mkModelID = exports.mkModelDef = exports.makeDigest = exports.composeSQLExpr = exports.indent = exports.getResultStructDefForView = exports.getResultStructDefForQuery = exports.QueryModel = exports.QueryQuery = exports.QueryStruct = exports.QueryField = void 0;
 __exportStar(require("./malloy_types"), exports);
 const query_node_1 = require("./query_node");
 Object.defineProperty(exports, "QueryField", { enumerable: true, get: function () { return query_node_1.QueryField; } });
@@ -60,6 +60,8 @@ Object.defineProperty(exports, "mkQuerySourceDef", { enumerable: true, get: func
 Object.defineProperty(exports, "mkSQLSourceDef", { enumerable: true, get: function () { return source_def_utils_1.mkSQLSourceDef; } });
 Object.defineProperty(exports, "mkTableSourceDef", { enumerable: true, get: function () { return source_def_utils_1.mkTableSourceDef; } });
 Object.defineProperty(exports, "resolveSourceID", { enumerable: true, get: function () { return source_def_utils_1.resolveSourceID; } });
+Object.defineProperty(exports, "resolveSourceRef", { enumerable: true, get: function () { return source_def_utils_1.resolveSourceRef; } });
+Object.defineProperty(exports, "sourceNamespaceReference", { enumerable: true, get: function () { return source_def_utils_1.sourceNamespaceReference; } });
 Object.defineProperty(exports, "registerSource", { enumerable: true, get: function () { return source_def_utils_1.registerSource; } });
 Object.defineProperty(exports, "hasSourceRegistryEntry", { enumerable: true, get: function () { return source_def_utils_1.hasSourceRegistryEntry; } });
 //# sourceMappingURL=index.js.map

package/dist/model/malloy_types.d.ts

@@ -858,6 +858,22 @@ interface SourceDefBase extends StructDefBase, Filtered, ResultStructMetadata {
     primaryKey?: PrimaryKeyRef;
     dialect: string;
     partitionComposite?: PartitionCompositeDesc;
+    /**
+     * Identity of this source's own definition (`name@modelURL`). Set for every
+     * source when it is defined. The persistence machinery reads this (gated by
+     * `isPersistableSourceDef`).
+     */
+    sourceID?: SourceID;
+    /**
+     * Set only when this source was created as an unmodified reference to another
+     * source (`source: a is b`, or a plain join) — then it holds the `sourceID`
+     * of the *immediately* referenced source. Absent when the source defines its
+     * own shape (table/sql/query, or a modified/extended source). So
+     * `referenceID !== undefined` means "created as a reference", and the value
+     * resolves through `ModelDef.sourceRegistry` to the referenced source and its
+     * namespace name (see `sourceNamespaceReference`).
+     */
+    referenceID?: SourceID;
 }
 /** which field is the primary key in this struct */
 export type PrimaryKeyRef = string;
@@ -878,7 +894,7 @@ export interface SQLStringSegment {
 export type SQLPhraseSegment = Query | PersistableSourceDef | SQLStringSegment;
 export declare function isSegmentSQL(f: SQLPhraseSegment): f is SQLStringSegment;
 export declare function isSegmentSource(f: SQLPhraseSegment): f is PersistableSourceDef;
-/** Format: "name@modelUrl" - uniquely identifies a source for persistence */
+/** Format: "name@modelUrl" - uniquely identifies a defined source */
 export type SourceID = string;
 /** Created with `mkGivenID`. */
 export type GivenID = string;
@@ -915,7 +931,6 @@ export interface SourceRegistryValue {
 }
 export declare function isSourceRegistryReference(entry: SourceRegistryEntry): entry is SourceRegistryReference;
 export interface PersistableSourceProperties {
-    sourceID?: SourceID;
     extends?: SourceID;
     persistent?: boolean;
 }
@@ -943,13 +958,17 @@ export declare function isSourceDef(sd: NamedModelObject | FieldDef): sd is Sour
 /**
  * Union of all source definition types.
  *
- * IMPORTANT: Never use object spread to copy a SourceDef. Use the factory
- * methods in source_def_utils.ts to merge changes into a source def:
+ * When building a *persisted/derived* source in the compiler, use the factory
+ * methods in source_def_utils.ts rather than object spread:
  * - mkSQLSourceDef(base, ...) - create SQLSourceDef from base
  * - mkQuerySourceDef(base, ...) - create QuerySourceDef from base
  *
- * These factories explicitly copy only safe fields, preventing accidental
- * propagation of sourceID/extends which must only be set in DefineSource.
+ * These factories explicitly copy only safe fields, dropping the identity
+ * fields (sourceID/referenceID/extends/persistent) so they are not propagated
+ * onto a freshly built source. In the translator, by contrast, object spread is
+ * used deliberately to *carry* sourceID/referenceID through an unmodified
+ * reference; DefineSource then sets them, and DynamicSpace clears referenceID
+ * on the modification path.
  */
 export type SourceDef = TableSourceDef | SQLSourceDef | QuerySourceDef | QueryResultDef | FinalizeSourceDef | NestSourceDef | VirtualSourceDef | CompositeSourceDef;
 /** Sources that can be persisted (materialized to tables) */

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/persist_utils.js

@@ -145,7 +145,7 @@ function findPersistentDependencies(root, modelDef, tagParseLog = []) {
         return results;
     }
     function processJoinedSource(source) {
-        // If it has a sourceID, go through the registry
+        // If it has an sourceID, go through the registry
         if ((0, malloy_types_1.isPersistableSourceDef)(source) && source.sourceID) {
             return processSourceID(source.sourceID);
         }

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[];
 };
@@ -88,8 +91,26 @@ export declare class QueryQuery extends QueryField {
      */
     collectArrayJoins(ji: JoinInstance): JoinInstance[];
     genereateSQLOrderBy(queryDef: QuerySegment, resultStruct: FieldInstanceResult): string;
+    /**
+     * The single-scan form, with no `group_set` fan-out: one `SELECT` over the
+     * scan, grouped by the dimensions. Used both for a query with no nests and --
+     * via canUseSingleGroupSetSQL -- for one whose only nests are single-stage
+     * grain-preserving projections, which become an array-agg in the same SELECT.
+     * That array-agg needs no `FILTER (WHERE group_set=N)` (every row is in the
+     * one group), and aggregate/window expressions must not gate themselves by
+     * group_set either, so emitsGroupSet is cleared (see FieldInstanceResultRoot).
+     */
     generateSimpleSQL(stageWriter: StageWriter): string;
-    generatePipelinedStages(outputPipelinedSQL: OutputPipelinedSQL[], lastStageName: string, stageWriter: StageWriter): string;
+    /**
+     * Can this query take the single-group-set fast path? True when the query
+     * needs no group-set fan-out: it has nests (so it's "complex") but every one
+     * is a single-stage grain-preserving projection riding group_set 0, and there
+     * are no reduce nests, ungroupings, or totals (all of which would mint a
+     * second group set and push maxGroupSet above 0). Anything outside that shape
+     * falls back to the general demux path, which is correct for every case.
+     */
+    canUseSingleGroupSetSQL(): boolean;
+    generatePipelinedStages(outputPipelinedSQL: OutputPipelinedSQL[], lastStageName: string, stageWriter: StageWriter, priorStageColumns: StageOutputColumn[]): string;
     generateStage0Fields(resultSet: FieldInstanceResult, output: StageOutputContext, stageWriter: StageWriter): void;
     generateSQLWhereChildren(resultStruct: FieldInstanceResult): AndChain;
     generateSQLWhereTurtled(): string;
@@ -99,7 +120,7 @@ export declare class QueryQuery extends QueryField {
     generateSQLDepthN(depth: number, stageWriter: StageWriter, stageName: string): string;
     genereateSQLCombineTurtles(stageWriter: StageWriter, stage0Name: string): string;
     buildDialectFieldList(resultStruct: FieldInstanceResult): DialectFieldList;
-    generateTurtleSQL(resultStruct: FieldInstanceResult, stageWriter: StageWriter, sqlFieldName: string, outputPipelinedSQL: OutputPipelinedSQL[]): string;
+    generateTurtleSQL(resultStruct: FieldInstanceResult, stageWriter: StageWriter, sqlFieldName: string, outputPipelinedSQL: OutputPipelinedSQL[], omitGroupSetFilter?: boolean): string;
     generateTurtlePipelineSQL(fi: FieldInstanceResult, stageWriter: StageWriter, sourceSQLExpression: string): {
         structDef: QueryResultDef;
         pipeOut: any;