@malloydata/malloy 0.0.435 → 0.0.436

package/dist/dialect/sqlserver/sqlserver.js

@@ -54,6 +54,7 @@ const sqlServerToMalloyTypes = {
     'datetime': { type: 'timestamp' },
     'datetime2': { type: 'timestamp' },
     'smalldatetime': { type: 'timestamp' },
+    'datetimeoffset': { type: 'timestamptz' },
 };
 function parseSQLServerType(sqlType) {
     var _a, _b;
@@ -160,7 +161,9 @@ class SQLServerDialect extends dialect_1.Dialect {
         // condition is expected, `true` and `false` are (1=1) and (1=0), a `bit`
         // column is an integer, and a cast to boolean is refused.
         this.booleanType = 'none';
-        this.hasTimestamptz = false;
+        // A datetimeoffset is an instant. Its clock is read at UTC, or in the
+        // query's time zone, never at the offset it was written in.
+        this.hasTimestamptz = true;
         // A bigint arrives from the driver as text and is read as a JavaScript number
         this.supportsBigIntPrecision = false;
         this.maxIdentifierLength = 128;
@@ -202,6 +205,8 @@ class SQLServerDialect extends dialect_1.Dialect {
                 return 'DATE';
             case 'timestamp':
                 return 'DATETIME2';
+            case 'timestamptz':
+                return 'DATETIMEOFFSET';
             case 'record':
             case 'array':
                 return 'NVARCHAR(MAX)';
@@ -374,42 +379,31 @@ class SQLServerDialect extends dialect_1.Dialect {
     sqlNowExpr() {
         return 'SYSUTCDATETIME()';
     }
-    sqlTimeExtractExpr(qi, from) {
-        let extractFrom = from.e.sql;
-        if (malloy_types_1.TD.isAnyTimestamp(from.e.typeDef)) {
-            const tz = (0, dialect_1.qtz)(qi);
-            if (tz) {
-                extractFrom = this.sqlConvertToCivilTime(extractFrom !== null && extractFrom !== void 0 ? extractFrom : '', tz, from.e.typeDef).sql;
-            }
-        }
-        if (from.units === 'day_of_week') {
+    sqlCivilExtract(expr, units, _civilType) {
+        if (units === 'day_of_week') {
             // Days since a Sunday, so the answer does not follow DATEFIRST
-            return `((DATEDIFF(day, '19000107', ${extractFrom}) % 7 + 7) % 7 + 1)`;
+            return `((DATEDIFF(day, '19000107', ${expr}) % 7 + 7) % 7 + 1)`;
         }
         // Malloy's week of the year is the ISO week; DATEPART(week) counts from
         // January 1st and follows DATEFIRST
-        const part = from.units === 'week' ? 'iso_week' : datePartMap[from.units];
+        const part = units === 'week' ? 'iso_week' : datePartMap[units];
         if (part === undefined) {
-            throw new Error(`Unknown SQL Server date part '${from.units}'`);
+            throw new Error(`Unknown SQL Server date part '${units}'`);
         }
-        return `DATEPART(${part}, ${extractFrom})`;
+        return `DATEPART(${part}, ${expr})`;
+    }
+    sqlCivilToDate(expr) {
+        return `CAST(${expr} AS DATE)`;
     }
-    sqlCast(qi, cast) {
+    sqlDateToCivil(expr) {
+        return `CAST(${expr} AS DATETIME2)`;
+    }
+    sqlCast(_qi, cast) {
         const expr = cast.e.sql || '';
         const { srcTypeDef, dstTypeDef, dstSQLType } = this.sqlCastPrep(cast);
         if ((dstTypeDef === null || dstTypeDef === void 0 ? void 0 : dstTypeDef.type) === 'boolean') {
             return this.unsupported('a cast to boolean: there are no boolean values');
         }
-        const tz = (0, dialect_1.qtz)(qi);
-        if (tz && srcTypeDef && dstTypeDef) {
-            if (malloy_types_1.TD.isTimestamp(srcTypeDef) && malloy_types_1.TD.isDate(dstTypeDef)) {
-                const civil = this.sqlConvertToCivilTime(expr, tz, srcTypeDef).sql;
-                return `CAST(${civil} AS DATE)`;
-            }
-            if (malloy_types_1.TD.isDate(srcTypeDef) && malloy_types_1.TD.isTimestamp(dstTypeDef)) {
-                return this.sqlConvertFromCivilTime(`CAST(${expr} AS DATETIME2)`, tz, dstTypeDef);
-            }
-        }
         if (!malloy_types_1.TD.eq(srcTypeDef, dstTypeDef)) {
             const castFunc = cast.safe ? 'TRY_CAST' : 'CAST';
             return `${castFunc}(${expr} AS ${dstSQLType})`;
@@ -422,16 +416,11 @@ class SQLServerDialect extends dialect_1.Dialect {
     sqlDateLiteral(_qi, literal) {
         return `CAST('${literal}' AS DATE)`;
     }
-    sqlTimestampLiteral(qi, literal, timezone) {
-        const tz = timezone || (0, dialect_1.qtz)(qi);
-        const ts = `CAST('${literal}' AS DATETIME2)`;
-        if (tz) {
-            return this.sqlConvertFromCivilTime(ts, tz, { type: 'timestamp' });
-        }
-        return ts;
+    sqlCivilLiteral(literal) {
+        return `CAST('${literal}' AS DATETIME2)`;
     }
-    sqlTimestamptzLiteral(_qi, _literal, _timezone) {
-        throw new Error('SQL Server dialect does not support timestamptz');
+    sqlTimestamptzLiteral(_qi, literal, timezone) {
+        return this.sqlConvertFromCivilTime(this.sqlCivilLiteral(literal), timezone, { type: 'timestamptz' });
     }
     // AT TIME ZONE takes a Windows time zone name
     sqlTimezoneLiteral(timezone) {
@@ -441,24 +430,34 @@ class SQLServerDialect extends dialect_1.Dialect {
         }
         return this.sqlLiteralString(windowsName);
     }
-    sqlConvertToCivilTime(expr, timezone, _typeDef) {
+    // Civil time is a datetime2, which has no zone. AT TIME ZONE 'UTC' labels
+    // a datetime2 as UTC and moves a datetimeoffset to UTC, so one expression
+    // reads the clock of either; a CAST alone would read a datetimeoffset's
+    // clock at the offset it was written in.
+    sqlConvertToCivilTime(expr, timezone, typeDef) {
         if (timezone === 'UTC') {
-            return { sql: expr, typeDef: { type: 'timestamp' } };
+            return malloy_types_1.TD.isTimestamptz(typeDef)
+                ? `CAST((${expr} AT TIME ZONE 'UTC') AS DATETIME2)`
+                : expr;
         }
         const tz = this.sqlTimezoneLiteral(timezone);
-        return {
-            sql: `CAST((${expr} AT TIME ZONE 'UTC') AT TIME ZONE ${tz} AS DATETIME2)`,
-            typeDef: { type: 'timestamp' },
-        };
-    }
-    sqlConvertFromCivilTime(expr, timezone, _destTypeDef) {
+        return `CAST((${expr} AT TIME ZONE 'UTC') AT TIME ZONE ${tz} AS DATETIME2)`;
+    }
+    sqlConvertFromCivilTime(expr, timezone, destTypeDef) {
+        if (malloy_types_1.TD.isTimestamptz(destTypeDef)) {
+            // A datetime2 cast to datetimeoffset is at +00:00
+            return timezone === 'UTC'
+                ? `CAST(${expr} AS DATETIMEOFFSET)`
+                : `(${expr} AT TIME ZONE ${this.sqlTimezoneLiteral(timezone)})`;
+        }
         if (timezone === 'UTC') {
             return expr;
         }
         const tz = this.sqlTimezoneLiteral(timezone);
         return `CAST((${expr} AT TIME ZONE ${tz}) AT TIME ZONE 'UTC' AS DATETIME2)`;
     }
-    sqlTruncate(expr, unit, typeDef, _inCivilTime, _timezone) {
+    sqlTruncate(expr, unit, civilType) {
+        const isDate = civilType === dialect_1.CivilTime.Date;
         // Truncation is DATEADD of the whole units since an anchor: 1900-01-01
         // for a calendar unit, the value's own midnight for a clock unit, so the
         // count fits an int. SQL Server 2017 has no DATETRUNC.
@@ -466,25 +465,25 @@ class SQLServerDialect extends dialect_1.Dialect {
         if (unit === 'week') {
             // Malloy weeks start on Sunday whatever DATEFIRST says, so count days
             // from a known Sunday.
-            const day = malloy_types_1.TD.isDate(typeDef) ? expr : midnight;
+            const day = isDate ? expr : midnight;
             return `DATEADD(day, -((DATEDIFF(day, '19000107', ${expr}) % 7 + 7) % 7), ${day})`;
         }
         const part = datePartMap[unit];
         if (part === undefined) {
             throw new Error(`Unknown SQL Server date part '${unit}'`);
         }
-        if (unit === 'day' && !malloy_types_1.TD.isDate(typeDef)) {
+        if (unit === 'day' && !isDate) {
             return midnight;
         }
         if (unit === 'hour' || unit === 'minute' || unit === 'second') {
             return `DATEADD(${part}, DATEDIFF(${part}, ${midnight}, ${expr}), ${midnight})`;
         }
         const truncated = `DATEADD(${part}, DATEDIFF(${part}, '19000101', ${expr}), '19000101')`;
-        return malloy_types_1.TD.isDate(typeDef)
+        return isDate
             ? `CAST(${truncated} AS DATE)`
             : `CAST(${truncated} AS DATETIME2)`;
     }
-    sqlOffsetTime(expr, op, magnitude, unit, _typeDef, _inCivilTime, _timezone) {
+    sqlOffsetTime(expr, op, magnitude, unit, _civilType) {
         const part = datePartMap[unit];
         if (part === undefined) {
             throw new Error(`Unknown SQL Server date part '${unit}'`);

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[];