@malloydata/malloy 0.0.323 → 0.0.325

package/CONTEXT.md

@@ -0,0 +1,57 @@
+# Malloy Core Package
+
+The `malloy` package is the heart of the Malloy language implementation. It contains the compiler, translator, and runtime system that powers Malloy's semantic modeling and query capabilities.
+
+## Package Structure
+
+```
+packages/malloy/
+├── src/
+│   ├── lang/              # Translator: Parse tree → AST → IR (see src/lang/CONTEXT.md)
+│   ├── model/             # Compiler: IR → SQL (see src/model/CONTEXT.md)
+│   ├── dialect/           # Database-specific SQL generation
+│   ├── api/               # Public API interfaces
+│   ├── connection/        # Database connection abstractions
+│   └── malloy.ts          # Main entry point
+```
+
+## Two-Phase Architecture
+
+The Malloy compilation process is split into two distinct phases:
+
+### Phase 1: Translation (src/lang/)
+The translator takes Malloy source code and transforms it into an Intermediate Representation (IR).
+
+**Process:**
+1. ANTLR parser generates parse tree from source code
+2. Parse tree is transformed into Abstract Syntax Tree (AST)
+3. AST is analyzed and transformed into IR
+
+**Key characteristics:**
+- IR is a **serializable data format** (plain objects, not class instances)
+- IR fully describes the semantic model independent of SQL
+- IR can be cached, transmitted, and reused across compilations
+
+For detailed information about the translator, see [src/lang/CONTEXT.md](src/lang/CONTEXT.md).
+
+### Phase 2: Compilation (src/model/)
+The compiler takes IR and generates SQL queries for specific database dialects.
+
+**Process:**
+1. IR is read and analyzed
+2. Query operations are transformed into SQL expressions
+3. Dialect-specific SQL is generated
+4. Metadata is generated for result processing
+
+**Key characteristics:**
+- Produces SQL that can be executed on target database
+- Includes metadata to interpret and render results
+- Dialect-agnostic until final SQL generation step
+
+For detailed information about the compiler, see [src/model/CONTEXT.md](src/model/CONTEXT.md).
+
+## Subsystem Context
+
+For deeper details on specific subsystems:
+- [src/lang/CONTEXT.md](src/lang/CONTEXT.md) - Translator architecture (grammar, AST, IR generation)
+- [src/model/CONTEXT.md](src/model/CONTEXT.md) - Compiler architecture (SQL generation, expression compilation)

package/dist/api/core.js

@@ -101,6 +101,8 @@ function typeDefFromField(type) {
             return { type: 'boolean' };
         case 'timestamp_type':
             return { type: 'timestamp', timeframe: type.timeframe };
+        case 'timestamptz_type':
+            return { type: 'timestamptz', timeframe: type.timeframe };
         case 'date_type':
             return { type: 'date', timeframe: type.timeframe };
         case 'sql_native_type':

package/dist/api/util.js

@@ -15,7 +15,6 @@ exports.nodeToLiteralValue = nodeToLiteralValue;
 exports.mapLogs = mapLogs;
 const malloy_tag_1 = require("@malloydata/malloy-tag");
 const annotation_1 = require("../annotation");
-const model_1 = require("../model");
 const to_stable_1 = require("../to_stable");
 const luxon_1 = require("luxon");
 function wrapLegacyInfoConnection(connection) {
@@ -92,7 +91,8 @@ function mapData(data, schema) {
             return { kind: 'null_cell' };
         }
         else if (field.type.kind === 'date_type' ||
-            field.type.kind === 'timestamp_type') {
+            field.type.kind === 'timestamp_type' ||
+            field.type.kind === 'timestamptz_type') {
             const time_value = valueToDate(value).toISOString();
             if (field.type.kind === 'date_type') {
                 return { kind: 'date_cell', date_value: time_value };
@@ -250,28 +250,20 @@ function nodeToLiteralValue(expr) {
             return { kind: 'boolean_literal', boolean_value: true };
         case 'false':
             return { kind: 'boolean_literal', boolean_value: false };
-        case 'timeLiteral': {
-            if (expr.typeDef.type === 'date') {
-                if (expr.typeDef.timeframe === undefined ||
-                    (0, model_1.isDateUnit)(expr.typeDef.timeframe)) {
-                    return {
-                        kind: 'date_literal',
-                        date_value: expr.literal,
-                        timezone: expr.timezone,
-                        granularity: expr.typeDef.timeframe,
-                    };
-                }
-                return undefined;
-            }
-            else {
-                return {
-                    kind: 'timestamp_literal',
-                    timestamp_value: expr.literal,
-                    timezone: expr.timezone,
-                    granularity: expr.typeDef.timeframe,
-                };
-            }
-        }
+        case 'dateLiteral':
+            return {
+                kind: 'date_literal',
+                date_value: expr.literal,
+                granularity: expr.typeDef.timeframe,
+            };
+        case 'timestampLiteral':
+        case 'timestamptzLiteral':
+            return {
+                kind: 'timestamp_literal',
+                timestamp_value: expr.literal,
+                timezone: expr.timezone,
+                granularity: expr.typeDef.timeframe,
+            };
         default:
             return undefined;
     }

package/dist/dialect/dialect.d.ts

@@ -1,4 +1,4 @@
-import type { Expr, Sampling, AtomicTypeDef, MeasureTimeExpr, TimeExtractExpr, TypecastExpr, RegexMatchExpr, TimeLiteralNode, RecordLiteralNode, ArrayLiteralNode, BasicAtomicTypeDef, OrderBy, TimestampUnit, TimeExpr } from '../model/malloy_types';
+import type { Expr, Sampling, AtomicTypeDef, MeasureTimeExpr, TimeExtractExpr, TypecastExpr, RegexMatchExpr, TimeLiteralExpr, RecordLiteralNode, ArrayLiteralNode, BasicAtomicTypeDef, OrderBy, TimestampUnit, ATimestampTypeDef, TimeExpr, TemporalFieldType } from '../model/malloy_types';
 import type { DialectFunctionOverloadDef } from './functions';
 interface DialectField {
     typeDef: AtomicTypeDef;
@@ -46,6 +46,7 @@ export declare abstract class Dialect {
     cantPartitionWindowFunctionsOnExpressions: boolean;
     supportsPipelinesInViews: boolean;
     supportsArraysInData: boolean;
+    hasTimestamptz: boolean;
     readsNestedData: boolean;
     orderByClause: OrderByClauseType;
     nullMatchesFunctionSignature: boolean;
@@ -61,6 +62,11 @@ export declare abstract class Dialect {
     compoundObjectInSchema: boolean;
     booleanType: BooleanTypeSupport;
     likeEscape: boolean;
+    /**
+     * Create the appropriate time literal IR node based on dialect support.
+     * Static method so it can be called with undefined dialect (e.g., ConstantFieldSpace).
+     */
+    static makeTimeLiteralNode(dialect: Dialect | undefined, literal: string, timezone: string | undefined, units: TimestampUnit | undefined, typ: TemporalFieldType): TimeLiteralExpr;
     abstract getDialectFunctionOverrides(): {
         [name: string]: DialectFunctionOverloadDef[];
     };
@@ -93,38 +99,87 @@ export declare abstract class Dialect {
     abstract sqlNowExpr(): string;
     abstract sqlTimeExtractExpr(qi: QueryInfo, xFrom: TimeExtractExpr): string;
     abstract sqlMeasureTimeExpr(e: MeasureTimeExpr): string;
+    /**
+     * Generate SQL for type casting expressions.
+     *
+     * Most casts are simple: `CAST(expr AS type)` or `TRY_CAST(expr AS type)` for safe casts.
+     *
+     * However, when a query timezone is set, casts between temporal types (date, timestamp, timestamptz)
+     * require special handling to ensure correct timezone semantics:
+     *
+     * **Timezone-Aware Cast Semantics:**
+     *
+     * 1. **TIMESTAMP → DATE**:
+     *    - TIMESTAMP represents UTC wall clock
+     *    - Convert to query timezone, then extract date
+     *    - Example: TIMESTAMP '2020-02-20 00:00:00' with tz 'America/Mexico_City' → '2020-02-19'
+     *
+     * 2. **TIMESTAMPTZ → DATE**:
+     *    - TIMESTAMPTZ represents absolute instant
+     *    - Convert to query timezone, then extract date
+     *    - Example: TIMESTAMPTZ '2020-02-20 00:00:00 UTC' with tz 'America/Mexico_City' → '2020-02-19'
+     *
+     * 3. **DATE → TIMESTAMP**:
+     *    - DATE represents civil date
+     *    - Interpret as midnight in query timezone, return UTC wall clock
+     *    - Example: DATE '2020-02-20' with tz 'America/Mexico_City' → TIMESTAMP '2020-02-20 06:00:00' (UTC)
+     *
+     * 4. **DATE → TIMESTAMPTZ**:
+     *    - DATE represents civil date
+     *    - Interpret as midnight in query timezone, create instant
+     *    - Example: DATE '2020-02-20' with tz 'America/Mexico_City' → instant at 2020-02-20 06:00:00 UTC
+     *
+     * 5. **TIMESTAMPTZ → TIMESTAMP**:
+     *    - TIMESTAMPTZ represents absolute instant
+     *    - Extract wall clock in query timezone, return as TIMESTAMP
+     *    - Example: TIMESTAMPTZ '2020-02-20 00:00:00 UTC' with tz 'America/Mexico_City' → TIMESTAMP '2020-02-19 18:00:00'
+     *
+     * 6. **TIMESTAMP → TIMESTAMPTZ**:
+     *    - TIMESTAMP represents UTC wall clock
+     *    - Interpret as being in query timezone
+     *    - Example: TIMESTAMP '2020-02-20 00:00:00' with tz 'America/Mexico_City' → instant at 2020-02-20 06:00:00 UTC
+     *
+     * **Implementation Notes:**
+     *
+     * - Dialects without timestamptz support (MySQL, BigQuery, StandardSQL) only need cases 1-3
+     * - Without query timezone, most casts are simple `CAST(expr AS type)`
+     *
+     * @param qi - Query info containing timezone and other context
+     * @param cast - The typecast expression to generate SQL for
+     * @returns SQL string for the cast operation
+     */
     abstract sqlCast(qi: QueryInfo, cast: TypecastExpr): string;
     abstract sqlRegexpMatch(df: RegexMatchExpr): string;
     /**
-     * Converts a UTC timestamp expression to civil (local) time in the specified timezone.
-     * Used when performing timezone-aware calendar arithmetic.
+     * Converts a Malloy timestamp to "civil time" for calendar operations in a timezone.
      *
-     * Example outputs:
-     * - BigQuery: `DATETIME(timestamp_expr, 'Europe/Dublin')`
-     * - PostgreSQL: `(timestamp_expr)::TIMESTAMPTZ AT TIME ZONE 'Europe/Dublin'`
-     * - DuckDB: `(timestamp_expr)::TIMESTAMPTZ AT TIME ZONE 'Europe/Dublin'`
-     * - Trino: `timestamp_expr AT TIME ZONE 'Europe/Dublin'`
+     * Each dialect selects its own SQL type to represent civil time (e.g., plain TIMESTAMP,
+     * TIMESTAMP WITH TIME ZONE, or DATETIME). The civil space is where timezone-aware
+     * truncation and interval arithmetic happen. Operations like sqlTruncate and sqlOffsetTime
+     * are aware of the civil space and work correctly within it.
      *
-     * @param expr The SQL expression for the UTC timestamp
-     * @param timezone The target timezone (e.g., 'Europe/Dublin', 'America/Los_Angeles')
-     * @returns SQL expression representing the timestamp in civil (local) time
+     * @param expr The SQL expression for the Malloy timestamp (plain or timestamptz)
+     * @param timezone The target timezone for civil operations
+     * @param typeDef The Malloy type of the input expression
+     * @returns Object with SQL expression and the SQL type it evaluates to (the civil type)
      */
-    abstract sqlConvertToCivilTime(expr: string, timezone: string): string;
+    abstract sqlConvertToCivilTime(expr: string, timezone: string, typeDef: AtomicTypeDef): {
+        sql: string;
+        typeDef: AtomicTypeDef;
+    };
     /**
-     * Converts a civil (local) time expression back to a UTC timestamp.
-     * The inverse of sqlConvertToCivilTime.
+     * Converts from civil time back to a Malloy timestamp type.
      *
-     * Example outputs:
-     * - BigQuery: `TIMESTAMP(datetime_expr, 'Europe/Dublin')`
-     * - PostgreSQL: `((datetime_expr) AT TIME ZONE 'Europe/Dublin')::TIMESTAMP`
-     * - DuckDB: `((datetime_expr) AT TIME ZONE 'Europe/Dublin')::TIMESTAMP`
-     * - Trino: `CAST(at_timezone(timestamptz_expr, 'UTC') AS TIMESTAMP)`
+     * This is the inverse of sqlConvertToCivilTime. Takes a value in the dialect's
+     * civil space and converts it back to either a plain timestamp (UTC) or a
+     * timestamptz, depending on the destination type.
      *
-     * @param expr The SQL expression for the civil time
+     * @param expr The SQL expression in civil time
      * @param timezone The timezone of the civil time
-     * @returns SQL expression representing the UTC timestamp
+     * @param destTypeDef The destination Malloy timestamp type (plain or timestamptz)
+     * @returns SQL expression representing the Malloy timestamp
      */
-    abstract sqlConvertFromCivilTime(expr: string, timezone: string): string;
+    abstract sqlConvertFromCivilTime(expr: string, timezone: string, destTypeDef: ATimestampTypeDef): string;
     /**
      * Truncates a time expression to the specified unit.
      *
@@ -193,6 +248,14 @@ export declare abstract class Dialect {
      * - sqlTruncate: Truncation operation
      * - sqlOffsetTime: Interval arithmetic
      *
+     * OFFSET TIMESTAMP BEHAVIOR:
+     * - Plain timestamps (offset=false): Always return plain TIMESTAMP in UTC
+     * - Offset timestamps (offset=true):
+     *   - Simple path: Operate in native embedded timezone, return TIMESTAMPTZ
+     *   - Civil path: Convert to query timezone (preserving instant), operate there,
+     *     return TIMESTAMPTZ in query timezone via sqlConvertFromCivilTime
+     * - BigQuery/MySQL: No offset timestamp support, this logic never runs
+     *
      * @param baseExpr The time expression to operate on (already compiled, with .sql populated)
      * @param qi Query information including timezone
      * @param truncateTo Optional truncation unit (year, month, day, etc.)
@@ -203,7 +266,34 @@ export declare abstract class Dialect {
         magnitude: string;
         unit: TimestampUnit;
     }): string;
-    abstract sqlLiteralTime(qi: QueryInfo, df: TimeLiteralNode): string;
+    /**
+     * Generate SQL for a DATE literal.
+     * @param literal - The date string in format 'YYYY-MM-DD'
+     * @returns SQL that produces a DATE value
+     */
+    abstract sqlDateLiteral(qi: QueryInfo, literal: string): string;
+    /**
+     * Generate SQL for a plain TIMESTAMP literal (without timezone offset).
+     * @param literal - The timestamp string in format 'YYYY-MM-DD HH:MM:SS'
+     * @param timezone - Optional timezone name (e.g., 'America/Los_Angeles')
+     *   - If undefined: Create plain timestamp literal from the literal string
+     *   - If defined: The literal string represents a civil time in the given timezone.
+     *     Convert it to a plain timestamp (typically by interpreting as timestamptz
+     *     in that timezone, then casting to plain timestamp). This happens when:
+     *     1. A constant with timezone is used (constants don't have dialect context)
+     *     2. A literal with timezone is used in a dialect that doesn't support offset timestamps
+     * @returns SQL that produces a plain TIMESTAMP value
+     */
+    abstract sqlTimestampLiteral(qi: QueryInfo, literal: string, timezone: string | undefined): string;
+    /**
+     * Generate SQL for an offset TIMESTAMP literal (TIMESTAMP WITH TIME ZONE).
+     * Only called for dialects where hasOffsetTimestamp = true.
+     * @param literal - The timestamp string in format 'YYYY-MM-DD HH:MM:SS'
+     * @param timezone - The timezone name (e.g., 'America/Los_Angeles')
+     * @returns SQL that produces a TIMESTAMP WITH TIME ZONE value representing
+     *   the civil time in the specified timezone
+     */
+    abstract sqlTimestamptzLiteral(qi: QueryInfo, literal: string, timezone: string): string;
     abstract sqlLiteralString(literal: string): string;
     abstract sqlLiteralRegexp(literal: string): string;
     abstract sqlLiteralArray(lit: ArrayLiteralNode): string;

package/dist/dialect/dialect.js

@@ -62,6 +62,8 @@ class Dialect {
         this.supportsPipelinesInViews = true;
         // Some dialects don't supporrt arrays (mysql)
         this.supportsArraysInData = true;
+        // Does the dialect support timestamptz (TIMESTAMP WITH TIME ZONE)?
+        this.hasTimestamptz = false;
         // can read some version of ga_sample
         this.readsNestedData = true;
         // ORDER BY 1 DESC
@@ -89,6 +91,58 @@ class Dialect {
         // Like characters are escaped with ESCAPE clause
         this.likeEscape = true;
     }
+    /**
+     * Create the appropriate time literal IR node based on dialect support.
+     * Static method so it can be called with undefined dialect (e.g., ConstantFieldSpace).
+     */
+    static makeTimeLiteralNode(dialect, literal, timezone, units, typ) {
+        var _a;
+        // ConstantFieldSpace.dialectObj() returns undefined, so constants default to false
+        const hasTimestamptz = (_a = dialect === null || dialect === void 0 ? void 0 : dialect.hasTimestamptz) !== null && _a !== void 0 ? _a : false;
+        if (typ === 'date') {
+            return {
+                node: 'dateLiteral',
+                literal,
+                typeDef: {
+                    type: 'date',
+                    timeframe: units !== undefined && (0, malloy_types_1.isDateUnit)(units) ? units : undefined,
+                },
+            };
+        }
+        // typ === 'timestamp'
+        if (timezone && hasTimestamptz) {
+            // Dialect supports timestamptz - create timestamptzLiteral
+            return {
+                node: 'timestamptzLiteral',
+                literal,
+                typeDef: {
+                    type: 'timestamptz',
+                    timeframe: units,
+                },
+                timezone,
+            };
+        }
+        // Plain timestamp (either no timezone, or dialect doesn't support timestamptz)
+        if (timezone) {
+            return {
+                node: 'timestampLiteral',
+                literal,
+                typeDef: {
+                    type: 'timestamp',
+                    timeframe: units,
+                },
+                timezone,
+            };
+        }
+        return {
+            node: 'timestampLiteral',
+            literal,
+            typeDef: {
+                type: 'timestamp',
+                timeframe: units,
+            },
+        };
+    }
     sqlFinalStage(_lastStageName, _fields) {
         throw new Error('Dialect has no final Stage but called Anyway');
     }
@@ -133,7 +187,7 @@ class Dialect {
         const tz = qtz(qi);
         // Timestamps with calendar truncation/offset need civil time computation
         // BUT only if there's actually a timezone to convert to/from
-        const needed = malloy_types_1.TD.isTimestamp(typeDef) &&
+        const needed = malloy_types_1.TD.isAnyTimestamp(typeDef) &&
             (isCalendarTruncate || isCalendarOffset) &&
             tz !== undefined;
         return { needed, tz };
@@ -153,6 +207,14 @@ class Dialect {
      * - sqlTruncate: Truncation operation
      * - sqlOffsetTime: Interval arithmetic
      *
+     * OFFSET TIMESTAMP BEHAVIOR:
+     * - Plain timestamps (offset=false): Always return plain TIMESTAMP in UTC
+     * - Offset timestamps (offset=true):
+     *   - Simple path: Operate in native embedded timezone, return TIMESTAMPTZ
+     *   - Civil path: Convert to query timezone (preserving instant), operate there,
+     *     return TIMESTAMPTZ in query timezone via sqlConvertFromCivilTime
+     * - BigQuery/MySQL: No offset timestamp support, this logic never runs
+     *
      * @param baseExpr The time expression to operate on (already compiled, with .sql populated)
      * @param qi Query information including timezone
      * @param truncateTo Optional truncation unit (year, month, day, etc.)
@@ -160,17 +222,21 @@ class Dialect {
      */
     sqlTruncAndOffset(baseExpr, qi, truncateTo, offset) {
         // Determine if we need to work in civil (local) time
-        const { needed: needsCivil, tz } = this.needsCivilTimeComputation(baseExpr.typeDef, truncateTo, offset === null || offset === void 0 ? void 0 : offset.unit, qi);
-        if (needsCivil && tz) {
-            // Civil time path: convert to local time, operate, convert back to UTC
-            let expr = this.sqlConvertToCivilTime(baseExpr.sql, tz);
-            if (truncateTo) {
-                expr = this.sqlTruncate(expr, truncateTo, baseExpr.typeDef, true, tz);
-            }
-            if (offset) {
-                expr = this.sqlOffsetTime(expr, offset.op, offset.magnitude, offset.unit, baseExpr.typeDef, true, tz);
+        if (malloy_types_1.TD.isAnyTimestamp(baseExpr.typeDef)) {
+            const { needed: needsCivil, tz } = this.needsCivilTimeComputation(baseExpr.typeDef, truncateTo, offset === null || offset === void 0 ? void 0 : offset.unit, qi);
+            if (needsCivil && tz) {
+                // Civil time path: convert to local time, operate, convert back to UTC
+                const civilResult = this.sqlConvertToCivilTime(baseExpr.sql, tz, baseExpr.typeDef);
+                let expr = civilResult.sql;
+                const civilTypeDef = civilResult.typeDef;
+                if (truncateTo) {
+                    expr = this.sqlTruncate(expr, truncateTo, civilTypeDef, true, tz);
+                }
+                if (offset) {
+                    expr = this.sqlOffsetTime(expr, offset.op, offset.magnitude, offset.unit, civilTypeDef, true, tz);
+                }
+                return this.sqlConvertFromCivilTime(expr, tz, baseExpr.typeDef);
             }
-            return this.sqlConvertFromCivilTime(expr, tz);
         }
         // Simple path: no civil time conversion needed
         let sql = baseExpr.sql;
@@ -237,8 +303,12 @@ class Dialect {
                 }
                 return;
             }
-            case 'timeLiteral':
-                return this.sqlLiteralTime(qi, df);
+            case 'dateLiteral':
+                return this.sqlDateLiteral(qi, df.literal);
+            case 'timestampLiteral':
+                return this.sqlTimestampLiteral(qi, df.literal, df.timezone);
+            case 'timestamptzLiteral':
+                return this.sqlTimestamptzLiteral(qi, df.literal, df.timezone);
             case 'stringLiteral':
                 return this.sqlLiteralString(df.literal);
             case 'numberLiteral':

package/dist/dialect/duckdb/duckdb.d.ts

@@ -56,13 +56,10 @@ export declare class DuckDBDialect extends PostgresBase {
     };
     malloyTypeToSQLType(malloyType: AtomicTypeDef): string;
     parseDuckDBType(sqlType: string): AtomicTypeDef;
-    sqlTypeToMalloyType(sqlType: string): BasicAtomicTypeDef;
+    sqlTypeToMalloyType(rawSqlType: string): BasicAtomicTypeDef;
     castToString(expression: string): string;
     concat(...values: string[]): string;
     validateTypeName(sqlType: string): boolean;
-    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;
     sqlRegexpMatch(df: RegexMatchExpr): string;
     sqlMeasureTimeExpr(df: MeasureTimeExpr): string;

package/dist/dialect/duckdb/duckdb.js

@@ -282,6 +282,9 @@ class DuckDBDialect extends pg_impl_1.PostgresBase {
         else if (malloyType.type === 'string') {
             return 'varchar';
         }
+        if (malloyType.type === 'timestamptz') {
+            return 'timestamp with time zone';
+        }
         return malloyType.type;
     }
     parseDuckDBType(sqlType) {
@@ -298,8 +301,12 @@ class DuckDBDialect extends pg_impl_1.PostgresBase {
             }
         }
     }
-    sqlTypeToMalloyType(sqlType) {
+    sqlTypeToMalloyType(rawSqlType) {
         var _a, _b, _c;
+        const sqlType = rawSqlType.toUpperCase();
+        if (sqlType === 'TIMESTAMP WITH TIME ZONE') {
+            return { type: 'timestamptz' };
+        }
         // Remove decimal precision
         const ddbType = sqlType.replace(/^DECIMAL\(\d+,\d+\)/g, 'DECIMAL');
         // Remove trailing params
@@ -323,20 +330,6 @@ class DuckDBDialect extends pg_impl_1.PostgresBase {
         // Brackets:             INT[ ]
         return sqlType.match(/^[A-Za-z\s(),[\]0-9]*$/) !== null;
     }
-    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) {
-        // DuckDB 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) {
         // DuckDB doesn't support INTERVAL '1' WEEK, convert to days
         let offsetUnit = unit;
@@ -412,10 +405,13 @@ class DuckDBTypeParser extends tiny_parser_1.TinyParser {
             baseType = { type: 'number', numberType: 'float' };
         }
         else if (id === 'TIMESTAMP') {
-            if (this.peek().text === 'WITH') {
+            if (this.peek().text.toUpperCase() === 'WITH') {
                 this.nextText('WITH', 'TIME', 'ZONE');
+                baseType = { type: 'timestamptz' };
+            }
+            else {
+                baseType = { type: 'timestamp' };
             }
-            baseType = { type: 'timestamp' };
         }
         else if (duckDBToMalloyTypes[id]) {
             baseType = duckDBToMalloyTypes[id];

package/dist/dialect/mysql/mysql.d.ts

@@ -1,4 +1,4 @@
-import type { Sampling, MeasureTimeExpr, TimeLiteralNode, RegexMatchExpr, TimeExtractExpr, TypecastExpr, BasicAtomicTypeDef, AtomicTypeDef, ArrayLiteralNode, RecordLiteralNode } from '../../model/malloy_types';
+import type { Sampling, MeasureTimeExpr, RegexMatchExpr, TimeExtractExpr, TypecastExpr, BasicAtomicTypeDef, AtomicTypeDef, TimestampTypeDef, ArrayLiteralNode, RecordLiteralNode } from '../../model/malloy_types';
 import type { BooleanTypeSupport, DialectFieldList, FieldReferenceType, OrderByClauseType, QueryInfo } from '../dialect';
 import { Dialect } from '../dialect';
 import type { DialectFunctionOverloadDef } from '../functions';
@@ -56,14 +56,19 @@ export declare class MySQLDialect extends Dialect {
     sqlMaybeQuoteIdentifier(identifier: string): string;
     sqlCreateTableAsSelect(_tableName: string, _sql: string): string;
     sqlNowExpr(): 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, te: TimeExtractExpr): string;
     sqlCast(qi: QueryInfo, cast: TypecastExpr): string;
     sqlRegexpMatch(df: RegexMatchExpr): string;
-    sqlLiteralTime(qi: QueryInfo, lt: 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;
     sqlAggDistinct(_key: string, _values: string[], _func: (valNames: string[]) => string): string;
     sqlSampleTable(tableSQL: string, sample: Sampling | undefined): string;

package/dist/dialect/mysql/mysql.js

@@ -291,10 +291,14 @@ class MySQLDialect extends dialect_1.Dialect {
     sqlNowExpr() {
         return 'LOCALTIMESTAMP';
     }
-    sqlConvertToCivilTime(expr, timezone) {
-        return `CONVERT_TZ(${expr}, 'UTC', '${timezone}')`;
-    }
-    sqlConvertFromCivilTime(expr, timezone) {
+    sqlConvertToCivilTime(expr, timezone, _typeDef) {
+        // MySQL has no timestamptz type, so typeDef.timestamptz will never be true
+        return {
+            sql: `CONVERT_TZ(${expr}, 'UTC', '${timezone}')`,
+            typeDef: { type: 'timestamp' },
+        };
+    }
+    sqlConvertFromCivilTime(expr, timezone, _destTypeDef) {
         return `CONVERT_TZ(${expr}, '${timezone}', 'UTC')`;
     }
     sqlTruncate(expr, unit, _typeDef, _inCivilTime, _timezone) {
@@ -378,15 +382,18 @@ class MySQLDialect extends dialect_1.Dialect {
     sqlRegexpMatch(df) {
         return `REGEXP_LIKE(${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 ` CONVERT_TZ('${lt.literal}', '${tz}', 'UTC')`;
+            return `CONVERT_TZ('${literal}', '${tz}', 'UTC')`;
         }
-        return `TIMESTAMP '${lt.literal}'`;
+        return `TIMESTAMP '${literal}'`;
+    }
+    sqlTimestamptzLiteral(_qi, _literal, _timezone) {
+        throw new Error('MySQL does not support timestamptz');
     }
     sqlMeasureTimeExpr(df) {
         let lVal = df.kids.left.sql;

package/dist/dialect/pg_impl.d.ts

@@ -1,4 +1,4 @@
-import type { ArrayLiteralNode, RecordLiteralNode, RegexMatchExpr, TimeExtractExpr, TimeLiteralNode, TypecastExpr } from '../model/malloy_types';
+import type { ArrayLiteralNode, AtomicTypeDef, ATimestampTypeDef, RecordLiteralNode, RegexMatchExpr, TimeExtractExpr, TimestampUnit, TypecastExpr } from '../model/malloy_types';
 import type { QueryInfo } from './dialect';
 import { Dialect } from './dialect';
 export declare const timeExtractMap: Record<string, string>;
@@ -7,12 +7,21 @@ export declare const timeExtractMap: Record<string, string>;
  * same implementations for the much of the SQL code generation
  */
 export declare abstract class PostgresBase extends Dialect {
+    hasTimestamptz: boolean;
     sqlNowExpr(): string;
     sqlTimeExtractExpr(qi: QueryInfo, from: TimeExtractExpr): string;
     sqlCast(qi: QueryInfo, cast: TypecastExpr): string;
     sqlRegexpMatch(df: RegexMatchExpr): string;
-    sqlLiteralTime(qi: QueryInfo, lt: 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;
     sqlLiteralRecord(_lit: RecordLiteralNode): string;
     sqlLiteralArray(lit: ArrayLiteralNode): string;
     sqlMaybeQuoteIdentifier(identifier: 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: TimestampUnit, _typeDef: AtomicTypeDef, inCivilTime: boolean, _timezone?: string): string;
 }