@malloydata/malloy 0.0.215 → 0.0.216-dev241118202522

package/dist/lang/ast/field-space/struct-space-field-base.js

@@ -46,6 +46,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StructSpaceFieldBase = void 0;
+const composite_source_utils_1 = require("../../../model/composite_source_utils");
 const malloy_types_1 = require("../../../model/malloy_types");
 const TDU = __importStar(require("../typedesc-utils"));
 const space_field_1 = require("../types/space-field");
@@ -65,17 +66,20 @@ class StructSpaceFieldBase extends space_field_1.SpaceField {
         };
     }
     typeDesc() {
+        var _a, _b;
         if ((0, malloy_types_1.isSourceDef)(this.structDef)) {
             return {
                 type: this.structDef.type,
                 evalSpace: 'input',
                 expressionType: 'scalar',
+                compositeFieldUsage: (_a = this.structDef.onCompositeFieldUsage) !== null && _a !== void 0 ? _a : (0, composite_source_utils_1.emptyCompositeFieldUsage)(),
             };
         }
         return {
             ...TDU.atomicDef(this.structDef),
             evalSpace: 'input',
             expressionType: 'scalar',
+            compositeFieldUsage: (_b = this.structDef.onCompositeFieldUsage) !== null && _b !== void 0 ? _b : (0, composite_source_utils_1.emptyCompositeFieldUsage)(),
         };
     }
 }

package/dist/lang/ast/index.d.ts

@@ -9,6 +9,7 @@ export * from './source-query-elements/sq-refine';
 export * from './source-query-elements/sq-source';
 export * from './source-query-elements/sq-reference';
 export * from './source-query-elements/sq-extend';
+export * from './source-query-elements/sq-compose';
 export * from './source-properties/field-list-edit';
 export * from './source-properties/primary-key';
 export * from './source-properties/renames';

package/dist/lang/ast/index.js

@@ -47,6 +47,7 @@ __exportStar(require("./source-query-elements/sq-refine"), exports);
 __exportStar(require("./source-query-elements/sq-source"), exports);
 __exportStar(require("./source-query-elements/sq-reference"), exports);
 __exportStar(require("./source-query-elements/sq-extend"), exports);
+__exportStar(require("./source-query-elements/sq-compose"), exports);
 __exportStar(require("./source-properties/field-list-edit"), exports);
 __exportStar(require("./source-properties/primary-key"), exports);
 __exportStar(require("./source-properties/renames"), exports);

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

@@ -40,7 +40,7 @@ class IndexBuilder {
     }
     execute(qp) {
         if (qp instanceof filters_1.Filter) {
-            this.filters.push(...qp.getFilterList(this.inputFS));
+            qp.queryExecute(this);
         }
         else if (qp instanceof limit_1.Limit) {
             if (this.limit) {

package/dist/lang/ast/query-builders/reduce-builder.d.ts

@@ -1,4 +1,4 @@
-import { FilterCondition, PipeSegment, QuerySegment } from '../../../model/malloy_types';
+import { CompositeFieldUsage, FilterCondition, PipeSegment, QuerySegment } from '../../../model/malloy_types';
 import { SourceFieldSpace } from '../types/field-space';
 import { Ordering } from '../query-properties/ordering';
 import { Top } from '../query-properties/top';
@@ -17,6 +17,7 @@ export declare abstract class QuerySegmentBuilder implements QueryBuilder {
     filters: FilterCondition[];
     execute(qp: QueryProperty): void;
     abstract finalize(fromSeg: PipeSegment | undefined): PipeSegment;
+    get compositeFieldUsage(): CompositeFieldUsage;
     refineFrom(from: PipeSegment | undefined, to: QuerySegment): void;
 }
 export declare class ReduceBuilder extends QuerySegmentBuilder implements QueryBuilder {

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

@@ -25,12 +25,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ReduceBuilder = exports.QuerySegmentBuilder = void 0;
 const malloy_types_1 = require("../../../model/malloy_types");
 const error_factory_1 = require("../error-factory");
-const filters_1 = require("../query-properties/filters");
 const limit_1 = require("../query-properties/limit");
 const ordering_1 = require("../query-properties/ordering");
 const top_1 = require("../query-properties/top");
 const query_spaces_1 = require("../field-space/query-spaces");
 const definition_list_1 = require("../types/definition-list");
+const composite_source_utils_1 = require("../../../model/composite_source_utils");
 class QuerySegmentBuilder {
     constructor() {
         this.alwaysJoins = [];
@@ -44,10 +44,6 @@ class QuerySegmentBuilder {
         if (qp instanceof definition_list_1.DefinitionList) {
             this.resultFS.pushFields(...qp.list);
         }
-        else if (qp instanceof filters_1.Filter) {
-            const filterFS = qp.havingClause ? this.resultFS : this.inputFS;
-            this.filters.push(...qp.getFilterList(filterFS));
-        }
         else if (qp instanceof top_1.Top) {
             if (this.limit) {
                 qp.logError('limit-already-specified', 'Query operation already limited');
@@ -81,7 +77,11 @@ class QuerySegmentBuilder {
             }
         }
     }
+    get compositeFieldUsage() {
+        return this.resultFS.compositeFieldUsage;
+    }
     refineFrom(from, to) {
+        var _a;
         if (from && from.type !== 'index' && from.type !== 'raw') {
             if (!this.order) {
                 if (from.orderBy) {
@@ -117,6 +117,10 @@ class QuerySegmentBuilder {
         if (this.alwaysJoins.length > 0) {
             to.alwaysJoins = [...this.alwaysJoins];
         }
+        const fromCompositeFieldUsage = from && (0, malloy_types_1.isQuerySegment)(from)
+            ? (_a = from.compositeFieldUsage) !== null && _a !== void 0 ? _a : (0, composite_source_utils_1.emptyCompositeFieldUsage)()
+            : (0, composite_source_utils_1.emptyCompositeFieldUsage)();
+        to.compositeFieldUsage = (0, composite_source_utils_1.mergeCompositeFieldUsage)(fromCompositeFieldUsage, this.compositeFieldUsage);
     }
 }
 exports.QuerySegmentBuilder = QuerySegmentBuilder;

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

@@ -23,14 +23,27 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.QueryBase = void 0;
+const composite_source_utils_1 = require("../../../model/composite_source_utils");
+const malloy_types_1 = require("../../../model/malloy_types");
 const query_utils_1 = require("../query-utils");
 const malloy_element_1 = require("../types/malloy-element");
 class QueryBase extends malloy_element_1.MalloyElement {
     query() {
-        const q = this.queryComp(true).query;
+        const { inputStruct, query } = this.queryComp(true);
+        // TODO add an error if a raw/index query is done against a composite source
+        let compositeResolvedSourceDef = undefined;
+        if (query.pipeline[0] && (0, malloy_types_1.isQuerySegment)(query.pipeline[0])) {
+            const compositeFieldUsage = query.pipeline[0].compositeFieldUsage;
+            if (compositeFieldUsage !== undefined &&
+                !(0, composite_source_utils_1.isEmptyCompositeFieldUsage)(compositeFieldUsage)) {
+                const resolved = (0, composite_source_utils_1.resolveCompositeSources)(inputStruct, compositeFieldUsage);
+                compositeResolvedSourceDef = resolved.sourceDef;
+            }
+        }
         return {
-            ...q,
-            pipeline: (0, query_utils_1.detectAndRemovePartialStages)(q.pipeline, this),
+            ...query,
+            compositeResolvedSourceDef,
+            pipeline: (0, query_utils_1.detectAndRemovePartialStages)(query.pipeline, this),
         };
     }
 }

package/dist/lang/ast/query-items/field-declaration.js

@@ -112,6 +112,7 @@ class AtomicFieldDeclaration extends malloy_element_1.MalloyElement {
                         type: retType,
                         location: this.location,
                         e: exprValue.value,
+                        compositeFieldUsage: exprValue.compositeFieldUsage,
                     };
                     if ((0, granular_result_1.isGranularResult)(exprValue)) {
                         timeRet.timeframe = exprValue.timeframe;
@@ -129,6 +130,7 @@ class AtomicFieldDeclaration extends malloy_element_1.MalloyElement {
                         name: exprName,
                         location: this.location,
                         e: exprValue.value,
+                        compositeFieldUsage: exprValue.compositeFieldUsage,
                     };
                     break;
                 }
@@ -141,6 +143,7 @@ class AtomicFieldDeclaration extends malloy_element_1.MalloyElement {
                         join: 'one',
                         fields,
                         e: exprValue.value,
+                        compositeFieldUsage: exprValue.compositeFieldUsage,
                         dialect: exprFS.dialectName(),
                     };
                     break;

package/dist/lang/ast/query-properties/filters.d.ts

@@ -2,6 +2,7 @@ import { FilterCondition } from '../../../model/malloy_types';
 import { ExpressionDef } from '../types/expression-def';
 import { FieldSpace } from '../types/field-space';
 import { ListOf, MalloyElement } from '../types/malloy-element';
+import { QueryBuilder } from '../types/query-builder';
 import { LegalRefinementStage, QueryPropertyInterface } from '../types/query-property-interface';
 export declare class FilterElement extends MalloyElement {
     readonly expr: ExpressionDef;
@@ -16,5 +17,7 @@ export declare class Filter extends ListOf<FilterElement> implements QueryProper
     forceQueryClass: undefined;
     queryRefinementStage: LegalRefinementStage;
     set having(isHaving: boolean);
+    protected checkedFilterCondition(fs: FieldSpace, filter: FilterElement): FilterCondition | undefined;
     getFilterList(fs: FieldSpace): FilterCondition[];
+    queryExecute(executeFor: QueryBuilder): void;
 }

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

@@ -24,6 +24,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Filter = exports.FilterElement = void 0;
 const malloy_types_1 = require("../../../model/malloy_types");
+const utils_1 = require("../../utils");
 const malloy_element_1 = require("../types/malloy-element");
 const query_property_interface_1 = require("../types/query-property-interface");
 class FilterElement extends malloy_element_1.MalloyElement {
@@ -42,6 +43,7 @@ class FilterElement extends malloy_element_1.MalloyElement {
                 code: this.exprSrc,
                 e: { node: 'false' },
                 expressionType: 'scalar',
+                compositeFieldUsage: exprVal.compositeFieldUsage,
             };
         }
         const exprCond = {
@@ -49,6 +51,7 @@ class FilterElement extends malloy_element_1.MalloyElement {
             code: this.exprSrc,
             e: exprVal.value,
             expressionType: exprVal.expressionType,
+            compositeFieldUsage: exprVal.compositeFieldUsage,
         };
         return exprCond;
     }
@@ -68,36 +71,49 @@ class Filter extends malloy_element_1.ListOf {
             ? query_property_interface_1.LegalRefinementStage.Tail
             : query_property_interface_1.LegalRefinementStage.Head;
     }
-    getFilterList(fs) {
-        const checked = [];
-        for (const oneElement of this.list) {
-            const fExpr = oneElement.filterCondition(fs);
-            // mtoy todo is having we never set then queryRefinementStage might be wrong
-            // ... calculations and aggregations must go last
-            // Aggregates are ALSO checked at SQL generation time, but checking
-            // here allows better reflection of errors back to user.
-            if (this.havingClause !== undefined) {
-                const isAggregate = (0, malloy_types_1.expressionIsAggregate)(fExpr.expressionType);
-                const isAnalytic = (0, malloy_types_1.expressionIsAnalytic)(fExpr.expressionType);
-                if (this.havingClause) {
-                    if (isAnalytic) {
-                        oneElement.logError('analytic-in-having', 'Analytic expressions are not allowed in `having:`');
-                        continue;
-                    }
+    checkedFilterCondition(fs, filter) {
+        const fExpr = filter.filterCondition(fs);
+        // mtoy todo is having we never set then queryRefinementStage might be wrong
+        // ... calculations and aggregations must go last
+        // Aggregates are ALSO checked at SQL generation time, but checking
+        // here allows better reflection of errors back to user.
+        if (this.havingClause !== undefined) {
+            const isAggregate = (0, malloy_types_1.expressionIsAggregate)(fExpr.expressionType);
+            const isAnalytic = (0, malloy_types_1.expressionIsAnalytic)(fExpr.expressionType);
+            if (this.havingClause) {
+                if (isAnalytic) {
+                    filter.logError('analytic-in-having', 'Analytic expressions are not allowed in `having:`');
+                    return;
+                }
+            }
+            else {
+                if (isAnalytic) {
+                    filter.logError('analytic-in-where', 'Analytic expressions are not allowed in `where:`');
+                    return;
                 }
-                else {
-                    if (isAnalytic) {
-                        oneElement.logError('analytic-in-where', 'Analytic expressions are not allowed in `where:`');
-                        continue;
-                    }
-                    else if (isAggregate) {
-                        oneElement.logError('aggregate-in-where', 'Aggregate expressions are not allowed in `where:`; use `having:`');
-                    }
+                else if (isAggregate) {
+                    filter.logError('aggregate-in-where', 'Aggregate expressions are not allowed in `where:`; use `having:`');
                 }
             }
-            checked.push(fExpr);
         }
-        return checked;
+        return fExpr;
+    }
+    getFilterList(fs) {
+        return this.list
+            .map(filter => this.checkedFilterCondition(fs, filter))
+            .filter(utils_1.isNotUndefined);
+    }
+    queryExecute(executeFor) {
+        const filterFS = this.havingClause
+            ? executeFor.resultFS
+            : executeFor.inputFS;
+        for (const filter of this.list) {
+            const fExpr = this.checkedFilterCondition(filterFS, filter);
+            if (fExpr !== undefined) {
+                executeFor.filters.push(fExpr);
+                executeFor.resultFS.addCompositeFieldUserFromFilter(fExpr, filter);
+            }
+        }
     }
 }
 exports.Filter = Filter;

package/dist/lang/ast/query-properties/nest.d.ts

@@ -7,6 +7,7 @@ export declare class NestFieldDeclaration extends ViewFieldDeclaration implement
     elementType: string;
     queryRefinementStage: LegalRefinementStage;
     forceQueryClass: QueryClass;
+    turtleDef: model.TurtleDef | undefined;
     queryExecute(executeFor: QueryBuilder): void;
     getFieldDef(fs: FieldSpace): model.TurtleDef;
 }

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

@@ -32,21 +32,25 @@ class NestFieldDeclaration extends view_field_declaration_1.ViewFieldDeclaration
         this.elementType = 'nest-field-declaration';
         this.queryRefinementStage = query_property_interface_1.LegalRefinementStage.Single;
         this.forceQueryClass = query_property_interface_1.QueryClass.Grouping;
+        this.turtleDef = undefined;
     }
     queryExecute(executeFor) {
         executeFor.resultFS.pushFields(this);
     }
     getFieldDef(fs) {
+        if (this.turtleDef)
+            return this.turtleDef;
         if (fs.isQueryFieldSpace()) {
             const { pipeline, annotation } = this.view.pipelineComp(fs, fs.outputSpace());
             const checkedPipeline = (0, query_utils_1.detectAndRemovePartialStages)(pipeline, this);
-            return {
+            this.turtleDef = {
                 type: 'turtle',
                 name: this.name,
                 pipeline: checkedPipeline,
                 annotation: { ...this.note, inherits: annotation },
                 location: this.location,
             };
+            return this.turtleDef;
         }
         throw this.internalError('Unexpected namespace for nest');
     }

package/dist/lang/ast/source-elements/composite-source.d.ts

@@ -0,0 +1,16 @@
+import { Annotation, SourceDef } from '../../../model/malloy_types';
+import { HasParameter } from '../parameters/has-parameter';
+import { Source } from './source';
+import { ParameterSpace } from '../field-space/parameter-space';
+/**
+ * A Source that is a virtual union of the fields of other sources, choosing
+ * the first source that has all the fields at query time.
+ */
+export declare class CompositeSource extends Source {
+    readonly sources: Source[];
+    elementType: string;
+    currentAnnotation?: Annotation;
+    constructor(sources: Source[]);
+    getSourceDef(parameterSpace: ParameterSpace | undefined): SourceDef;
+    withParameters(parameterSpace: ParameterSpace | undefined, pList: HasParameter[] | undefined): SourceDef;
+}

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

@@ -0,0 +1,75 @@
+"use strict";
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ *  LICENSE file in the root directory of this source tree.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompositeSource = void 0;
+const malloy_types_1 = require("../../../model/malloy_types");
+const source_1 = require("./source");
+/**
+ * A Source that is a virtual union of the fields of other sources, choosing
+ * the first source that has all the fields at query time.
+ */
+class CompositeSource extends source_1.Source {
+    constructor(sources) {
+        super({ sources });
+        this.sources = sources;
+        this.elementType = 'compositeSource';
+    }
+    getSourceDef(parameterSpace) {
+        return this.withParameters(parameterSpace, []);
+    }
+    withParameters(parameterSpace, pList) {
+        const sourceDefs = this.sources.map(source => source.withParameters(parameterSpace, pList));
+        const connection = sourceDefs[0].connection;
+        const dialect = sourceDefs[0].dialect;
+        const name = 'composite_source';
+        const fields = [];
+        const fieldNames = new Set();
+        this.sources.forEach((source, index) => {
+            var _a;
+            const sourceDef = sourceDefs[index];
+            // Check that connections all match; don't bother checking dialect, since it will
+            // match if the connection matches.
+            if (sourceDef.connection !== connection) {
+                source.logError('composite-source-connection-mismatch', `All sources in a composite source must share the same connection; connection \`${sourceDef.connection}\` differs from previous connection \`${connection}\``);
+            }
+            for (const field of sourceDef.fields) {
+                if (!(0, malloy_types_1.isAtomic)(field)) {
+                    source.logWarning('composite-source-atomic-fields-only', `Only atomic fields are supported in composite sources; field \`${field.name}\` is not atomic and will be ignored`);
+                    continue;
+                }
+                const fieldName = (_a = field.as) !== null && _a !== void 0 ? _a : field.name;
+                if (!fieldNames.has(fieldName)) {
+                    fieldNames.add(fieldName);
+                    const compositeField = {
+                        ...field,
+                        name: fieldName,
+                        as: undefined,
+                        e: { node: 'compositeField' },
+                        compositeFieldUsage: { fields: [fieldName], joinedUsage: {} },
+                        code: this.code,
+                        location: this.codeLocation,
+                    };
+                    fields.push(compositeField);
+                }
+            }
+        });
+        return {
+            type: 'composite',
+            // TODO Use sourceRefs rather than sourceDefs when possible to avoid potential
+            // explosion of source defs...
+            sources: sourceDefs,
+            connection,
+            fields,
+            dialect,
+            name,
+            parameters: sourceDefs[0].parameters,
+        };
+    }
+}
+exports.CompositeSource = CompositeSource;
+//# sourceMappingURL=composite-source.js.map

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

@@ -1,4 +1,4 @@
-import { InvokedStructRef, Parameter, SourceDef, StructDef } from '../../../model/malloy_types';
+import { InvokedStructRef, Parameter, SourceDef } from '../../../model/malloy_types';
 import { MalloyElement } from '../types/malloy-element';
 import { HasParameter } from '../parameters/has-parameter';
 import { ParameterSpace } from '../field-space/parameter-space';
@@ -10,5 +10,5 @@ export declare abstract class Source extends MalloyElement {
     abstract getSourceDef(parameterSpace: ParameterSpace | undefined): SourceDef;
     structRef(parameterSpace: ParameterSpace | undefined): InvokedStructRef;
     protected packParameters(pList: HasParameter[] | undefined): Record<string, Parameter> | undefined;
-    withParameters(parameterSpace: ParameterSpace | undefined, pList: HasParameter[] | undefined): StructDef;
+    withParameters(parameterSpace: ParameterSpace | undefined, pList: HasParameter[] | undefined): SourceDef;
 }

package/dist/lang/ast/source-properties/join.js

@@ -95,6 +95,7 @@ class KeyJoin extends Join {
                             right: exprX.value,
                         },
                     };
+                    inStruct.onCompositeFieldUsage = exprX.compositeFieldUsage;
                     return;
                 }
                 else {
@@ -137,6 +138,7 @@ class ExpressionJoin extends Join {
             return;
         }
         inStruct.onExpression = exprX.value;
+        inStruct.onCompositeFieldUsage = exprX.compositeFieldUsage;
     }
     structDef(parameterSpace) {
         var _a;

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

@@ -0,0 +1,13 @@
+import { CompositeSource } from '../source-elements/composite-source';
+import { SourceQueryElement } from './source-query-element';
+/**
+ * e.g. `compose(source_a, source_b)`
+ */
+export declare class SQCompose extends SourceQueryElement {
+    readonly sources: SourceQueryElement[];
+    elementType: string;
+    asSource?: CompositeSource;
+    constructor(sources: SourceQueryElement[]);
+    getSource(): CompositeSource | undefined;
+    isSource(): boolean;
+}

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

@@ -0,0 +1,48 @@
+"use strict";
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ *  LICENSE file in the root directory of this source tree.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SQCompose = void 0;
+const composite_source_1 = require("../source-elements/composite-source");
+const source_query_element_1 = require("./source-query-element");
+/**
+ * e.g. `compose(source_a, source_b)`
+ */
+class SQCompose extends source_query_element_1.SourceQueryElement {
+    constructor(sources) {
+        super({ sources });
+        this.sources = sources;
+        this.elementType = 'sq-compose';
+    }
+    getSource() {
+        if (this.asSource) {
+            return this.asSource;
+        }
+        const sources = this.sources.map(s => s.getSource());
+        if (sources.length === 0) {
+            this.sqLog('empty-composite-source', 'Composite source must have at least one input source');
+            return undefined;
+        }
+        else if (sources.length === 1) {
+            this.sqLog('unnecessary-composite-source', 'A composite source with one input is equivalent to that input', { severity: 'warn' });
+        }
+        if (hasNoUndefined(sources)) {
+            this.asSource = new composite_source_1.CompositeSource(sources);
+            this.has({ asSource: this.asSource });
+            return this.asSource;
+        }
+        this.sqLog('invalid-composite-source-input', 'All composite source inputs must be valid sources');
+    }
+    isSource() {
+        return true;
+    }
+}
+exports.SQCompose = SQCompose;
+function hasNoUndefined(arr) {
+    return arr.every(s => s !== undefined);
+}
+//# sourceMappingURL=sq-compose.js.map

package/dist/lang/ast/typedesc-utils.js

@@ -24,12 +24,18 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.atomicDef = exports.inspect = exports.typeEq = exports.typeIn = exports.eq = exports.any = exports.anyAtomicT = exports.aggregateBoolT = exports.viewT = exports.errorT = exports.boolT = exports.timestampT = exports.dateT = exports.stringT = exports.numberT = exports.nullT = void 0;
 const model_1 = require("../../model");
+const composite_source_utils_1 = require("../../model/composite_source_utils");
 function mkTypeDesc(
 // The problem is that record and array, as currently defined, require a dialect
 // which isn't available. In retrospect the dialect shouldn't be in the type,
 // it should only be in the field, which I wil do eventually.
 dataType, expressionType = 'scalar', evalSpace = 'constant') {
-    return { type: dataType, expressionType, evalSpace };
+    return {
+        type: dataType,
+        expressionType,
+        evalSpace,
+        compositeFieldUsage: (0, composite_source_utils_1.emptyCompositeFieldUsage)(),
+    };
 }
 exports.nullT = mkTypeDesc('null');
 exports.numberT = mkTypeDesc('number');

package/dist/lang/ast/types/expr-value.js

@@ -24,12 +24,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.literalTimeResult = exports.literalExprValue = exports.computedErrorExprValue = exports.computedTimeResult = exports.computedExprValue = void 0;
 const model_1 = require("../../../model");
+const composite_source_utils_1 = require("../../../model/composite_source_utils");
 function computedExprValue({ value, dataType, from, }) {
     return {
         ...dataType,
         value,
         expressionType: (0, model_1.maxOfExpressionTypes)(from.map(e => e.expressionType)),
         evalSpace: (0, model_1.mergeEvalSpaces)(...from.map(e => e.evalSpace)),
+        compositeFieldUsage: (0, composite_source_utils_1.mergeCompositeFieldUsage)(...from.map(e => e.compositeFieldUsage)),
     };
 }
 exports.computedExprValue = computedExprValue;
@@ -40,6 +42,7 @@ function computedTimeResult({ value, dataType, from, timeframe, }) {
         expressionType: xv.expressionType,
         evalSpace: xv.evalSpace,
         value: xv.value,
+        compositeFieldUsage: (0, composite_source_utils_1.mergeCompositeFieldUsage)(...from.map(e => e.compositeFieldUsage)),
     };
     if (timeframe) {
         y.timeframe = timeframe;
@@ -67,6 +70,7 @@ function literalTimeResult({ value, dataType, timeframe, }) {
         expressionType: xv.expressionType,
         evalSpace: xv.evalSpace,
         value: xv.value,
+        compositeFieldUsage: (0, composite_source_utils_1.emptyCompositeFieldUsage)(),
     };
     if (timeframe) {
         y.timeframe = timeframe;

package/dist/lang/ast/types/expression-def.js

@@ -200,12 +200,11 @@ function getMorphicValue(mv, mt) {
         return mv;
     }
     if (mv.morphic && mv.morphic[mt]) {
-        return {
-            type: mt,
+        return (0, expr_value_1.computedExprValue)({
+            dataType: { type: mt },
             value: mv.morphic[mt],
-            expressionType: mv.expressionType,
-            evalSpace: mv.evalSpace,
-        };
+            from: [mv],
+        });
     }
 }
 exports.getMorphicValue = getMorphicValue;

package/dist/lang/ast/types/query-builder.d.ts

@@ -1,8 +1,9 @@
-import { PipeSegment } from '../../../model/malloy_types';
+import { FilterCondition, PipeSegment } from '../../../model/malloy_types';
 import { QueryProperty } from './query-property';
 import { QueryInputSpace } from '../field-space/query-input-space';
 import { QueryOperationSpace } from '../field-space/query-spaces';
 export interface QueryBuilder {
+    filters: FilterCondition[];
     type: 'grouping' | 'index' | 'project';
     inputFS: QueryInputSpace;
     resultFS: QueryOperationSpace;

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

@@ -24,14 +24,27 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SpaceField = void 0;
 const space_entry_1 = require("./space-entry");
+const composite_source_utils_1 = require("../../../model/composite_source_utils");
 class SpaceField extends space_entry_1.SpaceEntry {
     constructor() {
         super(...arguments);
         this.refType = 'field';
     }
     fieldTypeFromFieldDef(def) {
+        var _a, _b, _c;
         const expressionType = def.expressionType || 'scalar';
-        const ref = { ...def, expressionType, evalSpace: 'input' };
+        const ref = {
+            ...def,
+            expressionType,
+            evalSpace: 'input',
+            compositeFieldUsage: 
+            // Use the composite field usage in the def if it exists, otherwise, if the
+            // field has an e whic is a composite field, then the composite field usage
+            // should be just the name of the field.
+            (_a = def.compositeFieldUsage) !== null && _a !== void 0 ? _a : (((_b = def.e) === null || _b === void 0 ? void 0 : _b.node) === 'compositeField'
+                ? { fields: [(_c = def.as) !== null && _c !== void 0 ? _c : def.name], joinedUsage: {} }
+                : (0, composite_source_utils_1.emptyCompositeFieldUsage)()),
+        };
         return ref;
     }
     getQueryFieldDef(_fs) {