@malloydata/malloy 0.0.433 → 0.0.435

package/dist/dialect/sqlserver/sqlserver.js

@@ -0,0 +1,538 @@
+"use strict";
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SQLServerDialect = void 0;
+const malloy_types_1 = require("../../model/malloy_types");
+const functions_1 = require("../functions");
+const dialect_1 = require("../dialect");
+const dialect_functions_1 = require("./dialect_functions");
+const function_overrides_1 = require("./function_overrides");
+const windows_zones_1 = require("./windows_zones");
+/** DATEPART / DATEADD / DATEDIFF spellings of Malloy's units */
+const datePartMap = {
+    second: 'second',
+    minute: 'minute',
+    hour: 'hour',
+    day: 'day',
+    week: 'week',
+    month: 'month',
+    quarter: 'quarter',
+    year: 'year',
+    day_of_year: 'dayofyear',
+};
+const inSeconds = {
+    second: 1,
+    minute: 60,
+    hour: 3600,
+    day: 24 * 3600,
+    week: 7 * 24 * 3600,
+};
+// Malloy types by SQL Server type name, spelled as sys.types and the
+// system_type_name of sys.dm_exec_describe_first_result_set spell them.
+// DECIMAL and NUMERIC are absent: their scale decides (sqlTypeToMalloyType).
+const sqlServerToMalloyTypes = {
+    // A bit is an integer: SQL Server has no boolean values
+    'bit': { type: 'number', numberType: 'integer' },
+    'tinyint': { type: 'number', numberType: 'integer' },
+    'smallint': { type: 'number', numberType: 'integer' },
+    'int': { type: 'number', numberType: 'integer' },
+    'bigint': { type: 'number', numberType: 'bigint' },
+    'real': { type: 'number', numberType: 'float' },
+    'float': { type: 'number', numberType: 'float' },
+    'money': { type: 'number', numberType: 'float' },
+    'smallmoney': { type: 'number', numberType: 'float' },
+    'char': { type: 'string' },
+    'varchar': { type: 'string' },
+    'nchar': { type: 'string' },
+    'nvarchar': { type: 'string' },
+    // text and ntext take no GROUP BY, MAX or comparison, so they stay native
+    // uniqueidentifier stays native: a GUID is neither text nor a number to Malloy
+    'date': { type: 'date' },
+    'datetime': { type: 'timestamp' },
+    'datetime2': { type: 'timestamp' },
+    'smalldatetime': { type: 'timestamp' },
+};
+function parseSQLServerType(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)) : [],
+    };
+}
+/**
+ * A table path with T-SQL's `[name]` segments rewritten as ANSI-quoted ones
+ * (`]]` inside a segment is one `]`); a `"name"` segment passes through
+ * untouched. `undefined` for a `[` that is never closed.
+ */
+function bracketsToAnsi(input, quote) {
+    let ansi = '';
+    let i = 0;
+    while (i < input.length) {
+        const c = input[i];
+        if (c === '"') {
+            let j = i + 1;
+            while (j < input.length) {
+                if (input[j] === '"') {
+                    if (input[j + 1] === '"') {
+                        j += 2;
+                        continue;
+                    }
+                    break;
+                }
+                j++;
+            }
+            ansi += input.slice(i, j + 1);
+            i = j + 1;
+        }
+        else if (c === '[') {
+            let body = '';
+            let j = i + 1;
+            let closed = false;
+            while (j < input.length) {
+                if (input[j] === ']') {
+                    if (input[j + 1] === ']') {
+                        body += ']';
+                        j += 2;
+                        continue;
+                    }
+                    closed = true;
+                    break;
+                }
+                body += input[j];
+                j++;
+            }
+            if (!closed) {
+                return undefined;
+            }
+            ansi += quote(body);
+            i = j + 1;
+        }
+        else {
+            ansi += c;
+            i++;
+        }
+    }
+    return ansi;
+}
+/** T-SQL for SQL Server 2017 and later, and Azure SQL Database. */
+class SQLServerDialect extends dialect_1.Dialect {
+    constructor() {
+        super(...arguments);
+        this.name = 'sqlserver';
+        this.experimental = true;
+        // The connection's batch prefix sets QUOTED_IDENTIFIER ON, so an identifier
+        // is double-quoted and a string literal single-quoted; a quote inside
+        // either is escaped by doubling it.
+        this.stringLiteralStyle = dialect_1.EscapeStyle.Doubled;
+        this.identifierEscapeStyle = dialect_1.EscapeStyle.Doubled;
+        this.identifierQuoteChar = '"';
+        this.defaultNumberType = 'FLOAT(53)';
+        this.defaultDecimalType = 'DECIMAL(38, 9)';
+        this.udfPrefix = '__udf';
+        this.hasFinalStage = false;
+        this.divisionIsInteger = true;
+        this.supportsSumDistinctFunction = true;
+        this.unnestWithNumbers = false;
+        this.defaultSampling = { rows: 50000 };
+        this.supportUnnestArrayAgg = false;
+        this.supportsAggDistinct = false;
+        // A CTE is a statement prefix and cannot appear inside a subquery.
+        this.supportsCTEinCoorelatedSubQueries = false;
+        this.dontUnionIndex = false;
+        this.supportsQualify = false;
+        this.supportsSafeCast = true;
+        this.supportsNesting = false;
+        this.supportsPipelinesInViews = false;
+        this.supportsFullJoin = true;
+        this.readsNestedData = false;
+        this.supportsComplexFilteredSources = false;
+        this.supportsArraysInData = false;
+        this.compoundObjectInSchema = false;
+        this.supportsSelectReplace = false;
+        this.supportsTempTables = false;
+        // SQL Server has no boolean values: a comparison is legal only where a
+        // condition is expected, `true` and `false` are (1=1) and (1=0), a `bit`
+        // column is an integer, and a cast to boolean is refused.
+        this.booleanType = 'none';
+        this.hasTimestamptz = false;
+        // A bigint arrives from the driver as text and is read as a JavaScript number
+        this.supportsBigIntPrecision = false;
+        this.maxIdentifierLength = 128;
+        this.likeEscape = true;
+        this.likeExtraWildcards = ['['];
+        this.groupByClause = 'expression';
+        // A leading `#` or `@` names a temp table or a variable, not a table.
+        this.tablePathBareIdentRegex = /^[A-Za-z_][A-Za-z0-9_$#@]*/;
+    }
+    /**
+     * `[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) {
+        const ansi = bracketsToAnsi(input, body => this.sqlQuoteIdentifier(body));
+        if (ansi === undefined) {
+            return {
+                ok: false,
+                error: `Invalid ${this.name} table path: ${JSON.stringify(input)} — unterminated bracketed segment`,
+            };
+        }
+        return super.sqlValidateTableName(ansi);
+    }
+    malloyTypeToSQLType(malloyType) {
+        switch (malloyType.type) {
+            case 'number':
+                if (malloyType.numberType === 'integer') {
+                    return 'INT';
+                }
+                else if (malloyType.numberType === 'bigint') {
+                    return 'BIGINT';
+                }
+                return this.defaultNumberType;
+            case 'string':
+                return 'NVARCHAR(MAX)';
+            case 'boolean':
+                return 'BIT';
+            case 'date':
+                return 'DATE';
+            case 'timestamp':
+                return 'DATETIME2';
+            case 'record':
+            case 'array':
+                return 'NVARCHAR(MAX)';
+            default:
+                return malloyType.type;
+        }
+    }
+    sqlTypeToMalloyType(sqlType) {
+        var _a, _b, _c;
+        const { base, params } = parseSQLServerType(sqlType);
+        if (base === 'decimal' || base === 'numeric') {
+            // Scale decides float vs exact; precision decides whether an exact
+            // value survives a JS double. A bare DECIMAL is (18, 0).
+            const [precision, scale] = [(_a = params[0]) !== null && _a !== void 0 ? _a : 18, (_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 ((_c = sqlServerToMalloyTypes[base]) !== null && _c !== void 0 ? _c : {
+            type: 'sql native',
+            rawType: base,
+        });
+    }
+    validateTypeName(sqlType) {
+        // The spellings the type map reads: letters, digits, spaces, parentheses
+        // and commas, as in BIGINT, FLOAT(53) and DECIMAL(5, 2).
+        return sqlType.match(/^[A-Za-z\s(),0-9]*$/) !== null;
+    }
+    sqlGroupSetTable(groupSetCount) {
+        const rows = Array.from({ length: groupSetCount + 1 }, (_, i) => `(${i})`);
+        return `CROSS JOIN (VALUES ${rows.join(',')}) AS group_set(group_set)`;
+    }
+    sqlAnyValue(_groupSet, fieldName) {
+        return `MAX(${fieldName})`;
+    }
+    // Nests, arrays and records are not supported: supportsNesting,
+    // supportsArraysInData and compoundObjectInSchema are false. A call here
+    // comes from a literal, a source the translator let through, or an
+    // ungrouped aggregate (all(), exclude()), which shares the nest machinery.
+    sqlAggregateTurtle() {
+        return this.unsupported('nesting');
+    }
+    sqlAnyValueTurtle() {
+        return this.unsupported('nesting');
+    }
+    sqlAnyValueLastTurtle() {
+        return this.unsupported('nesting');
+    }
+    sqlCoaleseMeasuresInline() {
+        return this.unsupported('nesting');
+    }
+    sqlUnnestAlias() {
+        return this.unsupported('arrays');
+    }
+    sqlSelectAliasAsStruct() {
+        return this.unsupported('records');
+    }
+    sqlLiteralRecord() {
+        return this.unsupported('record literals');
+    }
+    sqlLiteralArray() {
+        return this.unsupported('array literals');
+    }
+    sqlFieldReference(parentAlias, _parentType, childName, _childType) {
+        return `${parentAlias}.${this.sqlQuoteIdentifier(childName)}`;
+    }
+    unsupported(what) {
+        throw new Error(`SQL Server dialect does not support ${what}`);
+    }
+    sqlUnnestPipelineHead(_isSingleton, _sourceSQLExpression, _fieldList) {
+        return this.unsupported('a nested pipeline');
+    }
+    sqlCreateFunction(_id, _funcText) {
+        return this.unsupported('a nested pipeline');
+    }
+    sqlCreateFunctionCombineLastStage(_lastStageName, _fieldList, _orderBy) {
+        return this.unsupported('a nested pipeline');
+    }
+    sqlCreateTableAsSelect(tableName, sql) {
+        return `SELECT * INTO ${tableName} FROM (\n${sql}\n) AS __malloy_ctas`;
+    }
+    // The row key a symmetric aggregate is keyed on: NEWID() is evaluated again
+    // for every joined row and double-counts, a row number is one per source row
+    sqlGenerateUUID() {
+        return 'ROW_NUMBER() OVER (ORDER BY (SELECT NULL))';
+    }
+    // A stage's SQL is indented when it becomes a CTE, which would indent the
+    // text of a literal spanning lines.
+    sqlLiteralString(literal) {
+        // N'...' is Unicode; a bare '...' is read in the database's code page
+        if (!/[\r\n]/.test(literal)) {
+            return `N${super.sqlLiteralString(literal)}`;
+        }
+        const parts = literal
+            .split(/(\r|\n)/)
+            .filter(p => p !== '')
+            .map(p => p === '\r'
+            ? 'CHAR(13)'
+            : p === '\n'
+                ? 'CHAR(10)'
+                : `N${super.sqlLiteralString(p)}`);
+        return `(${parts.join(' + ')})`;
+    }
+    // The MD5 of the key as a 64-bit integer, widened so that hash + value is
+    // exact at the value's scale.
+    sqlSumDistinctHashedKey(sqlDistinctKey) {
+        return `CAST(CAST(HASHBYTES('MD5', CAST(${sqlDistinctKey} AS NVARCHAR(MAX))) AS BIGINT) AS ${this.defaultDecimalType})`;
+    }
+    sqlSumDistinct(key, value, funcName) {
+        const hashKey = this.sqlSumDistinctHashedKey(key);
+        const v = `CAST(COALESCE(${value}, 0) AS ${this.defaultDecimalType})`;
+        const sqlSum = `CAST((SUM(DISTINCT ${hashKey} + ${v}) - SUM(DISTINCT ${hashKey})) AS ${this.defaultNumberType})`;
+        if (funcName === 'SUM') {
+            return sqlSum;
+        }
+        else if (funcName === 'AVG') {
+            return `(${sqlSum})/NULLIF(COUNT(DISTINCT CASE WHEN ${value} IS NOT NULL THEN ${key} END), 0)`;
+        }
+        throw new Error(`Unknown Symmetric Aggregate function ${funcName}`);
+    }
+    sqlAggDistinct(_key, _values, _func) {
+        return this.unsupported('distinct aggregates');
+    }
+    // OFFSET/FETCH is ORDER BY's row limit, and an ORDER BY carrying an OFFSET
+    // is legal inside a CTE or derived table where a bare one is not; the server
+    // still sorts it. A limit with no ordering orders by (SELECT NULL), the one
+    // constant ORDER BY accepts.
+    sqlOrderByLimit(orderTerms, limit) {
+        if (orderTerms.length === 0 && limit === undefined) {
+            return '';
+        }
+        const orderBy = orderTerms.length > 0
+            ? this.sqlOrderBy(orderTerms, 'query')
+            : 'ORDER BY (SELECT NULL)';
+        const fetch = limit === undefined ? '' : ` FETCH NEXT ${limit} ROWS ONLY`;
+        return `${orderBy} OFFSET 0 ROWS${fetch}\n`;
+    }
+    // TABLESAMPLE reads whole pages of a base table and nothing else, so a
+    // sample on a derived table is ignored rather than taken as its first rows.
+    sqlSampleTable(tableSQL, sample, onBaseTable = true) {
+        if (sample === undefined || !onBaseTable) {
+            return tableSQL;
+        }
+        if ((0, malloy_types_1.isSamplingEnable)(sample) && sample.enable) {
+            sample = this.defaultSampling;
+        }
+        if ((0, malloy_types_1.isSamplingRows)(sample)) {
+            return `(SELECT * FROM ${tableSQL} TABLESAMPLE (${sample.rows} ROWS))`;
+        }
+        if ((0, malloy_types_1.isSamplingPercent)(sample)) {
+            return `(SELECT * FROM ${tableSQL} TABLESAMPLE (${sample.percent} PERCENT))`;
+        }
+        return tableSQL;
+    }
+    castToString(expression) {
+        return `CAST(${expression} AS NVARCHAR(MAX))`;
+    }
+    concat(...values) {
+        return `CONCAT(${values.join(', ')})`;
+    }
+    sqlDateToString(sqlDateExp) {
+        return `CONVERT(NVARCHAR(10), ${sqlDateExp}, 23)`;
+    }
+    // A Malloy timestamp is a UTC wall clock: a datetime2 is read as UTC, and
+    // now is the server's UTC clock
+    sqlNowExpr() {
+        return 'SYSUTCDATETIME()';
+    }
+    sqlTimeExtractExpr(qi, from) {
+        let extractFrom = from.e.sql;
+        if (malloy_types_1.TD.isAnyTimestamp(from.e.typeDef)) {
+            const tz = (0, dialect_1.qtz)(qi);
+            if (tz) {
+                extractFrom = this.sqlConvertToCivilTime(extractFrom !== null && extractFrom !== void 0 ? extractFrom : '', tz, from.e.typeDef).sql;
+            }
+        }
+        if (from.units === 'day_of_week') {
+            // Days since a Sunday, so the answer does not follow DATEFIRST
+            return `((DATEDIFF(day, '19000107', ${extractFrom}) % 7 + 7) % 7 + 1)`;
+        }
+        // Malloy's week of the year is the ISO week; DATEPART(week) counts from
+        // January 1st and follows DATEFIRST
+        const part = from.units === 'week' ? 'iso_week' : datePartMap[from.units];
+        if (part === undefined) {
+            throw new Error(`Unknown SQL Server date part '${from.units}'`);
+        }
+        return `DATEPART(${part}, ${extractFrom})`;
+    }
+    sqlCast(qi, cast) {
+        const expr = cast.e.sql || '';
+        const { srcTypeDef, dstTypeDef, dstSQLType } = this.sqlCastPrep(cast);
+        if ((dstTypeDef === null || dstTypeDef === void 0 ? void 0 : dstTypeDef.type) === 'boolean') {
+            return this.unsupported('a cast to boolean: there are no boolean values');
+        }
+        const tz = (0, dialect_1.qtz)(qi);
+        if (tz && srcTypeDef && dstTypeDef) {
+            if (malloy_types_1.TD.isTimestamp(srcTypeDef) && malloy_types_1.TD.isDate(dstTypeDef)) {
+                const civil = this.sqlConvertToCivilTime(expr, tz, srcTypeDef).sql;
+                return `CAST(${civil} AS DATE)`;
+            }
+            if (malloy_types_1.TD.isDate(srcTypeDef) && malloy_types_1.TD.isTimestamp(dstTypeDef)) {
+                return this.sqlConvertFromCivilTime(`CAST(${expr} AS DATETIME2)`, tz, dstTypeDef);
+            }
+        }
+        if (!malloy_types_1.TD.eq(srcTypeDef, dstTypeDef)) {
+            const castFunc = cast.safe ? 'TRY_CAST' : 'CAST';
+            return `${castFunc}(${expr} AS ${dstSQLType})`;
+        }
+        return expr;
+    }
+    sqlRegexpMatch(_df) {
+        return this.unsupported('regular expressions before SQL Server 2025');
+    }
+    sqlDateLiteral(_qi, literal) {
+        return `CAST('${literal}' AS DATE)`;
+    }
+    sqlTimestampLiteral(qi, literal, timezone) {
+        const tz = timezone || (0, dialect_1.qtz)(qi);
+        const ts = `CAST('${literal}' AS DATETIME2)`;
+        if (tz) {
+            return this.sqlConvertFromCivilTime(ts, tz, { type: 'timestamp' });
+        }
+        return ts;
+    }
+    sqlTimestamptzLiteral(_qi, _literal, _timezone) {
+        throw new Error('SQL Server dialect does not support timestamptz');
+    }
+    // AT TIME ZONE takes a Windows time zone name
+    sqlTimezoneLiteral(timezone) {
+        const windowsName = windows_zones_1.WINDOWS_TIME_ZONES[timezone];
+        if (windowsName === undefined) {
+            throw new Error(`SQL Server dialect has no Windows time zone for '${timezone}'`);
+        }
+        return this.sqlLiteralString(windowsName);
+    }
+    sqlConvertToCivilTime(expr, timezone, _typeDef) {
+        if (timezone === 'UTC') {
+            return { sql: expr, typeDef: { type: 'timestamp' } };
+        }
+        const tz = this.sqlTimezoneLiteral(timezone);
+        return {
+            sql: `CAST((${expr} AT TIME ZONE 'UTC') AT TIME ZONE ${tz} AS DATETIME2)`,
+            typeDef: { type: 'timestamp' },
+        };
+    }
+    sqlConvertFromCivilTime(expr, timezone, _destTypeDef) {
+        if (timezone === 'UTC') {
+            return expr;
+        }
+        const tz = this.sqlTimezoneLiteral(timezone);
+        return `CAST((${expr} AT TIME ZONE ${tz}) AT TIME ZONE 'UTC' AS DATETIME2)`;
+    }
+    sqlTruncate(expr, unit, typeDef, _inCivilTime, _timezone) {
+        // Truncation is DATEADD of the whole units since an anchor: 1900-01-01
+        // for a calendar unit, the value's own midnight for a clock unit, so the
+        // count fits an int. SQL Server 2017 has no DATETRUNC.
+        const midnight = `CAST(CAST(${expr} AS DATE) AS DATETIME2)`;
+        if (unit === 'week') {
+            // Malloy weeks start on Sunday whatever DATEFIRST says, so count days
+            // from a known Sunday.
+            const day = malloy_types_1.TD.isDate(typeDef) ? expr : midnight;
+            return `DATEADD(day, -((DATEDIFF(day, '19000107', ${expr}) % 7 + 7) % 7), ${day})`;
+        }
+        const part = datePartMap[unit];
+        if (part === undefined) {
+            throw new Error(`Unknown SQL Server date part '${unit}'`);
+        }
+        if (unit === 'day' && !malloy_types_1.TD.isDate(typeDef)) {
+            return midnight;
+        }
+        if (unit === 'hour' || unit === 'minute' || unit === 'second') {
+            return `DATEADD(${part}, DATEDIFF(${part}, ${midnight}, ${expr}), ${midnight})`;
+        }
+        const truncated = `DATEADD(${part}, DATEDIFF(${part}, '19000101', ${expr}), '19000101')`;
+        return malloy_types_1.TD.isDate(typeDef)
+            ? `CAST(${truncated} AS DATE)`
+            : `CAST(${truncated} AS DATETIME2)`;
+    }
+    sqlOffsetTime(expr, op, magnitude, unit, _typeDef, _inCivilTime, _timezone) {
+        const part = datePartMap[unit];
+        if (part === undefined) {
+            throw new Error(`Unknown SQL Server date part '${unit}'`);
+        }
+        const n = op === '-' ? `-(${magnitude})` : `(${magnitude})`;
+        return `DATEADD(${part}, ${n}, ${expr})`;
+    }
+    // Malloy measures a range in whole units completed, truncated toward zero;
+    // DATEDIFF counts boundaries crossed.
+    sqlMeasureTimeExpr(df) {
+        const from = df.kids.left;
+        const to = df.kids.right;
+        const lVal = from.sql;
+        const rVal = to.sql;
+        if (malloy_types_1.TD.isDate(from.typeDef) &&
+            malloy_types_1.TD.isDate(to.typeDef) &&
+            ['week', 'month', 'quarter', 'year'].includes(df.units)) {
+            // Integer division truncates toward zero, as Malloy measures
+            if (df.units === 'week') {
+                return `(DATEDIFF(day, ${lVal}, ${rVal}) / 7)`;
+            }
+            const earlier = `(CASE WHEN ${rVal} >= ${lVal} THEN ${lVal} ELSE ${rVal} END)`;
+            const later = `(CASE WHEN ${rVal} >= ${lVal} THEN ${rVal} ELSE ${lVal} END)`;
+            const months = `(DATEDIFF(month, ${earlier}, ${later}) - CASE WHEN DAY(${later}) < DAY(${earlier}) THEN 1 ELSE 0 END)`;
+            const measured = df.units === 'month'
+                ? months
+                : df.units === 'quarter'
+                    ? `(${months} / 3)`
+                    : `(${months} / 12)`;
+            return `CASE
+        WHEN ${lVal} IS NULL OR ${rVal} IS NULL THEN NULL
+        WHEN ${rVal} >= ${lVal} THEN ${measured}
+        ELSE -(${measured})
+      END`;
+        }
+        if (inSeconds[df.units]) {
+            const ms = `DATEDIFF_BIG(millisecond, ${lVal}, ${rVal})`;
+            const divisor = inSeconds[df.units] * 1000;
+            return `CAST(${ms} / ${divisor} AS BIGINT)`;
+        }
+        throw new Error(`Unknown or unhandled SQL Server time unit: ${df.units}`);
+    }
+    getDialectFunctionOverrides() {
+        return (0, functions_1.expandOverrideMap)(function_overrides_1.SQLSERVER_MALLOY_STANDARD_OVERLOADS);
+    }
+    getDialectFunctions() {
+        return (0, functions_1.expandBlueprintMap)(dialect_functions_1.SQLSERVER_DIALECT_FUNCTIONS);
+    }
+}
+exports.SQLServerDialect = SQLServerDialect;
+//# sourceMappingURL=sqlserver.js.map

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

@@ -0,0 +1 @@
+export declare const WINDOWS_TIME_ZONES: Record<string, string>;