@malloydata/malloy 0.0.427 → 0.0.429

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/query-properties/drill.d.ts

@@ -13,7 +13,7 @@ export declare class DrillField extends ExpressionDef {
     readonly typeDesc: TypeDesc;
     elementType: string;
     constructor(expr: Expr, typeDesc: TypeDesc);
-    getExpression(_fs: FieldSpace): ExprValue;
+    protected computeExpression(_fs: FieldSpace): ExprValue;
 }
 export declare class Drill extends Filter implements QueryPropertyInterface {
     elementType: string;

package/dist/lang/ast/query-properties/drill.js

@@ -25,7 +25,7 @@ class DrillField extends expression_def_1.ExpressionDef {
         this.typeDesc = typeDesc;
         this.elementType = 'drillField';
     }
-    getExpression(_fs) {
+    computeExpression(_fs) {
         return {
             value: this.expr,
             ...this.typeDesc,

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

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

@@ -35,7 +35,7 @@ class SQLString extends malloy_element_1.MalloyElement {
             el.logError('invalid-sql-source-interpolation', 'This element is not legal inside an SQL string');
         }
     }
-    sqlPhrases() {
+    sqlPhrases(forConnection) {
         const ret = [];
         let valid = true;
         for (const el of this.elements) {
@@ -47,19 +47,39 @@ class SQLString extends malloy_element_1.MalloyElement {
                 const source = el.getSource();
                 if (source) {
                     const sourceDef = source.getSourceDef(undefined);
-                    if ((0, malloy_types_1.isPersistableSourceDef)(sourceDef)) {
+                    const connectionMismatch = sourceDef.connection !== forConnection;
+                    const persistable = (0, malloy_types_1.isPersistableSourceDef)(sourceDef);
+                    if (!connectionMismatch && persistable) {
                         ret.push(sourceDef);
                         continue;
                     }
+                    valid = false;
+                    // A source can be wrong in both ways at once, and both are worth
+                    // saying, so claim the report and then say everything.
+                    if (el.sqClaimError()) {
+                        if (connectionMismatch) {
+                            el.logError('sql-source-connection-mismatch', `Source is on connection ${sourceDef.connection}, but this SQL is for ${forConnection}`);
+                        }
+                        if (!persistable) {
+                            el.logError('invalid-sql-source-interpolation', 'Source is not persistable, cannot be used in SQL');
+                        }
+                    }
+                }
+                else {
+                    el.sqLog('failed-to-expand-sql-source', 'Cannot expand into a query');
+                    valid = false;
                 }
-                el.sqLog('failed-to-expand-sql-source', 'Cannot expand into a query');
-                valid = false;
             }
             else {
                 // Not a source - try as a query
                 const queryObject = el.getQuery();
                 if (queryObject) {
-                    ret.push(queryObject.query(false));
+                    const queryComp = queryObject.queryComp(false, false);
+                    if (queryComp.inputStruct.connection !== forConnection) {
+                        el.sqLog('sql-source-connection-mismatch', `Query is on connection ${queryComp.inputStruct.connection}, but this SQL is for ${forConnection}`);
+                        valid = false;
+                    }
+                    ret.push(queryComp.query);
                 }
                 else {
                     el.sqLog('failed-to-expand-sql-source', 'Cannot expand into a query');

package/dist/lang/ast/statements/import-statement.js

@@ -10,13 +10,6 @@ const malloy_types_1 = require("../../../model/malloy_types");
 const source_def_utils_1 = require("../../../model/source_def_utils");
 const persist_utils_1 = require("../../../model/persist_utils");
 const utils_1 = require("../../../model/utils");
-/** Walk BuildNode tree and collect all sourceIDs */
-function collectSourceIDs(nodes, into) {
-    for (const node of nodes) {
-        into.add(node.sourceID);
-        collectSourceIDs(node.dependsOn, into);
-    }
-}
 class ImportSourceName extends malloy_element_1.MalloyElement {
     constructor(text) {
         super();
@@ -160,10 +153,14 @@ class ImportStatement extends malloy_element_1.ListOf {
                             const importMe = { ...sourceEntry };
                             importMe.as = dstName;
                             doc.setEntry(dstName, { entry: importMe, exported: false });
-                            // Collect dependencies for persistable sources
+                            // Every source the walk touched, routes included — not just the
+                            // persistent ones. A `#@ -persist` wrapper that adds a join is
+                            // not a table, but it can be the only way to reach the tables
+                            // under it, and this model has to be able to take the same route.
                             if ((0, malloy_types_1.isSourceDef)(importMe) && (0, malloy_types_1.isPersistableSourceDef)(importMe)) {
-                                const deps = (0, persist_utils_1.findPersistentDependencies)(importMe, importedModel);
-                                collectSourceIDs(deps, neededSourceIDs);
+                                for (const found of (0, persist_utils_1.walkPersistentDependencies)([importMe], importedModel)) {
+                                    neededSourceIDs.add(found.sourceID);
+                                }
                             }
                         }
                     }

package/dist/lang/ast/types/expression-def.d.ts

@@ -13,20 +13,53 @@ export declare enum ATNodeType {
 }
 /**
  * Root node for any element in an expression. These essentially
- * create a sub-tree in the larger AST. Expression nodes know
- * how to write themselves as SQL (or rather, generate the
- * template for SQL required by the query writer)
+ * create a sub-tree in the larger AST. An ExpressionDef, when
+ * given a FieldSpace, can be evaluated to produce an ExprValue
+ * which is the IR for an Expr along with its type and other metadata.
  */
 export declare abstract class ExpressionDef extends MalloyElement {
     abstract elementType: string;
     granular(): boolean;
     /**
-     * Returns the "translation" or template for SQL generation. When asking
+     * Returns the "translation" or Expr tree for SQL generation. When asking
      * for a translation you may pass the types you can accept, allowing
      * the translation code a chance to convert to match your expectations
      * @param space Namespace for looking up field references
+     *
+     * THE RETURNED ExprValue IS SHARED -- TREAT IT AS IMMUTABLE. Asking twice
+     * yields the same object, so to derive a value from one, build a new one:
+     * `{...operand, type: 'boolean'}` or `computedExprValue({…, from: [operand]})`.
+     *
+     * DO NOT OVERRIDE THIS. Nodes implement `computeExpression`; an override
+     * here bypasses the memo, which for `+`/`-` chains is the difference
+     * between linear and exponential compile time.
      */
-    abstract getExpression(fs: FieldSpace): ExprValue;
+    getExpression(fs: FieldSpace): ExprValue;
+    /**
+     * The last value this node computed, and what it was computed against.
+     * Three states, distinguished by memoGen:
+     *
+     *   memoFs undefined              -- nothing computed, or abandoned
+     *   memoFs set, memoGen undefined -- computing right now, and only that,
+     *                                    since abandoning clears memoFs
+     *   memoFs set, memoGen set       -- memoValue is that computation's result
+     *
+     * Both halves of the stamp are needed: a node can be evaluated under more
+     * than one field space -- ConstantExpression evaluates its child against a
+     * ConstantFieldSpace whatever it was handed -- and a field space can rebind
+     * a name under us.
+     *
+     * One slot, not a map. A node which alternates between two field spaces
+     * simply misses and recomputes, which costs time and never correctness.
+     */
+    private memoFs?;
+    private memoGen?;
+    private memoValue?;
+    /**
+     * Evaluate this node. Implemented by every expression node; called only
+     * by `getExpression` above, never directly.
+     */
+    protected abstract computeExpression(fs: FieldSpace): ExprValue;
     legalChildTypes: import("../../..").TypeDesc[];
     /**
      * Some operators want to give the right hand value a chance to
@@ -45,13 +78,19 @@ export declare abstract class ExpressionDef extends MalloyElement {
     typeCheck(eNode: ExpressionDef, eVal: ExprValue): boolean;
     drillExpression(): Malloy.Expression | undefined;
     /**
-     * This is the operation which makes partial comparison and value trees work
-     * The default implementation merely constructs LEFT OP RIGHT, but specialized
-     * nodes like alternation trees or or partial comparison can control how
-     * the appplication gets generated
+     * This is the operation which makes partial comparison and value trees work.
+     * `this` is the RIGHT operand; the left arrives here as an argument. All of
+     * the magic of malloy expressions eventually flows through here, where an
+     * operator is applied to two values -- depending on the operator and the
+     * value types that may transform the values or even the operator.
+     *
+     * Specialized nodes like alternation trees and partial comparisons override
+     * this to control how the application gets generated. They are the reason
+     * the right operand is in charge: a partial has no bound left operand, and
+     * only learns it here.
      * @param fs The symbol table
      * @param op The operator being applied
-     * @param expr The "other" (besdies 'this') value
+     * @param left The "other" (besides 'this') value
      * @return The translated expression
      */
     apply(fs: FieldSpace, op: BinaryMalloyOperator, left: ExpressionDef, _warnOnComplexTree?: boolean): ExprValue;
@@ -69,20 +108,8 @@ export declare class ExprDuration extends ExpressionDef {
     legalChildTypes: import("../../..").TypeDesc[];
     constructor(n: ExpressionDef, timeframe: TimestampUnit);
     apply(fs: FieldSpace, op: BinaryMalloyOperator, left: ExpressionDef): ExprValue;
-    getExpression(fs: FieldSpace): ExprValue;
+    protected computeExpression(fs: FieldSpace): ExprValue;
 }
 export type MorphicType = 'date' | 'timestamp';
 export declare function getMorphicValue(mv: ExprValue, mt: MorphicType): ExprValue | undefined;
-/**
- * All of the magic of malloy expressions eventually flows to here,
- * where an operator is applied to two values. Depending on the
- * operator and value types this may involve transformations of
- * the values or even the operator.
- * @param fs FieldSpace for the symbols
- * @param left Left value
- * @param op The operator
- * @param right Right Value
- * @return ExprValue of the expression
- */
-export declare function applyBinary(fs: FieldSpace, left: ExpressionDef, op: BinaryMalloyOperator, right: ExpressionDef): ExprValue;
 export declare function checkFilterExpression(logTo: MalloyElement, ft: FilterExprType, fexpr: Expr): void;