@malloydata/malloy 0.0.432 → 0.0.434

package/dist/dialect/pg_impl.js

@@ -45,7 +45,7 @@ class PostgresBase extends dialect_1.Dialect {
         if (malloy_types_1.TD.isAnyTimestamp(from.e.typeDef)) {
             const tz = (0, dialect_1.qtz)(qi);
             if (tz) {
-                extractFrom = `(${extractFrom}::TIMESTAMPTZ AT TIME ZONE '${tz}')`;
+                extractFrom = `(${extractFrom}::TIMESTAMPTZ AT TIME ZONE ${this.sqlTimezoneLiteral(tz)})`;
             }
         }
         const extracted = `EXTRACT(${units} FROM ${extractFrom})`;
@@ -59,23 +59,23 @@ class PostgresBase extends dialect_1.Dialect {
         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 '${tz}' AS DATE)`;
+                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 '${tz}' AS DATE)`;
+                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 '${tz}' AS TIMESTAMP)`;
+                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 '${tz}'`;
+                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 '${tz}'`;
+                return `(${expr}) AT TIME ZONE ${this.sqlTimezoneLiteral(tz)}`;
             }
         }
         // No special handling needed, or no query timezone
@@ -94,12 +94,12 @@ class PostgresBase extends dialect_1.Dialect {
     sqlTimestampLiteral(qi, literal, timezone) {
         const tz = timezone || (0, dialect_1.qtz)(qi);
         if (tz) {
-            return `TIMESTAMPTZ '${literal} ${tz}'::TIMESTAMP`;
+            return `TIMESTAMPTZ '${literal} ${this.checkedTimezoneName(tz)}'::TIMESTAMP`;
         }
         return `TIMESTAMP '${literal}'`;
     }
     sqlTimestamptzLiteral(_qi, literal, timezone) {
-        return `TIMESTAMPTZ '${literal} ${timezone}'`;
+        return `TIMESTAMPTZ '${literal} ${this.checkedTimezoneName(timezone)}'`;
     }
     sqlLiteralRecord(_lit) {
         throw new Error('Cannot create a record literal for postgres base dialect');
@@ -113,22 +113,22 @@ class PostgresBase extends dialect_1.Dialect {
         // For timestamptz (TIMESTAMPTZ): AT TIME ZONE converts to plain TIMESTAMP (civil in timezone)
         if (typeDef.type === 'timestamptz') {
             return {
-                sql: `(${expr}) AT TIME ZONE '${timezone}'`,
+                sql: `(${expr}) AT TIME ZONE ${this.sqlTimezoneLiteral(timezone)}`,
                 typeDef: { type: 'timestamp' },
             };
         }
         // 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 '${timezone}'`,
+            sql: `(${expr})::TIMESTAMPTZ AT TIME ZONE ${this.sqlTimezoneLiteral(timezone)}`,
             typeDef: { type: 'timestamp' },
         };
     }
     sqlConvertFromCivilTime(expr, timezone, destTypeDef) {
         if (destTypeDef.type === 'timestamptz') {
-            return `(${expr}) AT TIME ZONE '${timezone}'`;
+            return `(${expr}) AT TIME ZONE ${this.sqlTimezoneLiteral(timezone)}`;
         }
-        return `((${expr}) AT TIME ZONE '${timezone}')::TIMESTAMP`;
+        return `((${expr}) AT TIME ZONE ${this.sqlTimezoneLiteral(timezone)})::TIMESTAMP`;
     }
     sqlTruncate(expr, unit, _typeDef, inCivilTime, _timezone) {
         // PostgreSQL/DuckDB starts weeks on Monday, Malloy wants Sunday

package/dist/dialect/postgres/postgres.js

@@ -94,7 +94,7 @@ class PostgresDialect extends pg_impl_1.PostgresBase {
     }
     mapFields(fieldList) {
         return fieldList
-            .map(f => `\n  ${f.sqlExpression}${f.typeDef.type === 'number' ? `::${this.defaultNumberType}` : ''} as ${f.sqlOutputName}`)
+            .map(f => `\n  ${f.sqlExpression}${f.typeDef.type === 'number' ? `::${this.defaultNumberType}` : ''} as ${this.sqlQuoteIdentifier(f.rawName)}`)
             .join(', ');
     }
     sqlAggregateTurtle(groupSet, fieldList, orderBy, limit, filterSQL) {
@@ -110,7 +110,7 @@ class PostgresDialect extends pg_impl_1.PostgresBase {
     }
     sqlAnyValueTurtle(groupSet, fieldList) {
         const fields = fieldList
-            .map(f => `${f.sqlExpression} as ${f.sqlOutputName}`)
+            .map(f => `${f.sqlExpression} as ${this.sqlQuoteIdentifier(f.rawName)}`)
             .join(', ');
         return `ANY_VALUE(CASE WHEN group_set=${groupSet} THEN STRUCT(${fields}))`;
     }
@@ -393,7 +393,7 @@ class PostgresDialect extends pg_impl_1.PostgresBase {
         if (malloy_types_1.TD.isAnyTimestamp(from.e.typeDef)) {
             const tz = (0, dialect_1.qtz)(qi);
             if (tz) {
-                extractFrom = `(${extractFrom}::TIMESTAMPTZ AT TIME ZONE '${tz}')`;
+                extractFrom = `(${extractFrom}::TIMESTAMPTZ AT TIME ZONE ${this.sqlTimezoneLiteral(tz)})`;
             }
         }
         // PostgreSQL before 14 returns a double precision for EXTRACT, cast to integer

package/dist/dialect/snowflake/snowflake.js

@@ -105,7 +105,7 @@ class SnowflakeDialect extends dialect_1.Dialect {
     }
     mapFields(fieldList) {
         return fieldList
-            .map(f => `\n  ${f.sqlExpression} as ${f.sqlOutputName}`)
+            .map(f => `\n  ${f.sqlExpression} as ${this.sqlQuoteIdentifier(f.rawName)}`)
             .join(', ');
     }
     mapFieldsForObjectConstruct(fieldList) {
@@ -138,7 +138,7 @@ class SnowflakeDialect extends dialect_1.Dialect {
     sqlCoaleseMeasuresInline(groupSet, fieldList) {
         const fields = this.mapFieldsForObjectConstruct(fieldList);
         const nullValues = fieldList
-            .map(f => `'${f.sqlOutputName}', NULL`)
+            .map(f => `${this.sqlLiteralString(f.rawName)}, NULL`)
             .join(', ');
         return `COALESCE(ARRAY_AGG(CASE WHEN group_set=${groupSet} THEN OBJECT_CONSTRUCT_KEEP_NULL(${fields}) END)[0], OBJECT_CONSTRUCT_KEEP_NULL(${nullValues}))`;
     }
@@ -254,21 +254,21 @@ ${(0, utils_1.indent)(sql)}
         // Returns TIMESTAMP_TZ with timezone preserved
         if (typeDef.type === 'timestamptz') {
             return {
-                sql: `CONVERT_TIMEZONE('${timezone}', ${expr})`,
+                sql: `CONVERT_TIMEZONE(${this.sqlTimezoneLiteral(timezone)}, ${expr})`,
                 typeDef: { type: 'timestamptz' },
             };
         }
         // For plain timestamps (TIMESTAMP_NTZ): use 3-arg form
         // Must cast to TIMESTAMP_NTZ first, returns TIMESTAMP_NTZ
         return {
-            sql: `CONVERT_TIMEZONE('UTC', '${timezone}', (${expr})::TIMESTAMP_NTZ)`,
+            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('${timezone}', 'UTC', (${expr})::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)
@@ -287,7 +287,7 @@ ${(0, utils_1.indent)(sql)}
         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('${tz}', ${extractFrom})`;
+            extractFrom = `CONVERT_TIMEZONE(${this.sqlTimezoneLiteral(tz)}, ${extractFrom})`;
         }
         return `EXTRACT(${extractUnits} FROM ${extractFrom})`;
     }
@@ -295,7 +295,7 @@ ${(0, utils_1.indent)(sql)}
         if (tz !== undefined) {
             return `(
       TO_CHAR(${sqlExpr}::TIMESTAMP_NTZ, 'YYYY-MM-DD HH24:MI:SS.FF9') ||
-      TO_CHAR(CONVERT_TIMEZONE('${tz}', '1970-01-01 00:00:00'), 'TZHTZM')
+      TO_CHAR(CONVERT_TIMEZONE(${this.sqlTimezoneLiteral(tz)}, '1970-01-01 00:00:00'), 'TZHTZM')
     )::TIMESTAMP_TZ`;
         }
         return `${sqlExpr}::TIMESTAMP_NTZ`;
@@ -321,11 +321,11 @@ ${(0, utils_1.indent)(sql)}
         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('${tz}', ${src}))`;
+                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('${tz}', ${src}))`;
+                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)) {
@@ -339,7 +339,7 @@ ${(0, utils_1.indent)(sql)}
             }
             // 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('${tz}', ${src})::TIMESTAMP_NTZ`;
+                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)) {
@@ -357,7 +357,7 @@ ${(0, utils_1.indent)(sql)}
         let ret = `'${literal}'::TIMESTAMP_NTZ`;
         if (tz) {
             // Interpret the literal as being in query timezone, convert to UTC
-            ret = `CONVERT_TIMEZONE('${tz}', 'UTC', ${ret})`;
+            ret = `CONVERT_TIMEZONE(${this.sqlTimezoneLiteral(tz)}, 'UTC', ${ret})`;
         }
         return ret;
     }
@@ -374,7 +374,7 @@ ${(0, utils_1.indent)(sql)}
         const minute = dt.minute;
         const second = dt.second;
         const nanosecond = dt.millisecond * 1000000;
-        return `TIMESTAMP_TZ_FROM_PARTS(${year}, ${month}, ${day}, ${hour}, ${minute}, ${second}, ${nanosecond}, '${timezone}')`;
+        return `TIMESTAMP_TZ_FROM_PARTS(${year}, ${month}, ${day}, ${hour}, ${minute}, ${second}, ${nanosecond}, ${this.sqlTimezoneLiteral(timezone)})`;
     }
     sqlMeasureTimeExpr(df) {
         const from = df.kids.left;

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

@@ -55,7 +55,7 @@ export declare class StandardSQLDialect extends Dialect {
     sqlCreateFunction(id: string, funcText: string): string;
     sqlCreateTableAsSelect(tableName: string, sql: string): string;
     sqlCreateFunctionCombineLastStage(lastStageName: string): string;
-    sqlSelectAliasAsStruct(alias: string): string;
+    sqlSelectAliasAsStruct(alias: string, dialectFieldList: DialectFieldList): string;
     sqlNowExpr(): string;
     sqlTimeExtractExpr(qi: QueryInfo, te: TimeExtractExpr): string;
     sqlConvertToCivilTime(expr: string, timezone: string, _typeDef: AtomicTypeDef): {

package/dist/dialect/standardsql/standardsql.js

@@ -150,7 +150,7 @@ class StandardSQLDialect extends dialect_1.Dialect {
     // can array agg or any_value a struct...
     sqlAggregateTurtle(groupSet, fieldList, orderBy, limit, filterSQL) {
         const fields = fieldList
-            .map(f => `\n  ${f.sqlExpression} as ${f.sqlOutputName}`)
+            .map(f => `\n  ${f.sqlExpression} as ${this.sqlQuoteIdentifier(f.rawName)}`)
             .join(', ');
         const orderByClause = orderBy ? this.sqlTurtleOrderByClause(orderBy) : '';
         // BigQuery ARRAY_AGG takes LIMIT as its final sub-clause, after ORDER BY.
@@ -162,7 +162,7 @@ class StandardSQLDialect extends dialect_1.Dialect {
     }
     sqlAnyValueTurtle(groupSet, fieldList) {
         const fields = fieldList
-            .map(f => `${f.sqlExpression} as ${f.sqlOutputName}`)
+            .map(f => `${f.sqlExpression} as ${this.sqlQuoteIdentifier(f.rawName)}`)
             .join(', ');
         return `ANY_VALUE(CASE WHEN group_set=${groupSet} THEN STRUCT(${fields}) END)`;
     }
@@ -171,10 +171,10 @@ class StandardSQLDialect extends dialect_1.Dialect {
     }
     sqlCoaleseMeasuresInline(groupSet, fieldList) {
         const fields = fieldList
-            .map(f => `${f.sqlExpression} as ${f.sqlOutputName}`)
+            .map(f => `${f.sqlExpression} as ${this.sqlQuoteIdentifier(f.rawName)}`)
             .join(', ');
         const nullValues = fieldList
-            .map(f => `NULL as ${f.sqlOutputName}`)
+            .map(f => `NULL as ${this.sqlQuoteIdentifier(f.rawName)}`)
             .join(', ');
         return `COALESCE(ANY_VALUE(CASE WHEN group_set=${groupSet} THEN STRUCT(${fields}) END), STRUCT(${nullValues}))`;
     }
@@ -240,8 +240,11 @@ ${(0, utils_1.indent)(sql)}
     sqlCreateFunctionCombineLastStage(lastStageName) {
         return `SELECT ARRAY((SELECT AS STRUCT * FROM ${lastStageName}))\n`;
     }
-    sqlSelectAliasAsStruct(alias) {
-        return `(SELECT AS STRUCT ${alias}.*)`;
+    sqlSelectAliasAsStruct(alias, dialectFieldList) {
+        const fields = dialectFieldList
+            .map(d => `${alias}.${this.sqlQuoteIdentifier(d.rawName)}`)
+            .join(', ');
+        return `(SELECT AS STRUCT ${fields})`;
     }
     sqlNowExpr() {
         return 'CURRENT_TIMESTAMP()';
@@ -249,18 +252,18 @@ ${(0, utils_1.indent)(sql)}
     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 '${tz}'` : '';
+        const tzAdd = tz ? ` AT TIME ZONE ${this.sqlTimezoneLiteral(tz)}` : '';
         return `EXTRACT(${extractTo} FROM ${te.e.sql}${tzAdd})`;
     }
     sqlConvertToCivilTime(expr, timezone, _typeDef) {
         // BigQuery has no timestamptz type, so typeDef.timestamptz will never be true
         return {
-            sql: `DATETIME(${expr}, '${timezone}')`,
+            sql: `DATETIME(${expr}, ${this.sqlTimezoneLiteral(timezone)})`,
             typeDef: { type: 'timestamp' },
         };
     }
     sqlConvertFromCivilTime(expr, timezone, _destTypeDef) {
-        return `TIMESTAMP(${expr}, '${timezone}')`;
+        return `TIMESTAMP(${expr}, ${this.sqlTimezoneLiteral(timezone)})`;
     }
     sqlTruncate(expr, unit, typeDef, inCivilTime, timezone) {
         if (inCivilTime) {
@@ -272,7 +275,7 @@ ${(0, utils_1.indent)(sql)}
             return `DATE_TRUNC(${expr}, ${unit})`;
         }
         // TIMESTAMP truncation with optional timezone
-        const tzParam = timezone ? `, '${timezone}'` : '';
+        const tzParam = timezone ? `, ${this.sqlTimezoneLiteral(timezone)}` : '';
         return `TIMESTAMP_TRUNC(${expr}, ${unit}${tzParam})`;
     }
     sqlOffsetTime(expr, op, magnitude, unit, typeDef, inCivilTime, _timezone) {
@@ -299,10 +302,10 @@ ${(0, utils_1.indent)(sql)}
         const tz = qtz(qi);
         const src = cast.e.sql || '';
         if (op === 'timestamp::date' && tz) {
-            return `DATE(${src},'${tz}')`;
+            return `DATE(${src},${this.sqlTimezoneLiteral(tz)})`;
         }
         if (op === 'date::timestamp' && tz) {
-            return `TIMESTAMP(${src}, '${tz}')`;
+            return `TIMESTAMP(${src}, ${this.sqlTimezoneLiteral(tz)})`;
         }
         if (!malloy_types_1.TD.eq(srcTypeDef, dstTypeDef)) {
             const castFunc = cast.safe ? 'SAFE_CAST' : 'CAST';
@@ -320,7 +323,7 @@ ${(0, utils_1.indent)(sql)}
         let timestampArgs = `'${literal}'`;
         const tz = timezone || qtz(qi);
         if (tz && tz !== 'UTC') {
-            timestampArgs += `,'${tz}'`;
+            timestampArgs += `,${this.sqlTimezoneLiteral(tz)}`;
         }
         return `TIMESTAMP(${timestampArgs})`;
     }

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

@@ -1,4 +1,4 @@
-import type { Expr, Sampling, AtomicTypeDef, ATimestampTypeDef, TypecastExpr, RegexMatchExpr, MeasureTimeExpr, TimeExtractExpr, BasicAtomicTypeDef, RecordLiteralNode } from '../../model/malloy_types';
+import type { Expr, Sampling, AtomicTypeDef, ATimestampTypeDef, TypecastExpr, RegexMatchExpr, MeasureTimeExpr, TimeExtractExpr, BasicAtomicTypeDef, RecordLiteralNode, OrderBy } from '../../model/malloy_types';
 import type { DialectFunctionOverloadDef } from '../functions';
 import type { CompiledOrderBy, DialectFieldList, OrderByClauseType, QueryInfo } from '../dialect';
 import { PostgresBase } from '../pg_impl';
@@ -49,8 +49,8 @@ export declare class TrinoDialect extends PostgresBase {
     sqlUnnestPipelineHead(isSingleton: boolean, sourceSQLExpression: string): string;
     sqlCreateFunction(id: string, funcText: string): string;
     sqlCreateTableAsSelect(tableName: string, sql: string): string;
-    sqlCreateFunctionCombineLastStage(lastStageName: string, fieldList: DialectFieldList): string;
-    sqlSelectAliasAsStruct(alias: string, fieldList: any): string;
+    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;

package/dist/dialect/trino/trino.js

@@ -82,7 +82,7 @@ class TrinoDialect extends pg_impl_1.PostgresBase {
         this.orderByClause = 'output_name';
         this.nullMatchesFunctionSignature = false;
         this.supportsSelectReplace = false;
-        this.supportsComplexFilteredSources = false;
+        this.supportsComplexFilteredSources = true;
         this.supportsTempTables = false;
         this.supportsCountApprox = true;
         this.supportsHyperLogLog = true;
@@ -223,7 +223,8 @@ class TrinoDialect extends pg_impl_1.PostgresBase {
     }
     buildTypeExpression(fieldList) {
         return fieldList
-            .map(dlf => `${dlf.sqlOutputName} ${this.malloyTypeToSQLType(dlf.typeDef)}`)
+            .map(dlf => `${this.sqlQuoteIdentifier(dlf.rawName)} ` +
+            this.malloyTypeToSQLType(dlf.typeDef))
             .join(', \n');
     }
     // can array agg or any_value a struct...
@@ -325,15 +326,18 @@ ${(0, utils_1.indent)(sql)}
 );
 `;
     }
-    sqlCreateFunctionCombineLastStage(lastStageName, fieldList) {
+    sqlCreateFunctionCombineLastStage(lastStageName, fieldList, orderBy) {
         const fields = fieldList.map(f => f.sqlExpression).join(', ');
         const definitions = this.buildTypeExpression(fieldList);
-        return `SELECT ARRAY_AGG(CAST(ROW(${fields}) as ROW(${definitions}))) FROM ${lastStageName}\n`;
+        const o = this.sqlCombineLastStageOrderBy(orderBy, fieldList);
+        return `SELECT ARRAY_AGG(CAST(ROW(${fields}) as ROW(${definitions}))${o}) FROM ${lastStageName}\n`;
     }
     sqlSelectAliasAsStruct(alias, fieldList) {
-        const fields = fieldList.map(f => f.sqlExpression).join(', ');
+        const fields = fieldList
+            .map(f => `${alias}.${this.sqlQuoteIdentifier(f.rawName)}`)
+            .join(', ');
         const definitions = this.buildTypeExpression(fieldList);
-        return `CAST(ROW(${fields}) as ROW(${definitions})`;
+        return `CAST(ROW(${fields}) as ROW(${definitions}))`;
     }
     sqlConvertToCivilTime(expr, timezone, typeDef) {
         // Trino civil time = TIMESTAMPTZ with query timezone as stored timezone
@@ -341,13 +345,13 @@ ${(0, utils_1.indent)(sql)}
         if (typeDef.type === 'timestamp') {
             // TIMESTAMP (UTC wall clock) → TIMESTAMPTZ in query timezone
             return {
-                sql: `at_timezone(with_timezone(${expr}, 'UTC'), '${timezone}')`,
+                sql: `at_timezone(with_timezone(${expr}, 'UTC'), ${this.sqlTimezoneLiteral(timezone)})`,
                 typeDef: { type: 'timestamptz' },
             };
         }
         // TIMESTAMPTZ → TIMESTAMPTZ in query timezone (same instant, different stored tz)
         return {
-            sql: `at_timezone(${expr}, '${timezone}')`,
+            sql: `at_timezone(${expr}, ${this.sqlTimezoneLiteral(timezone)})`,
             typeDef: { type: 'timestamptz' },
         };
     }
@@ -392,27 +396,27 @@ ${(0, utils_1.indent)(sql)}
         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)`;
+                return `CAST(at_timezone(with_timezone(${expr}, 'UTC'), ${this.sqlTimezoneLiteral(tz)}) AS DATE)`;
             }
             // TIMESTAMPTZ → DATE: convert to query timezone
             if (malloy_types_1.TD.isTimestamptz(srcTypeDef) && malloy_types_1.TD.isDate(dstTypeDef)) {
-                return `CAST(at_timezone(${expr}, '${tz}') AS DATE)`;
+                return `CAST(at_timezone(${expr}, ${this.sqlTimezoneLiteral(tz)}) AS DATE)`;
             }
             // DATE → TIMESTAMP: interpret date in query timezone, return UTC wall clock
             if (malloy_types_1.TD.isDate(srcTypeDef) && malloy_types_1.TD.isTimestamp(dstTypeDef)) {
-                return `CAST(at_timezone(with_timezone(CAST(${expr} AS TIMESTAMP), '${tz}'), 'UTC') AS TIMESTAMP)`;
+                return `CAST(at_timezone(with_timezone(CAST(${expr} AS TIMESTAMP), ${this.sqlTimezoneLiteral(tz)}), 'UTC') AS TIMESTAMP)`;
             }
             // DATE → TIMESTAMPTZ: interpret date in query timezone
             if (malloy_types_1.TD.isDate(srcTypeDef) && malloy_types_1.TD.isTimestamptz(dstTypeDef)) {
-                return `with_timezone(CAST(${expr} AS TIMESTAMP), '${tz}')`;
+                return `with_timezone(CAST(${expr} AS TIMESTAMP), ${this.sqlTimezoneLiteral(tz)})`;
             }
             // TIMESTAMPTZ → TIMESTAMP: convert to query timezone wall clock
             if (malloy_types_1.TD.isTimestamptz(srcTypeDef) && malloy_types_1.TD.isTimestamp(dstTypeDef)) {
-                return `CAST(at_timezone(${expr}, '${tz}') AS TIMESTAMP)`;
+                return `CAST(at_timezone(${expr}, ${this.sqlTimezoneLiteral(tz)}) AS TIMESTAMP)`;
             }
             // TIMESTAMP → TIMESTAMPTZ: interpret TIMESTAMP as being in query timezone
             if (malloy_types_1.TD.isTimestamp(srcTypeDef) && malloy_types_1.TD.isTimestamptz(dstTypeDef)) {
-                return `with_timezone(${expr}, '${tz}')`;
+                return `with_timezone(${expr}, ${this.sqlTimezoneLiteral(tz)})`;
             }
         }
         // No special handling needed, or no query timezone
@@ -567,13 +571,13 @@ ${(0, utils_1.indent)(sql)}
         const tz = timezone || qtz(qi);
         if (tz) {
             // Interpret wall clock time in timezone, convert to UTC wall clock, cast to TIMESTAMP
-            return `CAST(at_timezone(with_timezone(TIMESTAMP '${literal}', '${tz}'), 'UTC') AS TIMESTAMP)`;
+            return `CAST(at_timezone(with_timezone(TIMESTAMP '${literal}', ${this.sqlTimezoneLiteral(tz)}), 'UTC') AS TIMESTAMP)`;
         }
         return `TIMESTAMP '${literal}'`;
     }
     sqlTimestamptzLiteral(_qi, literal, timezone) {
         // Use with_timezone to create a TIMESTAMP WITH TIME ZONE
-        return `with_timezone(TIMESTAMP '${literal}', '${timezone}')`;
+        return `with_timezone(TIMESTAMP '${literal}', ${this.sqlTimezoneLiteral(timezone)})`;
     }
     sqlTimeExtractExpr(qi, from) {
         const pgUnits = pg_impl_1.timeExtractMap[from.units] || from.units;
@@ -584,11 +588,11 @@ ${(0, utils_1.indent)(sql)}
                 // 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}')`;
+                    extractFrom = `at_timezone(with_timezone(${extractFrom}, 'UTC'), ${this.sqlTimezoneLiteral(tz)})`;
                 }
                 else {
                     // TIMESTAMPTZ: convert to query timezone
-                    extractFrom = `at_timezone(${extractFrom}, '${tz}')`;
+                    extractFrom = `at_timezone(${extractFrom}, ${this.sqlTimezoneLiteral(tz)})`;
                 }
             }
         }
@@ -628,18 +632,18 @@ class PrestoDialect extends TrinoDialect {
     sqlTimestampLiteral(qi, literal, timezone) {
         const tz = timezone || qtz(qi);
         if (tz) {
-            return `CAST(TIMESTAMP '${literal} ${tz}' AT TIME ZONE 'UTC' AS TIMESTAMP)`;
+            return `CAST(TIMESTAMP '${literal} ${this.checkedTimezoneName(tz)}' AT TIME ZONE 'UTC' AS TIMESTAMP)`;
         }
         return `TIMESTAMP '${literal}'`;
     }
     sqlTimestamptzLiteral(_qi, literal, timezone) {
-        return `TIMESTAMP '${literal} ${timezone}'`;
+        return `TIMESTAMP '${literal} ${this.checkedTimezoneName(timezone)}'`;
     }
     sqlConvertToCivilTime(expr, timezone, _typeDef) {
         // Presto's AT TIME ZONE operator (not function) produces TIMESTAMPTZ
         // Reinterprets the instant in the target timezone
         return {
-            sql: `${expr} AT TIME ZONE '${timezone}'`,
+            sql: `${expr} AT TIME ZONE ${this.sqlTimezoneLiteral(timezone)}`,
             typeDef: { type: 'timestamptz' },
         };
     }
@@ -658,26 +662,26 @@ class PrestoDialect extends TrinoDialect {
         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)`;
+                return `CAST((${expr} AT TIME ZONE 'UTC') AT TIME ZONE ${this.sqlTimezoneLiteral(tz)} AS DATE)`;
             }
             // TIMESTAMPTZ → DATE: convert to query timezone
             if (malloy_types_1.TD.isTimestamptz(srcTypeDef) && malloy_types_1.TD.isDate(dstTypeDef)) {
-                return `CAST(${expr} AT TIME ZONE '${tz}' AS DATE)`;
+                return `CAST(${expr} AT TIME ZONE ${this.sqlTimezoneLiteral(tz)} AS DATE)`;
             }
             // DATE → TIMESTAMP: interpret date in query timezone, return UTC wall clock
             // Presto doesn't have a way to interpret TIMESTAMP in a non-UTC timezone,
             // so we build a TIMESTAMPTZ literal string and cast it
             if (malloy_types_1.TD.isDate(srcTypeDef) && malloy_types_1.TD.isTimestamp(dstTypeDef)) {
-                const tstzLiteral = `CAST(CAST(${expr} AS VARCHAR) || ' 00:00:00 ${tz}' AS TIMESTAMP WITH TIME ZONE)`;
+                const tstzLiteral = `CAST(CAST(${expr} AS VARCHAR) || ' 00:00:00 ${this.checkedTimezoneName(tz)}' AS TIMESTAMP WITH TIME ZONE)`;
                 return `CAST(${tstzLiteral} AS TIMESTAMP)`;
             }
             // DATE → TIMESTAMPTZ: interpret date in query timezone
             if (malloy_types_1.TD.isDate(srcTypeDef) && malloy_types_1.TD.isTimestamptz(dstTypeDef)) {
-                return `CAST(CAST(${expr} AS VARCHAR) || ' 00:00:00 ${tz}' AS TIMESTAMP WITH TIME ZONE)`;
+                return `CAST(CAST(${expr} AS VARCHAR) || ' 00:00:00 ${this.checkedTimezoneName(tz)}' AS TIMESTAMP WITH TIME ZONE)`;
             }
             // TIMESTAMPTZ → TIMESTAMP: convert to query timezone wall clock
             if (malloy_types_1.TD.isTimestamptz(srcTypeDef) && malloy_types_1.TD.isTimestamp(dstTypeDef)) {
-                return `CAST(${expr} AT TIME ZONE '${tz}' AS TIMESTAMP)`;
+                return `CAST(${expr} AT TIME ZONE ${this.sqlTimezoneLiteral(tz)} AS TIMESTAMP)`;
             }
             // TIMESTAMP → TIMESTAMPTZ: interpret TIMESTAMP as UTC
             if (malloy_types_1.TD.isTimestamp(srcTypeDef) && malloy_types_1.TD.isTimestamptz(dstTypeDef)) {
@@ -701,11 +705,11 @@ class PrestoDialect extends TrinoDialect {
                 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}'`;
+                    extractFrom = `(${extractFrom} AT TIME ZONE 'UTC') AT TIME ZONE ${this.sqlTimezoneLiteral(tz)}`;
                 }
                 else {
                     // TIMESTAMPTZ: convert to query timezone
-                    extractFrom = `${extractFrom} AT TIME ZONE '${tz}'`;
+                    extractFrom = `${extractFrom} AT TIME ZONE ${this.sqlTimezoneLiteral(tz)}`;
                 }
             }
         }

package/dist/lang/ast/expressions/expr-aggregate-function.js

@@ -45,6 +45,7 @@ const static_space_1 = require("../field-space/static-space");
 const TDU = __importStar(require("../typedesc-utils"));
 const field_references_1 = require("../query-items/field-references");
 const expression_def_1 = require("../types/expression-def");
+const field_space_1 = require("../types/field-space");
 const space_field_1 = require("../types/space-field");
 const expr_id_reference_1 = require("./expr-id-reference");
 class ExprAggregateFunction extends expression_def_1.ExpressionDef {
@@ -224,37 +225,30 @@ function joinPathEq(a1, a2) {
 }
 function getJoinUsage(fs, expr) {
     const result = [];
+    /**
+     * Walk a path from translated IR. Every name in it is known to resolve at
+     * private level, so a failure is an internal error. The names are
+     * unparented; readEntry records no references for them.
+     */
     const lookupWithPath = (fs, path) => {
-        const head = path[0];
-        const rest = path.slice(1);
-        const def = fs.entry(head);
-        if (def === undefined) {
-            throw new Error(`Invalid field lookup ${head}`);
-        }
-        if (def instanceof static_space_1.StructSpaceField && rest.length > 0) {
-            const restDef = lookupWithPath(def.fieldSpace, rest);
-            return {
-                ...restDef,
-                joinPath: [{ ...def.joinPathElement, name: head }, ...restDef.joinPath],
-            };
+        const names = path.map(n => new field_space_1.FieldName(n));
+        const last = names[names.length - 1];
+        const ns = (0, static_space_1.resolveNamespace)(fs, names.slice(0, -1), 'private', last.name);
+        if (ns.error) {
+            throw new Error(ns.error.message);
         }
-        else if (def instanceof space_field_1.SpaceField) {
-            if (rest.length !== 0) {
-                throw new Error(`${head} cannot contain a ${rest.join('.')}`);
-            }
-            const fieldDef = def.fieldDef();
-            if (fieldDef) {
-                return {
-                    fs,
-                    def: fieldDef,
-                    joinPath: [],
-                };
-            }
-            throw new Error('No field def');
+        const read = (0, static_space_1.readEntry)(ns.space, last, 'private');
+        if (read.error) {
+            throw new Error(read.error.message);
         }
-        else {
+        if (!(read.found instanceof space_field_1.SpaceField)) {
             throw new Error('expected a field def or struct');
         }
+        const def = read.found.fieldDef();
+        if (def === undefined) {
+            throw new Error('No field def');
+        }
+        return { fs: ns.space, def, joinPath: ns.joinPath };
     };
     for (const frag of (0, utils_1.exprWalk)(expr)) {
         if (frag.node === 'field') {

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

@@ -23,6 +23,7 @@ class DefSpace extends passthrough_space_1.PassthroughSpace {
                 error: {
                     message: `Circular reference to '${this.circular.defineName}' in definition`,
                     code: 'circular-reference-in-field-definition',
+                    at: symbol[0],
                 },
                 found: undefined,
             };