@malloydata/malloy 0.0.335 → 0.0.336

package/dist/model/query_query.js

@@ -11,7 +11,8 @@ const utils_1 = require("./utils");
 const query_node_1 = require("./query_node");
 const stage_writer_1 = require("./stage_writer");
 const field_instance_1 = require("./field_instance");
-const utils_2 = require("./materialization/utils");
+const sql_compiled_1 = require("./sql_compiled");
+const source_def_utils_1 = require("./source_def_utils");
 function pathToCol(path) {
     return path.map(el => encodeURIComponent(el)).join('/');
 }
@@ -51,7 +52,7 @@ class QueryQuery extends query_node_1.QueryField {
             parent = new query_node_1.QueryStruct({
                 ...sourceDef,
                 fields: [...sourceDef.fields, ...firstStage.extendSource],
-            }, parentStruct.sourceArguments, parent.parent ? { struct: parent } : { model: parent.model }, parent.prepareResultOptions);
+            }, parentStruct.sourceArguments, parent.parent ? { struct: parent } : { model: parent.getModel() }, parent.prepareResultOptions);
             turtleWithFilters = {
                 ...turtleWithFilters,
                 pipeline: [
@@ -514,7 +515,7 @@ class QueryQuery extends query_node_1.QueryField {
         return outputStruct;
     }
     getStructSourceSQL(qs, stageWriter) {
-        var _a, _b, _c;
+        var _a, _b;
         switch (qs.structDef.type) {
             case 'table':
                 return this.parent.dialect.quoteTablePath(qs.structDef.tablePath);
@@ -525,47 +526,86 @@ class QueryQuery extends query_node_1.QueryField {
             case 'finalize':
                 return qs.structDef.name;
             case 'sql_select':
-                return `(${qs.structDef.selectStr})`;
+                return `(${(0, sql_compiled_1.getCompiledSQL)(qs.structDef, (_a = qs.prepareResultOptions) !== null && _a !== void 0 ? _a : {}, path => this.parent.dialect.quoteTablePath(path), (query, opts) => {
+                    // Compile query to isolated SQL (not into parent's stageWriter)
+                    const ret = this.compileQueryToStages(query, opts !== null && opts !== void 0 ? opts : {}, undefined, false);
+                    return ret.sql;
+                })})`;
             case 'nest_source':
                 return qs.structDef.pipeSQL;
             case 'query_source': {
-                // cache derived table.
-                if (((_a = qs.prepareResultOptions) === null || _a === void 0 ? void 0 : _a.replaceMaterializedReferences) &&
-                    (0, utils_2.shouldMaterialize)(qs.structDef.query.annotation)) {
-                    return stageWriter.addMaterializedQuery((0, malloy_types_1.getIdentifier)(qs.structDef), qs.structDef.query, (_b = qs.prepareResultOptions) === null || _b === void 0 ? void 0 : _b.materializedTablePrefix);
-                }
-                else {
-                    // Inline what loadQuery does, circularity workaround, finds the
-                    // the name of the last stage
-                    const query = qs.structDef.query;
-                    const turtleDef = {
-                        type: 'turtle',
-                        name: 'ignoreme',
-                        pipeline: query.pipeline,
-                        filterList: query.filterList,
-                    };
-                    const structRef = (_c = query.compositeResolvedSourceDef) !== null && _c !== void 0 ? _c : query.structRef;
-                    let sourceStruct;
-                    if (typeof structRef === 'string') {
-                        const struct = this.structRefToQueryStruct(structRef);
-                        if (!struct) {
-                            throw new Error(`Unexpected reference to an undefined source '${structRef}'`);
+                const { buildManifest, connectionDigests, strictPersist } = (_b = qs.prepareResultOptions) !== null && _b !== void 0 ? _b : {};
+                // Check manifest for this source
+                if (buildManifest && connectionDigests) {
+                    const connDigest = connectionDigests[qs.structDef.connection];
+                    if (connDigest) {
+                        // Compile with empty opts to get manifest-ignorant SQL for BuildID
+                        const fullRet = this.compileQueryToStages(qs.structDef.query, {}, undefined, false);
+                        const buildId = (0, source_def_utils_1.mkBuildID)(connDigest, fullRet.sql);
+                        const entry = buildManifest.buildEntries[buildId];
+                        if (entry) {
+                            // Found in manifest - use persisted table
+                            return this.parent.dialect.quoteTablePath(entry.tableName);
+                        }
+                        if (strictPersist) {
+                            throw new Error(`Persist source '${qs.structDef.sourceID}' not found in manifest (buildId: ${buildId})`);
                         }
-                        sourceStruct = struct;
-                    }
-                    else {
-                        sourceStruct = new query_node_1.QueryStruct(structRef, query.sourceArguments, { model: this.parent.getModel() }, qs.prepareResultOptions);
                     }
-                    const q = QueryQuery.makeQuery(turtleDef, sourceStruct, stageWriter, qs.parent !== undefined, // isJoinedSubquery
-                    this.structRefToQueryStruct);
-                    const ret = q.generateSQLFromPipeline(stageWriter);
-                    return ret.lastStageName;
                 }
+                // Not in manifest - compile normally
+                const ret = this.compileQueryToStages(qs.structDef.query, qs.prepareResultOptions, stageWriter, qs.parent !== undefined);
+                return ret.lastStageName;
             }
             default:
                 throw new Error(`Cannot create SQL StageWriter from '${(0, malloy_types_1.getIdentifier)(qs.structDef)}' type '${qs.structDef.type}`);
         }
     }
+    /**
+     * Compile a Query into SQL stages. Used by both query_source compilation
+     * and getCompiledSQL for interpolated sources.
+     *
+     * @param query The query to compile
+     * @param prepareResultOptions Options including manifest for substitution
+     * @param stageWriter If provided, stages are added to this writer and lastStageName is returned.
+     *                    If undefined, a new isolated writer is created and full SQL is returned.
+     * @param isJoinedSubquery Whether this is a joined subquery
+     * @returns { lastStageName, stageWriter, sql } - sql is only set if stageWriter was undefined
+     */
+    compileQueryToStages(query, prepareResultOptions, stageWriter, isJoinedSubquery) {
+        var _a;
+        const turtleDef = {
+            type: 'turtle',
+            name: 'ignoreme',
+            pipeline: query.pipeline,
+            filterList: query.filterList,
+        };
+        const structRef = (_a = query.compositeResolvedSourceDef) !== null && _a !== void 0 ? _a : query.structRef;
+        let sourceStruct;
+        if (typeof structRef === 'string') {
+            const struct = this.structRefToQueryStruct(structRef);
+            if (!struct) {
+                throw new Error(`Unexpected reference to an undefined source '${structRef}'`);
+            }
+            sourceStruct = struct;
+        }
+        else {
+            sourceStruct = new query_node_1.QueryStruct(structRef, query.sourceArguments, { model: this.parent.getModel() }, prepareResultOptions);
+        }
+        // Create isolated stageWriter if none provided
+        const isolated = stageWriter === undefined;
+        // When isPartialQuery is set (e.g., SQL interpolation), don't use CTEs
+        // for dialects that don't support them in subqueries
+        const noCTE = prepareResultOptions.isPartialQuery &&
+            !sourceStruct.dialect.supportsCTEinCoorelatedSubQueries;
+        const writer = stageWriter !== null && stageWriter !== void 0 ? stageWriter : new stage_writer_1.StageWriter(!noCTE, undefined);
+        const q = QueryQuery.makeQuery(turtleDef, sourceStruct, writer, isJoinedSubquery, this.structRefToQueryStruct);
+        const ret = q.generateSQLFromPipeline(writer);
+        return {
+            lastStageName: ret.lastStageName,
+            stageWriter: writer,
+            sql: isolated ? writer.generateSQLStages() : undefined,
+        };
+    }
     generateSQLJoinBlock(stageWriter, ji, depth) {
         var _a;
         let s = '';
@@ -1490,10 +1530,10 @@ class QueryQuery extends query_node_1.QueryField {
             };
             pipeline.shift();
             for (const transform of pipeline) {
-                const parent = this.parent.parent
+                const parentArg = this.parent.parent
                     ? { struct: this.parent.parent }
                     : { model: this.parent.getModel() };
-                const s = new query_node_1.QueryStruct(structDef, undefined, parent, this.parent.prepareResultOptions);
+                const s = new query_node_1.QueryStruct(structDef, undefined, parentArg, this.parent.prepareResultOptions);
                 const q = QueryQuery.makeQuery({ type: 'turtle', name: '~computeLastStage~', pipeline: [transform] }, s, stageWriter, this.isJoinedSubquery, this.structRefToQueryStruct);
                 q.prepare(stageWriter);
                 lastStageName = q.generateSQL(stageWriter);
@@ -1727,10 +1767,15 @@ class QueryQueryProject extends QueryQuery {
 }
 class QueryQueryRaw extends QueryQuery {
     generateSQL(stageWriter) {
+        var _a;
         if (this.parent.structDef.type !== 'sql_select') {
             throw new Error('Invalid struct for QueryQueryRaw, currently only supports SQL');
         }
-        return stageWriter.addStage(this.parent.structDef.selectStr);
+        return stageWriter.addStage((0, sql_compiled_1.getCompiledSQL)(this.parent.structDef, (_a = this.parent.prepareResultOptions) !== null && _a !== void 0 ? _a : {}, path => this.parent.dialect.quoteTablePath(path), (query, opts) => {
+            // Compile query to isolated SQL (not into parent's stageWriter)
+            const ret = this.compileQueryToStages(query, opts !== null && opts !== void 0 ? opts : {}, undefined, false);
+            return ret.sql;
+        }));
     }
     prepare() {
         // Do nothing!

package/dist/model/source_def_utils.d.ts

@@ -0,0 +1,50 @@
+/**
+ * SourceDef Utilities for Persistence
+ *
+ * Key invariant: sourceID is ONLY assigned in DefineSource when a source
+ * gets a name. Factory functions explicitly copy only the fields they need,
+ * never using spread, to prevent accidental propagation of sourceID/extends.
+ *
+ * The `extends` property is set by callers when processing extend blocks.
+ */
+import type { BuildID, FieldDef, ModelDef, PersistableSourceDef, Query, QuerySourceDef, SourceDef, SourceID, SourceRegistryEntry, SourceRegistryValue, SQLPhraseSegment, SQLSourceDef, TableSourceDef } from './malloy_types';
+export declare function mkSourceID(name: string, url: string | undefined): SourceID;
+/**
+ * Create a BuildID from connection digest and SQL.
+ * BuildID is a hash that uniquely identifies a build artifact.
+ */
+export declare function mkBuildID(connectionDigest: string, sql: string): BuildID;
+/**
+ * Create a QuerySourceDef from query compilation output.
+ * Explicitly copies SourceDefBase fields - no spread.
+ */
+export declare function mkQuerySourceDef(base: SourceDef, query: Query, name: string): QuerySourceDef;
+/**
+ * Create an SQLSourceDef from schema lookup result.
+ * Explicitly copies SourceDefBase fields - no spread.
+ */
+export declare function mkSQLSourceDef(base: SourceDef, selectStr: string, selectSegments?: SQLPhraseSegment[]): SQLSourceDef;
+/**
+ * Create a TableSourceDef. All fields specified, no base to copy from.
+ */
+export declare function mkTableSourceDef(name: string, connection: string, tablePath: string, dialect: string, fields: FieldDef[]): TableSourceDef;
+/**
+ * Resolve a sourceID to a SourceDef using the sourceRegistry.
+ *
+ * @param modelDef The model definition containing the registry
+ * @param sourceID The sourceID to resolve
+ * @returns The SourceDef if found, undefined otherwise
+ */
+export declare function resolveSourceID(modelDef: ModelDef, sourceID: SourceID): PersistableSourceDef | undefined;
+/**
+ * Add an entry to the sourceRegistry.
+ *
+ * @param registry The sourceRegistry to modify (from ModelDef or Document)
+ * @param sourceID The sourceID to register
+ * @param entry Either a SourceRegistryReference (for namespace sources) or a PersistableSourceDef (for hidden deps)
+ */
+export declare function registerSource(registry: Record<SourceID, SourceRegistryValue>, sourceID: SourceID, entry: SourceRegistryEntry): void;
+/**
+ * Check if a sourceID is already in the registry.
+ */
+export declare function hasSourceRegistryEntry(modelDef: ModelDef, sourceID: SourceID): boolean;

package/dist/model/source_def_utils.js

@@ -0,0 +1,154 @@
+"use strict";
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mkSourceID = mkSourceID;
+exports.mkBuildID = mkBuildID;
+exports.mkQuerySourceDef = mkQuerySourceDef;
+exports.mkSQLSourceDef = mkSQLSourceDef;
+exports.mkTableSourceDef = mkTableSourceDef;
+exports.resolveSourceID = resolveSourceID;
+exports.registerSource = registerSource;
+exports.hasSourceRegistryEntry = hasSourceRegistryEntry;
+const utils_1 = require("./utils");
+const malloy_types_1 = require("./malloy_types");
+function mkSourceID(name, url) {
+    return `${name}@${url !== null && url !== void 0 ? url : 'unknown'}`;
+}
+/**
+ * Create a BuildID from connection digest and SQL.
+ * BuildID is a hash that uniquely identifies a build artifact.
+ */
+function mkBuildID(connectionDigest, sql) {
+    return (0, utils_1.makeDigest)(connectionDigest, sql);
+}
+/**
+ * Create a QuerySourceDef from query compilation output.
+ * Explicitly copies SourceDefBase fields - no spread.
+ */
+function mkQuerySourceDef(base, query, name) {
+    return {
+        // Type discriminant
+        type: 'query_source',
+        // QuerySourceDef-specific
+        query,
+        // NamedObject
+        name,
+        as: base.as,
+        // HasLocation
+        location: base.location,
+        // StructDefBase
+        annotation: base.annotation,
+        modelAnnotation: base.modelAnnotation,
+        fields: base.fields,
+        // Filtered
+        filterList: base.filterList,
+        // ResultStructMetadata
+        resultMetadata: base.resultMetadata,
+        // SourceDefBase
+        arguments: query.sourceArguments,
+        parameters: base.parameters,
+        queryTimezone: base.queryTimezone,
+        connection: base.connection,
+        primaryKey: base.primaryKey,
+        dialect: base.dialect,
+        partitionComposite: base.partitionComposite,
+        errorFactory: base.errorFactory,
+        // PersistableSourceProperties - explicitly NOT copied
+        // sourceID: undefined,
+        // extends: undefined,
+    };
+}
+/**
+ * Create an SQLSourceDef from schema lookup result.
+ * Explicitly copies SourceDefBase fields - no spread.
+ */
+function mkSQLSourceDef(base, selectStr, selectSegments) {
+    return {
+        // Type discriminant
+        type: 'sql_select',
+        // SQLSourceDef-specific
+        selectStr,
+        selectSegments,
+        // NamedObject
+        name: base.name,
+        as: base.as,
+        // HasLocation
+        location: base.location,
+        // StructDefBase
+        annotation: base.annotation,
+        modelAnnotation: base.modelAnnotation,
+        fields: base.fields,
+        // Filtered
+        filterList: base.filterList,
+        // ResultStructMetadata
+        resultMetadata: base.resultMetadata,
+        // SourceDefBase
+        arguments: base.arguments,
+        parameters: base.parameters,
+        queryTimezone: base.queryTimezone,
+        connection: base.connection,
+        primaryKey: base.primaryKey,
+        dialect: base.dialect,
+        partitionComposite: base.partitionComposite,
+        errorFactory: base.errorFactory,
+        // PersistableSourceProperties - explicitly NOT copied
+        // sourceID: undefined,
+        // extends: undefined,
+    };
+}
+/**
+ * Create a TableSourceDef. All fields specified, no base to copy from.
+ */
+function mkTableSourceDef(name, connection, tablePath, dialect, fields) {
+    return {
+        type: 'table',
+        name,
+        connection,
+        tablePath,
+        dialect,
+        fields,
+    };
+}
+// =============================================================================
+// Source Registry Utilities
+// =============================================================================
+/**
+ * Resolve a sourceID to a SourceDef using the sourceRegistry.
+ *
+ * @param modelDef The model definition containing the registry
+ * @param sourceID The sourceID to resolve
+ * @returns The SourceDef if found, undefined otherwise
+ */
+function resolveSourceID(modelDef, sourceID) {
+    const value = modelDef.sourceRegistry[sourceID];
+    if (!value)
+        return undefined;
+    if ((0, malloy_types_1.isSourceRegistryReference)(value.entry)) {
+        const obj = modelDef.contents[value.entry.name];
+        return obj && (0, malloy_types_1.isSourceDef)(obj) && (0, malloy_types_1.isPersistableSourceDef)(obj)
+            ? obj
+            : undefined;
+    }
+    // It's a PersistableSourceDef
+    return value.entry;
+}
+/**
+ * Add an entry to the sourceRegistry.
+ *
+ * @param registry The sourceRegistry to modify (from ModelDef or Document)
+ * @param sourceID The sourceID to register
+ * @param entry Either a SourceRegistryReference (for namespace sources) or a PersistableSourceDef (for hidden deps)
+ */
+function registerSource(registry, sourceID, entry) {
+    registry[sourceID] = { entry };
+}
+/**
+ * Check if a sourceID is already in the registry.
+ */
+function hasSourceRegistryEntry(modelDef, sourceID) {
+    return sourceID in modelDef.sourceRegistry;
+}
+//# sourceMappingURL=source_def_utils.js.map

package/dist/model/sql_block.d.ts

@@ -1,4 +1,8 @@
 import type { SQLSourceRequest } from '../lang/translate-response';
 import type { SQLPhraseSegment, ModelDef } from './malloy_types';
-export declare function compileSQLInterpolation(select: SQLPhraseSegment[], connection: string, partialModel: ModelDef | undefined): SQLSourceRequest;
+/**
+ * The translator needs to know the output schema of an SQLSourceDef
+ * this will prepare an SQL string suitable to answer that question.
+ */
+export declare function getSourceRequest(select: SQLPhraseSegment[], connection: string, partialModel: ModelDef | undefined): SQLSourceRequest;
 export declare function sqlKey(connectionName: string, sql: string): string;

package/dist/model/sql_block.js

@@ -22,12 +22,16 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.compileSQLInterpolation = compileSQLInterpolation;
+exports.getSourceRequest = getSourceRequest;
 exports.sqlKey = sqlKey;
 const query_model_1 = require("./query_model");
 const malloy_types_1 = require("./malloy_types");
 const utils_1 = require("./utils");
-function compileSQLInterpolation(select, connection, partialModel) {
+/**
+ * The translator needs to know the output schema of an SQLSourceDef
+ * this will prepare an SQL string suitable to answer that question.
+ */
+function getSourceRequest(select, connection, partialModel) {
     let queryModel = undefined;
     let selectStr = '';
     let parenAlready = false;
@@ -36,8 +40,30 @@ function compileSQLInterpolation(select, connection, partialModel) {
             selectStr += segment.sql;
             parenAlready = segment.sql.match(/\(\s*$/) !== null;
         }
+        else if ((0, malloy_types_1.isSegmentSource)(segment)) {
+            // PersistableSourceDef (sql_select or query_source)
+            let compiledSql;
+            if (segment.type === 'sql_select') {
+                compiledSql = segment.selectStr;
+            }
+            else {
+                // query_source - compile the inner query
+                if (!queryModel) {
+                    if (!partialModel) {
+                        throw new Error('Internal error: Partial model missing when compiling SQL block');
+                    }
+                    queryModel = (0, query_model_1.makeQueryModel)(partialModel);
+                }
+                compiledSql = queryModel.compileQuery(segment.query, {
+                    defaultRowLimit: undefined,
+                    isPartialQuery: true,
+                }, false).sql;
+            }
+            selectStr += parenAlready ? compiledSql : `(${compiledSql})`;
+            parenAlready = false;
+        }
         else {
-            // TODO catch exceptions and throw errors ...
+            // Query segment
             if (!queryModel) {
                 if (!partialModel) {
                     throw new Error('Internal error: Partial model missing when compiling SQL block');
@@ -49,7 +75,6 @@ function compileSQLInterpolation(select, connection, partialModel) {
                 isPartialQuery: true,
             }, false).sql;
             selectStr += parenAlready ? compiledSql : `(${compiledSql})`;
-            // console.log(selectStr);
             parenAlready = false;
         }
     }

package/dist/model/sql_compiled.d.ts

@@ -0,0 +1,29 @@
+import type { PrepareResultOptions, SQLSourceDef, PersistableSourceDef, Query } from './malloy_types';
+/**
+ * Callback type for compiling a Query to SQL.
+ * opts is optional - omit for "full SQL" (BuildID computation),
+ * provide for "run SQL" (with manifest substitution).
+ */
+export type CompileQueryCallback = (query: Query, opts?: PrepareResultOptions) => string;
+/**
+ * Compile a SQLSourceDef to its final SQL string.
+ *
+ * If the source has selectSegments (interpolated persistent sources), each segment
+ * is expanded by looking up in the manifest or compiling inline.
+ *
+ * @param src The SQLSourceDef to compile
+ * @param opts PrepareResultOptions with buildManifest and connectionDigests
+ * @param quoteTablePath Dialect function to safely quote a table path
+ * @param compileQuery Callback to compile a Query to SQL
+ */
+export declare function getCompiledSQL(src: SQLSourceDef, opts: PrepareResultOptions, quoteTablePath: (path: string) => string, compileQuery: CompileQueryCallback): string;
+/**
+ * Get the SQL for a PersistableSourceDef.
+ *
+ * @param source The persistable source to compile
+ * @param quoteTablePath Dialect function to quote table paths
+ * @param compileQuery Callback to compile a Query to SQL
+ * @param opts Optional - if provided with manifest, nested sources may be substituted.
+ *             Omit for "full SQL" (e.g., when computing BuildID).
+ */
+export declare function getSourceSQL(source: PersistableSourceDef, quoteTablePath: (path: string) => string, compileQuery: CompileQueryCallback, opts?: PrepareResultOptions): string;

package/dist/model/sql_compiled.js

@@ -0,0 +1,102 @@
+"use strict";
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCompiledSQL = getCompiledSQL;
+exports.getSourceSQL = getSourceSQL;
+const malloy_types_1 = require("./malloy_types");
+const source_def_utils_1 = require("./source_def_utils");
+/**
+ * Compile a SQLSourceDef to its final SQL string.
+ *
+ * If the source has selectSegments (interpolated persistent sources), each segment
+ * is expanded by looking up in the manifest or compiling inline.
+ *
+ * @param src The SQLSourceDef to compile
+ * @param opts PrepareResultOptions with buildManifest and connectionDigests
+ * @param quoteTablePath Dialect function to safely quote a table path
+ * @param compileQuery Callback to compile a Query to SQL
+ */
+function getCompiledSQL(src, opts, quoteTablePath, compileQuery) {
+    // If no segments, just return the pre-computed selectStr
+    if (!src.selectSegments || src.selectSegments.length === 0) {
+        return src.selectStr;
+    }
+    // Expand each segment
+    const parts = [];
+    for (const segment of src.selectSegments) {
+        parts.push(expandSegment(segment, opts, quoteTablePath, compileQuery));
+    }
+    return parts.join('');
+}
+/**
+ * Expand a single SQLPhraseSegment to SQL.
+ */
+function expandSegment(segment, opts, quoteTablePath, compileQuery) {
+    // Plain SQL string
+    if ((0, malloy_types_1.isSegmentSQL)(segment)) {
+        return segment.sql;
+    }
+    // PersistableSourceDef (sql_select or query_source)
+    if ((0, malloy_types_1.isSegmentSource)(segment)) {
+        return expandPersistableSource(segment, opts, quoteTablePath, compileQuery);
+    }
+    // Query segment
+    return expandQuery(segment, opts, quoteTablePath, compileQuery);
+}
+/**
+ * Expand a PersistableSourceDef, checking manifest for pre-built table.
+ * Always returns a subquery form: (SELECT * FROM table) or (inline SQL)
+ */
+function expandPersistableSource(source, opts, quoteTablePath, compileQuery) {
+    const { buildManifest, connectionDigests, strictPersist } = opts;
+    // Try manifest lookup if we have the required info
+    if (buildManifest && connectionDigests) {
+        const connDigest = connectionDigests[source.connection];
+        if (connDigest) {
+            // Get the SQL for this source to compute BuildID (no opts = full SQL)
+            const sql = getSourceSQL(source, quoteTablePath, compileQuery);
+            const buildId = (0, source_def_utils_1.mkBuildID)(connDigest, sql);
+            const entry = buildManifest.buildEntries[buildId];
+            if (entry) {
+                // Found in manifest - substitute with subquery from persisted table
+                return `(SELECT * FROM ${quoteTablePath(entry.tableName)})`;
+            }
+            // Not in manifest
+            if (strictPersist) {
+                throw new Error(`Persist source '${source.sourceID}' not found in manifest (buildId: ${buildId})`);
+            }
+        }
+    }
+    // No manifest or not found - expand inline as subquery
+    const sql = getSourceSQL(source, quoteTablePath, compileQuery, opts);
+    return `(${sql})`;
+}
+/**
+ * Expand a Query segment.
+ */
+function expandQuery(query, opts, _quoteTablePath, compileQuery) {
+    // Set isPartialQuery so CTEs aren't used (they can't be nested in subqueries)
+    const sql = compileQuery(query, { ...opts, isPartialQuery: true });
+    return `(${sql})`;
+}
+/**
+ * Get the SQL for a PersistableSourceDef.
+ *
+ * @param source The persistable source to compile
+ * @param quoteTablePath Dialect function to quote table paths
+ * @param compileQuery Callback to compile a Query to SQL
+ * @param opts Optional - if provided with manifest, nested sources may be substituted.
+ *             Omit for "full SQL" (e.g., when computing BuildID).
+ */
+function getSourceSQL(source, quoteTablePath, compileQuery, opts) {
+    if (source.type === 'sql_select') {
+        // Recursive call for nested sql_select
+        return getCompiledSQL(source, opts !== null && opts !== void 0 ? opts : {}, quoteTablePath, compileQuery);
+    }
+    // query_source - compile the inner query
+    return compileQuery(source.query, opts);
+}
+//# sourceMappingURL=sql_compiled.js.map

package/dist/model/stage_writer.d.ts

@@ -1,12 +1,11 @@
 import type { Dialect } from '../dialect';
-import type { QueryToMaterialize, StructDef, Query } from './malloy_types';
+import type { StructDef } from './malloy_types';
 export declare class StageWriter {
     parent: StageWriter | undefined;
     withs: string[];
     stageNames: string[];
     udfs: string[];
     pdts: string[];
-    dependenciesToMaterialize: Record<string, QueryToMaterialize>;
     stagePrefix: string;
     useCTE: boolean;
     stageNumber: number;
@@ -16,7 +15,6 @@ export declare class StageWriter {
     root(): StageWriter;
     addStage(sql: string): string;
     addUDF(stageWriter: StageWriter, dialect: Dialect, structDef: StructDef): string;
-    addMaterializedQuery(fieldName: string, query: Query, materializatedTablePrefix?: string): string;
     addPDT(baseName: string, dialect: Dialect): string;
     combineStages(includeLastStage: boolean): {
         sql: string;