@malloydata/malloy 0.0.323 → 0.0.325

package/dist/dialect/trino/trino.js

@@ -67,9 +67,6 @@ const trinoToMalloyTypes = {
     'FLOAT64': {type: 'number', numberType: 'float'},
     'NUMERIC': {type: 'number', numberType: 'float'},
     'BIGNUMERIC': {type: 'number', numberType: 'float'},
-    'TIMESTAMP': {type: 'timestamp'},
-    'BOOLEAN': {type: 'boolean'},
-    'BOOL': {type: 'boolean'},
     'JSON': {type: 'json'},*/
     // TODO (https://cloud.google.com/bigquery/docs/reference/rest/v2/tables#tablefieldschema):
     // BYTES
@@ -330,10 +327,29 @@ ${(0, utils_1.indent)(sql)}
         const definitions = this.buildTypeExpression(fieldList);
         return `CAST(ROW(${fields}) as ROW(${definitions})`;
     }
-    sqlConvertToCivilTime(expr, timezone) {
-        return `${expr} AT TIME ZONE '${timezone}'`;
+    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'), '${timezone}')`,
+                typeDef: { type: 'timestamptz' },
+            };
+        }
+        // TIMESTAMPTZ → TIMESTAMPTZ in query timezone (same instant, different stored tz)
+        return {
+            sql: `at_timezone(${expr}, '${timezone}')`,
+            typeDef: { type: 'timestamptz' },
+        };
     }
-    sqlConvertFromCivilTime(expr, _timezone) {
+    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) {
@@ -361,16 +377,37 @@ ${(0, utils_1.indent)(sql)}
         return `DATE_ADD('${offsetUnit}', ${n}, ${expr})`;
     }
     sqlCast(qi, cast) {
-        const { op, srcTypeDef, dstTypeDef, dstSQLType } = this.sqlCastPrep(cast);
+        const { srcTypeDef, dstTypeDef, dstSQLType } = this.sqlCastPrep(cast);
         const tz = qtz(qi);
         const expr = cast.e.sql || '';
-        if (op === 'timestamp::date' && tz) {
-            const tstz = `CAST(${expr} as TIMESTAMP)`;
-            return `CAST((${tstz}) AT TIME ZONE '${tz}' AS DATE)`;
-        }
-        else if (op === 'date::timestamp' && tz) {
-            return `CAST(CONCAT(CAST(CAST(${expr} AS TIMESTAMP) AS VARCHAR), ' ${tz}') AS TIMESTAMP WITH TIME ZONE)`;
+        // 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'), '${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}, '${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), '${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), '${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}, '${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}, '${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})`;
@@ -446,6 +483,8 @@ ${(0, utils_1.indent)(sql)}
                 return malloyType.numberType === 'integer' ? 'BIGINT' : 'DOUBLE';
             case 'string':
                 return 'VARCHAR';
+            case 'timestamptz':
+                return 'TIMESTAMP WITH TIME ZONE';
             case 'record': {
                 const typeSpec = [];
                 for (const f of malloyType.fields) {
@@ -475,7 +514,11 @@ ${(0, utils_1.indent)(sql)}
     }
     sqlTypeToMalloyType(sqlType) {
         var _a, _b, _c;
-        const baseSqlType = (_b = (_a = sqlType.match(/^(\w+)/)) === null || _a === void 0 ? void 0 : _a.at(0)) !== null && _b !== void 0 ? _b : sqlType;
+        const matchType = sqlType.toLowerCase();
+        if (matchType.startsWith('timestamp with time zone')) {
+            return { type: 'timestamptz' };
+        }
+        const baseSqlType = (_b = (_a = matchType.match(/^\w+/)) === null || _a === void 0 ? void 0 : _a.at(0)) !== null && _b !== void 0 ? _b : matchType;
         return ((_c = trinoToMalloyTypes[baseSqlType]) !== null && _c !== void 0 ? _c : {
             type: 'sql native',
             rawType: sqlType,
@@ -502,24 +545,36 @@ ${(0, utils_1.indent)(sql)}
         // Angle Brackets:       ARRAY<INT64>
         return sqlType.match(/^[A-Za-z\s(),<>0-9]*$/) !== null;
     }
-    sqlLiteralTime(qi, lit) {
-        if (malloy_types_1.TD.isDate(lit.typeDef)) {
-            return `DATE '${lit.literal}'`;
-        }
-        const tz = lit.timezone || qtz(qi);
+    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 '${lit.literal}', '${tz}'), 'UTC') AS TIMESTAMP)`;
+            return `CAST(at_timezone(with_timezone(TIMESTAMP '${literal}', '${tz}'), 'UTC') AS TIMESTAMP)`;
         }
-        return `TIMESTAMP '${lit.literal}'`;
+        return `TIMESTAMP '${literal}'`;
+    }
+    sqlTimestamptzLiteral(_qi, literal, timezone) {
+        // Use with_timezone to create a TIMESTAMP WITH TIME ZONE
+        return `with_timezone(TIMESTAMP '${literal}', '${timezone}')`;
     }
     sqlTimeExtractExpr(qi, from) {
         const pgUnits = pg_impl_1.timeExtractMap[from.units] || from.units;
         let extractFrom = from.e.sql || '';
-        if (malloy_types_1.TD.isTimestamp(from.e.typeDef)) {
+        if (malloy_types_1.TD.isAnyTimestamp(from.e.typeDef)) {
             const tz = qtz(qi);
             if (tz) {
-                extractFrom = `at_timezone(${extractFrom},'${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'), '${tz}')`;
+                }
+                else {
+                    // TIMESTAMPTZ: convert to query timezone
+                    extractFrom = `at_timezone(${extractFrom}, '${tz}')`;
+                }
             }
         }
         const extracted = `EXTRACT(${pgUnits} FROM ${extractFrom})`;
@@ -552,19 +607,96 @@ class PrestoDialect extends TrinoDialect {
     sqlGenerateUUID() {
         return 'CAST(UUID() AS VARCHAR)';
     }
-    sqlLiteralTime(qi, lit) {
-        if (malloy_types_1.TD.isDate(lit.typeDef)) {
-            return `DATE '${lit.literal}'`;
-        }
-        const tz = lit.timezone || qtz(qi);
+    sqlDateLiteral(_qi, literal) {
+        return `DATE '${literal}'`;
+    }
+    sqlTimestampLiteral(qi, literal, timezone) {
+        const tz = timezone || qtz(qi);
         if (tz) {
-            return `CAST(TIMESTAMP '${lit.literal} ${tz}' AT TIME ZONE 'UTC' AS TIMESTAMP)`;
+            return `CAST(TIMESTAMP '${literal} ${tz}' AT TIME ZONE 'UTC' AS TIMESTAMP)`;
         }
-        return `TIMESTAMP '${lit.literal}'`;
+        return `TIMESTAMP '${literal}'`;
+    }
+    sqlTimestamptzLiteral(_qi, literal, timezone) {
+        return `TIMESTAMP '${literal} ${timezone}'`;
     }
-    sqlConvertFromCivilTime(expr, _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 '${timezone}'`,
+            typeDef: { type: 'timestamptz' },
+        };
+    }
+    sqlConvertFromCivilTime(expr, _timezone, destTypeDef) {
+        if (destTypeDef.type === 'timestamptz') {
+            return expr;
+        }
         return `CAST(${expr} AT TIME ZONE 'UTC' AS TIMESTAMP)`;
     }
+    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 '${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 '${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 ${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 ${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 '${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})`;
+        }
+        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 '${tz}'`;
+                }
+                else {
+                    // TIMESTAMPTZ: convert to query timezone
+                    extractFrom = `${extractFrom} AT TIME ZONE '${tz}'`;
+                }
+            }
+        }
+        const extracted = `EXTRACT(${pgUnits} FROM ${extractFrom})`;
+        return from.units === 'day_of_week' ? `mod(${extracted}+1,7)` : extracted;
+    }
     sqlUnnestAlias(source, alias, _fieldList, needDistinctKey, isArray, _isInNestedPipeline) {
         if (isArray) {
             if (needDistinctKey) {

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 export { DuckDBDialect, StandardSQLDialect, TrinoDialect, PostgresDialect, SnowflakeDialect, MySQLDialect, registerDialect, arg, qtz, overload, minScalar, anyExprType, minAggregate, maxScalar, sql, makeParam, param, variadicParam, literal, spread, Dialect, TinyParser, } from './dialect';
 export type { DialectFieldList, DialectFunctionOverloadDef, QueryInfo, MalloyStandardFunctionImplementations, DefinitionBlueprint, DefinitionBlueprintMap, OverloadedDefinitionBlueprint, TinyToken, } from './dialect';
-export type { QueryDataRow, 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, NamedQuery, NamedModelObject, ExpressionType, FunctionDef, FunctionOverloadDef, FunctionParameterDef, ExpressionValueType, TypeDesc, FunctionParamTypeDesc, DocumentLocation, DocumentRange, DocumentPosition, Sampling, Annotation, BasicAtomicTypeDef, BasicAtomicDef, AtomicTypeDef, AtomicFieldDef, ArrayDef, ArrayTypeDef, RecordTypeDef, RepeatedRecordTypeDef, RecordDef, RepeatedRecordDef, RecordLiteralNode, StringLiteralNode, ArrayLiteralNode, SourceComponentInfo, TimeLiteralNode, TypecastExpr, } from './model';
+export type { QueryDataRow, 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, NamedQuery, NamedModelObject, ExpressionType, FunctionDef, FunctionOverloadDef, FunctionParameterDef, ExpressionValueType, TypeDesc, FunctionParamTypeDesc, DocumentLocation, DocumentRange, DocumentPosition, Sampling, Annotation, BasicAtomicTypeDef, BasicAtomicDef, AtomicTypeDef, AtomicFieldDef, ArrayDef, ArrayTypeDef, RecordTypeDef, RepeatedRecordTypeDef, RecordDef, RepeatedRecordDef, RecordLiteralNode, StringLiteralNode, ArrayLiteralNode, SourceComponentInfo, DateLiteralNode, TimestampLiteralNode, TimestamptzLiteralNode, TimeLiteralExpr, TypecastExpr, } from './model';
 export { isSourceDef, isBasicAtomic, isJoined, isJoinedSource, isSamplingEnable, isSamplingPercent, isSamplingRows, isRepeatedRecord, isBasicArray, mkArrayDef, mkFieldDef, expressionIsAggregate, expressionIsAnalytic, expressionIsCalculation, expressionIsScalar, expressionIsUngroupedAggregate, indent, composeSQLExpr, isTimestampUnit, isDateUnit, constantExprToSQL, } from './model';
 export { malloyToQuery, MalloyTranslator, } from './lang';
 export type { LogMessage, TranslateResponse } from './lang';

package/dist/lang/ast/expressions/expr-granular-time.js

@@ -98,18 +98,36 @@ class ExprGranularTime extends expression_def_1.ExpressionDef {
     getExpression(fs) {
         const timeframe = this.units;
         const exprVal = this.expr.getExpression(fs);
+        let timeType;
+        let tsVal;
         if (malloy_types_1.TD.isTemporal(exprVal)) {
-            const tsVal = {
-                ...exprVal,
-                timeframe: timeframe,
-            };
+            if (exprVal.type === 'date') {
+                if (!(0, malloy_types_1.isDateUnit)(timeframe)) {
+                    return this.loggedErrorExpr('unsupported-type-for-time-truncation', `Cannot truncate date to timestamp unit '${timeframe}'`);
+                }
+                tsVal = { ...exprVal, timeframe: timeframe };
+                timeType = { type: 'date', timeframe };
+            }
+            else {
+                // timestamp or timestamptz
+                tsVal = { ...exprVal, timeframe: timeframe };
+                if (exprVal.type === 'timestamptz') {
+                    timeType = { type: 'timestamptz', timeframe };
+                }
+                else {
+                    timeType = { type: 'timestamp', timeframe };
+                }
+            }
             if (this.truncate) {
                 tsVal.value = {
                     node: 'trunc',
-                    e: (0, malloy_types_1.mkTemporal)(exprVal.value, exprVal.type),
+                    e: (0, malloy_types_1.mkTemporal)(exprVal.value, timeType),
                     units: timeframe,
                 };
             }
+            else {
+                tsVal.value = exprVal.value;
+            }
             return tsVal;
         }
         if (exprVal.type !== 'error') {
@@ -145,9 +163,9 @@ class ExprGranularTime extends expression_def_1.ExpressionDef {
     toRange(fs) {
         const begin = this.getExpression(fs);
         const one = { node: 'numberLiteral', literal: '1' };
-        if (begin.type === 'timestamp') {
-            const beginTS = expr_time_1.ExprTime.fromValue('timestamp', begin);
-            const endTS = new expr_time_1.ExprTime('timestamp', (0, time_utils_1.timeOffset)('timestamp', begin.value, '+', one, this.units), [begin]);
+        if (malloy_types_1.TD.isAnyTimestamp(begin)) {
+            const beginTS = expr_time_1.ExprTime.fromValue(begin.type, begin);
+            const endTS = new expr_time_1.ExprTime(begin.type, (0, time_utils_1.timeOffset)(begin.type, begin.value, '+', one, this.units), [begin]);
             return new range_1.Range(beginTS, endTS);
         }
         const beginDate = new expr_time_1.ExprTime('date', begin.value, [begin]);

package/dist/lang/ast/expressions/expr-props.d.ts

@@ -48,6 +48,18 @@ export declare class ExprProps extends ExpressionDef {
         morphic?: {
             [x: string]: import("../../../model/malloy_types").Expr;
         };
+    } | {
+        requiresGroupBy: import("../../../model/malloy_types").RequiredGroupBy[] | undefined;
+        type: "timestamptz";
+        timeframe?: import("../../../model/malloy_types").TimestampUnit;
+        expressionType: import("../../../model/malloy_types").ExpressionType;
+        evalSpace: import("../../../model/malloy_types").EvalSpace;
+        fieldUsage: import("../../../model/malloy_types").FieldUsage[];
+        ungroupings?: import("../../../model/malloy_types").AggregateUngrouping[];
+        value: import("../../../model/malloy_types").Expr;
+        morphic?: {
+            [x: string]: import("../../../model/malloy_types").Expr;
+        };
     } | {
         requiresGroupBy: import("../../../model/malloy_types").RequiredGroupBy[] | undefined;
         type: "number";
@@ -189,5 +201,17 @@ export declare class ExprProps extends ExpressionDef {
         morphic?: {
             [x: string]: import("../../../model/malloy_types").Expr;
         };
+    } | {
+        requiresGroupBy: import("../../../model/malloy_types").RequiredGroupBy[] | undefined;
+        type: "timestamptz";
+        timeframe?: import("../../../model/malloy_types").TimestampUnit;
+        expressionType: import("../../../model/malloy_types").ExpressionType;
+        evalSpace: import("../../../model/malloy_types").EvalSpace;
+        fieldUsage: import("../../../model/malloy_types").FieldUsage[];
+        ungroupings?: import("../../../model/malloy_types").AggregateUngrouping[];
+        value: import("../../../model/malloy_types").Expr;
+        morphic?: {
+            [x: string]: import("../../../model/malloy_types").Expr;
+        };
     };
 }

package/dist/lang/ast/expressions/for-range.d.ts

@@ -8,7 +8,7 @@ export declare class ForRange extends ExpressionDef {
     readonly duration: ExpressionDef;
     readonly timeframe: Timeframe;
     elementType: string;
-    legalChildTypes: import("../../..").TypeDesc[];
+    legalChildTypes: import("../../../model/malloy_types").TypeDesc[];
     constructor(from: ExpressionDef, duration: ExpressionDef, timeframe: Timeframe);
     apply(fs: FieldSpace, op: BinaryMalloyOperator, expr: ExpressionDef): ExprValue;
     requestExpression(_fs: FieldSpace): undefined;

package/dist/lang/ast/expressions/for-range.js

@@ -59,6 +59,7 @@ exports.ForRange = void 0;
 const ast_utils_1 = require("../ast-utils");
 const TDU = __importStar(require("../typedesc-utils"));
 const time_utils_1 = require("../time-utils");
+const malloy_types_1 = require("../../../model/malloy_types");
 const expr_value_1 = require("../types/expr-value");
 const expression_def_1 = require("../types/expression-def");
 const expr_time_1 = require("./expr-time");
@@ -93,10 +94,10 @@ class ForRange extends expression_def_1.ExpressionDef {
         // If the duration resolution is smaller than date, we have
         // to do the computaion with timestamps.
         let rangeType = (0, time_utils_1.resolution)(units);
-        // Next, if the beginning of the range is a timestamp, then we
-        // also have to do the computation as a timestamp
-        if (startV.type === 'timestamp') {
-            rangeType = 'timestamp';
+        // Next, if the beginning of the range is a timestamp or timestamptz, then we
+        // also have to do the computation as a timestamp (or timestamptz)
+        if (malloy_types_1.TD.isAnyTimestamp(startV)) {
+            rangeType = startV.type;
         }
         // everything is dates, do date math
         if (checkV.type === 'date' && rangeType === 'date') {

package/dist/lang/ast/expressions/time-literal.d.ts

@@ -1,5 +1,5 @@
 import type * as Malloy from '@malloydata/malloy-interfaces';
-import type { TemporalFieldType, TimestampUnit, TimeLiteralNode } from '../../../model/malloy_types';
+import type { TemporalFieldType, TimestampUnit, TimeLiteralExpr } from '../../../model/malloy_types';
 import type { ExprValue } from '../types/expr-value';
 import type { FieldSpace } from '../types/field-space';
 import { ExpressionDef } from '../types/expression-def';
@@ -21,16 +21,18 @@ export declare abstract class TimeLiteral extends ExpressionDef {
     nextLit?: string;
     timeZone?: string;
     constructor(tm: TimeText, units: TimestampUnit | undefined, timeType: TemporalFieldType);
-    protected makeLiteral(val: string, typ: TemporalFieldType, units: TimestampUnit | undefined): TimeLiteralNode;
-    protected makeValue(val: string, dataType: TemporalFieldType): TimeResult;
+    protected makeLiteral(fs: FieldSpace, val: string, typ: TemporalFieldType, units: TimestampUnit | undefined): TimeLiteralExpr;
+    protected makeValue(fs: FieldSpace, val: string, dataType: TemporalFieldType): TimeResult;
     getStableLiteral(): Malloy.LiteralValue;
     getValue(): (import("../../../model/malloy_types").DateTypeDef & import("../../../model/malloy_types").TypeInfo & import("../types/expr-result").WithValue & {
         timeframe?: TimestampUnit;
     }) | (import("../../../model/malloy_types").TimestampTypeDef & import("../../../model/malloy_types").TypeInfo & import("../types/expr-result").WithValue & {
         timeframe?: TimestampUnit;
+    }) | (import("../../../model/malloy_types").TimestamptzTypeDef & import("../../../model/malloy_types").TypeInfo & import("../types/expr-result").WithValue & {
+        timeframe?: TimestampUnit;
     });
-    getExpression(_fs: FieldSpace): ExprValue;
-    getNext(): ExprValue | undefined;
+    getExpression(fs: FieldSpace): ExprValue;
+    getNext(fs: FieldSpace): ExprValue | undefined;
     granular(): boolean;
 }
 export declare class LiteralTimestamp extends TimeLiteral {
@@ -60,8 +62,8 @@ export declare class LiteralHour extends GranularLiteral {
  */
 declare abstract class DateBasedLiteral extends GranularLiteral {
     constructor(tm: TimeText, units: TimestampUnit, nextLit: string);
-    getExpression(_fs: FieldSpace): ExprValue;
-    getNext(): ExprValue | undefined;
+    getExpression(fs: FieldSpace): ExprValue;
+    getNext(fs: FieldSpace): ExprValue | undefined;
 }
 export declare class LiteralDay extends DateBasedLiteral {
     elementType: string;

package/dist/lang/ast/expressions/time-literal.js

@@ -29,6 +29,7 @@ const expr_value_1 = require("../types/expr-value");
 const range_1 = require("./range");
 const expr_time_1 = require("./expr-time");
 const expression_def_1 = require("../types/expression-def");
+const dialect_1 = require("../../../dialect/dialect");
 class TimeFormatError extends Error {
 }
 exports.TimeFormatError = TimeFormatError;
@@ -69,24 +70,11 @@ class TimeLiteral extends expression_def_1.ExpressionDef {
             this.timeZone = tm.tzSpec;
         }
     }
-    makeLiteral(val, typ, units) {
-        const timeFrag = {
-            node: 'timeLiteral',
-            literal: val,
-            typeDef: typ === 'timestamp'
-                ? { type: typ, timeframe: units }
-                : {
-                    type: typ,
-                    timeframe: units !== undefined && (0, malloy_types_1.isDateUnit)(units) ? units : undefined,
-                },
-        };
-        if (this.timeZone) {
-            timeFrag.timezone = this.timeZone;
-        }
-        return timeFrag;
+    makeLiteral(fs, val, typ, units) {
+        return dialect_1.Dialect.makeTimeLiteralNode(fs.dialectObj(), val, this.timeZone, units, typ);
     }
-    makeValue(val, dataType) {
-        const value = this.makeLiteral(val, dataType, this.units);
+    makeValue(fs, val, dataType) {
+        const value = this.makeLiteral(fs, val, dataType, this.units);
         return (0, expr_value_1.literalTimeResult)({
             value,
             dataType: value.typeDef,
@@ -96,48 +84,53 @@ class TimeLiteral extends expression_def_1.ExpressionDef {
     getStableLiteral() {
         const value = this.getValue();
         let granularity = value.timeframe;
-        if (value.value.node !== 'timeLiteral') {
-            // TODO should probably just throw...
+        const node = value.value;
+        if (node.node === 'dateLiteral') {
+            if (granularity === 'hour' ||
+                granularity === 'minute' ||
+                granularity === 'second') {
+                // TODO should probably just throw...
+                granularity = 'day';
+            }
             return {
-                kind: 'timestamp_literal',
-                timestamp_value: '1970-01-01 00:00:00',
+                kind: 'date_literal',
+                date_value: node.literal,
                 granularity,
             };
         }
-        const timeValue = value.value.literal;
-        const timezone = value.value.timezone;
-        if (value.type === 'timestamp') {
+        else if (node.node === 'timestampLiteral') {
             return {
                 kind: 'timestamp_literal',
-                timestamp_value: timeValue,
+                timestamp_value: node.literal,
                 granularity,
-                timezone,
+                timezone: node.timezone,
             };
         }
-        else {
-            if (granularity === 'hour' ||
-                granularity === 'minute' ||
-                granularity === 'second') {
-                // TODO should probably just throw...
-                granularity = 'day';
-            }
+        else if (node.node === 'timestamptzLiteral') {
             return {
-                kind: 'date_literal',
-                date_value: timeValue,
+                kind: 'timestamp_literal',
+                timestamp_value: node.literal,
                 granularity,
-                timezone,
+                timezone: node.timezone,
             };
         }
+        throw new Error(`Unexpected time literal node type: ${node.node}`);
     }
     getValue() {
-        return this.makeValue(this.literalPart, this.timeType);
+        // Used for stable literals - no dialect context, so pass undefined
+        const value = dialect_1.Dialect.makeTimeLiteralNode(undefined, this.literalPart, this.timeZone, this.units, this.timeType);
+        return (0, expr_value_1.literalTimeResult)({
+            value,
+            dataType: value.typeDef,
+            timeframe: this.units,
+        });
     }
-    getExpression(_fs) {
-        return this.makeValue(this.literalPart, this.timeType);
+    getExpression(fs) {
+        return this.makeValue(fs, this.literalPart, this.timeType);
     }
-    getNext() {
+    getNext(fs) {
         if (this.nextLit) {
-            return this.makeValue(this.nextLit, this.timeType);
+            return this.makeValue(fs, this.nextLit, this.timeType);
         }
     }
     granular() {
@@ -197,7 +190,7 @@ class GranularLiteral extends TimeLiteral {
     apply(fs, op, left) {
         // We have a chance to write our own range comparison will all constants.
         let rangeStart = this.getExpression(fs);
-        let rangeEnd = this.getNext();
+        let rangeEnd = this.getNext(fs);
         if (rangeEnd) {
             const testValue = left.getExpression(fs);
             if (testValue.type === 'date' && op === '=' && this.units === 'day') {
@@ -210,7 +203,7 @@ class GranularLiteral extends TimeLiteral {
                 // }
                 return super.apply(fs, op, left);
             }
-            if (testValue.type === 'timestamp' &&
+            if (malloy_types_1.TD.isAnyTimestamp(testValue) &&
                 op === '=' &&
                 this.units === undefined) {
                 // TODO remove the === 'second' check above and warn
@@ -222,7 +215,7 @@ class GranularLiteral extends TimeLiteral {
                 // }
                 return super.apply(fs, op, left);
             }
-            if (testValue.type === 'timestamp') {
+            if (malloy_types_1.TD.isAnyTimestamp(testValue)) {
                 const newStart = (0, expression_def_1.getMorphicValue)(rangeStart, 'timestamp');
                 const newEnd = (0, expression_def_1.getMorphicValue)(rangeEnd, 'timestamp');
                 if (newStart && newEnd) {
@@ -274,14 +267,14 @@ class DateBasedLiteral extends GranularLiteral {
     constructor(tm, units, nextLit) {
         super(tm, units, 'date', nextLit);
     }
-    getExpression(_fs) {
-        const dateValue = this.makeValue(this.literalPart, 'date');
-        const timestamp = this.makeLiteral(`${this.literalPart} 00:00:00`, 'timestamp', this.units);
+    getExpression(fs) {
+        const dateValue = this.makeValue(fs, this.literalPart, 'date');
+        const timestamp = this.makeLiteral(fs, `${this.literalPart} 00:00:00`, 'timestamp', this.units);
         return { ...dateValue, morphic: { timestamp }, evalSpace: 'literal' };
     }
-    getNext() {
-        const dateValue = this.makeValue(this.nextLit, 'date');
-        const timestamp = this.makeLiteral(`${this.nextLit} 00:00:00`, 'timestamp', this.units);
+    getNext(fs) {
+        const dateValue = this.makeValue(fs, this.nextLit, 'date');
+        const timestamp = this.makeLiteral(fs, `${this.nextLit} 00:00:00`, 'timestamp', this.units);
         return { ...dateValue, morphic: { timestamp } };
     }
 }

package/dist/lang/ast/query-items/field-declaration.js

@@ -126,8 +126,7 @@ class AtomicFieldDeclaration extends malloy_element_1.MalloyElement {
         if ((0, malloy_types_1.isAtomicFieldType)(exprValue.type) && exprValue.type !== 'error') {
             this.typecheckExprValue(exprValue);
             const ret = (0, malloy_types_1.mkFieldDef)(TDU.atomicDef(exprValue), exprName);
-            if ((ret.type === 'date' || ret.type === 'timestamp') &&
-                (0, granular_result_1.isGranularResult)(exprValue)) {
+            if (malloy_types_1.TD.isTemporal(ret) && (0, granular_result_1.isGranularResult)(exprValue)) {
                 ret.timeframe = exprValue.timeframe;
             }
             ret.location = this.location;

package/dist/lang/ast/time-utils.js

@@ -75,7 +75,7 @@ function resolution(timeframe) {
 }
 function mkTimeResult(t, tt) {
     if (tt) {
-        if (t.type === 'timestamp') {
+        if (malloy_types_1.TD.isAnyTimestamp(t)) {
             return { ...t, timeframe: tt };
         }
         if ((0, malloy_types_1.isDateUnit)(tt)) {

package/dist/lang/ast/typedesc-utils.d.ts

@@ -4,6 +4,7 @@ export declare const numberT: TypeDesc;
 export declare const stringT: TypeDesc;
 export declare const dateT: TypeDesc;
 export declare const timestampT: TypeDesc;
+export declare const timestamptzT: TypeDesc;
 export declare const boolT: TypeDesc;
 export declare const errorT: TypeDesc;
 export declare const aggregateBoolT: TypeDesc;