@malloydata/malloy 0.0.321 → 0.0.323

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, TimeLiteralNode, RecordLiteralNode, ArrayLiteralNode, BasicAtomicTypeDef, OrderBy, TimestampUnit, TimeExpr } from '../model/malloy_types';
 import type { DialectFunctionOverloadDef } from './functions';
 interface DialectField {
     typeDef: AtomicTypeDef;
@@ -91,12 +91,118 @@ 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;
     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.
+     *
+     * 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'`
+     *
+     * @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
+     */
+    abstract sqlConvertToCivilTime(expr: string, timezone: string): string;
+    /**
+     * Converts a civil (local) time expression back to a UTC timestamp.
+     * The inverse of sqlConvertToCivilTime.
+     *
+     * 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)`
+     *
+     * @param expr The SQL expression for the civil time
+     * @param timezone The timezone of the civil time
+     * @returns SQL expression representing the UTC timestamp
+     */
+    abstract sqlConvertFromCivilTime(expr: string, timezone: string): 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
+     *
+     * @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;
     abstract sqlLiteralTime(qi: QueryInfo, df: TimeLiteralNode): string;
     abstract sqlLiteralString(literal: string): string;
     abstract sqlLiteralRegexp(literal: string): string;

package/dist/dialect/dialect.js

@@ -104,6 +104,84 @@ 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.isTimestamp(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
+     *
+     * @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
+        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);
+            }
+            return this.sqlConvertFromCivilTime(expr, tz);
+        }
+        // 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 +198,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':

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';
@@ -60,7 +60,10 @@ export declare class DuckDBDialect extends PostgresBase {
     castToString(expression: string): string;
     concat(...values: string[]): string;
     validateTypeName(sqlType: string): boolean;
-    sqlAlterTimeExpr(df: TimeDeltaExpr): 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;
     sqlRegexpMatch(df: RegexMatchExpr): string;
     sqlMeasureTimeExpr(df: MeasureTimeExpr): string;
     sqlLiteralRecord(lit: RecordLiteralNode): string;

package/dist/dialect/duckdb/duckdb.js

@@ -323,19 +323,30 @@ 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`;
+    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)`;
         }
-        else if (timeframe === 'week') {
-            timeframe = 'day';
-            n = `${n}*7`;
+        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;
+        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})`;

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, TimeLiteralNode, RegexMatchExpr, TimeExtractExpr, TypecastExpr, BasicAtomicTypeDef, AtomicTypeDef, 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,10 +56,11 @@ 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): string;
+    sqlConvertFromCivilTime(expr: string, timezone: string): 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;

package/dist/dialect/mysql/mysql.js

@@ -291,38 +291,21 @@ class MySQLDialect extends dialect_1.Dialect {
     sqlNowExpr() {
         return 'LOCALTIMESTAMP';
     }
-    sqlTruncExpr(qi, trunc) {
-        const truncThis = trunc.e.sql || 'internal-error-in-sql-generation';
-        const week = trunc.units === 'week';
-        // Only do timezone conversion for timestamps, not dates
-        if (malloy_types_1.TD.isTimestamp(trunc.e.typeDef)) {
-            const tz = (0, dialect_1.qtz)(qi);
-            if (tz) {
-                // Convert timestamp to the query timezone (civil time)
-                const civilSource = `(CONVERT_TZ(${truncThis}, 'UTC','${tz}'))`;
-                // For week truncation, we need to adjust to Sunday in the civil timezone
-                // DAYOFWEEK returns 1=Sunday, 2=Monday, etc., so subtract (DAYOFWEEK-1) days
-                const adjustedSource = week
-                    ? `DATE_SUB(${civilSource}, INTERVAL DAYOFWEEK(${civilSource}) - 1 DAY)`
-                    : civilSource;
-                // Truncate to the appropriate unit in civil time
-                const civilTrunc = `${this.truncToUnit(adjustedSource, trunc.units)}`;
-                // Convert the truncated civil time back to UTC
-                const truncTsTz = `CONVERT_TZ(${civilTrunc}, '${tz}', 'UTC')`;
-                return `(${truncTsTz})`; // TODO: should it cast?
-            }
-        }
-        // For dates (civil time) or timestamps without query timezone
-        // do the week adjustment before truncating
-        const adjustedThis = week
-            ? `DATE_SUB(${truncThis}, INTERVAL DAYOFWEEK(${truncThis}) - 1 DAY)`
-            : truncThis;
-        const result = `${this.truncToUnit(adjustedThis, trunc.units)}`;
-        return result;
-    }
-    truncToUnit(expr, units) {
+    sqlConvertToCivilTime(expr, timezone) {
+        return `CONVERT_TZ(${expr}, 'UTC', '${timezone}')`;
+    }
+    sqlConvertFromCivilTime(expr, timezone) {
+        return `CONVERT_TZ(${expr}, '${timezone}', 'UTC')`;
+    }
+    sqlTruncate(expr, unit, _typeDef, _inCivilTime, _timezone) {
+        // For week truncation, adjust to Sunday first
+        // DAYOFWEEK returns 1=Sunday, 2=Monday, etc., so subtract (DAYOFWEEK-1) days
+        const adjustedExpr = unit === 'week'
+            ? `DATE_SUB(${expr}, INTERVAL DAYOFWEEK(${expr}) - 1 DAY)`
+            : expr;
+        // Generate truncation using DATE_FORMAT
         let format = "'%Y-%m-%d %H:%i:%s'";
-        switch (units) {
+        switch (unit) {
             case 'minute':
                 format = "'%Y-%m-%d %H:%i:00'";
                 break;
@@ -337,13 +320,28 @@ class MySQLDialect extends dialect_1.Dialect {
                 format = "'%Y-%m-01 00:00:00'";
                 break;
             case 'quarter':
-                format = `CASE WHEN MONTH(${expr}) > 9 THEN '%Y-10-01 00:00:00' WHEN MONTH(${expr}) > 6 THEN '%Y-07-01 00:00:00' WHEN MONTH(${expr}) > 3 THEN '%Y-04-01 00:00:00' ELSE '%Y-01-01 00:00:00' end`;
+                format = `CASE WHEN MONTH(${adjustedExpr}) > 9 THEN '%Y-10-01 00:00:00' WHEN MONTH(${adjustedExpr}) > 6 THEN '%Y-07-01 00:00:00' WHEN MONTH(${adjustedExpr}) > 3 THEN '%Y-04-01 00:00:00' ELSE '%Y-01-01 00:00:00' end`;
                 break;
             case 'year':
                 format = "'%Y-01-01 00:00:00'";
                 break;
         }
-        return `TIMESTAMP(DATE_FORMAT(${expr}, ${format}))`;
+        return `TIMESTAMP(DATE_FORMAT(${adjustedExpr}, ${format}))`;
+    }
+    sqlOffsetTime(expr, op, magnitude, unit, _typeDef, _inCivilTime, _timezone) {
+        // Convert quarter/week to supported units
+        let offsetUnit = unit;
+        let offsetMag = magnitude;
+        if (unit === 'quarter') {
+            offsetUnit = 'month';
+            offsetMag = `${magnitude}*3`;
+        }
+        else if (unit === 'week') {
+            offsetUnit = 'day';
+            offsetMag = `${magnitude}*7`;
+        }
+        const interval = `INTERVAL ${offsetMag} ${offsetUnit}`;
+        return `(${expr} ${op} ${interval})`;
     }
     sqlTimeExtractExpr(qi, te) {
         const msUnits = msExtractionMap[te.units] || te.units;
@@ -356,20 +354,6 @@ class MySQLDialect extends dialect_1.Dialect {
         }
         return `${msUnits}(${extractFrom})`;
     }
-    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`;
-        }
-        const interval = `INTERVAL ${n} ${timeframe} `;
-        return `(${df.kids.base.sql})${df.op}${interval}`;
-    }
     sqlCast(qi, cast) {
         const srcSQL = cast.e.sql || 'internal-error-in-sql-generation';
         const { op, srcTypeDef, dstTypeDef, dstSQLType } = this.sqlCastPrep(cast);

package/dist/dialect/pg_impl.d.ts

@@ -1,4 +1,4 @@
-import type { ArrayLiteralNode, RecordLiteralNode, RegexMatchExpr, TimeExtractExpr, TimeLiteralNode, TimeTruncExpr, TypecastExpr } from '../model/malloy_types';
+import type { ArrayLiteralNode, RecordLiteralNode, RegexMatchExpr, TimeExtractExpr, TimeLiteralNode, TypecastExpr } from '../model/malloy_types';
 import type { QueryInfo } from './dialect';
 import { Dialect } from './dialect';
 export declare const timeExtractMap: Record<string, string>;
@@ -7,7 +7,6 @@ export declare const timeExtractMap: Record<string, string>;
  * same implementations for the much of the SQL code generation
  */
 export declare abstract class PostgresBase extends Dialect {
-    sqlTruncExpr(qi: QueryInfo, df: TimeTruncExpr): string;
     sqlNowExpr(): string;
     sqlTimeExtractExpr(qi: QueryInfo, from: TimeExtractExpr): string;
     sqlCast(qi: QueryInfo, cast: TypecastExpr): string;

package/dist/dialect/pg_impl.js

@@ -18,36 +18,6 @@ exports.timeExtractMap = {
  * same implementations for the much of the SQL code generation
  */
 class PostgresBase extends dialect_1.Dialect {
-    sqlTruncExpr(qi, df) {
-        // adjusting for monday/sunday weeks
-        const week = df.units === 'week';
-        const truncThis = week ? `${df.e.sql} + INTERVAL '1' DAY` : df.e.sql;
-        // Only do timezone conversion for timestamps, not dates
-        if (malloy_types_1.TD.isTimestamp(df.e.typeDef)) {
-            const tz = (0, dialect_1.qtz)(qi);
-            if (tz) {
-                // get a civil version of the time in the query time zone
-                const civilSource = `((${truncThis})::TIMESTAMPTZ AT TIME ZONE '${tz}')`;
-                // do truncation in that time space
-                let civilTrunc = `DATE_TRUNC('${df.units}', ${civilSource})`;
-                if (week) {
-                    civilTrunc = `(${civilTrunc} - INTERVAL '1' DAY)`;
-                }
-                // make a tstz from the civil time ... "AT TIME ZONE" of
-                // a TIMESTAMP will produce a TIMESTAMPTZ in that zone
-                // where the civi appeareance is the same as the TIMESTAMP
-                const truncTsTz = `${civilTrunc} AT TIME ZONE '${tz}'`;
-                // Now just make a system TIMESTAMP from that
-                return `(${truncTsTz})::TIMESTAMP`;
-            }
-        }
-        // For dates (civil time) or timestamps without query timezone
-        let result = `DATE_TRUNC('${df.units}', ${truncThis})`;
-        if (week) {
-            result = `(${result} - INTERVAL '1' DAY)`;
-        }
-        return result;
-    }
     sqlNowExpr() {
         return 'LOCALTIMESTAMP';
     }

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

@@ -1,4 +1,4 @@
-import type { Sampling, AtomicTypeDef, TimeDeltaExpr, TypecastExpr, MeasureTimeExpr, BasicAtomicTypeDef, RecordLiteralNode, ArrayLiteralNode, TimeExtractExpr } from '../../model/malloy_types';
+import type { Sampling, AtomicTypeDef, TypecastExpr, MeasureTimeExpr, BasicAtomicTypeDef, RecordLiteralNode, ArrayLiteralNode, TimeExtractExpr, TimestampUnit } from '../../model/malloy_types';
 import type { DialectFunctionOverloadDef } from '../functions';
 import { type DialectFieldList, type FieldReferenceType, type QueryInfo } from '../dialect';
 import { PostgresBase } from '../pg_impl';
@@ -44,7 +44,10 @@ export declare class PostgresDialect extends PostgresBase {
     sqlFinalStage(lastStageName: string, _fields: string[]): string;
     sqlSelectAliasAsStruct(alias: string): string;
     sqlCreateTableAsSelect(_tableName: string, _sql: string): string;
-    sqlAlterTimeExpr(df: TimeDeltaExpr): 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;
     sqlSumDistinct(key: string, value: string, funcName: string): string;

package/dist/dialect/postgres/postgres.js

@@ -209,19 +209,36 @@ class PostgresDialect extends pg_impl_1.PostgresBase {
     sqlCreateTableAsSelect(_tableName, _sql) {
         throw new Error('Not implemented Yet');
     }
-    sqlAlterTimeExpr(df) {
-        let timeframe = df.units;
-        let n = df.kids.delta.sql;
-        if (timeframe === 'quarter') {
-            timeframe = 'month';
-            n = `${n}*3`;
+    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;
+        let offsetMag = magnitude;
+        if (unit === 'quarter') {
+            offsetUnit = 'month';
+            offsetMag = `(${magnitude})*3`;
         }
-        else if (timeframe === 'week') {
-            timeframe = 'day';
-            n = `${n}*7`;
+        else if (unit === 'week') {
+            offsetUnit = 'day';
+            offsetMag = `(${magnitude})*7`;
         }
-        const interval = `make_interval(${pgMakeIntervalMap[timeframe]}=>(${n})::integer)`;
-        return `(${df.kids.base.sql})${df.op}${interval}`;
+        // Map to make_interval parameter name
+        const intervalParam = pgMakeIntervalMap[offsetUnit];
+        const interval = `make_interval(${intervalParam}=>(${offsetMag})::integer)`;
+        return `(${expr} ${op} ${interval})`;
     }
     sqlCast(qi, cast) {
         if (cast.safe) {

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

@@ -1,4 +1,4 @@
-import type { Sampling, AtomicTypeDef, TimeTruncExpr, TimeExtractExpr, TimeDeltaExpr, TypecastExpr, TimeLiteralNode, MeasureTimeExpr, RegexMatchExpr, BasicAtomicTypeDef, ArrayLiteralNode, RecordLiteralNode } from '../../model/malloy_types';
+import type { Sampling, AtomicTypeDef, TimeExtractExpr, TypecastExpr, TimeLiteralNode, MeasureTimeExpr, RegexMatchExpr, BasicAtomicTypeDef, ArrayLiteralNode, RecordLiteralNode } from '../../model/malloy_types';
 import type { DialectFunctionOverloadDef } from '../functions';
 import type { DialectFieldList, FieldReferenceType, QueryInfo } from '../dialect';
 import { Dialect } from '../dialect';
@@ -45,9 +45,11 @@ export declare class SnowflakeDialect extends Dialect {
     sqlSelectAliasAsStruct(alias: string): string;
     sqlMaybeQuoteIdentifier(identifier: string): string;
     sqlCreateTableAsSelect(tableName: string, sql: string): string;
-    sqlTruncExpr(qi: QueryInfo, te: TimeTruncExpr): string;
+    sqlConvertToCivilTime(expr: string, timezone: string): string;
+    sqlConvertFromCivilTime(expr: string, timezone: string): 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;
-    sqlAlterTimeExpr(df: TimeDeltaExpr): string;
     private atTz;
     sqlNowExpr(): string;
     sqlCast(qi: QueryInfo, cast: TypecastExpr): string;

package/dist/dialect/snowflake/snowflake.js

@@ -249,13 +249,24 @@ ${(0, utils_1.indent)(sql)}
 );
 `;
     }
-    sqlTruncExpr(qi, te) {
-        const tz = (0, dialect_1.qtz)(qi);
-        let truncThis = te.e.sql;
-        if (tz && malloy_types_1.TD.isTimestamp(te.e.typeDef)) {
-            truncThis = `CONVERT_TIMEZONE('${tz}',${truncThis})`;
-        }
-        return `DATE_TRUNC('${te.units}',${truncThis})`;
+    sqlConvertToCivilTime(expr, timezone) {
+        // 3-arg form: explicitly convert from UTC to specified timezone
+        return `CONVERT_TIMEZONE('UTC', '${timezone}', ${expr})`;
+    }
+    sqlConvertFromCivilTime(expr, timezone) {
+        // 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)`;
+    }
+    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
+        return `DATE_TRUNC('${unit}', ${expr})`;
+    }
+    sqlOffsetTime(expr, op, magnitude, unit, typeDef, _inCivilTime, _timezone) {
+        const funcName = typeDef.type === 'date' ? 'DATEADD' : 'TIMESTAMPADD';
+        const n = op === '+' ? magnitude : `-(${magnitude})`;
+        return `${funcName}(${unit}, ${n}, ${expr})`;
     }
     sqlTimeExtractExpr(qi, from) {
         const extractUnits = extractionMap[from.units] || from.units;
@@ -266,12 +277,6 @@ ${(0, utils_1.indent)(sql)}
         }
         return `EXTRACT(${extractUnits} FROM ${extractFrom})`;
     }
-    sqlAlterTimeExpr(df) {
-        var _a;
-        const add = ((_a = df.typeDef) === null || _a === void 0 ? void 0 : _a.type) === 'date' ? 'DATEADD' : 'TIMESTAMPADD';
-        const n = df.op === '+' ? df.kids.delta.sql : `-(${df.kids.delta.sql})`;
-        return `${add}(${df.units},${n},${df.kids.base.sql})`;
-    }
     atTz(sqlExpr, tz) {
         if (tz !== undefined) {
             return `(
@@ -315,19 +320,15 @@ ${(0, utils_1.indent)(sql)}
     }
     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);
-        // just making it explicit that timestring does not have timezone info
         let ret = `'${lf.literal}'::TIMESTAMP_NTZ`;
-        // now do the hack to add timezone to a timestamp ntz
         const targetTimeZone = (_a = lf.timezone) !== null && _a !== void 0 ? _a : tz;
         if (targetTimeZone) {
-            const targetTimeZoneSuffix = `TO_CHAR(CONVERT_TIMEZONE('${targetTimeZone}', '1970-01-01 00:00:00'), 'TZHTZM')`;
-            const retTimeString = `TO_CHAR(${ret}, 'YYYY-MM-DD HH24:MI:SS.FF9')`;
-            ret = `${retTimeString} || ${targetTimeZoneSuffix}`;
-            ret = `(${ret})::TIMESTAMP_TZ`;
-        }
-        if (malloy_types_1.TD.isDate(lf.typeDef)) {
-            return `TO_DATE(${ret})`;
+            // Interpret the literal as being in targetTimeZone, convert to UTC
+            ret = `CONVERT_TIMEZONE('${targetTimeZone}', 'UTC', ${ret})`;
         }
         return ret;
     }