@malloydata/malloy 0.0.323 → 0.0.324

package/dist/dialect/pg_impl.js

@@ -18,13 +18,17 @@ exports.timeExtractMap = {
  * same implementations for the much of the SQL code generation
  */
 class PostgresBase extends dialect_1.Dialect {
+    constructor() {
+        super(...arguments);
+        this.hasTimestamptz = true;
+    }
     sqlNowExpr() {
         return 'LOCALTIMESTAMP';
     }
     sqlTimeExtractExpr(qi, from) {
         const units = exports.timeExtractMap[from.units] || from.units;
         let extractFrom = from.e.sql;
-        if (malloy_types_1.TD.isTimestamp(from.e.typeDef)) {
+        if (malloy_types_1.TD.isAnyTimestamp(from.e.typeDef)) {
             const tz = (0, dialect_1.qtz)(qi);
             if (tz) {
                 extractFrom = `(${extractFrom}::TIMESTAMPTZ AT TIME ZONE '${tz}')`;
@@ -35,15 +39,32 @@ class PostgresBase extends dialect_1.Dialect {
     }
     sqlCast(qi, cast) {
         const expr = cast.e.sql || '';
-        const { op, srcTypeDef, dstTypeDef, dstSQLType } = this.sqlCastPrep(cast);
+        const { srcTypeDef, dstTypeDef, dstSQLType } = this.sqlCastPrep(cast);
         const tz = (0, dialect_1.qtz)(qi);
-        if (op === 'timestamp::date' && tz) {
-            const tstz = `${expr}::TIMESTAMPTZ`;
-            return `CAST((${tstz}) AT TIME ZONE '${tz}' AS DATE)`;
-        }
-        else if (op === 'date::timestamp' && tz) {
-            return `CAST((${expr})::TIMESTAMP AT TIME ZONE '${tz}' AS TIMESTAMP)`;
+        // Timezone-aware casts when query timezone is set
+        if (tz && srcTypeDef && dstTypeDef) {
+            // TIMESTAMP → DATE: convert via TIMESTAMPTZ to query timezone
+            if (malloy_types_1.TD.isTimestamp(srcTypeDef) && malloy_types_1.TD.isDate(dstTypeDef)) {
+                return `CAST((${expr}::TIMESTAMPTZ) AT TIME ZONE '${tz}' AS DATE)`;
+            }
+            // TIMESTAMPTZ → DATE: convert to query timezone
+            if (malloy_types_1.TD.isTimestamptz(srcTypeDef) && malloy_types_1.TD.isDate(dstTypeDef)) {
+                return `CAST((${expr}) AT TIME ZONE '${tz}' AS DATE)`;
+            }
+            // DATE → TIMESTAMP: interpret date in query timezone, return UTC timestamp
+            if (malloy_types_1.TD.isDate(srcTypeDef) && malloy_types_1.TD.isTimestamp(dstTypeDef)) {
+                return `CAST((${expr})::TIMESTAMP AT TIME ZONE '${tz}' AS TIMESTAMP)`;
+            }
+            // DATE → TIMESTAMPTZ: interpret date in query timezone
+            if (malloy_types_1.TD.isDate(srcTypeDef) && malloy_types_1.TD.isTimestamptz(dstTypeDef)) {
+                return `(${expr})::TIMESTAMP AT TIME ZONE '${tz}'`;
+            }
+            // TIMESTAMPTZ → TIMESTAMP: convert to query timezone (returns TIMESTAMP)
+            if (malloy_types_1.TD.isTimestamptz(srcTypeDef) && malloy_types_1.TD.isTimestamp(dstTypeDef)) {
+                return `(${expr}) AT TIME ZONE '${tz}'`;
+            }
         }
+        // No special handling needed, or no query timezone
         if (!malloy_types_1.TD.eq(srcTypeDef, dstTypeDef)) {
             const castFunc = cast.safe ? 'TRY_CAST' : 'CAST';
             return `${castFunc}(${expr} AS ${dstSQLType})`;
@@ -53,15 +74,18 @@ class PostgresBase extends dialect_1.Dialect {
     sqlRegexpMatch(df) {
         return `${df.kids.expr.sql} ~ ${df.kids.regex.sql}`;
     }
-    sqlLiteralTime(qi, lt) {
-        if (malloy_types_1.TD.isDate(lt.typeDef)) {
-            return `DATE '${lt.literal}'`;
-        }
-        const tz = lt.timezone || (0, dialect_1.qtz)(qi);
+    sqlDateLiteral(_qi, literal) {
+        return `DATE '${literal}'`;
+    }
+    sqlTimestampLiteral(qi, literal, timezone) {
+        const tz = timezone || (0, dialect_1.qtz)(qi);
         if (tz) {
-            return `TIMESTAMPTZ '${lt.literal} ${tz}'::TIMESTAMP`;
+            return `TIMESTAMPTZ '${literal} ${tz}'::TIMESTAMP`;
         }
-        return `TIMESTAMP '${lt.literal}'`;
+        return `TIMESTAMP '${literal}'`;
+    }
+    sqlTimestamptzLiteral(_qi, literal, timezone) {
+        return `TIMESTAMPTZ '${literal} ${timezone}'`;
     }
     sqlLiteralRecord(_lit) {
         throw new Error('Cannot create a record literal for postgres base dialect');
@@ -73,6 +97,46 @@ class PostgresBase extends dialect_1.Dialect {
     sqlMaybeQuoteIdentifier(identifier) {
         return '"' + identifier.replace(/"/g, '""') + '"';
     }
+    sqlConvertToCivilTime(expr, timezone, typeDef) {
+        // PostgreSQL/DuckDB: AT TIME ZONE is polymorphic
+        // For timestamptz (TIMESTAMPTZ): AT TIME ZONE converts to plain TIMESTAMP (civil in timezone)
+        if (typeDef.type === 'timestamptz') {
+            return {
+                sql: `(${expr}) AT TIME ZONE '${timezone}'`,
+                typeDef: { type: 'timestamp' },
+            };
+        }
+        // For plain timestamps: cast to TIMESTAMPTZ (interprets as UTC)
+        // Then AT TIME ZONE converts to plain TIMESTAMP (civil in timezone)
+        return {
+            sql: `(${expr})::TIMESTAMPTZ AT TIME ZONE '${timezone}'`,
+            typeDef: { type: 'timestamp' },
+        };
+    }
+    sqlConvertFromCivilTime(expr, timezone, destTypeDef) {
+        if (destTypeDef.type === 'timestamptz') {
+            return `(${expr}) AT TIME ZONE '${timezone}'`;
+        }
+        return `((${expr}) AT TIME ZONE '${timezone}')::TIMESTAMP`;
+    }
+    sqlTruncate(expr, unit, _typeDef, inCivilTime, _timezone) {
+        // PostgreSQL/DuckDB starts weeks on Monday, Malloy wants Sunday
+        // Add 1 day before truncating, subtract 1 day after
+        let truncated;
+        if (unit === 'week') {
+            truncated = `(DATE_TRUNC('${unit}', (${expr} + INTERVAL '1' DAY)) - INTERVAL '1' DAY)`;
+        }
+        else {
+            truncated = `DATE_TRUNC('${unit}', ${expr})`;
+        }
+        // DATE_TRUNC returns DATE for calendar units (day/week/month/quarter/year)
+        // When in civil time (plain TIMESTAMP), cast DATE back to TIMESTAMP to continue operations
+        const calendarUnits = ['day', 'week', 'month', 'quarter', 'year'];
+        if (inCivilTime && calendarUnits.includes(unit)) {
+            return `(${truncated})::TIMESTAMP`;
+        }
+        return truncated;
+    }
 }
 exports.PostgresBase = PostgresBase;
 //# sourceMappingURL=pg_impl.js.map

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

@@ -44,9 +44,6 @@ export declare class PostgresDialect extends PostgresBase {
     sqlFinalStage(lastStageName: string, _fields: string[]): string;
     sqlSelectAliasAsStruct(alias: string): string;
     sqlCreateTableAsSelect(_tableName: string, _sql: string): string;
-    sqlConvertToCivilTime(expr: string, timezone: string): string;
-    sqlConvertFromCivilTime(expr: string, timezone: string): string;
-    sqlTruncate(expr: string, unit: TimestampUnit, _typeDef: AtomicTypeDef, _inCivilTime: boolean, _timezone?: string): string;
     sqlOffsetTime(expr: string, op: '+' | '-', magnitude: string, unit: TimestampUnit, _typeDef: AtomicTypeDef, _inCivilTime: boolean, _timezone?: string): string;
     sqlCast(qi: QueryInfo, cast: TypecastExpr): string;
     sqlMeasureTimeExpr(df: MeasureTimeExpr): string;
@@ -63,7 +60,7 @@ export declare class PostgresDialect extends PostgresBase {
         [name: string]: DialectFunctionOverloadDef[];
     };
     malloyTypeToSQLType(malloyType: AtomicTypeDef): string;
-    sqlTypeToMalloyType(sqlType: string): BasicAtomicTypeDef;
+    sqlTypeToMalloyType(rawSqlType: string): BasicAtomicTypeDef;
     castToString(expression: string): string;
     concat(...values: string[]): string;
     validateTypeName(sqlType: string): boolean;

package/dist/dialect/postgres/postgres.js

@@ -46,6 +46,7 @@ const inSeconds = {
     'day': 24 * 3600,
     'week': 7 * 24 * 3600,
 };
+// TODO there needs be an audit of this data structure
 const postgresToMalloyTypes = {
     'character varying': { type: 'string' },
     'name': { type: 'string' },
@@ -54,10 +55,10 @@ const postgresToMalloyTypes = {
     'integer': { type: 'number', numberType: 'integer' },
     'bigint': { type: 'number', numberType: 'integer' },
     'double precision': { type: 'number', numberType: 'float' },
-    'timestamp without time zone': { type: 'timestamp' }, // maybe not
+    'timestamp without time zone': { type: 'timestamp' },
+    'timestamp with time zone': { type: 'timestamptz' },
     'oid': { type: 'string' },
     'boolean': { type: 'boolean' },
-    // ARRAY: "string",
     'timestamp': { type: 'timestamp' },
     '"char"': { type: 'string' },
     'character': { type: 'string' },
@@ -209,20 +210,6 @@ class PostgresDialect extends pg_impl_1.PostgresBase {
     sqlCreateTableAsSelect(_tableName, _sql) {
         throw new Error('Not implemented Yet');
     }
-    sqlConvertToCivilTime(expr, timezone) {
-        return `(${expr})::TIMESTAMPTZ AT TIME ZONE '${timezone}'`;
-    }
-    sqlConvertFromCivilTime(expr, timezone) {
-        return `((${expr}) AT TIME ZONE '${timezone}')::TIMESTAMP`;
-    }
-    sqlTruncate(expr, unit, _typeDef, _inCivilTime, _timezone) {
-        // PostgreSQL starts weeks on Monday, Malloy wants Sunday
-        // Add 1 day before truncating, subtract 1 day after
-        if (unit === 'week') {
-            return `(DATE_TRUNC('${unit}', (${expr} + INTERVAL '1' DAY)) - INTERVAL '1' DAY)`;
-        }
-        return `DATE_TRUNC('${unit}', ${expr})`;
-    }
     sqlOffsetTime(expr, op, magnitude, unit, _typeDef, _inCivilTime, _timezone) {
         // Convert quarter/week to supported units
         let offsetUnit = unit;
@@ -343,8 +330,9 @@ class PostgresDialect extends pg_impl_1.PostgresBase {
         }
         return malloyType.type;
     }
-    sqlTypeToMalloyType(sqlType) {
+    sqlTypeToMalloyType(rawSqlType) {
         var _a, _b, _c;
+        const sqlType = rawSqlType.toLowerCase();
         // Remove trailing params
         const baseSqlType = (_b = (_a = sqlType.match(/^([\w\s]+)/)) === null || _a === void 0 ? void 0 : _a.at(0)) !== null && _b !== void 0 ? _b : sqlType;
         return ((_c = postgresToMalloyTypes[baseSqlType.trim().toLowerCase()]) !== null && _c !== void 0 ? _c : {
@@ -380,7 +368,7 @@ class PostgresDialect extends pg_impl_1.PostgresBase {
     sqlTimeExtractExpr(qi, from) {
         const units = pg_impl_1.timeExtractMap[from.units] || from.units;
         let extractFrom = from.e.sql;
-        if (malloy_types_1.TD.isTimestamp(from.e.typeDef)) {
+        if (malloy_types_1.TD.isAnyTimestamp(from.e.typeDef)) {
             const tz = (0, dialect_1.qtz)(qi);
             if (tz) {
                 extractFrom = `(${extractFrom}::TIMESTAMPTZ AT TIME ZONE '${tz}')`;

package/dist/dialect/snowflake/snowflake.d.ts

@@ -1,10 +1,11 @@
-import type { Sampling, AtomicTypeDef, TimeExtractExpr, TypecastExpr, TimeLiteralNode, MeasureTimeExpr, RegexMatchExpr, BasicAtomicTypeDef, ArrayLiteralNode, RecordLiteralNode } from '../../model/malloy_types';
+import type { Sampling, AtomicTypeDef, TimeExtractExpr, TypecastExpr, MeasureTimeExpr, RegexMatchExpr, BasicAtomicTypeDef, TimestampTypeDef, ArrayLiteralNode, RecordLiteralNode } from '../../model/malloy_types';
 import type { DialectFunctionOverloadDef } from '../functions';
 import type { DialectFieldList, FieldReferenceType, QueryInfo } from '../dialect';
 import { Dialect } from '../dialect';
 export declare class SnowflakeDialect extends Dialect {
     name: string;
     experimental: boolean;
+    hasTimestamptz: boolean;
     defaultNumberType: string;
     defaultDecimalType: string;
     udfPrefix: string;
@@ -45,15 +46,20 @@ export declare class SnowflakeDialect extends Dialect {
     sqlSelectAliasAsStruct(alias: string): string;
     sqlMaybeQuoteIdentifier(identifier: string): string;
     sqlCreateTableAsSelect(tableName: string, sql: string): string;
-    sqlConvertToCivilTime(expr: string, timezone: string): string;
-    sqlConvertFromCivilTime(expr: string, timezone: string): string;
+    sqlConvertToCivilTime(expr: string, timezone: string, typeDef: AtomicTypeDef): {
+        sql: string;
+        typeDef: AtomicTypeDef;
+    };
+    sqlConvertFromCivilTime(expr: string, timezone: string, _destTypeDef: TimestampTypeDef): string;
     sqlTruncate(expr: string, unit: string, _typeDef: AtomicTypeDef, _inCivilTime: boolean, _timezone?: string): string;
     sqlOffsetTime(expr: string, op: '+' | '-', magnitude: string, unit: string, typeDef: AtomicTypeDef, _inCivilTime: boolean, _timezone?: string): string;
     sqlTimeExtractExpr(qi: QueryInfo, from: TimeExtractExpr): string;
     private atTz;
     sqlNowExpr(): string;
     sqlCast(qi: QueryInfo, cast: TypecastExpr): string;
-    sqlLiteralTime(qi: QueryInfo, lf: TimeLiteralNode): string;
+    sqlDateLiteral(_qi: QueryInfo, literal: string): string;
+    sqlTimestampLiteral(qi: QueryInfo, literal: string, timezone: string | undefined): string;
+    sqlTimestamptzLiteral(_qi: QueryInfo, literal: string, timezone: string): string;
     sqlMeasureTimeExpr(df: MeasureTimeExpr): string;
     sqlRegexpMatch(compare: RegexMatchExpr): string;
     sqlSampleTable(tableSQL: string, sample: Sampling | undefined): string;

package/dist/dialect/snowflake/snowflake.js

@@ -23,6 +23,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SnowflakeDialect = void 0;
+const luxon_1 = require("luxon");
 const utils_1 = require("../../model/utils");
 const malloy_types_1 = require("../../model/malloy_types");
 const functions_1 = require("../functions");
@@ -68,9 +69,9 @@ const snowflakeToMalloyTypes = {
     'timestampntz': { type: 'timestamp' },
     'timestamp_ntz': { type: 'timestamp' },
     'timestamp without time zone': { type: 'timestamp' },
-    'timestamptz': { type: 'timestamp' },
-    'timestamp_tz': { type: 'timestamp' },
-    'timestamp with time zone': { type: 'timestamp' },
+    'timestamptz': { type: 'timestamptz' },
+    'timestamp_tz': { type: 'timestamptz' },
+    'timestamp with time zone': { type: 'timestamptz' },
     /* timestamp_ltz is not supported in malloy snowflake dialect */
 };
 class SnowflakeDialect extends dialect_1.Dialect {
@@ -78,6 +79,7 @@ class SnowflakeDialect extends dialect_1.Dialect {
         super(...arguments);
         this.name = 'snowflake';
         this.experimental = false;
+        this.hasTimestamptz = true;
         this.defaultNumberType = 'NUMBER';
         this.defaultDecimalType = 'NUMBER';
         this.udfPrefix = '__udf';
@@ -249,11 +251,23 @@ ${(0, utils_1.indent)(sql)}
 );
 `;
     }
-    sqlConvertToCivilTime(expr, timezone) {
-        // 3-arg form: explicitly convert from UTC to specified timezone
-        return `CONVERT_TIMEZONE('UTC', '${timezone}', ${expr})`;
-    }
-    sqlConvertFromCivilTime(expr, timezone) {
+    sqlConvertToCivilTime(expr, timezone, typeDef) {
+        // For timestamptz (TIMESTAMP_TZ): use 2-arg form
+        // Returns TIMESTAMP_TZ with timezone preserved
+        if (typeDef.type === 'timestamptz') {
+            return {
+                sql: `CONVERT_TIMEZONE('${timezone}', ${expr})`,
+                typeDef: { type: 'timestamptz' },
+            };
+        }
+        // For plain timestamps (TIMESTAMP_NTZ): use 3-arg form
+        // Must cast to TIMESTAMP_NTZ first, returns TIMESTAMP_NTZ
+        return {
+            sql: `CONVERT_TIMEZONE('UTC', '${timezone}', (${expr})::TIMESTAMP_NTZ)`,
+            typeDef: { type: 'timestamp' },
+        };
+    }
+    sqlConvertFromCivilTime(expr, timezone, _destTypeDef) {
         // After civil time operations, we have a TIMESTAMP_NTZ in the target timezone
         // Convert from timezone to UTC, returning TIMESTAMP_NTZ
         return `CONVERT_TIMEZONE('${timezone}', 'UTC', (${expr})::TIMESTAMP_NTZ)`;
@@ -261,6 +275,8 @@ ${(0, utils_1.indent)(sql)}
     sqlTruncate(expr, unit, _typeDef, _inCivilTime, _timezone) {
         // Snowflake session is configured with WEEK_START=7 (Sunday)
         // so DATE_TRUNC already truncates to Sunday - no adjustment needed
+        // Unlike PostgreSQL/DuckDB, Snowflake's DATE_TRUNC preserves the input type
+        // (TIMESTAMP_NTZ → TIMESTAMP_NTZ, TIMESTAMP_TZ → TIMESTAMP_TZ)
         return `DATE_TRUNC('${unit}', ${expr})`;
     }
     sqlOffsetTime(expr, op, magnitude, unit, typeDef, _inCivilTime, _timezone) {
@@ -272,7 +288,7 @@ ${(0, utils_1.indent)(sql)}
         const extractUnits = extractionMap[from.units] || from.units;
         let extractFrom = from.e.sql;
         const tz = (0, dialect_1.qtz)(qi);
-        if (tz && malloy_types_1.TD.isTimestamp(from.e.typeDef)) {
+        if (tz && malloy_types_1.TD.isAnyTimestamp(from.e.typeDef)) {
             extractFrom = `CONVERT_TIMEZONE('${tz}', ${extractFrom})`;
         }
         return `EXTRACT(${extractUnits} FROM ${extractFrom})`;
@@ -291,7 +307,7 @@ ${(0, utils_1.indent)(sql)}
     }
     sqlCast(qi, cast) {
         const src = cast.e.sql || '';
-        const { op, srcTypeDef, dstTypeDef, dstSQLType } = this.sqlCastPrep(cast);
+        const { srcTypeDef, dstTypeDef, dstSQLType } = this.sqlCastPrep(cast);
         if (malloy_types_1.TD.eq(srcTypeDef, dstTypeDef)) {
             return src;
         }
@@ -303,35 +319,65 @@ ${(0, utils_1.indent)(sql)}
         refer to: https://docs.snowflake.com/en/sql-reference/functions/try_cast`);
         }
         const tz = (0, dialect_1.qtz)(qi);
-        // casting timestamps and dates
-        if (op === 'timestamp::date') {
-            let castExpr = src;
-            if (tz) {
-                castExpr = `CONVERT_TIMEZONE('${tz}', ${castExpr})`;
+        // Timezone-aware casts when query timezone is set
+        if (tz && srcTypeDef && dstTypeDef) {
+            // TIMESTAMP → DATE: convert to query timezone, then to date
+            if (malloy_types_1.TD.isTimestamp(srcTypeDef) && malloy_types_1.TD.isDate(dstTypeDef)) {
+                return `TO_DATE(CONVERT_TIMEZONE('${tz}', ${src}))`;
+            }
+            // TIMESTAMPTZ → DATE: convert to query timezone, then to date
+            if (malloy_types_1.TD.isTimestamptz(srcTypeDef) && malloy_types_1.TD.isDate(dstTypeDef)) {
+                return `TO_DATE(CONVERT_TIMEZONE('${tz}', ${src}))`;
+            }
+            // DATE → TIMESTAMP: interpret date in query timezone, return UTC timestamp
+            if (malloy_types_1.TD.isDate(srcTypeDef) && malloy_types_1.TD.isTimestamp(dstTypeDef)) {
+                const retExpr = `TO_TIMESTAMP(${src})`;
+                return this.atTz(retExpr, tz);
+            }
+            // DATE → TIMESTAMPTZ: interpret date in query timezone
+            if (malloy_types_1.TD.isDate(srcTypeDef) && malloy_types_1.TD.isTimestamptz(dstTypeDef)) {
+                const retExpr = `TO_TIMESTAMP(${src})`;
+                return this.atTz(retExpr, tz);
+            }
+            // TIMESTAMPTZ → TIMESTAMP: convert to query timezone, get UTC wall clock
+            if (malloy_types_1.TD.isTimestamptz(srcTypeDef) && malloy_types_1.TD.isTimestamp(dstTypeDef)) {
+                return `CONVERT_TIMEZONE('${tz}', ${src})::TIMESTAMP_NTZ`;
+            }
+            // TIMESTAMP → TIMESTAMPTZ: interpret as UTC, convert to TIMESTAMPTZ
+            if (malloy_types_1.TD.isTimestamp(srcTypeDef) && malloy_types_1.TD.isTimestamptz(dstTypeDef)) {
+                return this.atTz(src, tz);
             }
-            return `TO_DATE(${castExpr})`;
-        }
-        else if (op === 'date::timestamp') {
-            const retExpr = `TO_TIMESTAMP(${src})`;
-            return this.atTz(retExpr, tz);
         }
         const castFunc = cast.safe ? 'TRY_CAST' : 'CAST';
         return `${castFunc}(${src} AS ${dstSQLType})`;
     }
-    sqlLiteralTime(qi, lf) {
-        var _a;
-        if (malloy_types_1.TD.isDate(lf.typeDef)) {
-            return `TO_DATE('${lf.literal}')`;
-        }
-        const tz = (0, dialect_1.qtz)(qi);
-        let ret = `'${lf.literal}'::TIMESTAMP_NTZ`;
-        const targetTimeZone = (_a = lf.timezone) !== null && _a !== void 0 ? _a : tz;
-        if (targetTimeZone) {
-            // Interpret the literal as being in targetTimeZone, convert to UTC
-            ret = `CONVERT_TIMEZONE('${targetTimeZone}', 'UTC', ${ret})`;
+    sqlDateLiteral(_qi, literal) {
+        return `TO_DATE('${literal}')`;
+    }
+    sqlTimestampLiteral(qi, literal, timezone) {
+        const tz = timezone || (0, dialect_1.qtz)(qi);
+        let ret = `'${literal}'::TIMESTAMP_NTZ`;
+        if (tz) {
+            // Interpret the literal as being in query timezone, convert to UTC
+            ret = `CONVERT_TIMEZONE('${tz}', 'UTC', ${ret})`;
         }
         return ret;
     }
+    sqlTimestamptzLiteral(_qi, literal, timezone) {
+        // Use TIMESTAMP_TZ_FROM_PARTS to create timestamptz
+        const dt = luxon_1.DateTime.fromFormat(literal, 'yyyy-LL-dd HH:mm:ss');
+        if (!dt.isValid) {
+            throw new Error(`Invalid timestamp literal: ${literal}`);
+        }
+        const year = dt.year;
+        const month = dt.month;
+        const day = dt.day;
+        const hour = dt.hour;
+        const minute = dt.minute;
+        const second = dt.second;
+        const nanosecond = dt.millisecond * 1000000;
+        return `TIMESTAMP_TZ_FROM_PARTS(${year}, ${month}, ${day}, ${hour}, ${minute}, ${second}, ${nanosecond}, '${timezone}')`;
+    }
     sqlMeasureTimeExpr(df) {
         const from = df.kids.left;
         const to = df.kids.right;
@@ -413,6 +459,9 @@ ${(0, utils_1.indent)(sql)}
         else if ((0, malloy_types_1.isBasicArray)(malloyType)) {
             return `ARRAY(${this.malloyTypeToSQLType(malloyType.elementTypeDef)})`;
         }
+        else if (malloyType.type === 'timestamptz') {
+            return 'TIMESTAMP_TZ';
+        }
         return malloyType.type;
     }
     sqlTypeToMalloyType(sqlType) {

package/dist/dialect/standardsql/standardsql.d.ts

@@ -1,4 +1,4 @@
-import type { Sampling, AtomicTypeDef, TimeExtractExpr, TypecastExpr, RegexMatchExpr, TimeLiteralNode, MeasureTimeExpr, BasicAtomicTypeDef, RecordLiteralNode, ArrayLiteralNode, TimestampUnit } from '../../model/malloy_types';
+import type { Sampling, AtomicTypeDef, TimeExtractExpr, TypecastExpr, RegexMatchExpr, MeasureTimeExpr, BasicAtomicTypeDef, RecordLiteralNode, ArrayLiteralNode, TimestampUnit, TimestampTypeDef } from '../../model/malloy_types';
 import type { DialectFunctionOverloadDef } from '../functions';
 import type { DialectFieldList, OrderByRequest, QueryInfo } from '../dialect';
 import { Dialect } from '../dialect';
@@ -51,14 +51,19 @@ export declare class StandardSQLDialect extends Dialect {
     sqlMaybeQuoteIdentifier(identifier: string): string;
     sqlNowExpr(): string;
     sqlTimeExtractExpr(qi: QueryInfo, te: TimeExtractExpr): string;
-    sqlConvertToCivilTime(expr: string, timezone: string): string;
-    sqlConvertFromCivilTime(expr: string, timezone: string): string;
+    sqlConvertToCivilTime(expr: string, timezone: string, _typeDef: AtomicTypeDef): {
+        sql: string;
+        typeDef: AtomicTypeDef;
+    };
+    sqlConvertFromCivilTime(expr: string, timezone: string, _destTypeDef: TimestampTypeDef): string;
     sqlTruncate(expr: string, unit: TimestampUnit, typeDef: AtomicTypeDef, inCivilTime: boolean, timezone?: string): string;
     sqlOffsetTime(expr: string, op: '+' | '-', magnitude: string, unit: TimestampUnit, typeDef: AtomicTypeDef, inCivilTime: boolean, _timezone?: string): string;
     ignoreInProject(fieldName: string): boolean;
     sqlCast(qi: QueryInfo, cast: TypecastExpr): string;
     sqlRegexpMatch(match: RegexMatchExpr): string;
-    sqlLiteralTime(qi: QueryInfo, lit: TimeLiteralNode): string;
+    sqlDateLiteral(_qi: QueryInfo, literal: string): string;
+    sqlTimestampLiteral(qi: QueryInfo, literal: string, timezone: string | undefined): string;
+    sqlTimestamptzLiteral(_qi: QueryInfo, _literal: string, _timezone: string): string;
     sqlMeasureTimeExpr(measure: MeasureTimeExpr): string;
     sqlSampleTable(tableSQL: string, sample: Sampling | undefined): string;
     sqlLiteralString(literal: string): string;

package/dist/dialect/standardsql/standardsql.js

@@ -108,7 +108,7 @@ class StandardSQLDialect extends dialect_1.Dialect {
         const calendarUnits = ['day', 'week', 'month', 'quarter', 'year'];
         const isCalendarTruncate = truncateTo !== undefined && calendarUnits.includes(truncateTo);
         const isCalendarOffset = offsetUnit !== undefined && calendarUnits.includes(offsetUnit);
-        const needed = malloy_types_1.TD.isTimestamp(typeDef) && (isCalendarTruncate || isCalendarOffset);
+        const needed = malloy_types_1.TD.isAnyTimestamp(typeDef) && (isCalendarTruncate || isCalendarOffset);
         const tz = needed ? qtz(qi) || 'UTC' : undefined;
         return { needed, tz };
     }
@@ -222,14 +222,18 @@ ${(0, utils_1.indent)(sql)}
     }
     sqlTimeExtractExpr(qi, te) {
         const extractTo = extractMap[te.units] || te.units;
-        const tz = malloy_types_1.TD.isTimestamp(te.e.typeDef) && qtz(qi);
+        const tz = malloy_types_1.TD.isAnyTimestamp(te.e.typeDef) && qtz(qi);
         const tzAdd = tz ? ` AT TIME ZONE '${tz}'` : '';
         return `EXTRACT(${extractTo} FROM ${te.e.sql}${tzAdd})`;
     }
-    sqlConvertToCivilTime(expr, timezone) {
-        return `DATETIME(${expr}, '${timezone}')`;
+    sqlConvertToCivilTime(expr, timezone, _typeDef) {
+        // BigQuery has no timestamptz type, so typeDef.timestamptz will never be true
+        return {
+            sql: `DATETIME(${expr}, '${timezone}')`,
+            typeDef: { type: 'timestamp' },
+        };
     }
-    sqlConvertFromCivilTime(expr, timezone) {
+    sqlConvertFromCivilTime(expr, timezone, _destTypeDef) {
         return `TIMESTAMP(${expr}, '${timezone}')`;
     }
     sqlTruncate(expr, unit, typeDef, inCivilTime, timezone) {
@@ -283,21 +287,19 @@ ${(0, utils_1.indent)(sql)}
     sqlRegexpMatch(match) {
         return `REGEXP_CONTAINS(${match.kids.expr.sql},${match.kids.regex.sql})`;
     }
-    sqlLiteralTime(qi, lit) {
-        if (malloy_types_1.TD.isDate(lit.typeDef)) {
-            return `DATE('${lit.literal}')`;
-        }
-        else if (malloy_types_1.TD.isTimestamp(lit.typeDef)) {
-            let timestampArgs = `'${lit.literal}'`;
-            const tz = lit.timezone || qtz(qi);
-            if (tz && tz !== 'UTC') {
-                timestampArgs += `,'${tz}'`;
-            }
-            return `TIMESTAMP(${timestampArgs})`;
-        }
-        else {
-            throw new Error(`Unsupported Literal time format ${lit.typeDef}`);
+    sqlDateLiteral(_qi, literal) {
+        return `DATE('${literal}')`;
+    }
+    sqlTimestampLiteral(qi, literal, timezone) {
+        let timestampArgs = `'${literal}'`;
+        const tz = timezone || qtz(qi);
+        if (tz && tz !== 'UTC') {
+            timestampArgs += `,'${tz}'`;
         }
+        return `TIMESTAMP(${timestampArgs})`;
+    }
+    sqlTimestamptzLiteral(_qi, _literal, _timezone) {
+        throw new Error('BigQuery does not support timestamptz');
     }
     sqlMeasureTimeExpr(measure) {
         const measureMap = {

package/dist/dialect/tiny_parser.js

@@ -93,7 +93,7 @@ class TinyParser {
         for (const txt of texts) {
             next = this.getNext();
             expected = txt;
-            if (next.text !== txt) {
+            if (next.text.toUpperCase() !== txt.toUpperCase()) {
                 next = undefined;
                 break;
             }

package/dist/dialect/trino/trino.d.ts

@@ -1,4 +1,4 @@
-import type { Expr, Sampling, AtomicTypeDef, TypecastExpr, RegexMatchExpr, MeasureTimeExpr, TimeLiteralNode, TimeExtractExpr, BasicAtomicTypeDef, RecordLiteralNode } from '../../model/malloy_types';
+import type { Expr, Sampling, AtomicTypeDef, ATimestampTypeDef, TypecastExpr, RegexMatchExpr, MeasureTimeExpr, TimeExtractExpr, BasicAtomicTypeDef, RecordLiteralNode } from '../../model/malloy_types';
 import type { DialectFunctionOverloadDef } from '../functions';
 import type { DialectFieldList, OrderByClauseType, QueryInfo } from '../dialect';
 import { PostgresBase } from '../pg_impl';
@@ -51,8 +51,11 @@ export declare class TrinoDialect extends PostgresBase {
     sqlCreateFunctionCombineLastStage(lastStageName: string, fieldList: DialectFieldList): string;
     sqlSelectAliasAsStruct(alias: string, fieldList: any): string;
     keywords: string[];
-    sqlConvertToCivilTime(expr: string, timezone: string): string;
-    sqlConvertFromCivilTime(expr: string, _timezone: string): string;
+    sqlConvertToCivilTime(expr: string, timezone: string, typeDef: AtomicTypeDef): {
+        sql: string;
+        typeDef: AtomicTypeDef;
+    };
+    sqlConvertFromCivilTime(expr: string, _timezone: string, destTypeDef: ATimestampTypeDef): string;
     sqlTruncate(expr: string, unit: string, _typeDef: AtomicTypeDef, _inCivilTime: boolean, _timezone?: string): string;
     sqlOffsetTime(expr: string, op: '+' | '-', magnitude: string, unit: string, _typeDef: AtomicTypeDef, _inCivilTime: boolean, _timezone?: string): string;
     sqlCast(qi: QueryInfo, cast: TypecastExpr): string;
@@ -74,7 +77,9 @@ export declare class TrinoDialect extends PostgresBase {
     sqlMakeUnnestKey(key: string, rowKey: string): string;
     sqlStringAggDistinct(distinctKey: string, valueSQL: string, separatorSQL: string): string;
     validateTypeName(sqlType: string): boolean;
-    sqlLiteralTime(qi: QueryInfo, lit: TimeLiteralNode): string;
+    sqlDateLiteral(_qi: QueryInfo, literal: string): string;
+    sqlTimestampLiteral(qi: QueryInfo, literal: string, timezone: string | undefined): string;
+    sqlTimestamptzLiteral(_qi: QueryInfo, literal: string, timezone: string): string;
     sqlTimeExtractExpr(qi: QueryInfo, from: TimeExtractExpr): string;
     sqlLiteralRecord(lit: RecordLiteralNode): string;
 }
@@ -83,8 +88,16 @@ export declare class PrestoDialect extends TrinoDialect {
     supportsPipelinesInViews: boolean;
     supportsLeftJoinUnnest: boolean;
     sqlGenerateUUID(): string;
-    sqlLiteralTime(qi: QueryInfo, lit: TimeLiteralNode): string;
-    sqlConvertFromCivilTime(expr: string, _timezone: string): string;
+    sqlDateLiteral(_qi: QueryInfo, literal: string): string;
+    sqlTimestampLiteral(qi: QueryInfo, literal: string, timezone: string | undefined): string;
+    sqlTimestamptzLiteral(_qi: QueryInfo, literal: string, timezone: string): string;
+    sqlConvertToCivilTime(expr: string, timezone: string, _typeDef: AtomicTypeDef): {
+        sql: string;
+        typeDef: AtomicTypeDef;
+    };
+    sqlConvertFromCivilTime(expr: string, _timezone: string, destTypeDef: ATimestampTypeDef): string;
+    sqlCast(qi: QueryInfo, cast: TypecastExpr): string;
+    sqlTimeExtractExpr(qi: QueryInfo, from: TimeExtractExpr): string;
     sqlUnnestAlias(source: string, alias: string, _fieldList: DialectFieldList, needDistinctKey: boolean, isArray: boolean, _isInNestedPipeline: boolean): string;
     getDialectFunctions(): {
         [name: string]: DialectFunctionOverloadDef[];