@malloydata/malloy 0.0.242 → 0.0.243-dev250314032737

package/dist/dialect/dialect.js

@@ -243,9 +243,18 @@ class Dialect {
                 escapeClause = true;
             }
             else {
-                if (escapeActive && (c === '%' || c === '_')) {
-                    escaped += this.likeEscape ? '^' : '\\';
-                    escapeClause = this.likeEscape;
+                if (escapeActive) {
+                    if (this.likeEscape) {
+                        if (c === '%' || c === '_') {
+                            escaped += '^';
+                            escapeClause = true;
+                        }
+                    }
+                    else {
+                        if (c === '%' || c === '_' || c === '\\') {
+                            escaped += '\\';
+                        }
+                    }
                 }
                 escaped += c;
                 escapeActive = false;

package/dist/dialect/postgres/postgres.d.ts

@@ -25,6 +25,7 @@ export declare class PostgresDialect extends PostgresBase {
     readsNestedData: boolean;
     supportsComplexFilteredSources: boolean;
     compoundObjectInSchema: boolean;
+    likeEscape: boolean;
     quoteTablePath(tablePath: string): string;
     sqlGroupSetTable(groupSetCount: number): string;
     sqlAnyValue(groupSet: number, fieldName: string): string;

package/dist/dialect/postgres/postgres.js

@@ -94,6 +94,7 @@ class PostgresDialect extends pg_impl_1.PostgresBase {
         this.readsNestedData = false;
         this.supportsComplexFilteredSources = false;
         this.compoundObjectInSchema = false;
+        this.likeEscape = false;
     }
     quoteTablePath(tablePath) {
         return tablePath

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

@@ -26,33 +26,47 @@ class ExprFilterExpression extends expression_def_1.ExpressionDef {
             if (matchExpr.type === 'error') {
                 return matchExpr;
             }
-            if (matchExpr.type === 'string') {
-                const fParse = malloy_filter_1.StringFilterExpression.parse(this.filterText);
-                if (fParse.log.length > 0) {
-                    for (const _err of fParse.log) {
-                        // mtoy todo actuall get error and report correct position and error type
-                        return this.loggedErrorExpr('filter-expression-type', 'FHJKL:DSHJKL error in parsing filter expression');
-                    }
-                }
-                if (!fParse.parsed) {
-                    return this.loggedErrorExpr('filter-expression-type', 'FJKLD:JDKSL: expression parsed to null');
-                }
-                const filterMatch = {
-                    node: 'filterMatch',
-                    dataType: matchExpr.type,
-                    filter: fParse.parsed,
-                    e: matchExpr.value,
-                };
-                if (op === '!~') {
-                    filterMatch.notMatch = true;
+            let fParse;
+            switch (matchExpr.type) {
+                case 'string':
+                    fParse = malloy_filter_1.StringFilterExpression.parse(this.filterText);
+                    break;
+                case 'number':
+                    fParse = malloy_filter_1.NumberFilterExpression.parse(this.filterText);
+                    break;
+                case 'boolean':
+                    fParse = malloy_filter_1.BooleanFilterExpression.parse(this.filterText);
+                    break;
+                case 'date':
+                case 'timestamp':
+                    fParse = malloy_filter_1.TemporalFilterExpression.parse(this.filterText);
+                    break;
+                default:
+                    return left.loggedErrorExpr('filter-expression-type', `Cannot use filter expressions with type '${matchExpr.type}'`);
+            }
+            if (fParse.log.length > 0) {
+                for (const _err of fParse.log) {
+                    // mtoy todo actuall get error and report correct position and error type
+                    return this.loggedErrorExpr('filter-expression-type', `Filter parse error: ${fParse.log[0].message}`);
                 }
-                return (0, expr_value_1.computedExprValue)({
-                    value: filterMatch,
-                    dataType: { type: 'boolean' },
-                    from: [matchExpr],
-                });
             }
-            return this.loggedErrorExpr('filter-expression-type', `CUISAO)VEFG Filter expressions for ${matchExpr.type} not available`);
+            if (!fParse.parsed) {
+                return this.loggedErrorExpr('filter-expression-type', 'FJKLD:JDKSL: expression parsed to null');
+            }
+            const filterMatch = {
+                node: 'filterMatch',
+                dataType: matchExpr.type,
+                filter: fParse.parsed,
+                e: matchExpr.value,
+            };
+            if (op === '!~') {
+                filterMatch.notMatch = true;
+            }
+            return (0, expr_value_1.computedExprValue)({
+                value: filterMatch,
+                dataType: { type: 'boolean' },
+                from: [matchExpr],
+            });
         }
         return this.loggedErrorExpr('filter-expression-type', `Cannot use the '${op}' operator with a filter expression`);
     }

package/dist/model/filter_compilers.d.ts

@@ -1,5 +1,9 @@
-import { StringClause } from '@malloydata/malloy-filter';
+import { BooleanClause, ClauseBase, NumberClause, StringClause, TemporalClause } from '@malloydata/malloy-filter';
 import { Dialect } from '../dialect';
 export declare const FilterCompilers: {
+    compile(t: string, c: ClauseBase, x: string, d: Dialect): string;
+    numberCompile(nc: NumberClause, x: string, d: Dialect): string;
+    booleanCompile(bc: BooleanClause, x: string, _d: Dialect): string;
+    temporalCompile(tc: TemporalClause, x: string, d: Dialect): string;
     stringCompile(sc: StringClause, x: string, d: Dialect): string;
 };

package/dist/model/filter_compilers.js

@@ -7,15 +7,25 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FilterCompilers = void 0;
-function likeSafe(v) {
-    return v.replace(/([_%])g/, '\\$1');
+const malloy_filter_1 = require("@malloydata/malloy-filter");
+function escapeForLike(v) {
+    return v.replace(/([%_\\])/g, '\\$1');
+}
+function invertCompare(no) {
+    if (no === '>')
+        return '<=';
+    else if (no === '<')
+        return '>=';
+    else if (no === '>=')
+        return '<';
+    return '>';
 }
 function unlike(disLiked, x) {
-    const orNull = `OR ${x} IS NULL`;
+    const orNull = ` OR ${x} IS NULL`;
     if (disLiked.length === 1) {
-        return `${disLiked[0]} ${orNull}`;
+        return `${disLiked[0]}${orNull}`;
     }
-    return `(${disLiked.join(' and ')}) $orNULL`;
+    return `(${disLiked.join(' AND ')})${orNull}`;
 }
 /*
  * These compilers from filter expression to SQL actually belong in malloy-filters but
@@ -25,6 +35,83 @@ function unlike(disLiked, x) {
  * XXXXFilterCompiler.compile() will move to XXXFilterExpression.compile()
  */
 exports.FilterCompilers = {
+    compile(t, c, x, d) {
+        if (t === 'string' && (0, malloy_filter_1.isStringClause)(c)) {
+            return exports.FilterCompilers.stringCompile(c, x, d);
+        }
+        else if (t === 'number' && (0, malloy_filter_1.isNumberClause)(c)) {
+            return exports.FilterCompilers.numberCompile(c, x, d);
+        }
+        else if (t === 'boolean' && (0, malloy_filter_1.isBooleanClause)(c)) {
+            return exports.FilterCompilers.booleanCompile(c, x, d);
+        }
+        else if ((t === 'date' || t === 'timestamp') && (0, malloy_filter_1.isTemporalClause)(c)) {
+            return exports.FilterCompilers.temporalCompile(c, x, d);
+        }
+        throw new Error('INTERNAL ERROR: No filter compiler for ' + t);
+    },
+    numberCompile(nc, x, d) {
+        switch (nc.operator) {
+            case '!=':
+            case '=': {
+                const notEqual = (nc.operator === '=' && nc.not) || (nc.operator === '!=' && !nc.not);
+                const optList = nc.values.join(', ');
+                if (nc.values.length === 1) {
+                    if (notEqual)
+                        return `${x} != ${optList} OR ${x} IS NULL`;
+                    return `${x} = ${optList}`;
+                }
+                if (notEqual)
+                    return `${x} NOT IN (${optList}) OR ${x} IS NULL`;
+                return `${x} IN (${optList})`;
+            }
+            case '>':
+            case '<':
+            case '>=':
+            case '<=':
+                return nc.values
+                    .map(v => `${x} ${nc.operator} ${v}`)
+                    .join(nc.not ? ' AND ' : ' OR ');
+            case 'range': {
+                let startOp = nc.startOperator;
+                let endOp = nc.endOperator;
+                let plus = ' AND ';
+                if (nc.not) {
+                    startOp = invertCompare(startOp);
+                    endOp = invertCompare(endOp);
+                    plus = ' OR ';
+                }
+                return `${x} ${startOp} ${nc.startValue} ${plus} ${x} ${endOp} ${nc.endValue}`;
+            }
+            case 'null':
+                return nc.not ? `${x} IS NOT NULL` : `${x} IS NULL`;
+            case '()': {
+                const wrapped = '(' + exports.FilterCompilers.numberCompile(nc.expr, x, d) + ')';
+                return nc.not ? `NOT ${wrapped}` : wrapped;
+            }
+            case 'and':
+            case 'or':
+                return nc.members
+                    .map(m => exports.FilterCompilers.numberCompile(m, x, d))
+                    .join(` ${nc.operator.toUpperCase()}`);
+        }
+    },
+    booleanCompile(bc, x, _d) {
+        switch (bc.operator) {
+            case 'false':
+                return `${x} = false`;
+            case 'false_or_null':
+                return `${x} IS NULL OR ${x} = false`;
+            case 'null':
+                return bc.not ? `${x} IS NOT NULL` : `${x} IS NULL`;
+            case 'true':
+                return x;
+        }
+    },
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    temporalCompile(tc, x, d) {
+        return 'false';
+    },
     stringCompile(sc, x, d) {
         switch (sc.operator) {
             case 'null':
@@ -47,38 +134,38 @@ exports.FilterCompilers = {
                 return sc.not ? `not ${wrapped}` : wrapped;
             }
             case 'contains': {
-                const matches = sc.values.map(v => '%' + likeSafe(v) + '%');
+                const matches = sc.values.map(v => '%' + escapeForLike(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 ');
+                return matches.map(m => d.sqlLike('LIKE', x, m)).join(' OR ');
             }
             case 'starts': {
-                const matches = sc.values.map(v => likeSafe(v) + '%');
+                const matches = sc.values.map(v => escapeForLike(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 ');
+                return matches.map(m => d.sqlLike('LIKE', x, m)).join(' OR ');
             }
             case 'ends': {
-                const matches = sc.values.map(v => '%' + likeSafe(v));
+                const matches = sc.values.map(v => '%' + escapeForLike(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 ');
+                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 ');
+                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 ');
+                return clauses.join(' AND ');
             }
             case 'or': {
                 const clauses = sc.members.map(c => exports.FilterCompilers.stringCompile(c, x, d));
-                return clauses.join(' or ');
+                return clauses.join(' AND ');
             }
             case ',': {
                 /*
@@ -134,7 +221,7 @@ exports.FilterCompilers = {
                     if (includeNull) {
                         includeExprs.push(`${x} IS NULL`);
                     }
-                    includeSQL = includeExprs.join(' or ');
+                    includeSQL = includeExprs.join(' OR ');
                 }
                 let excludeSQL = '';
                 if (excludes.length > 0 || excludeEmpty || excludeNull) {
@@ -145,11 +232,11 @@ exports.FilterCompilers = {
                     if (excludeNull) {
                         excludeExprs.push(`${x} IS NOT NULL`);
                     }
-                    excludeSQL = excludeExprs.join(' and ');
+                    excludeSQL = excludeExprs.join(' AND ');
                 }
                 if (includeSQL) {
                     return excludeSQL !== ''
-                        ? includeSQL + ' and ' + excludeSQL
+                        ? `(${includeSQL}) AND (${excludeSQL})`
                         : includeSQL;
                 }
                 return excludeSQL !== '' ? excludeSQL : 'true';

package/dist/model/malloy_query.js

@@ -883,10 +883,12 @@ class QueryField extends QueryNode {
             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);
+                if (expr.dataType === 'string' ||
+                    expr.dataType === 'number' ||
+                    expr.dataType === 'boolean') {
+                    return filter_compilers_1.FilterCompilers.compile(expr.dataType, expr.filter, expr.e.sql || '', this.parent.dialect);
                 }
-                throw new Error(`Internal Error: FCU ${expr.dataType}`);
+                throw new Error(`Internal Error: Filter Compiler Undefined (FCU) ${expr.dataType}`);
             default:
                 throw new Error(`Internal Error: Unknown expression node '${expr.node}' ${JSON.stringify(expr, undefined, 2)}`);
         }

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const MALLOY_VERSION = "0.0.242";
+export declare const MALLOY_VERSION = "0.0.243";

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/malloy",
-  "version": "0.0.242",
+  "version": "0.0.243-dev250314032737",
   "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.242",
-    "@malloydata/malloy-interfaces": "^0.0.242",
-    "@malloydata/malloy-tag": "^0.0.242",
+    "@malloydata/malloy-filter": "^0.0.243-dev250314032737",
+    "@malloydata/malloy-interfaces": "^0.0.243-dev250314032737",
+    "@malloydata/malloy-tag": "^0.0.243-dev250314032737",
     "antlr4ts": "^0.5.0-alpha.4",
     "assert": "^2.0.0",
     "jest-diff": "^29.6.2",