@malloydata/malloy 0.0.335 → 0.0.336

package/dist/model/malloy_types.d.ts

@@ -1,4 +1,5 @@
 import type * as Malloy from '@malloydata/malloy-interfaces';
+import type { EventStream } from '../runtime_types';
 /**
  * Field computations are compiled into an expression tree of "Expr"
  * type nodes. Each node is one of these three interfaces. The
@@ -582,7 +583,7 @@ export interface Query extends Pipeline, Filtered, HasLocation {
     modelAnnotation?: Annotation;
     compositeResolvedSourceDef?: SourceDef;
 }
-export type NamedQuery = Query & NamedObject;
+export type NamedQueryDef = Query & NamedObject;
 export type PipeSegment = QuerySegment | IndexSegment | RawSegment;
 export declare function segmentHasErrors(segment: PipeSegment): boolean;
 export declare function structHasErrors(struct: StructDef): boolean;
@@ -685,6 +686,8 @@ interface StructDefBase extends HasLocation, NamedObject {
     annotation?: Annotation;
     modelAnnotation?: ModelAnnotation;
     fields: FieldDef[];
+    /** Marker for error placeholder structs created by ErrorFactory */
+    errorFactory?: boolean;
 }
 export interface PartitionCompositeDesc {
     partitionField: string;
@@ -716,13 +719,46 @@ export interface CompositeSourceDef extends SourceDefBase {
 export interface SQLStringSegment {
     sql: string;
 }
-export type SQLPhraseSegment = Query | SQLStringSegment;
+export type SQLPhraseSegment = Query | PersistableSourceDef | SQLStringSegment;
 export declare function isSegmentSQL(f: SQLPhraseSegment): f is SQLStringSegment;
-export interface SQLSourceDef extends SourceDefBase {
+export declare function isSegmentSource(f: SQLPhraseSegment): f is PersistableSourceDef;
+/** Format: "name@modelUrl" - uniquely identifies a source for persistence */
+export type SourceID = string;
+/** Hash of (connectionDigest, sql) - uniquely identifies a built artifact */
+export type BuildID = string;
+/**
+ * Reference to a source in modelDef.contents by name.
+ * Used in sourceRegistry to avoid duplicating SourceDefs that are in the namespace.
+ */
+export interface SourceRegistryReference {
+    type: 'source_registry_reference';
+    name: string;
+}
+/**
+ * Inner entry type: either a reference to contents or an actual PersistableSourceDef.
+ * - SourceRegistryReference: source is in namespace (contents), look it up by name
+ * - PersistableSourceDef: source is not in namespace (hidden dependency), stored directly
+ */
+export type SourceRegistryEntry = SourceRegistryReference | PersistableSourceDef;
+/**
+ * Value in the sourceRegistry, wrapping the entry with persistence info.
+ * persist is lazily computed: undefined = not checked, true/false = checked
+ */
+export interface SourceRegistryValue {
+    entry: SourceRegistryEntry;
+    persist?: boolean;
+}
+export declare function isSourceRegistryReference(entry: SourceRegistryEntry): entry is SourceRegistryReference;
+export interface PersistableSourceProperties {
+    sourceID?: SourceID;
+    extends?: SourceID;
+}
+export interface SQLSourceDef extends SourceDefBase, PersistableSourceProperties {
     type: 'sql_select';
     selectStr: string;
+    selectSegments?: SQLPhraseSegment[];
 }
-export interface QuerySourceDef extends SourceDefBase {
+export interface QuerySourceDef extends SourceDefBase, PersistableSourceProperties {
     type: 'query_source';
     query: Query;
 }
@@ -738,7 +774,21 @@ export interface FinalizeSourceDef extends SourceDefBase {
 }
 export declare function sourceBase(sd: SourceDefBase): SourceDefBase;
 export declare function isSourceDef(sd: NamedModelObject | FieldDef): sd is SourceDef;
+/**
+ * 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:
+ * - 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.
+ */
 export type SourceDef = TableSourceDef | SQLSourceDef | QuerySourceDef | QueryResultDef | FinalizeSourceDef | NestSourceDef | CompositeSourceDef;
+/** Sources that can be persisted (materialized to tables) */
+export type PersistableSourceDef = SQLSourceDef | QuerySourceDef;
+export declare function isPersistableSourceDef(sd: SourceDef): sd is PersistableSourceDef;
 /** Is this the "FROM" table of a query tree */
 export declare function isBaseTable(def: StructDef): def is SourceDef;
 export type StructDef = SourceDef | RecordDef | ArrayDef;
@@ -891,7 +941,7 @@ export type QueryFieldDef = AtomicFieldDef | TurtleDef | RefToField;
 export type TypedDef = AtomicTypeDef | JoinFieldDef | TurtleDef | RefToField | StructDef;
 /** Get the output name for a NamedObject */
 export declare function getIdentifier(n: AliasedName): string;
-export type NamedModelObject = SourceDef | NamedQuery | FunctionDef | ConnectionDef;
+export type NamedModelObject = SourceDef | NamedQueryDef | FunctionDef | ConnectionDef;
 export interface DependencyTree {
     [url: string]: DependencyTree;
 }
@@ -900,6 +950,13 @@ export interface ModelDef {
     name: string;
     exports: string[];
     contents: Record<string, NamedModelObject>;
+    /**
+     * Registry mapping sourceID to source definitions for build graph construction.
+     * For sources in namespace: maps to SourceRegistryReference (look up in contents)
+     * For hidden dependencies: maps to actual PersistableSourceDef (not in namespace)
+     * Each entry includes a lazily-computed persist flag.
+     */
+    sourceRegistry: Record<SourceID, SourceRegistryValue>;
     annotation?: ModelAnnotation;
     queryList: Query[];
     dependencies: DependencyTree;
@@ -948,12 +1005,6 @@ export interface DrillSource {
     sourceFilters?: FilterCondition[];
     sourceArguments?: Record<string, Argument>;
 }
-export type QueryToMaterialize = {
-    id: string;
-    path: string;
-    source: string | undefined;
-    queryName: string;
-};
 export interface CompiledQuery extends DrillSource {
     structs: SourceDef[];
     sql: string;
@@ -963,8 +1014,6 @@ export interface CompiledQuery extends DrillSource {
     connectionName: string;
     queryTimezone?: string;
     annotation?: Annotation;
-    dependenciesToMaterialize?: Record<string, QueryToMaterialize>;
-    materialization?: QueryToMaterialize;
     defaultRowLimitAdded?: number;
 }
 /** Result type for running a Malloy query. */
@@ -1007,10 +1056,15 @@ export interface SearchValueMapResult {
     }[];
 }
 export interface PrepareResultOptions {
-    replaceMaterializedReferences?: boolean;
-    materializedTablePrefix?: string;
     defaultRowLimit?: number;
     isPartialQuery?: boolean;
+    eventStream?: EventStream;
+    /** Manifest of built tables (BuildID → entry), the build cache */
+    buildManifest?: BuildManifest;
+    /** Map from connectionName to connectionDigest (from Connection.getDigest()) */
+    connectionDigests?: Record<string, string>;
+    /** If true, throw when a persist query's digest is not in the manifest */
+    strictPersist?: boolean;
 }
 type UTD = AtomicTypeDef | TypedDef | FunctionParameterTypeDef | FunctionReturnTypeDef | undefined;
 /**
@@ -1048,4 +1102,24 @@ export type UniqueKeyRequirement = undefined | {
     isCount: boolean;
 };
 export declare function mergeUniqueKeyRequirement(existing: UniqueKeyRequirement, newInfo: UniqueKeyRequirement): UniqueKeyRequirement;
+/**
+ * Entry in a BuildManifest for a persisted table.
+ */
+export interface BuildManifestEntry {
+    /** Hash of (connectionDigest, sql) - also the key in buildEntries */
+    buildId: BuildID;
+    tableName: string;
+    buildStartedAt: string;
+    buildFinishedAt: string;
+}
+/**
+ * Manifest of persisted query results (the build cache).
+ * Used by compileQuery to substitute persist queries with table references.
+ */
+export interface BuildManifest {
+    modelUrl: string;
+    buildStartedAt: string;
+    buildFinishedAt: string;
+    buildEntries: Record<BuildID, BuildManifestEntry>;
+}
 export {};

package/dist/model/malloy_types.js

@@ -76,8 +76,11 @@ exports.isRawSegment = isRawSegment;
 exports.isIndexSegment = isIndexSegment;
 exports.bareFieldUsage = bareFieldUsage;
 exports.isSegmentSQL = isSegmentSQL;
+exports.isSegmentSource = isSegmentSource;
+exports.isSourceRegistryReference = isSourceRegistryReference;
 exports.sourceBase = sourceBase;
 exports.isSourceDef = isSourceDef;
+exports.isPersistableSourceDef = isPersistableSourceDef;
 exports.isBaseTable = isBaseTable;
 exports.isLiteral = isLiteral;
 exports.mergeEvalSpaces = mergeEvalSpaces;
@@ -443,6 +446,12 @@ function bareFieldUsage(fu) {
 function isSegmentSQL(f) {
     return 'sql' in f;
 }
+function isSegmentSource(f) {
+    return 'type' in f && (f.type === 'sql_select' || f.type === 'query_source');
+}
+function isSourceRegistryReference(entry) {
+    return entry.type === 'source_registry_reference';
+}
 // The gesture {...sourceStruct moreProperties}  happens everywhere, now that
 // structs aren't all identical, we need a way to make one from any of the
 // exisitng structs
@@ -458,6 +467,9 @@ function isSourceDef(sd) {
         sd.type === 'nest_source' ||
         sd.type === 'composite');
 }
+function isPersistableSourceDef(sd) {
+    return sd.type === 'sql_select' || sd.type === 'query_source';
+}
 /** Is this the "FROM" table of a query tree */
 function isBaseTable(def) {
     if (isJoinedSource(def)) {

package/dist/model/persist_utils.d.ts

@@ -0,0 +1,47 @@
+import type { ModelDef, SourceDef, Query } from './malloy_types';
+import type { BuildNode } from '../api/foundation/types';
+/**
+ * Find persistent dependencies for a source or query, returning a nested DAG.
+ *
+ * Walks the full dependency tree but only includes persistent sources in the
+ * result. Non-persistent sources are "flattened out" - their persistent
+ * dependencies bubble up to become direct dependencies of the caller.
+ *
+ * Example: source_c (persist) -> source_b (NOT persist) -> source_a (persist)
+ * Returns: [{sourceID: source_a, dependsOn: []}]
+ * (source_b is flattened out, source_a becomes direct dependency)
+ *
+ * ## The 6 Dependency Paths in the IR
+ *
+ * Starting from a Query or SourceDef, these are ALL the ways a SourceDef
+ * can be referenced (and thus must be walked for dependency tracking):
+ *
+ * 1. **Query.structRef** → SourceDef (the FROM clause)
+ * 2. **Query.pipeline[].extendSource[]** → JoinFieldDef (joins in extend blocks)
+ * 3. **SourceDef.fields[]** → JoinFieldDef (joins defined on a source)
+ * 4. **PersistableSourceDef.extends** → SourceID (extend chain reference)
+ * 5. **SQLSourceDef.selectSegments[]** → Query | PersistableSourceDef (SQL interpolation)
+ * 6. **QuerySourceDef.query** → Query (nested query in query_source)
+ *
+ * Note: CompositeSourceDef.sources[] is ignored - composite sources and
+ * persistence may be incompatible features.
+ *
+ * @param root The source or query to find dependencies for
+ * @param modelDef The model definition containing the source registry
+ * @returns Array of BuildNode representing the persistent dependency DAG
+ */
+export declare function findPersistentDependencies(root: SourceDef | Query, modelDef: ModelDef): BuildNode[];
+/**
+ * Find the minimal set of root build graphs from a forest of BuildNodes.
+ *
+ * Uses flattening for ANALYSIS ONLY to identify unique nodes and find roots.
+ * Returns original graph structures (NOT flattened) - preserves branching
+ * for parallel builds.
+ *
+ * Roots are sourceIDs that exist but nothing depends on them - these are
+ * the entry points for building.
+ *
+ * @param deps Array of BuildNode trees (potentially overlapping)
+ * @returns Array of root BuildNode trees (deduplicated)
+ */
+export declare function minimalBuildGraph(deps: BuildNode[]): BuildNode[];

package/dist/model/persist_utils.js

@@ -0,0 +1,257 @@
+"use strict";
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findPersistentDependencies = findPersistentDependencies;
+exports.minimalBuildGraph = minimalBuildGraph;
+const malloy_types_1 = require("./malloy_types");
+const source_def_utils_1 = require("./source_def_utils");
+const annotation_1 = require("../annotation");
+/**
+ * Resolve a source name to its definition from model contents.
+ */
+function resolveSource(modelDef, name) {
+    const obj = modelDef.contents[name];
+    return obj && (0, malloy_types_1.isSourceDef)(obj) ? obj : undefined;
+}
+/**
+ * Check if a source has the #@ persist annotation.
+ */
+function checkPersistAnnotation(source) {
+    if (!source.annotation)
+        return false;
+    const { tag } = (0, annotation_1.annotationToTag)(source.annotation, { prefix: /^#@ / });
+    return tag.has('persist');
+}
+/**
+ * Check if a sourceID is persistent, using lazy evaluation and caching.
+ * Sets the persist flag on the registry entry as a side effect.
+ */
+function isPersistent(sourceID, modelDef) {
+    const value = modelDef.sourceRegistry[sourceID];
+    if (!value)
+        return false;
+    if (value.persist === undefined) {
+        const sourceDef = (0, source_def_utils_1.resolveSourceID)(modelDef, sourceID);
+        value.persist = sourceDef ? checkPersistAnnotation(sourceDef) : false;
+    }
+    return value.persist;
+}
+/**
+ * Find persistent dependencies for a source or query, returning a nested DAG.
+ *
+ * Walks the full dependency tree but only includes persistent sources in the
+ * result. Non-persistent sources are "flattened out" - their persistent
+ * dependencies bubble up to become direct dependencies of the caller.
+ *
+ * Example: source_c (persist) -> source_b (NOT persist) -> source_a (persist)
+ * Returns: [{sourceID: source_a, dependsOn: []}]
+ * (source_b is flattened out, source_a becomes direct dependency)
+ *
+ * ## The 6 Dependency Paths in the IR
+ *
+ * Starting from a Query or SourceDef, these are ALL the ways a SourceDef
+ * can be referenced (and thus must be walked for dependency tracking):
+ *
+ * 1. **Query.structRef** → SourceDef (the FROM clause)
+ * 2. **Query.pipeline[].extendSource[]** → JoinFieldDef (joins in extend blocks)
+ * 3. **SourceDef.fields[]** → JoinFieldDef (joins defined on a source)
+ * 4. **PersistableSourceDef.extends** → SourceID (extend chain reference)
+ * 5. **SQLSourceDef.selectSegments[]** → Query | PersistableSourceDef (SQL interpolation)
+ * 6. **QuerySourceDef.query** → Query (nested query in query_source)
+ *
+ * Note: CompositeSourceDef.sources[] is ignored - composite sources and
+ * persistence may be incompatible features.
+ *
+ * @param root The source or query to find dependencies for
+ * @param modelDef The model definition containing the source registry
+ * @returns Array of BuildNode representing the persistent dependency DAG
+ */
+function findPersistentDependencies(root, modelDef) {
+    const visited = new Set();
+    function processSourceID(sourceID) {
+        if (visited.has(sourceID)) {
+            return [];
+        }
+        visited.add(sourceID);
+        const sourceDef = (0, source_def_utils_1.resolveSourceID)(modelDef, sourceID);
+        if (!sourceDef) {
+            return [];
+        }
+        const childDeps = processSourceDef(sourceDef);
+        const persistent = isPersistent(sourceID, modelDef);
+        if (persistent) {
+            return [{ sourceID, dependsOn: childDeps }];
+        }
+        else {
+            return childDeps;
+        }
+    }
+    function processSourceDef(source) {
+        const results = [];
+        // Path 4: PersistableSourceDef.extends
+        if ((0, malloy_types_1.isPersistableSourceDef)(source) && source.extends) {
+            results.push(...processSourceID(source.extends));
+        }
+        // Path 6: QuerySourceDef.query
+        if (source.type === 'query_source') {
+            results.push(...processQuery(source.query));
+        }
+        // Path 5: SQLSourceDef.selectSegments[]
+        if (source.type === 'sql_select' && source.selectSegments) {
+            for (const segment of source.selectSegments) {
+                results.push(...processSQLSegment(segment));
+            }
+        }
+        // Path 3: SourceDef.fields[] - joins defined on the source
+        for (const field of source.fields) {
+            if ((0, malloy_types_1.isJoined)(field) && (0, malloy_types_1.isSourceDef)(field)) {
+                results.push(...processJoinedSource(field));
+            }
+        }
+        return results;
+    }
+    function processQuery(query) {
+        const results = [];
+        // Path 1: Query.structRef
+        results.push(...processStructRef(query.structRef));
+        // Path 2: Query.pipeline[].extendSource[]
+        for (const segment of query.pipeline) {
+            if (segment.type === 'reduce' ||
+                segment.type === 'project' ||
+                segment.type === 'partial') {
+                const querySegment = segment;
+                if (querySegment.extendSource) {
+                    for (const field of querySegment.extendSource) {
+                        if ((0, malloy_types_1.isJoined)(field) && (0, malloy_types_1.isSourceDef)(field)) {
+                            results.push(...processJoinedSource(field));
+                        }
+                    }
+                }
+            }
+        }
+        return results;
+    }
+    function processJoinedSource(source) {
+        // If it has a sourceID, go through the registry
+        if ((0, malloy_types_1.isPersistableSourceDef)(source) && source.sourceID) {
+            return processSourceID(source.sourceID);
+        }
+        // Otherwise walk through it transparently
+        return processSourceDef(source);
+    }
+    function processStructRef(ref) {
+        if (typeof ref === 'string') {
+            const source = resolveSource(modelDef, ref);
+            if (!source)
+                return [];
+            if ((0, malloy_types_1.isPersistableSourceDef)(source) && source.sourceID) {
+                return processSourceID(source.sourceID);
+            }
+            return processSourceDef(source);
+        }
+        else if ((0, malloy_types_1.isSourceDef)(ref)) {
+            if ((0, malloy_types_1.isPersistableSourceDef)(ref) && ref.sourceID) {
+                return processSourceID(ref.sourceID);
+            }
+            return processSourceDef(ref);
+        }
+        return [];
+    }
+    function processSQLSegment(segment) {
+        if ((0, malloy_types_1.isSegmentSQL)(segment)) {
+            return [];
+        }
+        else if ((0, malloy_types_1.isSegmentSource)(segment)) {
+            if ((0, malloy_types_1.isPersistableSourceDef)(segment) && segment.sourceID) {
+                return processSourceID(segment.sourceID);
+            }
+            return processSourceDef(segment);
+        }
+        else {
+            // It's a Query
+            return processQuery(segment);
+        }
+    }
+    // Entry point: handle both SourceDef and Query
+    // Query has required 'structRef', SourceDef does not
+    if ('structRef' in root) {
+        return processQuery(root);
+    }
+    else {
+        // If the root source itself is persistable and has a sourceID, process it through
+        // processSourceID so it gets included in the result if persistent
+        if ((0, malloy_types_1.isPersistableSourceDef)(root) && root.sourceID) {
+            return processSourceID(root.sourceID);
+        }
+        return processSourceDef(root);
+    }
+}
+/**
+ * Collect all sourceIDs from a BuildNode forest (for analysis only).
+ */
+function collectAllSourceIDs(nodes) {
+    const result = new Set();
+    for (const node of nodes) {
+        result.add(node.sourceID);
+        for (const id of collectAllSourceIDs(node.dependsOn)) {
+            result.add(id);
+        }
+    }
+    return result;
+}
+/**
+ * Collect all sourceIDs that appear in any dependsOn (for analysis only).
+ */
+function collectAllDependedOn(nodes) {
+    const result = new Set();
+    for (const node of nodes) {
+        for (const dep of node.dependsOn) {
+            result.add(dep.sourceID);
+        }
+        for (const id of collectAllDependedOn(node.dependsOn)) {
+            result.add(id);
+        }
+    }
+    return result;
+}
+/**
+ * Find the minimal set of root build graphs from a forest of BuildNodes.
+ *
+ * Uses flattening for ANALYSIS ONLY to identify unique nodes and find roots.
+ * Returns original graph structures (NOT flattened) - preserves branching
+ * for parallel builds.
+ *
+ * Roots are sourceIDs that exist but nothing depends on them - these are
+ * the entry points for building.
+ *
+ * @param deps Array of BuildNode trees (potentially overlapping)
+ * @returns Array of root BuildNode trees (deduplicated)
+ */
+function minimalBuildGraph(deps) {
+    if (deps.length === 0)
+        return [];
+    // Use flattening for analysis only
+    const allSourceIDs = collectAllSourceIDs(deps);
+    const dependedOn = collectAllDependedOn(deps);
+    // Roots are sourceIDs that exist but nothing depends on them
+    const rootIDs = new Set();
+    for (const id of allSourceIDs) {
+        if (!dependedOn.has(id)) {
+            rootIDs.add(id);
+        }
+    }
+    // Return original graph structures for roots (deduplicated by sourceID)
+    const seen = new Set();
+    const roots = [];
+    for (const node of deps) {
+        if (rootIDs.has(node.sourceID) && !seen.has(node.sourceID)) {
+            seen.add(node.sourceID);
+            roots.push(node);
+        }
+    }
+    return roots;
+}
+//# sourceMappingURL=persist_utils.js.map

package/dist/model/query_model_impl.d.ts

@@ -1,18 +1,16 @@
 import type { ModelDef, StructRef, Argument, PrepareResultOptions, Query, SourceDef, SearchIndexResult, CompiledQuery, TurtleDef } from './malloy_types';
 import { StageWriter } from './stage_writer';
 import { type Dialect } from '../dialect';
-import type { EventStream } from '../runtime_types';
 import type { Connection } from '../connection/types';
 import type { ModelRootInterface } from './query_node';
 import { QueryStruct } from './query_node';
 import type { QueryModel, QueryResults } from './query_model_contract';
-export declare function makeQueryModel(modelDef: ModelDef | undefined, eventStream?: EventStream): QueryModel;
+export declare function makeQueryModel(modelDef: ModelDef | undefined): QueryModel;
 export declare class QueryModelImpl implements QueryModel, ModelRootInterface {
-    readonly eventStream?: EventStream | undefined;
     dialect: Dialect;
     modelDef: ModelDef | undefined;
     structs: Map<string, QueryStruct>;
-    constructor(modelDef: ModelDef | undefined, eventStream?: EventStream | undefined);
+    constructor(modelDef: ModelDef | undefined);
     getFinalOutputStruct(query: Query, options: PrepareResultOptions | undefined): SourceDef | undefined;
     loadModelFromDef(modelDef: ModelDef): void;
     getStructByName(name: string): QueryStruct;

package/dist/model/query_model_impl.js

@@ -12,15 +12,13 @@ const query_query_1 = require("./query_query");
 const malloy_types_1 = require("./malloy_types");
 const stage_writer_1 = require("./stage_writer");
 const dialect_1 = require("../dialect");
-const utils_1 = require("./materialization/utils");
 const query_node_1 = require("./query_node");
 const row_data_utils_1 = require("../api/row_data_utils");
-function makeQueryModel(modelDef, eventStream) {
-    return new QueryModelImpl(modelDef, eventStream);
+function makeQueryModel(modelDef) {
+    return new QueryModelImpl(modelDef);
 }
 class QueryModelImpl {
-    constructor(modelDef, eventStream) {
-        this.eventStream = eventStream;
+    constructor(modelDef) {
         this.dialect = new dialect_1.StandardSQLDialect();
         // dialect: Dialect = new PostgresDialect();
         this.modelDef = undefined;
@@ -141,13 +139,11 @@ class QueryModelImpl {
         };
     }
     compileQuery(query, prepareResultOptions, finalize = true) {
-        var _a, _b, _c;
-        let newModel;
+        var _a, _b;
         const addDefaultRowLimit = this.addDefaultRowLimit(query, prepareResultOptions === null || prepareResultOptions === void 0 ? void 0 : prepareResultOptions.defaultRowLimit);
         query = addDefaultRowLimit.query;
         const addedDefaultRowLimit = addDefaultRowLimit.addedDefaultRowLimit;
-        const m = newModel || this;
-        const ret = m.loadQuery(query, undefined, prepareResultOptions, finalize, false);
+        const ret = this.loadQuery(query, undefined, prepareResultOptions, finalize, false);
         const structRef = (_a = query.compositeResolvedSourceDef) !== null && _a !== void 0 ? _a : query.structRef;
         const sourceExplore = typeof structRef === 'string'
             ? structRef
@@ -163,10 +159,6 @@ class QueryModelImpl {
             lastStageName: ret.lastStageName,
             malloy: ret.malloy,
             sql: ret.stageWriter.generateSQLStages(),
-            dependenciesToMaterialize: ret.stageWriter.dependenciesToMaterialize,
-            materialization: (0, utils_1.shouldMaterialize)(query.annotation)
-                ? (0, utils_1.buildQueryMaterializationSpec)((_c = query.location) === null || _c === void 0 ? void 0 : _c.url, query.name, prepareResultOptions === null || prepareResultOptions === void 0 ? void 0 : prepareResultOptions.materializedTablePrefix)
-                : undefined,
             structs: ret.structs,
             sourceExplore,
             sourceFilters: query.filterList,

package/dist/model/query_node.d.ts

@@ -61,7 +61,7 @@ export interface ParentQueryStruct {
     struct: QueryStruct;
 }
 export interface ModelRootInterface {
-    eventStream?: EventStream;
+    structs: Map<string, QueryStruct>;
 }
 export interface ParentQueryModel {
     model: ModelRootInterface;
@@ -119,7 +119,6 @@ export declare class QueryStruct {
     resolveQueryFields(finalOutputStruct: (query: Query, options: PrepareResultOptions | undefined) => SourceDef | undefined): void;
     getModel(): ModelRootInterface;
     get eventStream(): EventStream | undefined;
-    setParent(parent: ParentQueryStruct | ParentQueryModel): void;
     /** makes a new queryable field object from a fieldDef */
     makeQueryField(field: FieldDef, referenceId?: string): QueryField;
     root(): QueryStruct;

package/dist/model/query_node.js

@@ -180,7 +180,6 @@ class QueryStruct {
         this.nameMap = new Map();
         this._modelTag = undefined;
         this._arguments = undefined;
-        this.setParent(parent);
         if ('model' in parent) {
             this.model = parent.model;
             this.pathAliasMap = new Map();
@@ -192,6 +191,7 @@ class QueryStruct {
             }
         }
         else {
+            this.parent = parent.struct;
             this.model = this.getModel();
             this.pathAliasMap = this.root().pathAliasMap;
             this.connectionName = this.root().connectionName;
@@ -471,18 +471,8 @@ class QueryStruct {
         }
     }
     get eventStream() {
-        return this.getModel().eventStream;
-    }
-    setParent(parent) {
-        if ('struct' in parent) {
-            this.parent = parent.struct;
-        }
-        if ('model' in parent) {
-            this.model = parent.model;
-        }
-        else {
-            this.model = this.getModel();
-        }
+        var _a;
+        return (_a = this.prepareResultOptions) === null || _a === void 0 ? void 0 : _a.eventStream;
     }
     /** makes a new queryable field object from a fieldDef */
     makeQueryField(field, referenceId) {

package/dist/model/query_query.d.ts

@@ -1,5 +1,5 @@
 import type { DialectFieldList } from '../dialect';
-import type { TurtleDef, QueryResultDef, ResultStructMetadataDef, ResultMetadataDef, PipeSegment, QuerySegment, QueryFieldDef, SegmentFieldDef } from './malloy_types';
+import type { TurtleDef, QueryResultDef, ResultStructMetadataDef, ResultMetadataDef, PipeSegment, QuerySegment, QueryFieldDef, SegmentFieldDef, Query, PrepareResultOptions } from './malloy_types';
 import { AndChain } from './utils';
 import type { JoinInstance } from './join_instance';
 import { QueryStruct, QueryField } from './query_node';
@@ -63,6 +63,22 @@ export declare class QueryQuery extends QueryField {
     /**  returns a fields and primary key of a struct for this query */
     getResultStructDef(resultStruct?: FieldInstanceResult, isRoot?: boolean): QueryResultDef;
     getStructSourceSQL(qs: QueryStruct, stageWriter: StageWriter): string;
+    /**
+     * 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: Query, prepareResultOptions: PrepareResultOptions, stageWriter: StageWriter | undefined, isJoinedSubquery: boolean): {
+        lastStageName: string;
+        stageWriter: StageWriter;
+        sql?: string;
+    };
     generateSQLJoinBlock(stageWriter: StageWriter, ji: JoinInstance, depth: number): string;
     generateSQLPassthroughKeys(qs: QueryStruct): string;
     generateSQLJoins(stageWriter: StageWriter): string;