@malloydata/malloy 0.0.432 → 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

@@ -22,38 +22,65 @@ const inSeconds = {
     day: 24 * 3600,
     week: 7 * 24 * 3600,
 };
+/**
+ * MySQL reports a column type as
+ *
+ *     base [ '(' params ')' ] [ 'unsigned' ] [ 'zerofill' ]
+ *
+ * and normalizes every alias away before reporting, so a schema read only
+ * ever produces canonical base names. A raw cast reaches this map without
+ * that normalization, and any alias it spells -- REAL, INTEGER, NUMERIC --
+ * falls through to `sql native`.
+ *
+ * No modifier changes the Malloy type: `unsigned` only widens the range, and
+ * the sole type whose range crosses a Malloy boundary is bigint, which is
+ * already `bigint`; `zerofill` is presentation. So the map is keyed on the
+ * base name alone. DECIMAL is not in the map because its Malloy type depends
+ * on its parameters.
+ */
 const mysqlToMalloyTypes = {
-    // TODO: This assumes tinyint is always going to be a boolean.
-    'tinyint': { type: 'boolean' },
+    'tinyint': { type: 'number', numberType: 'integer' },
     'smallint': { type: 'number', numberType: 'integer' },
     'mediumint': { type: 'number', numberType: 'integer' },
     'int': { type: 'number', numberType: 'integer' },
     'bigint': { type: 'number', numberType: 'bigint' },
-    'tinyint unsigned': { type: 'number', numberType: 'integer' },
-    'smallint unsigned': { type: 'number', numberType: 'integer' },
-    'mediumint unsigned': { type: 'number', numberType: 'integer' },
-    'int unsigned': { type: 'number', numberType: 'integer' },
-    'bigint unsigned': { type: 'number', numberType: 'bigint' },
+    'float': { type: 'number', numberType: 'float' },
     'double': { type: 'number', numberType: 'float' },
-    'varchar': { type: 'string' },
-    'varbinary': { type: 'string' },
     'char': { type: 'string' },
+    'varchar': { type: 'string' },
+    'tinytext': { type: 'string' },
     'text': { type: 'string' },
+    'mediumtext': { type: 'string' },
+    'longtext': { type: 'string' },
     'date': { type: 'date' },
     'datetime': { type: 'timestamp' },
     'timestamp': { type: 'timestamp' },
     'time': { type: 'string' },
-    'decimal': { type: 'number', numberType: 'float' },
-    // TODO: Check if we need special handling for boolean.
-    'tinyint(1)': { type: 'boolean' },
 };
+/**
+ * Split a reported type into its base name and numeric parameters.
+ *
+ * Only numeric parameter lists are read. ENUM and SET carry quoted value
+ * lists whose quoting rules a regex should not chase, and nothing needs
+ * their values -- both map to `sql native`.
+ */
+function parseMySQLType(sqlType) {
+    var _a, _b;
+    const text = sqlType.trim().toLowerCase();
+    const base = (_b = (_a = text.match(/^\w+/)) === null || _a === void 0 ? void 0 : _a[0]) !== null && _b !== void 0 ? _b : text;
+    const params = text.match(/^\w+\s*\((\d+(?:\s*,\s*\d+)*)\)/);
+    return {
+        base,
+        params: params ? params[1].split(',').map(p => parseInt(p, 10)) : [],
+    };
+}
 function malloyTypeToJSONTableType(malloyType) {
     switch (malloyType.type) {
         case 'number':
-            if (malloyType.numberType === 'integer') {
-                return 'INT';
-            }
-            else if (malloyType.numberType === 'bigint') {
+            // BIGINT for both: JSON_TABLE turns an out-of-range value into NULL
+            // without warning, and `integer` is not bounded at 32 bits.
+            if (malloyType.numberType === 'integer' ||
+                malloyType.numberType === 'bigint') {
                 return 'BIGINT';
             }
             else {
@@ -62,7 +89,8 @@ function malloyTypeToJSONTableType(malloyType) {
         case 'string':
             return 'CHAR(255)'; // JSON_TABLE needs a length
         case 'boolean':
-            return 'INT'; // or TINYINT(1) if you prefer
+            // MySQL has no boolean; TINYINT(1) is only a spelling of TINYINT.
+            return 'INT';
         case 'record':
         case 'array':
             return 'JSON';
@@ -141,11 +169,24 @@ class MySQLDialect extends dialect_1.Dialect {
     }
     sqlTypeToMalloyType(sqlType) {
         var _a, _b;
-        // Remove trailing params
-        const baseSqlType = (_b = (_a = sqlType.match(/^(\w+)/)) === null || _a === void 0 ? void 0 : _a.at(0)) !== null && _b !== void 0 ? _b : sqlType;
-        return (mysqlToMalloyTypes[baseSqlType.toLowerCase()] || {
+        const { base, params } = parseMySQLType(sqlType);
+        if (base === 'decimal') {
+            // DECIMAL is exact, so scale 0 is an integer rather than a float. Above
+            // 15 digits it no longer survives a JS double and must be carried as a
+            // bigint. MySQL reports precision and scale on every decimal; the
+            // defaults match its own when a bare DECIMAL is declared.
+            const [precision, scale] = [(_a = params[0]) !== null && _a !== void 0 ? _a : 10, (_b = params[1]) !== null && _b !== void 0 ? _b : 0];
+            if (scale > 0) {
+                return { type: 'number', numberType: 'float' };
+            }
+            return {
+                type: 'number',
+                numberType: precision <= 15 ? 'integer' : 'bigint',
+            };
+        }
+        return (mysqlToMalloyTypes[base] || {
             type: 'sql native',
-            rawType: baseSqlType,
+            rawType: base,
         });
     }
     sqlGroupSetTable(groupSetCount) {
@@ -220,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');
     }
@@ -313,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
@@ -372,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})`;
@@ -382,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) {
@@ -407,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}'`;
     }
@@ -459,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) {