@malloydata/malloy 0.0.433 → 0.0.434

package/dist/api/foundation/compile.d.ts

@@ -2,7 +2,7 @@ import type { LogMessage } from '../../lang';
 import type { Connection, InfoConnection, LookupConnection, FetchSchemaOptions } from '../../connection/types';
 import type { ConnectionTypeDef, ConnectionPropertyDefinition } from '../../connection/registry';
 import type { URLReader, EventStream } from '../../runtime_types';
-import type { SQLSourceDef, QueryRunStats } from '../../model';
+import type { SQLSourceDef, QueryRunStats, VirtualMap } from '../../model';
 import type { RunSQLOptions } from '../../run_sql_options';
 import type { CacheManager } from './cache';
 import { Parse } from './document';
@@ -36,6 +36,7 @@ export interface MalloyCompileOptions {
     eventStream?: EventStream;
     importBaseURL?: URL;
     testEnvironment?: boolean;
+    virtualMap?: VirtualMap;
 }
 export interface MalloyRunOptions {
     connection?: Connection;

package/dist/api/foundation/compile.js

@@ -119,9 +119,10 @@ class Malloy {
      * @return A (promise of a) compiled `Model`.
      */
     static async compile(req) {
-        var _a, _b, _c, _d, _e;
+        var _a, _b, _c, _d, _e, _f;
         let { url, source, importBaseURL, cacheManager } = req;
         const { parse, urlReader, connections, model, refreshSchemaCache, noThrowOnError, eventStream, restrictedMode, method, } = req;
+        const virtualMap = (_a = req.virtualMap) !== null && _a !== void 0 ? _a : parse === null || parse === void 0 ? void 0 : parse._translator.virtualMap;
         if (restrictedMode) {
             // Restricted-mode compiles do not participate in the model-def
             // cache. The cache key is the URL, but restricted vs. unrestricted
@@ -172,7 +173,8 @@ class Malloy {
                 throw new Error(`Malloy.compile: restrictedMode (${restrictedMode}) does not match the pre-parsed translator's restrictedMode (${parse._translator.restrictedMode}). Set restrictedMode at parse time.`);
             }
             translator = parse._translator;
-            const invalidationKey = (_a = parse._invalidationKey) !== null && _a !== void 0 ? _a : (await (0, readers_1.getInvalidationKey)(urlReader, url));
+            translator.virtualMap = virtualMap;
+            const invalidationKey = (_b = parse._invalidationKey) !== null && _b !== void 0 ? _b : (await (0, readers_1.getInvalidationKey)(urlReader, url));
             invalidationKeys[_url] = invalidationKey;
         }
         else {
@@ -187,7 +189,7 @@ class Malloy {
             }
             translator = new lang_1.MalloyTranslator(_url, importBaseURL.toString(), {
                 urls: { [_url]: source },
-            }, eventStream, restrictedMode !== null && restrictedMode !== void 0 ? restrictedMode : false);
+            }, eventStream, restrictedMode !== null && restrictedMode !== void 0 ? restrictedMode : false, virtualMap);
         }
         for (;;) {
             const result = translator.translate(model === null || model === void 0 ? void 0 : model._modelDef);
@@ -208,14 +210,14 @@ class Malloy {
                     const existingQueryModel = !result.modelWasModified && model
                         ? model.getExistingQueryModel()
                         : undefined;
-                    return new core_1.Model(result.modelDef, result.problems || [], [...((_b = model === null || model === void 0 ? void 0 : model.fromSources) !== null && _b !== void 0 ? _b : []), ...((_c = result.fromSources) !== null && _c !== void 0 ? _c : [])], existingQueryModel);
+                    return new core_1.Model(result.modelDef, result.problems || [], [...((_c = model === null || model === void 0 ? void 0 : model.fromSources) !== null && _c !== void 0 ? _c : []), ...((_d = result.fromSources) !== null && _d !== void 0 ? _d : [])], existingQueryModel);
                 }
                 else if (noThrowOnError) {
                     const emptyModel = (0, model_1.mkModelDef)('modelDidNotCompile');
                     const modelFromCompile = (model === null || model === void 0 ? void 0 : model._modelDef) || emptyModel;
                     return new core_1.Model(modelFromCompile, result.problems || [], [
-                        ...((_d = model === null || model === void 0 ? void 0 : model.fromSources) !== null && _d !== void 0 ? _d : []),
-                        ...((_e = result.fromSources) !== null && _e !== void 0 ? _e : []),
+                        ...((_e = model === null || model === void 0 ? void 0 : model.fromSources) !== null && _e !== void 0 ? _e : []),
+                        ...((_f = result.fromSources) !== null && _f !== void 0 ? _f : []),
                     ]);
                 }
                 else {

package/dist/api/foundation/config.js

@@ -169,7 +169,7 @@ class MalloyConfig {
         this._managedLookup = (0, config_lookup_1.buildManagedLookup)(prepared.compiledConnections, rawConnectionEntries(pojo), mergedOverlays, log);
         this._connections = this._managedLookup;
         this._overlays = mergedOverlays;
-        this.virtualMap = toVirtualMap(prepared.virtualMap, log);
+        this.virtualMap = toVirtualMap(prepared.virtualMap);
         this.configURL = configURL;
         this.rootDirectory = rootDirectory;
         this.manifestPath = prepared.manifestPath;
@@ -444,10 +444,10 @@ function validateURLString(value, fieldName, log) {
 }
 /**
  * Convert the raw virtualMap POJO shape (a dict of dicts of strings) into
- * the runtime Map-of-Maps representation. Invalid entries are dropped and
- * logged — they'd be pasted into FROM clauses downstream otherwise.
+ * the runtime Map-of-Maps representation. Table paths are checked against
+ * the executing dialect when a virtual source is substituted into SQL.
  */
-function toVirtualMap(raw, log) {
+function toVirtualMap(raw) {
     if (!isRecord(raw))
         return undefined;
     const outer = new Map();
@@ -456,18 +456,9 @@ function toVirtualMap(raw, log) {
             continue;
         const innerMap = new Map();
         for (const [virtualName, tablePath] of Object.entries(inner)) {
-            if (typeof tablePath !== 'string')
-                continue;
-            const invalid = (0, validate_table_path_1.validateCanonicalTablePathAnyDialect)(tablePath);
-            if (invalid !== undefined) {
-                log.push({
-                    message: `virtualMap entry '${connName}.${virtualName}': ${invalid}`,
-                    severity: 'error',
-                    code: 'config-validation',
-                });
-                continue;
+            if (typeof tablePath === 'string') {
+                innerMap.set(virtualName, tablePath);
             }
-            innerMap.set(virtualName, tablePath);
         }
         if (innerMap.size > 0)
             outer.set(connName, innerMap);

package/dist/api/foundation/runtime.d.ts

@@ -172,13 +172,8 @@ export declare class Runtime {
     /** @internal */
     _invalidateGivensCache(): void;
     /**
-     * The virtual map for virtual source resolution.
-     * When set, compiled queries automatically resolve virtual sources
-     * against this map. Can be overridden per-query via
-     * CompileQueryOptions.virtualMap.
-     *
-     * When constructed with a MalloyConfig, falls through to
-     * config.virtualMap.
+     * Default virtual-source bindings for translation and query SQL generation.
+     * Falls back to config.virtualMap when no runtime map is assigned.
      */
     get virtualMap(): VirtualMap | undefined;
     set virtualMap(map: VirtualMap | undefined);

package/dist/api/foundation/runtime.js

@@ -302,13 +302,8 @@ class Runtime {
         this._resolvedGivensPromise = undefined;
     }
     /**
-     * The virtual map for virtual source resolution.
-     * When set, compiled queries automatically resolve virtual sources
-     * against this map. Can be overridden per-query via
-     * CompileQueryOptions.virtualMap.
-     *
-     * When constructed with a MalloyConfig, falls through to
-     * config.virtualMap.
+     * Default virtual-source bindings for translation and query SQL generation.
+     * Falls back to config.virtualMap when no runtime map is assigned.
      */
     get virtualMap() {
         var _a, _b;
@@ -365,6 +360,7 @@ class Runtime {
         }
         const compilable = source instanceof URL ? { url: source } : { source };
         return new ModelMaterializer(this, async () => {
+            var _a;
             const m = await compile_1.Malloy.compile({
                 ...compilable,
                 urlReader: this.urlReader,
@@ -375,6 +371,7 @@ class Runtime {
                 importBaseURL: options === null || options === void 0 ? void 0 : options.importBaseURL,
                 testEnvironment: options === null || options === void 0 ? void 0 : options.testEnvironment,
                 cacheManager: this.cacheManager,
+                virtualMap: (_a = options === null || options === void 0 ? void 0 : options.virtualMap) !== null && _a !== void 0 ? _a : this.virtualMap,
             });
             return this._withRuntimeContext(m);
         }, options);
@@ -640,6 +637,7 @@ class ModelMaterializer extends FluentState {
             ...callQueryOptions,
         };
         return this.makeQueryMaterializer(async () => {
+            var _a;
             const compilable = query instanceof URL ? { url: query } : { source: query };
             const queryModel = await compile_1.Malloy.compile({
                 ...compilable,
@@ -651,6 +649,7 @@ class ModelMaterializer extends FluentState {
                 importBaseURL,
                 testEnvironment: testEnvironment || this.runtime.isTestRuntime,
                 ...compileQueryOptions,
+                virtualMap: (_a = compileQueryOptions.virtualMap) !== null && _a !== void 0 ? _a : this.runtime.virtualMap,
             });
             return queryModel.preparedQuery;
         }, compileQueryOptions);
@@ -725,6 +724,8 @@ class ModelMaterializer extends FluentState {
      * or loading further related objects.
      */
     extendModel(query, options) {
+        var _a, _b;
+        const virtualMap = (_a = options === null || options === void 0 ? void 0 : options.virtualMap) !== null && _a !== void 0 ? _a : (_b = this.compileQueryOptions) === null || _b === void 0 ? void 0 : _b.virtualMap;
         if (this.runtime.isTestRuntime) {
             if (options === undefined) {
                 options = { testEnvironment: true };
@@ -749,9 +750,10 @@ class ModelMaterializer extends FluentState {
                 importBaseURL: options === null || options === void 0 ? void 0 : options.importBaseURL,
                 testEnvironment: options === null || options === void 0 ? void 0 : options.testEnvironment,
                 ...this.compileQueryOptions,
+                virtualMap: virtualMap !== null && virtualMap !== void 0 ? virtualMap : this.runtime.virtualMap,
             });
             return this.runtime._withRuntimeContext(queryModel);
-        }, options);
+        }, { ...options, virtualMap });
     }
     async search(sourceName, searchTerm, limit = 1000, searchField = undefined) {
         const model = await this.materialize();
@@ -1064,15 +1066,7 @@ class QueryMaterializer extends FluentState {
                     connectionDigests[connName] = conn.getDigest();
                 }
             }
-            // Use virtualMap from options if provided, otherwise fall back to Runtime's.
             const virtualMap = (_b = mergedOptions.virtualMap) !== null && _b !== void 0 ? _b : this.runtime.virtualMap;
-            if (virtualMap) {
-                for (const [connName, inner] of virtualMap) {
-                    for (const [virtualName, tablePath] of inner) {
-                        (0, validate_table_path_1.requireCanonicalTablePathAnyDialect)(tablePath, `virtualMap entry '${connName}.${virtualName}'`);
-                    }
-                }
-            }
             // Per-query supply for a finalized given is rejected at API entry
             // — the finalized-givens set is the runtime's "this can't be
             // overridden by the caller" guarantee. Fail before any IO so misuse

package/dist/api/foundation/types.d.ts

@@ -43,6 +43,7 @@ export type CompileMethod = 'loadModel' | 'extendModel' | 'query';
 export interface CompileOptions {
     refreshSchemaCache?: boolean | number;
     noThrowOnError?: boolean;
+    virtualMap?: VirtualMap;
 }
 /** Options given to the Malloy compiler (QueryModel) */
 export interface CompileQueryOptions {

package/dist/connection/validate_table_path.d.ts

@@ -2,8 +2,7 @@
 export declare function validateCanonicalTablePath(dialectName: string, tablePath: string): string | undefined;
 /**
  * Validate against any registered dialect. Used at boundaries where the
- * destination dialect isn't synchronously known (virtualMap, manifest
- * entries).
+ * destination dialect isn't synchronously known (manifest entries).
  */
 export declare function validateCanonicalTablePathAnyDialect(tablePath: string): string | undefined;
 /** Throw if `tablePath` isn't canonical SQL in any registered dialect. */

package/dist/connection/validate_table_path.js

@@ -28,8 +28,7 @@ function validateCanonicalTablePath(dialectName, tablePath) {
 }
 /**
  * Validate against any registered dialect. Used at boundaries where the
- * destination dialect isn't synchronously known (virtualMap, manifest
- * entries).
+ * destination dialect isn't synchronously known (manifest entries).
  */
 function validateCanonicalTablePathAnyDialect(tablePath) {
     let suggestion;

package/dist/dialect/databricks/databricks.js

@@ -304,13 +304,13 @@ class DatabricksDialect extends dialect_1.Dialect {
         // Databricks has no timestamptz type; timestamps are stored as UTC
         // Convert from UTC to local timezone for civil time operations
         return {
-            sql: `FROM_UTC_TIMESTAMP(${expr}, '${timezone}')`,
+            sql: `FROM_UTC_TIMESTAMP(${expr}, ${this.sqlTimezoneLiteral(timezone)})`,
             typeDef: { type: 'timestamp' },
         };
     }
     sqlConvertFromCivilTime(expr, timezone, _destTypeDef) {
         // Convert from local timezone back to UTC
-        return `TO_UTC_TIMESTAMP(${expr}, '${timezone}')`;
+        return `TO_UTC_TIMESTAMP(${expr}, ${this.sqlTimezoneLiteral(timezone)})`;
     }
     sqlTruncate(expr, unit, _typeDef, _inCivilTime, _timezone) {
         // Databricks DATE_TRUNC starts weeks on Monday; Malloy wants Sunday.
@@ -342,7 +342,7 @@ class DatabricksDialect extends dialect_1.Dialect {
         if (malloy_types_1.TD.isTimestamp(te.e.typeDef)) {
             const tz = (0, dialect_1.qtz)(qi);
             if (tz) {
-                extractFrom = `FROM_UTC_TIMESTAMP(${extractFrom}, '${tz}')`;
+                extractFrom = `FROM_UTC_TIMESTAMP(${extractFrom}, ${this.sqlTimezoneLiteral(tz)})`;
             }
         }
         if (extractionMap[te.units]) {
@@ -356,10 +356,10 @@ class DatabricksDialect extends dialect_1.Dialect {
         const { op, srcTypeDef, dstTypeDef, dstSQLType } = this.sqlCastPrep(cast);
         const tz = (0, dialect_1.qtz)(qi);
         if (op === 'timestamp::date' && tz) {
-            return `CAST(FROM_UTC_TIMESTAMP(${srcSQL}, '${tz}') AS DATE)`;
+            return `CAST(FROM_UTC_TIMESTAMP(${srcSQL}, ${this.sqlTimezoneLiteral(tz)}) AS DATE)`;
         }
         else if (op === 'date::timestamp' && tz) {
-            return `TO_UTC_TIMESTAMP(CAST(${srcSQL} AS TIMESTAMP_NTZ), '${tz}')`;
+            return `TO_UTC_TIMESTAMP(CAST(${srcSQL} AS TIMESTAMP_NTZ), ${this.sqlTimezoneLiteral(tz)})`;
         }
         if (!malloy_types_1.TD.eq(srcTypeDef, dstTypeDef)) {
             if (cast.safe) {
@@ -381,7 +381,7 @@ class DatabricksDialect extends dialect_1.Dialect {
     sqlTimestampLiteral(qi, literal, timezone) {
         const tz = timezone || (0, dialect_1.qtz)(qi);
         if (tz) {
-            return `TO_UTC_TIMESTAMP(TIMESTAMP_NTZ '${literal}', '${tz}')`;
+            return `TO_UTC_TIMESTAMP(TIMESTAMP_NTZ '${literal}', ${this.sqlTimezoneLiteral(tz)})`;
         }
         return `TIMESTAMP '${literal}'`;
     }

package/dist/dialect/dialect.d.ts

@@ -1,11 +1,20 @@
 import type { Expr, Sampling, AtomicTypeDef, MeasureTimeExpr, TimeExtractExpr, TypecastExpr, RegexMatchExpr, TimeLiteralExpr, RecordLiteralNode, ArrayLiteralNode, BasicAtomicTypeDef, OrderBy, TimestampUnit, ATimestampTypeDef, TimeExpr, TemporalFieldType } from '../model/malloy_types';
 import type { DialectFunctionOverloadDef } from './functions';
 import type { ValidateTablePathResult } from './table-path';
+/**
+ * One field of a struct, for the dialect methods which emit SQL over it.
+ *
+ * `typeDef` is the Malloy type, for the dialects which have to declare a SQL
+ * type for the field -- the ROW and STRUCT types they build.  `sqlExpression`
+ * is SQL producing the value, valid in the scope the consumer emits into.
+ * `rawName` is the field's name with no quoting: a consumer needing it as an
+ * identifier quotes it itself, because only the consumer knows whether it
+ * wants an identifier or a string literal holding the name.
+ */
 interface DialectField {
     typeDef: AtomicTypeDef;
     sqlExpression: string;
     rawName: string;
-    sqlOutputName: string;
 }
 export type DialectFieldList = DialectField[];
 /**
@@ -188,6 +197,7 @@ export declare abstract class Dialect {
     abstract sqlAnyValue(groupSet: number, fieldName: string): string;
     abstract sqlAggregateTurtle(groupSet: number | undefined, fieldList: DialectFieldList, orderBy: CompiledOrderBy[] | undefined, limit?: number, filterSQL?: string): string;
     sqlTurtleOrderByClause(orderBy: CompiledOrderBy[]): string;
+    sqlCombineLastStageOrderBy(orderBy: OrderBy[] | undefined, fieldList: DialectFieldList): string;
     abstract sqlAnyValueTurtle(groupSet: number, fieldList: DialectFieldList): string;
     abstract sqlAnyValueLastTurtle(name: string, groupSet: number, sqlName: string): string;
     abstract sqlCoaleseMeasuresInline(groupSet: number, fieldList: DialectFieldList): string;
@@ -457,6 +467,16 @@ export declare abstract class Dialect {
      *   the civil time in the specified timezone
      */
     abstract sqlTimestamptzLiteral(qi: QueryInfo, literal: string, timezone: string): string;
+    /**
+     * Reject characters that can break SQL literals or
+     * be changed by SQL formatting. Timezone-name validity belongs to the
+     * database, whose formats may include offsets and POSIX TZ strings.
+     * Static so the translator can apply the same rule before dialect resolution.
+     */
+    static isSafeTimezoneName(timezone: string): boolean;
+    /** Return an unquoted timezone for inclusion in a larger SQL literal. */
+    protected checkedTimezoneName(timezone: string): string;
+    sqlTimezoneLiteral(timezone: string): string;
     /**
      * Render a Malloy string as a SQL string literal. The escape style is
      * driven by `stringLiteralStyle`; dialects normally do not override
@@ -490,7 +510,6 @@ export declare abstract class Dialect {
      * NULLs last, but should go away once MySQL fully implements NULLs last.
      */
     sqlOrderBy(orderTerms: string[], _orderFor?: OrderByRequest): string;
-    sqlTzStr(qi: QueryInfo): string;
     sqlMakeUnnestKey(key: string, rowKey: string): string;
     sqlStringAggDistinct(distinctKey: string, valueSQL: string, separatorSQL: string): string;
     abstract sqlTypeToMalloyType(sqlType: string): BasicAtomicTypeDef;

package/dist/dialect/dialect.js

@@ -323,6 +323,20 @@ class Dialect {
         const terms = orderBy.map(o => ` ${o.field} ${o.dir.toUpperCase()}`);
         return ' ' + this.sqlOrderBy(terms, 'turtle');
     }
+    // Format the ordering of the last stage of a nest's pipeline into an ORDER BY
+    // clause for the aggregate which packs that stage's rows into an array. An
+    // ordinal names an output field by number, counting from one; the field list
+    // is a zero-based array.
+    sqlCombineLastStageOrderBy(orderBy, fieldList) {
+        if (orderBy === undefined || orderBy.length === 0) {
+            return '';
+        }
+        const terms = orderBy.map(o => {
+            const name = typeof o.field === 'string' ? o.field : fieldList[o.field - 1].rawName;
+            return `${this.sqlQuoteIdentifier(name)} ${o.dir || 'asc'}`;
+        });
+        return ` ORDER BY ${terms.join(', ')}`;
+    }
     sqlFinalStage(_lastStageName, _fields) {
         throw new Error('Dialect has no final Stage but called Anyway');
     }
@@ -482,6 +496,25 @@ class Dialect {
         }
         return sql;
     }
+    /**
+     * Reject characters that can break SQL literals or
+     * be changed by SQL formatting. Timezone-name validity belongs to the
+     * database, whose formats may include offsets and POSIX TZ strings.
+     * Static so the translator can apply the same rule before dialect resolution.
+     */
+    static isSafeTimezoneName(timezone) {
+        return !/['"`\\\r\n]/.test(timezone);
+    }
+    /** Return an unquoted timezone for inclusion in a larger SQL literal. */
+    checkedTimezoneName(timezone) {
+        if (!Dialect.isSafeTimezoneName(timezone)) {
+            throw new Error(`Invalid timezone ${JSON.stringify(timezone)}: quotes, backslashes, and line breaks are not allowed`);
+        }
+        return timezone;
+    }
+    sqlTimezoneLiteral(timezone) {
+        return `'${this.checkedTimezoneName(timezone)}'`;
+    }
     /**
      * Render a Malloy string as a SQL string literal. The escape style is
      * driven by `stringLiteralStyle`; dialects normally do not override
@@ -604,9 +637,6 @@ class Dialect {
     sqlOrderBy(orderTerms, _orderFor) {
         return `ORDER BY ${orderTerms.join(',')}`;
     }
-    sqlTzStr(qi) {
-        return `"${qi.queryTimezone}"`;
-    }
     sqlMakeUnnestKey(key, rowKey) {
         return this.concat(key, "'x'", rowKey);
     }

package/dist/dialect/duckdb/duckdb.js

@@ -94,7 +94,7 @@ class DuckDBDialect extends pg_impl_1.PostgresBase {
     }
     sqlAggregateTurtle(groupSet, fieldList, orderBy, limit, filterSQL) {
         const fields = fieldList
-            .map(f => `\n  ${f.sqlOutputName}: ${f.sqlExpression}`)
+            .map(f => `\n  ${this.sqlQuoteIdentifier(f.rawName)}: ${f.sqlExpression}`)
             .join(', ');
         const orderByClause = orderBy ? this.sqlTurtleOrderByClause(orderBy) : '';
         const cond = (0, dialect_1.turtleGroupSetCondition)(groupSet, filterSQL);
@@ -107,7 +107,7 @@ class DuckDBDialect extends pg_impl_1.PostgresBase {
     }
     sqlAnyValueTurtle(groupSet, fieldList) {
         const fields = fieldList
-            .map(f => `${f.sqlOutputName}:=${f.sqlExpression}`)
+            .map(f => `${this.sqlQuoteIdentifier(f.rawName)}:=${f.sqlExpression}`)
             .join(', ');
         return `ANY_VALUE(CASE WHEN group_set=${groupSet} THEN STRUCT_PACK(${fields}) END)`;
     }
@@ -116,10 +116,10 @@ class DuckDBDialect extends pg_impl_1.PostgresBase {
     }
     sqlCoaleseMeasuresInline(groupSet, fieldList) {
         const fields = fieldList
-            .map(f => `${f.sqlOutputName}: ${f.sqlExpression} `)
+            .map(f => `${this.sqlQuoteIdentifier(f.rawName)}: ${f.sqlExpression} `)
             .join(', ');
         const nullValues = fieldList
-            .map(f => `${f.sqlOutputName}: NULL`)
+            .map(f => `${this.sqlQuoteIdentifier(f.rawName)}: NULL`)
             .join(', ');
         return `COALESCE(FIRST({${fields}}) FILTER(WHERE group_set=${groupSet}), {${nullValues}})`;
     }
@@ -181,28 +181,14 @@ class DuckDBDialect extends pg_impl_1.PostgresBase {
         return `DROP MACRO IF EXISTS ${id}; \n${hackSplitComment}\n CREATE MACRO ${id}(_param) AS (\n${(0, utils_1.indent)(funcText)}\n);\n${hackSplitComment}\n`;
     }
     sqlCreateFunctionCombineLastStage(lastStageName, dialectFieldList, orderBy) {
-        let o = '';
-        if (orderBy) {
-            const clauses = [];
-            for (const c of orderBy) {
-                if (typeof c.field === 'string') {
-                    clauses.push(`${c.field} ${c.dir || 'asc'}`);
-                }
-                else {
-                    clauses.push(`${dialectFieldList[c.field].sqlOutputName} ${c.dir || 'asc'}`);
-                }
-            }
-            if (clauses.length > 0) {
-                o = ` ORDER BY ${clauses.join(', ')}`;
-            }
-        }
+        const o = this.sqlCombineLastStageOrderBy(orderBy, dialectFieldList);
         return `SELECT LIST(STRUCT_PACK(${dialectFieldList
-            .map(d => this.sqlQuoteIdentifier(d.sqlOutputName))
+            .map(d => this.sqlQuoteIdentifier(d.rawName))
             .join(',')})${o}) FROM ${lastStageName}\n`;
     }
     sqlSelectAliasAsStruct(alias, dialectFieldList) {
         return `STRUCT_PACK(${dialectFieldList
-            .map(d => `${alias}.${d.sqlOutputName}`)
+            .map(d => `${alias}.${this.sqlQuoteIdentifier(d.rawName)}`)
             .join(', ')})`;
     }
     // The simple way to do this is to add a comment on the table

package/dist/dialect/mysql/mysql.js

@@ -261,7 +261,7 @@ class MySQLDialect extends dialect_1.Dialect {
             // quote in the user-controlled field name cannot close the SQL
             // string literal.
             const jsonPathLit = this.sqlLiteralString('$.' + f.rawName);
-            fields.push(`${this.sqlQuoteIdentifier(f.sqlOutputName)} ${fType}  PATH ${jsonPathLit}`);
+            fields.push(`${this.sqlQuoteIdentifier(f.rawName)} ${fType}  PATH ${jsonPathLit}`);
         }
         return fields.join(',\n');
     }
@@ -354,12 +354,12 @@ class MySQLDialect extends dialect_1.Dialect {
     sqlConvertToCivilTime(expr, timezone, _typeDef) {
         // MySQL has no timestamptz type, so typeDef.timestamptz will never be true
         return {
-            sql: `CONVERT_TZ(${expr}, 'UTC', '${timezone}')`,
+            sql: `CONVERT_TZ(${expr}, 'UTC', ${this.sqlTimezoneLiteral(timezone)})`,
             typeDef: { type: 'timestamp' },
         };
     }
     sqlConvertFromCivilTime(expr, timezone, _destTypeDef) {
-        return `CONVERT_TZ(${expr}, '${timezone}', 'UTC')`;
+        return `CONVERT_TZ(${expr}, ${this.sqlTimezoneLiteral(timezone)}, 'UTC')`;
     }
     sqlTruncate(expr, unit, _typeDef, _inCivilTime, _timezone) {
         // For week truncation, adjust to Sunday first
@@ -413,7 +413,7 @@ class MySQLDialect extends dialect_1.Dialect {
         if (malloy_types_1.TD.isTimestamp(te.e.typeDef)) {
             const tz = (0, dialect_1.qtz)(qi);
             if (tz) {
-                extractFrom = `CONVERT_TZ(${extractFrom}, 'UTC', '${tz}')`;
+                extractFrom = `CONVERT_TZ(${extractFrom}, 'UTC', ${this.sqlTimezoneLiteral(tz)})`;
             }
         }
         return `${msUnits}(${extractFrom})`;
@@ -423,10 +423,10 @@ class MySQLDialect extends dialect_1.Dialect {
         const { op, srcTypeDef, dstTypeDef, dstSQLType } = this.sqlCastPrep(cast);
         const tz = (0, dialect_1.qtz)(qi);
         if (op === 'timestamp::date' && tz) {
-            return `CAST(CONVERT_TZ(${srcSQL}, 'UTC', '${tz}') AS DATE) `;
+            return `CAST(CONVERT_TZ(${srcSQL}, 'UTC', ${this.sqlTimezoneLiteral(tz)}) AS DATE) `;
         }
         else if (op === 'date::timestamp' && tz) {
-            return ` CONVERT_TZ(${srcSQL}, '${tz}', 'UTC')`;
+            return ` CONVERT_TZ(${srcSQL}, ${this.sqlTimezoneLiteral(tz)}, 'UTC')`;
         }
         if (!malloy_types_1.TD.eq(srcTypeDef, dstTypeDef)) {
             if (cast.safe) {
@@ -448,7 +448,7 @@ class MySQLDialect extends dialect_1.Dialect {
     sqlTimestampLiteral(qi, literal, timezone) {
         const tz = timezone || (0, dialect_1.qtz)(qi);
         if (tz) {
-            return `CONVERT_TZ('${literal}', '${tz}', 'UTC')`;
+            return `CONVERT_TZ('${literal}', ${this.sqlTimezoneLiteral(tz)}, 'UTC')`;
         }
         return `TIMESTAMP '${literal}'`;
     }
@@ -500,7 +500,7 @@ class MySQLDialect extends dialect_1.Dialect {
     }
     mapFieldsForJsonObject(fieldList, nullValues) {
         return fieldList
-            .map(f => `${f.sqlOutputName.replace(/`/g, "'")}, ${nullValues ? 'NULL' : f.sqlExpression}\n`)
+            .map(f => `${this.sqlLiteralString(f.rawName)}, ${nullValues ? 'NULL' : f.sqlExpression}\n`)
             .join(', ');
     }
     castToString(expression) {

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