@malloydata/malloy 0.0.262 → 0.0.263-dev250414184158

package/dist/lang/lib/Malloy/MalloyParserListener.d.ts

@@ -113,6 +113,7 @@ import { SourcePropertyListContext } from "./MalloyParser";
 import { SourceDefinitionContext } from "./MalloyParser";
 import { SqExploreContext } from "./MalloyParser";
 import { SourceParametersContext } from "./MalloyParser";
+import { LegalParamTypeContext } from "./MalloyParser";
 import { SourceParameterContext } from "./MalloyParser";
 import { ParameterNameDefContext } from "./MalloyParser";
 import { SourceNameDefContext } from "./MalloyParser";
@@ -1551,6 +1552,16 @@ export interface MalloyParserListener extends ParseTreeListener {
      * @param ctx the parse tree
      */
     exitSourceParameters?: (ctx: SourceParametersContext) => void;
+    /**
+     * Enter a parse tree produced by `MalloyParser.legalParamType`.
+     * @param ctx the parse tree
+     */
+    enterLegalParamType?: (ctx: LegalParamTypeContext) => void;
+    /**
+     * Exit a parse tree produced by `MalloyParser.legalParamType`.
+     * @param ctx the parse tree
+     */
+    exitLegalParamType?: (ctx: LegalParamTypeContext) => void;
     /**
      * Enter a parse tree produced by `MalloyParser.sourceParameter`.
      * @param ctx the parse tree

package/dist/lang/lib/Malloy/MalloyParserVisitor.d.ts

@@ -113,6 +113,7 @@ import { SourcePropertyListContext } from "./MalloyParser";
 import { SourceDefinitionContext } from "./MalloyParser";
 import { SqExploreContext } from "./MalloyParser";
 import { SourceParametersContext } from "./MalloyParser";
+import { LegalParamTypeContext } from "./MalloyParser";
 import { SourceParameterContext } from "./MalloyParser";
 import { ParameterNameDefContext } from "./MalloyParser";
 import { SourceNameDefContext } from "./MalloyParser";
@@ -1014,6 +1015,12 @@ export interface MalloyParserVisitor<Result> extends ParseTreeVisitor<Result> {
      * @return the visitor result
      */
     visitSourceParameters?: (ctx: SourceParametersContext) => Result;
+    /**
+     * Visit a parse tree produced by `MalloyParser.legalParamType`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitLegalParamType?: (ctx: LegalParamTypeContext) => Result;
     /**
      * Visit a parse tree produced by `MalloyParser.sourceParameter`.
      * @param ctx the parse tree

package/dist/lang/malloy-to-ast.d.ts

@@ -79,7 +79,7 @@ export declare class MalloyToAST extends AbstractParseTreeVisitor<ast.MalloyElem
     protected getIsNotes(cx: parse.IsDefineContext): Note[];
     visitMalloyDocument(pcx: parse.MalloyDocumentContext): ast.Document;
     visitDefineSourceStatement(pcx: parse.DefineSourceStatementContext): ast.DefineSourceList;
-    getSourceParameter(pcx: parse.SourceParameterContext): ast.HasParameter;
+    getSourceParameter(pcx: parse.SourceParameterContext): ast.HasParameter | null;
     getSourceParameters(pcx: parse.SourceParametersContext | undefined): ast.HasParameter[];
     visitSourceDefinition(pcx: parse.SourceDefinitionContext): ast.DefineSource;
     protected getSourceExtensions(extensions: parse.ExplorePropertiesContext): ast.SourceDesc;

package/dist/lang/malloy-to-ast.js

@@ -56,8 +56,8 @@ const ast_1 = require("./ast");
 const parse_utils_1 = require("./parse-utils");
 const malloy_types_1 = require("../model/malloy_types");
 const malloy_tag_1 = require("@malloydata/malloy-tag");
-const constant_expression_1 = require("./ast/expressions/constant-expression");
 const utils_1 = require("./utils");
+const malloy_filter_1 = require("@malloydata/malloy-filter");
 class ErrorNode extends ast.SourceQueryElement {
     constructor() {
         super(...arguments);
@@ -262,23 +262,49 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
         return defList;
     }
     getSourceParameter(pcx) {
+        const name = (0, parse_utils_1.getId)(pcx.parameterNameDef());
+        let pType;
+        let filterType;
+        const typeCx = pcx.legalParamType();
+        if (typeCx) {
+            const fTypeCx = typeCx.malloyType();
+            if (fTypeCx) {
+                const t = this.getMalloyType(fTypeCx);
+                if ((0, malloy_filter_1.isFilterable)(t)) {
+                    filterType = t;
+                }
+                else {
+                    this.contextError(typeCx, 'parameter-illegal-default-type', `Unknown filter type ${t}`);
+                }
+            }
+            const parseType = typeCx.FILTER()
+                ? 'filter expression'
+                : typeCx.text.toLowerCase();
+            if (!(0, malloy_types_1.isParameterType)(parseType)) {
+                this.contextError(typeCx, 'parameter-illegal-default-type', `Unknown parameter type ${parseType}`);
+                return null;
+            }
+            pType = parseType;
+        }
         const defaultCx = pcx.fieldExpr();
-        const defaultValue = defaultCx
-            ? this.astAt(new constant_expression_1.ConstantExpression(this.getFieldExpr(defaultCx)), defaultCx)
-            : undefined;
-        const typeCx = pcx.malloyType();
-        const type = typeCx ? this.getMalloyType(typeCx) : undefined;
-        return this.astAt(new ast.HasParameter({
-            name: (0, parse_utils_1.getId)(pcx.parameterNameDef()),
-            type,
-            default: defaultValue,
-        }), pcx);
+        let defVal;
+        if (defaultCx) {
+            const defaultExpr = new ast.ConstantExpression(this.getFieldExpr(defaultCx));
+            defVal = this.astAt(defaultExpr, defaultCx);
+        }
+        return this.astAt(new ast.HasParameter({ name, type: pType, default: defVal, filterType }), pcx);
     }
     getSourceParameters(pcx) {
         if (pcx === undefined)
             return [];
         this.inExperiment('parameters', pcx);
-        return pcx.sourceParameter().map(param => this.getSourceParameter(param));
+        function notNullParam(p) {
+            return p !== null;
+        }
+        return pcx
+            .sourceParameter()
+            .map(param => this.getSourceParameter(param))
+            .filter(notNullParam);
     }
     visitSourceDefinition(pcx) {
         const exploreExpr = this.visit(pcx.sqExplore());

package/dist/lang/test/expr-to-str.js

@@ -8,7 +8,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.exprToStr = void 0;
 const malloy_types_1 = require("../../model/malloy_types");
-const malloy_filter_1 = require("@malloydata/malloy-filter");
 function exprToStr(e, symbols) {
     function subExpr(e) {
         return exprToStr(e, symbols);
@@ -87,27 +86,11 @@ function exprToStr(e, symbols) {
             return sql;
         }
         case 'filterMatch': {
-            let filterText = '';
-            switch (e.dataType) {
-                case 'string':
-                    filterText = malloy_filter_1.StringFilterExpression.unparse(e.filter);
-                    break;
-                case 'number':
-                    filterText = malloy_filter_1.NumberFilterExpression.unparse(e.filter);
-                    break;
-                case 'date':
-                case 'timestamp':
-                    filterText = malloy_filter_1.TemporalFilterExpression.unparse(e.filter);
-                    break;
-                case 'boolean':
-                    filterText = malloy_filter_1.BooleanFilterExpression.unparse(e.filter);
-                    break;
-                default:
-                    filterText = 'UNKOWN-FILTER';
-            }
             const fType = `${e.dataType[0].toUpperCase()}${e.dataType.slice(1)}`;
-            return `{filter${fType} ${subExpr(e.e)} | ${filterText}}`;
+            return `{filter${fType} ${subExpr(e.kids.expr)} | ${subExpr(e.kids.filterExpr)}}`;
         }
+        case 'filterLiteral':
+            return `${e.filterSrc}`;
     }
     if ((0, malloy_types_1.exprHasKids)(e) && e.kids['left'] && e.kids['right']) {
         return `{${subExpr(e.kids['left'])} ${e.node} ${subExpr(e.kids['right'])}}`;

package/dist/model/filter_compilers.d.ts

@@ -7,3 +7,30 @@ export declare const FilterCompilers: {
     stringCompile(sc: StringFilter, x: string, d: Dialect): string;
     temporalCompile(tc: TemporalFilter, x: string, d: Dialect, t: 'date' | 'timestamp'): string;
 };
+/**
+ * I felt like there was enough "helpful functions needed to make everything
+ * work, all of which need to know the dialect", to justify making a class
+ * for this. Maybe this should just be a set of functions which take
+ * a dialect as an argument?
+ */
+export declare class TemporalFilterCompiler {
+    readonly expr: string;
+    readonly timetype: 'timestamp' | 'date';
+    readonly d: Dialect;
+    constructor(expr: string, dialect: Dialect, timetype?: 'timestamp' | 'date');
+    time(timeSQL: string): string;
+    compile(tc: TemporalFilter): string;
+    private expandLiteral;
+    private literalNode;
+    private nowExpr;
+    private n;
+    private delta;
+    private dayofWeek;
+    private nowDot;
+    private thisUnit;
+    private lastUnit;
+    private nextUnit;
+    mod7(n: string): string;
+    private moment;
+    private isIn;
+}

package/dist/model/filter_compilers.js

@@ -6,9 +6,10 @@
  * LICENSE file in the root directory of this source tree.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FilterCompilers = void 0;
+exports.TemporalFilterCompiler = exports.FilterCompilers = void 0;
 const malloy_filter_1 = require("@malloydata/malloy-filter");
-const filter_temporal_compiler_1 = require("./filter_temporal_compiler");
+const malloy_types_1 = require("./malloy_types");
+const luxon_1 = require("luxon");
 function escapeForLike(v) {
     return v.replace(/([%_\\])/g, '\\$1');
 }
@@ -247,8 +248,339 @@ exports.FilterCompilers = {
     },
     // mtoy todo figure out what to do about dates
     temporalCompile(tc, x, d, t) {
-        const c = new filter_temporal_compiler_1.TemporalFilterCompiler(x, d, t);
+        const c = new TemporalFilterCompiler(x, d, t);
         return c.compile(tc);
     },
 };
+const fYear = 'yyyy';
+const fMonth = `${fYear}-LL`;
+const fDay = `${fMonth}-dd`;
+const fHour = `${fDay} HH`;
+const fMinute = `${fHour}:mm`;
+const fTimestamp = `${fMinute}:ss`;
+/**
+ * I felt like there was enough "helpful functions needed to make everything
+ * work, all of which need to know the dialect", to justify making a class
+ * for this. Maybe this should just be a set of functions which take
+ * a dialect as an argument?
+ */
+class TemporalFilterCompiler {
+    constructor(expr, dialect, timetype = 'timestamp') {
+        this.expr = expr;
+        this.timetype = timetype;
+        this.d = dialect;
+    }
+    time(timeSQL) {
+        if (this.timetype === 'timestamp') {
+            return timeSQL;
+        }
+        return this.d.sqlCast({}, {
+            node: 'cast',
+            e: {
+                node: 'genericSQLExpr',
+                src: ['', timeSQL],
+                kids: { args: [] },
+                sql: timeSQL,
+            },
+            srcType: { type: 'timestamp' },
+            dstType: { type: 'date' },
+            safe: false,
+        });
+    }
+    compile(tc) {
+        const x = this.expr;
+        switch (tc.operator) {
+            case 'after':
+                return `${x} ${tc.not ? '<' : '>='} ${this.time(this.moment(tc.after).end)}`;
+            case 'before':
+                return `${x} ${tc.not ? '>=' : '<'} ${this.time(this.moment(tc.before).begin.sql)}`;
+            case 'in': {
+                const m = this.moment(tc.in);
+                if (m.begin.sql === m.end) {
+                    return tc.not
+                        ? `${x} != ${this.time(m.end)} OR ${x} IS NULL`
+                        : `${x} = ${this.time(m.end)}`;
+                }
+                return this.isIn(tc.not, m.begin.sql, m.end);
+            }
+            case 'for': {
+                const start = this.moment(tc.begin);
+                const end = this.delta(start.begin, '+', tc.n, tc.units);
+                return this.isIn(tc.not, start.begin.sql, end.sql);
+            }
+            case 'in_last': {
+                // last N units means "N - 1 UNITS AGO FOR N UNITS"
+                const back = Number(tc.n) - 1;
+                const thisUnit = this.nowDot(tc.units);
+                const start = back > 0
+                    ? this.delta(thisUnit, '-', back.toString(), tc.units)
+                    : thisUnit;
+                const end = this.delta(thisUnit, '+', '1', tc.units);
+                return this.isIn(tc.not, start.sql, end.sql);
+            }
+            case 'to': {
+                const firstMoment = this.moment(tc.fromMoment);
+                const lastMoment = this.moment(tc.toMoment);
+                return this.isIn(tc.not, firstMoment.begin.sql, lastMoment.begin.sql);
+            }
+            case 'last': {
+                const thisUnit = this.nowDot(tc.units);
+                const start = this.delta(thisUnit, '-', tc.n, tc.units);
+                return this.isIn(tc.not, start.sql, thisUnit.sql);
+            }
+            case 'next': {
+                const thisUnit = this.nowDot(tc.units);
+                const start = this.delta(thisUnit, '+', '1', tc.units);
+                const end = this.delta(thisUnit, '+', (Number(tc.n) + 1).toString(), tc.units);
+                return this.isIn(tc.not, start.sql, end.sql);
+            }
+            case 'null':
+                return tc.not ? `${x} IS NOT NULL` : `${x} IS NULL`;
+            case '()': {
+                const wrapped = '(' + this.compile(tc.expr) + ')';
+                return tc.not ? `NOT ${wrapped}` : wrapped;
+            }
+            case 'and':
+            case 'or':
+                return tc.members
+                    .map(m => this.compile(m))
+                    .join(` ${tc.operator.toUpperCase()} `);
+        }
+    }
+    expandLiteral(tl) {
+        let literal = tl.literal;
+        switch (tl.units) {
+            case 'year': {
+                const y = luxon_1.DateTime.fromFormat(literal, fYear);
+                const begin = this.literalNode(y.toFormat(fTimestamp));
+                const next = y.plus({ year: 1 });
+                return { begin, end: this.literalNode(next.toFormat(fTimestamp)).sql };
+            }
+            case 'month': {
+                const yyyymm = luxon_1.DateTime.fromFormat(literal, fMonth);
+                const begin = this.literalNode(yyyymm.toFormat(fTimestamp));
+                const next = yyyymm.plus({ month: 1 });
+                return { begin, end: this.literalNode(next.toFormat(fTimestamp)).sql };
+            }
+            case 'day': {
+                const yyyymmdd = luxon_1.DateTime.fromFormat(literal, fDay);
+                const begin = this.literalNode(yyyymmdd.toFormat(fTimestamp));
+                const next = yyyymmdd.plus({ day: 1 });
+                return { begin, end: this.literalNode(next.toFormat(fTimestamp)).sql };
+            }
+            case 'hour': {
+                const ymdh = luxon_1.DateTime.fromFormat(literal, fHour);
+                const begin = this.literalNode(ymdh.toFormat(fTimestamp));
+                const next = ymdh.plus({ hour: 1 });
+                return { begin, end: this.literalNode(next.toFormat(fTimestamp)).sql };
+            }
+            case 'minute': {
+                const ymdhm = luxon_1.DateTime.fromFormat(literal, fMinute);
+                const begin = this.literalNode(ymdhm.toFormat(fTimestamp));
+                const next = ymdhm.plus({ minute: 1 });
+                return { begin, end: this.literalNode(next.toFormat(fTimestamp)).sql };
+            }
+            case 'week': {
+                const a = luxon_1.DateTime.fromFormat(literal.slice(0, 10), fDay);
+                // Luxon uses monday weeks, so look for the Monday week which contains
+                // the day after, which for all days except Sunday is the same as
+                // the sunday week, and on Sunday it is this monday week instead of
+                // last monday week.
+                const mondayWeek = a.plus({ day: 1 }).startOf('week');
+                // Now back that up by one day and we have the Sunday week
+                const ymd_wk = mondayWeek.minus({ day: 1 });
+                const begin = this.literalNode(ymd_wk.toFormat(fTimestamp));
+                const next = ymd_wk.plus({ days: 7 });
+                return { begin, end: this.literalNode(next.toFormat(fTimestamp)).sql };
+            }
+            case 'quarter': {
+                const yyyy = literal.slice(0, 4);
+                const q = literal.slice(6);
+                if (q === '1') {
+                    literal = `${yyyy}-01-01 00:00:00`;
+                }
+                else if (q === '2') {
+                    literal = `${yyyy}-03-01 00:00:00`;
+                }
+                else if (q === '3') {
+                    literal = `${yyyy}-06-01 00:00:00`;
+                }
+                else {
+                    literal = `${yyyy}-09-01 00:00:00`;
+                }
+                const begin = this.literalNode(literal);
+                const ymd_q = luxon_1.DateTime.fromFormat(literal, fTimestamp);
+                const next = ymd_q.plus({ months: 3 });
+                return { begin, end: this.literalNode(next.toFormat(fTimestamp)).sql };
+            }
+            case undefined:
+            case 'second': {
+                const begin = this.literalNode(literal);
+                return { begin, end: begin.sql };
+            }
+        }
+    }
+    literalNode(literal) {
+        const literalNode = {
+            node: 'timeLiteral',
+            typeDef: { type: 'timestamp' },
+            literal,
+        };
+        return { ...literalNode, sql: this.d.sqlLiteralTime({}, literalNode) };
+    }
+    nowExpr() {
+        return {
+            node: 'now',
+            typeDef: { type: 'timestamp' },
+            sql: this.d.sqlNowExpr(),
+        };
+    }
+    n(literal) {
+        return { node: 'numberLiteral', literal, sql: literal };
+    }
+    delta(from, op, n, units) {
+        const ret = {
+            node: 'delta',
+            op,
+            units,
+            kids: {
+                base: (0, malloy_types_1.mkTemporal)(from, 'timestamp'),
+                delta: this.n(n),
+            },
+        };
+        return { ...ret, sql: this.d.sqlAlterTimeExpr(ret) };
+    }
+    dayofWeek(e) {
+        const t = {
+            node: 'extract',
+            e: (0, malloy_types_1.mkTemporal)(e, 'timestamp'),
+            units: 'day_of_week',
+        };
+        return { ...t, sql: this.d.sqlTimeExtractExpr({}, t) };
+    }
+    nowDot(units) {
+        const nowTruncExpr = {
+            node: 'trunc',
+            e: this.nowExpr(),
+            units,
+        };
+        return { ...nowTruncExpr, sql: this.d.sqlTruncExpr({}, nowTruncExpr) };
+    }
+    thisUnit(units) {
+        const thisUnit = this.nowDot(units);
+        const nextUnit = this.delta(thisUnit, '+', '1', units);
+        return { begin: thisUnit, end: nextUnit.sql };
+    }
+    lastUnit(units) {
+        const thisUnit = this.nowDot(units);
+        const lastUnit = this.delta(thisUnit, '-', '1', units);
+        return { begin: lastUnit, end: thisUnit.sql };
+    }
+    nextUnit(units) {
+        const thisUnit = this.nowDot(units);
+        const nextUnit = this.delta(thisUnit, '+', '1', units);
+        const next2Unit = this.delta(thisUnit, '+', '2', units);
+        return { begin: nextUnit, end: next2Unit.sql };
+    }
+    mod7(n) {
+        return this.d.hasModOperator ? `(${n})%7` : `MOD(${n},7)`;
+    }
+    moment(m) {
+        switch (m.moment) {
+            case 'now': {
+                const now = this.nowExpr();
+                return { begin: now, end: now.sql };
+            }
+            case 'literal':
+                return this.expandLiteral(m);
+            case 'ago':
+            case 'from_now': {
+                const nowTruncExpr = this.nowDot(m.units);
+                const nowTrunc = (0, malloy_types_1.mkTemporal)(nowTruncExpr, 'timestamp');
+                const beginExpr = this.delta(nowTrunc, m.moment === 'ago' ? '-' : '+', m.n, m.units);
+                // Now the end is one unit after that .. either n-1 units ago or n+1 units from now
+                if (m.moment === 'ago' && m.n === '1') {
+                    return { begin: beginExpr, end: nowTruncExpr.sql };
+                }
+                const oneDifferent = Number(m.n) + (m.moment === 'ago' ? -1 : 1);
+                const endExpr = {
+                    ...beginExpr,
+                    kids: { base: nowTrunc, delta: this.n(oneDifferent.toString()) },
+                };
+                return { begin: beginExpr, end: this.d.sqlAlterTimeExpr(endExpr) };
+            }
+            case 'today':
+                return this.thisUnit('day');
+            case 'yesterday':
+                return this.lastUnit('day');
+            case 'tomorrow':
+                return this.nextUnit('day');
+            case 'this':
+                return this.thisUnit(m.units);
+            case 'last':
+                return this.lastUnit(m.units);
+            case 'next':
+                return this.nextUnit(m.units);
+            case 'monday':
+            case 'tuesday':
+            case 'wednesday':
+            case 'thursday':
+            case 'friday':
+            case 'saturday':
+            case 'sunday': {
+                const destDay = [
+                    'sunday',
+                    'monday',
+                    'tuesday',
+                    'wednesday',
+                    'thursday',
+                    'friday',
+                    'saturday',
+                ].indexOf(m.moment);
+                const dow = this.dayofWeek(this.nowExpr()).sql;
+                if (m.which === 'next') {
+                    const nForwards = `${this.mod7(`${destDay}-(${dow}-1)+6`)}+1`;
+                    const begin = this.delta(this.thisUnit('day').begin, '+', nForwards, 'day');
+                    const end = this.delta(this.thisUnit('day').begin, '+', `${nForwards}+1`, 'day');
+                    // console.log(
+                    //   `SELECT ${
+                    //     this.nowExpr().sql
+                    //   } as now,\n  ${destDay} as destDay,\n  ${dow} as dow,\n  ${nForwards} as nForwards,\n  ${
+                    //     begin.sql
+                    //   } as begin,\n   ${end.sql} as end`
+                    // );
+                    return { begin, end: end.sql };
+                }
+                // dacks back = mod((daw0 - dst) + 6, 7) + 1;
+                // dacks back = mod(((daw - 1) - dst) + 6, 7) + 1;
+                // dacks back = mod(((daw) - dst) + 7, 7) + 1;
+                const nBack = `${this.mod7(`(${dow}-1)-${destDay}+6`)}+1`;
+                const begin = this.delta(this.thisUnit('day').begin, '-', nBack, 'day');
+                const end = this.delta(this.thisUnit('day').begin, '-', `(${nBack})-1`, 'day');
+                // console.log(
+                //   `SELECT ${
+                //     this.nowExpr().sql
+                //   } as now,\n  ${destDay} as destDay,\n  ${dow} as dow,\n  ${nBack} as nBack,\n  ${
+                //     begin.sql
+                //   } as begin,\n   ${end.sql} as end`
+                // );
+                return { begin, end: end.sql };
+            }
+        }
+    }
+    isIn(notIn, begin, end) {
+        let begOp = '>=';
+        let endOp = '<';
+        let joinOp = 'AND';
+        if (notIn) {
+            joinOp = 'OR';
+            begOp = '<';
+            endOp = '>=';
+        }
+        begin = this.time(begin);
+        end = this.time(end);
+        return `${this.expr} ${begOp} ${begin} ${joinOp} ${this.expr} ${endOp} ${end}`;
+    }
+}
+exports.TemporalFilterCompiler = TemporalFilterCompiler;
 //# sourceMappingURL=filter_compilers.js.map

package/dist/model/malloy_query.d.ts

@@ -1,5 +1,5 @@
 import type { QueryInfo, Dialect, DialectFieldList } from '../dialect';
-import type { AggregateFunctionType, Annotation, CompiledQuery, Expr, FieldDef, Filtered, FunctionOverloadDef, FunctionParameterDef, JoinRelationship, ModelDef, OrderBy, OutputFieldNode, ParameterNode, PipeSegment, Query, QueryFieldDef, QuerySegment, ResultMetadataDef, ResultStructMetadataDef, SearchIndexResult, SegmentFieldDef, StructDef, StructRef, TurtleDef, FunctionOrderBy, Argument, AggregateExpr, FilterCondition, GenericSQLExpr, FieldnameNode, FunctionCallNode, UngroupNode, SourceReferenceNode, SpreadExpr, FilteredExpr, SourceDef, BooleanFieldDef, QueryResultDef, QueryToMaterialize, PrepareResultOptions, CaseExpr, BasicAtomicDef, AtomicFieldDef } from './malloy_types';
+import type { AggregateFunctionType, Annotation, CompiledQuery, Expr, FieldDef, Filtered, FunctionOverloadDef, FunctionParameterDef, JoinRelationship, ModelDef, OrderBy, OutputFieldNode, ParameterNode, PipeSegment, Query, QueryFieldDef, QuerySegment, ResultMetadataDef, ResultStructMetadataDef, SearchIndexResult, SegmentFieldDef, StructDef, StructRef, TurtleDef, FunctionOrderBy, Argument, AggregateExpr, FilterCondition, GenericSQLExpr, FieldnameNode, FunctionCallNode, UngroupNode, SourceReferenceNode, SpreadExpr, FilteredExpr, SourceDef, BooleanFieldDef, QueryResultDef, QueryToMaterialize, PrepareResultOptions, CaseExpr, BasicAtomicDef, AtomicFieldDef, FilterMatchExpr } from './malloy_types';
 import type { Connection } from '../connection/types';
 import { AndChain } from './utils';
 import type { EventStream } from '../runtime_types';
@@ -94,6 +94,7 @@ declare class QueryField extends QueryNode {
     generateAnalyticFragment(dialect: string, resultStruct: FieldInstanceResult, context: QueryStruct, expr: Expr, overload: FunctionOverloadDef, state: GenerateState, args: Expr[], partitionByFields?: string[], funcOrdering?: string): string;
     generateCaseSQL(pf: CaseExpr): string;
     exprToSQL(resultSet: FieldInstanceResult, context: QueryStruct, exprToTranslate: Expr, state?: GenerateState): string;
+    generateAppliedFilter(context: QueryStruct, filterMatchExpr: FilterMatchExpr): string;
     isNestedInParent(parentDef: FieldDef): boolean;
     isArrayElement(parentDef: FieldDef): boolean;
     generateExpression(resultSet: FieldInstanceResult): string;

package/dist/model/malloy_query.js

@@ -890,20 +890,55 @@ class QueryField extends QueryNode {
             case 'compositeField':
                 return '{COMPOSITE_FIELD}';
             case 'filterMatch':
-                if (expr.dataType === 'string' ||
-                    expr.dataType === 'number' ||
-                    expr.dataType === 'date' ||
-                    expr.dataType === 'timestamp' ||
-                    expr.dataType === 'boolean') {
-                    if (expr.filter === null || (0, malloy_filter_1.isFilterExpression)(expr.filter)) {
-                        return filter_compilers_1.FilterCompilers.compile(expr.dataType, expr.filter, expr.e.sql || '', this.parent.dialect);
-                    }
-                }
-                throw new Error(`Internal Error: Filter Compiler Undefined Type '${expr.dataType}'`);
+                return this.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)}`);
         }
     }
+    generateAppliedFilter(context, filterMatchExpr) {
+        var _a;
+        let filterExpr = filterMatchExpr.kids.filterExpr;
+        while (filterExpr.node === '()') {
+            filterExpr = filterExpr.e;
+        }
+        if (filterExpr.node === 'parameter') {
+            const name = filterExpr.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) {
+                filterExpr = argument.value;
+            }
+            else {
+                throw new Error(`Parameter ${name} was expected to be a filter expression`);
+            }
+        }
+        if (filterExpr.node !== 'filterLiteral') {
+            throw new Error('Can only use filter expression literals or parameters as filter expressions');
+        }
+        const filterSrc = filterExpr.filterSrc;
+        let fParse;
+        switch (filterMatchExpr.dataType) {
+            case 'string':
+                fParse = malloy_filter_1.StringFilterExpression.parse(filterSrc);
+                break;
+            case 'number':
+                fParse = malloy_filter_1.NumberFilterExpression.parse(filterSrc);
+                break;
+            case 'boolean':
+                fParse = malloy_filter_1.BooleanFilterExpression.parse(filterSrc);
+                break;
+            case 'date':
+            case 'timestamp':
+                fParse = malloy_filter_1.TemporalFilterExpression.parse(filterSrc);
+                break;
+        }
+        if (fParse.log.length > 0) {
+            throw new Error(`Filter expression parse error: ${fParse.log[0]}`);
+        }
+        return filter_compilers_1.FilterCompilers.compile(filterMatchExpr.dataType, fParse.parsed, filterMatchExpr.kids.expr.sql || '', context.dialect);
+    }
     isNestedInParent(parentDef) {
         switch (parentDef.type) {
             case 'record':