@malloydata/malloy 0.0.321 → 0.0.323

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

@@ -1,4 +1,4 @@
-import type { Sampling, AtomicTypeDef, TimeTruncExpr, TimeExtractExpr, TimeDeltaExpr, TypecastExpr, RegexMatchExpr, TimeLiteralNode, MeasureTimeExpr, BasicAtomicTypeDef, RecordLiteralNode, ArrayLiteralNode } from '../../model/malloy_types';
+import type { Sampling, AtomicTypeDef, TimeExtractExpr, TypecastExpr, RegexMatchExpr, TimeLiteralNode, MeasureTimeExpr, BasicAtomicTypeDef, RecordLiteralNode, ArrayLiteralNode, TimestampUnit } from '../../model/malloy_types';
 import type { DialectFunctionOverloadDef } from '../functions';
 import type { DialectFieldList, OrderByRequest, QueryInfo } from '../dialect';
 import { Dialect } from '../dialect';
@@ -28,6 +28,10 @@ export declare class StandardSQLDialect extends Dialect {
     supportsHyperLogLog: boolean;
     likeEscape: boolean;
     quoteTablePath(tablePath: string): string;
+    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;
@@ -46,9 +50,11 @@ export declare class StandardSQLDialect extends Dialect {
     sqlSelectAliasAsStruct(alias: string): string;
     sqlMaybeQuoteIdentifier(identifier: string): string;
     sqlNowExpr(): string;
-    sqlTruncExpr(qi: QueryInfo, trunc: TimeTruncExpr): string;
     sqlTimeExtractExpr(qi: QueryInfo, te: TimeExtractExpr): string;
-    sqlAlterTimeExpr(df: TimeDeltaExpr): string;
+    sqlConvertToCivilTime(expr: string, timezone: string): string;
+    sqlConvertFromCivilTime(expr: string, timezone: string): string;
+    sqlTruncate(expr: string, unit: TimestampUnit, typeDef: AtomicTypeDef, inCivilTime: boolean, timezone?: string): string;
+    sqlOffsetTime(expr: string, op: '+' | '-', magnitude: string, unit: TimestampUnit, typeDef: AtomicTypeDef, inCivilTime: boolean, _timezone?: string): string;
     ignoreInProject(fieldName: string): boolean;
     sqlCast(qi: QueryInfo, cast: TypecastExpr): string;
     sqlRegexpMatch(match: RegexMatchExpr): string;

package/dist/dialect/standardsql/standardsql.js

@@ -40,9 +40,6 @@ function timestampMeasureable(units) {
         'day',
     ].includes(units);
 }
-function dateMeasureable(units) {
-    return ['day', 'week', 'month', 'quarter', 'year'].includes(units);
-}
 const extractMap = {
     'day_of_week': 'dayofweek',
     'day_of_year': 'dayofyear',
@@ -104,6 +101,17 @@ class StandardSQLDialect extends dialect_1.Dialect {
     quoteTablePath(tablePath) {
         return `\`${tablePath}\``;
     }
+    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.isTimestamp(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)))`;
     }
@@ -212,45 +220,46 @@ ${(0, utils_1.indent)(sql)}
     sqlNowExpr() {
         return 'CURRENT_TIMESTAMP()';
     }
-    sqlTruncExpr(qi, trunc) {
-        const tz = qtz(qi);
-        const tzAdd = tz ? `, "${tz}"` : '';
-        if (malloy_types_1.TD.isDate(trunc.e.typeDef)) {
-            if (dateMeasureable(trunc.units)) {
-                return `DATE_TRUNC(${trunc.e.sql},${trunc.units})`;
-            }
-            return `TIMESTAMP(${trunc.e.sql}${tzAdd})`;
-        }
-        return `TIMESTAMP_TRUNC(${trunc.e.sql},${trunc.units}${tzAdd})`;
-    }
     sqlTimeExtractExpr(qi, te) {
         const extractTo = extractMap[te.units] || te.units;
         const tz = malloy_types_1.TD.isTimestamp(te.e.typeDef) && qtz(qi);
         const tzAdd = tz ? ` AT TIME ZONE '${tz}'` : '';
         return `EXTRACT(${extractTo} FROM ${te.e.sql}${tzAdd})`;
     }
-    sqlAlterTimeExpr(df) {
-        const from = df.kids.base;
-        let dataType = from === null || from === void 0 ? void 0 : from.typeDef.type;
-        let sql = from.sql;
-        if (df.units !== 'day' && timestampMeasureable(df.units)) {
-            // The units must be done in timestamp, no matter the input type
-            if (dataType !== 'timestamp') {
-                sql = `TIMESTAMP(${sql})`;
-                dataType = 'timestamp';
-            }
+    sqlConvertToCivilTime(expr, timezone) {
+        return `DATETIME(${expr}, '${timezone}')`;
+    }
+    sqlConvertFromCivilTime(expr, timezone) {
+        return `TIMESTAMP(${expr}, '${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})`;
         }
-        else if (dataType === 'timestamp') {
-            sql = `DATETIME(${sql})`;
-            dataType = 'datetime';
+        // TIMESTAMP truncation with optional timezone
+        const tzParam = timezone ? `, '${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})`;
         }
-        const funcTail = df.op === '+' ? '_ADD' : '_SUB';
-        const funcName = `${dataType.toUpperCase()}${funcTail}`;
-        const newTime = `${funcName}(${sql}, INTERVAL ${df.kids.delta.sql} ${df.units})`;
-        if (dataType === from.typeDef.type) {
-            return newTime;
+        // 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})`;
         }
-        return `${from.typeDef.type.toUpperCase()}(${newTime})`;
+        // TIMESTAMP with sub-day units only (calendar units go through civil time)
+        const funcName = op === '+' ? 'TIMESTAMP_ADD' : 'TIMESTAMP_SUB';
+        return `${funcName}(${expr}, INTERVAL ${magnitude} ${unit})`;
     }
     ignoreInProject(fieldName) {
         return fieldName === '_PARTITIONTIME';

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

@@ -1,4 +1,4 @@
-import type { Expr, Sampling, AtomicTypeDef, TimeDeltaExpr, TypecastExpr, RegexMatchExpr, MeasureTimeExpr, TimeLiteralNode, TimeExtractExpr, TimeTruncExpr, BasicAtomicTypeDef, RecordLiteralNode } from '../../model/malloy_types';
+import type { Expr, Sampling, AtomicTypeDef, TypecastExpr, RegexMatchExpr, MeasureTimeExpr, TimeLiteralNode, TimeExtractExpr, BasicAtomicTypeDef, RecordLiteralNode } from '../../model/malloy_types';
 import type { DialectFunctionOverloadDef } from '../functions';
 import type { DialectFieldList, OrderByClauseType, QueryInfo } from '../dialect';
 import { PostgresBase } from '../pg_impl';
@@ -51,7 +51,10 @@ export declare class TrinoDialect extends PostgresBase {
     sqlCreateFunctionCombineLastStage(lastStageName: string, fieldList: DialectFieldList): string;
     sqlSelectAliasAsStruct(alias: string, fieldList: any): string;
     keywords: string[];
-    sqlAlterTimeExpr(df: TimeDeltaExpr): string;
+    sqlConvertToCivilTime(expr: string, timezone: string): string;
+    sqlConvertFromCivilTime(expr: string, _timezone: string): string;
+    sqlTruncate(expr: string, unit: string, _typeDef: AtomicTypeDef, _inCivilTime: boolean, _timezone?: string): string;
+    sqlOffsetTime(expr: string, op: '+' | '-', magnitude: string, unit: string, _typeDef: AtomicTypeDef, _inCivilTime: boolean, _timezone?: string): string;
     sqlCast(qi: QueryInfo, cast: TypecastExpr): string;
     sqlRegexpMatch(reCmp: RegexMatchExpr): string;
     sqlMeasureTimeExpr(mf: MeasureTimeExpr): string;
@@ -72,7 +75,6 @@ export declare class TrinoDialect extends PostgresBase {
     sqlStringAggDistinct(distinctKey: string, valueSQL: string, separatorSQL: string): string;
     validateTypeName(sqlType: string): boolean;
     sqlLiteralTime(qi: QueryInfo, lit: TimeLiteralNode): string;
-    sqlTruncExpr(qi: QueryInfo, df: TimeTruncExpr): string;
     sqlTimeExtractExpr(qi: QueryInfo, from: TimeExtractExpr): string;
     sqlLiteralRecord(lit: RecordLiteralNode): string;
 }
@@ -81,6 +83,8 @@ export declare class PrestoDialect extends TrinoDialect {
     supportsPipelinesInViews: boolean;
     supportsLeftJoinUnnest: boolean;
     sqlGenerateUUID(): string;
+    sqlLiteralTime(qi: QueryInfo, lit: TimeLiteralNode): string;
+    sqlConvertFromCivilTime(expr: string, _timezone: string): string;
     sqlUnnestAlias(source: string, alias: string, _fieldList: DialectFieldList, needDistinctKey: boolean, isArray: boolean, _isInNestedPipeline: boolean): string;
     getDialectFunctions(): {
         [name: string]: DialectFunctionOverloadDef[];

package/dist/dialect/trino/trino.js

@@ -330,21 +330,35 @@ ${(0, utils_1.indent)(sql)}
         const definitions = this.buildTypeExpression(fieldList);
         return `CAST(ROW(${fields}) as ROW(${definitions})`;
     }
-    sqlAlterTimeExpr(df) {
-        let timeframe = df.units;
-        let n = df.kids.delta.sql;
-        if (timeframe === 'quarter') {
-            timeframe = 'month';
-            n = `${n}*3`;
+    sqlConvertToCivilTime(expr, timezone) {
+        return `${expr} AT TIME ZONE '${timezone}'`;
+    }
+    sqlConvertFromCivilTime(expr, _timezone) {
+        return `CAST(at_timezone(${expr}, 'UTC') AS TIMESTAMP)`;
+    }
+    sqlTruncate(expr, unit, _typeDef, _inCivilTime, _timezone) {
+        // Trino starts weeks on Monday, Malloy wants Sunday
+        // Add 1 day before truncating, subtract 1 day after
+        if (unit === 'week') {
+            return `(DATE_TRUNC('${unit}', (${expr} + INTERVAL '1' DAY)) - INTERVAL '1' DAY)`;
         }
-        if (timeframe === 'week') {
-            timeframe = 'day';
-            n = `${n}*7`;
+        return `DATE_TRUNC('${unit}', ${expr})`;
+    }
+    sqlOffsetTime(expr, op, magnitude, unit, _typeDef, _inCivilTime, _timezone) {
+        // Convert quarter/week to supported units
+        let offsetUnit = unit;
+        let offsetMag = magnitude;
+        if (unit === 'quarter') {
+            offsetUnit = 'month';
+            offsetMag = `${magnitude}*3`;
         }
-        if (df.op === '-') {
-            n = `(${n})*-1`;
+        else if (unit === 'week') {
+            offsetUnit = 'day';
+            offsetMag = `${magnitude}*7`;
         }
-        return `DATE_ADD('${timeframe}', ${n}, ${df.kids.base.sql})`;
+        // Handle subtraction by negating
+        const n = op === '-' ? `(${offsetMag})*-1` : offsetMag;
+        return `DATE_ADD('${offsetUnit}', ${n}, ${expr})`;
     }
     sqlCast(qi, cast) {
         const { op, srcTypeDef, dstTypeDef, dstSQLType } = this.sqlCastPrep(cast);
@@ -494,40 +508,11 @@ ${(0, utils_1.indent)(sql)}
         }
         const tz = lit.timezone || qtz(qi);
         if (tz) {
-            return `TIMESTAMP '${lit.literal} ${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 `TIMESTAMP '${lit.literal}'`;
     }
-    sqlTruncExpr(qi, df) {
-        // adjusting for monday/sunday weeks
-        const week = df.units === 'week';
-        const truncThis = week ? `${df.e.sql} + INTERVAL '1' DAY` : df.e.sql;
-        // Only do timezone conversion for timestamps, not dates
-        if (malloy_types_1.TD.isTimestamp(df.e.typeDef)) {
-            const tz = qtz(qi);
-            if (tz) {
-                // get a civil version of the time in the query time zone
-                const civilSource = `(CAST(${truncThis} AS TIMESTAMP WITH TIME ZONE) AT TIME ZONE '${tz}')`;
-                // do truncation in that time space
-                let civilTrunc = `DATE_TRUNC('${df.units}', ${civilSource})`;
-                if (week) {
-                    civilTrunc = `(${civilTrunc} - INTERVAL '1' DAY)`;
-                }
-                // make a tstz from the civil time ... "AT TIME ZONE" of
-                // a TIMESTAMP will produce a TIMESTAMP WITH TIME ZONE in that zone
-                // where the civil appearance is the same as the TIMESTAMP
-                const truncTsTz = `${civilTrunc} AT TIME ZONE '${tz}'`;
-                // Now just make a system TIMESTAMP from that
-                return `CAST(${truncTsTz} AS TIMESTAMP)`;
-            }
-        }
-        // For dates (civil time) or timestamps without query timezone
-        let result = `DATE_TRUNC('${df.units}', ${truncThis})`;
-        if (week) {
-            result = `(${result} - INTERVAL '1' DAY)`;
-        }
-        return result;
-    }
     sqlTimeExtractExpr(qi, from) {
         const pgUnits = pg_impl_1.timeExtractMap[from.units] || from.units;
         let extractFrom = from.e.sql || '';
@@ -567,6 +552,19 @@ 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);
+        if (tz) {
+            return `CAST(TIMESTAMP '${lit.literal} ${tz}' AT TIME ZONE 'UTC' AS TIMESTAMP)`;
+        }
+        return `TIMESTAMP '${lit.literal}'`;
+    }
+    sqlConvertFromCivilTime(expr, _timezone) {
+        return `CAST(${expr} AT TIME ZONE 'UTC' AS TIMESTAMP)`;
+    }
     sqlUnnestAlias(source, alias, _fieldList, needDistinctKey, isArray, _isInNestedPipeline) {
         if (isArray) {
             if (needDistinctKey) {

package/dist/lang/ast/error-factory.js

@@ -52,7 +52,7 @@ class ErrorFactory {
         return factoryJoin;
     }
     static didCreate(s) {
-        return s.type === 'table' && 'errorFactory' in s;
+        return 'errorFactory' in s;
     }
     static get query() {
         return {

package/dist/lang/ast/field-space/static-space.js

@@ -141,7 +141,11 @@ class StaticSpace {
                     type: found instanceof struct_space_field_base_1.StructSpaceFieldBase
                         ? 'joinReference'
                         : 'fieldReference',
-                    definition,
+                    definition: {
+                        type: definition.type,
+                        annotation: definition.annotation,
+                        location: definition.location,
+                    },
                     location: head.location,
                     text: head.refString,
                 });

package/dist/lang/ast/types/malloy-element.js

@@ -118,7 +118,11 @@ class MalloyElement {
                 this.addReference({
                     type: 'queryReference',
                     text: key,
-                    definition: result.entry,
+                    definition: {
+                        type: result.entry.type,
+                        annotation: result.entry.annotation,
+                        location: result.entry.location,
+                    },
                     location: reference.location,
                 });
             }
@@ -126,7 +130,11 @@ class MalloyElement {
                 this.addReference({
                     type: 'exploreReference',
                     text: key,
-                    definition: result.entry,
+                    definition: {
+                        type: result.entry.type,
+                        annotation: result.entry.annotation,
+                        location: result.entry.location,
+                    },
                     location: reference.location,
                 });
             }