@malloydata/malloy 0.0.427 → 0.0.429

package/dist/lang/ast/expressions/expr-now.js

@@ -11,7 +11,7 @@ class ExprNow extends expression_def_1.ExpressionDef {
         super(...arguments);
         this.elementType = 'timestamp';
     }
-    getExpression(_fs) {
+    computeExpression(_fs) {
         return {
             type: 'timestamp',
             expressionType: 'scalar',

package/dist/lang/ast/expressions/expr-null.d.ts

@@ -3,7 +3,7 @@ import type { ExprValue } from '../types/expr-value';
 import { ATNodeType, ExpressionDef } from '../types/expression-def';
 export declare class ExprNULL extends ExpressionDef {
     elementType: string;
-    getExpression(): ExprValue;
+    protected computeExpression(): ExprValue;
     apply(fs: FieldSpace, op: BinaryMalloyOperator, left: ExpressionDef): ExprValue;
 }
 export declare class PartialIsNull extends ExpressionDef {
@@ -12,7 +12,7 @@ export declare class PartialIsNull extends ExpressionDef {
     constructor(op: '=' | '!=');
     apply(fs: FieldSpace, op: string, expr: ExpressionDef): ExprValue;
     requestExpression(_fs: FieldSpace): ExprValue | undefined;
-    getExpression(_fs: FieldSpace): ExprValue;
+    protected computeExpression(_fs: FieldSpace): ExprValue;
     atNodeType(): ATNodeType;
 }
 export declare class ExprIsNull extends ExpressionDef {
@@ -20,5 +20,5 @@ export declare class ExprIsNull extends ExpressionDef {
     readonly op: '=' | '!=';
     elementType: string;
     constructor(expr: ExpressionDef, op: '=' | '!=');
-    getExpression(fs: FieldSpace): ExprValue;
+    protected computeExpression(fs: FieldSpace): ExprValue;
 }

package/dist/lang/ast/expressions/expr-null.js

@@ -8,20 +8,25 @@ exports.ExprIsNull = exports.PartialIsNull = exports.ExprNULL = void 0;
 const expr_value_1 = require("../types/expr-value");
 const expression_def_1 = require("../types/expression-def");
 function doIsNull(fs, op, expr) {
+    // Build a new value rather than retyping the operand's in place: what
+    // getExpression hands back is shared, and the operand is usually asked for
+    // its value again after this.
     const nullCmp = expr.getExpression(fs);
-    nullCmp.type = 'boolean';
-    nullCmp.value = {
-        node: op === '=' ? 'is-null' : 'is-not-null',
-        e: nullCmp.value,
-    };
-    return nullCmp;
+    return (0, expr_value_1.computedExprValue)({
+        dataType: { type: 'boolean' },
+        value: {
+            node: op === '=' ? 'is-null' : 'is-not-null',
+            e: nullCmp.value,
+        },
+        from: [nullCmp],
+    });
 }
 class ExprNULL extends expression_def_1.ExpressionDef {
     constructor() {
         super(...arguments);
         this.elementType = 'NULL';
     }
-    getExpression() {
+    computeExpression() {
         return (0, expr_value_1.literalExprValue)({
             dataType: { type: 'null' },
             value: { node: 'null' },
@@ -47,7 +52,7 @@ class PartialIsNull extends expression_def_1.ExpressionDef {
     requestExpression(_fs) {
         return undefined;
     }
-    getExpression(_fs) {
+    computeExpression(_fs) {
         return this.loggedErrorExpr('partial-as-value', 'Partial null check does not have a value');
     }
     atNodeType() {
@@ -63,7 +68,7 @@ class ExprIsNull extends expression_def_1.ExpressionDef {
         this.elementType = 'is null';
         this.has({ expr });
     }
-    getExpression(fs) {
+    computeExpression(fs) {
         return doIsNull(fs, this.op, this.expr);
     }
 }

package/dist/lang/ast/expressions/expr-number.d.ts

@@ -6,7 +6,7 @@ export declare class ExprNumber extends ExpressionDef {
     readonly n: string;
     elementType: string;
     constructor(n: string);
-    getExpression(fs: FieldSpace): ExprValue;
+    protected computeExpression(fs: FieldSpace): ExprValue;
     /**
      * Default number type when no dialect is available.
      * Integers default to bigint for safety, floats to float.

package/dist/lang/ast/expressions/expr-number.js

@@ -13,7 +13,7 @@ class ExprNumber extends expression_def_1.ExpressionDef {
         this.n = n;
         this.elementType = 'numeric literal';
     }
-    getExpression(fs) {
+    computeExpression(fs) {
         var _a;
         const dialect = fs.dialectObj();
         const dataType = (_a = dialect === null || dialect === void 0 ? void 0 : dialect.literalNumberType(this.n)) !== null && _a !== void 0 ? _a : this.defaultNumberType();

package/dist/lang/ast/expressions/expr-parens.d.ts

@@ -7,7 +7,7 @@ export declare class ExprParens extends ExpressionDef {
     elementType: string;
     constructor(expr: ExpressionDef);
     requestExpression(fs: FieldSpace): ExprValue | undefined;
-    getExpression(fs: FieldSpace): ExprValue;
+    protected computeExpression(fs: FieldSpace): ExprValue;
     apply(fs: FieldSpace, op: BinaryMalloyOperator, left: ExpressionDef, doWarn: boolean): ExprValue;
     atNodeType(): ATNodeType;
     atExpr(): ExpressionDef;

package/dist/lang/ast/expressions/expr-parens.js

@@ -15,15 +15,18 @@ class ExprParens extends expression_def_1.ExpressionDef {
     requestExpression(fs) {
         return this.expr.requestExpression(fs);
     }
-    getExpression(fs) {
+    computeExpression(fs) {
         const subExpr = this.expr.getExpression(fs);
         return { ...subExpr, value: { node: '()', e: subExpr.value } };
     }
     apply(fs, op, left, doWarn) {
         if (this.expr.atNodeType() === expression_def_1.ATNodeType.Or) {
+            // Parens are invisible to `?`/`=`, so hand the tree the operator and
+            // doWarn, which decides whether an un-collapsible `|` list is worth a
+            // warning. The base ignores doWarn, which is why it is not passed on.
             return this.expr.apply(fs, op, left, doWarn);
         }
-        return (0, expression_def_1.applyBinary)(fs, left, op, this);
+        return super.apply(fs, op, left);
     }
     atNodeType() {
         return this.expr.atNodeType();

package/dist/lang/ast/expressions/expr-props.d.ts

@@ -10,7 +10,7 @@ export declare class ExprProps extends ExpressionDef {
     legalChildTypes: import("../../..").TypeDesc[];
     constructor(expr: ExpressionDef, statements: FieldPropStatement[]);
     private getFilteredExpression;
-    getExpression(fs: FieldSpace): ExprValue;
+    protected computeExpression(fs: FieldSpace): ExprValue;
     getGroupedBys(fs: FieldSpace, expr: ExprValue, groupedBys: GroupedBy[]): {
         requiresGroupBy: import("../../../model").RequiredGroupBy[] | undefined;
         type: "string";

package/dist/lang/ast/expressions/expr-props.js

@@ -87,7 +87,7 @@ class ExprProps extends expression_def_1.ExpressionDef {
         }
         return expr;
     }
-    getExpression(fs) {
+    computeExpression(fs) {
         const partitionBys = [];
         let limit;
         const orderBys = [];

package/dist/lang/ast/expressions/expr-record-literal.d.ts

@@ -19,7 +19,7 @@ export declare class RecordLiteral extends ExpressionDef {
     readonly pairs: RecordElement[];
     elementType: string;
     constructor(pairs: RecordElement[]);
-    getExpression(fs: FieldSpace): ExprValue;
+    protected computeExpression(fs: FieldSpace): ExprValue;
     getRecord(fs: FieldSpace, kidNames: string[]): ExprValue;
     getNextElement(fs: FieldSpace, headValue: ExprValue): ExprValue;
 }

package/dist/lang/ast/expressions/expr-record-literal.js

@@ -70,7 +70,7 @@ class RecordLiteral extends expression_def_1.ExpressionDef {
         this.elementType = 'record literal';
         this.has({ pairs });
     }
-    getExpression(fs) {
+    computeExpression(fs) {
         return this.getRecord(fs, []);
     }
     getRecord(fs, kidNames) {

package/dist/lang/ast/expressions/expr-regex.d.ts

@@ -4,5 +4,5 @@ export declare class ExprRegEx extends ExpressionDef {
     readonly regex: string;
     elementType: string;
     constructor(regex: string);
-    getExpression(): ExprValue;
+    protected computeExpression(): ExprValue;
 }

package/dist/lang/ast/expressions/expr-regex.js

@@ -13,7 +13,7 @@ class ExprRegEx extends expression_def_1.ExpressionDef {
         this.regex = regex;
         this.elementType = 'regular expression literal';
     }
-    getExpression() {
+    computeExpression() {
         return (0, expr_value_1.literalExprValue)({
             dataType: { type: 'regular expression' },
             value: { node: 'regexpLiteral', literal: this.regex },

package/dist/lang/ast/expressions/expr-string.d.ts

@@ -6,6 +6,6 @@ export declare class ExprString extends ExpressionDef {
     elementType: string;
     value: string;
     constructor(src: string);
-    getExpression(_fs: FieldSpace): ExprValue;
+    protected computeExpression(_fs: FieldSpace): ExprValue;
     getStableLiteral(): Malloy.LiteralValue;
 }

package/dist/lang/ast/expressions/expr-string.js

@@ -13,7 +13,7 @@ class ExprString extends expression_def_1.ExpressionDef {
         this.elementType = 'string literal';
         this.value = src;
     }
-    getExpression(_fs) {
+    computeExpression(_fs) {
         return (0, expr_value_1.literalExprValue)({
             dataType: { type: 'string' },
             value: { node: 'stringLiteral', literal: this.value },

package/dist/lang/ast/expressions/expr-time-extract.d.ts

@@ -9,5 +9,5 @@ export declare class ExprTimeExtract extends ExpressionDef {
     static pluralMap: Record<string, ExtractUnit>;
     static extractor(funcName: string): ExtractUnit | undefined;
     constructor(extractText: string, args: ExpressionDef[]);
-    getExpression(fs: FieldSpace): ExprValue;
+    protected computeExpression(fs: FieldSpace): ExprValue;
 }

package/dist/lang/ast/expressions/expr-time-extract.js

@@ -25,7 +25,7 @@ class ExprTimeExtract extends expression_def_1.ExpressionDef {
         this.args = args;
         this.elementType = 'timeExtract';
     }
-    getExpression(fs) {
+    computeExpression(fs) {
         const extractTo = ExprTimeExtract.extractor(this.extractText);
         if (extractTo) {
             if (this.args.length !== 1) {

package/dist/lang/ast/expressions/expr-time.d.ts

@@ -6,6 +6,6 @@ export declare class ExprTime extends ExpressionDef {
     elementType: string;
     readonly translationValue: ExprValue;
     constructor(timeType: TemporalFieldType, value: Expr, from?: ExprValue[]);
-    getExpression(_fs: FieldSpace): ExprValue;
+    protected computeExpression(_fs: FieldSpace): ExprValue;
     static fromValue(timeType: TemporalFieldType, expr: ExprValue): ExprTime;
 }

package/dist/lang/ast/expressions/expr-time.js

@@ -19,7 +19,7 @@ class ExprTime extends expression_def_1.ExpressionDef {
             from: from !== null && from !== void 0 ? from : [],
         });
     }
-    getExpression(_fs) {
+    computeExpression(_fs) {
         return this.translationValue;
     }
     static fromValue(timeType, expr) {

package/dist/lang/ast/expressions/expr-ungroup.d.ts

@@ -8,5 +8,5 @@ export declare class ExprUngroup extends ExpressionDef {
     legalChildTypes: import("../../..").TypeDesc[];
     elementType: string;
     constructor(control: 'all' | 'exclude', expr: ExpressionDef, fields: FieldName[]);
-    getExpression(fs: FieldSpace): ExprValue;
+    protected computeExpression(fs: FieldSpace): ExprValue;
 }

package/dist/lang/ast/expressions/expr-ungroup.js

@@ -52,7 +52,7 @@ class ExprUngroup extends expression_def_1.ExpressionDef {
         this.legalChildTypes = TDU.anyAtomicT;
         this.elementType = 'ungroup';
     }
-    getExpression(fs) {
+    computeExpression(fs) {
         var _a;
         const exprVal = this.expr.getExpression(fs);
         if (!(0, malloy_types_1.expressionIsAggregate)(exprVal.expressionType)) {

package/dist/lang/ast/expressions/for-range.d.ts

@@ -12,5 +12,5 @@ export declare class ForRange extends ExpressionDef {
     constructor(from: ExpressionDef, duration: ExpressionDef, timeframe: Timeframe);
     apply(fs: FieldSpace, op: BinaryMalloyOperator, expr: ExpressionDef): ExprValue;
     requestExpression(_fs: FieldSpace): undefined;
-    getExpression(_fs: FieldSpace): ExprValue;
+    protected computeExpression(_fs: FieldSpace): ExprValue;
 }

package/dist/lang/ast/expressions/for-range.js

@@ -110,7 +110,7 @@ class ForRange extends expression_def_1.ExpressionDef {
     requestExpression(_fs) {
         return undefined;
     }
-    getExpression(_fs) {
+    computeExpression(_fs) {
         return this.loggedErrorExpr('range-as-value', 'A Range is not a value');
     }
 }

package/dist/lang/ast/expressions/partial-compare.d.ts

@@ -10,6 +10,6 @@ export declare class PartialCompare extends ExpressionDef {
     granular(): boolean;
     apply(fs: FieldSpace, op: string, expr: ExpressionDef): ExprValue;
     requestExpression(_fs: FieldSpace): ExprValue | undefined;
-    getExpression(_fs: FieldSpace): ExprValue;
+    protected computeExpression(_fs: FieldSpace): ExprValue;
     atNodeType(): ATNodeType;
 }

package/dist/lang/ast/expressions/partial-compare.js

@@ -22,7 +22,7 @@ class PartialCompare extends expression_def_1.ExpressionDef {
     requestExpression(_fs) {
         return undefined;
     }
-    getExpression(_fs) {
+    computeExpression(_fs) {
         return this.loggedErrorExpr('partial-as-value', 'Partial comparison does not have a value');
     }
     atNodeType() {

package/dist/lang/ast/expressions/pick-when.d.ts

@@ -9,7 +9,7 @@ export declare class Pick extends ExpressionDef {
     constructor(choices: PickWhen[], elsePick?: ExpressionDef | undefined);
     requestExpression(fs: FieldSpace): ExprValue | undefined;
     apply(fs: FieldSpace, op: string, expr: ExpressionDef): ExprValue;
-    getExpression(fs: FieldSpace): ExprValue;
+    protected computeExpression(fs: FieldSpace): ExprValue;
 }
 export declare class PickWhen extends MalloyElement {
     readonly pick: ExpressionDef | undefined;

package/dist/lang/ast/expressions/pick-when.js

@@ -138,7 +138,7 @@ class Pick extends expression_def_1.ExpressionDef {
             from: dependents,
         });
     }
-    getExpression(fs) {
+    computeExpression(fs) {
         const pick = {
             node: 'case',
             kids: {

package/dist/lang/ast/expressions/range.d.ts

@@ -9,5 +9,5 @@ export declare class Range extends ExpressionDef {
     constructor(first: ExpressionDef, last: ExpressionDef);
     apply(fs: FieldSpace, op: BinaryMalloyOperator, expr: ExpressionDef): ExprValue;
     requestExpression(_fs: FieldSpace): undefined;
-    getExpression(_fs: FieldSpace): ExprValue;
+    protected computeExpression(_fs: FieldSpace): ExprValue;
 }

package/dist/lang/ast/expressions/range.js

@@ -56,7 +56,7 @@ class Range extends expression_def_1.ExpressionDef {
     requestExpression(_fs) {
         return undefined;
     }
-    getExpression(_fs) {
+    computeExpression(_fs) {
         this.logError('range-as-value', 'A Range is not a value');
         return (0, ast_utils_1.errorFor)('a range is not a value');
     }

package/dist/lang/ast/expressions/time-literal.d.ts

@@ -31,7 +31,7 @@ export declare abstract class TimeLiteral extends ExpressionDef {
     }) | (import("../../../model").TimestamptzTypeDef & import("../../../model").TypeInfo & import("../types/expr-result").WithValue & {
         timeframe?: TimestampUnit;
     });
-    getExpression(fs: FieldSpace): ExprValue;
+    protected computeExpression(fs: FieldSpace): ExprValue;
     getNext(fs: FieldSpace): ExprValue | undefined;
     granular(): boolean;
 }
@@ -62,7 +62,7 @@ export declare class LiteralHour extends GranularLiteral {
  */
 declare abstract class DateBasedLiteral extends GranularLiteral {
     constructor(tm: TimeText, units: TimestampUnit, nextLit: string);
-    getExpression(fs: FieldSpace): ExprValue;
+    protected computeExpression(fs: FieldSpace): ExprValue;
     getNext(fs: FieldSpace): ExprValue | undefined;
 }
 export declare class LiteralDay extends DateBasedLiteral {

package/dist/lang/ast/expressions/time-literal.js

@@ -107,7 +107,7 @@ class TimeLiteral extends expression_def_1.ExpressionDef {
             timeframe: this.units,
         });
     }
-    getExpression(fs) {
+    computeExpression(fs) {
         return this.makeValue(fs, this.literalPart, this.timeType);
     }
     getNext(fs) {
@@ -249,7 +249,7 @@ class DateBasedLiteral extends GranularLiteral {
     constructor(tm, units, nextLit) {
         super(tm, units, 'date', nextLit);
     }
-    getExpression(fs) {
+    computeExpression(fs) {
         const dateValue = this.makeValue(fs, this.literalPart, 'date');
         const timestamp = this.makeLiteral(fs, `${this.literalPart} 00:00:00`, 'timestamp', this.units);
         return { ...dateValue, morphic: { timestamp }, evalSpace: 'literal' };

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/field-space/parameter-space.d.ts

@@ -18,4 +18,5 @@ export declare class ParameterSpace implements FieldSpace {
     dialectObj(): Dialect | undefined;
     isQueryFieldSpace(): this is QueryFieldSpace;
     accessProtectionLevel(): AccessModifierLabel;
+    generation(): number;
 }

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

@@ -5,6 +5,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ParameterSpace = void 0;
+const field_space_1 = require("../types/field-space");
 const space_param_1 = require("../types/space-param");
 class ParameterSpace {
     constructor(parameters) {
@@ -80,6 +81,11 @@ class ParameterSpace {
     accessProtectionLevel() {
         return 'private';
     }
+    // Bindings are fixed by the constructor and never change, so this space
+    // contributes no invalidation of its own.
+    generation() {
+        return (0, field_space_1.currentGeneration)();
+    }
 }
 exports.ParameterSpace = ParameterSpace;
 //# sourceMappingURL=parameter-space.js.map

package/dist/lang/ast/field-space/passthrough-space.d.ts

@@ -19,4 +19,5 @@ export declare class PassthroughSpace implements FieldSpace {
     inputSpace(): import("..").SourceFieldSpace;
     accessProtectionLevel(): AccessModifierLabel;
     connectionName(): string;
+    generation(): number;
 }

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

@@ -52,6 +52,9 @@ class PassthroughSpace {
     connectionName() {
         return this.realFS.connectionName();
     }
+    generation() {
+        return this.realFS.generation();
+    }
 }
 exports.PassthroughSpace = PassthroughSpace;
 //# sourceMappingURL=passthrough-space.js.map

package/dist/lang/ast/field-space/static-space.d.ts

@@ -18,6 +18,14 @@ export declare class StaticSpace implements FieldSpace {
     defToSpaceField(from: FieldDef): SpaceField;
     private get map();
     accessProtectionLevel(): AccessModifierLabel;
+    /**
+     * StaticSpace itself never rebinds anything after construction, but
+     * DynamicSpace extends it and the three mutators below are the whole
+     * write surface for both -- `memoMap` is private, and every caller
+     * goes through these. That is what makes "every rebinding bumps the
+     * generation" checkable rather than a hope.
+     */
+    generation(): number;
     protected dropEntries(): void;
     protected dropEntry(name: string): void;
     entry(name: string): SpaceEntry | undefined;

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

@@ -7,6 +7,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.StaticSourceSpace = exports.StructSpaceField = exports.StaticSpace = void 0;
 const dialect_map_1 = require("../../../dialect/dialect_map");
 const malloy_types_1 = require("../../../model/malloy_types");
+const field_space_1 = require("../types/field-space");
 const space_param_1 = require("../types/space-param");
 const space_field_1 = require("../types/space-field");
 const struct_space_field_base_1 = require("./struct-space-field-base");
@@ -64,10 +65,22 @@ class StaticSpace {
     accessProtectionLevel() {
         return 'internal';
     }
+    /**
+     * StaticSpace itself never rebinds anything after construction, but
+     * DynamicSpace extends it and the three mutators below are the whole
+     * write surface for both -- `memoMap` is private, and every caller
+     * goes through these. That is what makes "every rebinding bumps the
+     * generation" checkable rather than a hope.
+     */
+    generation() {
+        return (0, field_space_1.currentGeneration)();
+    }
     dropEntries() {
+        (0, field_space_1.noteRebinding)();
         this.memoMap = new Map();
     }
     dropEntry(name) {
+        (0, field_space_1.noteRebinding)();
         this.map.delete(name);
     }
     // TODO this was protected
@@ -75,6 +88,7 @@ class StaticSpace {
         return this.map.get(name);
     }
     setEntry(name, value) {
+        (0, field_space_1.noteRebinding)();
         this.map.set(name, value);
     }
     entries() {

package/dist/lang/ast/query-builders/index-builder.js

@@ -94,7 +94,7 @@ class IndexBuilder {
             path: [],
             uniqueKeyRequirement: { isCount: true },
         });
-        (0, malloy_types_1.setFieldUsage)(indexSegment, fieldUsage);
+        indexSegment.refSummary = { ...indexSegment.refSummary, fieldUsage };
         return indexSegment;
     }
 }

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;
 }