@malloydata/malloy-tests 0.0.312 → 0.0.313

package/package.json

@@ -21,14 +21,14 @@
   },
   "dependencies": {
     "@jest/globals": "^29.4.3",
-    "@malloydata/db-bigquery": "0.0.312",
-    "@malloydata/db-duckdb": "0.0.312",
-    "@malloydata/db-postgres": "0.0.312",
-    "@malloydata/db-snowflake": "0.0.312",
-    "@malloydata/db-trino": "0.0.312",
-    "@malloydata/malloy": "0.0.312",
-    "@malloydata/malloy-tag": "0.0.312",
-    "@malloydata/render": "0.0.312",
+    "@malloydata/db-bigquery": "0.0.313",
+    "@malloydata/db-duckdb": "0.0.313",
+    "@malloydata/db-postgres": "0.0.313",
+    "@malloydata/db-snowflake": "0.0.313",
+    "@malloydata/db-trino": "0.0.313",
+    "@malloydata/malloy": "0.0.313",
+    "@malloydata/malloy-tag": "0.0.313",
+    "@malloydata/render": "0.0.313",
     "events": "^3.3.0",
     "jsdom": "^22.1.0",
     "luxon": "^2.4.0",
@@ -38,5 +38,5 @@
     "@types/jsdom": "^21.1.1",
     "@types/luxon": "^2.4.0"
   },
-  "version": "0.0.312"
+  "version": "0.0.313"
 }

package/src/databases/all/db_filter_expressions.spec.ts

@@ -421,55 +421,78 @@ describe.each(runtimes.runtimeList)('filter expressions %s', (dbName, db) => {
     });
   });
 
-  type TL = 'timeLiteral';
-
   describe('temporal filters', () => {
+    function tsLit(at: LuxonDateTime): string {
+      const typeDef: {type: 'timestamp' | 'date'} = {type: 'timestamp'};
+      const node: {node: 'timeLiteral'} = {node: 'timeLiteral'};
+      const timeStr = at.toUTC().toFormat(fTimestamp);
+      const n = {...node, typeDef, literal: timeStr};
+      return db.dialect.sqlLiteralTime({}, n);
+    }
     function lit(t: string, type: 'timestamp' | 'date'): string {
       const typeDef: {type: 'timestamp' | 'date'} = {type};
-      const timeLiteral: TL = 'timeLiteral';
-      const n = {
-        node: timeLiteral,
-        typeDef,
-        literal: t,
-      };
+      const node: {node: 'timeLiteral'} = {node: 'timeLiteral'};
+      const n = {...node, typeDef, literal: t};
       return db.dialect.sqlLiteralTime({}, n);
     }
 
     const fTimestamp = 'yyyy-LL-dd HH:mm:ss';
     const fDate = 'yyyy-LL-dd';
 
+    const inRange = [{n: 'first'}, {n: 'last'}];
+    const notInRange = [{n: 'before'}, {n: 'post-range'}];
+
     /**
-     * Create a source for testing a range. It will have five rows
+     * Create a query for testing temporal filters with better timezone handling.
+     * Returns a complete Malloy query string with the filter and timezone in the same segment.
+     * Result will have five rows:
      * { t: 1 second before start, n: 'before' }
      * { t: start,                 n: 'first' }
      * { t: 1 second before end,   n: 'last' }
      * { t: end,                   n: 'post-range' }
      * { t: NULL                   n: 'z-null' }
      * Use malloyResultMatches(range, inRange) or (range, notInRange)
+     *
+     * If a timezone is provided then ...
+     * - the start and end times are considered to be in that timezone
+     * - the query generated will include a timezone: directive
+     * - the filter expression is evaluated in that timezone
      */
-    const inRange = [{n: 'first'}, {n: 'last'}];
-    const notInRange = [{n: 'before'}, {n: 'post-range'}];
-    function mkRange(start: string, end: string) {
-      const begin = LuxonDateTime.fromFormat(start, fTimestamp);
+    function mkRangeQuery(
+      filterExpr: string,
+      start: string,
+      end: string,
+      queryTimezone?: string
+    ): string {
+      const zone = queryTimezone ?? 'UTC';
+
+      // Convert the civil time to the desired timezone
+      const begin = LuxonDateTime.fromFormat(start, fTimestamp, {zone});
+      const endTime = LuxonDateTime.fromFormat(end, fTimestamp, {zone});
+
       const b4 = begin.minus({second: 1});
-      const last = lit(
-        LuxonDateTime.fromFormat(end, fTimestamp)
-          .minus({second: 1})
-          .toFormat(fTimestamp),
-        'timestamp'
-      );
-      const before = lit(b4.toFormat(fTimestamp), 'timestamp');
-      const rangeModel = `
-        query: range is ${dbName}.sql("""
-          SELECT ${before} AS ${q`t`}, 'before' AS ${q`n`}
-          UNION ALL SELECT ${lit(start, 'timestamp')}, 'first'
-          UNION ALL SELECT ${last} , 'last'
-          UNION ALL SELECT ${lit(end, 'timestamp')}, 'post-range'
+      const last = endTime.minus({second: 1});
+
+      const timezoneClause = queryTimezone
+        ? `timezone: '${queryTimezone}';`
+        : '';
+
+      return `
+        run: ${dbName}.sql("""
+          SELECT ${tsLit(b4)} AS ${q`t`}, 'before' AS ${q`n`}
+          UNION ALL SELECT ${tsLit(begin)}, 'first'
+          UNION ALL SELECT ${tsLit(last)} , 'last'
+          UNION ALL SELECT ${tsLit(endTime)}, 'post-range'
           UNION ALL SELECT NULL, 'z-null'
-        """)
-        -> {select: *; order_by: n}`;
-      return db.loadModel(rangeModel);
+        """) -> {
+          ${timezoneClause}
+          where: t ~ ${filterExpr}
+          select: t, n
+          order_by: n
+        }
+      `;
     }
+
     function mkDateRange(start: string, end: string) {
       const begin = LuxonDateTime.fromFormat(start, fDate);
       const b4 = begin.minus({day: 1});
@@ -499,9 +522,12 @@ describe.each(runtimes.runtimeList)('filter expressions %s', (dbName, db) => {
     /**
      * All the relative time tests need a way to set what time it is now
      */
-    function nowIs(timeStr: string) {
+    function nowIs(nowStr: string, zone = 'UTC') {
       const spyNow = jest.spyOn(db.dialect, 'sqlNowExpr');
-      spyNow.mockImplementation(() => lit(timeStr, 'timestamp'));
+      spyNow.mockImplementation(() => {
+        const utcTime = LuxonDateTime.fromFormat(nowStr, fTimestamp, {zone});
+        return tsLit(utcTime);
+      });
     }
     afterEach(() => jest.restoreAllMocks());
 
@@ -525,110 +551,144 @@ describe.each(runtimes.runtimeList)('filter expressions %s', (dbName, db) => {
     });
     test('2 days ago', async () => {
       nowIs('2001-01-15 12:00:00');
-      const range = mkRange('2001-01-13 00:00:00', '2001-01-14 00:00:00');
-      await expect(`
-        run: range + { where: t ~ f'2 days ago' }
-      `).malloyResultMatches(range, inRange);
+      const rangeQuery = mkRangeQuery(
+        "f'2 days ago'",
+        '2001-01-13 00:00:00',
+        '2001-01-14 00:00:00'
+      );
+      await expect(rangeQuery).malloyResultMatches(db, inRange);
     });
     test('2 days', async () => {
       nowIs('2001-01-15 12:00:00');
-      const range = mkRange('2001-01-14 00:00:00', '2001-01-16 00:00:00');
-      await expect(`
-        run: range + { where: t ~ f'2 days' }
-      `).malloyResultMatches(range, inRange);
+      const rangeQuery = mkRangeQuery(
+        "f'2 days'",
+        '2001-01-14 00:00:00',
+        '2001-01-16 00:00:00'
+      );
+      await expect(rangeQuery).malloyResultMatches(db, inRange);
     });
     test('2 days from now', async () => {
       nowIs('2001-01-15 12:00:00');
-      const range = mkRange('2001-01-17 00:00:00', '2001-01-18 00:00:00');
-      await expect(`
-        run: range + { where: t ~ f'2 days from now' }
-      `).malloyResultMatches(range, inRange);
+      const rangeQuery = mkRangeQuery(
+        "f'2 days from now'",
+        '2001-01-17 00:00:00',
+        '2001-01-18 00:00:00'
+      );
+      await expect(rangeQuery).malloyResultMatches(db, inRange);
     });
     test('2000 to 2001', async () => {
-      const range = mkRange('2000-01-01 00:00:00', '2001-01-01 00:00:00');
-      await expect(`
-        run: range + { where: t ~ f'2000 to 2001' }
-      `).malloyResultMatches(range, inRange);
+      const rangeQuery = mkRangeQuery(
+        "f'2000 to 2001'",
+        '2000-01-01 00:00:00',
+        '2001-01-01 00:00:00'
+      );
+      await expect(rangeQuery).malloyResultMatches(db, inRange);
     });
     test('next 2 days', async () => {
       nowIs('2001-01-01 12:00:00');
-      const range = mkRange('2001-01-02 00:00:00', '2001-01-04 00:00:00');
-      await expect(`
-        run: range + { where: t ~ f'next 2 days' }
-      `).malloyResultMatches(range, inRange);
+      const rangeQuery = mkRangeQuery(
+        "f'next 2 days'",
+        '2001-01-02 00:00:00',
+        '2001-01-04 00:00:00'
+      );
+      await expect(rangeQuery).malloyResultMatches(db, inRange);
     });
     test('last 2 months', async () => {
       nowIs('2001-01-01 12:00:00');
-      const range = mkRange('2000-11-01 00:00:00', '2001-01-01 00:00:00');
-      await expect(`
-        run: range + { where: t ~ f'last 2 months' }
-      `).malloyResultMatches(range, inRange);
+      const rangeQuery = mkRangeQuery(
+        "f'last 2 months'",
+        '2000-11-01 00:00:00',
+        '2001-01-01 00:00:00'
+      );
+      await expect(rangeQuery).malloyResultMatches(db, inRange);
     });
     test('before y2k', async () => {
-      const range = mkRange('2001-01-01 00:00:00', '2002-01-01 00:00:00');
-      await expect(`
-        run: range + { where: t ~ f'before 2001' }
-      `).malloyResultMatches(range, [{n: 'before'}]);
+      const rangeQuery = mkRangeQuery(
+        "f'before 2001'",
+        '2001-01-01 00:00:00',
+        '2002-01-01 00:00:00'
+      );
+      await expect(rangeQuery).malloyResultMatches(db, [{n: 'before'}]);
     });
     test('after y2k', async () => {
-      const range = mkRange('2001-01-01 00:00:00', '2002-01-01 00:00:00');
-      await expect(`
-        run: range + { where: t ~ f'after 2001' }
-      `).malloyResultMatches(range, [{n: 'post-range'}]);
+      const rangeQuery = mkRangeQuery(
+        "f'after 2001'",
+        '2001-01-01 00:00:00',
+        '2002-01-01 00:00:00'
+      );
+      await expect(rangeQuery).malloyResultMatches(db, [{n: 'post-range'}]);
     });
     test('y2k for 1 minute', async () => {
-      const range = mkRange('2001-01-01 00:00:00', '2001-01-01 00:01:00');
-      await expect(`
-        run: range + { where: t ~ f'2001 for 1 minute' }
-      `).malloyResultMatches(range, inRange);
+      const rangeQuery = mkRangeQuery(
+        "f'2001 for 1 minute'",
+        '2001-01-01 00:00:00',
+        '2001-01-01 00:01:00'
+      );
+      await expect(rangeQuery).malloyResultMatches(db, inRange);
     });
     test('y2k for 2 hour', async () => {
-      const range = mkRange('2001-01-01 00:00:00', '2001-01-01 02:00:00');
-      await expect(`
-        run: range + { where: t ~ f'2001 for 2 hour' }
-      `).malloyResultMatches(range, inRange);
+      const rangeQuery = mkRangeQuery(
+        "f'2001 for 2 hour'",
+        '2001-01-01 00:00:00',
+        '2001-01-01 02:00:00'
+      );
+      await expect(rangeQuery).malloyResultMatches(db, inRange);
     });
     test('y2k for 1 day', async () => {
-      const range = mkRange('2001-01-01 00:00:00', '2001-01-02 00:00:00');
-      await expect(`
-        run: range + { where: t ~ f'2001 for 1 day' }
-      `).malloyResultMatches(range, inRange);
+      const rangeQuery = mkRangeQuery(
+        "f'2001 for 1 day'",
+        '2001-01-01 00:00:00',
+        '2001-01-02 00:00:00'
+      );
+      await expect(rangeQuery).malloyResultMatches(db, inRange);
     });
     test('y2k for 1 week', async () => {
-      const range = mkRange('2001-01-01 00:00:00', '2001-01-08 00:00:00');
-      await expect(`
-        run: range + { where: t ~ f'2001 for 1 week' }
-      `).malloyResultMatches(range, inRange);
+      const rangeQuery = mkRangeQuery(
+        "f'2001 for 1 week'",
+        '2001-01-01 00:00:00',
+        '2001-01-08 00:00:00'
+      );
+      await expect(rangeQuery).malloyResultMatches(db, inRange);
     });
     test('y2k for 1 month', async () => {
-      const range = mkRange('2001-01-01 00:00:00', '2001-02-01 00:00:00');
-      await expect(`
-        run: range + { where: t ~ f'2001 for 1 month' }
-      `).malloyResultMatches(range, inRange);
+      const rangeQuery = mkRangeQuery(
+        "f'2001 for 1 month'",
+        '2001-01-01 00:00:00',
+        '2001-02-01 00:00:00'
+      );
+      await expect(rangeQuery).malloyResultMatches(db, inRange);
     });
     test('y2k for 1 quarter', async () => {
-      const range = mkRange('2001-01-01 00:00:00', '2001-04-01 00:00:00');
-      await expect(`
-        run: range + { where: t ~ f'2001 for 1 quarter' }
-      `).malloyResultMatches(range, inRange);
+      const rangeQuery = mkRangeQuery(
+        "f'2001 for 1 quarter'",
+        '2001-01-01 00:00:00',
+        '2001-04-01 00:00:00'
+      );
+      await expect(rangeQuery).malloyResultMatches(db, inRange);
     });
     test('y2k for 1 year', async () => {
-      const range = mkRange('2001-01-01 00:00:00', '2002-01-01 00:00:00');
-      await expect(`
-        run: range + { where: t ~ f'2001 for 1 year' }
-      `).malloyResultMatches(range, inRange);
+      const rangeQuery = mkRangeQuery(
+        "f'2001 for 1 year'",
+        '2001-01-01 00:00:00',
+        '2002-01-01 00:00:00'
+      );
+      await expect(rangeQuery).malloyResultMatches(db, inRange);
     });
     test('null', async () => {
-      const range = mkRange('2001-01-01 00:00:00', '2002-01-01 00:00:00');
-      await expect(`
-        run: range + { where: t ~ f'null' }
-      `).malloyResultMatches(range, [{n: 'z-null'}]);
+      const rangeQuery = mkRangeQuery(
+        "f'null'",
+        '2001-01-01 00:00:00',
+        '2002-01-01 00:00:00'
+      );
+      await expect(rangeQuery).malloyResultMatches(db, [{n: 'z-null'}]);
     });
     test('not null', async () => {
-      const range = mkRange('2001-01-01 00:00:00', '2002-01-01 00:00:00');
-      await expect(`
-        run: range + { where: t ~ f'not null'; order_by: n }
-      `).malloyResultMatches(range, [
+      const rangeQuery = mkRangeQuery(
+        "f'not null'",
+        '2001-01-01 00:00:00',
+        '2002-01-01 00:00:00'
+      );
+      await expect(rangeQuery).malloyResultMatches(db, [
         {n: 'before'},
         {n: 'first'},
         {n: 'last'},
@@ -636,11 +696,12 @@ describe.each(runtimes.runtimeList)('filter expressions %s', (dbName, db) => {
       ]);
     });
     test('empty temporal filter', async () => {
-      const range = mkRange('2001-01-01 00:00:00', '2002-01-01 00:00:00');
-      await expect(`
-        # test.verbose
-        run: range + { where: t ~ f''; order_by: n }
-      `).malloyResultMatches(range, [
+      const rangeQuery = mkRangeQuery(
+        "f''",
+        '2001-01-01 00:00:00',
+        '2002-01-01 00:00:00'
+      );
+      await expect(rangeQuery).malloyResultMatches(db, [
         {n: 'before'},
         {n: 'first'},
         {n: 'last'},
@@ -649,46 +710,60 @@ describe.each(runtimes.runtimeList)('filter expressions %s', (dbName, db) => {
       ]);
     });
     test('year literal', async () => {
-      const range = mkRange('2001-01-01 00:00:00', '2002-01-01 00:00:00');
-      await expect(`
-        run: range + { where: t ~ f'2001' }
-      `).malloyResultMatches(range, inRange);
+      const rangeQuery = mkRangeQuery(
+        "f'2001'",
+        '2001-01-01 00:00:00',
+        '2002-01-01 00:00:00'
+      );
+      await expect(rangeQuery).malloyResultMatches(db, inRange);
     });
     test('not month literal', async () => {
-      const range = mkRange('2001-06-01 00:00:00', '2001-07-01 00:00:00');
-      await expect(`
-        run: range + { where: t ~ f'not 2001-06' }
-      `).malloyResultMatches(range, notInRange);
+      const rangeQuery = mkRangeQuery(
+        "f'not 2001-06'",
+        '2001-06-01 00:00:00',
+        '2001-07-01 00:00:00'
+      );
+      await expect(rangeQuery).malloyResultMatches(db, notInRange);
     });
     test('day literal', async () => {
-      const range = mkRange('2001-06-15 00:00:00', '2001-06-16 00:00:00');
-      await expect(`
-        run: range + { where: t ~ f'2001-06-15' }
-      `).malloyResultMatches(range, inRange);
+      const rangeQuery = mkRangeQuery(
+        "f'2001-06-15'",
+        '2001-06-15 00:00:00',
+        '2001-06-16 00:00:00'
+      );
+      await expect(rangeQuery).malloyResultMatches(db, inRange);
     });
     test('hour literal', async () => {
-      const range = mkRange('2001-02-03 04:00:00', '2001-02-03 05:00:00');
-      await expect(`
-        run: range + { where: t ~ f'2001-02-03 04' }
-      `).malloyResultMatches(range, inRange);
+      const rangeQuery = mkRangeQuery(
+        "f'2001-02-03 04'",
+        '2001-02-03 04:00:00',
+        '2001-02-03 05:00:00'
+      );
+      await expect(rangeQuery).malloyResultMatches(db, inRange);
     });
     test('minute literal', async () => {
-      const range = mkRange('2001-02-03 04:05:00', '2001-02-03 04:06:00');
-      await expect(`
-        run: range + { where: t ~ f'2001-02-03 04:05' }
-      `).malloyResultMatches(range, inRange);
+      const rangeQuery = mkRangeQuery(
+        "f'2001-02-03 04:05'",
+        '2001-02-03 04:05:00',
+        '2001-02-03 04:06:00'
+      );
+      await expect(rangeQuery).malloyResultMatches(db, inRange);
     });
     test('quarter literal', async () => {
-      const range = mkRange('2001-01-01 00:00:00', '2001-04-01 00:00:00');
-      await expect(`
-        run: range + { where: t ~ f'2001-Q1' }
-      `).malloyResultMatches(range, inRange);
+      const rangeQuery = mkRangeQuery(
+        "f'2001-Q1'",
+        '2001-01-01 00:00:00',
+        '2001-04-01 00:00:00'
+      );
+      await expect(rangeQuery).malloyResultMatches(db, inRange);
     });
     test('week literal', async () => {
-      const range = mkRange('2023-01-01 00:00:00', '2023-01-08 00:00:00');
-      await expect(`
-        run: range + { where: t ~ f'2023-01-01-WK' }
-      `).malloyResultMatches(range, inRange);
+      const rangeQuery = mkRangeQuery(
+        "f'2023-01-01-WK'",
+        '2023-01-01 00:00:00',
+        '2023-01-08 00:00:00'
+      );
+      await expect(rangeQuery).malloyResultMatches(db, inRange);
     });
     test('full second literal', async () => {
       const eqtime = mkEqTime('2023-01-01 01:02:03');
@@ -704,163 +779,250 @@ describe.each(runtimes.runtimeList)('filter expressions %s', (dbName, db) => {
     });
     test('today', async () => {
       nowIs('2001-02-03 12:00:00');
-      const range = mkRange('2001-02-03 00:00:00', '2001-02-04 00:00:00');
-      await expect(`
-        run: range + { where: t ~ f'today' }
-      `).malloyResultMatches(range, inRange);
+      const rangeQuery = mkRangeQuery(
+        "f'today'",
+        '2001-02-03 00:00:00',
+        '2001-02-04 00:00:00'
+      );
+      await expect(rangeQuery).malloyResultMatches(db, inRange);
     });
     test('yesterday', async () => {
       nowIs('2001-02-03 12:00:00');
-      const range = mkRange('2001-02-02 00:00:00', '2001-02-03 00:00:00');
-      await expect(`
-        run: range + { where: t ~ f'yesterday' }
-      `).malloyResultMatches(range, inRange);
+      const rangeQuery = mkRangeQuery(
+        "f'yesterday'",
+        '2001-02-02 00:00:00',
+        '2001-02-03 00:00:00'
+      );
+      await expect(rangeQuery).malloyResultMatches(db, inRange);
     });
     test('tomorrow', async () => {
       nowIs('2001-02-03 12:00:00');
-      const range = mkRange('2001-02-04 00:00:00', '2001-02-05 00:00:00');
-      await expect(`
-        run: range + { where: t ~ f'tomorrow' }
-      `).malloyResultMatches(range, inRange);
+      const rangeQuery = mkRangeQuery(
+        "f'tomorrow'",
+        '2001-02-04 00:00:00',
+        '2001-02-05 00:00:00'
+      );
+      await expect(rangeQuery).malloyResultMatches(db, inRange);
     });
     test('this week', async () => {
       nowIs('2023-01-03 00:00:00');
-      const range = mkRange('2023-01-01 00:00:00', '2023-01-08 00:00:00');
-      await expect(`
-        run: range + { where: t ~ f'this week' }
-      `).malloyResultMatches(range, inRange);
+      const rangeQuery = mkRangeQuery(
+        "f'this week'",
+        '2023-01-01 00:00:00',
+        '2023-01-08 00:00:00'
+      );
+      await expect(rangeQuery).malloyResultMatches(db, inRange);
     });
     test('last month', async () => {
       nowIs('2001-02-01 12:00:00');
-      const range = mkRange('2001-01-01 00:00:00', '2001-02-01 00:00:00');
-      await expect(`
-        run: range + { where: t ~ f'last month' }
-      `).malloyResultMatches(range, inRange);
+      const rangeQuery = mkRangeQuery(
+        "f'last month'",
+        '2001-01-01 00:00:00',
+        '2001-02-01 00:00:00'
+      );
+      await expect(rangeQuery).malloyResultMatches(db, inRange);
     });
     test('next quarter', async () => {
       nowIs('2001-01-02 12:00:00');
-      const range = mkRange('2001-04-01 00:00:00', '2001-07-01 00:00:00');
-      await expect(`
-        run: range + { where: t ~ f'next quarter' }
-      `).malloyResultMatches(range, inRange);
+      const rangeQuery = mkRangeQuery(
+        "f'next quarter'",
+        '2001-04-01 00:00:00',
+        '2001-07-01 00:00:00'
+      );
+      await expect(rangeQuery).malloyResultMatches(db, inRange);
     });
     test('this year', async () => {
       nowIs('2001-01-02 12:00:00');
-      const range = mkRange('2001-01-01 00:00:00', '2002-01-01 00:00:00');
-      await expect(`
-        run: range + { where: t ~ f'this year' }
-      `).malloyResultMatches(range, inRange);
+      const rangeQuery = mkRangeQuery(
+        "f'this year'",
+        '2001-01-01 00:00:00',
+        '2002-01-01 00:00:00'
+      );
+      await expect(rangeQuery).malloyResultMatches(db, inRange);
     });
     // 2023-01-01 is a sunday
     test('(last) sunday', async () => {
       nowIs('2023-01-03 00:00:00');
-      const range = mkRange('2023-01-01 00:00:00', '2023-01-02 00:00:00');
-      await expect(`
-        run: range + { where: t ~ f'sunday' }
-      `).malloyResultMatches(range, inRange);
+      const rangeQuery = mkRangeQuery(
+        "f'sunday'",
+        '2023-01-01 00:00:00',
+        '2023-01-02 00:00:00'
+      );
+      await expect(rangeQuery).malloyResultMatches(db, inRange);
     });
     test('last monday', async () => {
       nowIs('2023-01-03 00:00:00');
-      const range = mkRange('2023-01-02 00:00:00', '2023-01-03 00:00:00');
-      await expect(`
-        run: range + { where: t ~ f'last monday' }
-      `).malloyResultMatches(range, inRange);
+      const rangeQuery = mkRangeQuery(
+        "f'last monday'",
+        '2023-01-02 00:00:00',
+        '2023-01-03 00:00:00'
+      );
+      await expect(rangeQuery).malloyResultMatches(db, inRange);
     });
     test('last-tuesday', async () => {
       nowIs('2023-01-03 00:00:00');
-      const range = mkRange('2022-12-27 00:00:00', '2022-12-28 00:00:00');
-      await expect(`
-        run: range + { where: t ~ f'tuesday' }
-      `).malloyResultMatches(range, inRange);
+      const rangeQuery = mkRangeQuery(
+        "f'tuesday'",
+        '2022-12-27 00:00:00',
+        '2022-12-28 00:00:00'
+      );
+      await expect(rangeQuery).malloyResultMatches(db, inRange);
     });
     test('last-wednesday', async () => {
       nowIs('2023-01-03 00:00:00');
-      const range = mkRange('2022-12-28 00:00:00', '2022-12-29 00:00:00');
-      await expect(`
-        run: range + { where: t ~ f'wednesday' }
-      `).malloyResultMatches(range, inRange);
+      const rangeQuery = mkRangeQuery(
+        "f'wednesday'",
+        '2022-12-28 00:00:00',
+        '2022-12-29 00:00:00'
+      );
+      await expect(rangeQuery).malloyResultMatches(db, inRange);
     });
     test('last-thursday', async () => {
       nowIs('2023-01-03 00:00:00');
-      const range = mkRange('2022-12-29 00:00:00', '2022-12-30 00:00:00');
-      await expect(`
-        run: range + { where: t ~ f'thursday' }
-      `).malloyResultMatches(range, inRange);
+      const rangeQuery = mkRangeQuery(
+        "f'thursday'",
+        '2022-12-29 00:00:00',
+        '2022-12-30 00:00:00'
+      );
+      await expect(rangeQuery).malloyResultMatches(db, inRange);
     });
     test('last-friday', async () => {
       nowIs('2023-01-03 00:00:00');
-      const range = mkRange('2022-12-30 00:00:00', '2022-12-31 00:00:00');
-      await expect(`
-        run: range + { where: t ~ f'friday' }
-      `).malloyResultMatches(range, inRange);
+      const rangeQuery = mkRangeQuery(
+        "f'friday'",
+        '2022-12-30 00:00:00',
+        '2022-12-31 00:00:00'
+      );
+      await expect(rangeQuery).malloyResultMatches(db, inRange);
     });
     test('last saturday', async () => {
       nowIs('2023-01-03 00:00:00');
-      const range = mkRange('2022-12-31 00:00:00', '2023-01-01 00:00:00');
-      await expect(`
-        run: range + { where: t ~ f'last saturday' }
-      `).malloyResultMatches(range, inRange);
+      const rangeQuery = mkRangeQuery(
+        "f'last saturday'",
+        '2022-12-31 00:00:00',
+        '2023-01-01 00:00:00'
+      );
+      await expect(rangeQuery).malloyResultMatches(db, inRange);
     });
     test('next sunday', async () => {
       nowIs('2023-01-03 00:00:00');
-      const range = mkRange('2023-01-08 00:00:00', '2023-01-09 00:00:00');
-      await expect(`
-        run: range + { where: t ~ f'next sunday' }
-      `).malloyResultMatches(range, inRange);
+      const rangeQuery = mkRangeQuery(
+        "f'next sunday'",
+        '2023-01-08 00:00:00',
+        '2023-01-09 00:00:00'
+      );
+      await expect(rangeQuery).malloyResultMatches(db, inRange);
     });
     test('next monday', async () => {
       nowIs('2023-01-03 00:00:00');
-      const range = mkRange('2023-01-09 00:00:00', '2023-01-10 00:00:00');
-      await expect(`
-        run: range + { where: t ~ f'next monday' }
-      `).malloyResultMatches(range, inRange);
+      const rangeQuery = mkRangeQuery(
+        "f'next monday'",
+        '2023-01-09 00:00:00',
+        '2023-01-10 00:00:00'
+      );
+      await expect(rangeQuery).malloyResultMatches(db, inRange);
     });
     test('next tuesday', async () => {
       nowIs('2023-01-03 00:00:00');
-      const range = mkRange('2023-01-10 00:00:00', '2023-01-11 00:00:00');
-      await expect(`
-        run: range + { where: t ~ f'next tuesday' }
-      `).malloyResultMatches(range, inRange);
+      const rangeQuery = mkRangeQuery(
+        "f'next tuesday'",
+        '2023-01-10 00:00:00',
+        '2023-01-11 00:00:00'
+      );
+      await expect(rangeQuery).malloyResultMatches(db, inRange);
     });
     test('next wednesday', async () => {
       nowIs('2023-01-03 00:00:00');
-      const range = mkRange('2023-01-04 00:00:00', '2023-01-05 00:00:00');
-      await expect(`
-        run: range + { where: t ~ f'next wednesday' }
-      `).malloyResultMatches(range, inRange);
+      const rangeQuery = mkRangeQuery(
+        "f'next wednesday'",
+        '2023-01-04 00:00:00',
+        '2023-01-05 00:00:00'
+      );
+      await expect(rangeQuery).malloyResultMatches(db, inRange);
     });
     test('next thursday', async () => {
       nowIs('2023-01-03 00:00:00');
-      const range = mkRange('2023-01-05 00:00:00', '2023-01-06 00:00:00');
-      await expect(`
-        run: range + { where: t ~ f'next thursday' }
-      `).malloyResultMatches(range, inRange);
+      const rangeQuery = mkRangeQuery(
+        "f'next thursday'",
+        '2023-01-05 00:00:00',
+        '2023-01-06 00:00:00'
+      );
+      await expect(rangeQuery).malloyResultMatches(db, inRange);
     });
     test('next friday', async () => {
       nowIs('2023-01-03 00:00:00');
-      const range = mkRange('2023-01-06 00:00:00', '2023-01-07 00:00:00');
-      await expect(`
-        run: range + { where: t ~ f'next friday' }
-      `).malloyResultMatches(range, inRange);
+      const rangeQuery = mkRangeQuery(
+        "f'next friday'",
+        '2023-01-06 00:00:00',
+        '2023-01-07 00:00:00'
+      );
+      await expect(rangeQuery).malloyResultMatches(db, inRange);
     });
     test('next saturday', async () => {
       nowIs('2023-01-03 00:00:00');
-      const range = mkRange('2023-01-07 00:00:00', '2023-01-08 00:00:00');
-      await expect(`
-        run: range + { where: t ~ f'next Saturday' }
-      `).malloyResultMatches(range, inRange);
+      const rangeQuery = mkRangeQuery(
+        "f'next Saturday'",
+        '2023-01-07 00:00:00',
+        '2023-01-08 00:00:00'
+      );
+      await expect(rangeQuery).malloyResultMatches(db, inRange);
     });
     test('temporal filters are case insensitive', async () => {
       nowIs('2023-01-03 00:00:00');
-      const range = mkRange('2023-01-04 00:00:00', '2023-01-05 00:00:00');
-      await expect(`
-        run: range + {where: t ~ f'Null Or noT aFter TomoRRow'}`).matchesRows(
-        range,
+      const rangeQuery = mkRangeQuery(
+        "f'Null Or noT aFter TomoRRow'",
+        '2023-01-04 00:00:00',
+        '2023-01-05 00:00:00'
+      );
+      await expect(rangeQuery).matchesRows(
+        db,
         {n: 'before'},
         {n: 'first'},
         {n: 'last'},
         {n: 'z-null'}
       );
     });
+    const tzTesting = dbName !== 'presto' && dbName !== 'trino';
+    describe('query time zone', () => {
+      test.when(tzTesting)('day literal in query time zone', async () => {
+        const rangeQuery = mkRangeQuery(
+          "f'2024-01-01'",
+          '2024-01-01 00:00:00',
+          '2024-01-02 00:00:00',
+          'America/Mexico_City'
+        );
+        await expect(rangeQuery).malloyResultMatches(db, inRange);
+      });
+      test.when(tzTesting)('day literal in query time zone', async () => {
+        nowIs('2024-01-15 00:34:56', 'America/Mexico_City');
+        const rangeQuery = mkRangeQuery(
+          "f'today'",
+          '2024-01-15 00:00:00',
+          '2024-01-16 00:00:00',
+          'America/Mexico_City'
+        );
+        await expect(rangeQuery).malloyResultMatches(db, inRange);
+      });
+      test.when(tzTesting)('day literal in query time zone', async () => {
+        nowIs('2024-01-01 00:00:00', 'America/Mexico_City');
+        const rangeQuery = mkRangeQuery(
+          "f'next wednesday'",
+          '2024-01-03 00:00:00',
+          '2024-01-04 00:00:00',
+          'America/Mexico_City'
+        );
+        await expect(rangeQuery).malloyResultMatches(db, inRange);
+      });
+      test.when(tzTesting)('day literal in query time zone', async () => {
+        const exactTimeModel = mkEqTime('2024-01-15 12:00:00');
+        await expect(`
+          run: eqtime -> {
+            timezone: 'America/Mexico_City'
+            where: t ~ f'2024-01-15 06:00:00'  // 6 AM Mexico City = Noon UTC
+            select: t, n
+          }
+        `).malloyResultMatches(exactTimeModel, {n: 'exact'});
+      });
+    });
   });
 });

package/src/databases/all/nomodel.spec.ts

@@ -57,6 +57,57 @@ function getSplitFunction(db: string) {
   }[db];
 }
 
+function lotsOfNumbersSQLTable(db: string): string | undefined {
+  return {
+    'mysql': `
+    SELECT
+    p0.n
+    + p1.n*2
+    + p2.n * POWER(2,2)
+    + p3.n * POWER(2,3)
+    + p4.n * POWER(2,4)
+    + p5.n * POWER(2,5)
+    + p6.n * POWER(2,6)
+    + p7.n * POWER(2,7)
+    + p8.n * POWER(2,8)
+    + p9.n * POWER(2,9)
+    + p10.n * POWER(2,10)
+    + p11.n * POWER(2,11)
+    + p12.n * POWER(2,12)
+    + p13.n * POWER(2,13)
+    + p14.n * POWER(2,14)
+    + p15.n * POWER(2,15)
+    + p16.n * POWER(2,16)
+    + p17.n * POWER(2,17)
+    + p18.n * POWER(2,18)
+    + p19.n * POWER(2,19)
+    as n
+  FROM
+    (SELECT 0 as n UNION SELECT 1) p0,
+    (SELECT 0 as n UNION SELECT 1) p1,
+    (SELECT 0 as n UNION SELECT 1) p2,
+    (SELECT 0 as n UNION SELECT 1) p3,
+    (SELECT 0 as n UNION SELECT 1) p4,
+    (SELECT 0 as n UNION SELECT 1) p5,
+    (SELECT 0 as n UNION SELECT 1) p6,
+    (SELECT 0 as n UNION SELECT 1) p7,
+    (SELECT 0 as n UNION SELECT 1) p8,
+    (SELECT 0 as n UNION SELECT 1) p9,
+    (SELECT 0 as n UNION SELECT 1) p10,
+    (SELECT 0 as n UNION SELECT 1) p11,
+    (SELECT 0 as n UNION SELECT 1) p12,
+    (SELECT 0 as n UNION SELECT 1) p13,
+    (SELECT 0 as n UNION SELECT 1) p14,
+    (SELECT 0 as n UNION SELECT 1) p15,
+    (SELECT 0 as n UNION SELECT 1) p16,
+    (SELECT 0 as n UNION SELECT 1) p17,
+    (SELECT 0 as n UNION SELECT 1) p18,
+    (SELECT 0 as n UNION SELECT 1) p19
+    `,
+    'duckdb': 'SELECT UNNEST(GENERATE_SERIES(0,1048575,1)) as n',
+  }[db];
+}
+
 afterAll(async () => {
   await runtimes.closeAll();
 });
@@ -64,6 +115,25 @@ afterAll(async () => {
 runtimes.runtimeMap.forEach((runtime, databaseName) => {
   const q = runtime.getQuoter();
 
+  const lotsSQL = lotsOfNumbersSQLTable(databaseName);
+  it.when(lotsSQL !== undefined)(
+    `big symmetric sum - ${databaseName}`,
+    async () => {
+      await expect(`
+      source: lots_of_numbers is ${databaseName}.sql(""" ${lotsSQL} """) extend {
+        measure:
+          total_n is n.sum()
+      }
+      query: two_rows is ${databaseName}.table('malloytest.state_facts') -> {select: state;  limit: 2}
+      source: b is two_rows extend {
+        join_cross: lots_of_numbers
+      }
+      run: b -> {
+        aggregate: lots_of_numbers.total_n
+      }
+    `).malloyResultMatches(runtime, {total_n: 549755289600});
+    }
+  );
   // Issue: #1284
   it(`parenthesize output field values - ${databaseName}`, async () => {
     await expect(`
@@ -278,23 +348,27 @@ runtimes.runtimeMap.forEach((runtime, databaseName) => {
     await expect(`
       source: a is ${databaseName}.table('malloytest.airports') extend {
         primary_key: code
-        dimension: big_elevation is elevation * 100000
+        dimension:
+          big_elevation is elevation * 100000.0
+          little_elevation is elevation / 100000.0
         measure:
           total_elevation is elevation.sum()
+          total_little_elevation is round(little_elevation.sum(),4)
           average_elevation is floor(elevation.avg())
-          total_big_elevation is big_elevation.sum()
+          total_big_elevation is round(big_elevation.sum(),0)     // mysql is weird
           average_big_elevation is floor(big_elevation.avg())
       }
       query: two_rows is ${databaseName}.table('malloytest.state_facts') -> {select: state;  limit: 2}
       source: b is two_rows extend {
-        join_cross: a on 1=1
+        join_cross: a
       }
 
-      run: b -> {aggregate: a.total_elevation, a.average_elevation, a.total_big_elevation, a.average_big_elevation}
+      run: b -> {aggregate: a.total_elevation, a.total_little_elevation, a.average_elevation, a.total_big_elevation, a.average_big_elevation}
       // run: two_rows
 
     `).malloyResultMatches(runtime, {
       total_elevation: 22629146,
+      total_little_elevation: 226.2915,
       average_elevation: 1143,
       total_big_elevation: 2262914600000,
       average_big_elevation: 114329035,