@malloydata/malloy-tests 0.0.323 → 0.0.324

package/package.json

@@ -21,22 +21,22 @@
   },
   "dependencies": {
     "@jest/globals": "^29.4.3",
-    "@malloydata/db-bigquery": "0.0.323",
-    "@malloydata/db-duckdb": "0.0.323",
-    "@malloydata/db-postgres": "0.0.323",
-    "@malloydata/db-snowflake": "0.0.323",
-    "@malloydata/db-trino": "0.0.323",
-    "@malloydata/malloy": "0.0.323",
-    "@malloydata/malloy-tag": "0.0.323",
-    "@malloydata/render": "0.0.323",
+    "@malloydata/db-bigquery": "0.0.324",
+    "@malloydata/db-duckdb": "0.0.324",
+    "@malloydata/db-postgres": "0.0.324",
+    "@malloydata/db-snowflake": "0.0.324",
+    "@malloydata/db-trino": "0.0.324",
+    "@malloydata/malloy": "0.0.324",
+    "@malloydata/malloy-tag": "0.0.324",
+    "@malloydata/render": "0.0.324",
     "events": "^3.3.0",
     "jsdom": "^22.1.0",
-    "luxon": "^2.4.0",
+    "luxon": "^3.5.0",
     "madge": "^6.0.0"
   },
   "devDependencies": {
     "@types/jsdom": "^21.1.1",
-    "@types/luxon": "^2.4.0"
+    "@types/luxon": "^3.5.0"
   },
-  "version": "0.0.323"
+  "version": "0.0.324"
 }

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

@@ -9,6 +9,7 @@ import {RuntimeList, allDatabases} from '../../runtimes';
 import '../../util/db-jest-matchers';
 import {databasesFromEnvironmentOr} from '../../util';
 import {DateTime as LuxonDateTime} from 'luxon';
+import {Dialect} from '@malloydata/malloy';
 
 const runtimes = new RuntimeList(databasesFromEnvironmentOr(allDatabases));
 
@@ -491,17 +492,25 @@ describe.each(runtimes.runtimeList)('filter expressions %s', (dbName, db) => {
 
   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);
+      const node = Dialect.makeTimeLiteralNode(
+        db.dialect,
+        timeStr,
+        undefined,
+        undefined,
+        'timestamp'
+      );
+      return db.dialect.exprToSQL({}, node) || '';
     }
     function lit(t: string, type: 'timestamp' | 'date'): string {
-      const typeDef: {type: 'timestamp' | 'date'} = {type};
-      const node: {node: 'timeLiteral'} = {node: 'timeLiteral'};
-      const n = {...node, typeDef, literal: t};
-      return db.dialect.sqlLiteralTime({}, n);
+      const node = Dialect.makeTimeLiteralNode(
+        db.dialect,
+        t,
+        undefined,
+        undefined,
+        type
+      );
+      return db.dialect.exprToSQL({}, node) || '';
     }
 
     const fTimestamp = 'yyyy-LL-dd HH:mm:ss';
@@ -1050,9 +1059,9 @@ describe.each(runtimes.runtimeList)('filter expressions %s', (dbName, db) => {
         {n: 'z-null'}
       );
     });
-    const tzTesting = dbName !== 'presto' && dbName !== 'trino';
+    const tzTesting = true;
     describe('query time zone', () => {
-      test.when(tzTesting)('day literal in query time zone', async () => {
+      test.when(tzTesting)('date literal in query time zone', async () => {
         const rangeQuery = mkRangeQuery(
           "f'2024-01-01'",
           '2024-01-01 00:00:00',
@@ -1061,26 +1070,32 @@ describe.each(runtimes.runtimeList)('filter expressions %s', (dbName, db) => {
         );
         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)(
+        'timestamp literal today 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)(
+        'timestamp literal next week 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(`

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

@@ -25,6 +25,7 @@
 import {RuntimeList, allDatabases} from '../../runtimes';
 import {databasesFromEnvironmentOr} from '../../util';
 import '../../util/db-jest-matchers';
+import {Dialect} from '@malloydata/malloy';
 
 const runtimes = new RuntimeList(databasesFromEnvironmentOr(allDatabases));
 
@@ -277,33 +278,33 @@ describe.each(runtimes.runtimeList)('%s', (databaseName, runtime) => {
         ]);
       }
     );
-    const y2020 = runtime.dialect.sqlLiteralTime(
-      {},
-      {
-        node: 'timeLiteral',
-        literal: '2020-01-01 00:00:00',
-        typeDef: {type: 'timestamp'},
-      }
+    const y2020Node = Dialect.makeTimeLiteralNode(
+      runtime.dialect,
+      '2020-01-01 00:00:00',
+      undefined,
+      undefined,
+      'timestamp'
     );
+    const y2020 = runtime.dialect.exprToSQL({}, y2020Node) || '';
     const d2020 = new Date('2020-01-01 00:00:00Z');
     const d2022 = new Date('2022-01-01 00:00:00Z');
     const d2025 = new Date('2025-01-01 00:00:00Z');
-    const y2025 = runtime.dialect.sqlLiteralTime(
-      {},
-      {
-        node: 'timeLiteral',
-        literal: '2025-01-01 00:00:00',
-        typeDef: {type: 'timestamp'},
-      }
+    const y2025Node = Dialect.makeTimeLiteralNode(
+      runtime.dialect,
+      '2025-01-01 00:00:00',
+      undefined,
+      undefined,
+      'timestamp'
     );
-    const y2022 = runtime.dialect.sqlLiteralTime(
-      {},
-      {
-        node: 'timeLiteral',
-        literal: '2022-01-01 00:00:00',
-        typeDef: {type: 'timestamp'},
-      }
+    const y2025 = runtime.dialect.exprToSQL({}, y2025Node) || '';
+    const y2022Node = Dialect.makeTimeLiteralNode(
+      runtime.dialect,
+      '2022-01-01 00:00:00',
+      undefined,
+      undefined,
+      'timestamp'
     );
+    const y2022 = runtime.dialect.exprToSQL({}, y2022Node) || '';
     const times = `${databaseName}.sql("""
       SELECT ${y2020} as ${q`t`}
       UNION ALL SELECT ${y2025}

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

@@ -32,14 +32,24 @@ import {
 } from '../../util';
 import {DateTime as LuxonDateTime} from 'luxon';
 import {API} from '@malloydata/malloy';
+import {TestSelect} from '../../test-select';
 
 const runtimes = new RuntimeList(databasesFromEnvironmentOr(allDatabases));
 
 // MTOY todo look at this list for timezone problems, I know there are some
 describe.each(runtimes.runtimeList)('%s date and time', (dbName, runtime) => {
-  const q = runtime.getQuoter();
-
-  const timeSQL = `SELECT DATE '2021-02-24' as ${q`t_date`}, TIMESTAMP '2021-02-24 03:05:06' as ${q`t_timestamp`} `;
+  const ts = new TestSelect(runtime.dialect);
+  const timestamptz = runtime.dialect.hasTimestamptz;
+  const timeSchema = {
+    t_date: ts.mk_date('2021-02-24'),
+    t_timestamp: ts.mk_timestamp('2021-02-24 03:05:06'),
+  };
+  if (timestamptz) {
+    timeSchema['t_timestamptz'] = ts.mk_timestamptz(
+      '2021-02-24 03:05:06 [UTC]'
+    );
+  }
+  const timeSQL = ts.generate(timeSchema);
   const sqlEq = mkSqlEqWith(runtime, dbName, {sql: timeSQL});
 
   describe('interval measurement', () => {
@@ -179,6 +189,14 @@ describe.each(runtimes.runtimeList)('%s date and time', (dbName, runtime) => {
       expect(await eq).isSqlEq();
     });
 
+    test.when(timestamptz)('trunc timestamptz day', async () => {
+      await expect(`
+          run: ${dbName}.sql("""${timeSQL}""") -> {
+            select: result is t_timestamptz.day
+          }
+        `).malloyResultMatches(runtime, {result: '2021-02-24 00:00:00Z'});
+    });
+
     test('trunc week', async () => {
       const eq = sqlEq('t_timestamp.week', '@2021-02-21 00:00:00');
       expect(await eq).isSqlEq();
@@ -247,6 +265,24 @@ describe.each(runtimes.runtimeList)('%s date and time', (dbName, runtime) => {
       expect(await eq).isSqlEq();
     });
   });
+
+  test.when(runtime.dialect.hasTimestamptz)(
+    'extract from timestamptz without query timezone',
+    async () => {
+      // TIMESTAMPTZ representing midnight UTC
+      // Without query timezone, extract should happen in UTC (or stored tz for Trino)
+      // Expected: hour = 0, day = 20
+      await expect(
+        `run: ${dbName}.sql("SELECT 1 as x") -> {
+          extend: { dimension: utc_tstz is @2020-02-20 00:00:00[UTC]::timestamptz }
+          select:
+            utc_hour is hour(utc_tstz)
+            utc_day is day(utc_tstz)
+        }`
+      ).malloyResultMatches(runtime, {utc_hour: 0, utc_day: 20});
+    }
+  );
+
   describe('date truncation', () => {
     test('date trunc day', async () => {
       const eq = sqlEq('t_date.day', '@2021-02-24');
@@ -473,9 +509,7 @@ describe.each(runtimes.runtimeList)('%s date and time', (dbName, runtime) => {
     });
   });
 
-  test.when(
-    !brokenIn('trino', dbName) && !brokenIn('presto', dbName) /* mtoy */
-  )('dependant join dialect fragments', async () => {
+  test('dependant join dialect fragments', async () => {
     await expect(`
       source: timeData is ${dbName}.sql("""${timeSQL}""")
       run: timeData -> {
@@ -631,9 +665,7 @@ const utc_2020 = LuxonDateTime.fromObject(
 );
 
 describe.each(runtimes.runtimeList)('%s: tz literals', (dbName, runtime) => {
-  test.when(
-    !brokenIn('trino', dbName) && !brokenIn('presto', dbName) /* mtoy */
-  )(`${dbName} - default timezone is UTC`, async () => {
+  test(`${dbName} - default timezone is UTC`, async () => {
     // this makes sure that the tests which use the test timezome are actually
     // testing something ... file this under "abundance of caution". It
     // really tests nothing, but I feel calmer with this here.
@@ -650,9 +682,7 @@ describe.each(runtimes.runtimeList)('%s: tz literals', (dbName, runtime) => {
     expect(have.valueOf()).toEqual(utc_2020.valueOf());
   });
 
-  test.when(
-    !brokenIn('trino', dbName) && !brokenIn('presto', dbName) /* mtoy */
-  )('literal with zone name', async () => {
+  test('literal with zone name', async () => {
     const query = runtime.loadQuery(
       `
         run: ${dbName}.sql("SELECT 1 as one") -> {
@@ -668,10 +698,12 @@ describe.each(runtimes.runtimeList)('%s: tz literals', (dbName, runtime) => {
 });
 
 describe.each(runtimes.runtimeList)('%s: query tz', (dbName, runtime) => {
-  const q = runtime.getQuoter();
-  test.when(
-    !brokenIn('trino', dbName) && !brokenIn('presto', dbName) /* mtoy */
-  )('literal timestamps', async () => {
+  const ts = new TestSelect(runtime.dialect);
+  const selectMidnight = `"""${ts.generate({
+    utc_midnight_ts: ts.mk_timestamp('2020-02-20 00:00:00'),
+    date_2020: ts.mk_date('2020-02-20'),
+  })}"""`;
+  test('literal timestamps', async () => {
     const query = runtime.loadQuery(
       `
         run: ${dbName}.sql("SELECT 1 as one") -> {
@@ -698,24 +730,37 @@ describe.each(runtimes.runtimeList)('%s: query tz', (dbName, runtime) => {
     ).malloyResultMatches(runtime, {mex_midnight: 18, mex_day: 19});
   });
 
-  test.when(
-    !brokenIn('trino', dbName) && !brokenIn('presto', dbName) /* mtoy */
-  )('truncate day', async () => {
+  test.when(runtime.dialect.hasTimestamptz)(
+    'extract from timestamptz with query timezone',
+    async () => {
+      // TIMESTAMPTZ representing midnight UTC
+      // With query timezone America/Mexico_City (-06:00), midnight UTC = 6pm Feb 19
+      // Expected: hour = 18, day = 19
+      await expect(
+        `run: ${dbName}.sql("SELECT 1 as x") -> {
+          timezone: '${zone}'
+          extend: { dimension: utc_tstz is @2020-02-20 00:00:00[UTC]::timestamptz }
+          select:
+            mex_hour is hour(utc_tstz)
+            mex_day is day(utc_tstz)
+        }`
+      ).malloyResultMatches(runtime, {mex_hour: 18, mex_day: 19});
+    }
+  );
+
+  test('truncate day', async () => {
     // At midnight in london it the 19th in Mexico, so that truncates to
     // midnight on the 19th
     const mex_19 = LuxonDateTime.fromISO('2020-02-19T00:00:00', {zone});
     await expect(
-      `run: ${dbName}.sql("SELECT 1 as x") -> {
+      `run: ${dbName}.sql(${selectMidnight}) -> {
         timezone: '${zone}'
-        extend: { dimension: utc_midnight is @2020-02-20 00:00:00[UTC] }
-        select: mex_day is utc_midnight.day
+        select: mex_day is utc_midnight_ts.day
       }`
     ).malloyResultMatches(runtime, {mex_day: mex_19.toJSDate()});
   });
 
-  test.when(
-    !brokenIn('trino', dbName) && !brokenIn('presto', dbName) /* mtoy */
-  )('truncate week', async () => {
+  test('truncate week', async () => {
     // the 19th in mexico is a wednesday, so trunc to the 15th
     const mex_19 = LuxonDateTime.fromISO('2020-02-19T00:00:00', {zone});
     // Find the sunday before then
@@ -729,30 +774,53 @@ describe.each(runtimes.runtimeList)('%s: query tz', (dbName, runtime) => {
     ).malloyResultMatches(runtime, {mex_week: mex_sunday.toJSDate()});
   });
 
-  test.when(
-    !brokenIn('trino', dbName) && !brokenIn('presto', dbName) /* mtoy */
-  )('cast timestamp to date', async () => {
-    // At midnight in london it is the 19th in Mexico, so when we cast that
-    // to a date, it should be the 19th.
+  test('cast timestamp to date', async () => {
     await expect(
-      `run: ${dbName}.sql("SELECT 1 as x") -> {
+      `run: ${dbName}.sql(${selectMidnight}) -> {
         timezone: '${zone}'
-        extend: { dimension: utc_midnight is @2020-02-20 00:00:00[UTC] }
-        select: mex_day is day(utc_midnight::date)
+        select: mex_date is utc_midnight_ts::date
       }`
-    ).malloyResultMatches(runtime, {mex_day: 19});
+    ).malloyResultMatches(runtime, {mex_date: '2020-02-19'});
   });
-
-  test.when(
-    !brokenIn('trino', dbName) && !brokenIn('presto', dbName) /* mtoy */
-  )('cast date to timestamp', async () => {
+  test.when(runtime.dialect.hasTimestamptz)(
+    'cast timestamptz to date',
+    async () => {
+      await expect(
+        `run: ${dbName}.sql("SELECT 1 as x") -> {
+          timezone: '${zone}'
+          extend: { dimension: utc_tstz is @2020-02-20 00:00:00[UTC]::timestamptz }
+          select: mex_date is utc_tstz::date
+        }`
+      ).malloyResultMatches(runtime, {mex_date: '2020-02-19'});
+    }
+  );
+  test('cast date to timestamp', async () => {
     await expect(
-      `run: ${dbName}.sql(""" SELECT DATE '2020-02-20'  AS ${q`mex_20`} """) -> {
+      `run: ${dbName}.sql(${selectMidnight}) -> {
         timezone: '${zone}'
-        select: mex_ts is mex_20::timestamp
+        select: mex_date is date_2020::timestamp
       }`
-    ).malloyResultMatches(runtime, {mex_ts: zone_2020.toJSDate()});
+    ).malloyResultMatches(runtime, {mex_date: zone_2020.toJSDate()});
   });
+  test('return date 2020-02-20', async () => {
+    await expect(
+      `run: ${dbName}.sql(${selectMidnight}) -> {
+        timezone: '${zone}'
+        select: d2020 is date_2020
+      }`
+    ).malloyResultMatches(runtime, {d2020: '2020-02-20'});
+  });
+  test.when(runtime.dialect.hasTimestamptz)(
+    'cast date to timestamptz',
+    async () => {
+      await expect(
+        `run: ${dbName}.sql(${selectMidnight}) -> {
+          timezone: '${zone}'
+          select: mex_date is date_2020::timestamptz
+        }`
+      ).malloyResultMatches(runtime, {mex_date: zone_2020.toJSDate()});
+    }
+  );
 
   // Test for timezone rendering issue with nested queries
   test.when(runtime.supportsNesting)(

package/src/databases/duckdb-all/duckdb.spec.ts

@@ -22,7 +22,7 @@
  */
 
 import {DateTime} from 'luxon';
-import {RuntimeList} from '../../runtimes';
+import {RuntimeList, runtimeFor} from '../../runtimes';
 import '../../util/db-jest-matchers';
 import {describeIfDatabaseAvailable} from '../../util';
 
@@ -118,11 +118,17 @@ describe.each(allDucks.runtimeList)('duckdb:%s', (dbName, runtime) => {
   });
 
   it('supports timezones', async () => {
-    await runtime.connection.runSQL("SET TimeZone='CET'");
-    const result = await runtime.connection.runSQL(
-      "SELECT current_setting('TimeZone')"
-    );
-    expect(result.rows[0]).toEqual({"current_setting('TimeZone')": 'CET'});
+    // Use isolated connection to avoid affecting other tests
+    const isolatedRuntime = runtimeFor(dbName);
+    try {
+      await isolatedRuntime.connection.runSQL("SET TimeZone='CET'");
+      const result = await isolatedRuntime.connection.runSQL(
+        "SELECT current_setting('TimeZone')"
+      );
+      expect(result.rows[0]).toEqual({"current_setting('TimeZone')": 'CET'});
+    } finally {
+      await isolatedRuntime.connection.close();
+    }
   });
 
   it('supports varchars with parameters', async () => {

package/src/databases/presto-trino/presto-trino.spec.ts

@@ -115,7 +115,7 @@ describe.each(runtimes.runtimeList)(
     });
 
     it(`runs the date_parse function - ${databaseName}`, async () => {
-      const expected = Date.parse('15 Sep 2024 00:00:00 UTC');
+      const expected = '2024-09-15T00:00:00Z';
 
       await expect(`run: ${databaseName}.sql("SELECT 1 as n") -> {
       select: x is date_parse('2024-09-15', '%Y-%m-%d')::date

package/src/test-select.ts

@@ -265,7 +265,7 @@ export class TestSelect {
 
     return {
       expr: {
-        node: 'timeLiteral',
+        node: 'dateLiteral',
         literal: value,
         typeDef: {type: 'date'},
       },
@@ -294,7 +294,7 @@ export class TestSelect {
 
     return {
       expr: {
-        node: 'timeLiteral',
+        node: 'timestampLiteral',
         literal: value,
         typeDef: {type: 'timestamp'},
       },
@@ -303,6 +303,42 @@ export class TestSelect {
     };
   }
 
+  mk_timestamptz(value: string | null): TypedValue {
+    const malloyType: AtomicTypeDef = {type: 'timestamptz'};
+
+    if (value === null) {
+      const castExpr: TypecastExpr = {
+        node: 'cast',
+        e: nullExpr,
+        dstType: {type: 'timestamptz'},
+        safe: false,
+      };
+
+      return {
+        expr: castExpr,
+        malloyType,
+        needsCast: true,
+      };
+    }
+
+    const match = value.match(/^(.+?)\s*\[(.+?)\]$/);
+    if (!match) {
+      throw new Error(`Invalid timestamptz format: ${value}. Expected format: 'YYYY-MM-DD
+  HH:MM:SS [Timezone]'`);
+    }
+    const [, ts, timezone] = match;
+    return {
+      expr: {
+        node: 'timestamptzLiteral',
+        literal: ts.trim(),
+        typeDef: {type: 'timestamptz'},
+        timezone,
+      },
+      malloyType,
+      needsCast: false,
+    };
+  }
+
   mk_array(values: TestValue[]): TypedValue {
     if (values.length === 0) {
       throw new Error(

package/src/util/db-jest-matchers.ts

@@ -207,8 +207,33 @@ expect.extend({
           }
           const got = result.data.path(...resultPath).value;
           const pGot = JSON.stringify(got);
-          const mustBe = value instanceof Date ? value.getTime() : value;
-          const actuallyGot = got instanceof Date ? got.getTime() : got;
+
+          let mustBe = value;
+          let actuallyGot = got;
+
+          // If the value is a Date this is some sort of temporal column.
+          // If the expected looks like a 'YYYY-MM-DD' value, then expect the
+          // Date to be YYYY-MM-DD 00:00:00Z
+          // When comparing Date values, we use getTime to verify in a safe way
+          // that the correct instant is returned.
+          if (got instanceof Date) {
+            actuallyGot = got.getTime();
+            mustBe = typeof value === 'string' ? new Date(value) : value;
+            if (mustBe instanceof Date) {
+              mustBe = mustBe.getTime();
+            }
+          }
+          // If expected is a date string like 'YYYY-MM-DD', compare as date strings
+          else if (
+            typeof value === 'string' &&
+            /^\d{4}-\d{2}-\d{2}$/.test(value)
+          ) {
+            if (got instanceof Date) {
+              actuallyGot = got.toISOString().split('T')[0];
+            }
+            // mustBe stays as the string value
+          }
+
           if (typeof mustBe === 'number' && typeof actuallyGot !== 'number') {
             fails.push(`${expected} Got: Non Numeric '${pGot}'`);
           } else if (!objectsMatch(actuallyGot, mustBe)) {

package/src/util/db-matcher-support.ts

@@ -11,9 +11,8 @@ import type {
   ModelMaterializer,
   QueryMaterializer,
   LogMessage,
-  Dialect,
 } from '@malloydata/malloy';
-import {API, MalloyError} from '@malloydata/malloy';
+import {API, MalloyError, Dialect} from '@malloydata/malloy';
 import type {Tag} from '@malloydata/malloy-tag';
 
 type JestMatcherResult = {
@@ -130,20 +129,22 @@ function errorLogToString(src: string, msgs: LogMessage[]) {
   return lovely;
 }
 
-type TL = 'timeLiteral';
-
-function lit(d: Dialect, t: string, type: 'timestamp' | 'date'): string {
-  const typeDef: {type: 'timestamp' | 'date'} = {type};
-  const timeLiteral: TL = 'timeLiteral';
-  const n = {
-    node: timeLiteral,
-    typeDef,
-    literal: t,
-  };
-  return d.sqlLiteralTime({}, n);
+function lit(
+  d: Dialect,
+  t: string,
+  type: 'timestamp' | 'timestamptz' | 'date'
+): string {
+  const node = Dialect.makeTimeLiteralNode(d, t, undefined, undefined, type);
+  return d.exprToSQL({}, node) || '';
 }
 
-type SQLDataType = 'string' | 'number' | 'timestamp' | 'date' | 'boolean';
+type SQLDataType =
+  | 'string'
+  | 'number'
+  | 'timestamp'
+  | 'timestamptz'
+  | 'date'
+  | 'boolean';
 type SQLRow = unknown[];
 
 /**
@@ -177,6 +178,8 @@ export function mkSQLSource(
         valStr = 'NULL';
       } else if (schema[colName] === 'timestamp' && typeof val === 'string') {
         valStr = lit(dialect, val, 'timestamp');
+      } else if (schema[colName] === 'timestamptz' && typeof val === 'string') {
+        valStr = lit(dialect, val, 'timestamptz');
       } else if (schema[colName] === 'date' && typeof val === 'string') {
         valStr = lit(dialect, val, 'date');
       }