@malloydata/malloy 0.0.306 → 0.0.308

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/field_instance.js

@@ -47,18 +47,6 @@ class FieldInstanceField {
         if ((0, malloy_types_1.hasExpression)(this.f.fieldDef)) {
             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) {
-            if (ancestor.structDef.type === 'record' &&
-                (0, malloy_types_1.hasExpression)(ancestor.structDef) &&
-                ancestor.recordAlias === undefined) {
-                if (!ancestor.parent) {
-                    throw new Error('Inconceivable record ancestor with expression but no parent');
-                }
-                const aliasValue = FieldInstanceField.exprCompiler(this.parent, ancestor.parent, ancestor.structDef.e);
-                ancestor.informOfAliasValue(aliasValue);
-            }
-        }
         return sqlFullChildReference(this.f.parent, this.f.fieldDef.name, this.f.parent.structDef.type === 'record'
             ? {
                 result: this.parent,

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_node.d.ts

@@ -77,14 +77,22 @@ export declare class QueryStruct {
     pathAliasMap: Map<string, string>;
     dialect: Dialect;
     connectionName: string;
-    recordAlias?: string;
+    /**
+     * For fields which are a record, but the value is an expression
+     * we capture the context needed to generate the expression in
+     * QueryQuery.expandFields. Later in the compilation if a
+     * reference passes through this struct, this will call
+     * the expression compiler with the correct context
+     * to compute the record value.
+     */
+    computeRecordExpression?: () => string;
+    recordValue?: string;
     constructor(structDef: StructDef, sourceArguments: Record<string, Argument> | undefined, parent: ParentQueryStruct | ParentQueryModel, prepareResultOptions: PrepareResultOptions);
     private static turtleFieldMaker;
     static registerTurtleFieldMaker(maker: (field: TurtleDef, parent: QueryStruct) => QueryField): void;
     private _modelTag;
     modelCompilerFlags(): Tag;
     protected findFirstDialect(): string;
-    informOfAliasValue(av: string): void;
     maybeEmitParameterizedSourceUsage(): void;
     private resolveParentParameterReferences;
     private _arguments;

package/dist/model/query_node.js

@@ -219,9 +219,6 @@ class QueryStruct {
         }
         throw new Error('Cannot create QueryStruct from record with model parent');
     }
-    informOfAliasValue(av) {
-        this.recordAlias = av;
-    }
     maybeEmitParameterizedSourceUsage() {
         var _a;
         if ((0, malloy_types_1.isSourceDef)(this.structDef)) {
@@ -373,8 +370,11 @@ class QueryStruct {
         // will have joins and thus be in the namespace. We can't compute it here
         // because we don't have access to the Query to call exprToSQL.
         if (this.structDef.type === 'record' && (0, malloy_types_1.hasExpression)(this.structDef)) {
-            if (this.recordAlias) {
-                return this.recordAlias;
+            if (this.computeRecordExpression) {
+                if (!this.recordValue) {
+                    this.recordValue = this.computeRecordExpression();
+                }
+                return this.recordValue;
             }
             throw new Error('INTERNAL ERROR, record field alias not pre-computed');
         }

package/dist/model/query_query.d.ts

@@ -43,10 +43,18 @@ export declare class QueryQuery extends QueryField {
     };
     private addDependantPath;
     private dependenciesFromFieldUsage;
-    findRecordAliases(context: QueryStruct, path: string[]): void;
     getSegmentFields(resultStruct: FieldInstanceResult): SegmentFieldDef[];
     private getDrillExpression;
     expandFields(resultStruct: FieldInstanceResult): void;
+    /**
+     * Recursively walks the input QueryStruct tree and sets up lazy expression
+     * compilation for all records with computed expressions, so that records with
+     * expression values have the correct context for evaluating them if needed.
+     *
+     * @param resultStruct - The FieldInstanceResult containing compilation context
+     * @param source - The QueryStruct to traverse (initially the query's parent/input)
+     */
+    expandSource(resultStruct: FieldInstanceResult, source: QueryStruct): void;
     generateSQLFilters(resultStruct: FieldInstanceResult, which: 'where' | 'having'): AndChain;
     prepare(_stageWriter: StageWriter | undefined): void;
     private findJoins;

package/dist/model/query_query.js

@@ -157,14 +157,10 @@ class QueryQuery extends query_node_1.QueryField {
                     resultStruct.addStructToJoin(this.parent, usage.uniqueKeyRequirement);
                 }
                 else {
-                    this.findRecordAliases(this.parent, usage.path);
                     this.addDependantPath(resultStruct, this.parent, usage.path, usage.uniqueKeyRequirement);
                 }
                 continue;
             }
-            if (usage.path.length > 1) {
-                this.findRecordAliases(this.parent, usage.path);
-            }
         }
         const expandedUngroupings = 'expandedUngroupings' in this.firstSegment
             ? this.firstSegment.expandedUngroupings || []
@@ -207,30 +203,6 @@ class QueryQuery extends query_node_1.QueryField {
             }
         }
     }
-    /*
-     ** Later on, when a record is referenced, the context needed to translate the
-     ** reference won't exist, so we translate them all in prepare. The better fix
-     ** involves understanding more about what a "translation state" is and how
-     ** to create it at the moment when a field is referenced, but I couldn't do
-     ** that at the time I did this work. TODO come back and do that.
-     */
-    findRecordAliases(context, path) {
-        for (const seg of path) {
-            const field = context.getChildByName(seg);
-            if (!field) {
-                throw new Error('findRecordAliases: field not found: ' + path.join('.'));
-            }
-            if (field instanceof query_node_1.QueryFieldStruct) {
-                const qs = field.queryStruct;
-                if (qs.structDef.type === 'record' &&
-                    (0, malloy_types_1.hasExpression)(qs.structDef) &&
-                    qs.parent) {
-                    qs.informOfAliasValue((0, expression_compiler_1.exprToSQL)(this.rootResult, qs.parent, qs.structDef.e));
-                }
-                context = qs;
-            }
-        }
-    }
     getSegmentFields(resultStruct) {
         const fs = resultStruct.firstSegment;
         return fs.type === 'index'
@@ -284,6 +256,31 @@ class QueryQuery extends query_node_1.QueryField {
             resultIndex++;
         }
     }
+    /**
+     * Recursively walks the input QueryStruct tree and sets up lazy expression
+     * compilation for all records with computed expressions, so that records with
+     * expression values have the correct context for evaluating them if needed.
+     *
+     * @param resultStruct - The FieldInstanceResult containing compilation context
+     * @param source - The QueryStruct to traverse (initially the query's parent/input)
+     */
+    expandSource(resultStruct, source) {
+        for (const field of source.nameMap.values()) {
+            if (field instanceof query_node_1.QueryFieldStruct) {
+                const qs = field.queryStruct;
+                // Set up closure if this is a record with expression
+                if (qs.structDef.type === 'record' &&
+                    (0, malloy_types_1.hasExpression)(qs.structDef) &&
+                    qs.parent) {
+                    const parent = qs.parent;
+                    const e = qs.structDef.e;
+                    qs.computeRecordExpression = () => (0, expression_compiler_1.exprToSQL)(resultStruct, parent, e);
+                }
+                // Recurse into this structure
+                this.expandSource(resultStruct, qs);
+            }
+        }
+    }
     generateSQLFilters(resultStruct, which
     // filterList: FilterCondition[] | undefined = undefined
     ) {
@@ -307,6 +304,7 @@ class QueryQuery extends query_node_1.QueryField {
     }
     prepare(_stageWriter) {
         if (!this.prepared) {
+            this.expandSource(this.rootResult, this.parent);
             // Add the root base join to the joins map
             this.rootResult.addStructToJoin(this.parent, undefined);
             // Expand fields (just adds them to result, no dependency tracking)

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const MALLOY_VERSION = "0.0.306";
+export declare const MALLOY_VERSION = "0.0.308";

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.306';
+exports.MALLOY_VERSION = '0.0.308';
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/malloy",
-  "version": "0.0.306",
+  "version": "0.0.308",
   "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.306",
-    "@malloydata/malloy-interfaces": "0.0.306",
-    "@malloydata/malloy-tag": "0.0.306",
+    "@malloydata/malloy-filter": "0.0.308",
+    "@malloydata/malloy-interfaces": "0.0.308",
+    "@malloydata/malloy-tag": "0.0.308",
     "antlr4ts": "^0.5.0-alpha.4",
     "assert": "^2.0.0",
     "jaro-winkler": "^0.2.8",