@malloydata/malloy 0.0.428 → 0.0.430

package/dist/api/foundation/types.d.ts

@@ -1,5 +1,7 @@
 import type { EventStream } from '../../runtime_types';
-import type { BuildManifest, GivenValue, VirtualMap } from '../../model';
+import type { BuildID, BuildManifest, GivenValue, VirtualMap } from '../../model';
+import type { LogMessage } from '../../lang';
+import type { PersistSource } from './core';
 /**
  * An empty BuildManifest with no entries and strict mode off.
  * Use this to explicitly suppress manifest substitution in a query:
@@ -57,6 +59,12 @@ export interface CompileQueryOptions {
 /**
  * A node in the build graph (recursive DAG structure).
  * Uses sourceID (sourceName@modelURL) for identity.
+ *
+ * A node reached twice is the *same object* both times, so the graph shares
+ * nodes rather than copying them. Anything walking it needs a seen-set on node
+ * identity, or a chain of diamonds is exponential.
+ *
+ * @deprecated Produced only by {@link BuildPlan}. Use `BuildTarget`.
  */
 export interface BuildNode {
     /** Source identity: "sourceName@modelURL" */
@@ -67,15 +75,94 @@ export interface BuildNode {
 /**
  * An ordered build plan for sources on a single connection.
  *
- * The leveled array structure determines build order: sources in the same
- * level can be built in parallel, levels must be built sequentially.
+ * `nodes` is typed for a leveled schedule that was never produced — it always
+ * holds exactly one entry, the roots, with the real ordering in each node's
+ * `dependsOn`.
  *
- * Builders can group graphs by `connectionName` to parallelize across
- * different database connections.
+ * @deprecated Use `BuildTargets`, which reports tables rather than sources.
  */
 export interface BuildGraph {
     /** The connection all sources in this graph run on */
     connectionName: string;
-    /** The leveled build nodes */
+    /** Always one entry: the root nodes */
     nodes: BuildNode[][];
 }
+/**
+ * One artifact: a table to build, and every source that maps onto it.
+ *
+ * A `BuildNode` is a source; a `BuildTarget` is a table. The two are not the
+ * same count. `#@ persist` is an annotation, so extending or renaming a
+ * persisted source inherits it — while `extend` never changes the source's
+ * SQL — and several sources routinely name one table. The manifest is keyed by
+ * `BuildID`, so those sources share one entry no matter how many plan nodes
+ * they occupy. `Runtime.getBuildTargets()` does that merge once, in the core,
+ * instead of leaving each builder to discover it by hashing.
+ */
+export interface BuildTarget {
+    /** Manifest key for this artifact: a hash of the connection digest and `sql` */
+    buildId: BuildID;
+    /** The connection this artifact is built on */
+    connectionName: string;
+    /**
+     * The SQL the BuildID is computed from: fully inlined, no manifest
+     * substitution, so it is the same string whatever else has been built.
+     *
+     * It is not the SQL to execute. That one substitutes the tables built so far
+     * — `source.getSQL({buildManifest, connectionDigests})` — so it can only be
+     * computed as the build walks, and only by the builder holding the manifest.
+     */
+    sql: string;
+    /** Targets that must exist before this one can be built */
+    dependsOn: BuildTarget[];
+    /** Every persist source in the model that maps onto this artifact */
+    sources: PersistSource[];
+}
+/**
+ * Everything one connection has to build.
+ *
+ * `targets` is in dependency order — everything a target depends on appears
+ * before it — so the simplest correct builder is a loop:
+ *
+ * ```typescript
+ * for (const target of targets) await build(target);
+ * ```
+ *
+ * A builder that wants concurrency uses `target.dependsOn` and starts each one
+ * the moment its own dependencies finish:
+ *
+ * ```typescript
+ * const done = new Map<BuildTarget, Promise<void>>();
+ * for (const target of targets) {
+ *   done.set(target, (async () => {
+ *     await Promise.all(target.dependsOn.map(d => done.get(d)));
+ *     await build(target);
+ *   })());
+ * }
+ * await Promise.all(done.values());
+ * ```
+ *
+ * That is the maximum available: nothing waits for anything it does not read.
+ * Batching the targets into rounds instead — everything at depth 0, then
+ * everything at depth 1 — is easier to write and strictly worse, because a
+ * target then waits on unrelated work that happens to share its depth.
+ */
+export interface ConnectionBuild {
+    /** The connection everything here is built on */
+    connectionName: string;
+    /** Every table to build, dependencies before dependents */
+    targets: BuildTarget[];
+}
+/**
+ * The build schedule for a model.
+ *
+ * Connections come first because they are the largest cut of parallelism: a
+ * query cannot cross a connection, so no dependency ever does either, and each
+ * entry here is a wholly independent build that needs no coordination with any
+ * other.
+ */
+export interface BuildTargets {
+    /** One per connection, mutually independent */
+    connections: ConnectionBuild[];
+    /** Errors and warnings from parsing `#@` annotations on persistable sources */
+    tagParseLog: LogMessage[];
+}

package/dist/index.d.ts

@@ -25,7 +25,7 @@ export { routeOf, payloadOf, annotationsForRoute, tagFromAnnotations, } from './
 /** @deprecated — use the `.annotations` view on a Foundation entity
  *  (`entity.annotations.parseAsTag(route)` / `.texts(route)`). */
 export { annotationToTag, annotationToTaglines, } from './api/foundation/annotation';
-export type { BuildGraph, BuildNode, BuildPlan } from './api/foundation';
+export type { BuildGraph, BuildNode, BuildPlan, BuildTarget, BuildTargets, ConnectionBuild, } from './api/foundation';
 export { PersistSource, EMPTY_BUILD_MANIFEST } from './api/foundation';
 export { Reference } from './api/foundation';
 export type { ReferenceKind } from './api/foundation';

package/dist/lang/ast/field-space/dynamic-space.js

@@ -114,10 +114,17 @@ class DynamicSpace extends static_space_1.StaticSpace {
                 }
             }
             this.sourceDef = { ...this.fromSource, fields: [] };
-            // This is a freshly built (modified) source: it presents a new exported
-            // shape, so it is no longer a reference to the source it was built from.
-            // DefineSource resets referenceID to this source's own sourceID.
+            // A freshly built (modified) source presents a new exported shape, so it
+            // is neither a reference to what it was built from nor that source's own
+            // definition. Both identities go; `DefineSource` stamps fresh ones if
+            // this ends up with a name, and an inline `extend` never does.
+            //
+            // Dropping `sourceID` also means the persistence walk descends *through*
+            // an unnamed modification rather than resolving it by id — which is how
+            // an inline `extend` used as a query's structRef stopped hiding the
+            // sources it added.
             delete this.sourceDef.referenceID;
+            delete this.sourceDef.sourceID;
             this.sourceDef.parameters = parameters;
             const fieldIndices = new Map();
             // Need to process the entities in specific order
@@ -141,6 +148,16 @@ class DynamicSpace extends static_space_1.StaticSpace {
                 if (field instanceof join_space_field_1.JoinSpaceField) {
                     const joinStruct = field.join.getStructDef(parameterSpace);
                     if (!error_factory_1.ErrorFactory.didCreate(joinStruct)) {
+                        // A query runs on one connection, so everything reachable from
+                        // the source it runs on must live on that connection. Record and
+                        // array joins are part of the row, and so have no connection.
+                        // A base whose schema could not be fetched has the error
+                        // connection, which is not worth complaining about twice.
+                        if (model.isSourceDef(joinStruct) &&
+                            !error_factory_1.ErrorFactory.didCreate(this.fromSource) &&
+                            joinStruct.connection !== this.connectionName()) {
+                            field.join.sourceExpr.logError('join-connection-mismatch', `Cannot join '${name}', which is on connection '${joinStruct.connection}', into a source on connection '${this.connectionName()}'`);
+                        }
                         fieldIndices.set(name, this.sourceDef.fields.length);
                         this.sourceDef.fields.push(joinStruct);
                         field.join.fixupJoinOn(this, joinStruct);

package/dist/lang/ast/query-elements/query-arrow.d.ts

@@ -13,5 +13,5 @@ export declare class QueryArrow extends QueryBase implements QueryElement {
     readonly view: View;
     elementType: string;
     constructor(source: Source | QueryElement, view: View);
-    queryComp(isRefOk: boolean): QueryComp;
+    queryComp(isRefOk: boolean, isPartialOk: boolean): QueryComp;
 }

package/dist/lang/ast/query-elements/query-arrow.js

@@ -10,6 +10,7 @@ const source_1 = require("../source-elements/source");
 const static_space_1 = require("../field-space/static-space");
 const query_base_1 = require("./query-base");
 const composite_source_utils_1 = require("../../composite-source-utils");
+const query_utils_1 = require("../query-utils");
 /**
  * A query operation that adds segments to a LHS source or query.
  *
@@ -22,7 +23,7 @@ class QueryArrow extends query_base_1.QueryBase {
         this.view = view;
         this.elementType = 'arrow';
     }
-    queryComp(isRefOk) {
+    queryComp(isRefOk, isPartialOk) {
         var _a;
         let inputStruct;
         let queryBase;
@@ -46,7 +47,9 @@ class QueryArrow extends query_base_1.QueryBase {
         }
         else {
             // We are adding a second stage to the given "source" query; we get the query and add a segment
-            const lhsQuery = this.source.queryComp(isRefOk);
+            // The LHS stages are complete stages, nothing will refine them, so they
+            // are never allowed to be partial no matter what this caller accepts.
+            const lhsQuery = this.source.queryComp(isRefOk, false);
             queryBase = lhsQuery.query;
             inputStruct = lhsQuery.outputStruct;
             fieldSpace = new static_space_1.StaticSourceSpace(lhsQuery.outputStruct, 'public');
@@ -77,12 +80,15 @@ class QueryArrow extends query_base_1.QueryBase {
                 : // Otherwise just use the `inputStruct`
                     inputStruct, rhsPipeline),
         ];
+        const finalPipeline = isPartialOk
+            ? pipelineWithExpandedFieldUsage
+            : (0, query_utils_1.detectAndRemovePartialStages)(pipelineWithExpandedFieldUsage, this);
         return {
             query: {
                 ...query,
                 compositeResolvedSourceDef,
-                pipeline: pipelineWithExpandedFieldUsage,
-                givenUsage: (0, composite_source_utils_1.computeQueryGivenUsage)(pipelineWithExpandedFieldUsage),
+                pipeline: finalPipeline,
+                givenUsage: (0, composite_source_utils_1.computeQueryGivenUsage)(finalPipeline),
             },
             outputStruct,
             inputStruct,

package/dist/lang/ast/query-elements/query-base.d.ts

@@ -2,7 +2,7 @@ import { type PipeSegment, type Query, type SourceDef } from '../../../model/mal
 import { MalloyElement } from '../types/malloy-element';
 import type { QueryComp } from '../types/query-comp';
 export declare abstract class QueryBase extends MalloyElement {
-    abstract queryComp(isRefOk: boolean): QueryComp;
+    abstract queryComp(isRefOk: boolean, isPartialOk: boolean): QueryComp;
     protected expandRefUsage(inputSource: SourceDef, pipeline: PipeSegment[]): PipeSegment[];
     protected resolveCompositeSource(inputSource: SourceDef, pipeline: PipeSegment[]): SourceDef | undefined;
     query(isRefOk?: boolean): Query;

package/dist/lang/ast/query-elements/query-base.js

@@ -8,7 +8,6 @@ exports.QueryBase = void 0;
 const composite_source_utils_1 = require("../../composite-source-utils");
 const malloy_types_1 = require("../../../model/malloy_types");
 const error_factory_1 = require("../error-factory");
-const query_utils_1 = require("../query-utils");
 const malloy_element_1 = require("../types/malloy-element");
 class QueryBase extends malloy_element_1.MalloyElement {
     expandRefUsage(inputSource, pipeline) {
@@ -40,11 +39,7 @@ class QueryBase extends malloy_element_1.MalloyElement {
         return undefined;
     }
     query(isRefOk = true) {
-        const { query } = this.queryComp(isRefOk);
-        return {
-            ...query,
-            pipeline: (0, query_utils_1.detectAndRemovePartialStages)(query.pipeline, this),
-        };
+        return this.queryComp(isRefOk, false).query;
     }
 }
 exports.QueryBase = QueryBase;

package/dist/lang/ast/query-elements/query-raw.d.ts

@@ -15,6 +15,6 @@ export declare class QueryRaw extends MalloyElement implements QueryElement {
     readonly source: Source;
     elementType: string;
     constructor(source: Source);
-    queryComp(isRefOk: boolean): QueryComp;
+    queryComp(isRefOk: boolean, _isPartialOk: boolean): QueryComp;
     query(isRefOk?: boolean): Query;
 }

package/dist/lang/ast/query-elements/query-raw.js

@@ -21,7 +21,9 @@ class QueryRaw extends malloy_element_1.MalloyElement {
         this.source = source;
         this.elementType = 'query-raw';
     }
-    queryComp(isRefOk) {
+    // A raw segment has no query class to decide, so it is never partial and
+    // `isPartialOk` has nothing to say here.
+    queryComp(isRefOk, _isPartialOk) {
         const invoked = isRefOk
             ? this.source.structRef(undefined)
             : { structRef: this.source.getSourceDef(undefined) };
@@ -40,7 +42,7 @@ class QueryRaw extends malloy_element_1.MalloyElement {
         };
     }
     query(isRefOk = true) {
-        return this.queryComp(isRefOk).query;
+        return this.queryComp(isRefOk, false).query;
     }
 }
 exports.QueryRaw = QueryRaw;

package/dist/lang/ast/query-elements/query-reference.d.ts

@@ -12,6 +12,6 @@ export declare class QueryReference extends MalloyElement implements QueryElemen
     readonly name: ModelEntryReference;
     elementType: string;
     constructor(name: ModelEntryReference);
-    queryComp(isRefOk: boolean): QueryComp;
+    queryComp(isRefOk: boolean, isPartialOk: boolean): QueryComp;
     query(isRefOk?: boolean): Query;
 }

package/dist/lang/ast/query-elements/query-reference.js

@@ -8,6 +8,7 @@ exports.QueryReference = void 0;
 const error_factory_1 = require("../error-factory");
 const malloy_element_1 = require("../types/malloy-element");
 const query_head_struct_1 = require("./query-head-struct");
+const query_utils_1 = require("../query-utils");
 const malloy_types_1 = require("../../../model/malloy_types");
 /**
  * A query operation that is just a reference to an existing query.
@@ -20,7 +21,7 @@ class QueryReference extends malloy_element_1.MalloyElement {
         this.name = name;
         this.elementType = 'query-reference';
     }
-    queryComp(isRefOk) {
+    queryComp(isRefOk, isPartialOk) {
         const headEntry = this.modelEntry(this.name);
         const query = headEntry === null || headEntry === void 0 ? void 0 : headEntry.entry;
         const oops = function () {
@@ -45,7 +46,12 @@ class QueryReference extends malloy_element_1.MalloyElement {
                     ? query
                     : { ...query, structRef: inputStruct };
             return {
-                query: unRefedQuery,
+                query: isPartialOk
+                    ? unRefedQuery
+                    : {
+                        ...unRefedQuery,
+                        pipeline: (0, query_utils_1.detectAndRemovePartialStages)(unRefedQuery.pipeline, this),
+                    },
                 outputStruct,
                 inputStruct,
             };
@@ -54,7 +60,7 @@ class QueryReference extends malloy_element_1.MalloyElement {
         return oops();
     }
     query(isRefOk = true) {
-        return this.queryComp(isRefOk).query;
+        return this.queryComp(isRefOk, false).query;
     }
 }
 exports.QueryReference = QueryReference;

package/dist/lang/ast/query-elements/query-refine.d.ts

@@ -12,5 +12,5 @@ export declare class QueryRefine extends QueryBase implements QueryElement {
     readonly refinement: View;
     elementType: string;
     constructor(base: QueryElement, refinement: View);
-    queryComp(isRefOk: boolean): QueryComp;
+    queryComp(isRefOk: boolean, isPartialOk: boolean): QueryComp;
 }

package/dist/lang/ast/query-elements/query-refine.js

@@ -8,6 +8,7 @@ exports.QueryRefine = void 0;
 const static_space_1 = require("../field-space/static-space");
 const query_base_1 = require("./query-base");
 const composite_source_utils_1 = require("../../composite-source-utils");
+const query_utils_1 = require("../query-utils");
 /**
  * A query operation that consists of an exisitng query with refinements.
  *
@@ -20,8 +21,10 @@ class QueryRefine extends query_base_1.QueryBase {
         this.refinement = refinement;
         this.elementType = 'query-refine';
     }
-    queryComp(isRefOk) {
-        const q = this.base.queryComp(isRefOk);
+    queryComp(isRefOk, isPartialOk) {
+        // The refinement is what decides the query class, so the base is the one
+        // place a partial segment is expected rather than an error.
+        const q = this.base.queryComp(isRefOk, true);
         const inputFS = new static_space_1.StaticSourceSpace(q.inputStruct, 'public');
         const pipeline = this.refinement.refine(inputFS, q.query.pipeline, undefined);
         const query = {
@@ -30,12 +33,15 @@ class QueryRefine extends query_base_1.QueryBase {
         };
         const compositeResolvedSourceDef = this.resolveCompositeSource(q.inputStruct, pipeline);
         const pipelineWithExpandedFieldUsage = this.expandRefUsage(compositeResolvedSourceDef !== null && compositeResolvedSourceDef !== void 0 ? compositeResolvedSourceDef : q.inputStruct, pipeline);
+        const finalPipeline = isPartialOk
+            ? pipelineWithExpandedFieldUsage
+            : (0, query_utils_1.detectAndRemovePartialStages)(pipelineWithExpandedFieldUsage, this);
         return {
             query: {
                 ...query,
                 compositeResolvedSourceDef,
-                pipeline: pipelineWithExpandedFieldUsage,
-                givenUsage: (0, composite_source_utils_1.computeQueryGivenUsage)(pipelineWithExpandedFieldUsage),
+                pipeline: finalPipeline,
+                givenUsage: (0, composite_source_utils_1.computeQueryGivenUsage)(finalPipeline),
             },
             // TODO bleh
             outputStruct: pipeline[pipeline.length - 1].outputStruct,

package/dist/lang/ast/source-elements/query-source.js

@@ -18,7 +18,7 @@ class QuerySource extends source_1.Source {
         return this.withParameters(parameterSpace, undefined);
     }
     withParameters(parameterSpace, pList) {
-        const comp = this.query.queryComp(false);
+        const comp = this.query.queryComp(false, false);
         const queryStruct = (0, source_def_utils_1.mkQuerySourceDef)(comp.outputStruct, comp.query, `QuerySource-${(0, uuid_1.v4)()}`);
         return {
             ...queryStruct,

package/dist/lang/ast/source-elements/sql-source.js

@@ -22,7 +22,7 @@ class SQLSource extends source_1.Source {
         const partialModel = this.select.containsQueries
             ? doc.modelDef()
             : undefined;
-        const [valid, phrases] = this.select.sqlPhrases();
+        const [valid, phrases] = this.select.sqlPhrases(this.connectionName.refString);
         if (valid) {
             return (0, sql_block_1.getSourceRequest)(phrases, this.connectionName.refString, partialModel);
         }
@@ -123,7 +123,7 @@ class SQLSource extends source_1.Source {
                 location: this.location,
             };
             // Use factory to create SQLSourceDef without propagating sourceID/extends
-            const [_valid, phrases] = this.select.sqlPhrases();
+            const [_valid, phrases] = this.select.sqlPhrases(this.connectionName.refString);
             const selectSegments = this.select.containsQueries ? phrases : undefined;
             const locStruct = (0, source_def_utils_1.mkSQLSourceDef)(baseStruct, lookup.value.selectStr, selectSegments);
             return locStruct;

package/dist/lang/ast/source-query-elements/source-query-element.d.ts

@@ -9,10 +9,37 @@ import type { LogMessageOptions, MessageCode, MessageParameterType } from '../..
  * a query.
  */
 export declare abstract class SourceQueryElement extends MalloyElement {
+    /** Set once this element has reported why it could not produce a value. */
     errored: boolean;
     getSource(): Source | undefined;
     getQuery(): QueryElement | undefined;
     isSource(): boolean;
+    /**
+     * Report the one message which explains why this expression could not be
+     * turned into a source or a query.
+     *
+     * Every element in a source/query expression says something when it fails,
+     * so an outer element's generic complaint ("could not get source for
+     * query") would stack on top of the specific cause already reported
+     * beneath it. The message is therefore logged only when nothing in this
+     * subtree has spoken yet, and `errored` is set either way, which is what
+     * silences the elements above.
+     *
+     * This is not protection against logging the same message twice —
+     * `MalloyElement.log` already drops a repeat of one message at one
+     * location. It is one message per failed expression.
+     *
+     * The case it does not serve is two unrelated complaints about the same
+     * element: a second `sqLog` is dropped. Use `sqClaimError` for those.
+     */
     sqLog<T extends MessageCode>(code: T, parameters: MessageParameterType<T>, options?: LogMessageOptions): T;
+    /**
+     * Take the one error report this expression is allowed, for an element with
+     * more than one complaint to make. False means something below has already
+     * spoken. True means the caller owns the report and should `logError` each
+     * of its complaints; nothing above will speak after that.
+     */
+    sqClaimError(): boolean;
+    /** True until this element, or anything below it, has reported a failure. */
     isErrorFree(): boolean;
 }

package/dist/lang/ast/source-query-elements/source-query-element.js

@@ -15,6 +15,7 @@ const malloy_element_1 = require("../types/malloy-element");
 class SourceQueryElement extends malloy_element_1.MalloyElement {
     constructor() {
         super(...arguments);
+        /** Set once this element has reported why it could not produce a value. */
         this.errored = false;
     }
     getSource() {
@@ -26,6 +27,24 @@ class SourceQueryElement extends malloy_element_1.MalloyElement {
     isSource() {
         return false;
     }
+    /**
+     * Report the one message which explains why this expression could not be
+     * turned into a source or a query.
+     *
+     * Every element in a source/query expression says something when it fails,
+     * so an outer element's generic complaint ("could not get source for
+     * query") would stack on top of the specific cause already reported
+     * beneath it. The message is therefore logged only when nothing in this
+     * subtree has spoken yet, and `errored` is set either way, which is what
+     * silences the elements above.
+     *
+     * This is not protection against logging the same message twice —
+     * `MalloyElement.log` already drops a repeat of one message at one
+     * location. It is one message per failed expression.
+     *
+     * The case it does not serve is two unrelated complaints about the same
+     * element: a second `sqLog` is dropped. Use `sqClaimError` for those.
+     */
     sqLog(code, parameters, options) {
         if (this.isErrorFree()) {
             this.logError(code, parameters, options);
@@ -33,6 +52,20 @@ class SourceQueryElement extends malloy_element_1.MalloyElement {
         this.errored = true;
         return code;
     }
+    /**
+     * Take the one error report this expression is allowed, for an element with
+     * more than one complaint to make. False means something below has already
+     * spoken. True means the caller owns the report and should `logError` each
+     * of its complaints; nothing above will speak after that.
+     */
+    sqClaimError() {
+        if (!this.isErrorFree()) {
+            return false;
+        }
+        this.errored = true;
+        return true;
+    }
+    /** True until this element, or anything below it, has reported a failure. */
     isErrorFree() {
         if (this.errored) {
             return false;

package/dist/lang/ast/source-query-elements/sq-arrow.d.ts

@@ -16,6 +16,8 @@ export declare class SQArrow extends SourceQueryElement {
     readonly applyTo: SourceQueryElement;
     readonly operation: View;
     elementType: string;
+    asQuery?: QueryElement;
+    asSource?: Source;
     constructor(applyTo: SourceQueryElement, operation: View);
     getQuery(): QueryElement | undefined;
     getSource(): Source | undefined;

package/dist/lang/ast/source-query-elements/sq-arrow.js

@@ -26,6 +26,9 @@ class SQArrow extends source_query_element_1.SourceQueryElement {
         this.elementType = 'sq-arrow';
     }
     getQuery() {
+        if (this.asQuery) {
+            return this.asQuery;
+        }
         const lhs = this.applyTo.isSource()
             ? this.applyTo.getSource()
             : this.applyTo.getQuery();
@@ -33,19 +36,22 @@ class SQArrow extends source_query_element_1.SourceQueryElement {
             this.sqLog('failed-to-compute-arrow-source', 'Could not get LHS of arrow operation');
             return;
         }
-        const arr = new query_arrow_1.QueryArrow(lhs, this.operation);
-        this.has({ query: arr });
-        return arr;
+        this.asQuery = new query_arrow_1.QueryArrow(lhs, this.operation);
+        this.has({ query: this.asQuery });
+        return this.asQuery;
     }
     getSource() {
+        if (this.asSource) {
+            return this.asSource;
+        }
         const query = this.getQuery();
         if (!query) {
             this.sqLog('failed-to-compute-source-from-query', "Couldn't comprehend query well enough to make a source");
             return;
         }
-        const asSource = new query_source_1.QuerySource(query);
-        this.has({ asSource });
-        return asSource;
+        this.asSource = new query_source_1.QuerySource(query);
+        this.has({ asSource: this.asSource });
+        return this.asSource;
     }
 }
 exports.SQArrow = SQArrow;

package/dist/lang/ast/source-query-elements/sq-refine.d.ts

@@ -12,6 +12,8 @@ export declare class SQRefine extends SourceQueryElement {
     readonly toRefine: SourceQueryElement;
     readonly refine: View;
     elementType: string;
+    asQuery?: QueryRefine;
+    asSource?: QuerySource;
     constructor(toRefine: SourceQueryElement, refine: View);
     getQuery(): QueryRefine | undefined;
     getSource(): QuerySource | undefined;

package/dist/lang/ast/source-query-elements/sq-refine.js

@@ -23,6 +23,9 @@ class SQRefine extends source_query_element_1.SourceQueryElement {
         this.elementType = 'sq-refine';
     }
     getQuery() {
+        if (this.asQuery) {
+            return this.asQuery;
+        }
         if (this.toRefine.isSource()) {
             if (this.toRefine instanceof sq_reference_1.SQReference) {
                 this.sqLog('illegal-refinement-of-source', `Cannot add view refinements to '${this.toRefine.ref.refString}' because it is a source`);
@@ -34,17 +37,20 @@ class SQRefine extends source_query_element_1.SourceQueryElement {
         }
         const refinedQuery = this.toRefine.getQuery();
         if (refinedQuery) {
-            const resultQuery = new query_refine_1.QueryRefine(refinedQuery, this.refine);
-            this.has({ query: resultQuery });
-            return resultQuery;
+            this.asQuery = new query_refine_1.QueryRefine(refinedQuery, this.refine);
+            this.has({ query: this.asQuery });
+            return this.asQuery;
         }
     }
     getSource() {
+        if (this.asSource) {
+            return this.asSource;
+        }
         const query = this.getQuery();
         if (query) {
-            const queryAsSource = new query_source_1.QuerySource(query);
-            this.has({ queryAsSource });
-            return queryAsSource;
+            this.asSource = new query_source_1.QuerySource(query);
+            this.has({ queryAsSource: this.asSource });
+            return this.asSource;
         }
     }
 }

package/dist/lang/ast/source-query-elements/sq-source.d.ts

@@ -10,6 +10,7 @@ import { QueryRaw } from '../query-elements/query-raw';
 export declare class SQSource extends SourceQueryElement {
     readonly theSource: Source;
     elementType: string;
+    asQuery?: QueryRaw;
     constructor(theSource: Source);
     isSource(): boolean;
     getSource(): Source;

package/dist/lang/ast/source-query-elements/sq-source.js

@@ -27,10 +27,13 @@ class SQSource extends source_query_element_1.SourceQueryElement {
         return this.theSource;
     }
     getQuery() {
+        if (this.asQuery) {
+            return this.asQuery;
+        }
         if (this.theSource instanceof sql_source_1.SQLSource) {
-            const rawQuery = new query_raw_1.QueryRaw(this.theSource);
-            this.has({ rawQuery });
-            return rawQuery;
+            this.asQuery = new query_raw_1.QueryRaw(this.theSource);
+            this.has({ rawQuery: this.asQuery });
+            return this.asQuery;
         }
         else {
             this.sqLog('invalid-source-as-query', 'This source cannot be used as a query');

package/dist/lang/ast/sql-elements/sql-string.d.ts

@@ -8,6 +8,6 @@ export declare class SQLString extends MalloyElement {
     containsQueries: boolean;
     complete(): void;
     push(el: string | MalloyElement): void;
-    sqlPhrases(): [boolean, SQLPhraseSegment[]];
+    sqlPhrases(forConnection: string): [boolean, SQLPhraseSegment[]];
 }
 export {};