@malloydata/malloy 0.0.434 → 0.0.436

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

@@ -1,7 +1,7 @@
-import type { Sampling, AtomicTypeDef, TimeExtractExpr, TypecastExpr, RegexMatchExpr, MeasureTimeExpr, BasicAtomicTypeDef, RecordLiteralNode, ArrayLiteralNode, TimestampUnit, TimestampTypeDef } from '../../model/malloy_types';
+import type { Sampling, AtomicTypeDef, TypecastExpr, RegexMatchExpr, MeasureTimeExpr, BasicAtomicTypeDef, RecordLiteralNode, ArrayLiteralNode, TimestampUnit, ATimestampTypeDef, ExtractUnit } from '../../model/malloy_types';
 import type { DialectFunctionOverloadDef } from '../functions';
 import type { CompiledOrderBy, DialectFieldList, IntegerTypeMapping, OrderByRequest, QueryInfo } from '../dialect';
-import { Dialect, type LateralJoinExpression } from '../dialect';
+import { CivilTime, Dialect, type LateralJoinExpression } from '../dialect';
 export declare class StandardSQLDialect extends Dialect {
     name: string;
     stringLiteralStyle: "backslash";
@@ -36,10 +36,6 @@ export declare class StandardSQLDialect extends Dialect {
     private bqRejectBacktick;
     sqlQuoteIdentifier(identifier: string): string;
     tablePathBareIdentRegex: RegExp;
-    needsCivilTimeComputation(typeDef: AtomicTypeDef, truncateTo: TimestampUnit | undefined, offsetUnit: TimestampUnit | undefined, qi: QueryInfo): {
-        needed: boolean;
-        tz: string | undefined;
-    };
     sqlGroupSetTable(groupSetCount: number): string;
     sqlAnyValue(groupSet: number, fieldName: string): string;
     sqlOrderBy(orderTerms: string[], obr?: OrderByRequest): string;
@@ -57,19 +53,18 @@ export declare class StandardSQLDialect extends Dialect {
     sqlCreateFunctionCombineLastStage(lastStageName: string): string;
     sqlSelectAliasAsStruct(alias: string, dialectFieldList: DialectFieldList): string;
     sqlNowExpr(): string;
-    sqlTimeExtractExpr(qi: QueryInfo, te: TimeExtractExpr): string;
-    sqlConvertToCivilTime(expr: string, timezone: string, _typeDef: AtomicTypeDef): {
-        sql: string;
-        typeDef: AtomicTypeDef;
-    };
-    sqlConvertFromCivilTime(expr: string, timezone: string, _destTypeDef: TimestampTypeDef): string;
-    sqlTruncate(expr: string, unit: TimestampUnit, typeDef: AtomicTypeDef, inCivilTime: boolean, timezone?: string): string;
-    sqlOffsetTime(expr: string, op: '+' | '-', magnitude: string, unit: TimestampUnit, typeDef: AtomicTypeDef, inCivilTime: boolean, _timezone?: string): string;
+    sqlCivilExtract(expr: string, units: ExtractUnit, _civilType: CivilTime): string;
+    sqlConvertToCivilTime(expr: string, timezone: string, _typeDef: ATimestampTypeDef): string;
+    sqlConvertFromCivilTime(expr: string, timezone: string, _destTypeDef: ATimestampTypeDef): string;
+    sqlTruncate(expr: string, unit: TimestampUnit, civilType: CivilTime): string;
+    sqlOffsetTime(expr: string, op: '+' | '-', magnitude: string, unit: TimestampUnit, civilType: CivilTime): string;
+    sqlCivilToDate(expr: string): string;
+    sqlDateToCivil(expr: string): string;
     ignoreInProject(fieldName: string): boolean;
-    sqlCast(qi: QueryInfo, cast: TypecastExpr): string;
+    sqlCast(_qi: QueryInfo, cast: TypecastExpr): string;
     sqlRegexpMatch(match: RegexMatchExpr): string;
     sqlDateLiteral(_qi: QueryInfo, literal: string): string;
-    sqlTimestampLiteral(qi: QueryInfo, literal: string, timezone: string | undefined): string;
+    sqlCivilLiteral(literal: string): string;
     sqlTimestamptzLiteral(_qi: QueryInfo, _literal: string, _timezone: string): string;
     sqlMeasureTimeExpr(measure: MeasureTimeExpr): string;
     sqlSampleTable(tableSQL: string, sample: Sampling | undefined): string;

package/dist/dialect/standardsql/standardsql.js

@@ -26,15 +26,6 @@ const extractMap = {
     'day_of_week': 'dayofweek',
     'day_of_year': 'dayofyear',
 };
-/**
- * Return a non UTC timezone, if one was specificed.
- */
-function qtz(qi) {
-    const tz = qi.queryTimezone;
-    if (tz && tz !== 'UTC') {
-        return tz;
-    }
-}
 const bqToMalloyTypes = {
     'DATE': { type: 'date' },
     'STRING': { type: 'string' },
@@ -124,17 +115,6 @@ class StandardSQLDialect extends dialect_1.Dialect {
         this.bqRejectBacktick(identifier, 'identifier');
         return super.sqlQuoteIdentifier(identifier);
     }
-    needsCivilTimeComputation(typeDef, truncateTo, offsetUnit, qi) {
-        // In addition to using "civil" space for units where a query time zone is
-        // set, BigQuery also uses civil space for unit operations not supported
-        // by the TIMESTAMP functions.
-        const calendarUnits = ['day', 'week', 'month', 'quarter', 'year'];
-        const isCalendarTruncate = truncateTo !== undefined && calendarUnits.includes(truncateTo);
-        const isCalendarOffset = offsetUnit !== undefined && calendarUnits.includes(offsetUnit);
-        const needed = malloy_types_1.TD.isAnyTimestamp(typeDef) && (isCalendarTruncate || isCalendarOffset);
-        const tz = needed ? qtz(qi) || 'UTC' : undefined;
-        return { needed, tz };
-    }
     sqlGroupSetTable(groupSetCount) {
         return `CROSS JOIN (SELECT row_number() OVER() -1  group_set FROM UNNEST(GENERATE_ARRAY(0,${groupSetCount},1)))`;
     }
@@ -249,64 +229,38 @@ ${(0, utils_1.indent)(sql)}
     sqlNowExpr() {
         return 'CURRENT_TIMESTAMP()';
     }
-    sqlTimeExtractExpr(qi, te) {
-        const extractTo = extractMap[te.units] || te.units;
-        const tz = malloy_types_1.TD.isAnyTimestamp(te.e.typeDef) && qtz(qi);
-        const tzAdd = tz ? ` AT TIME ZONE ${this.sqlTimezoneLiteral(tz)}` : '';
-        return `EXTRACT(${extractTo} FROM ${te.e.sql}${tzAdd})`;
+    sqlCivilExtract(expr, units, _civilType) {
+        return `EXTRACT(${extractMap[units] || units} FROM ${expr})`;
     }
+    // Civil time is a DATETIME, which has no zone
     sqlConvertToCivilTime(expr, timezone, _typeDef) {
-        // BigQuery has no timestamptz type, so typeDef.timestamptz will never be true
-        return {
-            sql: `DATETIME(${expr}, ${this.sqlTimezoneLiteral(timezone)})`,
-            typeDef: { type: 'timestamp' },
-        };
+        return `DATETIME(${expr}, ${this.sqlTimezoneLiteral(timezone)})`;
     }
     sqlConvertFromCivilTime(expr, timezone, _destTypeDef) {
         return `TIMESTAMP(${expr}, ${this.sqlTimezoneLiteral(timezone)})`;
     }
-    sqlTruncate(expr, unit, typeDef, inCivilTime, timezone) {
-        if (inCivilTime) {
-            // Operating on DATETIME (civil time)
-            return `DATETIME_TRUNC(${expr}, ${unit})`;
-        }
-        // Operating on DATE or TIMESTAMP
-        if (malloy_types_1.TD.isDate(typeDef)) {
-            return `DATE_TRUNC(${expr}, ${unit})`;
-        }
-        // TIMESTAMP truncation with optional timezone
-        const tzParam = timezone ? `, ${this.sqlTimezoneLiteral(timezone)}` : '';
-        return `TIMESTAMP_TRUNC(${expr}, ${unit}${tzParam})`;
-    }
-    sqlOffsetTime(expr, op, magnitude, unit, typeDef, inCivilTime, _timezone) {
-        if (inCivilTime) {
-            // Operating on DATETIME (civil time)
-            const funcName = op === '+' ? 'DATETIME_ADD' : 'DATETIME_SUB';
-            return `${funcName}(${expr}, INTERVAL ${magnitude} ${unit})`;
-        }
-        // Operating on DATE or TIMESTAMP
-        const baseType = typeDef.type;
-        if (baseType === 'date') {
-            const funcName = op === '+' ? 'DATE_ADD' : 'DATE_SUB';
-            return `${funcName}(${expr}, INTERVAL ${magnitude} ${unit})`;
-        }
-        // TIMESTAMP with sub-day units only (calendar units go through civil time)
-        const funcName = op === '+' ? 'TIMESTAMP_ADD' : 'TIMESTAMP_SUB';
+    sqlTruncate(expr, unit, civilType) {
+        return civilType === dialect_1.CivilTime.Date
+            ? `DATE_TRUNC(${expr}, ${unit})`
+            : `DATETIME_TRUNC(${expr}, ${unit})`;
+    }
+    sqlOffsetTime(expr, op, magnitude, unit, civilType) {
+        const funcType = civilType === dialect_1.CivilTime.Date ? 'DATE' : 'DATETIME';
+        const funcName = `${funcType}_${op === '+' ? 'ADD' : 'SUB'}`;
         return `${funcName}(${expr}, INTERVAL ${magnitude} ${unit})`;
     }
+    sqlCivilToDate(expr) {
+        return `DATE(${expr})`;
+    }
+    sqlDateToCivil(expr) {
+        return `DATETIME(${expr})`;
+    }
     ignoreInProject(fieldName) {
         return fieldName === '_PARTITIONTIME';
     }
-    sqlCast(qi, cast) {
-        const { op, srcTypeDef, dstTypeDef, dstSQLType } = this.sqlCastPrep(cast);
-        const tz = qtz(qi);
+    sqlCast(_qi, cast) {
+        const { srcTypeDef, dstTypeDef, dstSQLType } = this.sqlCastPrep(cast);
         const src = cast.e.sql || '';
-        if (op === 'timestamp::date' && tz) {
-            return `DATE(${src},${this.sqlTimezoneLiteral(tz)})`;
-        }
-        if (op === 'date::timestamp' && tz) {
-            return `TIMESTAMP(${src}, ${this.sqlTimezoneLiteral(tz)})`;
-        }
         if (!malloy_types_1.TD.eq(srcTypeDef, dstTypeDef)) {
             const castFunc = cast.safe ? 'SAFE_CAST' : 'CAST';
             return `${castFunc}(${src} AS ${dstSQLType})`;
@@ -319,13 +273,8 @@ ${(0, utils_1.indent)(sql)}
     sqlDateLiteral(_qi, literal) {
         return `DATE('${literal}')`;
     }
-    sqlTimestampLiteral(qi, literal, timezone) {
-        let timestampArgs = `'${literal}'`;
-        const tz = timezone || qtz(qi);
-        if (tz && tz !== 'UTC') {
-            timestampArgs += `,${this.sqlTimezoneLiteral(tz)}`;
-        }
-        return `TIMESTAMP(${timestampArgs})`;
+    sqlCivilLiteral(literal) {
+        return `DATETIME '${literal}'`;
     }
     sqlTimestamptzLiteral(_qi, _literal, _timezone) {
         throw new Error('BigQuery does not support timestamptz');

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

@@ -1,6 +1,6 @@
-import type { Expr, Sampling, AtomicTypeDef, ATimestampTypeDef, TypecastExpr, RegexMatchExpr, MeasureTimeExpr, TimeExtractExpr, BasicAtomicTypeDef, RecordLiteralNode, OrderBy } from '../../model/malloy_types';
+import type { Expr, Sampling, AtomicTypeDef, ATimestampTypeDef, TypecastExpr, RegexMatchExpr, MeasureTimeExpr, TimeExtractExpr, BasicAtomicTypeDef, RecordLiteralNode, OrderBy, TimestampUnit, ExtractUnit, TimeExpr } from '../../model/malloy_types';
 import type { DialectFunctionOverloadDef } from '../functions';
-import type { CompiledOrderBy, DialectFieldList, OrderByClauseType, QueryInfo } from '../dialect';
+import type { CivilTime, CompiledOrderBy, DialectFieldList, OrderByClauseType, QueryInfo, TimeOffset } from '../dialect';
 import { PostgresBase } from '../pg_impl';
 export declare class TrinoDialect extends PostgresBase {
     name: string;
@@ -52,14 +52,11 @@ export declare class TrinoDialect extends PostgresBase {
     sqlCreateFunctionCombineLastStage(lastStageName: string, fieldList: DialectFieldList, orderBy: OrderBy[] | undefined): string;
     sqlSelectAliasAsStruct(alias: string, fieldList: DialectFieldList): string;
     keywords: string[];
-    sqlConvertToCivilTime(expr: string, timezone: string, typeDef: AtomicTypeDef): {
-        sql: string;
-        typeDef: AtomicTypeDef;
-    };
-    sqlConvertFromCivilTime(expr: string, _timezone: string, destTypeDef: ATimestampTypeDef): string;
-    sqlTruncate(expr: string, unit: string, _typeDef: AtomicTypeDef, _inCivilTime: boolean, _timezone?: string): string;
-    sqlOffsetTime(expr: string, op: '+' | '-', magnitude: string, unit: string, _typeDef: AtomicTypeDef, _inCivilTime: boolean, _timezone?: string): string;
-    sqlCast(qi: QueryInfo, cast: TypecastExpr): string;
+    sqlConvertToCivilTime(expr: string, timezone: string, typeDef: ATimestampTypeDef): string;
+    sqlConvertFromCivilTime(expr: string, timezone: string, destTypeDef: ATimestampTypeDef): string;
+    sqlTruncate(expr: string, unit: TimestampUnit, _civilType: CivilTime): string;
+    sqlOffsetTime(expr: string, op: '+' | '-', magnitude: string, unit: TimestampUnit, _civilType: CivilTime): string;
+    sqlCast(_qi: QueryInfo, cast: TypecastExpr): string;
     sqlRegexpMatch(reCmp: RegexMatchExpr): string;
     sqlMeasureTimeExpr(mf: MeasureTimeExpr): string;
     sqlSampleTable(tableSQL: string, sample: Sampling | undefined): string;
@@ -77,9 +74,8 @@ export declare class TrinoDialect extends PostgresBase {
     sqlStringAggDistinct(distinctKey: string, valueSQL: string, separatorSQL: string): string;
     validateTypeName(sqlType: string): boolean;
     sqlDateLiteral(_qi: QueryInfo, literal: string): string;
-    sqlTimestampLiteral(qi: QueryInfo, literal: string, timezone: string | undefined): string;
     sqlTimestamptzLiteral(_qi: QueryInfo, literal: string, timezone: string): string;
-    sqlTimeExtractExpr(qi: QueryInfo, from: TimeExtractExpr): string;
+    sqlCivilExtract(expr: string, units: ExtractUnit, _civilType: CivilTime): string;
     sqlLiteralRecord(lit: RecordLiteralNode): string;
 }
 export declare class PrestoDialect extends TrinoDialect {
@@ -90,13 +86,15 @@ export declare class PrestoDialect extends TrinoDialect {
     sqlDateLiteral(_qi: QueryInfo, literal: string): string;
     sqlTimestampLiteral(qi: QueryInfo, literal: string, timezone: string | undefined): string;
     sqlTimestamptzLiteral(_qi: QueryInfo, literal: string, timezone: string): string;
-    sqlConvertToCivilTime(expr: string, timezone: string, _typeDef: AtomicTypeDef): {
-        sql: string;
-        typeDef: AtomicTypeDef;
-    };
-    sqlConvertFromCivilTime(expr: string, _timezone: string, destTypeDef: ATimestampTypeDef): string;
-    sqlCast(qi: QueryInfo, cast: TypecastExpr): string;
+    sqlConvertToCivilTime(): string;
+    sqlConvertFromCivilTime(): string;
+    /** The instant `expr`, showing the clock of `timezone` */
+    private inZone;
+    /** An instant from inZone, as a value of `typeDef` */
+    private fromZone;
     sqlTimeExtractExpr(qi: QueryInfo, from: TimeExtractExpr): string;
+    sqlTruncAndOffset(baseExpr: TimeExpr, qi: QueryInfo, truncateTo?: TimestampUnit, offset?: TimeOffset): string;
+    sqlTimeCast(qi: QueryInfo, cast: TypecastExpr): string | undefined;
     sqlUnnestAlias(source: string, alias: string, _fieldList: DialectFieldList, needDistinctKey: boolean, isArray: boolean, _isInNestedPipeline: boolean): string;
     getDialectFunctions(): {
         [name: string]: DialectFunctionOverloadDef[];

package/dist/dialect/trino/trino.js

@@ -23,15 +23,6 @@ function timestampMeasureable(units) {
         'day',
     ].includes(units);
 }
-/**
- * Return a non UTC timezone, if one was specificed.
- */
-function qtz(qi) {
-    const tz = qi.queryTimezone;
-    if (tz && tz !== 'UTC') {
-        return tz;
-    }
-}
 const trinoToMalloyTypes = {
     'varchar': { type: 'string' },
     'integer': { type: 'number', numberType: 'integer' },
@@ -57,6 +48,33 @@ const trinoToMalloyTypes = {
     // TIME
     // GEOGRAPHY
 };
+function trinoTrunc(expr, unit) {
+    // Weeks start on Monday here, so truncate the following day
+    if (unit === 'week') {
+        return `(DATE_TRUNC('${unit}', (${expr} + INTERVAL '1' DAY)) - INTERVAL '1' DAY)`;
+    }
+    return `DATE_TRUNC('${unit}', ${expr})`;
+}
+function trinoDateAdd(expr, op, magnitude, unit) {
+    // DATE_ADD has no quarter or week
+    let offsetUnit = unit;
+    let offsetMag = magnitude;
+    if (unit === 'quarter') {
+        offsetUnit = 'month';
+        offsetMag = `${magnitude}*3`;
+    }
+    else if (unit === 'week') {
+        offsetUnit = 'day';
+        offsetMag = `${magnitude}*7`;
+    }
+    const n = op === '-' ? `(${offsetMag})*-1` : offsetMag;
+    return `DATE_ADD('${offsetUnit}', ${n}, ${expr})`;
+}
+function trinoExtract(expr, units) {
+    const extracted = `EXTRACT(${pg_impl_1.timeExtractMap[units] || units} FROM ${expr})`;
+    // Trino counts the days of a week from 1 on Monday
+    return units === 'day_of_week' ? `mod(${extracted}+1,7)` : extracted;
+}
 class TrinoDialect extends pg_impl_1.PostgresBase {
     constructor() {
         super(...arguments);
@@ -339,87 +357,34 @@ ${(0, utils_1.indent)(sql)}
         const definitions = this.buildTypeExpression(fieldList);
         return `CAST(ROW(${fields}) as ROW(${definitions}))`;
     }
+    // Civil time is a TIMESTAMP, which Trino keeps without a zone
     sqlConvertToCivilTime(expr, timezone, typeDef) {
-        // Trino civil time = TIMESTAMPTZ with query timezone as stored timezone
-        // Operations (extract, truncate, etc.) happen in the stored timezone
-        if (typeDef.type === 'timestamp') {
-            // TIMESTAMP (UTC wall clock) → TIMESTAMPTZ in query timezone
-            return {
-                sql: `at_timezone(with_timezone(${expr}, 'UTC'), ${this.sqlTimezoneLiteral(timezone)})`,
-                typeDef: { type: 'timestamptz' },
-            };
+        const tz = this.sqlTimezoneLiteral(timezone);
+        if (malloy_types_1.TD.isTimestamptz(typeDef)) {
+            return `CAST(at_timezone(${expr}, ${tz}) AS TIMESTAMP)`;
         }
-        // TIMESTAMPTZ → TIMESTAMPTZ in query timezone (same instant, different stored tz)
-        return {
-            sql: `at_timezone(${expr}, ${this.sqlTimezoneLiteral(timezone)})`,
-            typeDef: { type: 'timestamptz' },
-        };
+        return timezone === 'UTC'
+            ? expr
+            : `CAST(at_timezone(with_timezone(${expr}, 'UTC'), ${tz}) AS TIMESTAMP)`;
     }
-    sqlConvertFromCivilTime(expr, _timezone, destTypeDef) {
-        // From civil TIMESTAMPTZ (in query timezone) to destination type
-        if (destTypeDef.type === 'timestamptz') {
-            // Already TIMESTAMPTZ, keep as-is
-            return expr;
-        }
-        // To TIMESTAMP: convert to UTC and cast to plain TIMESTAMP
-        return `CAST(at_timezone(${expr}, 'UTC') AS TIMESTAMP)`;
-    }
-    sqlTruncate(expr, unit, _typeDef, _inCivilTime, _timezone) {
-        // Trino 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)`;
+    sqlConvertFromCivilTime(expr, timezone, destTypeDef) {
+        const tz = this.sqlTimezoneLiteral(timezone);
+        if (malloy_types_1.TD.isTimestamptz(destTypeDef)) {
+            return `with_timezone(${expr}, ${tz})`;
         }
-        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 (unit === 'week') {
-            offsetUnit = 'day';
-            offsetMag = `${magnitude}*7`;
-        }
-        // Handle subtraction by negating
-        const n = op === '-' ? `(${offsetMag})*-1` : offsetMag;
-        return `DATE_ADD('${offsetUnit}', ${n}, ${expr})`;
+        return timezone === 'UTC'
+            ? expr
+            : `CAST(at_timezone(with_timezone(${expr}, ${tz}), 'UTC') AS TIMESTAMP)`;
+    }
+    sqlTruncate(expr, unit, _civilType) {
+        return trinoTrunc(expr, unit);
     }
-    sqlCast(qi, cast) {
+    sqlOffsetTime(expr, op, magnitude, unit, _civilType) {
+        return trinoDateAdd(expr, op, magnitude, unit);
+    }
+    sqlCast(_qi, cast) {
         const { srcTypeDef, dstTypeDef, dstSQLType } = this.sqlCastPrep(cast);
-        const tz = qtz(qi);
         const expr = cast.e.sql || '';
-        // Timezone-aware casts when query timezone is set
-        if (tz && srcTypeDef && dstTypeDef) {
-            // TIMESTAMP → DATE: interpret as UTC, convert to query timezone
-            if (malloy_types_1.TD.isTimestamp(srcTypeDef) && malloy_types_1.TD.isDate(dstTypeDef)) {
-                return `CAST(at_timezone(with_timezone(${expr}, 'UTC'), ${this.sqlTimezoneLiteral(tz)}) AS DATE)`;
-            }
-            // TIMESTAMPTZ → DATE: convert to query timezone
-            if (malloy_types_1.TD.isTimestamptz(srcTypeDef) && malloy_types_1.TD.isDate(dstTypeDef)) {
-                return `CAST(at_timezone(${expr}, ${this.sqlTimezoneLiteral(tz)}) AS DATE)`;
-            }
-            // DATE → TIMESTAMP: interpret date in query timezone, return UTC wall clock
-            if (malloy_types_1.TD.isDate(srcTypeDef) && malloy_types_1.TD.isTimestamp(dstTypeDef)) {
-                return `CAST(at_timezone(with_timezone(CAST(${expr} AS TIMESTAMP), ${this.sqlTimezoneLiteral(tz)}), 'UTC') AS TIMESTAMP)`;
-            }
-            // DATE → TIMESTAMPTZ: interpret date in query timezone
-            if (malloy_types_1.TD.isDate(srcTypeDef) && malloy_types_1.TD.isTimestamptz(dstTypeDef)) {
-                return `with_timezone(CAST(${expr} AS TIMESTAMP), ${this.sqlTimezoneLiteral(tz)})`;
-            }
-            // TIMESTAMPTZ → TIMESTAMP: convert to query timezone wall clock
-            if (malloy_types_1.TD.isTimestamptz(srcTypeDef) && malloy_types_1.TD.isTimestamp(dstTypeDef)) {
-                return `CAST(at_timezone(${expr}, ${this.sqlTimezoneLiteral(tz)}) AS TIMESTAMP)`;
-            }
-            // TIMESTAMP → TIMESTAMPTZ: interpret TIMESTAMP as being in query timezone
-            if (malloy_types_1.TD.isTimestamp(srcTypeDef) && malloy_types_1.TD.isTimestamptz(dstTypeDef)) {
-                return `with_timezone(${expr}, ${this.sqlTimezoneLiteral(tz)})`;
-            }
-        }
-        // No special handling needed, or no query timezone
         if (!malloy_types_1.TD.eq(srcTypeDef, dstTypeDef)) {
             const castFunc = cast.safe ? 'TRY_CAST' : 'CAST';
             return `${castFunc}(${expr} AS ${dstSQLType})`;
@@ -567,37 +532,12 @@ ${(0, utils_1.indent)(sql)}
     sqlDateLiteral(_qi, literal) {
         return `DATE '${literal}'`;
     }
-    sqlTimestampLiteral(qi, literal, timezone) {
-        const tz = timezone || qtz(qi);
-        if (tz) {
-            // Interpret wall clock time in timezone, convert to UTC wall clock, cast to TIMESTAMP
-            return `CAST(at_timezone(with_timezone(TIMESTAMP '${literal}', ${this.sqlTimezoneLiteral(tz)}), 'UTC') AS TIMESTAMP)`;
-        }
-        return `TIMESTAMP '${literal}'`;
-    }
     sqlTimestamptzLiteral(_qi, literal, timezone) {
         // Use with_timezone to create a TIMESTAMP WITH TIME ZONE
         return `with_timezone(TIMESTAMP '${literal}', ${this.sqlTimezoneLiteral(timezone)})`;
     }
-    sqlTimeExtractExpr(qi, from) {
-        const pgUnits = pg_impl_1.timeExtractMap[from.units] || from.units;
-        let extractFrom = from.e.sql || '';
-        if (malloy_types_1.TD.isAnyTimestamp(from.e.typeDef)) {
-            const tz = qtz(qi);
-            if (tz) {
-                // Convert both TIMESTAMP and TIMESTAMPTZ to query timezone for extraction
-                if (from.e.typeDef.type === 'timestamp') {
-                    // TIMESTAMP: interpret as UTC, convert to query timezone
-                    extractFrom = `at_timezone(with_timezone(${extractFrom}, 'UTC'), ${this.sqlTimezoneLiteral(tz)})`;
-                }
-                else {
-                    // TIMESTAMPTZ: convert to query timezone
-                    extractFrom = `at_timezone(${extractFrom}, ${this.sqlTimezoneLiteral(tz)})`;
-                }
-            }
-        }
-        const extracted = `EXTRACT(${pgUnits} FROM ${extractFrom})`;
-        return from.units === 'day_of_week' ? `mod(${extracted}+1,7)` : extracted;
+    sqlCivilExtract(expr, units, _civilType) {
+        return trinoExtract(expr, units);
     }
     sqlLiteralRecord(lit) {
         var _a, _b;
@@ -630,91 +570,97 @@ class PrestoDialect extends TrinoDialect {
         return `DATE '${literal}'`;
     }
     sqlTimestampLiteral(qi, literal, timezone) {
-        const tz = timezone || qtz(qi);
-        if (tz) {
-            return `CAST(TIMESTAMP '${literal} ${this.checkedTimezoneName(tz)}' AT TIME ZONE 'UTC' AS TIMESTAMP)`;
+        const tz = timezone !== null && timezone !== void 0 ? timezone : (0, dialect_1.queryZone)(qi);
+        if (tz === 'UTC') {
+            return `TIMESTAMP '${literal}'`;
         }
-        return `TIMESTAMP '${literal}'`;
+        return `CAST(TIMESTAMP '${literal} ${this.checkedTimezoneName(tz)}' AS TIMESTAMP)`;
     }
     sqlTimestamptzLiteral(_qi, literal, timezone) {
         return `TIMESTAMP '${literal} ${this.checkedTimezoneName(timezone)}'`;
     }
-    sqlConvertToCivilTime(expr, timezone, _typeDef) {
-        // Presto's AT TIME ZONE operator (not function) produces TIMESTAMPTZ
-        // Reinterprets the instant in the target timezone
-        return {
-            sql: `${expr} AT TIME ZONE ${this.sqlTimezoneLiteral(timezone)}`,
-            typeDef: { type: 'timestamptz' },
-        };
-    }
-    sqlConvertFromCivilTime(expr, _timezone, destTypeDef) {
-        if (destTypeDef.type === 'timestamptz') {
+    /*
+     * Presto cannot meet the civil contract: its only way to read a date and
+     * time of day as an instant in a zone is to parse a string, which fails
+     * on a time the zone skips. So Presto never converts to civil time. It
+     * places an instant in the zone as a TIMESTAMP WITH TIME ZONE, whose
+     * functions read the clock in that zone and resolve any skipped or
+     * repeated time themselves. A Presto TIMESTAMP is an instant shown in the
+     * session zone, which is UTC.
+     */
+    sqlConvertToCivilTime() {
+        throw new Error('Presto has no civil time');
+    }
+    sqlConvertFromCivilTime() {
+        throw new Error('Presto has no civil time');
+    }
+    /** The instant `expr`, showing the clock of `timezone` */
+    inZone(expr, typeDef, timezone) {
+        if (malloy_types_1.TD.isTimestamp(typeDef) && timezone === 'UTC') {
             return expr;
         }
-        return `CAST(${expr} AT TIME ZONE 'UTC' AS TIMESTAMP)`;
+        return `(${expr}) AT TIME ZONE ${this.sqlTimezoneLiteral(timezone)}`;
     }
-    sqlCast(qi, cast) {
-        const { srcTypeDef, dstTypeDef, dstSQLType } = this.sqlCastPrep(cast);
-        const tz = qtz(qi);
-        const expr = cast.e.sql || '';
-        // Timezone-aware casts when query timezone is set
-        // Presto uses AT TIME ZONE operator instead of Trino's with_timezone/at_timezone functions
-        if (tz && srcTypeDef && dstTypeDef) {
-            // TIMESTAMP → DATE: interpret as UTC, convert to query timezone
-            if (malloy_types_1.TD.isTimestamp(srcTypeDef) && malloy_types_1.TD.isDate(dstTypeDef)) {
-                return `CAST((${expr} AT TIME ZONE 'UTC') AT TIME ZONE ${this.sqlTimezoneLiteral(tz)} AS DATE)`;
-            }
-            // TIMESTAMPTZ → DATE: convert to query timezone
-            if (malloy_types_1.TD.isTimestamptz(srcTypeDef) && malloy_types_1.TD.isDate(dstTypeDef)) {
-                return `CAST(${expr} AT TIME ZONE ${this.sqlTimezoneLiteral(tz)} AS DATE)`;
-            }
-            // DATE → TIMESTAMP: interpret date in query timezone, return UTC wall clock
-            // Presto doesn't have a way to interpret TIMESTAMP in a non-UTC timezone,
-            // so we build a TIMESTAMPTZ literal string and cast it
-            if (malloy_types_1.TD.isDate(srcTypeDef) && malloy_types_1.TD.isTimestamp(dstTypeDef)) {
-                const tstzLiteral = `CAST(CAST(${expr} AS VARCHAR) || ' 00:00:00 ${this.checkedTimezoneName(tz)}' AS TIMESTAMP WITH TIME ZONE)`;
-                return `CAST(${tstzLiteral} AS TIMESTAMP)`;
-            }
-            // DATE → TIMESTAMPTZ: interpret date in query timezone
-            if (malloy_types_1.TD.isDate(srcTypeDef) && malloy_types_1.TD.isTimestamptz(dstTypeDef)) {
-                return `CAST(CAST(${expr} AS VARCHAR) || ' 00:00:00 ${this.checkedTimezoneName(tz)}' AS TIMESTAMP WITH TIME ZONE)`;
-            }
-            // TIMESTAMPTZ → TIMESTAMP: convert to query timezone wall clock
-            if (malloy_types_1.TD.isTimestamptz(srcTypeDef) && malloy_types_1.TD.isTimestamp(dstTypeDef)) {
-                return `CAST(${expr} AT TIME ZONE ${this.sqlTimezoneLiteral(tz)} AS TIMESTAMP)`;
-            }
-            // TIMESTAMP → TIMESTAMPTZ: interpret TIMESTAMP as UTC
-            if (malloy_types_1.TD.isTimestamp(srcTypeDef) && malloy_types_1.TD.isTimestamptz(dstTypeDef)) {
-                return `${expr} AT TIME ZONE 'UTC'`;
-            }
-        }
-        // No special handling needed, or no query timezone
-        if (!malloy_types_1.TD.eq(srcTypeDef, dstTypeDef)) {
-            const castFunc = cast.safe ? 'TRY_CAST' : 'CAST';
-            return `${castFunc}(${expr} AS ${dstSQLType})`;
+    /** An instant from inZone, as a value of `typeDef` */
+    fromZone(expr, typeDef, timezone) {
+        if (malloy_types_1.TD.isTimestamp(typeDef) && timezone !== 'UTC') {
+            return `CAST(${expr} AS TIMESTAMP)`;
         }
         return expr;
     }
     sqlTimeExtractExpr(qi, from) {
-        const pgUnits = pg_impl_1.timeExtractMap[from.units] || from.units;
-        let extractFrom = from.e.sql || '';
-        if (malloy_types_1.TD.isAnyTimestamp(from.e.typeDef)) {
-            const tz = qtz(qi);
-            if (tz) {
-                // Convert both TIMESTAMP and TIMESTAMPTZ to query timezone for extraction
-                if (from.e.typeDef.type === 'timestamp') {
-                    // TIMESTAMP: interpret as UTC, convert to query timezone
-                    // Presto uses AT TIME ZONE operator
-                    extractFrom = `(${extractFrom} AT TIME ZONE 'UTC') AT TIME ZONE ${this.sqlTimezoneLiteral(tz)}`;
-                }
-                else {
-                    // TIMESTAMPTZ: convert to query timezone
-                    extractFrom = `${extractFrom} AT TIME ZONE ${this.sqlTimezoneLiteral(tz)}`;
-                }
+        const time = from.e;
+        const expr = malloy_types_1.TD.isAnyTimestamp(time.typeDef)
+            ? this.inZone(time.sql, time.typeDef, (0, dialect_1.queryZone)(qi))
+            : time.sql;
+        return trinoExtract(expr, from.units);
+    }
+    sqlTruncAndOffset(baseExpr, qi, truncateTo, offset) {
+        const timeType = baseExpr.typeDef;
+        // Adding hours, minutes or seconds to an instant needs no zone
+        const usesQueryZone = malloy_types_1.TD.isAnyTimestamp(timeType) &&
+            (truncateTo !== undefined ||
+                (offset !== undefined && (0, malloy_types_1.isDateUnit)(offset.unit)));
+        const zone = (0, dialect_1.queryZone)(qi);
+        let sql = usesQueryZone
+            ? this.inZone(baseExpr.sql, timeType, zone)
+            : baseExpr.sql;
+        if (truncateTo) {
+            sql = trinoTrunc(sql, truncateTo);
+        }
+        if (offset) {
+            sql = trinoDateAdd(sql, offset.op, offset.magnitude, offset.unit);
+        }
+        return usesQueryZone ? this.fromZone(sql, timeType, zone) : sql;
+    }
+    sqlTimeCast(qi, cast) {
+        var _a;
+        const { srcTypeDef, dstTypeDef } = this.sqlCastPrep(cast);
+        const expr = (_a = cast.e.sql) !== null && _a !== void 0 ? _a : '';
+        const zone = (0, dialect_1.queryZone)(qi);
+        if (malloy_types_1.TD.isAnyTimestamp(srcTypeDef)) {
+            if (malloy_types_1.TD.isDate(dstTypeDef)) {
+                return `CAST(${this.inZone(expr, srcTypeDef, zone)} AS DATE)`;
+            }
+            if (malloy_types_1.TD.isTimestamp(dstTypeDef) && malloy_types_1.TD.isTimestamptz(srcTypeDef)) {
+                return `CAST(${expr} AS TIMESTAMP)`;
+            }
+            if (malloy_types_1.TD.isTimestamptz(dstTypeDef) && malloy_types_1.TD.isTimestamp(srcTypeDef)) {
+                return `(${expr}) AT TIME ZONE 'UTC'`;
+            }
+        }
+        if (malloy_types_1.TD.isDate(srcTypeDef) && malloy_types_1.TD.isAnyTimestamp(dstTypeDef)) {
+            if (zone === 'UTC') {
+                const midnight = `CAST(${expr} AS TIMESTAMP)`;
+                return malloy_types_1.TD.isTimestamp(dstTypeDef)
+                    ? midnight
+                    : `(${midnight}) AT TIME ZONE 'UTC'`;
             }
+            // Fails in a zone which skips the midnight starting the date
+            const midnight = `CAST(CAST(${expr} AS VARCHAR) || ' 00:00:00 ${this.checkedTimezoneName(zone)}' AS TIMESTAMP WITH TIME ZONE)`;
+            return this.fromZone(midnight, dstTypeDef, zone);
         }
-        const extracted = `EXTRACT(${pgUnits} FROM ${extractFrom})`;
-        return from.units === 'day_of_week' ? `mod(${extracted}+1,7)` : extracted;
+        return undefined;
     }
     sqlUnnestAlias(source, alias, _fieldList, needDistinctKey, isArray, _isInNestedPipeline) {
         if (isArray) {

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { DuckDBDialect, StandardSQLDialect, TrinoDialect, PostgresDialect, SnowflakeDialect, MySQLDialect, DatabricksDialect, registerDialect, arg, qtz, overload, minScalar, anyExprType, minAggregate, maxScalar, sql, makeParam, param, variadicParam, literal, spread, Dialect, decodeDottedTablePath, validateDottedTablePath, } from './dialect';
+export { DuckDBDialect, StandardSQLDialect, TrinoDialect, PostgresDialect, SnowflakeDialect, MySQLDialect, DatabricksDialect, SQLServerDialect, registerDialect, getDialect, arg, queryZone, overload, minScalar, anyExprType, minAggregate, maxScalar, sql, makeParam, param, variadicParam, literal, spread, Dialect, decodeDottedTablePath, validateDottedTablePath, } from './dialect';
 export type { DialectFieldList, DialectFunctionOverloadDef, QueryInfo, MalloyStandardFunctionImplementations, DefinitionBlueprint, DefinitionBlueprintMap, OverloadedDefinitionBlueprint, DecodeDottedTablePathResult, DottedTablePathOptions, TablePathEscapeStyle, TablePathSegment, ValidateTablePathResult, } from './dialect';
 export type { QueryRecord, StructDef, TableSourceDef, SQLSourceDef, SourceDef, JoinFieldDef, NamedSourceDefs, MalloyQueryData, DateUnit, ExtractUnit, TimestampUnit, TemporalFieldType, QueryData, QueryValue, Expr, FilterCondition, Argument, Parameter, FieldDef, PipeSegment, QueryFieldDef, IndexFieldDef, TurtleDef, SearchValueMapResult, SearchIndexResult, ModelDef, Query, QueryResult, QueryResultDef, QueryRunStats, QueryScalar, NamedQueryDef, NamedModelObject, ExpressionType, FunctionDef, FunctionOverloadDef, FunctionParameterDef, ExpressionValueType, TypeDesc, FunctionParamTypeDesc, DocumentLocation, DocumentRange, DocumentPosition, Sampling, BasicAtomicTypeDef, BasicAtomicDef, AtomicTypeDef, AtomicFieldDef, ArrayDef, ArrayTypeDef, RecordTypeDef, RepeatedRecordTypeDef, RecordDef, RepeatedRecordDef, RecordLiteralNode, StringLiteralNode, ArrayLiteralNode, SourceComponentInfo, DateLiteralNode, TimestampLiteralNode, TimestamptzLiteralNode, TimeLiteralExpr, TypecastExpr, BuildID, BuildManifest, BuildManifestEntry, GivenValue, VirtualMap, } from './model';
 export { isSourceDef, isAtomic, isBasicAtomic, isCompoundArrayData, isJoined, isJoinedSource, isSamplingEnable, isSamplingPercent, isSamplingRows, isRepeatedRecord, isBasicArray, mkArrayDef, mkFieldDef, expressionIsAggregate, expressionIsAnalytic, expressionIsCalculation, expressionIsScalar, expressionIsUngroupedAggregate, indent, composeSQLExpr, isTimestampUnit, isDateUnit, constantExprToSQL, } from './model';
@@ -25,7 +25,7 @@ export { routeOf, payloadOf, annotationsForRoute, tagFromAnnotations, } from './
 /** @deprecated — use the `.annotations` view on a Foundation entity
  *  (`entity.annotations.parseAsTag(route)` / `.texts(route)`). */
 export { annotationToTag, annotationToTaglines, } from './api/foundation/annotation';
-export type { BuildGraph, BuildNode, BuildPlan, BuildTarget, BuildTargets, ConnectionBuild, } from './api/foundation';
+export type { BuildGraph, BuildNode, BuildPlan, BuildTarget, BuildTargetOptions, BuildTargets, ConnectionBuild, UnbuildableSource, } from './api/foundation';
 export { PersistSource, EMPTY_BUILD_MANIFEST } from './api/foundation';
 export { Reference } from './api/foundation';
 export type { ReferenceKind } from './api/foundation';