@malloydata/malloy 0.0.305 → 0.0.307

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

@@ -885,6 +885,18 @@ class MalloyToQuery extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor
         else if (literalCx instanceof parse.ExprNULLContext) {
             return { kind: 'null_literal' };
         }
+        else if (literalCx instanceof parse.FilterString_stubContext) {
+            const filterContext = literalCx.getChild(0);
+            if (filterContext instanceof parse.FilterStringContext) {
+                const filterString = this.getFilterString(filterContext);
+                if (filterString) {
+                    return {
+                        kind: 'filter_expression_literal',
+                        filter_expression_value: filterString,
+                    };
+                }
+            }
+        }
         return null;
     }
     getDrill(drillCx) {

package/dist/model/constant_expression_compiler.d.ts

@@ -0,0 +1,22 @@
+import type { Expr, Parameter } from './malloy_types';
+import type { Dialect } from '../dialect';
+import type { EventStream } from '../runtime_types';
+type ConstantExpressionResult = {
+    sql: string;
+    error?: undefined;
+} | {
+    sql?: undefined;
+    error: string;
+};
+/**
+ * Compiles an IR expression containing only constants and parameters to SQL.
+ * This is useful for expressions that don't reference source fields.
+ *
+ * @param expr The expression to compile (should contain only literals, parameters, and operations on them)
+ * @param dialect The SQL dialect to use for generation
+ * @param parameters Parameters that can be referenced in the expression
+ * @param eventStream Optional event stream for debugging/tracking
+ * @returns Either {sql: string} on success or {error: string} on failure
+ */
+export declare function constantExprToSQL(expr: Expr, dialect: Dialect, parameters?: Record<string, Parameter>, eventStream?: EventStream): ConstantExpressionResult;
+export {};

package/dist/model/constant_expression_compiler.js

@@ -0,0 +1,144 @@
+"use strict";
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.constantExprToSQL = constantExprToSQL;
+const expression_compiler_1 = require("./expression_compiler");
+const utils_1 = require("./utils");
+const query_node_1 = require("./query_node");
+const field_instance_1 = require("./field_instance");
+/**
+ * Custom error class for constant expression compilation errors.
+ * Used to distinguish expected errors from unexpected ones.
+ */
+class ConstantExpressionError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ConstantExpressionError';
+    }
+}
+/**
+ * Minimal FieldInstanceResultRoot for constant expressions.
+ * This serves as both the result set and its own root, providing
+ * only what's needed by exprToSQL for constants.
+ */
+class ConstantFieldInstanceResultRoot extends field_instance_1.FieldInstanceResultRoot {
+    constructor() {
+        // Create a minimal TurtleDef
+        const minimalTurtleDef = {
+            type: 'turtle',
+            name: '__constant__',
+            pipeline: [],
+        };
+        super(minimalTurtleDef);
+        this.joins = new Map();
+        this.havings = new utils_1.AndChain();
+        this.isComplexQuery = false;
+        this.queryUsesPartitioning = false;
+        this.computeOnlyGroups = [];
+        this.elimatedComputeGroups = false;
+        // Create minimal SourceDef for outputStruct
+        const minimalOutputStruct = {
+            type: 'table',
+            name: '__constant_output__',
+            fields: [],
+            tablePath: '__constant__',
+            connection: '__constant__',
+            dialect: 'standardsql',
+        };
+        // Create minimal QuerySegment
+        const minimalSegment = {
+            type: 'project',
+            filterList: [],
+            queryFields: [],
+            outputStruct: minimalOutputStruct,
+            isRepeated: false,
+        };
+        this.firstSegment = minimalSegment;
+    }
+    root() {
+        return this;
+    }
+    getQueryInfo() {
+        // Return minimal query info - constants don't need timezone
+        return {
+            queryTimezone: 'UTC',
+        };
+    }
+}
+/**
+ * Minimal QueryStruct subclass for constant expression compilation.
+ * This provides only what's needed to compile expressions containing
+ * literals and parameters, without requiring a full query structure.
+ */
+class ConstantQueryStruct extends query_node_1.QueryStruct {
+    constructor(dialect, parameters, eventStream) {
+        // Create a minimal StructDef that satisfies the constructor requirements
+        const minimalStructDef = {
+            type: 'table',
+            name: '__constant__',
+            fields: [],
+            tablePath: '__constant__',
+            connection: dialect.name,
+            dialect: dialect.name,
+        };
+        // Create a minimal model interface that only provides eventStream
+        const minimalModel = { eventStream };
+        // Create minimal prepare result options
+        const minimalPrepareOptions = {};
+        // Call parent constructor with minimal requirements
+        super(minimalStructDef, undefined, // no source arguments initially
+        { model: minimalModel }, minimalPrepareOptions);
+        this.dialect = dialect;
+        this._constantArguments = parameters;
+        if (eventStream) {
+            this.model.eventStream = eventStream;
+        }
+    }
+    /**
+     * Override arguments() to return our parameters
+     */
+    arguments() {
+        return this._constantArguments;
+    }
+    /**
+     * These methods should not be called for constant expressions
+     */
+    getFieldByName(path) {
+        throw new ConstantExpressionError(`Illegal reference to '${path.join('.')}' in constant expressions`);
+    }
+    getStructByName(path) {
+        throw new ConstantExpressionError(`Illegal reference to '${path.join('.')}' in constant expressions`);
+    }
+    getSQLIdentifier() {
+        throw new ConstantExpressionError('Constant expressions do not need SQL identifiers');
+    }
+}
+/**
+ * Compiles an IR expression containing only constants and parameters to SQL.
+ * This is useful for expressions that don't reference source fields.
+ *
+ * @param expr The expression to compile (should contain only literals, parameters, and operations on them)
+ * @param dialect The SQL dialect to use for generation
+ * @param parameters Parameters that can be referenced in the expression
+ * @param eventStream Optional event stream for debugging/tracking
+ * @returns Either {sql: string} on success or {error: string} on failure
+ */
+function constantExprToSQL(expr, dialect, parameters = {}, eventStream) {
+    try {
+        const context = new ConstantQueryStruct(dialect, parameters, eventStream);
+        const resultSet = new ConstantFieldInstanceResultRoot();
+        const sql = (0, expression_compiler_1.exprToSQL)(resultSet, context, expr);
+        return { sql };
+    }
+    catch (error) {
+        if (error instanceof ConstantExpressionError) {
+            return { error: error.message };
+        }
+        // Re-throw unexpected errors
+        throw error;
+    }
+}
+//# sourceMappingURL=constant_expression_compiler.js.map

package/dist/model/expression_compiler.d.ts

@@ -1,27 +1,26 @@
-import type { Expr, FunctionCallNode, FunctionOverloadDef, FunctionOrderBy, FieldnameNode, OutputFieldNode, GenericSQLExpr, FilteredExpr, UngroupNode, ParameterNode, SpreadExpr, AggregateExpr, SourceReferenceNode, CaseExpr } from './malloy_types';
+import type { Expr, FunctionCallNode, FunctionOverloadDef, FunctionOrderBy, FieldnameNode, OutputFieldNode, GenericSQLExpr, FilteredExpr, UngroupNode, ParameterNode, AggregateExpr, SourceReferenceNode, CaseExpr } from './malloy_types';
 import { type FieldInstanceResult } from './field_instance';
 import { GenerateState } from './utils';
-import type { QueryStruct, QueryField } from './query_node';
+import type { QueryStruct } from './query_node';
 /**
  * Converts an expression to SQL.
  * This function was extracted from QueryField.exprToSQL to break circular dependencies.
  */
-export declare function exprToSQL(field: QueryField, resultSet: FieldInstanceResult, context: QueryStruct, exprToTranslate: Expr, state?: GenerateState): string;
-export declare function generateFunctionCallExpression(field: QueryField, resultSet: FieldInstanceResult, context: QueryStruct, frag: FunctionCallNode, state: GenerateState): string;
-export declare function generateFieldFragment(field: QueryField, resultSet: FieldInstanceResult, context: QueryStruct, expr: FieldnameNode, state: GenerateState): string;
-export declare function generateOutputFieldFragment(field: QueryField, resultSet: FieldInstanceResult, _context: QueryStruct, frag: OutputFieldNode, _state: GenerateState): string;
-export declare function generateParameterFragment(field: QueryField, resultSet: FieldInstanceResult, context: QueryStruct, expr: ParameterNode, state: GenerateState): string;
-export declare function generateFilterFragment(field: QueryField, resultSet: FieldInstanceResult, context: QueryStruct, expr: FilteredExpr, state: GenerateState): string;
-export declare function generateDimFragment(field: QueryField, resultSet: FieldInstanceResult, context: QueryStruct, expr: Expr, state: GenerateState): string;
-export declare function generateUngroupedFragment(field: QueryField, resultSet: FieldInstanceResult, context: QueryStruct, expr: UngroupNode, state: GenerateState): string;
-export declare function generateDistinctKeyIfNecessary(field: QueryField, resultSet: FieldInstanceResult, context: QueryStruct, structPath: string[] | undefined): string | undefined;
-export declare function generateSumFragment(field: QueryField, resultSet: FieldInstanceResult, context: QueryStruct, expr: AggregateExpr, state: GenerateState): string;
-export declare function generateSymmetricFragment(field: QueryField, resultSet: FieldInstanceResult, context: QueryStruct, expr: AggregateExpr, state: GenerateState): string;
-export declare function generateAvgFragment(field: QueryField, resultSet: FieldInstanceResult, context: QueryStruct, expr: AggregateExpr, state: GenerateState): string;
-export declare function generateCountFragment(field: QueryField, resultSet: FieldInstanceResult, context: QueryStruct, expr: AggregateExpr, state: GenerateState): string;
-export declare function generateSpread(field: QueryField, _resultSet: FieldInstanceResult, _context: QueryStruct, _frag: SpreadExpr, _state: GenerateState): string;
-export declare function generateSourceReference(field: QueryField, resultSet: FieldInstanceResult, context: QueryStruct, expr: SourceReferenceNode): string;
-export declare function generateCaseSQL(field: QueryField, pf: CaseExpr): string;
-export declare function getFunctionOrderBy(field: QueryField, resultSet: FieldInstanceResult, context: QueryStruct, state: GenerateState, orderBy: FunctionOrderBy[], args: Expr[], overload: FunctionOverloadDef): string | undefined;
-export declare function getAnalyticPartitions(field: QueryField, resultStruct: FieldInstanceResult, extraPartitionFields?: string[]): string[];
-export declare function stringsFromSQLExpression(field: QueryField, resultSet: FieldInstanceResult, context: QueryStruct, e: GenericSQLExpr, state: GenerateState): Generator<string, void, unknown>;
+export declare function exprToSQL(resultSet: FieldInstanceResult, context: QueryStruct, exprToTranslate: Expr, state?: GenerateState): string;
+export declare function generateFunctionCallExpression(resultSet: FieldInstanceResult, context: QueryStruct, frag: FunctionCallNode, state: GenerateState): string;
+export declare function generateFieldFragment(resultSet: FieldInstanceResult, context: QueryStruct, expr: FieldnameNode, state: GenerateState): string;
+export declare function generateOutputFieldFragment(resultSet: FieldInstanceResult, _context: QueryStruct, frag: OutputFieldNode, _state: GenerateState): string;
+export declare function generateParameterFragment(resultSet: FieldInstanceResult, context: QueryStruct, expr: ParameterNode, state: GenerateState): string;
+export declare function generateFilterFragment(resultSet: FieldInstanceResult, context: QueryStruct, expr: FilteredExpr, state: GenerateState): string;
+export declare function generateDimFragment(resultSet: FieldInstanceResult, context: QueryStruct, expr: Expr, state: GenerateState): string;
+export declare function generateUngroupedFragment(resultSet: FieldInstanceResult, context: QueryStruct, expr: UngroupNode, state: GenerateState): string;
+export declare function generateDistinctKeyIfNecessary(resultSet: FieldInstanceResult, context: QueryStruct, structPath: string[] | undefined): string | undefined;
+export declare function generateSumFragment(resultSet: FieldInstanceResult, context: QueryStruct, expr: AggregateExpr, state: GenerateState): string;
+export declare function generateSymmetricFragment(resultSet: FieldInstanceResult, context: QueryStruct, expr: AggregateExpr, state: GenerateState): string;
+export declare function generateAvgFragment(resultSet: FieldInstanceResult, context: QueryStruct, expr: AggregateExpr, state: GenerateState): string;
+export declare function generateCountFragment(resultSet: FieldInstanceResult, context: QueryStruct, expr: AggregateExpr, state: GenerateState): string;
+export declare function generateSourceReference(resultSet: FieldInstanceResult, context: QueryStruct, expr: SourceReferenceNode): string;
+export declare function generateCaseSQL(pf: CaseExpr): string;
+export declare function getFunctionOrderBy(resultSet: FieldInstanceResult, context: QueryStruct, state: GenerateState, orderBy: FunctionOrderBy[], args: Expr[], overload: FunctionOverloadDef): string | undefined;
+export declare function getAnalyticPartitions(resultStruct: FieldInstanceResult, extraPartitionFields?: string[]): string[];
+export declare function stringsFromSQLExpression(resultSet: FieldInstanceResult, context: QueryStruct, e: GenericSQLExpr, state: GenerateState): Generator<string, void, unknown>;

package/dist/model/expression_compiler.js

@@ -17,7 +17,6 @@ exports.generateSumFragment = generateSumFragment;
 exports.generateSymmetricFragment = generateSymmetricFragment;
 exports.generateAvgFragment = generateAvgFragment;
 exports.generateCountFragment = generateCountFragment;
-exports.generateSpread = generateSpread;
 exports.generateSourceReference = generateSourceReference;
 exports.generateCaseSQL = generateCaseSQL;
 exports.getFunctionOrderBy = getFunctionOrderBy;
@@ -51,11 +50,11 @@ function sqlSumDistinct(dialect, sqlExp, sqlDistintKey) {
  * Converts an expression to SQL.
  * This function was extracted from QueryField.exprToSQL to break circular dependencies.
  */
-function exprToSQL(field, resultSet, context, exprToTranslate, state = new utils_1.GenerateState()) {
+function exprToSQL(resultSet, context, exprToTranslate, state = new utils_1.GenerateState()) {
     var _a;
     // Wrap non leaf sub expressions in parenthesis
-    const subExpr = function (qf, e) {
-        const sql = exprToSQL(qf, resultSet, context, e, state);
+    const subExpr = function (e) {
+        const sql = exprToSQL(resultSet, context, e, state);
         if ((0, malloy_types_1.exprHasKids)(e)) {
             return `(${sql})`;
         }
@@ -69,7 +68,7 @@ function exprToSQL(field, resultSet, context, exprToTranslate, state = new utils
     let expr = exprToTranslate;
     if ((0, malloy_types_1.exprHasE)(exprToTranslate)) {
         expr = { ...exprToTranslate };
-        const eSql = subExpr(field, expr.e);
+        const eSql = subExpr(expr.e);
         expr.e = { ...expr.e, sql: eSql };
     }
     else if ((0, malloy_types_1.exprHasKids)(exprToTranslate)) {
@@ -80,11 +79,11 @@ function exprToSQL(field, resultSet, context, exprToTranslate, state = new utils
                 continue;
             if (Array.isArray(kidExpr)) {
                 expr.kids[name] = kidExpr.map(e => {
-                    return { ...e, sql: subExpr(field, e) };
+                    return { ...e, sql: subExpr(e) };
                 });
             }
             else {
-                expr.kids[name] = { ...oldKids[name], sql: subExpr(field, kidExpr) };
+                expr.kids[name] = { ...oldKids[name], sql: subExpr(kidExpr) };
             }
         }
     }
@@ -92,37 +91,37 @@ function exprToSQL(field, resultSet, context, exprToTranslate, state = new utils
      * Give the dialect a chance to translate this node
      */
     const qi = resultSet.getQueryInfo();
-    const dialectSQL = field.parent.dialect.exprToSQL(qi, expr);
+    const dialectSQL = context.dialect.exprToSQL(qi, expr);
     if (dialectSQL) {
         return dialectSQL;
     }
     switch (expr.node) {
         case 'field':
-            return generateFieldFragment(field, resultSet, context, expr, state);
+            return generateFieldFragment(resultSet, context, expr, state);
         case 'parameter':
-            return generateParameterFragment(field, resultSet, context, expr, state);
+            return generateParameterFragment(resultSet, context, expr, state);
         case 'filteredExpr':
-            return generateFilterFragment(field, resultSet, context, expr, state);
+            return generateFilterFragment(resultSet, context, expr, state);
         case 'all':
         case 'exclude':
-            return generateUngroupedFragment(field, resultSet, context, expr, state);
+            return generateUngroupedFragment(resultSet, context, expr, state);
         case 'genericSQLExpr':
-            return Array.from(stringsFromSQLExpression(field, resultSet, context, expr, state)).join('');
+            return Array.from(stringsFromSQLExpression(resultSet, context, expr, state)).join('');
         case 'aggregate': {
             let agg = '';
             if (expr.function === 'sum') {
-                agg = generateSumFragment(field, resultSet, context, expr, state);
+                agg = generateSumFragment(resultSet, context, expr, state);
             }
             else if (expr.function === 'avg') {
-                agg = generateAvgFragment(field, resultSet, context, expr, state);
+                agg = generateAvgFragment(resultSet, context, expr, state);
             }
             else if (expr.function === 'count') {
-                agg = generateCountFragment(field, resultSet, context, expr, state);
+                agg = generateCountFragment(resultSet, context, expr, state);
             }
             else if (expr.function === 'min' ||
                 expr.function === 'max' ||
                 expr.function === 'distinct') {
-                agg = generateSymmetricFragment(field, resultSet, context, expr, state);
+                agg = generateSymmetricFragment(resultSet, context, expr, state);
             }
             else {
                 throw new Error(`Internal Error: Unknown aggregate function ${expr.function}`);
@@ -139,13 +138,13 @@ function exprToSQL(field, resultSet, context, exprToTranslate, state = new utils
         case 'function_parameter':
             throw new Error('Internal Error: Function parameter fragment remaining during SQL generation');
         case 'outputField':
-            return generateOutputFieldFragment(field, resultSet, context, expr, state);
+            return generateOutputFieldFragment(resultSet, context, expr, state);
         case 'function_call':
-            return generateFunctionCallExpression(field, resultSet, context, expr, state);
+            return generateFunctionCallExpression(resultSet, context, expr, state);
         case 'spread':
-            return generateSpread(field, resultSet, context, expr, state);
+            throw new Error("Internal Error: expandFunctionCall() failed to process node: 'spread'");
         case 'source-reference':
-            return generateSourceReference(field, resultSet, context, expr);
+            return generateSourceReference(resultSet, context, expr);
         case '+':
         case '-':
         case '*':
@@ -175,7 +174,7 @@ function exprToSQL(field, resultSet, context, exprToTranslate, state = new utils
         case '!like': {
             const likeIt = expr.node === 'like' ? 'LIKE' : 'NOT LIKE';
             const compare = expr.kids.right.node === 'stringLiteral'
-                ? field.parent.dialect.sqlLike(likeIt, (_a = expr.kids.left.sql) !== null && _a !== void 0 ? _a : '', expr.kids.right.literal)
+                ? context.dialect.sqlLike(likeIt, (_a = expr.kids.left.sql) !== null && _a !== void 0 ? _a : '', expr.kids.right.literal)
                 : `${expr.kids.left.sql} ${likeIt} ${expr.kids.right.sql}`;
             return expr.node === 'like' ? compare : `COALESCE(${compare},true)`;
         }
@@ -196,7 +195,7 @@ function exprToSQL(field, resultSet, context, exprToTranslate, state = new utils
         case 'null':
             return 'NULL';
         case 'case':
-            return generateCaseSQL(field, expr);
+            return generateCaseSQL(expr);
         case '':
             return '';
         case 'filterCondition':
@@ -214,14 +213,14 @@ function exprToSQL(field, resultSet, context, exprToTranslate, state = new utils
         case 'compositeField':
             return '{COMPOSITE_FIELD}';
         case 'filterMatch':
-            return generateAppliedFilter(field, context, expr);
+            return generateAppliedFilter(context, expr);
         case 'filterLiteral':
             return 'INTERNAL ERROR FILTER EXPRESSION VALUE SHOULD NOT BE USED';
         default:
             throw new Error(`Internal Error: Unknown expression node '${expr.node}' ${JSON.stringify(expr, undefined, 2)}`);
     }
 }
-function generateAppliedFilter(field, context, filterMatchExpr) {
+function generateAppliedFilter(context, filterMatchExpr) {
     var _a;
     let filterExpr = filterMatchExpr.kids.filterExpr;
     while (filterExpr.node === '()') {
@@ -335,19 +334,19 @@ function getParamForArgIndex(params, argIndex) {
     const prevVariadic = params.slice(0, argIndex).find(p => p.isVariadic);
     return prevVariadic !== null && prevVariadic !== void 0 ? prevVariadic : params[argIndex];
 }
-function generateAsymmetricStringAggExpression(field, resultSet, context, value, separator, distinctKey, orderBy, dialectName, state) {
+function generateAsymmetricStringAggExpression(resultSet, context, value, separator, distinctKey, orderBy, dialectName, state) {
     if (orderBy) {
         throw new Error(`Function \`string_agg\` does not support fanning out with an order by in ${dialectName}`);
     }
-    const valueSQL = generateDimFragment(field, resultSet, context, value, state);
+    const valueSQL = generateDimFragment(resultSet, context, value, state);
     const separatorSQL = separator
-        ? generateDimFragment(field, resultSet, context, separator, state)
+        ? generateDimFragment(resultSet, context, separator, state)
         : '';
-    return field.parent.dialect.sqlStringAggDistinct(distinctKey, valueSQL, separatorSQL);
+    return context.dialect.sqlStringAggDistinct(distinctKey, valueSQL, separatorSQL);
 }
-function generateAnalyticFragment(field, dialect, resultStruct, context, expr, overload, state, args, partitionByFields, funcOrdering) {
+function generateAnalyticFragment(dialect, resultStruct, context, expr, overload, state, args, partitionByFields, funcOrdering) {
     const isComplex = resultStruct.root().isComplexQuery;
-    const partitionFields = getAnalyticPartitions(field, resultStruct, partitionByFields);
+    const partitionFields = getAnalyticPartitions(resultStruct, partitionByFields);
     const allPartitions = [
         ...(isComplex ? ['group_set'] : []),
         ...partitionFields,
@@ -396,7 +395,7 @@ function generateAnalyticFragment(field, dialect, resultStruct, context, expr, o
             }
         }
         if (obSQL.length > 0) {
-            orderBy = ' ' + field.parent.dialect.sqlOrderBy(obSQL, 'analytical');
+            orderBy = ' ' + context.dialect.sqlOrderBy(obSQL, 'analytical');
         }
     }
     let between = '';
@@ -421,41 +420,41 @@ function generateAnalyticFragment(field, dialect, resultStruct, context, expr, o
         });
         between = `ROWS BETWEEN ${preceding} PRECEDING AND ${following} FOLLOWING`;
     }
-    const funcSQL = exprToSQL(field, resultStruct, context, expr, state);
+    const funcSQL = exprToSQL(resultStruct, context, expr, state);
     let retExpr = `${funcSQL} OVER(${partitionBy} ${orderBy} ${between})`;
     if (isComplex) {
         retExpr = `CASE WHEN group_set=${resultStruct.groupSet} THEN ${retExpr} END`;
     }
     return retExpr;
 }
-function generateFunctionCallExpression(field, resultSet, context, frag, state) {
+function generateFunctionCallExpression(resultSet, context, frag, state) {
     var _a, _b, _c;
     const overload = frag.overload;
     const args = frag.kids.args;
     const isSymmetric = (_a = frag.overload.isSymmetric) !== null && _a !== void 0 ? _a : false;
     const distinctKey = (0, malloy_types_1.expressionIsAggregate)(overload.returnType.expressionType) &&
         !isSymmetric &&
-        generateDistinctKeyIfNecessary(field, resultSet, context, frag.structPath);
+        generateDistinctKeyIfNecessary(resultSet, context, frag.structPath);
     const aggregateLimit = frag.limit ? `LIMIT ${frag.limit}` : undefined;
     if (frag.name === 'string_agg' &&
         distinctKey &&
         !context.dialect.supportsAggDistinct &&
         context.dialect.name !== 'snowflake') {
-        return generateAsymmetricStringAggExpression(field, resultSet, context, args[0], args[1], distinctKey, frag.kids.orderBy, context.dialect.name, state);
+        return generateAsymmetricStringAggExpression(resultSet, context, args[0], args[1], distinctKey, frag.kids.orderBy, context.dialect.name, state);
     }
     if (distinctKey) {
         if (!context.dialect.supportsAggDistinct) {
             throw new Error(`Function \`${frag.name}\` does not support fanning out in ${context.dialect.name}`);
         }
         const argsExpressions = args.map(arg => {
-            return generateDimFragment(field, resultSet, context, arg, state);
+            return generateDimFragment(resultSet, context, arg, state);
         });
         const orderBys = (_b = frag.kids.orderBy) !== null && _b !== void 0 ? _b : [];
         const orderByExpressions = orderBys.map(ob => {
             var _a;
             const defaultOrderByArgIndex = (_a = overload.dialect[context.dialect.name].defaultOrderByArgIndex) !== null && _a !== void 0 ? _a : 0;
             const expr = ob.node === 'functionOrderBy' ? ob.e : args[defaultOrderByArgIndex];
-            return generateDimFragment(field, resultSet, context, expr, state);
+            return generateDimFragment(resultSet, context, expr, state);
         });
         return context.dialect.sqlAggDistinct(distinctKey, [...argsExpressions, ...orderByExpressions], valNames => {
             const vals = valNames.map((v, i) => {
@@ -476,9 +475,9 @@ function generateFunctionCallExpression(field, resultSet, context, frag, state)
                 .map((e, i) => {
                 return { node: 'functionOrderBy', e, dir: orderBys[i].dir };
             });
-            const orderBySQL = getFunctionOrderBy(field, resultSet, context, state, orderBy, newArgs, overload);
+            const orderBySQL = getFunctionOrderBy(resultSet, context, state, orderBy, newArgs, overload);
             const funcCall = expandFunctionCall(context.dialect.name, overload, newArgs, orderBySQL, aggregateLimit);
-            return exprToSQL(field, resultSet, context, funcCall, state);
+            return exprToSQL(resultSet, context, funcCall, state);
         });
     }
     else {
@@ -500,28 +499,28 @@ function generateFunctionCallExpression(field, resultSet, context, frag, state)
                 return param.allowedTypes.every(t => (0, malloy_types_1.isLiteral)(t.evalSpace))
                     ? arg
                     : (0, utils_1.composeSQLExpr)([
-                        generateDimFragment(field, resultSet, context, arg, state),
+                        generateDimFragment(resultSet, context, arg, state),
                     ]);
             })
             : args;
         const orderBySql = frag.kids.orderBy
-            ? getFunctionOrderBy(field, resultSet, context, state, frag.kids.orderBy, args, overload)
+            ? getFunctionOrderBy(resultSet, context, state, frag.kids.orderBy, args, overload)
             : '';
         const funcCall = expandFunctionCall(context.dialect.name, overload, mappedArgs, orderBySql, aggregateLimit);
         if ((0, malloy_types_1.expressionIsAnalytic)(overload.returnType.expressionType)) {
             const extraPartitions = ((_c = frag.partitionBy) !== null && _c !== void 0 ? _c : []).map(outputName => {
                 return `(${resultSet.getField(outputName).getAnalyticalSQL(false)})`;
             });
-            return generateAnalyticFragment(field, context.dialect.name, resultSet, context, funcCall, overload, state, args, extraPartitions, orderBySql);
+            return generateAnalyticFragment(context.dialect.name, resultSet, context, funcCall, overload, state, args, extraPartitions, orderBySql);
         }
-        return exprToSQL(field, resultSet, context, funcCall, state);
+        return exprToSQL(resultSet, context, funcCall, state);
     }
 }
-function generateFieldFragment(field, resultSet, context, expr, state) {
+function generateFieldFragment(resultSet, context, expr, state) {
     // find the structDef and return the path to the field...
     const fieldRef = context.getFieldByName(expr.path);
     if ((0, malloy_types_1.hasExpression)(fieldRef.fieldDef)) {
-        const ret = exprToSQL(field, resultSet, fieldRef.parent, fieldRef.fieldDef.e, state);
+        const ret = exprToSQL(resultSet, fieldRef.parent, fieldRef.fieldDef.e, state);
         return `(${ret})`;
     }
     else {
@@ -541,34 +540,34 @@ function generateFieldFragment(field, resultSet, context, expr, state) {
             : undefined);
     }
 }
-function generateOutputFieldFragment(field, resultSet, _context, frag, _state) {
+function generateOutputFieldFragment(resultSet, _context, frag, _state) {
     return `(${resultSet.getField(frag.name).getAnalyticalSQL(false)})`;
 }
-function generateParameterFragment(field, resultSet, context, expr, state) {
+function generateParameterFragment(resultSet, context, expr, state) {
     var _a;
     const name = expr.path[0];
     (_a = context.eventStream) === null || _a === void 0 ? void 0 : _a.emit('source-argument-compiled', { name });
     const argument = context.arguments()[name];
     if (argument.value) {
-        return exprToSQL(field, resultSet, context, argument.value, state);
+        return exprToSQL(resultSet, context, argument.value, state);
     }
     throw new Error(`Can't generate SQL, no value for ${expr.path}`);
 }
-function generateFilterFragment(field, resultSet, context, expr, state) {
+function generateFilterFragment(resultSet, context, expr, state) {
     const allWhere = new utils_1.AndChain(state.whereSQL);
     for (const cond of expr.kids.filterList) {
-        allWhere.add(exprToSQL(field, resultSet, context, cond.e, state.withWhere()));
+        allWhere.add(exprToSQL(resultSet, context, cond.e, state.withWhere()));
     }
-    return exprToSQL(field, resultSet, context, expr.kids.e, state.withWhere(allWhere.sql()));
+    return exprToSQL(resultSet, context, expr.kids.e, state.withWhere(allWhere.sql()));
 }
-function generateDimFragment(field, resultSet, context, expr, state) {
-    let dim = exprToSQL(field, resultSet, context, expr, state);
+function generateDimFragment(resultSet, context, expr, state) {
+    let dim = exprToSQL(resultSet, context, expr, state);
     if (state.whereSQL) {
         dim = `CASE WHEN ${state.whereSQL} THEN ${dim} END`;
     }
     return dim;
 }
-function generateUngroupedFragment(field, resultSet, context, expr, state) {
+function generateUngroupedFragment(resultSet, context, expr, state) {
     if (state.totalGroupSet !== -1) {
         throw new Error('Already in ALL.  Cannot nest within an all calcuation.');
     }
@@ -585,7 +584,7 @@ function generateUngroupedFragment(field, resultSet, context, expr, state) {
     else {
         totalGroupSet = resultSet.parent ? resultSet.parent.groupSet : 0;
     }
-    const s = exprToSQL(field, resultSet, context, expr.e, state.withTotal(totalGroupSet));
+    const s = exprToSQL(resultSet, context, expr.e, state.withTotal(totalGroupSet));
     const fields = resultSet.getUngroupPartitions(ungroupSet);
     let partitionBy = '';
     const fieldsString = fields.map(f => f.getAnalyticalSQL(true)).join(', ');
@@ -598,10 +597,10 @@ function getDistinctKeySQL(struct, resultSet) {
     const distinctKeyField = struct.getDistinctKey();
     return generateDistinctKeySQL(distinctKeyField, resultSet);
 }
-function generateDistinctKeyIfNecessary(field, resultSet, context, structPath) {
+function generateDistinctKeyIfNecessary(resultSet, context, structPath) {
     let struct = context;
     if (structPath) {
-        struct = field.parent.getStructByName(structPath);
+        struct = context.getStructByName(structPath);
     }
     if (needsSymetricCalculation(struct, resultSet)) {
         return getDistinctKeySQL(struct, resultSet);
@@ -610,16 +609,16 @@ function generateDistinctKeyIfNecessary(field, resultSet, context, structPath) {
         return undefined;
     }
 }
-function generateSumFragment(field, resultSet, context, expr, state) {
-    const dimSQL = generateDimFragment(field, resultSet, context, expr.e, state);
-    const distinctKeySQL = generateDistinctKeyIfNecessary(field, resultSet, context, expr.structPath);
+function generateSumFragment(resultSet, context, expr, state) {
+    const dimSQL = generateDimFragment(resultSet, context, expr.e, state);
+    const distinctKeySQL = generateDistinctKeyIfNecessary(resultSet, context, expr.structPath);
     let ret;
     if (distinctKeySQL) {
-        if (field.parent.dialect.supportsSumDistinctFunction) {
-            ret = field.parent.dialect.sqlSumDistinct(distinctKeySQL, dimSQL, 'SUM');
+        if (context.dialect.supportsSumDistinctFunction) {
+            ret = context.dialect.sqlSumDistinct(distinctKeySQL, dimSQL, 'SUM');
         }
         else {
-            ret = sqlSumDistinct(field.parent.dialect, dimSQL, distinctKeySQL);
+            ret = sqlSumDistinct(context.dialect, dimSQL, distinctKeySQL);
         }
     }
     else {
@@ -627,14 +626,14 @@ function generateSumFragment(field, resultSet, context, expr, state) {
     }
     return `COALESCE(${ret},0)`;
 }
-function generateSymmetricFragment(field, resultSet, context, expr, state) {
-    const dimSQL = generateDimFragment(field, resultSet, context, expr.e, state);
+function generateSymmetricFragment(resultSet, context, expr, state) {
+    const dimSQL = generateDimFragment(resultSet, context, expr.e, state);
     const f = expr.function === 'distinct' ? 'count(distinct ' : expr.function + '(';
     return `${f}${dimSQL})`;
 }
-function generateAvgFragment(field, resultSet, context, expr, state) {
-    const dimSQL = generateDimFragment(field, resultSet, context, expr.e, state);
-    const distinctKeySQL = generateDistinctKeyIfNecessary(field, resultSet, context, expr.structPath);
+function generateAvgFragment(resultSet, context, expr, state) {
+    const dimSQL = generateDimFragment(resultSet, context, expr.e, state);
+    const distinctKeySQL = generateDistinctKeyIfNecessary(resultSet, context, expr.structPath);
     if (distinctKeySQL) {
         let countDistinctKeySQL = distinctKeySQL;
         if (state.whereSQL) {
@@ -642,11 +641,11 @@ function generateAvgFragment(field, resultSet, context, expr, state) {
         }
         let sumDistinctSQL;
         let avgDistinctSQL;
-        if (field.parent.dialect.supportsSumDistinctFunction) {
-            avgDistinctSQL = field.parent.dialect.sqlSumDistinct(distinctKeySQL, dimSQL, 'AVG');
+        if (context.dialect.supportsSumDistinctFunction) {
+            avgDistinctSQL = context.dialect.sqlSumDistinct(distinctKeySQL, dimSQL, 'AVG');
         }
         else {
-            sumDistinctSQL = sqlSumDistinct(field.parent.dialect, dimSQL, distinctKeySQL);
+            sumDistinctSQL = sqlSumDistinct(context.dialect, dimSQL, distinctKeySQL);
             avgDistinctSQL = `(${sumDistinctSQL})/NULLIF(COUNT(DISTINCT CASE WHEN ${dimSQL} IS NOT NULL THEN ${countDistinctKeySQL} END),0)`;
         }
         return avgDistinctSQL;
@@ -655,12 +654,12 @@ function generateAvgFragment(field, resultSet, context, expr, state) {
         return `AVG(${dimSQL})`;
     }
 }
-function generateCountFragment(field, resultSet, context, expr, state) {
+function generateCountFragment(resultSet, context, expr, state) {
     let func = 'COUNT(';
     let thing = '1';
     let struct = context;
     if (expr.structPath) {
-        struct = field.parent.getStructByName(expr.structPath);
+        struct = context.getStructByName(expr.structPath);
     }
     const joinName = struct.getJoinableParent().getIdentifier();
     const join = resultSet.root().joins.get(joinName);
@@ -678,10 +677,7 @@ function generateCountFragment(field, resultSet, context, expr, state) {
         return `${func}${thing})`;
     }
 }
-function generateSpread(field, _resultSet, _context, _frag, _state) {
-    throw new Error(`Unexpanded spread encountered during SQL generation for ${field.getIdentifier()}`);
-}
-function generateSourceReference(field, resultSet, context, expr) {
+function generateSourceReference(resultSet, context, expr) {
     if (expr.path === undefined) {
         return context.getSQLIdentifier();
     }
@@ -689,7 +685,7 @@ function generateSourceReference(field, resultSet, context, expr) {
         return context.getFieldByName(expr.path).getIdentifier();
     }
 }
-function generateCaseSQL(field, pf) {
+function generateCaseSQL(pf) {
     const caseStmt = ['CASE'];
     if (pf.kids.caseValue !== undefined) {
         caseStmt.push(`${pf.kids.caseValue.sql}`);
@@ -703,7 +699,7 @@ function generateCaseSQL(field, pf) {
     caseStmt.push('END');
     return caseStmt.join(' ');
 }
-function getFunctionOrderBy(field, resultSet, context, state, orderBy, args, overload) {
+function getFunctionOrderBy(resultSet, context, state, orderBy, args, overload) {
     if (orderBy.length === 0)
         return undefined;
     return ('ORDER BY ' +
@@ -712,13 +708,13 @@ function getFunctionOrderBy(field, resultSet, context, state, orderBy, args, ove
             var _a;
             const defaultOrderByArgIndex = (_a = overload.dialect[context.dialect.name].defaultOrderByArgIndex) !== null && _a !== void 0 ? _a : 0;
             const expr = ob.node === 'functionOrderBy' ? ob.e : args[defaultOrderByArgIndex];
-            const osql = generateDimFragment(field, resultSet, context, expr, state);
+            const osql = generateDimFragment(resultSet, context, expr, state);
             const dirsql = ob.dir === 'asc' ? ' ASC' : ob.dir === 'desc' ? ' DESC' : '';
             return `${osql}${dirsql}`;
         })
             .join(', '));
 }
-function getAnalyticPartitions(field, resultStruct, extraPartitionFields) {
+function getAnalyticPartitions(resultStruct, extraPartitionFields) {
     const ret = [];
     let p = resultStruct.parent;
     while (p !== undefined) {
@@ -732,7 +728,7 @@ function getAnalyticPartitions(field, resultStruct, extraPartitionFields) {
     }
     return ret;
 }
-function* stringsFromSQLExpression(field, resultSet, context, e, state) {
+function* stringsFromSQLExpression(resultSet, context, e, state) {
     /*
      * Like template strings, the array of strings is paired with template insertions,
      * each string is followed by at most one expression to be inserted
@@ -742,7 +738,7 @@ function* stringsFromSQLExpression(field, resultSet, context, e, state) {
         yield str;
         const expr = subExprList.shift();
         if (expr) {
-            yield exprToSQL(field, resultSet, context, expr, state);
+            yield exprToSQL(resultSet, context, expr, state);
         }
     }
 }
@@ -753,15 +749,13 @@ function generateDistinctKeySQL(fieldRef, resultSet) {
     if (parent.primaryKey()) {
         const pk = parent.getPrimaryKeyField(fieldRef.fieldDef);
         // Recursively generate the primary key SQL
-        return generateFieldFragment(fieldRef, // Use fieldRef as the field parameter
-        resultSet, parent, { node: 'field', path: [pk.getIdentifier()] }, new utils_1.GenerateState());
+        return generateFieldFragment(resultSet, parent, { node: 'field', path: [pk.getIdentifier()] }, new utils_1.GenerateState());
     }
     else if (parent.structDef.type === 'array') {
         const parentDistinctKey = (_a = parent.parent) === null || _a === void 0 ? void 0 : _a.getDistinctKey();
         let parentKeySQL = '';
         if (parentDistinctKey && parent.parent) {
-            parentKeySQL = generateFieldFragment(fieldRef, // Use fieldRef as the field parameter
-            resultSet, parent.parent, { node: 'field', path: ['__distinct_key'] }, new utils_1.GenerateState());
+            parentKeySQL = generateFieldFragment(resultSet, parent.parent, { node: 'field', path: ['__distinct_key'] }, new utils_1.GenerateState());
         }
         return parent.dialect.sqlMakeUnnestKey(parentKeySQL, parent.dialect.sqlFieldReference(parent.getIdentifier(), 'table', '__row_id', 'string'));
     }

package/dist/model/field_instance.d.ts

@@ -24,8 +24,8 @@ export declare class FieldInstanceField implements FieldInstance {
     partitionSQL: string | undefined;
     constructor(f: QueryField, fieldUsage: InstanceFieldUsage, parent: FieldInstanceResult, drillExpression: Malloy.Expression | undefined);
     root(): FieldInstanceResultRoot;
-    static exprCompiler?: (field: QueryField, resultSet: FieldInstanceResult, context: QueryStruct, expr: Expr, state?: GenerateState) => string;
-    static registerExpressionCompiler(compiler: (field: QueryField, resultSet: FieldInstanceResult, context: QueryStruct, expr: Expr, state?: GenerateState) => string): void;
+    static exprCompiler?: (resultSet: FieldInstanceResult, context: QueryStruct, expr: Expr, state?: GenerateState) => string;
+    static registerExpressionCompiler(compiler: (resultSet: FieldInstanceResult, context: QueryStruct, expr: Expr, state?: GenerateState) => string): void;
     getSQL(): string;
     generateExpression(): string;
     private generateDistinctKeyExpression;

package/dist/model/field_instance.js

@@ -45,7 +45,7 @@ class FieldInstanceField {
         }
         // Normal field expression generation
         if ((0, malloy_types_1.hasExpression)(this.f.fieldDef)) {
-            return FieldInstanceField.exprCompiler(this.f, this.parent, this.f.parent, this.f.fieldDef.e);
+            return FieldInstanceField.exprCompiler(this.parent, this.f.parent, this.f.fieldDef.e);
         }
         // Walk the tree and compute record aliases if needed
         for (let ancestor = this.f.parent; ancestor !== undefined; ancestor = ancestor.parent) {
@@ -55,7 +55,7 @@ class FieldInstanceField {
                 if (!ancestor.parent) {
                     throw new Error('Inconceivable record ancestor with expression but no parent');
                 }
-                const aliasValue = FieldInstanceField.exprCompiler(this.f, this.parent, ancestor.parent, ancestor.structDef.e);
+                const aliasValue = FieldInstanceField.exprCompiler(this.parent, ancestor.parent, ancestor.structDef.e);
                 ancestor.informOfAliasValue(aliasValue);
             }
         }
@@ -498,7 +498,7 @@ function sqlFullChildReference(struct, name, expand) {
         if (!FieldInstanceField.exprCompiler) {
             throw new Error('Expression compiler not registered with FieldInstanceField');
         }
-        parentRef = FieldInstanceField.exprCompiler(expand.field, expand.result, struct.parent, struct.structDef.e);
+        parentRef = FieldInstanceField.exprCompiler(expand.result, struct.parent, struct.structDef.e);
     }
     let refType = 'table';
     if (struct.structDef.type === 'record') {

package/dist/model/index.d.ts

@@ -5,3 +5,4 @@ import { QueryModelImpl } from './query_model_impl';
 export { QueryField, QueryStruct, QueryQuery, QueryModelImpl as QueryModel };
 export { getResultStructDefForQuery, getResultStructDefForView, } from './query_model_impl';
 export { indent, composeSQLExpr } from './utils';
+export { constantExprToSQL } from './constant_expression_compiler';

package/dist/model/index.js

@@ -36,7 +36,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.composeSQLExpr = exports.indent = exports.getResultStructDefForView = exports.getResultStructDefForQuery = exports.QueryModel = exports.QueryQuery = exports.QueryStruct = exports.QueryField = void 0;
+exports.constantExprToSQL = exports.composeSQLExpr = exports.indent = exports.getResultStructDefForView = exports.getResultStructDefForQuery = exports.QueryModel = exports.QueryQuery = exports.QueryStruct = exports.QueryField = void 0;
 __exportStar(require("./malloy_types"), exports);
 const query_node_1 = require("./query_node");
 Object.defineProperty(exports, "QueryField", { enumerable: true, get: function () { return query_node_1.QueryField; } });
@@ -65,4 +65,6 @@ Object.defineProperty(exports, "getResultStructDefForView", { enumerable: true,
 var utils_1 = require("./utils");
 Object.defineProperty(exports, "indent", { enumerable: true, get: function () { return utils_1.indent; } });
 Object.defineProperty(exports, "composeSQLExpr", { enumerable: true, get: function () { return utils_1.composeSQLExpr; } });
+var constant_expression_compiler_1 = require("./constant_expression_compiler");
+Object.defineProperty(exports, "constantExprToSQL", { enumerable: true, get: function () { return constant_expression_compiler_1.constantExprToSQL; } });
 //# sourceMappingURL=index.js.map

package/dist/model/query_query.js

@@ -225,7 +225,7 @@ class QueryQuery extends query_node_1.QueryField {
                 if (qs.structDef.type === 'record' &&
                     (0, malloy_types_1.hasExpression)(qs.structDef) &&
                     qs.parent) {
-                    qs.informOfAliasValue((0, expression_compiler_1.exprToSQL)(this, this.rootResult, qs.parent, qs.structDef.e));
+                    qs.informOfAliasValue((0, expression_compiler_1.exprToSQL)(this.rootResult, qs.parent, qs.structDef.e));
                 }
                 context = qs;
             }
@@ -299,7 +299,7 @@ class QueryQuery extends query_node_1.QueryField {
             const context = this.parent;
             if ((which === 'having' && (0, malloy_types_1.expressionIsCalculation)(cond.expressionType)) ||
                 (which === 'where' && (0, malloy_types_1.expressionIsScalar)(cond.expressionType))) {
-                const sqlClause = (0, expression_compiler_1.exprToSQL)(this, resultStruct, context, cond.e, undefined);
+                const sqlClause = (0, expression_compiler_1.exprToSQL)(resultStruct, context, cond.e, undefined);
                 resultFilters.add(sqlClause);
             }
         }
@@ -671,7 +671,7 @@ class QueryQuery extends query_node_1.QueryField {
                 // If this array is NOT contained in the parent, but a computed entity
                 // then the thing we are joining is not "parent.childName", but
                 // the expression which is built in that namespace
-                arrayExpression = (0, expression_compiler_1.exprToSQL)(this, this.rootResult, qs.parent, qsDef.e);
+                arrayExpression = (0, expression_compiler_1.exprToSQL)(this.rootResult, qs.parent, qsDef.e);
             }
             else {
                 // If this is a reference through an expression at the top level,

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const MALLOY_VERSION = "0.0.305";
+export declare const MALLOY_VERSION = "0.0.307";

package/dist/version.js

@@ -2,5 +2,5 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MALLOY_VERSION = void 0;
 // generated with 'generate-version-file' script; do not edit manually
-exports.MALLOY_VERSION = '0.0.305';
+exports.MALLOY_VERSION = '0.0.307';
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/malloy",
-  "version": "0.0.305",
+  "version": "0.0.307",
   "license": "MIT",
   "exports": {
     ".": "./dist/index.js",
@@ -41,9 +41,9 @@
     "generate-version-file": "VERSION=$(npm pkg get version --workspaces=false | tr -d \\\")\necho \"// generated with 'generate-version-file' script; do not edit manually\\nexport const MALLOY_VERSION = '$VERSION';\" > src/version.ts"
   },
   "dependencies": {
-    "@malloydata/malloy-filter": "0.0.305",
-    "@malloydata/malloy-interfaces": "0.0.305",
-    "@malloydata/malloy-tag": "0.0.305",
+    "@malloydata/malloy-filter": "0.0.307",
+    "@malloydata/malloy-interfaces": "0.0.307",
+    "@malloydata/malloy-tag": "0.0.307",
     "antlr4ts": "^0.5.0-alpha.4",
     "assert": "^2.0.0",
     "jaro-winkler": "^0.2.8",