@malloydata/malloy 0.0.177-dev240828173040 → 0.0.177-dev240829030921

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

@@ -24,7 +24,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExprTime = void 0;
 const malloy_types_1 = require("../../../model/malloy_types");
-const utils_1 = require("./utils");
 const expression_def_1 = require("../types/expression-def");
 class ExprTime extends expression_def_1.ExpressionDef {
     constructor(timeType, value, expressionType = 'scalar') {
@@ -34,7 +33,7 @@ class ExprTime extends expression_def_1.ExpressionDef {
         this.translationValue = {
             dataType: timeType,
             expressionType,
-            value: typeof value === 'string' ? [value] : value,
+            value,
             evalSpace: 'constant',
         };
     }
@@ -45,16 +44,15 @@ class ExprTime extends expression_def_1.ExpressionDef {
         let value = expr.value;
         if (timeType !== expr.dataType) {
             const toTs = {
-                type: 'dialect',
-                function: 'cast',
+                node: 'cast',
                 safe: false,
                 dstType: timeType,
-                expr: expr.value,
+                e: expr.value,
             };
             if ((0, malloy_types_1.isTimeFieldType)(expr.dataType)) {
                 toTs.srcType = expr.dataType;
             }
-            value = (0, utils_1.compressExpr)([toTs]);
+            value = toTs;
         }
         return new ExprTime(timeType, value, expr.expressionType);
     }

package/dist/lang/ast/expressions/expr-ungroup.js

@@ -51,7 +51,7 @@ class ExprUngroup extends expression_def_1.ExpressionDef {
             return (0, ast_utils_1.errorFor)('doubly-ungrouped aggregate');
         }
         const ungroup = {
-            type: this.control,
+            node: this.control,
             e: exprVal.value,
         };
         if (this.typeCheck(this.expr, { ...exprVal, expressionType: 'scalar' })) {
@@ -87,7 +87,7 @@ class ExprUngroup extends expression_def_1.ExpressionDef {
             return {
                 dataType: this.returns(exprVal),
                 expressionType: 'ungrouped_aggregate',
-                value: [ungroup],
+                value: ungroup,
                 evalSpace: 'output',
             };
         }

package/dist/lang/ast/expressions/for-range.d.ts

@@ -1,3 +1,4 @@
+import { BinaryMalloyOperator } from '../types/binary_operators';
 import { ExprValue } from '../types/expr-value';
 import { ExpressionDef } from '../types/expression-def';
 import { FieldSpace } from '../types/field-space';
@@ -9,7 +10,7 @@ export declare class ForRange extends ExpressionDef {
     elementType: string;
     legalChildTypes: import("../../../model").TypeDesc[];
     constructor(from: ExpressionDef, duration: ExpressionDef, timeframe: Timeframe);
-    apply(fs: FieldSpace, op: string, expr: ExpressionDef): ExprValue;
+    apply(fs: FieldSpace, op: BinaryMalloyOperator, expr: ExpressionDef): ExprValue;
     requestExpression(_fs: FieldSpace): undefined;
     getExpression(_fs: FieldSpace): ExprValue;
 }

package/dist/lang/ast/expressions/function-ordering.js

@@ -38,7 +38,7 @@ class FunctionOrderBy extends malloy_element_1.MalloyElement {
     getAnalyticOrderBy(fs) {
         if (!this.field) {
             this.log('analytic `order_by` must specify an aggregate expression or output field reference');
-            return { e: ['error'], dir: this.dir };
+            return { node: 'functionOrderBy', e: { node: 'error' }, dir: this.dir };
         }
         const expr = this.field.getExpression(fs);
         if ((0, malloy_types_1.expressionIsAggregate)(expr.expressionType)) {
@@ -53,7 +53,7 @@ class FunctionOrderBy extends malloy_element_1.MalloyElement {
         else {
             this.field.log('analytic `order_by` must be scalar or aggregate');
         }
-        return { e: expr.value, dir: this.dir };
+        return { node: 'functionOrderBy', e: expr.value, dir: this.dir };
     }
     getAggregateOrderBy(fs, allowExpression) {
         if (this.field) {
@@ -64,15 +64,15 @@ class FunctionOrderBy extends malloy_element_1.MalloyElement {
             if (!allowExpression) {
                 this.field.log('`order_by` must be only `asc` or `desc` with no expression');
             }
-            return { e: expr.value, dir: this.dir };
+            return { node: 'functionOrderBy', e: expr.value, dir: this.dir };
         }
         else {
             if (this.dir === undefined) {
                 // This error should technically never happen because it can't parse this way
                 this.log('field or order direction must be specified');
-                return { e: undefined, dir: 'asc' };
+                return { node: 'functionDefaultOrderBy', dir: 'asc' };
             }
-            return { e: undefined, dir: this.dir };
+            return { node: 'functionDefaultOrderBy', dir: this.dir };
         }
     }
 }

package/dist/lang/ast/expressions/partial-compare.d.ts

@@ -1,12 +1,12 @@
-import { Comparison } from '../types/comparison';
+import { CompareMalloyOperator } from '../types/binary_operators';
 import { ExprValue } from '../types/expr-value';
 import { ExpressionDef } from '../types/expression-def';
 import { FieldSpace } from '../types/field-space';
 export declare class PartialCompare extends ExpressionDef {
-    readonly op: Comparison;
+    readonly op: CompareMalloyOperator;
     readonly right: ExpressionDef;
     elementType: string;
-    constructor(op: Comparison, right: ExpressionDef);
+    constructor(op: CompareMalloyOperator, right: ExpressionDef);
     granular(): boolean;
     apply(fs: FieldSpace, op: string, expr: ExpressionDef): ExprValue;
     requestExpression(_fs: FieldSpace): ExprValue | undefined;

package/dist/lang/ast/expressions/pick-when.js

@@ -28,7 +28,6 @@ const ast_utils_1 = require("../ast-utils");
 const fragtype_utils_1 = require("../fragtype-utils");
 const expression_def_1 = require("../types/expression-def");
 const malloy_element_1 = require("../types/malloy-element");
-const utils_1 = require("./utils");
 function typeCoalesce(ev1, ev2) {
     return ev1 === undefined ||
         ev1.dataType === 'null' ||
@@ -63,7 +62,14 @@ class Pick extends expression_def_1.ExpressionDef {
         return this.getExpression(fs);
     }
     apply(fs, op, expr) {
-        const caseValue = ['CASE'];
+        const caseValue = {
+            node: 'pick',
+            kids: {
+                pickWhen: [],
+                pickThen: [],
+                pickElse: { node: 'error', message: 'pick statement not complete' },
+            },
+        };
         let returnType;
         let anyExpressionType = 'scalar';
         let anyEvalSpace = 'constant';
@@ -80,7 +86,8 @@ class Pick extends expression_def_1.ExpressionDef {
                 return (0, ast_utils_1.errorFor)('pick when type');
             }
             returnType = typeCoalesce(returnType, thenExpr);
-            caseValue.push(' WHEN ', ...whenExpr.value, ' THEN ', ...thenExpr.value);
+            caseValue.kids.pickWhen.push(whenExpr.value);
+            caseValue.kids.pickThen.push(thenExpr.value);
         }
         const elsePart = this.elsePick || expr;
         const elseVal = elsePart.getExpression(fs);
@@ -90,14 +97,23 @@ class Pick extends expression_def_1.ExpressionDef {
             this.log(`${errSrc} type '${fragtype_utils_1.FT.inspect(elseVal)}', expected '${returnType.dataType}'[pick-values-must-match]`);
             return (0, ast_utils_1.errorFor)('pick else type');
         }
+        caseValue.kids.pickElse = elseVal.value;
         return {
             dataType: returnType.dataType,
             expressionType: (0, malloy_types_1.maxExpressionType)(anyExpressionType, elseVal.expressionType),
             evalSpace: (0, malloy_types_1.mergeEvalSpaces)(anyEvalSpace, elseVal.evalSpace),
-            value: (0, utils_1.compressExpr)([...caseValue, ' ELSE ', ...elseVal.value, ' END']),
+            value: caseValue,
         };
     }
     getExpression(fs) {
+        const pick = {
+            node: 'pick',
+            kids: {
+                pickWhen: [],
+                pickThen: [],
+                pickElse: { node: 'error', message: 'pick statement not complete' },
+            },
+        };
         if (this.elsePick === undefined) {
             this.log("pick incomplete, missing 'else'");
             return (0, ast_utils_1.errorFor)('no value for partial pick');
@@ -119,7 +135,6 @@ class Pick extends expression_def_1.ExpressionDef {
             });
         }
         let returnType;
-        const caseValue = ['CASE'];
         let anyExpressionType = 'scalar';
         let anyEvalSpace = 'constant';
         for (const aChoice of choiceValues) {
@@ -135,7 +150,8 @@ class Pick extends expression_def_1.ExpressionDef {
             returnType = typeCoalesce(returnType, aChoice.pick);
             anyExpressionType = (0, malloy_types_1.maxExpressionType)(anyExpressionType, (0, malloy_types_1.maxExpressionType)(aChoice.pick.expressionType, aChoice.when.expressionType));
             anyEvalSpace = (0, malloy_types_1.mergeEvalSpaces)(anyEvalSpace, aChoice.pick.evalSpace, aChoice.when.evalSpace);
-            caseValue.push(' WHEN ', ...aChoice.when.value, ' THEN ', ...aChoice.pick.value);
+            pick.kids.pickWhen.push(aChoice.when.value);
+            pick.kids.pickThen.push(aChoice.pick.value);
         }
         const defVal = this.elsePick.getExpression(fs);
         anyExpressionType = (0, malloy_types_1.maxExpressionType)(anyExpressionType, defVal.expressionType);
@@ -145,11 +161,11 @@ class Pick extends expression_def_1.ExpressionDef {
             this.elsePick.log(`else type '${fragtype_utils_1.FT.inspect(defVal)}', expected '${returnType.dataType}'[pick-values-must-match]`);
             return (0, ast_utils_1.errorFor)('pick value type mismatch');
         }
-        caseValue.push(' ELSE ', ...defVal.value, ' END');
+        pick.kids.pickElse = defVal.value;
         return {
             dataType: returnType.dataType,
             expressionType: anyExpressionType,
-            value: (0, utils_1.compressExpr)(caseValue),
+            value: pick,
             evalSpace: anyEvalSpace,
         };
     }

package/dist/lang/ast/expressions/range.d.ts

@@ -1,3 +1,4 @@
+import { BinaryMalloyOperator } from '../types/binary_operators';
 import { ExprValue } from '../types/expr-value';
 import { ExpressionDef } from '../types/expression-def';
 import { FieldSpace } from '../types/field-space';
@@ -6,7 +7,7 @@ export declare class Range extends ExpressionDef {
     readonly last: ExpressionDef;
     elementType: string;
     constructor(first: ExpressionDef, last: ExpressionDef);
-    apply(fs: FieldSpace, op: string, expr: ExpressionDef): ExprValue;
+    apply(fs: FieldSpace, op: BinaryMalloyOperator, expr: ExpressionDef): ExprValue;
     requestExpression(_fs: FieldSpace): undefined;
     getExpression(_fs: FieldSpace): ExprValue;
 }

package/dist/lang/ast/expressions/range.js

@@ -26,7 +26,6 @@ exports.Range = void 0;
 const malloy_types_1 = require("../../../model/malloy_types");
 const ast_utils_1 = require("../ast-utils");
 const expression_def_1 = require("../types/expression-def");
-const utils_1 = require("./utils");
 class Range extends expression_def_1.ExpressionDef {
     constructor(first, last) {
         super({ first: first, last: last });
@@ -47,7 +46,10 @@ class Range extends expression_def_1.ExpressionDef {
                     dataType: 'boolean',
                     expressionType: (0, malloy_types_1.maxExpressionType)(fromValue.expressionType, toValue.expressionType),
                     evalSpace: (0, malloy_types_1.mergeEvalSpaces)(fromValue.evalSpace, toValue.evalSpace),
-                    value: (0, utils_1.compose)(fromValue.value, op2, toValue.value),
+                    value: {
+                        node: op2,
+                        kids: { left: fromValue.value, right: toValue.value },
+                    },
                 };
             }
             /**

package/dist/lang/ast/expressions/time-literal.d.ts

@@ -1,8 +1,9 @@
-import { TimeFieldType, TimestampUnit, TimeLiteralFragment } from '../../../model/malloy_types';
+import { TimeFieldType, TimestampUnit, TimeLiteralNode } from '../../../model/malloy_types';
 import { ExprValue } from '../types/expr-value';
 import { FieldSpace } from '../types/field-space';
 import { ExpressionDef } from '../types/expression-def';
 import { TimeResult } from '../types/time-result';
+import { BinaryMalloyOperator } from '../types/binary_operators';
 export declare class TimeFormatError extends Error {
 }
 interface TimeText {
@@ -19,7 +20,7 @@ declare abstract class TimeLiteral extends ExpressionDef {
     nextLit?: string;
     timeZone?: string;
     constructor(tm: TimeText, units: TimestampUnit | undefined, timeType: TimeFieldType);
-    protected makeLiteral(val: string, typ: TimeFieldType): TimeLiteralFragment;
+    protected makeLiteral(val: string, typ: TimeFieldType): TimeLiteralNode;
     protected makeValue(val: string, dataType: TimeFieldType): TimeResult;
     getExpression(_fs: FieldSpace): ExprValue;
     getNext(): ExprValue | undefined;
@@ -38,7 +39,7 @@ declare class GranularLiteral extends TimeLiteral {
     readonly nextLit: string;
     elementType: string;
     constructor(tm: TimeText, units: TimestampUnit | undefined, timeType: TimeFieldType, nextLit: string);
-    apply(fs: FieldSpace, op: string, left: ExpressionDef): ExprValue;
+    apply(fs: FieldSpace, op: BinaryMalloyOperator, left: ExpressionDef): ExprValue;
 }
 export declare class LiteralHour extends GranularLiteral {
     elementType: string;

package/dist/lang/ast/expressions/time-literal.js

@@ -70,10 +70,9 @@ class TimeLiteral extends expression_def_1.ExpressionDef {
     }
     makeLiteral(val, typ) {
         const timeFrag = {
-            type: 'dialect',
-            function: 'timeLiteral',
+            node: 'timeLiteral',
             literal: val,
-            literalType: typ,
+            dataType: typ,
         };
         if (this.timeZone) {
             timeFrag.timezone = this.timeZone;
@@ -83,7 +82,7 @@ class TimeLiteral extends expression_def_1.ExpressionDef {
     makeValue(val, dataType) {
         const timeFrag = this.makeLiteral(val, dataType);
         const expressionType = 'scalar';
-        const value = [timeFrag];
+        const value = timeFrag;
         if (this.units) {
             return {
                 dataType,
@@ -214,16 +213,12 @@ class DateBasedLiteral extends GranularLiteral {
     }
     getExpression(_fs) {
         const dateValue = this.makeValue(this.literalPart, 'date');
-        const timestamp = [
-            this.makeLiteral(`${this.literalPart} 00:00:00`, 'timestamp'),
-        ];
+        const timestamp = this.makeLiteral(`${this.literalPart} 00:00:00`, 'timestamp');
         return { ...dateValue, morphic: { timestamp }, evalSpace: 'literal' };
     }
     getNext() {
         const dateValue = this.makeValue(this.nextLit, 'date');
-        const timestamp = [
-            this.makeLiteral(`${this.nextLit} 00:00:00`, 'timestamp'),
-        ];
+        const timestamp = this.makeLiteral(`${this.nextLit} 00:00:00`, 'timestamp');
         return { ...dateValue, morphic: { timestamp } };
     }
 }

package/dist/lang/ast/expressions/top-by.js

@@ -26,7 +26,6 @@ exports.TopBy = void 0;
 const malloy_types_1 = require("../../../model/malloy_types");
 const expression_def_1 = require("../types/expression-def");
 const malloy_element_1 = require("../types/malloy-element");
-const utils_1 = require("./utils");
 class TopBy extends malloy_element_1.MalloyElement {
     constructor(by) {
         super();
@@ -42,7 +41,7 @@ class TopBy extends malloy_element_1.MalloyElement {
             if (!(0, malloy_types_1.expressionIsAggregate)(byExpr.expressionType)) {
                 this.log('top by expression must be an aggregate');
             }
-            return { by: 'expression', e: (0, utils_1.compressExpr)(byExpr.value) };
+            return { by: 'expression', e: byExpr.value };
         }
         return { by: 'name', name: this.by };
     }

package/dist/lang/ast/expressions/utils.d.ts

@@ -1,12 +1,3 @@
-import { Expr, Fragment } from '../../../model/malloy_types';
-import { Equality } from '../types/equality';
-/**
- * Compose a binary expression. Tries to write them safely and concisely
- * @param left
- * @param op
- * @param right
- * @return Fragment list of the composed expression
- */
-export declare function compose(left: Fragment[], op: string, right: Fragment[]): Fragment[];
-export declare function compressExpr(expr: Expr): Expr;
-export declare function nullsafeNot(expr: Expr, op?: Equality): Expr;
+import { Expr } from '../../../model/malloy_types';
+import { EqualityMalloyOperator } from '../types/binary_operators';
+export declare function nullsafeNot(expr: Expr, op?: EqualityMalloyOperator): Expr;

package/dist/lang/ast/expressions/utils.js

@@ -22,64 +22,16 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.nullsafeNot = exports.compressExpr = exports.compose = void 0;
-const malloy_types_1 = require("../../../model/malloy_types");
-/**
- * If the passed expresion is not a single term, wrap it in parens
- * @param f expression fragment
- */
-function term(f) {
-    if (f.length > 1) {
-        return ['(', ...f, ')'];
-    }
-    if (f.length === 0) {
-        // Trying to compose a binary expresion with an entity that has no value
-        // this should at least cause the generated SQL to error, but likely
-        // there has already been a semantic error reported.
-        return ['__MISSING_VALUE__'];
-    }
-    return f;
-}
-/**
- * Compose a binary expression. Tries to write them safely and concisely
- * @param left
- * @param op
- * @param right
- * @return Fragment list of the composed expression
- */
-function compose(left, op, right) {
-    const opAlpha = op.match(/^[A-Za-z]/);
-    const leftSpace = left.length === 1 && opAlpha ? ' ' : '';
-    const rightSpace = right.length === 1 && opAlpha ? ' ' : '';
-    const newOp = leftSpace + op + rightSpace;
-    return [...term(left), newOp, ...term(right)];
-}
-exports.compose = compose;
-function compressExpr(expr) {
-    // compress all adjacent strings
-    const compressValue = [];
-    let buildString;
-    for (const fragment of expr.flat()) {
-        if (typeof fragment === 'string') {
-            buildString = buildString ? buildString + fragment : fragment;
-        }
-        else {
-            if (buildString) {
-                compressValue.push(buildString);
-                buildString = undefined;
-            }
-            compressValue.push(fragment);
-        }
-    }
-    if (buildString) {
-        compressValue.push(buildString);
-    }
-    return compressValue;
-}
-exports.compressExpr = compressExpr;
+exports.nullsafeNot = void 0;
 function nullsafeNot(expr, op) {
     if (op === undefined || op === '!=' || op === '!~') {
-        return (0, malloy_types_1.mkExpr) `NOT(COALESCE(${expr}, FALSE))`;
+        return {
+            node: 'not',
+            e: {
+                node: 'coalesce',
+                kids: { left: expr, right: { node: 'false' } },
+            },
+        };
     }
     return expr;
 }

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

@@ -53,7 +53,7 @@ class ReferenceField extends space_field_1.SpaceField {
                 ? {
                     type: check.found.typeDesc().dataType,
                     name: path[0],
-                    e: [{ type: 'parameter', path }],
+                    e: { node: 'parameter', path },
                 }
                 : { type: 'fieldref', path };
             this.queryFieldDef = queryFieldDef;

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

@@ -96,7 +96,7 @@ export * from './source-elements/sql-source';
 export * from './source-elements/table-source';
 export * from './sql-elements/sql-string';
 export * from './types/annotation-elements';
-export * from './types/comparison';
+export * from './types/binary_operators';
 export * from './types/source-desc';
 export * from './types/source-property';
 export * from './types/expression-def';

package/dist/lang/ast/index.js

@@ -134,7 +134,7 @@ __exportStar(require("./source-elements/sql-source"), exports);
 __exportStar(require("./source-elements/table-source"), exports);
 __exportStar(require("./sql-elements/sql-string"), exports);
 __exportStar(require("./types/annotation-elements"), exports);
-__exportStar(require("./types/comparison"), exports);
+__exportStar(require("./types/binary_operators"), exports);
 __exportStar(require("./types/source-desc"), exports);
 __exportStar(require("./types/source-property"), exports);
 __exportStar(require("./types/expression-def"), exports);

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

@@ -1,4 +1,4 @@
-import { FilterExpression, PipeSegment, Sampling } from '../../../model/malloy_types';
+import { FilterCondition, PipeSegment, Sampling } from '../../../model/malloy_types';
 import { FieldName, FieldSpace } from '../types/field-space';
 import { Limit } from '../query-properties/limit';
 import { IndexFieldSpace } from '../field-space/index-field-space';
@@ -8,7 +8,7 @@ import { QueryInputSpace } from '../field-space/query-input-space';
 import { QueryOperationSpace } from '../field-space/query-spaces';
 import { MalloyElement } from '../types/malloy-element';
 export declare class IndexBuilder implements QueryBuilder {
-    filters: FilterExpression[];
+    filters: FilterCondition[];
     limit?: Limit;
     indexOn?: FieldName;
     sample?: Sampling;

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

@@ -1,4 +1,4 @@
-import { FilterExpression, PipeSegment, QuerySegment } from '../../../model/malloy_types';
+import { FilterCondition, PipeSegment, QuerySegment } from '../../../model/malloy_types';
 import { FieldSpace } from '../types/field-space';
 import { Ordering } from '../query-properties/ordering';
 import { Top } from '../query-properties/top';
@@ -13,7 +13,7 @@ export declare abstract class QuerySegmentBuilder implements QueryBuilder {
     abstract inputFS: QueryInputSpace;
     abstract resultFS: QueryOperationSpace;
     abstract readonly type: 'grouping' | 'project';
-    filters: FilterExpression[];
+    filters: FilterCondition[];
     execute(qp: QueryProperty): void;
     abstract finalize(fromSeg: PipeSegment | undefined): PipeSegment;
     refineFrom(from: PipeSegment | undefined, to: QuerySegment): void;

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

@@ -24,7 +24,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FieldDefinitionValue = exports.DefSpace = exports.DimensionFieldDeclaration = exports.MeasureFieldDeclaration = exports.DeclareFieldDeclaration = exports.ProjectFieldDeclaration = exports.GroupByFieldDeclaration = exports.AggregateFieldDeclaration = exports.CalculateFieldDeclaration = exports.AtomicFieldDeclaration = void 0;
 const malloy_types_1 = require("../../../model/malloy_types");
-const utils_1 = require("../expressions/utils");
 const fragtype_utils_1 = require("../fragtype-utils");
 const granular_result_1 = require("../types/granular-result");
 const malloy_element_1 = require("../types/malloy-element");
@@ -74,7 +73,6 @@ class AtomicFieldDeclaration extends malloy_element_1.MalloyElement {
                 type: 'error',
             };
         }
-        const compressValue = (0, utils_1.compressExpr)(exprValue.value);
         let retType = exprValue.dataType;
         if (retType === 'null') {
             this.expr.log('null value defaults to type number, use "null::TYPE" to specify correct type', 'warn');
@@ -86,9 +84,7 @@ class AtomicFieldDeclaration extends malloy_element_1.MalloyElement {
                 type: retType,
                 location: this.location,
             };
-            if (compressValue.length > 0) {
-                template.e = compressValue;
-            }
+            template.e = exprValue.value;
             if (exprValue.expressionType) {
                 template.expressionType = exprValue.expressionType;
             }

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

@@ -1,4 +1,4 @@
-import { FilterExpression } from '../../../model/malloy_types';
+import { FilterCondition } from '../../../model/malloy_types';
 import { ExpressionDef } from '../types/expression-def';
 import { FieldSpace } from '../types/field-space';
 import { ListOf, MalloyElement } from '../types/malloy-element';
@@ -8,7 +8,7 @@ export declare class FilterElement extends MalloyElement {
     readonly exprSrc: string;
     elementType: string;
     constructor(expr: ExpressionDef, exprSrc: string);
-    filterExpression(fs: FieldSpace): FilterExpression;
+    filterCondition(fs: FieldSpace): FilterCondition;
 }
 export declare class Filter extends ListOf<FilterElement> implements QueryPropertyInterface {
     elementType: string;
@@ -16,5 +16,5 @@ export declare class Filter extends ListOf<FilterElement> implements QueryProper
     forceQueryClass: undefined;
     queryRefinementStage: LegalRefinementStage;
     set having(isHaving: boolean);
-    getFilterList(fs: FieldSpace): FilterExpression[];
+    getFilterList(fs: FieldSpace): FilterCondition[];
 }

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

@@ -24,7 +24,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Filter = exports.FilterElement = void 0;
 const malloy_types_1 = require("../../../model/malloy_types");
-const utils_1 = require("../expressions/utils");
 const malloy_element_1 = require("../types/malloy-element");
 const query_property_interface_1 = require("../types/query-property-interface");
 class FilterElement extends malloy_element_1.MalloyElement {
@@ -34,19 +33,21 @@ class FilterElement extends malloy_element_1.MalloyElement {
         this.exprSrc = exprSrc;
         this.elementType = 'filterElement';
     }
-    filterExpression(fs) {
+    filterCondition(fs) {
         const exprVal = this.expr.getExpression(fs);
         if (exprVal.dataType !== 'boolean') {
             this.expr.log('Filter expression must have boolean value');
             return {
+                node: 'filterCondition',
                 code: this.exprSrc,
-                expression: ['_FILTER_MUST_RETURN_BOOLEAN_'],
+                e: { node: 'false' },
                 expressionType: 'scalar',
             };
         }
         const exprCond = {
+            node: 'filterCondition',
             code: this.exprSrc,
-            expression: (0, utils_1.compressExpr)(exprVal.value),
+            e: exprVal.value,
             expressionType: exprVal.expressionType,
         };
         return exprCond;
@@ -70,7 +71,7 @@ class Filter extends malloy_element_1.ListOf {
     getFilterList(fs) {
         const checked = [];
         for (const oneElement of this.list) {
-            const fExpr = oneElement.filterExpression(fs);
+            const fExpr = oneElement.filterCondition(fs);
             // mtoy todo is having we never set then queryRefinementStage might be wrong
             // ... calculations and aggregations must go last
             // Aggregates are ALSO checked at SQL generation time, but checking

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

@@ -24,7 +24,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Top = void 0;
 const malloy_types_1 = require("../../../model/malloy_types");
-const utils_1 = require("../expressions/utils");
 const field_space_1 = require("../types/field-space");
 const malloy_element_1 = require("../types/malloy-element");
 const query_property_interface_1 = require("../types/query-property-interface");
@@ -67,7 +66,7 @@ class Top extends malloy_element_1.MalloyElement {
                 if (byExpr.evalSpace === 'output') {
                     this.by.log('top by expression must be an output expression');
                 }
-                return { by: 'expression', e: (0, utils_1.compressExpr)(byExpr.value) };
+                return { by: 'expression', e: byExpr.value };
             }
         }
         return undefined;

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

@@ -119,7 +119,7 @@ class RefinedSource extends source_1.Source {
         let moreFilters = false;
         for (const filter of filters) {
             for (const el of filter.list) {
-                const fc = el.filterExpression(fs);
+                const fc = el.filterCondition(fs);
                 if ((0, malloy_types_1.expressionIsCalculation)(fc.expressionType)) {
                     el.log("Can't use aggregate computations in top level filters");
                 }