@malloydata/malloy 0.0.433 → 0.0.434

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/source-elements/refined-source.js

@@ -81,7 +81,7 @@ class RefinedSource extends source_1.Source {
                 filters.push(el);
             }
             else if (el instanceof timezone_statement_1.TimezoneStatement) {
-                newTimezone = el.tz;
+                newTimezone = el.timezoneName();
             }
             else {
                 errTo.logError('unexpected-source-property', `Unexpected source property: '${errTo.elementType}'`);

package/dist/lang/ast/source-elements/sql-source.js

@@ -19,12 +19,13 @@ class SQLSource extends source_1.Source {
         this.connectionNameInvalid = false;
     }
     sqlSourceRequest(doc) {
+        var _a;
         const partialModel = this.select.containsQueries
             ? doc.modelDef()
             : undefined;
         const [valid, phrases] = this.select.sqlPhrases(this.connectionName.refString);
         if (valid) {
-            return (0, sql_block_1.getSourceRequest)(phrases, this.connectionName.refString, partialModel);
+            return (0, sql_block_1.getSourceRequest)(phrases, this.connectionName.refString, partialModel, (_a = this.translator()) === null || _a === void 0 ? void 0 : _a.root.virtualMap);
         }
         return undefined;
     }

package/dist/lang/ast/source-properties/timezone-statement.d.ts

@@ -1,12 +1,13 @@
+import type { ExprString } from '../expressions/expr-string';
 import type { QueryBuilder } from '../types/query-builder';
 import { MalloyElement } from '../types/malloy-element';
 import type { QueryPropertyInterface } from '../types/query-property-interface';
 export declare class TimezoneStatement extends MalloyElement implements QueryPropertyInterface {
-    readonly tz: string;
+    private readonly timezone;
     elementType: string;
     forceQueryClass: undefined;
     queryRefinementStage: undefined;
-    constructor(tz: string);
-    get isValid(): boolean;
+    constructor(timezone: ExprString);
+    timezoneName(): string | undefined;
     queryExecute(executeFor: QueryBuilder): void;
 }

package/dist/lang/ast/source-properties/timezone-statement.js

@@ -5,27 +5,29 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TimezoneStatement = void 0;
+const dialect_1 = require("../../../dialect/dialect");
 const malloy_element_1 = require("../types/malloy-element");
-const luxon_1 = require("luxon");
 class TimezoneStatement extends malloy_element_1.MalloyElement {
-    constructor(tz) {
-        super();
-        this.tz = tz;
+    constructor(timezone) {
+        super({ timezone });
+        this.timezone = timezone;
         this.elementType = 'timezone';
         this.forceQueryClass = undefined;
         this.queryRefinementStage = undefined;
     }
-    get isValid() {
-        try {
-            luxon_1.DateTime.fromISO('2020-02-19T00:00:00', { zone: this.tz });
-            return true;
-        }
-        catch {
-            return false;
+    timezoneName() {
+        const name = this.timezone.value;
+        if (!dialect_1.Dialect.isSafeTimezoneName(name)) {
+            this.logError('invalid-timezone', { timezone: name }, { at: this.timezone.location });
+            return undefined;
         }
+        return name;
     }
     queryExecute(executeFor) {
-        executeFor.resultFS.setTimezone(this.tz);
+        const timezone = this.timezoneName();
+        if (timezone !== undefined) {
+            executeFor.resultFS.setTimezone(timezone);
+        }
     }
 }
 exports.TimezoneStatement = TimezoneStatement;

package/dist/lang/composite-source-utils.js

@@ -407,9 +407,11 @@ function expandRefUsage(seed, fields, alwaysJoinNames = []) {
     // given usage into the accumulator. Used both in-loop (joins reached
     // via reference paths) and upfront (always-on segment-level joins).
     function activateJoin(joinDef, joinPath) {
+        if (!(0, malloy_types_1.isJoined)(joinDef))
+            return;
         const joinKey = (0, utils_2.pathToKey)('join', joinPath);
         const thisDep = getJoin(activeJoinGraph, joinKey, joinPath);
-        if (!(0, malloy_types_1.isJoined)(joinDef) || thisDep.checked)
+        if (thisDep.checked)
             return;
         thisDep.checked = true;
         const joinFieldUsage = getJoinFieldUsage(joinDef, joinPath);
@@ -462,8 +464,13 @@ function expandRefUsage(seed, fields, alwaysJoinNames = []) {
                 ungroupings.push(...joinedUngroupings(refPath, def.ungroupings));
             }
         }
-        // For paths through joins, additionaly track join relationships
-        for (let joinLen = 1; joinLen < reference.path.length; joinLen++) {
+        // Track the joins along the path.  A path which ends at a join and carries
+        // a unique key requirement is an aggregate computed over that join's rows,
+        // which should then include the join's on-clause fields in the field usage.
+        // A path which merely names a join-typed value does not.
+        const endsInTraversedJoin = reference.uniqueKeyRequirement !== undefined;
+        const joinDepth = reference.path.length - (endsInTraversedJoin ? 0 : 1);
+        for (let joinLen = 1; joinLen <= joinDepth; joinLen++) {
             const joinPath = reference.path.slice(0, joinLen);
             const joinDef = inNamespace(joinPath, fieldNameSpace);
             if (!joinDef)

package/dist/lang/malloy-to-ast.js

@@ -803,14 +803,8 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
         return this.visitTimezoneStatement(cx.timezoneStatement());
     }
     visitTimezoneStatement(cx) {
-        const timezone = this.getPlainStringFrom(cx);
-        const timezoneStatement = this.astAt(new ast.TimezoneStatement(timezone), cx.string());
-        if (!timezoneStatement.isValid) {
-            this.astError(timezoneStatement, 'invalid-timezone', {
-                timezone: timezoneStatement.tz,
-            });
-        }
-        return this.astAt(timezoneStatement, cx);
+        const timezone = this.astAt(new ast.ExprString(this.getPlainStringFrom(cx)), cx.string());
+        return this.astAt(new ast.TimezoneStatement(timezone), cx);
     }
     visitQueryProperties(pcx) {
         const qProps = this.only(pcx.queryStatement().map(qcx => this.astAt(this.visit(qcx), qcx)), x => ast.isQueryProperty(x) && x, 'query statement');

package/dist/lang/parse-malloy.d.ts

@@ -1,4 +1,4 @@
-import type { DocumentLocation, DocumentPosition, DocumentReference, ImportLocation, ModelDef, SourceDef, SQLSourceDef, DependencyTree, DocumentRange } from '../model/malloy_types';
+import type { DocumentLocation, DocumentPosition, DocumentReference, ImportLocation, ModelDef, SourceDef, SQLSourceDef, DependencyTree, DocumentRange, VirtualMap } from '../model/malloy_types';
 import type { LogMessage, LogMessageOptions, MessageCode, MessageParameterType } from './parse-log';
 import { BaseMessageLogger } from './parse-log';
 import type { ZoneData } from './zone';
@@ -186,6 +186,7 @@ export declare class MalloyChildTranslator extends MalloyTranslation {
 export declare class MalloyTranslator extends MalloyTranslation {
     private readonly eventStream;
     readonly restrictedMode: boolean;
+    virtualMap?: VirtualMap | undefined;
     schemaZone: Zone<SourceDef>;
     importZone: Zone<string>;
     pretranslatedModels: Map<string, ModelDef>;
@@ -193,7 +194,7 @@ export declare class MalloyTranslator extends MalloyTranslation {
     connectionDialectZone: Zone<string>;
     logger: BaseMessageLogger;
     readonly root: MalloyTranslator;
-    constructor(rootURL: string, importURL?: string | null, preload?: ParseUpdate | null, eventStream?: EventStream | null, restrictedMode?: boolean);
+    constructor(rootURL: string, importURL?: string | null, preload?: ParseUpdate | null, eventStream?: EventStream | null, restrictedMode?: boolean, virtualMap?: VirtualMap | undefined);
     update(dd: ParseUpdate): void;
     private lockZonesIfRestricted;
     translate(extendingModel?: ModelDef): TranslateResponse;

package/dist/lang/parse-malloy.js

@@ -780,10 +780,11 @@ exports.MalloyChildTranslator = MalloyChildTranslator;
  * no need to call again, the translation is finished or error'd.
  */
 class MalloyTranslator extends MalloyTranslation {
-    constructor(rootURL, importURL = null, preload = null, eventStream = null, restrictedMode = false) {
+    constructor(rootURL, importURL = null, preload = null, eventStream = null, restrictedMode = false, virtualMap) {
         super(rootURL, importURL);
         this.eventStream = eventStream;
         this.restrictedMode = restrictedMode;
+        this.virtualMap = virtualMap;
         this.schemaZone = new zone_1.Zone();
         this.importZone = new zone_1.Zone();
         this.pretranslatedModels = new Map();

package/dist/lang/test/test-translator.d.ts

@@ -1,4 +1,4 @@
-import type { DocumentLocation, FieldDef, ModelDef, NamedModelObject, PipeSegment, Query, QueryFieldDef, StructDef, TurtleDef, SourceDef, TableSourceDef, SQLSourceDef, UserTypeDef } from '../../model/malloy_types';
+import type { DocumentLocation, FieldDef, ModelDef, NamedModelObject, PipeSegment, Query, QueryFieldDef, StructDef, TurtleDef, SourceDef, TableSourceDef, SQLSourceDef, UserTypeDef, VirtualMap } from '../../model/malloy_types';
 import { MalloyElement } from '../ast';
 import type { NameSpace } from '../ast/types/name-space';
 import type { ModelEntry } from '../ast/types/model-entry';
@@ -56,6 +56,7 @@ export interface TestTranslatorOptions {
     eventStream?: EventStream | null;
     internalModel?: ModelDef;
     restrictedMode?: boolean;
+    virtualMap?: VirtualMap;
     /**
      * Each entry is a compiler-flag tag fragment — the content that
      * would follow `##! ` in a Malloy source annotation. Rendered to

package/dist/lang/test/test-translator.js

@@ -339,7 +339,7 @@ const testURI = 'internal://test/langtests/root.malloy';
 class TestTranslator extends parse_malloy_1.MalloyTranslator {
     constructor(testSrc, options = {}) {
         var _a, _b, _c, _d, _e;
-        super(testURI, (_a = options.importBaseURL) !== null && _a !== void 0 ? _a : null, null, (_b = options.eventStream) !== null && _b !== void 0 ? _b : null, (_c = options.restrictedMode) !== null && _c !== void 0 ? _c : false);
+        super(testURI, (_a = options.importBaseURL) !== null && _a !== void 0 ? _a : null, null, (_b = options.eventStream) !== null && _b !== void 0 ? _b : null, (_c = options.restrictedMode) !== null && _c !== void 0 ? _c : false, options.virtualMap);
         this.testSrc = testSrc;
         this.allDialectsEnabled = true;
         /*

package/dist/model/join_instance.d.ts

@@ -12,6 +12,7 @@ export declare class JoinInstance {
     joinFilterConditions?: QueryFieldBoolean[];
     children: JoinInstance[];
     constructor(queryStruct: QueryStruct, alias: string, parent: JoinInstance | undefined);
+    isSubquery(): boolean;
     parentRelationship(): 'root' | JoinRelationship;
     forceAllSymmetricCalculations(): boolean;
     getDialectFieldList(): DialectFieldList;