@malloydata/malloy 0.0.242-dev250313002313 → 0.0.242-dev250313045635

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

@@ -19,6 +19,7 @@ import { ExprTimeContext } from "./MalloyParser";
 import { ExprNULLContext } from "./MalloyParser";
 import { ExprBoolContext } from "./MalloyParser";
 import { ExprRegexContext } from "./MalloyParser";
+import { FilterString_stubContext } from "./MalloyParser";
 import { ExprNowContext } from "./MalloyParser";
 import { TableFunctionContext } from "./MalloyParser";
 import { TableMethodContext } from "./MalloyParser";
@@ -235,6 +236,9 @@ import { FieldNameContext } from "./MalloyParser";
 import { SqlExploreNameRefContext } from "./MalloyParser";
 import { NameSQLBlockContext } from "./MalloyParser";
 import { ConnectionNameContext } from "./MalloyParser";
+import { TripFilterStringContext } from "./MalloyParser";
+import { TickFilterStringContext } from "./MalloyParser";
+import { FilterStringContext } from "./MalloyParser";
 import { DebugExprContext } from "./MalloyParser";
 import { DebugPartialContext } from "./MalloyParser";
 import { ExperimentalStatementForTestingContext } from "./MalloyParser";
@@ -483,6 +487,18 @@ export interface MalloyParserListener extends ParseTreeListener {
      * @param ctx the parse tree
      */
     exitExprRegex?: (ctx: ExprRegexContext) => void;
+    /**
+     * Enter a parse tree produced by the `filterString_stub`
+     * labeled alternative in `MalloyParser.literal`.
+     * @param ctx the parse tree
+     */
+    enterFilterString_stub?: (ctx: FilterString_stubContext) => void;
+    /**
+     * Exit a parse tree produced by the `filterString_stub`
+     * labeled alternative in `MalloyParser.literal`.
+     * @param ctx the parse tree
+     */
+    exitFilterString_stub?: (ctx: FilterString_stubContext) => void;
     /**
      * Enter a parse tree produced by the `exprNow`
      * labeled alternative in `MalloyParser.literal`.
@@ -2777,6 +2793,36 @@ export interface MalloyParserListener extends ParseTreeListener {
      * @param ctx the parse tree
      */
     exitConnectionName?: (ctx: ConnectionNameContext) => void;
+    /**
+     * Enter a parse tree produced by `MalloyParser.tripFilterString`.
+     * @param ctx the parse tree
+     */
+    enterTripFilterString?: (ctx: TripFilterStringContext) => void;
+    /**
+     * Exit a parse tree produced by `MalloyParser.tripFilterString`.
+     * @param ctx the parse tree
+     */
+    exitTripFilterString?: (ctx: TripFilterStringContext) => void;
+    /**
+     * Enter a parse tree produced by `MalloyParser.tickFilterString`.
+     * @param ctx the parse tree
+     */
+    enterTickFilterString?: (ctx: TickFilterStringContext) => void;
+    /**
+     * Exit a parse tree produced by `MalloyParser.tickFilterString`.
+     * @param ctx the parse tree
+     */
+    exitTickFilterString?: (ctx: TickFilterStringContext) => void;
+    /**
+     * Enter a parse tree produced by `MalloyParser.filterString`.
+     * @param ctx the parse tree
+     */
+    enterFilterString?: (ctx: FilterStringContext) => void;
+    /**
+     * Exit a parse tree produced by `MalloyParser.filterString`.
+     * @param ctx the parse tree
+     */
+    exitFilterString?: (ctx: FilterStringContext) => void;
     /**
      * Enter a parse tree produced by `MalloyParser.debugExpr`.
      * @param ctx the parse tree

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

@@ -19,6 +19,7 @@ import { ExprTimeContext } from "./MalloyParser";
 import { ExprNULLContext } from "./MalloyParser";
 import { ExprBoolContext } from "./MalloyParser";
 import { ExprRegexContext } from "./MalloyParser";
+import { FilterString_stubContext } from "./MalloyParser";
 import { ExprNowContext } from "./MalloyParser";
 import { TableFunctionContext } from "./MalloyParser";
 import { TableMethodContext } from "./MalloyParser";
@@ -235,6 +236,9 @@ import { FieldNameContext } from "./MalloyParser";
 import { SqlExploreNameRefContext } from "./MalloyParser";
 import { NameSQLBlockContext } from "./MalloyParser";
 import { ConnectionNameContext } from "./MalloyParser";
+import { TripFilterStringContext } from "./MalloyParser";
+import { TickFilterStringContext } from "./MalloyParser";
+import { FilterStringContext } from "./MalloyParser";
 import { DebugExprContext } from "./MalloyParser";
 import { DebugPartialContext } from "./MalloyParser";
 import { ExperimentalStatementForTestingContext } from "./MalloyParser";
@@ -386,6 +390,13 @@ export interface MalloyParserVisitor<Result> extends ParseTreeVisitor<Result> {
      * @return the visitor result
      */
     visitExprRegex?: (ctx: ExprRegexContext) => Result;
+    /**
+     * Visit a parse tree produced by the `filterString_stub`
+     * labeled alternative in `MalloyParser.literal`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitFilterString_stub?: (ctx: FilterString_stubContext) => Result;
     /**
      * Visit a parse tree produced by the `exprNow`
      * labeled alternative in `MalloyParser.literal`.
@@ -1749,6 +1760,24 @@ export interface MalloyParserVisitor<Result> extends ParseTreeVisitor<Result> {
      * @return the visitor result
      */
     visitConnectionName?: (ctx: ConnectionNameContext) => Result;
+    /**
+     * Visit a parse tree produced by `MalloyParser.tripFilterString`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitTripFilterString?: (ctx: TripFilterStringContext) => Result;
+    /**
+     * Visit a parse tree produced by `MalloyParser.tickFilterString`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitTickFilterString?: (ctx: TickFilterStringContext) => Result;
+    /**
+     * Visit a parse tree produced by `MalloyParser.filterString`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitFilterString?: (ctx: FilterStringContext) => Result;
     /**
      * Visit a parse tree produced by `MalloyParser.debugExpr`.
      * @param ctx the parse tree

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

@@ -242,5 +242,7 @@ export declare class MalloyToAST extends AbstractParseTreeVisitor<ast.MalloyElem
     visitExprWarnLike(pcx: parse.ExprWarnLikeContext): ast.ExprCompare;
     visitExprNullCheck(pcx: parse.ExprNullCheckContext): ast.ExprIsNull;
     visitExprWarnIn(pcx: parse.ExprWarnInContext): ast.ExprLegacyIn;
+    visitTickFilterString(pcx: parse.TickFilterStringContext): ast.ExprFilterExpression;
+    visitTripFilterString(pcx: parse.TripFilterStringContext): ast.ExprFilterExpression;
 }
 export {};

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

@@ -917,7 +917,8 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
         const str = pcx.text.slice(1).trimStart();
         const lastChar = str[str.length - 1];
         if (lastChar === '\n') {
-            this.contextError(pcx, 'literal-string-newline', 'String cannot contain a new-line character');
+            const t = str[0] === "'" ? '"' : "'";
+            this.contextError(pcx, 'literal-string-newline', `Missing ${t}${str[0]}${t} before end-of-line`);
         }
         const astStr = new ast.ExprString(str.slice(1, -1));
         return this.astAt(astStr, pcx);
@@ -1513,6 +1514,23 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
             .join(' | ')})`);
         return inStmt;
     }
+    visitTickFilterString(pcx) {
+        const fString = pcx.text.slice(1).trimStart(); // remove fSPACE
+        const lastChar = fString[fString.length - 1];
+        if (lastChar === '\n') {
+            const t = fString[0] === "'" ? '"' : "'";
+            this.contextError(pcx, 'literal-string-newline', `Missing $${t}${fString[0]}${t} before end-of-line`);
+        }
+        const filterText = fString.slice(1, -1);
+        const mfe = new ast.ExprFilterExpression(filterText);
+        return this.astAt(mfe, pcx);
+    }
+    visitTripFilterString(pcx) {
+        const fString = pcx.text.slice(1).trimStart();
+        const filterText = fString.slice(3, -3);
+        const mfe = new ast.ExprFilterExpression(filterText);
+        return this.astAt(mfe, pcx);
+    }
 }
 exports.MalloyToAST = MalloyToAST;
 //# sourceMappingURL=malloy-to-ast.js.map

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

@@ -54,6 +54,7 @@ type MessageParameterTypes = {
     'pick-when-must-be-boolean': {
         whenType: ExpressionValueType;
     };
+    'pick-non-atomic-type': string;
     'experiment-not-enabled': {
         experimentId: string;
     };
@@ -362,6 +363,7 @@ type MessageParameterTypes = {
     'unsupported-path-in-include': string;
     'wildcard-include-rename': string;
     'literal-string-newline': string;
+    'filter-expression-type': string;
     'invalid-malloy-query-document': string;
 };
 export declare const MESSAGE_FORMATTERS: PartialErrorCodeMessageMap;

package/dist/lang/test/expr-to-str.d.ts

@@ -0,0 +1,9 @@
+import { Expr } from '../../model/malloy_types';
+/**
+ * Returns a readable shorthand for the an Expr for use in debugging.
+ * If not passed any symbols, the first field reference will be A,
+ * the second B and so on in the output.
+ */
+type ESymbols = Record<string, string> | undefined;
+export declare function exprToStr(e: Expr, symbols: ESymbols): string;
+export {};

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

@@ -0,0 +1,124 @@
+"use strict";
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+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);
+    }
+    switch (e.node) {
+        case 'field': {
+            const ref = e.path.join('.');
+            if (symbols) {
+                if (symbols[ref] === undefined) {
+                    const nSyms = Object.keys(symbols).length;
+                    symbols[ref] = String.fromCharCode('A'.charCodeAt(0) + nSyms);
+                }
+                return symbols[ref];
+            }
+            else {
+                return ref;
+            }
+        }
+        case '()':
+            return `(${subExpr(e.e)})`;
+        case 'numberLiteral':
+            return `${e.literal}`;
+        case 'stringLiteral':
+            return `{"${e.literal}"}`;
+        case 'timeLiteral':
+            return `@${e.literal}`;
+        case 'recordLiteral': {
+            const parts = [];
+            for (const [name, val] of Object.entries(e.kids)) {
+                parts.push(`${name}:${subExpr(val)}`);
+            }
+            return `{${parts.join(', ')}}`;
+        }
+        case 'arrayLiteral': {
+            const parts = e.kids.values.map(k => subExpr(k));
+            return `[${parts.join(', ')}]`;
+        }
+        case 'regexpLiteral':
+            return `/${e.literal}/`;
+        case 'trunc':
+            return `{timeTrunc-${e.units} ${subExpr(e.e)}}`;
+        case 'delta':
+            return `{${e.op}${e.units} ${subExpr(e.kids.base)} ${subExpr(e.kids.delta)}}`;
+        case 'true':
+        case 'false':
+            return e.node;
+        case 'case': {
+            const caseStmt = ['case'];
+            if (e.kids.caseValue !== undefined) {
+                caseStmt.push(`${subExpr(e.kids.caseValue)}`);
+            }
+            for (let i = 0; i < e.kids.caseWhen.length; i += 1) {
+                caseStmt.push(`when ${subExpr(e.kids.caseWhen[i])} then ${subExpr(e.kids.caseThen[i])}`);
+            }
+            if (e.kids.caseElse !== undefined) {
+                caseStmt.push(`else ${subExpr(e.kids.caseElse)}`);
+            }
+            return `{${caseStmt.join(' ')}}`;
+        }
+        case 'regexpMatch':
+            return `{${subExpr(e.kids.expr)} regex-match ${subExpr(e.kids.regex)}}`;
+        case 'in': {
+            return `{${subExpr(e.kids.e)} ${e.not ? 'not in' : 'in'} {${e.kids.oneOf
+                .map(o => `${subExpr(o)}`)
+                .join(',')}}}`;
+        }
+        case 'genericSQLExpr': {
+            let sql = '';
+            let i = 0;
+            for (; i < e.kids.args.length; i++) {
+                sql += `${e.src[i]}{${subExpr(e.kids.args[i])}}`;
+            }
+            if (i < e.src.length) {
+                sql += e.src[i];
+            }
+            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}}`;
+        }
+    }
+    if ((0, malloy_types_1.exprHasKids)(e) && e.kids['left'] && e.kids['right']) {
+        return `{${subExpr(e.kids['left'])} ${e.node} ${subExpr(e.kids['right'])}}`;
+    }
+    else if ((0, malloy_types_1.exprHasE)(e)) {
+        return `{${e.node} ${subExpr(e.e)}}`;
+    }
+    else if ((0, malloy_types_1.exprIsLeaf)(e)) {
+        return `{${e.node}}`;
+    }
+    return `{?${e.node}}`;
+}
+exports.exprToStr = exprToStr;
+//# sourceMappingURL=expr-to-str.js.map

package/dist/lang/test/parse-expects.js

@@ -23,7 +23,7 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-const model_1 = require("../../model");
+const expr_to_str_1 = require("./expr-to-str");
 const test_translator_1 = require("./test-translator");
 function rangeToStr(loc) {
     if (loc) {
@@ -122,95 +122,6 @@ function xlated(tt, warningsOkay = false) {
     tt.translate();
     return checkForNeededs(tt);
 }
-function eToStr(e, symbols) {
-    function subExpr(e) {
-        return eToStr(e, symbols);
-    }
-    switch (e.node) {
-        case 'field': {
-            const ref = e.path.join('.');
-            if (symbols) {
-                if (symbols[ref] === undefined) {
-                    const nSyms = Object.keys(symbols).length;
-                    symbols[ref] = String.fromCharCode('A'.charCodeAt(0) + nSyms);
-                }
-                return symbols[ref];
-            }
-            else {
-                return ref;
-            }
-        }
-        case '()':
-            return `(${subExpr(e.e)})`;
-        case 'numberLiteral':
-            return `${e.literal}`;
-        case 'stringLiteral':
-            return `{"${e.literal}"}`;
-        case 'timeLiteral':
-            return `@${e.literal}`;
-        case 'recordLiteral': {
-            const parts = [];
-            for (const [name, val] of Object.entries(e.kids)) {
-                parts.push(`${name}:${subExpr(val)}`);
-            }
-            return `{${parts.join(', ')}}`;
-        }
-        case 'arrayLiteral': {
-            const parts = e.kids.values.map(k => subExpr(k));
-            return `[${parts.join(', ')}]`;
-        }
-        case 'regexpLiteral':
-            return `/${e.literal}/`;
-        case 'trunc':
-            return `{timeTrunc-${e.units} ${subExpr(e.e)}}`;
-        case 'delta':
-            return `{${e.op}${e.units} ${subExpr(e.kids.base)} ${subExpr(e.kids.delta)}}`;
-        case 'true':
-        case 'false':
-            return e.node;
-        case 'case': {
-            const caseStmt = ['case'];
-            if (e.kids.caseValue !== undefined) {
-                caseStmt.push(`${subExpr(e.kids.caseValue)}`);
-            }
-            for (let i = 0; i < e.kids.caseWhen.length; i += 1) {
-                caseStmt.push(`when ${subExpr(e.kids.caseWhen[i])} then ${subExpr(e.kids.caseThen[i])}`);
-            }
-            if (e.kids.caseElse !== undefined) {
-                caseStmt.push(`else ${subExpr(e.kids.caseElse)}`);
-            }
-            return `{${caseStmt.join(' ')}}`;
-        }
-        case 'regexpMatch':
-            return `{${subExpr(e.kids.expr)} regex-match ${subExpr(e.kids.regex)}}`;
-        case 'in': {
-            return `{${subExpr(e.kids.e)} ${e.not ? 'not in' : 'in'} {${e.kids.oneOf
-                .map(o => `${subExpr(o)}`)
-                .join(',')}}}`;
-        }
-        case 'genericSQLExpr': {
-            let sql = '';
-            let i = 0;
-            for (; i < e.kids.args.length; i++) {
-                sql += `${e.src[i]}{${subExpr(e.kids.args[i])}}`;
-            }
-            if (i < e.src.length) {
-                sql += e.src[i];
-            }
-            return sql;
-        }
-    }
-    if ((0, model_1.exprHasKids)(e) && e.kids['left'] && e.kids['right']) {
-        return `{${subExpr(e.kids['left'])} ${e.node} ${subExpr(e.kids['right'])}}`;
-    }
-    else if ((0, model_1.exprHasE)(e)) {
-        return `{${e.node} ${subExpr(e.e)}}`;
-    }
-    else if ((0, model_1.exprIsLeaf)(e)) {
-        return `{${e.node}}`;
-    }
-    return `{?${e.node}}`;
-}
 expect.extend({
     toParse: function (tx) {
         const x = xlator(tx);
@@ -286,7 +197,7 @@ expect.extend({
         if (!badRefs.pass) {
             return badRefs;
         }
-        const rcvExpr = eToStr(bx.generated().value, undefined);
+        const rcvExpr = (0, expr_to_str_1.exprToStr)(bx.generated().value, undefined);
         const pass = this.equals(rcvExpr, expr);
         const msg = pass ? `Matched: ${rcvExpr}` : this.utils.diff(expr, rcvExpr);
         return { pass, message: () => `${msg}` };

package/dist/model/filter_compilers.d.ts

@@ -0,0 +1,5 @@
+import { StringClause } from '@malloydata/malloy-filter';
+import { Dialect } from '../dialect';
+export declare const FilterCompilers: {
+    stringCompile(sc: StringClause, x: string, d: Dialect): string;
+};

package/dist/model/filter_compilers.js

@@ -0,0 +1,160 @@
+"use strict";
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilterCompilers = void 0;
+function likeSafe(v) {
+    return v.replace(/([_%])g/, '\\$1');
+}
+function unlike(disLiked, x) {
+    const orNull = `OR ${x} IS NULL`;
+    if (disLiked.length === 1) {
+        return `${disLiked[0]} ${orNull}`;
+    }
+    return `(${disLiked.join(' and ')}) $orNULL`;
+}
+/*
+ * These compilers from filter expression to SQL actually belong in malloy-filters but
+ * that will require moving Dialect out to malloy-dialect to avoid a circular dependency
+ * between the filter compilers and packages/malloy. That's why these are
+ * defined in this slightly weird way. At some point the code here for
+ * XXXXFilterCompiler.compile() will move to XXXFilterExpression.compile()
+ */
+exports.FilterCompilers = {
+    stringCompile(sc, x, d) {
+        switch (sc.operator) {
+            case 'null':
+                return sc.not ? `${x} IS NOT NULL` : `${x} IS NULL`;
+            case 'empty':
+                return sc.not ? `COALESCE(${x},'') != ''` : `COALESCE(${x},'') = ''`;
+            case '=': {
+                if (sc.values.length === 1) {
+                    const eq = sc.not ? '!=' : '=';
+                    const compare = `${x} ${eq} ${d.sqlLiteralString(sc.values[0])}`;
+                    return sc.not ? `(${compare} OR ${x} IS NULL)` : compare;
+                }
+                const eqList = '(' + sc.values.map(v => d.sqlLiteralString(v)).join(', ') + ')';
+                return sc.not
+                    ? `(${x} NOT IN ${eqList} OR ${x} IS NULL)`
+                    : `${x} IN ${eqList}`;
+            }
+            case '()': {
+                const wrapped = '(' + exports.FilterCompilers.stringCompile(sc.expr, x, d) + ')';
+                return sc.not ? `not ${wrapped}` : wrapped;
+            }
+            case 'contains': {
+                const matches = sc.values.map(v => '%' + likeSafe(v) + '%');
+                if (sc.not) {
+                    return unlike(matches.map(m => d.sqlLike('NOT LIKE', x, m)), x);
+                }
+                return matches.map(m => d.sqlLike('LIKE', x, m)).join(' or ');
+            }
+            case 'starts': {
+                const matches = sc.values.map(v => likeSafe(v) + '%');
+                if (sc.not) {
+                    return unlike(matches.map(m => d.sqlLike('NOT LIKE', x, m)), x);
+                }
+                return matches.map(m => d.sqlLike('LIKE', x, m)).join(' or ');
+            }
+            case 'ends': {
+                const matches = sc.values.map(v => '%' + likeSafe(v));
+                if (sc.not) {
+                    return unlike(matches.map(m => d.sqlLike('NOT LIKE', x, m)), x);
+                }
+                return matches.map(m => d.sqlLike('LIKE', x, m)).join(' or ');
+            }
+            case '~':
+                if (sc.not) {
+                    return unlike(sc.escaped_values.map(m => d.sqlLike('NOT LIKE', x, m)), x);
+                }
+                return sc.escaped_values.map(m => d.sqlLike('LIKE', x, m)).join(' or ');
+            case 'and': {
+                const clauses = sc.members.map(c => exports.FilterCompilers.stringCompile(c, x, d));
+                return clauses.join(' and ');
+            }
+            case 'or': {
+                const clauses = sc.members.map(c => exports.FilterCompilers.stringCompile(c, x, d));
+                return clauses.join(' or ');
+            }
+            case ',': {
+                /*
+                 * Basic formula over all members
+                 * ALL INCLUDED THINGS OR TOGETHER AND ALL EXCLUDED THINGS ANDED TOGETHER
+                 */
+                const includes = [];
+                const excludes = [];
+                let includeNull = false;
+                let excludeNull = false;
+                let includeEmpty = false;
+                let excludeEmpty = false;
+                for (const c of sc.members) {
+                    switch (c.operator) {
+                        case 'or':
+                        case 'and':
+                        case ',':
+                            includes.push(c);
+                            break;
+                        case 'null':
+                            if (c.not) {
+                                excludeNull = true;
+                            }
+                            else {
+                                includeNull = true;
+                            }
+                            break;
+                        case 'empty':
+                            if (c.not) {
+                                excludeEmpty = true;
+                                excludeNull = true;
+                            }
+                            else {
+                                includeEmpty = true;
+                                includeNull = true;
+                            }
+                            break;
+                        default:
+                            (c.not ? excludes : includes).push(c);
+                    }
+                }
+                if ((includeEmpty && excludeEmpty) || (includeNull && excludeNull)) {
+                    return 'false';
+                }
+                let includeSQL = '';
+                if (includes.length > 0 || includeNull || includeEmpty) {
+                    excludeEmpty = false;
+                    excludeNull = false;
+                    const includeExprs = includes.map(inc => exports.FilterCompilers.stringCompile(inc, x, d));
+                    if (includeEmpty) {
+                        includeExprs.push(`${x} = ''`);
+                    }
+                    if (includeNull) {
+                        includeExprs.push(`${x} IS NULL`);
+                    }
+                    includeSQL = includeExprs.join(' or ');
+                }
+                let excludeSQL = '';
+                if (excludes.length > 0 || excludeEmpty || excludeNull) {
+                    const excludeExprs = excludes.map(inc => exports.FilterCompilers.stringCompile(inc, x, d));
+                    if (excludeEmpty) {
+                        excludeExprs.push(`${x} != ''`);
+                    }
+                    if (excludeNull) {
+                        excludeExprs.push(`${x} IS NOT NULL`);
+                    }
+                    excludeSQL = excludeExprs.join(' and ');
+                }
+                if (includeSQL) {
+                    return excludeSQL !== ''
+                        ? includeSQL + ' and ' + excludeSQL
+                        : includeSQL;
+                }
+                return excludeSQL !== '' ? excludeSQL : 'true';
+            }
+        }
+    },
+};
+//# sourceMappingURL=filter_compilers.js.map

package/dist/model/malloy_query.js

@@ -30,6 +30,7 @@ const malloy_types_1 = require("./malloy_types");
 const utils_1 = require("./utils");
 const utils_2 = require("./materialization/utils");
 const annotation_1 = require("../annotation");
+const filter_compilers_1 = require("./filter_compilers");
 function pathToCol(path) {
     return path.map(el => encodeURIComponent(el)).join('/');
 }
@@ -722,6 +723,7 @@ class QueryField extends QueryNode {
         return caseStmt.join(' ');
     }
     exprToSQL(resultSet, context, exprToTranslate, state = new GenerateState()) {
+        var _a;
         // Wrap non leaf sub expressions in parenthesis
         const subExpr = function (qf, e) {
             const sql = qf.exprToSQL(resultSet, context, e, state);
@@ -841,11 +843,12 @@ class QueryField extends QueryNode {
                 return `${expr.kids.e.sql} ${expr.not ? 'NOT IN' : 'IN'} (${oneOf})`;
             }
             case 'like':
-                return this.parent.dialect.likeExpr(expr);
-            // Malloy inequality comparisons always return a boolean
             case '!like': {
-                const notLike = this.parent.dialect.likeExpr(expr);
-                return `COALESCE(${notLike},true)`;
+                const likeIt = expr.node === 'like' ? 'LIKE' : 'NOT LIKE';
+                const compare = expr.kids.right.node === 'stringLiteral'
+                    ? this.parent.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)`;
             }
             case '()':
                 return `(${expr.e.sql})`;
@@ -879,6 +882,11 @@ class QueryField extends QueryNode {
                 return '';
             case 'compositeField':
                 return '{COMPOSITE_FIELD}';
+            case 'filterMatch':
+                if (expr.dataType === 'string') {
+                    return filter_compilers_1.FilterCompilers.stringCompile(expr.filter, expr.e.sql || '', this.parent.dialect);
+                }
+                throw new Error(`Internal Error: FCU ${expr.dataType}`);
             default:
                 throw new Error(`Internal Error: Unknown expression node '${expr.node}' ${JSON.stringify(expr, undefined, 2)}`);
         }