@malloydata/malloy 0.0.435 → 0.0.437

package/dist/dialect/index.js

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: MIT
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateDottedTablePath = exports.decodeDottedTablePath = exports.TinyParser = exports.getMalloyStandardFunctions = exports.registerDialect = exports.getDialect = exports.SQLServerDialect = exports.DatabricksDialect = exports.MySQLDialect = exports.TrinoDialect = exports.SnowflakeDialect = exports.DuckDBDialect = exports.PostgresDialect = exports.StandardSQLDialect = exports.qtz = exports.Dialect = exports.sql = exports.literal = exports.variadicParam = exports.param = exports.spread = exports.maxScalar = exports.minAggregate = exports.minScalar = exports.overload = exports.makeParam = exports.anyExprType = exports.arg = void 0;
+exports.validateDottedTablePath = exports.decodeDottedTablePath = exports.TinyParser = exports.getMalloyStandardFunctions = exports.registerDialect = exports.getDialect = exports.SQLServerDialect = exports.DatabricksDialect = exports.MySQLDialect = exports.TrinoDialect = exports.SnowflakeDialect = exports.DuckDBDialect = exports.PostgresDialect = exports.StandardSQLDialect = exports.queryZone = exports.Dialect = exports.sql = exports.literal = exports.variadicParam = exports.param = exports.spread = exports.maxScalar = exports.minAggregate = exports.minScalar = exports.overload = exports.makeParam = exports.anyExprType = exports.arg = void 0;
 var util_1 = require("./functions/util");
 Object.defineProperty(exports, "arg", { enumerable: true, get: function () { return util_1.arg; } });
 Object.defineProperty(exports, "anyExprType", { enumerable: true, get: function () { return util_1.anyExprType; } });
@@ -20,7 +20,7 @@ Object.defineProperty(exports, "literal", { enumerable: true, get: function () {
 Object.defineProperty(exports, "sql", { enumerable: true, get: function () { return util_1.sql; } });
 var dialect_1 = require("./dialect");
 Object.defineProperty(exports, "Dialect", { enumerable: true, get: function () { return dialect_1.Dialect; } });
-Object.defineProperty(exports, "qtz", { enumerable: true, get: function () { return dialect_1.qtz; } });
+Object.defineProperty(exports, "queryZone", { enumerable: true, get: function () { return dialect_1.queryZone; } });
 var standardsql_1 = require("./standardsql");
 Object.defineProperty(exports, "StandardSQLDialect", { enumerable: true, get: function () { return standardsql_1.StandardSQLDialect; } });
 var postgres_1 = require("./postgres");

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

@@ -1,5 +1,5 @@
-import type { Sampling, MeasureTimeExpr, RegexMatchExpr, TimeExtractExpr, TypecastExpr, BasicAtomicTypeDef, AtomicTypeDef, TimestampTypeDef, ArrayLiteralNode, RecordLiteralNode } from '../../model/malloy_types';
-import type { BooleanTypeSupport, CompiledOrderBy, DialectFieldList, FieldReferenceType, OrderByClauseType, QueryInfo } from '../dialect';
+import type { Sampling, MeasureTimeExpr, RegexMatchExpr, TypecastExpr, BasicAtomicTypeDef, AtomicTypeDef, ArrayLiteralNode, RecordLiteralNode, ATimestampTypeDef, TimestampUnit, ExtractUnit } from '../../model/malloy_types';
+import type { CivilTime, BooleanTypeSupport, CompiledOrderBy, DialectFieldList, FieldReferenceType, OrderByClauseType, QueryInfo } from '../dialect';
 import { Dialect } from '../dialect';
 import type { DialectFunctionOverloadDef } from '../functions';
 export declare class MySQLDialect extends Dialect {
@@ -60,18 +60,17 @@ export declare class MySQLDialect extends Dialect {
     sqlSelectAliasAsStruct(_alias: string, _fieldList: DialectFieldList): string;
     sqlCreateTableAsSelect(_tableName: string, _sql: string): string;
     sqlNowExpr(): string;
-    sqlConvertToCivilTime(expr: string, timezone: string, _typeDef: AtomicTypeDef): {
-        sql: string;
-        typeDef: AtomicTypeDef;
-    };
-    sqlConvertFromCivilTime(expr: string, timezone: string, _destTypeDef: TimestampTypeDef): string;
-    sqlTruncate(expr: string, unit: string, _typeDef: AtomicTypeDef, _inCivilTime: boolean, _timezone?: string): string;
-    sqlOffsetTime(expr: string, op: '+' | '-', magnitude: string, unit: string, _typeDef: AtomicTypeDef, _inCivilTime: boolean, _timezone?: string): string;
-    sqlTimeExtractExpr(qi: QueryInfo, te: TimeExtractExpr): string;
-    sqlCast(qi: QueryInfo, cast: TypecastExpr): string;
+    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;
+    sqlCivilExtract(expr: string, units: ExtractUnit, _civilType: CivilTime): string;
+    sqlCivilToDate(expr: string): string;
+    sqlDateToCivil(expr: string): string;
+    sqlCast(_qi: QueryInfo, cast: TypecastExpr): string;
     sqlRegexpMatch(df: 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(df: MeasureTimeExpr): string;
     sqlAggDistinct(_key: string, _values: string[], _func: (valNames: string[]) => string): string;

package/dist/dialect/mysql/mysql.js

@@ -351,17 +351,18 @@ class MySQLDialect extends dialect_1.Dialect {
     sqlNowExpr() {
         return 'LOCALTIMESTAMP';
     }
+    // Civil time is a DATETIME, which has no zone
     sqlConvertToCivilTime(expr, timezone, _typeDef) {
-        // MySQL has no timestamptz type, so typeDef.timestamptz will never be true
-        return {
-            sql: `CONVERT_TZ(${expr}, 'UTC', ${this.sqlTimezoneLiteral(timezone)})`,
-            typeDef: { type: 'timestamp' },
-        };
+        return timezone === 'UTC'
+            ? expr
+            : `CONVERT_TZ(${expr}, 'UTC', ${this.sqlTimezoneLiteral(timezone)})`;
     }
     sqlConvertFromCivilTime(expr, timezone, _destTypeDef) {
-        return `CONVERT_TZ(${expr}, ${this.sqlTimezoneLiteral(timezone)}, 'UTC')`;
+        return timezone === 'UTC'
+            ? expr
+            : `CONVERT_TZ(${expr}, ${this.sqlTimezoneLiteral(timezone)}, 'UTC')`;
     }
-    sqlTruncate(expr, unit, _typeDef, _inCivilTime, _timezone) {
+    sqlTruncate(expr, unit, _civilType) {
         // For week truncation, adjust to Sunday first
         // DAYOFWEEK returns 1=Sunday, 2=Monday, etc., so subtract (DAYOFWEEK-1) days
         const adjustedExpr = unit === 'week'
@@ -392,7 +393,7 @@ class MySQLDialect extends dialect_1.Dialect {
         }
         return `TIMESTAMP(DATE_FORMAT(${adjustedExpr}, ${format}))`;
     }
-    sqlOffsetTime(expr, op, magnitude, unit, _typeDef, _inCivilTime, _timezone) {
+    sqlOffsetTime(expr, op, magnitude, unit, _civilType) {
         // Convert quarter/week to supported units
         let offsetUnit = unit;
         let offsetMag = magnitude;
@@ -407,27 +408,18 @@ class MySQLDialect extends dialect_1.Dialect {
         const interval = `INTERVAL ${offsetMag} ${offsetUnit}`;
         return `(${expr} ${op} ${interval})`;
     }
-    sqlTimeExtractExpr(qi, te) {
-        const msUnits = msExtractionMap[te.units] || te.units;
-        let extractFrom = te.e.sql;
-        if (malloy_types_1.TD.isTimestamp(te.e.typeDef)) {
-            const tz = (0, dialect_1.qtz)(qi);
-            if (tz) {
-                extractFrom = `CONVERT_TZ(${extractFrom}, 'UTC', ${this.sqlTimezoneLiteral(tz)})`;
-            }
-        }
-        return `${msUnits}(${extractFrom})`;
+    sqlCivilExtract(expr, units, _civilType) {
+        return `${msExtractionMap[units] || units}(${expr})`;
+    }
+    sqlCivilToDate(expr) {
+        return `CAST(${expr} AS DATE)`;
+    }
+    sqlDateToCivil(expr) {
+        return `CAST(${expr} AS DATETIME)`;
     }
-    sqlCast(qi, cast) {
+    sqlCast(_qi, cast) {
         const srcSQL = cast.e.sql || 'internal-error-in-sql-generation';
-        const { op, srcTypeDef, dstTypeDef, dstSQLType } = this.sqlCastPrep(cast);
-        const tz = (0, dialect_1.qtz)(qi);
-        if (op === 'timestamp::date' && tz) {
-            return `CAST(CONVERT_TZ(${srcSQL}, 'UTC', ${this.sqlTimezoneLiteral(tz)}) AS DATE) `;
-        }
-        else if (op === 'date::timestamp' && tz) {
-            return ` CONVERT_TZ(${srcSQL}, ${this.sqlTimezoneLiteral(tz)}, 'UTC')`;
-        }
+        const { srcTypeDef, dstTypeDef, dstSQLType } = this.sqlCastPrep(cast);
         if (!malloy_types_1.TD.eq(srcTypeDef, dstTypeDef)) {
             if (cast.safe) {
                 throw new Error("Mysql dialect doesn't support Safe Cast");
@@ -445,11 +437,7 @@ class MySQLDialect extends dialect_1.Dialect {
     sqlDateLiteral(_qi, literal) {
         return `DATE '${literal}'`;
     }
-    sqlTimestampLiteral(qi, literal, timezone) {
-        const tz = timezone || (0, dialect_1.qtz)(qi);
-        if (tz) {
-            return `CONVERT_TZ('${literal}', ${this.sqlTimezoneLiteral(tz)}, 'UTC')`;
-        }
+    sqlCivilLiteral(literal) {
         return `TIMESTAMP '${literal}'`;
     }
     sqlTimestamptzLiteral(_qi, _literal, _timezone) {

package/dist/dialect/pg_impl.d.ts

@@ -1,5 +1,5 @@
-import type { ArrayLiteralNode, AtomicTypeDef, ATimestampTypeDef, RecordLiteralNode, RegexMatchExpr, TimeExtractExpr, TimestampUnit, TypecastExpr } from '../model/malloy_types';
-import type { QueryInfo } from './dialect';
+import type { ArrayLiteralNode, ATimestampTypeDef, RecordLiteralNode, ExtractUnit, RegexMatchExpr, TimestampUnit, TypecastExpr } from '../model/malloy_types';
+import type { CivilTime, QueryInfo } from './dialect';
 import { Dialect } from './dialect';
 export declare const timeExtractMap: Record<string, string>;
 /**
@@ -14,18 +14,17 @@ export declare abstract class PostgresBase extends Dialect {
     identifierQuoteChar: string;
     sqlLiteralString(literal: string): string;
     sqlNowExpr(): string;
-    sqlTimeExtractExpr(qi: QueryInfo, from: TimeExtractExpr): string;
-    sqlCast(qi: QueryInfo, cast: TypecastExpr): string;
+    sqlCivilExtract(expr: string, units: ExtractUnit, _civilType: CivilTime): string;
+    sqlCast(_qi: QueryInfo, cast: TypecastExpr): string;
     sqlRegexpMatch(df: 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;
     sqlLiteralRecord(_lit: RecordLiteralNode): string;
     sqlLiteralArray(lit: ArrayLiteralNode): string;
-    sqlConvertToCivilTime(expr: string, timezone: string, typeDef: AtomicTypeDef): {
-        sql: string;
-        typeDef: AtomicTypeDef;
-    };
+    sqlConvertToCivilTime(expr: string, timezone: string, typeDef: ATimestampTypeDef): string;
     sqlConvertFromCivilTime(expr: string, timezone: string, destTypeDef: ATimestampTypeDef): string;
-    sqlTruncate(expr: string, unit: TimestampUnit, _typeDef: AtomicTypeDef, inCivilTime: boolean, _timezone?: string): string;
+    sqlTruncate(expr: string, unit: TimestampUnit, _civilType: CivilTime): string;
+    sqlCivilToDate(expr: string): string;
+    sqlDateToCivil(expr: string): string;
 }

package/dist/dialect/pg_impl.js

@@ -39,46 +39,13 @@ class PostgresBase extends dialect_1.Dialect {
     sqlNowExpr() {
         return 'LOCALTIMESTAMP';
     }
-    sqlTimeExtractExpr(qi, from) {
-        const units = exports.timeExtractMap[from.units] || from.units;
-        let extractFrom = from.e.sql;
-        if (malloy_types_1.TD.isAnyTimestamp(from.e.typeDef)) {
-            const tz = (0, dialect_1.qtz)(qi);
-            if (tz) {
-                extractFrom = `(${extractFrom}::TIMESTAMPTZ AT TIME ZONE ${this.sqlTimezoneLiteral(tz)})`;
-            }
-        }
-        const extracted = `EXTRACT(${units} FROM ${extractFrom})`;
-        return from.units === 'day_of_week' ? `(${extracted}+1)` : extracted;
+    sqlCivilExtract(expr, units, _civilType) {
+        const extracted = `EXTRACT(${exports.timeExtractMap[units] || units} FROM ${expr})`;
+        return units === 'day_of_week' ? `(${extracted}+1)` : extracted;
     }
-    sqlCast(qi, cast) {
+    sqlCast(_qi, cast) {
         const expr = cast.e.sql || '';
         const { srcTypeDef, dstTypeDef, dstSQLType } = this.sqlCastPrep(cast);
-        const tz = (0, dialect_1.qtz)(qi);
-        // Timezone-aware casts when query timezone is set
-        if (tz && srcTypeDef && dstTypeDef) {
-            // TIMESTAMP → DATE: convert via TIMESTAMPTZ to query timezone
-            if (malloy_types_1.TD.isTimestamp(srcTypeDef) && malloy_types_1.TD.isDate(dstTypeDef)) {
-                return `CAST((${expr}::TIMESTAMPTZ) 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 timestamp
-            if (malloy_types_1.TD.isDate(srcTypeDef) && malloy_types_1.TD.isTimestamp(dstTypeDef)) {
-                return `CAST((${expr})::TIMESTAMP AT TIME ZONE ${this.sqlTimezoneLiteral(tz)} AS TIMESTAMP)`;
-            }
-            // DATE → TIMESTAMPTZ: interpret date in query timezone
-            if (malloy_types_1.TD.isDate(srcTypeDef) && malloy_types_1.TD.isTimestamptz(dstTypeDef)) {
-                return `(${expr})::TIMESTAMP AT TIME ZONE ${this.sqlTimezoneLiteral(tz)}`;
-            }
-            // TIMESTAMPTZ → TIMESTAMP: convert to query timezone (returns TIMESTAMP)
-            if (malloy_types_1.TD.isTimestamptz(srcTypeDef) && malloy_types_1.TD.isTimestamp(dstTypeDef)) {
-                return `(${expr}) AT TIME ZONE ${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})`;
@@ -91,11 +58,7 @@ class PostgresBase extends dialect_1.Dialect {
     sqlDateLiteral(_qi, literal) {
         return `DATE '${literal}'`;
     }
-    sqlTimestampLiteral(qi, literal, timezone) {
-        const tz = timezone || (0, dialect_1.qtz)(qi);
-        if (tz) {
-            return `TIMESTAMPTZ '${literal} ${this.checkedTimezoneName(tz)}'::TIMESTAMP`;
-        }
+    sqlCivilLiteral(literal) {
         return `TIMESTAMP '${literal}'`;
     }
     sqlTimestamptzLiteral(_qi, literal, timezone) {
@@ -109,44 +72,35 @@ class PostgresBase extends dialect_1.Dialect {
         return 'ARRAY[' + array.join(',') + ']';
     }
     sqlConvertToCivilTime(expr, timezone, typeDef) {
-        // PostgreSQL/DuckDB: AT TIME ZONE is polymorphic
-        // For timestamptz (TIMESTAMPTZ): AT TIME ZONE converts to plain TIMESTAMP (civil in timezone)
-        if (typeDef.type === 'timestamptz') {
-            return {
-                sql: `(${expr}) AT TIME ZONE ${this.sqlTimezoneLiteral(timezone)}`,
-                typeDef: { type: 'timestamp' },
-            };
+        const tz = this.sqlTimezoneLiteral(timezone);
+        if (malloy_types_1.TD.isTimestamptz(typeDef)) {
+            return `(${expr}) AT TIME ZONE ${tz}`;
         }
-        // For plain timestamps: cast to TIMESTAMPTZ (interprets as UTC)
-        // Then AT TIME ZONE converts to plain TIMESTAMP (civil in timezone)
-        return {
-            sql: `(${expr})::TIMESTAMPTZ AT TIME ZONE ${this.sqlTimezoneLiteral(timezone)}`,
-            typeDef: { type: 'timestamp' },
-        };
+        return timezone === 'UTC'
+            ? expr
+            : `(${expr})::TIMESTAMPTZ AT TIME ZONE ${tz}`;
     }
     sqlConvertFromCivilTime(expr, timezone, destTypeDef) {
-        if (destTypeDef.type === 'timestamptz') {
-            return `(${expr}) AT TIME ZONE ${this.sqlTimezoneLiteral(timezone)}`;
+        const tz = this.sqlTimezoneLiteral(timezone);
+        if (malloy_types_1.TD.isTimestamptz(destTypeDef)) {
+            return `(${expr}) AT TIME ZONE ${tz}`;
         }
-        return `((${expr}) AT TIME ZONE ${this.sqlTimezoneLiteral(timezone)})::TIMESTAMP`;
+        return timezone === 'UTC'
+            ? expr
+            : `((${expr}) AT TIME ZONE ${tz})::TIMESTAMP`;
     }
-    sqlTruncate(expr, unit, _typeDef, inCivilTime, _timezone) {
-        // PostgreSQL/DuckDB starts weeks on Monday, Malloy wants Sunday
-        // Add 1 day before truncating, subtract 1 day after
-        let truncated;
+    sqlTruncate(expr, unit, _civilType) {
+        // Weeks start on Monday here, so truncate the following day
         if (unit === 'week') {
-            truncated = `(DATE_TRUNC('${unit}', (${expr} + INTERVAL '1' DAY)) - INTERVAL '1' DAY)`;
-        }
-        else {
-            truncated = `DATE_TRUNC('${unit}', ${expr})`;
+            return `(DATE_TRUNC('${unit}', (${expr} + INTERVAL '1' DAY)) - INTERVAL '1' DAY)`;
         }
-        // DATE_TRUNC returns DATE for calendar units (day/week/month/quarter/year)
-        // When in civil time (plain TIMESTAMP), cast DATE back to TIMESTAMP to continue operations
-        const calendarUnits = ['day', 'week', 'month', 'quarter', 'year'];
-        if (inCivilTime && calendarUnits.includes(unit)) {
-            return `(${truncated})::TIMESTAMP`;
-        }
-        return truncated;
+        return `DATE_TRUNC('${unit}', ${expr})`;
+    }
+    sqlCivilToDate(expr) {
+        return `CAST(${expr} AS DATE)`;
+    }
+    sqlDateToCivil(expr) {
+        return `CAST(${expr} AS TIMESTAMP)`;
     }
 }
 exports.PostgresBase = PostgresBase;

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

@@ -1,6 +1,6 @@
-import type { Sampling, AtomicTypeDef, TypecastExpr, MeasureTimeExpr, BasicAtomicTypeDef, RecordLiteralNode, ArrayLiteralNode, TimeExtractExpr, TimestampUnit } from '../../model/malloy_types';
+import type { Sampling, AtomicTypeDef, TypecastExpr, MeasureTimeExpr, BasicAtomicTypeDef, RecordLiteralNode, ArrayLiteralNode, TimestampUnit, ExtractUnit } from '../../model/malloy_types';
 import type { DialectFunctionOverloadDef } from '../functions';
-import { type CompiledOrderBy, type DialectFieldList, type FieldReferenceType, type QueryInfo } from '../dialect';
+import { type CompiledOrderBy, type DialectFieldList, type FieldReferenceType, type QueryInfo, type CivilTime } from '../dialect';
 import { PostgresBase } from '../pg_impl';
 export declare class PostgresDialect extends PostgresBase {
     name: string;
@@ -46,7 +46,7 @@ export declare class PostgresDialect extends PostgresBase {
     sqlFinalStage(lastStageName: string, _fields: string[]): string;
     sqlSelectAliasAsStruct(alias: string): string;
     sqlCreateTableAsSelect(_tableName: string, _sql: string): string;
-    sqlOffsetTime(expr: string, op: '+' | '-', magnitude: string, unit: TimestampUnit, _typeDef: AtomicTypeDef, _inCivilTime: boolean, _timezone?: string): string;
+    sqlOffsetTime(expr: string, op: '+' | '-', magnitude: string, unit: TimestampUnit, _civilType: CivilTime): string;
     sqlCast(qi: QueryInfo, cast: TypecastExpr): string;
     sqlMeasureTimeExpr(df: MeasureTimeExpr): string;
     sqlSumDistinct(key: string, value: string, funcName: string): string;
@@ -66,5 +66,5 @@ export declare class PostgresDialect extends PostgresBase {
     validateTypeName(sqlType: string): boolean;
     sqlLiteralRecord(lit: RecordLiteralNode): string;
     sqlLiteralArray(lit: ArrayLiteralNode): string;
-    sqlTimeExtractExpr(qi: QueryInfo, from: TimeExtractExpr): string;
+    sqlCivilExtract(expr: string, units: ExtractUnit, _civilType: CivilTime): string;
 }

package/dist/dialect/postgres/postgres.js

@@ -200,7 +200,7 @@ class PostgresDialect extends pg_impl_1.PostgresBase {
     sqlCreateTableAsSelect(_tableName, _sql) {
         throw new Error('Not implemented Yet');
     }
-    sqlOffsetTime(expr, op, magnitude, unit, _typeDef, _inCivilTime, _timezone) {
+    sqlOffsetTime(expr, op, magnitude, unit, _civilType) {
         // Convert quarter/week to supported units
         let offsetUnit = unit;
         let offsetMag = magnitude;
@@ -281,14 +281,18 @@ class PostgresDialect extends pg_impl_1.PostgresBase {
         // PostgreSQL requires CAST to NUMERIC before ROUND, which is different
         // than the generic implementation of sqlSumDistinct, but is OK in
         // PostgreSQL because NUMERIC has arbitrary precision.
+        // The sum stays NUMERIC so later stages and derived expressions see the
+        // exact value. A DOUBLE PRECISION cast would keep only ~16 digits. The
+        // ROUND(..., 9) leaves a scale of 9, which would show up in string
+        // conversions as trailing zeros; trim_scale removes it.
         const roundedValue = `ROUND(CAST(COALESCE(${value}, 0) AS NUMERIC), 9)`;
         const sumSQL = `SUM(DISTINCT ${roundedValue} + ${hashKey}) - SUM(DISTINCT ${hashKey})`;
-        const ret = `CAST(${sumSQL} AS DOUBLE PRECISION)`;
+        const ret = `trim_scale(${sumSQL})`;
         if (funcName === 'SUM') {
             return ret;
         }
         else if (funcName === 'AVG') {
-            return `(${ret})/NULLIF(COUNT(DISTINCT CASE WHEN ${value} IS NOT NULL THEN ${key} END), 0)`;
+            return `trim_scale((${sumSQL})/NULLIF(COUNT(DISTINCT CASE WHEN ${value} IS NOT NULL THEN ${key} END), 0))`;
         }
         throw new Error(`Unknown Symmetric Aggregate function ${funcName}`);
     }
@@ -387,19 +391,11 @@ class PostgresDialect extends pg_impl_1.PostgresBase {
         const array = lit.kids.values.map(val => val.sql);
         return 'JSONB_BUILD_ARRAY(' + array.join(',') + ')';
     }
-    sqlTimeExtractExpr(qi, from) {
-        const units = pg_impl_1.timeExtractMap[from.units] || from.units;
-        let extractFrom = from.e.sql;
-        if (malloy_types_1.TD.isAnyTimestamp(from.e.typeDef)) {
-            const tz = (0, dialect_1.qtz)(qi);
-            if (tz) {
-                extractFrom = `(${extractFrom}::TIMESTAMPTZ AT TIME ZONE ${this.sqlTimezoneLiteral(tz)})`;
-            }
-        }
+    sqlCivilExtract(expr, units, _civilType) {
         // PostgreSQL before 14 returns a double precision for EXTRACT, cast to integer
         // since it is common to pass an extraction to mod ( like in fitler expressions )
-        const extracted = `EXTRACT(${units} FROM ${extractFrom})::integer`;
-        return from.units === 'day_of_week' ? `(${extracted}+1)` : `(${extracted})`;
+        const extracted = `EXTRACT(${pg_impl_1.timeExtractMap[units] || units} FROM ${expr})::integer`;
+        return units === 'day_of_week' ? `(${extracted}+1)` : `(${extracted})`;
     }
 }
 exports.PostgresDialect = PostgresDialect;

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

@@ -1,7 +1,7 @@
-import type { Sampling, AtomicTypeDef, TimeExtractExpr, TypecastExpr, MeasureTimeExpr, RegexMatchExpr, BasicAtomicTypeDef, TimestampTypeDef, ArrayLiteralNode, RecordLiteralNode } from '../../model/malloy_types';
+import type { Sampling, AtomicTypeDef, TypecastExpr, MeasureTimeExpr, RegexMatchExpr, BasicAtomicTypeDef, ArrayLiteralNode, RecordLiteralNode, ATimestampTypeDef, TimestampUnit, ExtractUnit } from '../../model/malloy_types';
 import type { DialectFunctionOverloadDef } from '../functions';
 import type { CompiledOrderBy, DialectFieldList, FieldReferenceType, IntegerTypeMapping, QueryInfo } from '../dialect';
-import { Dialect } from '../dialect';
+import { CivilTime, Dialect } from '../dialect';
 export declare class SnowflakeDialect extends Dialect {
     name: string;
     experimental: boolean;
@@ -50,19 +50,17 @@ export declare class SnowflakeDialect extends Dialect {
     sqlCreateFunctionCombineLastStage(_lastStageName: string): string;
     sqlSelectAliasAsStruct(alias: string): string;
     sqlCreateTableAsSelect(tableName: string, sql: string): string;
-    sqlConvertToCivilTime(expr: string, timezone: string, typeDef: AtomicTypeDef): {
-        sql: string;
-        typeDef: AtomicTypeDef;
-    };
-    sqlConvertFromCivilTime(expr: string, timezone: string, _destTypeDef: TimestampTypeDef): string;
-    sqlTruncate(expr: string, unit: string, _typeDef: AtomicTypeDef, _inCivilTime: boolean, _timezone?: string): string;
-    sqlOffsetTime(expr: string, op: '+' | '-', magnitude: string, unit: string, typeDef: AtomicTypeDef, _inCivilTime: boolean, _timezone?: string): string;
-    sqlTimeExtractExpr(qi: QueryInfo, from: TimeExtractExpr): string;
-    private atTz;
+    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;
+    sqlCivilExtract(expr: string, units: ExtractUnit, _civilType: CivilTime): string;
+    sqlCivilToDate(expr: string): string;
+    sqlDateToCivil(expr: string): string;
     sqlNowExpr(): string;
-    sqlCast(qi: QueryInfo, cast: TypecastExpr): string;
+    sqlCast(_qi: QueryInfo, cast: TypecastExpr): 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(df: MeasureTimeExpr): string;
     sqlRegexpMatch(compare: RegexMatchExpr): string;

package/dist/dialect/snowflake/snowflake.js

@@ -249,61 +249,45 @@ ${(0, utils_1.indent)(sql)}
 );
 `;
     }
+    // Civil time is a TIMESTAMP_NTZ, which has no zone
     sqlConvertToCivilTime(expr, timezone, typeDef) {
-        // For timestamptz (TIMESTAMP_TZ): use 2-arg form
-        // Returns TIMESTAMP_TZ with timezone preserved
-        if (typeDef.type === 'timestamptz') {
-            return {
-                sql: `CONVERT_TIMEZONE(${this.sqlTimezoneLiteral(timezone)}, ${expr})`,
-                typeDef: { type: 'timestamptz' },
-            };
+        const tz = this.sqlTimezoneLiteral(timezone);
+        if (malloy_types_1.TD.isTimestamptz(typeDef)) {
+            return `CONVERT_TIMEZONE(${tz}, ${expr})::TIMESTAMP_NTZ`;
         }
-        // For plain timestamps (TIMESTAMP_NTZ): use 3-arg form
-        // Must cast to TIMESTAMP_NTZ first, returns TIMESTAMP_NTZ
-        return {
-            sql: `CONVERT_TIMEZONE('UTC', ${this.sqlTimezoneLiteral(timezone)}, (${expr})::TIMESTAMP_NTZ)`,
-            typeDef: { type: 'timestamp' },
-        };
-    }
-    sqlConvertFromCivilTime(expr, timezone, _destTypeDef) {
-        // After civil time operations, we have a TIMESTAMP_NTZ in the target timezone
-        // Convert from timezone to UTC, returning TIMESTAMP_NTZ
-        return `CONVERT_TIMEZONE(${this.sqlTimezoneLiteral(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
-        // Unlike PostgreSQL/DuckDB, Snowflake's DATE_TRUNC preserves the input type
-        // (TIMESTAMP_NTZ → TIMESTAMP_NTZ, TIMESTAMP_TZ → TIMESTAMP_TZ)
+        return timezone === 'UTC'
+            ? expr
+            : `CONVERT_TIMEZONE('UTC', ${tz}, (${expr})::TIMESTAMP_NTZ)`;
+    }
+    sqlConvertFromCivilTime(expr, timezone, destTypeDef) {
+        const utc = timezone === 'UTC'
+            ? expr
+            : `CONVERT_TIMEZONE(${this.sqlTimezoneLiteral(timezone)}, 'UTC', (${expr})::TIMESTAMP_NTZ)`;
+        // The session time zone is UTC
+        return malloy_types_1.TD.isTimestamptz(destTypeDef) ? `(${utc})::TIMESTAMP_TZ` : utc;
+    }
+    sqlTruncate(expr, unit, _civilType) {
+        // The session sets WEEK_START to Sunday
         return `DATE_TRUNC('${unit}', ${expr})`;
     }
-    sqlOffsetTime(expr, op, magnitude, unit, typeDef, _inCivilTime, _timezone) {
-        const funcName = typeDef.type === 'date' ? 'DATEADD' : 'TIMESTAMPADD';
+    sqlOffsetTime(expr, op, magnitude, unit, civilType) {
+        const funcName = civilType === dialect_1.CivilTime.Date ? 'DATEADD' : 'TIMESTAMPADD';
         const n = op === '+' ? magnitude : `-(${magnitude})`;
         return `${funcName}(${unit}, ${n}, ${expr})`;
     }
-    sqlTimeExtractExpr(qi, from) {
-        const extractUnits = extractionMap[from.units] || from.units;
-        let extractFrom = from.e.sql;
-        const tz = (0, dialect_1.qtz)(qi);
-        if (tz && malloy_types_1.TD.isAnyTimestamp(from.e.typeDef)) {
-            extractFrom = `CONVERT_TIMEZONE(${this.sqlTimezoneLiteral(tz)}, ${extractFrom})`;
-        }
-        return `EXTRACT(${extractUnits} FROM ${extractFrom})`;
-    }
-    atTz(sqlExpr, tz) {
-        if (tz !== undefined) {
-            return `(
-      TO_CHAR(${sqlExpr}::TIMESTAMP_NTZ, 'YYYY-MM-DD HH24:MI:SS.FF9') ||
-      TO_CHAR(CONVERT_TIMEZONE(${this.sqlTimezoneLiteral(tz)}, '1970-01-01 00:00:00'), 'TZHTZM')
-    )::TIMESTAMP_TZ`;
-        }
-        return `${sqlExpr}::TIMESTAMP_NTZ`;
+    sqlCivilExtract(expr, units, _civilType) {
+        return `EXTRACT(${extractionMap[units] || units} FROM ${expr})`;
+    }
+    sqlCivilToDate(expr) {
+        return `TO_DATE(${expr})`;
+    }
+    sqlDateToCivil(expr) {
+        return `(${expr})::TIMESTAMP_NTZ`;
     }
     sqlNowExpr() {
         return 'CURRENT_TIMESTAMP()';
     }
-    sqlCast(qi, cast) {
+    sqlCast(_qi, cast) {
         const src = cast.e.sql || '';
         const { srcTypeDef, dstTypeDef, dstSQLType } = this.sqlCastPrep(cast);
         if (malloy_types_1.TD.eq(srcTypeDef, dstTypeDef)) {
@@ -316,50 +300,14 @@ ${(0, utils_1.indent)(sql)}
             throw new Error(`Snowflake dialect doesn't support safe cast for a few types:
         refer to: https://docs.snowflake.com/en/sql-reference/functions/try_cast`);
         }
-        const tz = (0, dialect_1.qtz)(qi);
-        // Timezone-aware casts when query timezone is set
-        if (tz && srcTypeDef && dstTypeDef) {
-            // TIMESTAMP → DATE: convert to query timezone, then to date
-            if (malloy_types_1.TD.isTimestamp(srcTypeDef) && malloy_types_1.TD.isDate(dstTypeDef)) {
-                return `TO_DATE(CONVERT_TIMEZONE(${this.sqlTimezoneLiteral(tz)}, ${src}))`;
-            }
-            // TIMESTAMPTZ → DATE: convert to query timezone, then to date
-            if (malloy_types_1.TD.isTimestamptz(srcTypeDef) && malloy_types_1.TD.isDate(dstTypeDef)) {
-                return `TO_DATE(CONVERT_TIMEZONE(${this.sqlTimezoneLiteral(tz)}, ${src}))`;
-            }
-            // DATE → TIMESTAMP: interpret date in query timezone, return UTC timestamp
-            if (malloy_types_1.TD.isDate(srcTypeDef) && malloy_types_1.TD.isTimestamp(dstTypeDef)) {
-                const retExpr = `TO_TIMESTAMP(${src})`;
-                return this.atTz(retExpr, tz);
-            }
-            // DATE → TIMESTAMPTZ: interpret date in query timezone
-            if (malloy_types_1.TD.isDate(srcTypeDef) && malloy_types_1.TD.isTimestamptz(dstTypeDef)) {
-                const retExpr = `TO_TIMESTAMP(${src})`;
-                return this.atTz(retExpr, tz);
-            }
-            // TIMESTAMPTZ → TIMESTAMP: convert to query timezone, get UTC wall clock
-            if (malloy_types_1.TD.isTimestamptz(srcTypeDef) && malloy_types_1.TD.isTimestamp(dstTypeDef)) {
-                return `CONVERT_TIMEZONE(${this.sqlTimezoneLiteral(tz)}, ${src})::TIMESTAMP_NTZ`;
-            }
-            // TIMESTAMP → TIMESTAMPTZ: interpret as UTC, convert to TIMESTAMPTZ
-            if (malloy_types_1.TD.isTimestamp(srcTypeDef) && malloy_types_1.TD.isTimestamptz(dstTypeDef)) {
-                return this.atTz(src, tz);
-            }
-        }
         const castFunc = cast.safe ? 'TRY_CAST' : 'CAST';
         return `${castFunc}(${src} AS ${dstSQLType})`;
     }
     sqlDateLiteral(_qi, literal) {
         return `TO_DATE('${literal}')`;
     }
-    sqlTimestampLiteral(qi, literal, timezone) {
-        const tz = timezone || (0, dialect_1.qtz)(qi);
-        let ret = `'${literal}'::TIMESTAMP_NTZ`;
-        if (tz) {
-            // Interpret the literal as being in query timezone, convert to UTC
-            ret = `CONVERT_TIMEZONE(${this.sqlTimezoneLiteral(tz)}, 'UTC', ${ret})`;
-        }
-        return ret;
+    sqlCivilLiteral(literal) {
+        return `'${literal}'::TIMESTAMP_NTZ`;
     }
     sqlTimestamptzLiteral(_qi, literal, timezone) {
         // Use TIMESTAMP_TZ_FROM_PARTS to create timestamptz

package/dist/dialect/sqlserver/sqlserver.d.ts

@@ -1,7 +1,7 @@
-import type { Sampling, AtomicTypeDef, ATimestampTypeDef, TypecastExpr, MeasureTimeExpr, BasicAtomicTypeDef, RegexMatchExpr, TimeExtractExpr, TimestampUnit, OrderBy } from '../../model/malloy_types';
+import type { Sampling, AtomicTypeDef, ATimestampTypeDef, TypecastExpr, MeasureTimeExpr, BasicAtomicTypeDef, RegexMatchExpr, TimestampUnit, OrderBy, ExtractUnit } from '../../model/malloy_types';
 import type { DialectFunctionOverloadDef } from '../functions';
 import type { BooleanTypeSupport, DialectFieldList, FieldReferenceType, GroupByClauseType, QueryInfo } from '../dialect';
-import { Dialect } from '../dialect';
+import { CivilTime, Dialect } from '../dialect';
 import type { ValidateTablePathResult } from '../table-path';
 /** T-SQL for SQL Server 2017 and later, and Azure SQL Database. */
 export declare class SQLServerDialect extends Dialect {
@@ -78,20 +78,19 @@ export declare class SQLServerDialect extends Dialect {
     concat(...values: string[]): string;
     sqlDateToString(sqlDateExp: string): string;
     sqlNowExpr(): string;
-    sqlTimeExtractExpr(qi: QueryInfo, from: TimeExtractExpr): string;
-    sqlCast(qi: QueryInfo, cast: TypecastExpr): string;
+    sqlCivilExtract(expr: string, units: ExtractUnit, _civilType: CivilTime): string;
+    sqlCivilToDate(expr: string): string;
+    sqlDateToCivil(expr: string): string;
+    sqlCast(_qi: QueryInfo, cast: TypecastExpr): string;
     sqlRegexpMatch(_df: RegexMatchExpr): string;
     sqlDateLiteral(_qi: QueryInfo, literal: string): string;
-    sqlTimestampLiteral(qi: QueryInfo, literal: string, timezone: string | undefined): string;
-    sqlTimestamptzLiteral(_qi: QueryInfo, _literal: string, _timezone: string): string;
+    sqlCivilLiteral(literal: string): string;
+    sqlTimestamptzLiteral(_qi: QueryInfo, literal: string, timezone: string): string;
     sqlTimezoneLiteral(timezone: string): string;
-    sqlConvertToCivilTime(expr: string, timezone: string, _typeDef: AtomicTypeDef): {
-        sql: string;
-        typeDef: AtomicTypeDef;
-    };
-    sqlConvertFromCivilTime(expr: string, timezone: string, _destTypeDef: ATimestampTypeDef): string;
-    sqlTruncate(expr: string, unit: TimestampUnit, typeDef: AtomicTypeDef, _inCivilTime: boolean, _timezone?: string): string;
-    sqlOffsetTime(expr: string, op: '+' | '-', magnitude: string, unit: TimestampUnit, _typeDef: AtomicTypeDef, _inCivilTime: boolean, _timezone?: string): 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;
     sqlMeasureTimeExpr(df: MeasureTimeExpr): string;
     getDialectFunctionOverrides(): {
         [name: string]: DialectFunctionOverloadDef[];