@malloydata/malloy 0.0.294 → 0.0.296

package/dist/dialect/trino/dialect_functions.js

@@ -211,6 +211,106 @@ const string_reverse = {
     returns: 'string',
     impl: { sql: 'REVERSE(CAST(${str} AS VARCHAR))' },
 };
+const set_agg = {
+    generic: { 'T': ['any'] },
+    takes: { 'value': { dimension: T } },
+    returns: { measure: { array: T } },
+    impl: { function: 'SET_AGG' },
+    isSymmetric: true,
+};
+const set_union = {
+    generic: { 'T': ['any'] },
+    takes: { x: { array: T } },
+    returns: { measure: { array: T } },
+    impl: { function: 'SET_UNION' },
+};
+const hll_accumulate_moving = {
+    preceding: {
+        takes: {
+            'value': { dimension: T },
+            'preceding': { literal: 'number' },
+        },
+        returns: { calculation: { sql_native: 'hyperloglog' } },
+        generic: {
+            'T': ['string', 'number', 'date', 'timestamp', 'boolean', 'json'],
+        },
+        impl: {
+            function: 'APPROX_SET',
+            needsWindowOrderBy: true,
+            between: { preceding: 'preceding', following: 0 },
+        },
+    },
+    following: {
+        takes: {
+            'value': { dimension: T },
+            'preceding': { literal: 'number' },
+            'following': { literal: 'number' },
+        },
+        returns: { calculation: { sql_native: 'hyperloglog' } },
+        generic: {
+            'T': ['string', 'number', 'date', 'timestamp', 'boolean', 'json'],
+        },
+        impl: {
+            function: 'APPROX_SET',
+            needsWindowOrderBy: true,
+            between: { preceding: 'preceding', following: 'following' },
+        },
+    },
+};
+const hll_combine_moving = {
+    preceding: {
+        takes: {
+            'value': { sql_native: 'hyperloglog' },
+            'preceding': { literal: 'number' },
+        },
+        returns: { calculation: { sql_native: 'hyperloglog' } },
+        impl: {
+            function: 'MERGE',
+            needsWindowOrderBy: true,
+            between: { preceding: 'preceding', following: 0 },
+        },
+    },
+    following: {
+        takes: {
+            'value': { sql_native: 'hyperloglog' },
+            'preceding': { literal: 'number' },
+            'following': { literal: 'number' },
+        },
+        returns: { calculation: { sql_native: 'hyperloglog' } },
+        impl: {
+            function: 'MERGE',
+            needsWindowOrderBy: true,
+            between: { preceding: 'preceding', following: 'following' },
+        },
+    },
+};
+const hll_estimate_moving = {
+    preceding: {
+        takes: {
+            'value': { sql_native: 'hyperloglog' },
+            'preceding': { literal: 'number' },
+        },
+        returns: { calculation: 'number' },
+        impl: {
+            function: 'CARDINALITY',
+            needsWindowOrderBy: true,
+            between: { preceding: 'preceding', following: 0 },
+        },
+    },
+    following: {
+        takes: {
+            'value': { sql_native: 'hyperloglog' },
+            'preceding': { literal: 'number' },
+            'following': { literal: 'number' },
+        },
+        returns: { calculation: 'number' },
+        impl: {
+            function: 'CARDINALITY',
+            needsWindowOrderBy: true,
+            between: { preceding: 'preceding', following: 'following' },
+        },
+    },
+};
 /**
  * This map is for functions which exist in both Presto and Trino.
  * If you are adding functions which only exist in Presto, put them in
@@ -223,6 +323,10 @@ exports.TRINO_DIALECT_FUNCTIONS = {
     // string functions
     reverse: string_reverse,
     // aggregate functions
+    max_by,
+    min_by,
+    string_agg,
+    string_agg_distinct,
     // TODO: Approx percentile can be called with a third argument; we probably
     // want to implement that at some point
     // In Presto, this is an "error" parameter between 0 and 1
@@ -284,10 +388,9 @@ exports.TRINO_DIALECT_FUNCTIONS = {
         returns: { dimension: { sql_native: 'hyperloglog' } },
         impl: { sql: 'CAST(${value} AS HyperLogLog)' },
     },
-    max_by,
-    min_by,
-    string_agg,
-    string_agg_distinct,
+    hll_accumulate_moving,
+    hll_combine_moving,
+    hll_estimate_moving,
     ...(0, util_1.def)('variance', { 'n': 'number' }, { measure: 'number' }),
     // scalar functions
     ...(0, util_1.def)('bitwise_and', { 'val1': 'number', 'val2': 'number' }, 'number'),
@@ -315,6 +418,8 @@ exports.TRINO_DIALECT_FUNCTIONS = {
     array_agg_distinct,
     array_join,
     sequence,
+    set_agg,
+    set_union,
     ...(0, util_1.def)('array_distinct', { 'x': { array: T } }, { array: T }),
     ...(0, util_1.def)('array_except', { 'x': { array: T }, 'y': { array: T } }, { array: T }),
     ...(0, util_1.def)('array_intersect', { 'x': { array: T }, 'y': { array: T } }, { array: T }),
@@ -402,5 +507,38 @@ exports.PRESTO_DIALECT_FUNCTIONS = {
             impl: { sql: 'APPROX_SET(${value}, 0.0040625)' },
         },
     },
+    hll_accumulate_moving: {
+        preceding: {
+            takes: {
+                'value': { dimension: T },
+                'preceding': { literal: 'number' },
+            },
+            returns: { calculation: { sql_native: 'hyperloglog' } },
+            generic: {
+                'T': ['string', 'number', 'date', 'timestamp', 'boolean', 'json'],
+            },
+            impl: {
+                sql: 'APPROX_SET(${value}, 0.0040625)',
+                needsWindowOrderBy: true,
+                between: { preceding: 'preceding', following: 0 },
+            },
+        },
+        following: {
+            takes: {
+                'value': { dimension: T },
+                'preceding': { literal: 'number' },
+                'following': { literal: 'number' },
+            },
+            returns: { calculation: { sql_native: 'hyperloglog' } },
+            generic: {
+                'T': ['string', 'number', 'date', 'timestamp', 'boolean', 'json'],
+            },
+            impl: {
+                sql: 'APPROX_SET(${value}, 0.0040625)',
+                needsWindowOrderBy: true,
+                between: { preceding: 'preceding', following: 'following' },
+            },
+        },
+    },
 };
 //# sourceMappingURL=dialect_functions.js.map

package/dist/index.d.ts

@@ -10,7 +10,7 @@ export type { QueryOptionsReader, RunSQLOptions } from './run_sql_options';
 export type { EventStream, ModelString, ModelURL, QueryString, QueryURL, URLReader, InvalidationKey, } from './runtime_types';
 export type { Connection, ConnectionConfig, ConnectionFactory, ConnectionParameter, ConnectionParameterValue, ConnectionConfigSchema, FetchSchemaOptions, InfoConnection, LookupConnection, PersistSQLResults, PooledConnection, TestableConnection, StreamingConnection, } from './connection/types';
 export { toAsyncGenerator } from './connection_utils';
-export { modelDefToModelInfo, sourceDefToSourceInfo } from './to_stable';
+export { modelDefToModelInfo, sourceDefToSourceInfo, writeMalloyObjectToTag, extractMalloyObjectFromTag, } from './to_stable';
 export * as API from './api';
 export type { SQLSourceRequest } from './lang/translate-response';
 export { sqlKey } from './model/sql_block';

package/dist/index.js

@@ -34,7 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConnectionRuntime = exports.AtomicFieldType = exports.Runtime = exports.Malloy = exports.Model = exports.MalloyTranslator = exports.malloyToQuery = exports.isDateUnit = exports.isTimestampUnit = exports.composeSQLExpr = exports.indent = exports.expressionIsUngroupedAggregate = exports.expressionIsScalar = exports.expressionIsCalculation = exports.expressionIsAnalytic = exports.expressionIsAggregate = exports.mkFieldDef = exports.mkArrayDef = exports.isBasicArray = exports.isRepeatedRecord = exports.isSamplingRows = exports.isSamplingPercent = exports.isSamplingEnable = exports.isJoinedSource = exports.isJoined = exports.isBasicAtomic = exports.Segment = exports.isSourceDef = exports.TinyParser = exports.Dialect = exports.spread = exports.literal = exports.variadicParam = exports.param = exports.makeParam = exports.sql = exports.maxScalar = exports.minAggregate = exports.anyExprType = exports.minScalar = exports.overload = exports.qtz = exports.arg = exports.registerDialect = exports.MySQLDialect = exports.SnowflakeDialect = exports.PostgresDialect = exports.TrinoDialect = exports.StandardSQLDialect = exports.DuckDBDialect = void 0;
-exports.annotationToTaglines = exports.annotationToTag = exports.sqlKey = exports.API = exports.sourceDefToSourceInfo = exports.modelDefToModelInfo = exports.toAsyncGenerator = exports.CacheManager = exports.InMemoryModelCache = exports.Explore = exports.DataWriter = exports.Parse = exports.JSONWriter = exports.CSVWriter = exports.QueryMaterializer = exports.Result = exports.PreparedResult = exports.TimestampTimeframe = exports.DateTimeframe = exports.SourceRelationship = exports.JoinRelationship = exports.MalloyError = exports.FixedConnectionMap = exports.InMemoryURLReader = exports.EmptyURLReader = exports.SingleConnectionRuntime = void 0;
+exports.annotationToTaglines = exports.annotationToTag = exports.sqlKey = exports.API = exports.extractMalloyObjectFromTag = exports.writeMalloyObjectToTag = exports.sourceDefToSourceInfo = exports.modelDefToModelInfo = exports.toAsyncGenerator = exports.CacheManager = exports.InMemoryModelCache = exports.Explore = exports.DataWriter = exports.Parse = exports.JSONWriter = exports.CSVWriter = exports.QueryMaterializer = exports.Result = exports.PreparedResult = exports.TimestampTimeframe = exports.DateTimeframe = exports.SourceRelationship = exports.JoinRelationship = exports.MalloyError = exports.FixedConnectionMap = exports.InMemoryURLReader = exports.EmptyURLReader = exports.SingleConnectionRuntime = void 0;
 /*
  * Copyright 2023 Google LLC
  *
@@ -137,6 +137,8 @@ Object.defineProperty(exports, "toAsyncGenerator", { enumerable: true, get: func
 var to_stable_1 = require("./to_stable");
 Object.defineProperty(exports, "modelDefToModelInfo", { enumerable: true, get: function () { return to_stable_1.modelDefToModelInfo; } });
 Object.defineProperty(exports, "sourceDefToSourceInfo", { enumerable: true, get: function () { return to_stable_1.sourceDefToSourceInfo; } });
+Object.defineProperty(exports, "writeMalloyObjectToTag", { enumerable: true, get: function () { return to_stable_1.writeMalloyObjectToTag; } });
+Object.defineProperty(exports, "extractMalloyObjectFromTag", { enumerable: true, get: function () { return to_stable_1.extractMalloyObjectFromTag; } });
 exports.API = __importStar(require("./api"));
 var sql_block_1 = require("./model/sql_block");
 Object.defineProperty(exports, "sqlKey", { enumerable: true, get: function () { return sql_block_1.sqlKey; } });

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

@@ -3,6 +3,7 @@ import type { ExprValue } from '../types/expr-value';
 import { ExpressionDef } from '../types/expression-def';
 import type { FieldSpace } from '../types/field-space';
 import { Range } from './range';
+import type * as Malloy from '@malloydata/malloy-interfaces';
 /**
  * GranularTime is a moment in time which ALSO has a "granularity"
  * commonly this are created by applying ".datePart" to an expression
@@ -18,6 +19,7 @@ export declare class ExprGranularTime extends ExpressionDef {
     legalChildTypes: import("../../../model/malloy_types").TypeDesc[];
     constructor(expr: ExpressionDef, units: TimestampUnit, truncate: boolean);
     granular(): boolean;
+    drillExpression(): Malloy.Expression | undefined;
     getExpression(fs: FieldSpace): ExprValue;
     toRange(fs: FieldSpace): Range;
 }

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

@@ -82,6 +82,19 @@ class ExprGranularTime extends expression_def_1.ExpressionDef {
     granular() {
         return true;
     }
+    drillExpression() {
+        const lhs = this.expr.drillExpression();
+        if ((lhs === null || lhs === void 0 ? void 0 : lhs.kind) !== 'field_reference')
+            return undefined;
+        return {
+            kind: 'time_truncation',
+            field_reference: {
+                name: lhs.name,
+                path: lhs.path,
+            },
+            truncation: this.units,
+        };
+    }
     getExpression(fs) {
         const timeframe = this.units;
         const exprVal = this.expr.getExpression(fs);

package/dist/lang/ast/expressions/expr-id-reference.d.ts

@@ -2,10 +2,12 @@ import type { ExprValue } from '../types/expr-value';
 import type { FieldReference } from '../query-items/field-references';
 import type { FieldSpace } from '../types/field-space';
 import { ExpressionDef } from '../types/expression-def';
+import type * as Malloy from '@malloydata/malloy-interfaces';
 export declare class ExprIdReference extends ExpressionDef {
     readonly fieldReference: FieldReference;
     elementType: string;
     constructor(fieldReference: FieldReference);
     get refString(): string;
+    drillExpression(): Malloy.Expression | undefined;
     getExpression(fs: FieldSpace): ExprValue;
 }

package/dist/lang/ast/expressions/expr-id-reference.js

@@ -35,6 +35,13 @@ class ExprIdReference extends expression_def_1.ExpressionDef {
     get refString() {
         return this.fieldReference.refString;
     }
+    drillExpression() {
+        return {
+            kind: 'field_reference',
+            name: this.fieldReference.nameString,
+            path: this.fieldReference.path.slice(0, -1),
+        };
+    }
     getExpression(fs) {
         const def = this.fieldReference.getField(fs);
         if (def.found) {

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

@@ -101,6 +101,11 @@ class ReferenceField extends space_field_1.SpaceField {
                     type: 'fieldref',
                     path,
                     at: this.fieldRef.location,
+                    drillExpression: {
+                        kind: 'field_reference',
+                        name: path[path.length - 1],
+                        path: path.slice(0, -1),
+                    },
                 };
             }
             const refTo = this.referenceTo;
@@ -128,17 +133,17 @@ class ReferenceField extends space_field_1.SpaceField {
         if (refTo) {
             const joinPath = this.fieldRef.list.slice(0, -1).map(x => x.refString);
             const typeDesc = refTo.typeDesc();
+            const usage = {
+                path: this.fieldRef.path,
+                at: this.fieldRef.location,
+            };
             this.memoTypeDesc = {
                 ...typeDesc,
-                fieldUsage: [
-                    {
-                        path: this.fieldRef.path,
-                        at: this.fieldRef.location,
-                    },
-                ],
+                fieldUsage: [usage],
                 requiresGroupBy: (_a = typeDesc.requiresGroupBy) === null || _a === void 0 ? void 0 : _a.map(gb => ({
                     ...gb,
                     path: [...joinPath, ...gb.path],
+                    fieldUsage: usage,
                 })),
             };
             return this.memoTypeDesc;

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

@@ -147,6 +147,7 @@ class AtomicFieldDeclaration extends malloy_element_1.MalloyElement {
             else {
                 ret.e = exprValue.value;
             }
+            ret.drillExpression = this.expr.drillExpression();
             ret.fieldUsage = exprValue.fieldUsage;
             ret.ungroupings = exprValue.ungroupings;
             ret.requiresGroupBy = exprValue.requiresGroupBy;

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

@@ -1,4 +1,4 @@
-import type { Expr, FilterCondition, PipeSegment, TypeDesc } from '../../../model/malloy_types';
+import type { Expr, FilterCondition, PipeSegment, TurtleDef, TypeDesc } from '../../../model/malloy_types';
 import type { FieldReference } from '../query-items/field-references';
 import type { ExprValue } from '../types/expr-value';
 import { ExpressionDef } from '../types/expression-def';
@@ -22,4 +22,5 @@ export declare class Drill extends Filter implements QueryPropertyInterface {
     protected checkedDrillCondition(fs: FieldSpace, filter: FilterElement, reference: FieldReference, value: Literal): FilterCondition | undefined;
     protected checkedFilterCondition(fs: FieldSpace, filter: FilterElement): FilterCondition | undefined;
 }
-export declare function attachDrillPaths(pipeline: PipeSegment[], name: string): PipeSegment[];
+export declare function updateNestedDrillPaths(nest: TurtleDef, name: string): TurtleDef;
+export declare function attachDrillPaths(pipeline: PipeSegment[], nestName: string): PipeSegment[];

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

@@ -7,6 +7,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Drill = exports.DrillField = void 0;
+exports.updateNestedDrillPaths = updateNestedDrillPaths;
 exports.attachDrillPaths = attachDrillPaths;
 const composite_source_utils_1 = require("../../../model/composite_source_utils");
 const malloy_types_1 = require("../../../model/malloy_types");
@@ -292,7 +293,8 @@ class Drill extends filters_1.Filter {
             fieldUsage: (0, composite_source_utils_1.mergeFieldUsage)(fExpr.fieldUsage, collectedWhereFieldUsage),
             stableFilter: {
                 kind: 'literal_equality',
-                field_reference: {
+                expression: {
+                    kind: 'field_reference',
                     name: fieldName.refString,
                     path: reference.list.slice(0, -1).map(f => f.name),
                 },
@@ -312,7 +314,39 @@ class Drill extends filters_1.Filter {
     }
 }
 exports.Drill = Drill;
-function attachDrillPaths(pipeline, name) {
+function updateNestedDrillPaths(nest, name) {
+    if (nest.pipeline.length !== 1 || !(0, malloy_types_1.isQuerySegment)(nest.pipeline[0])) {
+        return nest;
+    }
+    return {
+        ...nest,
+        pipeline: [
+            {
+                ...nest.pipeline[0],
+                queryFields: nest.pipeline[0].queryFields.map(f => {
+                    var _a;
+                    if (f.type === 'turtle') {
+                        return updateNestedDrillPaths(f, name);
+                    }
+                    const existing = f.drillExpression;
+                    if (existing === undefined)
+                        return f;
+                    if (existing.kind !== 'field_reference') {
+                        return { ...f, drillExpression: undefined };
+                    }
+                    return {
+                        ...f,
+                        drillExpression: {
+                            ...existing,
+                            path: [name, ...((_a = existing.path) !== null && _a !== void 0 ? _a : [])],
+                        },
+                    };
+                }),
+            },
+        ],
+    };
+}
+function attachDrillPaths(pipeline, nestName) {
     var _a;
     if (pipeline.length !== 1)
         return pipeline;
@@ -323,12 +357,23 @@ function attachDrillPaths(pipeline, name) {
             ...pipeline[0],
             filterList: (_a = pipeline[0].filterList) === null || _a === void 0 ? void 0 : _a.map(f => ({
                 ...f,
-                drillView: name,
-            })),
-            queryFields: pipeline[0].queryFields.map(f => ({
-                ...f,
-                drillView: name,
+                filterView: nestName,
             })),
+            queryFields: pipeline[0].queryFields.map(f => {
+                var _a;
+                if (f.type === 'turtle') {
+                    return updateNestedDrillPaths(f, nestName);
+                }
+                const fieldName = f.type === 'fieldref' ? f.path[f.path.length - 1] : (_a = f.as) !== null && _a !== void 0 ? _a : f.name;
+                return {
+                    ...f,
+                    drillExpression: {
+                        kind: 'field_reference',
+                        name: fieldName,
+                        path: [nestName],
+                    },
+                };
+            }),
         },
     ];
 }

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

@@ -39,28 +39,28 @@ class FilterElement extends malloy_element_1.MalloyElement {
         this.elementType = 'filterElement';
     }
     getStableFilter() {
-        const drillFilter = this.drillFilter();
-        if (drillFilter !== undefined) {
+        if (this.expr instanceof expr_compare_1.ExprEquality &&
+            this.expr.op === '=' &&
+            (0, literal_1.isLiteral)(this.expr.right)) {
+            const lhs = this.expr.left.drillExpression();
+            if (lhs === undefined)
+                return undefined;
             return {
                 kind: 'literal_equality',
-                field_reference: {
-                    name: drillFilter.reference.nameString,
-                    path: drillFilter.reference.list.map(f => f.name).slice(0, -1),
-                },
-                value: drillFilter.value.getStableLiteral(),
+                expression: lhs,
+                value: this.expr.right.getStableLiteral(),
             };
         }
-        const filterExpressionFilter = this.filterExpressionFilter();
-        if (filterExpressionFilter !== undefined) {
+        else if (this.expr instanceof expr_compare_1.ExprCompare &&
+            this.expr.op === '~' &&
+            this.expr.right instanceof expr_filter_expr_1.ExprFilterExpression) {
+            const lhs = this.expr.left.drillExpression();
+            if (lhs === undefined)
+                return undefined;
             return {
                 kind: 'filter_string',
-                field_reference: {
-                    name: filterExpressionFilter.reference.nameString,
-                    path: filterExpressionFilter.reference.list
-                        .map(f => f.name)
-                        .slice(0, -1),
-                },
-                filter: filterExpressionFilter.filterExpression,
+                expression: lhs,
+                filter: this.expr.right.filterText,
             };
         }
         return undefined;

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

@@ -1,3 +1,4 @@
+import type * as Malloy from '@malloydata/malloy-interfaces';
 import type { Expr, TimestampUnit } from '../../../model/malloy_types';
 import type { ExprValue } from './expr-value';
 import type { FieldSpace } from './field-space';
@@ -42,6 +43,7 @@ export declare abstract class ExpressionDef extends MalloyElement {
      * @param eVal ...list of expressions that must match legalChildTypes
      */
     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

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

@@ -124,6 +124,9 @@ class ExpressionDef extends malloy_element_1.MalloyElement {
         }
         return true;
     }
+    drillExpression() {
+        return undefined;
+    }
     /**
      * This is the operation which makes partial comparison and value trees work
      * The default implementation merely constructs LEFT OP RIGHT, but specialized

package/dist/lang/malloy-to-stable-query.js

@@ -736,7 +736,8 @@ class MalloyToQuery extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor
                         return {
                             filter: {
                                 kind: 'filter_string',
-                                field_reference: {
+                                expression: {
+                                    kind: 'field_reference',
                                     name,
                                     path,
                                 },
@@ -759,7 +760,8 @@ class MalloyToQuery extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor
                     return {
                         filter: {
                             kind: 'literal_equality',
-                            field_reference: {
+                            expression: {
+                                kind: 'field_reference',
                                 name,
                                 path,
                             },

package/dist/lang/parse-log.d.ts

@@ -1,4 +1,4 @@
-import type { FieldUsage, DocumentLocation, ExpressionValueType } from '../model/malloy_types';
+import type { DocumentLocation, ExpressionValueType } from '../model/malloy_types';
 import type { EventStream } from '../runtime_types';
 export type LogSeverity = 'error' | 'warn' | 'debug';
 /**
@@ -159,11 +159,6 @@ type MessageParameterTypes = {
     'field-not-found': string;
     'composite-field-type-mismatch': string;
     'invalid-composite-source-input': string;
-    'invalid-composite-field-usage': {
-        newUsage: FieldUsage[];
-        allUsage: FieldUsage[];
-        conflictingUsage: FieldUsage[];
-    };
     'could-not-resolve-composite-source': string;
     'empty-composite-source': string;
     'unnecessary-composite-source': string;

package/dist/lang/parse-log.js

@@ -24,7 +24,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MESSAGE_FORMATTERS = exports.BaseMessageLogger = void 0;
 exports.makeLogMessage = makeLogMessage;
-const composite_source_utils_1 = require("../model/composite_source_utils");
 class BaseMessageLogger {
     constructor(eventStream) {
         this.eventStream = eventStream;
@@ -96,13 +95,6 @@ exports.MESSAGE_FORMATTERS = {
     'case-else-type-does-not-match': e => `Case else type ${e.elseType} does not match return type ${e.returnType}`,
     'case-when-must-be-boolean': e => `Case when expression must be boolean, not ${e.whenType}`,
     'case-when-type-does-not-match': e => `Case when type ${e.whenType} does not match value type ${e.valueType}`,
-    'invalid-composite-field-usage': e => {
-        const formattedNewCompositeUsage = (0, composite_source_utils_1.formatFieldUsages)(e.newUsage);
-        const formattedConflictingCompositeUsage = (0, composite_source_utils_1.formatFieldUsages)(e.conflictingUsage);
-        const formattedAllCompositeUsage = (0, composite_source_utils_1.formatFieldUsages)(e.allUsage);
-        const pluralUse = (0, composite_source_utils_1.fieldUsageIsPlural)(e.newUsage) ? 's' : '';
-        return `This operation uses field${pluralUse} ${formattedNewCompositeUsage}, resulting in invalid usage of the composite source, as there is no composite input source which defines all of ${formattedConflictingCompositeUsage}\nFields required in source: ${formattedAllCompositeUsage}`;
-    },
 };
 function makeLogMessage(code, parameters, options) {
     var _a, _b, _c, _d, _e;

package/dist/model/composite_source_utils.d.ts

@@ -84,7 +84,6 @@ export declare function fieldUsageJoinPaths(fieldUsage: FieldUsage[]): string[][
 export declare function checkRequiredGroupBys(compositeResolvedSourceDef: SourceDef, segment: PipeSegment): RequiredGroupBy[];
 export declare function pathEq(a: string[], b: string[]): boolean;
 export declare function pathBegins(path: string[], prefix: string[]): boolean;
-export declare function sortFieldUsageByReferenceLocation(usage: FieldUsage[]): FieldUsage[];
 export declare function hasCompositesAnywhere(source: StructDef): boolean;
 export declare function logCompositeError(error: CompositeError, logTo: MalloyElement): void;
 export declare function compileFilterExpression(ft: string, fexpr: Expr): {