@malloydata/malloy 0.0.247-dev250321153536 → 0.0.247-dev250321211927

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

@@ -15,7 +15,6 @@ class ExprFilterExpression extends expression_def_1.ExpressionDef {
         super();
         this.filterText = filterText;
         this.elementType = 'filter expression literal';
-        // mtoy todo parse the filter and reflect errors into the error stream
     }
     getExpression() {
         return this.loggedErrorExpr('filter-expression-type', 'Filter expression illegal here');
@@ -49,9 +48,14 @@ class ExprFilterExpression extends expression_def_1.ExpressionDef {
                     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}`);
+                for (const err of fParse.log) {
+                    // Current parser only ever returns one error, it doesn't recover
+                    // Theoretically possible to user the startIndex to point to the
+                    // error inside the filter string, but I don't know if this is an
+                    // f' string or an f''' string, and I think the startOffset is from
+                    // the first non blank space in the filter (it was at one point)
+                    // so for now, we just flag the entire filter source token.
+                    return this.loggedErrorExpr('filter-expression-error', `Filter parse error: ${err.message}`);
                 }
             }
             if (!fParse.parsed) {

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

@@ -364,6 +364,7 @@ type MessageParameterTypes = {
     'wildcard-include-rename': string;
     'literal-string-newline': string;
     'filter-expression-type': string;
+    'filter-expression-error': string;
     'invalid-malloy-query-document': string;
 };
 export declare const MESSAGE_FORMATTERS: PartialErrorCodeMessageMap;

package/dist/model/filter_compilers.d.ts

@@ -5,5 +5,5 @@ export declare const FilterCompilers: {
     numberCompile(nc: NumberFilter, x: string, d: Dialect): string;
     booleanCompile(bc: BooleanFilter, x: string, _d: Dialect): string;
     stringCompile(sc: StringFilter, x: string, d: Dialect): string;
-    temporalCompile(tc: TemporalFilter, x: string, d: Dialect): string;
+    temporalCompile(tc: TemporalFilter, x: string, d: Dialect, t: 'date' | 'timestamp'): string;
 };

package/dist/model/filter_compilers.js

@@ -47,7 +47,7 @@ exports.FilterCompilers = {
             return exports.FilterCompilers.booleanCompile(c, x, d);
         }
         else if ((t === 'date' || t === 'timestamp') && (0, malloy_filter_1.isTemporalFilter)(c)) {
-            return exports.FilterCompilers.temporalCompile(c, x, d);
+            return exports.FilterCompilers.temporalCompile(c, x, d, t);
         }
         throw new Error('INTERNAL ERROR: No filter compiler for ' + t);
     },
@@ -167,9 +167,9 @@ exports.FilterCompilers = {
             case ',': {
                 /*
                  * Basic formula over all members
-                 * ALL INCLUDED THINGS OR TOGETHER AND ALL EXCLUDED THINGS ANDED TOGETHER
-                 *
-                 * mtoy todo write some tests to see if AND clauses are includes or excludes
+                 *    (ALL INCLUDED THINGS OR TOGETHER)
+                 * AND
+                 *    (ALL EXCLUDED THINGS ANDED TOGETHER)
                  */
                 const includes = [];
                 const excludes = [];
@@ -243,8 +243,8 @@ exports.FilterCompilers = {
         }
     },
     // mtoy todo figure out what to do about dates
-    temporalCompile(tc, x, d) {
-        const c = new filter_temporal_compiler_1.TemporalFilterCompiler(x, d);
+    temporalCompile(tc, x, d, t) {
+        const c = new filter_temporal_compiler_1.TemporalFilterCompiler(x, d, t);
         return c.compile(tc);
     },
 };

package/dist/model/filter_temporal_compiler.d.ts

@@ -11,6 +11,7 @@ export declare class TemporalFilterCompiler {
     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;

package/dist/model/filter_temporal_compiler.js

@@ -27,16 +27,37 @@ class TemporalFilterCompiler {
         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.moment(tc.after).end}`;
+                return `${x} ${tc.not ? '<' : '>='} ${this.time(this.moment(tc.after).end)}`;
             case 'before':
-                return `${x} ${tc.not ? '>=' : '<'} ${this.moment(tc.before).begin}`;
+                return `${x} ${tc.not ? '>=' : '<'} ${this.time(this.moment(tc.before).begin.sql)}`;
             case 'in': {
-                // mtoy todo in now
                 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': {
@@ -57,7 +78,7 @@ class TemporalFilterCompiler {
             case 'to': {
                 const firstMoment = this.moment(tc.fromMoment);
                 const lastMoment = this.moment(tc.toMoment);
-                return this.isIn(tc.not, firstMoment.begin.sql, lastMoment.end);
+                return this.isIn(tc.not, firstMoment.begin.sql, lastMoment.begin.sql);
             }
             case 'last': {
                 const thisUnit = this.nowDot(tc.units);
@@ -221,7 +242,6 @@ class TemporalFilterCompiler {
     }
     moment(m) {
         switch (m.moment) {
-            // mtoy todo moments which have no duration should have somethign in the interface?
             case 'now': {
                 const now = this.nowExpr();
                 return { begin: now, end: now.sql };
@@ -230,20 +250,14 @@ class TemporalFilterCompiler {
                 return this.expandLiteral(m);
             case 'ago':
             case 'from_now': {
-                // mtoy todo just pretending all units work, they don't
-                const nowTruncExpr = {
-                    node: 'trunc',
-                    e: this.nowExpr(),
-                    units: m.units,
-                };
-                nowTruncExpr.sql = this.d.sqlTruncExpr({}, nowTruncExpr);
+                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 oneDifferent = Number(m.n) + (m.moment === 'ago' ? -1 : 1);
                 const endExpr = {
                     ...beginExpr,
                     kids: { base: nowTrunc, delta: this.n(oneDifferent.toString()) },
@@ -318,6 +332,8 @@ class TemporalFilterCompiler {
             begOp = '<';
             endOp = '>=';
         }
+        begin = this.time(begin);
+        end = this.time(end);
         return `${this.expr} ${begOp} ${begin} ${joinOp} ${this.expr} ${endOp} ${end}`;
     }
 }

package/dist/model/malloy_query.js

@@ -893,8 +893,7 @@ class QueryField extends QueryNode {
                         return filter_compilers_1.FilterCompilers.compile(expr.dataType, expr.filter, expr.e.sql || '', this.parent.dialect);
                     }
                 }
-                // mtoy todo no throw
-                throw new Error(`Internal Error: Filter Compiler Undefined (FCU) ${expr.dataType}`);
+                throw new Error(`Internal Error: Filter Compiler Undefined Type '${expr.dataType}'`);
             default:
                 throw new Error(`Internal Error: Unknown expression node '${expr.node}' ${JSON.stringify(expr, undefined, 2)}`);
         }

package/package.json

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