@malloydata/malloy 0.0.322 → 0.0.324

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, TimeTruncExpr, TimeExtractExpr, TimeDeltaExpr, TypecastExpr, RegexMatchExpr, TimeLiteralNode, RecordLiteralNode, ArrayLiteralNode, BasicAtomicTypeDef, OrderBy } 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[];
     };
@@ -91,13 +97,203 @@ export declare abstract class Dialect {
     sqlLiteralNumber(literal: string): string;
     ignoreInProject(_fieldName: string): boolean;
     abstract sqlNowExpr(): string;
-    abstract sqlTruncExpr(qi: QueryInfo, toTrunc: TimeTruncExpr): string;
     abstract sqlTimeExtractExpr(qi: QueryInfo, xFrom: TimeExtractExpr): string;
     abstract sqlMeasureTimeExpr(e: MeasureTimeExpr): string;
-    abstract sqlAlterTimeExpr(df: TimeDeltaExpr): 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;
-    abstract sqlLiteralTime(qi: QueryInfo, df: TimeLiteralNode): string;
+    /**
+     * Converts a Malloy timestamp to "civil time" for calendar operations in a timezone.
+     *
+     * 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 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, typeDef: AtomicTypeDef): {
+        sql: string;
+        typeDef: AtomicTypeDef;
+    };
+    /**
+     * Converts from civil time back to a Malloy timestamp type.
+     *
+     * 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 in civil time
+     * @param timezone The timezone of the civil time
+     * @param destTypeDef The destination Malloy timestamp type (plain or timestamptz)
+     * @returns SQL expression representing the Malloy timestamp
+     */
+    abstract sqlConvertFromCivilTime(expr: string, timezone: string, destTypeDef: ATimestampTypeDef): string;
+    /**
+     * Truncates a time expression to the specified unit.
+     *
+     * @param expr The SQL expression to truncate
+     * @param unit The unit to truncate to (year, month, day, hour, etc.)
+     * @param typeDef The Malloy type of the expression (date, timestamp, etc.)
+     * @param inCivilTime If true, the expression is already in civil (local) time and should not
+     *                    be converted. If false, may need timezone conversion for timestamps.
+     * @param timezone Optional timezone for the operation. Only provided when timezone-aware
+     *                 truncation is needed but inCivilTime is false.
+     * @returns SQL expression representing the truncated time
+     */
+    abstract sqlTruncate(expr: string, unit: TimestampUnit, typeDef: AtomicTypeDef, inCivilTime: boolean, timezone?: string): string;
+    /**
+     * Adds or subtracts a time interval from a time expression.
+     *
+     * @param expr The SQL expression to offset
+     * @param op The operation: '+' for addition, '-' for subtraction
+     * @param magnitude The SQL expression for the interval magnitude (e.g., '6', '(delta_val)')
+     * @param unit The interval unit (year, month, day, hour, etc.)
+     * @param typeDef The Malloy type of the expression (date, timestamp, etc.)
+     * @param inCivilTime If true, the expression is already in civil (local) time and should not
+     *                    be converted. If false, may need timezone conversion for timestamps.
+     * @param timezone Optional timezone for the operation. Only provided when timezone-aware
+     *                 offset is needed but inCivilTime is false.
+     * @returns SQL expression representing the offset time
+     */
+    abstract sqlOffsetTime(expr: string, op: '+' | '-', magnitude: string, unit: TimestampUnit, typeDef: AtomicTypeDef, inCivilTime: boolean, timezone?: string): string;
+    /**
+     * Determines whether a truncation and/or offset operation needs to be performed in
+     * civil (local) time, and if so, which timezone to use.
+     *
+     * Calendar-based operations (day, week, month, quarter, year) typically need civil time
+     * computation because these units can cross DST boundaries, changing the UTC offset.
+     *
+     * Default implementation:
+     * - Returns true for timestamps with truncation or calendar-unit offsets
+     * - Uses the query timezone from QueryInfo, or 'UTC' if none specified
+     * - Returns false for dates or sub-day offsets (hour, minute, second)
+     *
+     * Dialects can override this if they have different rules about which operations
+     * require civil time computation.
+     *
+     * @param typeDef The Malloy type of the base expression
+     * @param truncateTo The truncation unit, if any
+     * @param offsetUnit The offset unit, if any
+     * @param qi Query information including timezone settings
+     * @returns Object with `needed` boolean and optional `tz` string
+     */
+    needsCivilTimeComputation(typeDef: AtomicTypeDef, truncateTo: TimestampUnit | undefined, offsetUnit: TimestampUnit | undefined, qi: QueryInfo): {
+        needed: boolean;
+        tz: string | undefined;
+    };
+    /**
+     * Unified function for truncation and/or offset operations. This turns out to
+     * be a very common operation and one which can be optimized by doing it together.
+     *
+     * Much of the complexity has to do with getting timezone values set up so that
+     * they will truncate/offset in the query timezone instead of UTC.
+     *
+     * The intention is that this implementation will work for all dialects, and all
+     * the dialect peculiarities are handled with the new primitives introduced to
+     * support this function:
+     * - needsCivilTimeComputation: Determines if operation needs civil time
+     * - sqlConvertToCivilTime/sqlConvertFromCivilTime: Timezone conversion
+     * - 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.)
+     * @param offset Optional offset to apply (after truncation if both present)
+     */
+    sqlTruncAndOffset(baseExpr: TimeExpr, qi: QueryInfo, truncateTo?: TimestampUnit, offset?: {
+        op: '+' | '-';
+        magnitude: string;
+        unit: TimestampUnit;
+    }): 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');
     }
@@ -104,6 +158,96 @@ class Dialect {
     ignoreInProject(_fieldName) {
         return false;
     }
+    /**
+     * Determines whether a truncation and/or offset operation needs to be performed in
+     * civil (local) time, and if so, which timezone to use.
+     *
+     * Calendar-based operations (day, week, month, quarter, year) typically need civil time
+     * computation because these units can cross DST boundaries, changing the UTC offset.
+     *
+     * Default implementation:
+     * - Returns true for timestamps with truncation or calendar-unit offsets
+     * - Uses the query timezone from QueryInfo, or 'UTC' if none specified
+     * - Returns false for dates or sub-day offsets (hour, minute, second)
+     *
+     * Dialects can override this if they have different rules about which operations
+     * require civil time computation.
+     *
+     * @param typeDef The Malloy type of the base expression
+     * @param truncateTo The truncation unit, if any
+     * @param offsetUnit The offset unit, if any
+     * @param qi Query information including timezone settings
+     * @returns Object with `needed` boolean and optional `tz` string
+     */
+    needsCivilTimeComputation(typeDef, truncateTo, offsetUnit, qi) {
+        // Calendar units that can cross DST boundaries
+        const calendarUnits = ['day', 'week', 'month', 'quarter', 'year'];
+        const isCalendarTruncate = truncateTo !== undefined && calendarUnits.includes(truncateTo);
+        const isCalendarOffset = offsetUnit !== undefined && calendarUnits.includes(offsetUnit);
+        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.isAnyTimestamp(typeDef) &&
+            (isCalendarTruncate || isCalendarOffset) &&
+            tz !== undefined;
+        return { needed, tz };
+    }
+    /**
+     * Unified function for truncation and/or offset operations. This turns out to
+     * be a very common operation and one which can be optimized by doing it together.
+     *
+     * Much of the complexity has to do with getting timezone values set up so that
+     * they will truncate/offset in the query timezone instead of UTC.
+     *
+     * The intention is that this implementation will work for all dialects, and all
+     * the dialect peculiarities are handled with the new primitives introduced to
+     * support this function:
+     * - needsCivilTimeComputation: Determines if operation needs civil time
+     * - sqlConvertToCivilTime/sqlConvertFromCivilTime: Timezone conversion
+     * - 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.)
+     * @param offset Optional offset to apply (after truncation if both present)
+     */
+    sqlTruncAndOffset(baseExpr, qi, truncateTo, offset) {
+        // Determine if we need to work in civil (local) time
+        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);
+            }
+        }
+        // Simple path: no civil time conversion needed
+        let sql = baseExpr.sql;
+        if (truncateTo) {
+            sql = this.sqlTruncate(sql, truncateTo, baseExpr.typeDef, false, qtz(qi));
+        }
+        if (offset) {
+            sql = this.sqlOffsetTime(sql, offset.op, offset.magnitude, offset.unit, baseExpr.typeDef, false, qtz(qi));
+        }
+        return sql;
+    }
     /**
      * The dialect has a chance to over-ride how expressions are translated. If
      * "undefined" is returned then the translation is left to the query translator.
@@ -120,10 +264,27 @@ class Dialect {
                 return this.sqlNowExpr();
             case 'timeDiff':
                 return this.sqlMeasureTimeExpr(df);
-            case 'delta':
-                return this.sqlAlterTimeExpr(df);
+            case 'delta': {
+                // Optimize: if delta's base is a trunc, combine them
+                const base = df.kids.base;
+                if (base.node === 'trunc') {
+                    // Combined trunc + offset - pass the base of the truncation
+                    return this.sqlTruncAndOffset(base.e, qi, base.units, {
+                        op: df.op,
+                        magnitude: df.kids.delta.sql,
+                        unit: df.units,
+                    });
+                }
+                // Just offset, no truncation - pass the delta's base
+                return this.sqlTruncAndOffset(base, qi, undefined, {
+                    op: df.op,
+                    magnitude: df.kids.delta.sql,
+                    unit: df.units,
+                });
+            }
             case 'trunc':
-                return this.sqlTruncExpr(qi, df);
+                // Just truncation, no offset
+                return this.sqlTruncAndOffset(df.e, qi, df.units);
             case 'extract':
                 return this.sqlTimeExtractExpr(qi, df);
             case 'cast':
@@ -142,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

@@ -1,4 +1,4 @@
-import type { Sampling, AtomicTypeDef, TimeDeltaExpr, RegexMatchExpr, MeasureTimeExpr, BasicAtomicTypeDef, RecordLiteralNode, OrderBy } from '../../model/malloy_types';
+import type { Sampling, AtomicTypeDef, RegexMatchExpr, MeasureTimeExpr, BasicAtomicTypeDef, RecordLiteralNode, OrderBy, TimestampUnit } from '../../model/malloy_types';
 import type { DialectFunctionOverloadDef } from '../functions';
 import type { DialectFieldList, FieldReferenceType } from '../dialect';
 import { PostgresBase } from '../pg_impl';
@@ -56,11 +56,11 @@ 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;
-    sqlAlterTimeExpr(df: TimeDeltaExpr): string;
+    sqlOffsetTime(expr: string, op: '+' | '-', magnitude: string, unit: TimestampUnit, _typeDef: AtomicTypeDef, _inCivilTime: boolean, _timezone?: string): string;
     sqlRegexpMatch(df: RegexMatchExpr): string;
     sqlMeasureTimeExpr(df: MeasureTimeExpr): string;
     sqlLiteralRecord(lit: RecordLiteralNode): 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,19 +330,16 @@ class DuckDBDialect extends pg_impl_1.PostgresBase {
         // Brackets:             INT[ ]
         return sqlType.match(/^[A-Za-z\s(),[\]0-9]*$/) !== null;
     }
-    sqlAlterTimeExpr(df) {
-        let timeframe = df.units;
-        let n = df.kids.delta.sql;
-        if (timeframe === 'quarter') {
-            timeframe = 'month';
-            n = `${n}*3`;
-        }
-        else if (timeframe === 'week') {
-            timeframe = 'day';
-            n = `${n}*7`;
+    sqlOffsetTime(expr, op, magnitude, unit, _typeDef, _inCivilTime, _timezone) {
+        // DuckDB doesn't support INTERVAL '1' WEEK, convert to days
+        let offsetUnit = unit;
+        let offsetMag = magnitude;
+        if (unit === 'week') {
+            offsetUnit = 'day';
+            offsetMag = `(${magnitude})*7`;
         }
-        const interval = `INTERVAL (${n}) ${timeframe}`;
-        return `${df.kids.base.sql} ${df.op} ${interval}`;
+        const interval = `INTERVAL (${offsetMag}) ${offsetUnit}`;
+        return `(${expr} ${op} ${interval})`;
     }
     sqlRegexpMatch(df) {
         return `REGEXP_MATCHES(${df.kids.expr.sql},${df.kids.regex.sql})`;
@@ -401,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, TimeDeltaExpr, TimeTruncExpr, 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,13 +56,19 @@ export declare class MySQLDialect extends Dialect {
     sqlMaybeQuoteIdentifier(identifier: string): string;
     sqlCreateTableAsSelect(_tableName: string, _sql: string): string;
     sqlNowExpr(): string;
-    sqlTruncExpr(qi: QueryInfo, trunc: TimeTruncExpr): string;
-    truncToUnit(expr: string, units: 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;
-    sqlAlterTimeExpr(df: TimeDeltaExpr): 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;