@malloydata/malloy 0.0.433 → 0.0.435

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/index.d.ts

@@ -1,7 +1,7 @@
 export type { DialectFunctionOverloadDef, DefinitionBlueprint, DefinitionBlueprintMap, OverloadedDefinitionBlueprint, } from './functions/util';
 export { arg, anyExprType, makeParam, overload, minScalar, minAggregate, maxScalar, spread, param, variadicParam, literal, sql, } from './functions/util';
 export { Dialect, qtz } from './dialect';
-export type { DialectFieldList, CompiledOrderBy, LateralJoinExpression, QueryInfo, FieldReferenceType, } from './dialect';
+export type { DialectFieldList, CompiledOrderBy, LateralJoinExpression, QueryInfo, FieldReferenceType, GroupByClauseType, OrderByClauseType, } from './dialect';
 export { StandardSQLDialect } from './standardsql';
 export { PostgresDialect } from './postgres';
 export { DuckDBDialect } from './duckdb';
@@ -9,6 +9,7 @@ export { SnowflakeDialect } from './snowflake';
 export { TrinoDialect } from './trino';
 export { MySQLDialect } from './mysql';
 export { DatabricksDialect } from './databricks';
+export { SQLServerDialect } from './sqlserver';
 export { getDialect, registerDialect } from './dialect_map';
 export { getMalloyStandardFunctions } from './functions';
 export type { MalloyStandardFunctionImplementations } from './functions';

package/dist/dialect/index.js

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: MIT
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateDottedTablePath = exports.decodeDottedTablePath = exports.TinyParser = exports.getMalloyStandardFunctions = exports.registerDialect = exports.getDialect = exports.DatabricksDialect = exports.MySQLDialect = exports.TrinoDialect = exports.SnowflakeDialect = exports.DuckDBDialect = exports.PostgresDialect = exports.StandardSQLDialect = exports.qtz = exports.Dialect = exports.sql = exports.literal = exports.variadicParam = exports.param = exports.spread = exports.maxScalar = exports.minAggregate = exports.minScalar = exports.overload = exports.makeParam = exports.anyExprType = exports.arg = void 0;
+exports.validateDottedTablePath = exports.decodeDottedTablePath = exports.TinyParser = exports.getMalloyStandardFunctions = exports.registerDialect = exports.getDialect = exports.SQLServerDialect = exports.DatabricksDialect = exports.MySQLDialect = exports.TrinoDialect = exports.SnowflakeDialect = exports.DuckDBDialect = exports.PostgresDialect = exports.StandardSQLDialect = exports.qtz = exports.Dialect = exports.sql = exports.literal = exports.variadicParam = exports.param = exports.spread = exports.maxScalar = exports.minAggregate = exports.minScalar = exports.overload = exports.makeParam = exports.anyExprType = exports.arg = void 0;
 var util_1 = require("./functions/util");
 Object.defineProperty(exports, "arg", { enumerable: true, get: function () { return util_1.arg; } });
 Object.defineProperty(exports, "anyExprType", { enumerable: true, get: function () { return util_1.anyExprType; } });
@@ -35,6 +35,8 @@ var mysql_1 = require("./mysql");
 Object.defineProperty(exports, "MySQLDialect", { enumerable: true, get: function () { return mysql_1.MySQLDialect; } });
 var databricks_1 = require("./databricks");
 Object.defineProperty(exports, "DatabricksDialect", { enumerable: true, get: function () { return databricks_1.DatabricksDialect; } });
+var sqlserver_1 = require("./sqlserver");
+Object.defineProperty(exports, "SQLServerDialect", { enumerable: true, get: function () { return sqlserver_1.SQLServerDialect; } });
 var dialect_map_1 = require("./dialect_map");
 Object.defineProperty(exports, "getDialect", { enumerable: true, get: function () { return dialect_map_1.getDialect; } });
 Object.defineProperty(exports, "registerDialect", { enumerable: true, get: function () { return dialect_map_1.registerDialect; } });

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

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/sqlserver/dialect_functions.d.ts

@@ -0,0 +1,2 @@
+import type { DefinitionBlueprintMap } from '../functions/util';
+export declare const SQLSERVER_DIALECT_FUNCTIONS: DefinitionBlueprintMap;

package/dist/dialect/sqlserver/dialect_functions.js

@@ -0,0 +1,42 @@
+"use strict";
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SQLSERVER_DIALECT_FUNCTIONS = void 0;
+const util_1 = require("../functions/util");
+const order_by = {
+    node: 'aggregate_order_by',
+    prefix: ' WITHIN GROUP (',
+    suffix: ')',
+};
+// STRING_AGG's result is limited to 8000 bytes unless its input is a MAX type.
+const string_agg = {
+    default_separator: {
+        takes: { 'value': { dimension: 'string' } },
+        returns: { measure: 'string' },
+        supportsOrderBy: true,
+        impl: {
+            expr: (0, util_1.sql) `STRING_AGG(CAST(${(0, util_1.arg)('value')} AS NVARCHAR(MAX)), ',')${order_by}`,
+        },
+    },
+    with_separator: {
+        takes: {
+            'value': { dimension: 'string' },
+            'separator': { literal: 'string' },
+        },
+        returns: { measure: 'string' },
+        supportsOrderBy: true,
+        impl: {
+            expr: (0, util_1.sql) `STRING_AGG(CAST(${(0, util_1.arg)('value')} AS NVARCHAR(MAX)), ${(0, util_1.arg)('separator')})${order_by}`,
+        },
+    },
+};
+// No string_agg_distinct: STRING_AGG accepts no DISTINCT, so the translator
+// reports the function as unknown for this dialect.
+exports.SQLSERVER_DIALECT_FUNCTIONS = {
+    string_agg,
+    ...(0, util_1.def)('reverse', { 'str': 'string' }, 'string'),
+};
+//# sourceMappingURL=dialect_functions.js.map

package/dist/dialect/sqlserver/function_overrides.d.ts

@@ -0,0 +1,2 @@
+import type { MalloyStandardFunctionImplementations as OverrideMap } from '../functions/malloy_standard_functions';
+export declare const SQLSERVER_MALLOY_STANDARD_OVERLOADS: OverrideMap;

package/dist/dialect/sqlserver/function_overrides.js

@@ -0,0 +1,55 @@
+"use strict";
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SQLSERVER_MALLOY_STANDARD_OVERLOADS = void 0;
+// LEN ignores trailing spaces: append one character, count, subtract one
+const len = (arg) => `(LEN(${arg} + N'x') - 1)`;
+exports.SQLSERVER_MALLOY_STANDARD_OVERLOADS = {
+    ceil: { function: 'CEILING' },
+    chr: { sql: "CASE WHEN ${value} = 0 THEN '' ELSE NCHAR(${value}) END" },
+    div: { sql: 'FLOOR(${dividend} / ${divisor})' },
+    // starts_with and ends_with are written as comparisons because SQL Server
+    // has no boolean values: legal as a condition (where:, having:), a server
+    // error as a value. A NULL input matches nothing, where the standard's
+    // COALESCE(..., false) returns false.
+    ends_with: {
+        sql: `RIGHT(\${value}, ${len('${suffix}')}) = \${suffix}`,
+    },
+    ifnull: { function: 'ISNULL' },
+    // A FLOAT holds neither infinity nor NaN, so neither condition is ever true
+    is_inf: { sql: '(1=0)' },
+    is_nan: { sql: '(1=0)' },
+    length: { sql: len('${value}') },
+    ln: { sql: 'LOG(${value})' },
+    log: { sql: 'LOG(${value}, ${base})' },
+    // POWER answers in the type of its base, so an integer base truncates
+    pow: { sql: 'POWER(CAST(${base} AS FLOAT(53)), ${exponent})' },
+    round: {
+        to_integer: { sql: 'ROUND(${value}, 0)' },
+        to_precision: { sql: 'ROUND(${value}, ${precision})' },
+    },
+    atan2: { function: 'ATN2' },
+    trim: { characters: { sql: 'TRIM(${trim_characters} FROM ${value})' } },
+    starts_with: {
+        sql: `LEFT(\${value}, ${len('${prefix}')}) = \${prefix}`,
+    },
+    stddev: { function: 'STDEV' },
+    string_repeat: { function: 'REPLICATE' },
+    strpos: { sql: 'CHARINDEX(${search_string}, ${test_string})' },
+    substr: {
+        position_only: {
+            sql: `SUBSTRING(\${value}, CASE WHEN \${position} < 0 THEN ${len('${value}')} + \${position} + 1 ELSE \${position} END, ${len('${value}')})`,
+        },
+        with_length: {
+            sql: `SUBSTRING(\${value}, CASE WHEN \${position} < 0 THEN ${len('${value}')} + \${position} + 1 ELSE \${position} END, \${length})`,
+        },
+    },
+    trunc: {
+        to_integer: { sql: 'ROUND(${value}, 0, 1)' },
+        to_precision: { sql: 'ROUND(${value}, ${precision}, 1)' },
+    },
+};
+//# sourceMappingURL=function_overrides.js.map

package/dist/dialect/sqlserver/index.d.ts

@@ -0,0 +1 @@
+export * from './sqlserver';

package/dist/dialect/sqlserver/index.js

@@ -0,0 +1,22 @@
+"use strict";
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./sqlserver"), exports);
+//# sourceMappingURL=index.js.map

package/dist/dialect/sqlserver/sqlserver.d.ts

@@ -0,0 +1,102 @@
+import type { Sampling, AtomicTypeDef, ATimestampTypeDef, TypecastExpr, MeasureTimeExpr, BasicAtomicTypeDef, RegexMatchExpr, TimeExtractExpr, TimestampUnit, OrderBy } from '../../model/malloy_types';
+import type { DialectFunctionOverloadDef } from '../functions';
+import type { BooleanTypeSupport, DialectFieldList, FieldReferenceType, GroupByClauseType, QueryInfo } from '../dialect';
+import { Dialect } from '../dialect';
+import type { ValidateTablePathResult } from '../table-path';
+/** T-SQL for SQL Server 2017 and later, and Azure SQL Database. */
+export declare class SQLServerDialect extends Dialect {
+    name: string;
+    experimental: boolean;
+    stringLiteralStyle: "doubled";
+    identifierEscapeStyle: "doubled";
+    identifierQuoteChar: string;
+    defaultNumberType: string;
+    defaultDecimalType: string;
+    udfPrefix: string;
+    hasFinalStage: boolean;
+    divisionIsInteger: boolean;
+    supportsSumDistinctFunction: boolean;
+    unnestWithNumbers: boolean;
+    defaultSampling: {
+        rows: number;
+    };
+    supportUnnestArrayAgg: boolean;
+    supportsAggDistinct: boolean;
+    supportsCTEinCoorelatedSubQueries: boolean;
+    dontUnionIndex: boolean;
+    supportsQualify: boolean;
+    supportsSafeCast: boolean;
+    supportsNesting: boolean;
+    supportsPipelinesInViews: boolean;
+    supportsFullJoin: boolean;
+    readsNestedData: boolean;
+    supportsComplexFilteredSources: boolean;
+    supportsArraysInData: boolean;
+    compoundObjectInSchema: boolean;
+    supportsSelectReplace: boolean;
+    supportsTempTables: boolean;
+    booleanType: BooleanTypeSupport;
+    hasTimestamptz: boolean;
+    supportsBigIntPrecision: boolean;
+    maxIdentifierLength: number;
+    likeEscape: boolean;
+    likeExtraWildcards: string[];
+    groupByClause: GroupByClauseType;
+    tablePathBareIdentRegex: RegExp;
+    /**
+     * `[schema].[table]` is read as the ANSI-quoted path it stands for, and the
+     * canonical form is the ANSI spelling the base validates.
+     */
+    sqlValidateTableName(input: string): ValidateTablePathResult;
+    malloyTypeToSQLType(malloyType: AtomicTypeDef): string;
+    sqlTypeToMalloyType(sqlType: string): BasicAtomicTypeDef;
+    validateTypeName(sqlType: string): boolean;
+    sqlGroupSetTable(groupSetCount: number): string;
+    sqlAnyValue(_groupSet: number, fieldName: string): string;
+    sqlAggregateTurtle(): string;
+    sqlAnyValueTurtle(): string;
+    sqlAnyValueLastTurtle(): string;
+    sqlCoaleseMeasuresInline(): string;
+    sqlUnnestAlias(): string;
+    sqlSelectAliasAsStruct(): string;
+    sqlLiteralRecord(): string;
+    sqlLiteralArray(): string;
+    sqlFieldReference(parentAlias: string, _parentType: FieldReferenceType, childName: string, _childType: string): string;
+    private unsupported;
+    sqlUnnestPipelineHead(_isSingleton: boolean, _sourceSQLExpression: string, _fieldList?: DialectFieldList): string;
+    sqlCreateFunction(_id: string, _funcText: string): string;
+    sqlCreateFunctionCombineLastStage(_lastStageName: string, _fieldList: DialectFieldList, _orderBy: OrderBy[] | undefined): string;
+    sqlCreateTableAsSelect(tableName: string, sql: string): string;
+    sqlGenerateUUID(): string;
+    sqlLiteralString(literal: string): string;
+    sqlSumDistinctHashedKey(sqlDistinctKey: string): string;
+    sqlSumDistinct(key: string, value: string, funcName: string): string;
+    sqlAggDistinct(_key: string, _values: string[], _func: (valNames: string[]) => string): string;
+    sqlOrderByLimit(orderTerms: string[], limit: number | undefined): string;
+    sqlSampleTable(tableSQL: string, sample: Sampling | undefined, onBaseTable?: boolean): string;
+    castToString(expression: string): string;
+    concat(...values: string[]): string;
+    sqlDateToString(sqlDateExp: string): string;
+    sqlNowExpr(): string;
+    sqlTimeExtractExpr(qi: QueryInfo, from: TimeExtractExpr): string;
+    sqlCast(qi: QueryInfo, cast: TypecastExpr): string;
+    sqlRegexpMatch(_df: RegexMatchExpr): string;
+    sqlDateLiteral(_qi: QueryInfo, literal: string): string;
+    sqlTimestampLiteral(qi: QueryInfo, literal: string, timezone: string | undefined): string;
+    sqlTimestamptzLiteral(_qi: QueryInfo, _literal: string, _timezone: string): string;
+    sqlTimezoneLiteral(timezone: string): string;
+    sqlConvertToCivilTime(expr: string, timezone: string, _typeDef: AtomicTypeDef): {
+        sql: string;
+        typeDef: AtomicTypeDef;
+    };
+    sqlConvertFromCivilTime(expr: string, timezone: string, _destTypeDef: ATimestampTypeDef): string;
+    sqlTruncate(expr: string, unit: TimestampUnit, typeDef: AtomicTypeDef, _inCivilTime: boolean, _timezone?: string): string;
+    sqlOffsetTime(expr: string, op: '+' | '-', magnitude: string, unit: TimestampUnit, _typeDef: AtomicTypeDef, _inCivilTime: boolean, _timezone?: string): string;
+    sqlMeasureTimeExpr(df: MeasureTimeExpr): string;
+    getDialectFunctionOverrides(): {
+        [name: string]: DialectFunctionOverloadDef[];
+    };
+    getDialectFunctions(): {
+        [name: string]: DialectFunctionOverloadDef[];
+    };
+}