@malloydata/malloy 0.0.350 → 0.0.351

package/dist/dialect/databricks/databricks.d.ts

@@ -0,0 +1,94 @@
+import type { Sampling, MeasureTimeExpr, RegexMatchExpr, TimeExtractExpr, TypecastExpr, BasicAtomicTypeDef, AtomicTypeDef, ArrayLiteralNode, RecordLiteralNode } from '../../model/malloy_types';
+import type { BooleanTypeSupport, CompiledOrderBy, DialectFieldList, FieldReferenceType, LateralJoinExpression, OrderByClauseType, OrderByRequest, QueryInfo } from '../dialect';
+import { Dialect } from '../dialect';
+import type { DialectFunctionOverloadDef } from '../functions';
+export declare class DatabricksDialect extends Dialect {
+    name: string;
+    defaultNumberType: string;
+    defaultDecimalType: string;
+    udfPrefix: string;
+    hasFinalStage: boolean;
+    stringTypeName: string;
+    divisionIsInteger: boolean;
+    supportsSumDistinctFunction: boolean;
+    unnestWithNumbers: boolean;
+    defaultSampling: {
+        rows: number;
+    };
+    supportUnnestArrayAgg: boolean;
+    supportsAggDistinct: boolean;
+    supportsCTEinCoorelatedSubQueries: boolean;
+    supportsSafeCast: boolean;
+    dontUnionIndex: boolean;
+    supportsQualify: boolean;
+    supportsNesting: boolean;
+    hasLateralColumnAliasInSelect: boolean;
+    cantPartitionWindowFunctionsOnExpressions: boolean;
+    experimental: boolean;
+    supportsFullJoin: boolean;
+    supportsPipelinesInViews: boolean;
+    readsNestedData: boolean;
+    supportsComplexFilteredSources: boolean;
+    supportsArraysInData: boolean;
+    compoundObjectInSchema: boolean;
+    booleanType: BooleanTypeSupport;
+    likeEscape: boolean;
+    orderByClause: OrderByClauseType;
+    hasTimestamptz: boolean;
+    supportsBigIntPrecision: boolean;
+    maxIdentifierLength: number;
+    malloyTypeToSQLType(malloyType: AtomicTypeDef): string;
+    sqlTypeToMalloyType(sqlType: string): BasicAtomicTypeDef;
+    quoteTablePath(tablePath: string): string;
+    sqlGroupSetTable(groupSetCount: number): string;
+    sqlLateralJoinBag(expressions: LateralJoinExpression[]): string;
+    sqlOrderBy(orderTerms: string[], obr?: OrderByRequest): string;
+    sqlAnyValue(groupSet: number, fieldName: string): string;
+    private buildNamedStructExpression;
+    sqlAggregateTurtle(groupSet: number, fieldList: DialectFieldList, orderBy: CompiledOrderBy[] | undefined): string;
+    private buildArraySortComparator;
+    sqlAnyValueTurtle(groupSet: number, fieldList: DialectFieldList): string;
+    sqlAnyValueLastTurtle(name: string, groupSet: number, sqlName: string): string;
+    sqlCoaleseMeasuresInline(groupSet: number, fieldList: DialectFieldList): string;
+    sqlUnnestAlias(source: string, alias: string, _fieldList: DialectFieldList, needDistinctKey: boolean, isArray: boolean, _isInNestedPipeline: boolean): string;
+    sqlUnnestPipelineHead(isSingleton: boolean, sourceSQLExpression: string, _fieldList?: DialectFieldList): string;
+    sqlSumDistinctHashedKey(sqlDistinctKey: string): string;
+    sqlSumDistinct(key: string, value: string, funcName: string): string;
+    sqlStringAggDistinct(distinctKey: string, valueSQL: string, separatorSQL: string): string;
+    sqlGenerateUUID(): string;
+    sqlFieldReference(parentAlias: string, _parentType: FieldReferenceType, childName: string, _childType: string): string;
+    sqlCreateFunction(id: string, funcText: string): string;
+    sqlCreateFunctionCombineLastStage(lastStageName: string, fieldList: DialectFieldList): string;
+    sqlSelectAliasAsStruct(alias: string, fieldList: DialectFieldList): string;
+    sqlMaybeQuoteIdentifier(identifier: string): string;
+    sqlCreateTableAsSelect(tableName: string, sql: string): string;
+    sqlNowExpr(): string;
+    sqlConvertToCivilTime(expr: string, timezone: string, _typeDef: AtomicTypeDef): {
+        sql: string;
+        typeDef: AtomicTypeDef;
+    };
+    sqlConvertFromCivilTime(expr: string, timezone: string, _destTypeDef: AtomicTypeDef): string;
+    sqlTruncate(expr: string, unit: string, _typeDef: AtomicTypeDef, _inCivilTime: boolean, _timezone?: string): string;
+    sqlOffsetTime(expr: string, op: '+' | '-', magnitude: string, unit: string, _typeDef: AtomicTypeDef, _inCivilTime: boolean, _timezone?: string): string;
+    sqlTimeExtractExpr(qi: QueryInfo, te: 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;
+    sqlMeasureTimeExpr(df: MeasureTimeExpr): string;
+    sqlSampleTable(tableSQL: string, sample: Sampling | undefined): string;
+    sqlLiteralString(literal: string): string;
+    sqlLiteralRegexp(literal: string): string;
+    getDialectFunctionOverrides(): {
+        [name: string]: DialectFunctionOverloadDef[];
+    };
+    getDialectFunctions(): {
+        [name: string]: DialectFunctionOverloadDef[];
+    };
+    castToString(expression: string): string;
+    concat(...values: string[]): string;
+    validateTypeName(sqlType: string): boolean;
+    sqlLiteralArray(lit: ArrayLiteralNode): string;
+    sqlLiteralRecord(lit: RecordLiteralNode): string;
+}

package/dist/dialect/databricks/databricks.js

@@ -0,0 +1,441 @@
+"use strict";
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatabricksDialect = void 0;
+const malloy_types_1 = require("../../model/malloy_types");
+const utils_1 = require("../../model/utils");
+const dialect_1 = require("../dialect");
+const functions_1 = require("../functions");
+const dialect_functions_1 = require("./dialect_functions");
+const function_overrides_1 = require("./function_overrides");
+const extractionMap = {
+    day_of_week: 'DAYOFWEEK',
+    day_of_year: 'DAYOFYEAR',
+};
+const inSeconds = {
+    second: 1,
+    minute: 60,
+    hour: 3600,
+    day: 24 * 3600,
+    week: 7 * 24 * 3600,
+};
+const databricksToMalloyTypes = {
+    'tinyint': { type: 'number', numberType: 'integer' },
+    'smallint': { type: 'number', numberType: 'integer' },
+    'int': { type: 'number', numberType: 'integer' },
+    'integer': { type: 'number', numberType: 'integer' },
+    'bigint': { type: 'number', numberType: 'bigint' },
+    'float': { type: 'number', numberType: 'float' },
+    'double': { type: 'number', numberType: 'float' },
+    'decimal': { type: 'number', numberType: 'float' },
+    'string': { type: 'string' },
+    'varchar': { type: 'string' },
+    'char': { type: 'string' },
+    'binary': { type: 'string' },
+    'boolean': { type: 'boolean' },
+    'date': { type: 'date' },
+    'timestamp': { type: 'timestamp' },
+};
+class DatabricksDialect extends dialect_1.Dialect {
+    constructor() {
+        super(...arguments);
+        this.name = 'databricks';
+        this.defaultNumberType = 'DOUBLE';
+        this.defaultDecimalType = 'DECIMAL';
+        this.udfPrefix = '__udf';
+        this.hasFinalStage = false;
+        this.stringTypeName = 'STRING';
+        this.divisionIsInteger = false;
+        this.supportsSumDistinctFunction = true;
+        this.unnestWithNumbers = false;
+        this.defaultSampling = { rows: 50000 };
+        this.supportUnnestArrayAgg = true;
+        this.supportsAggDistinct = false;
+        this.supportsCTEinCoorelatedSubQueries = true;
+        this.supportsSafeCast = true;
+        this.dontUnionIndex = false;
+        this.supportsQualify = false;
+        this.supportsNesting = true;
+        this.hasLateralColumnAliasInSelect = true;
+        this.cantPartitionWindowFunctionsOnExpressions = true;
+        this.experimental = false;
+        this.supportsFullJoin = true;
+        this.supportsPipelinesInViews = false;
+        this.readsNestedData = false;
+        this.supportsComplexFilteredSources = false;
+        this.supportsArraysInData = false;
+        this.compoundObjectInSchema = false;
+        this.booleanType = 'supported';
+        this.likeEscape = false;
+        this.orderByClause = 'ordinal';
+        this.hasTimestamptz = false;
+        this.supportsBigIntPrecision = false;
+        this.maxIdentifierLength = 255;
+    }
+    malloyTypeToSQLType(malloyType) {
+        switch (malloyType.type) {
+            case 'number':
+                if (malloyType.numberType === 'integer') {
+                    return 'INT';
+                }
+                else if (malloyType.numberType === 'bigint') {
+                    return 'BIGINT';
+                }
+                else {
+                    return 'DOUBLE';
+                }
+            case 'string':
+                return 'STRING';
+            case 'boolean':
+                return 'BOOLEAN';
+            case 'record': {
+                const fields = [];
+                for (const f of malloyType.fields) {
+                    if ((0, malloy_types_1.isAtomic)(f)) {
+                        fields.push(`${this.sqlMaybeQuoteIdentifier(f.name)}: ${this.malloyTypeToSQLType(f)}`);
+                    }
+                }
+                return `STRUCT<${fields.join(', ')}>`;
+            }
+            case 'array': {
+                if ((0, malloy_types_1.isRepeatedRecord)(malloyType)) {
+                    const fields = [];
+                    for (const f of malloyType.fields) {
+                        if ((0, malloy_types_1.isAtomic)(f)) {
+                            fields.push(`${this.sqlMaybeQuoteIdentifier(f.name)}: ${this.malloyTypeToSQLType(f)}`);
+                        }
+                    }
+                    return `ARRAY<STRUCT<${fields.join(', ')}>>`;
+                }
+                return `ARRAY<${this.malloyTypeToSQLType(malloyType.elementTypeDef)}>`;
+            }
+            case 'timestamp':
+                return 'TIMESTAMP';
+            case 'sql native':
+                return malloyType.rawType || 'STRING';
+            default:
+                return malloyType.type.toUpperCase();
+        }
+    }
+    sqlTypeToMalloyType(sqlType) {
+        var _a, _b;
+        const baseSqlType = (_b = (_a = sqlType.match(/^(\w+)/)) === null || _a === void 0 ? void 0 : _a.at(0)) !== null && _b !== void 0 ? _b : sqlType;
+        return (databricksToMalloyTypes[baseSqlType.toLowerCase()] || {
+            type: 'sql native',
+            rawType: baseSqlType,
+        });
+    }
+    quoteTablePath(tablePath) {
+        return tablePath
+            .split('.')
+            .map(part => (/^[a-zA-Z_]\w*$/.test(part) ? part : `\`${part}\``))
+            .join('.');
+    }
+    sqlGroupSetTable(groupSetCount) {
+        return `LATERAL VIEW EXPLODE(SEQUENCE(0, ${groupSetCount})) group_set AS group_set`;
+    }
+    sqlLateralJoinBag(expressions) {
+        // Use LATERAL VIEW INLINE to produce a single-row lateral join with named
+        // columns. This must be LATERAL VIEW (not LEFT JOIN LATERAL) because
+        // Databricks requires all LATERAL VIEWs to come after regular JOINs,
+        // and group_set uses LATERAL VIEW EXPLODE.
+        const structArgs = expressions
+            .map(e => `'${e.name.replace(/`/g, '')}', ${e.sql}`)
+            .join(', ');
+        const aliases = expressions.map(e => e.name).join(', ');
+        return `LATERAL VIEW INLINE(ARRAY(named_struct(${structArgs}))) __lateral_join_bag AS ${aliases}\n`;
+    }
+    sqlOrderBy(orderTerms, obr) {
+        if (obr === 'analytical' || obr === 'turtle') {
+            return `ORDER BY ${orderTerms.join(',')}`;
+        }
+        return `ORDER BY ${orderTerms.map(t => `${t} NULLS LAST`).join(',')}`;
+    }
+    sqlAnyValue(groupSet, fieldName) {
+        return `FIRST(CASE WHEN group_set=${groupSet} THEN ${fieldName} END) IGNORE NULLS`;
+    }
+    // Build a named_struct expression that creates struct fields with the
+    // correct output names. This avoids CAST(STRUCT(...) AS STRUCT<...>) which
+    // can lose nested complex type information (e.g. inner array-of-struct
+    // field names) in Databricks.
+    buildNamedStructExpression(fieldList) {
+        return ('named_struct(' +
+            fieldList.map(f => `'${f.rawName}', ${f.sqlExpression}`).join(', ') +
+            ')');
+    }
+    sqlAggregateTurtle(groupSet, fieldList, orderBy) {
+        const namedStruct = this.buildNamedStructExpression(fieldList);
+        const collectExpr = `COLLECT_LIST(${namedStruct}) FILTER (WHERE group_set=${groupSet})`;
+        if (!orderBy || orderBy.length === 0) {
+            return collectExpr;
+        }
+        return `ARRAY_SORT(${collectExpr}, (l, r) -> ${this.buildArraySortComparator(orderBy)})`;
+    }
+    // Build a lambda comparator for ARRAY_SORT that handles multi-field
+    // mixed-direction ordering. Each field comparison returns -1/0/1;
+    // fields are chained so that ties on earlier fields fall through to
+    // later fields.
+    buildArraySortComparator(orderBy) {
+        const result = orderBy.reduceRight((fallthrough, ob) => {
+            const asc = ob.dir === 'asc';
+            const lt = asc ? -1 : 1;
+            const gt = asc ? 1 : -1;
+            const f = ob.structField;
+            return [
+                'CASE',
+                `  WHEN l.${f} IS NULL AND r.${f} IS NULL THEN ${fallthrough}`,
+                `  WHEN l.${f} IS NULL THEN 1`,
+                `  WHEN r.${f} IS NULL THEN -1`,
+                `  WHEN l.${f} < r.${f} THEN ${lt}`,
+                `  WHEN l.${f} > r.${f} THEN ${gt}`,
+                `  ELSE ${fallthrough}`,
+                'END',
+            ].join('\n');
+        }, '0');
+        return result;
+    }
+    sqlAnyValueTurtle(groupSet, fieldList) {
+        const namedStruct = this.buildNamedStructExpression(fieldList);
+        return `FIRST(CASE WHEN group_set=${groupSet} THEN ${namedStruct} END) IGNORE NULLS`;
+    }
+    sqlAnyValueLastTurtle(name, groupSet, sqlName) {
+        return `FIRST(CASE WHEN group_set=${groupSet} THEN ${name} END) IGNORE NULLS as ${sqlName}`;
+    }
+    sqlCoaleseMeasuresInline(groupSet, fieldList) {
+        const namedStruct = this.buildNamedStructExpression(fieldList);
+        const nullStruct = 'named_struct(' +
+            fieldList.map(f => `'${f.rawName}', NULL`).join(', ') +
+            ')';
+        return `COALESCE(FIRST(CASE WHEN group_set=${groupSet} THEN ${namedStruct} END) IGNORE NULLS, ${nullStruct})`;
+    }
+    // Use LATERAL VIEW EXPLODE instead of LEFT JOIN LATERAL EXPLODE.
+    // LEFT JOIN LATERAL EXPLODE has a Databricks bug where struct field
+    // access on the exploded column returns null.
+    sqlUnnestAlias(source, alias, _fieldList, needDistinctKey, isArray, _isInNestedPipeline) {
+        if (isArray) {
+            if (needDistinctKey) {
+                return `LATERAL VIEW OUTER POSEXPLODE(${source}) ${alias} AS __row_id_from_${alias}, value`;
+            }
+            return `LATERAL VIEW OUTER EXPLODE(${source}) ${alias} AS value`;
+        }
+        if (needDistinctKey) {
+            return `LATERAL VIEW OUTER POSEXPLODE(${source}) ${alias}_outer AS __row_id_from_${alias}, ${alias}`;
+        }
+        return `LATERAL VIEW OUTER EXPLODE(${source}) ${alias}_outer AS ${alias}`;
+    }
+    sqlUnnestPipelineHead(isSingleton, sourceSQLExpression, _fieldList) {
+        let p = sourceSQLExpression;
+        if (isSingleton) {
+            p = `ARRAY(${p})`;
+        }
+        return `EXPLODE(${p})`;
+    }
+    // Two-chunk MD5 hash: upper 15 hex chars * 4294967296 + lower 8 hex chars
+    // gives ~88 bits of entropy, matching the pattern used by Snowflake/Trino.
+    sqlSumDistinctHashedKey(sqlDistinctKey) {
+        const castKey = `CAST(${sqlDistinctKey} AS STRING)`;
+        const upper = `CAST(CONV(SUBSTRING(MD5(${castKey}), 1, 15), 16, 10) AS DECIMAL(38,0)) * 4294967296`;
+        const lower = `CAST(CONV(SUBSTRING(MD5(${castKey}), 16, 8), 16, 10) AS DECIMAL(38,0))`;
+        return `(${upper} + ${lower})`;
+    }
+    // Scale the value to integer before adding to hash, then divide after
+    // subtraction. This keeps all arithmetic in integer space and avoids
+    // DECIMAL precision/overflow issues (Databricks max is DECIMAL(38,x)).
+    sqlSumDistinct(key, value, funcName) {
+        const hashKey = this.sqlSumDistinctHashedKey(key);
+        const scale = 100000000.0;
+        const v = `CAST(COALESCE(${value},0)*${scale} AS DECIMAL(38,0))`;
+        const sqlSum = `(SUM(DISTINCT ${hashKey} + ${v}) - SUM(DISTINCT ${hashKey}))/${scale}`;
+        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}`);
+    }
+    sqlStringAggDistinct(distinctKey, valueSQL, separatorSQL) {
+        const sep = separatorSQL.length > 0 ? separatorSQL : "','";
+        return `ARRAY_JOIN(TRANSFORM(COLLECT_SET(NAMED_STRUCT('k', ${distinctKey}, 'v', ${valueSQL})), x -> x.v), ${sep})`;
+    }
+    sqlGenerateUUID() {
+        return 'UUID()';
+    }
+    sqlFieldReference(parentAlias, _parentType, childName, _childType) {
+        if (childName === '__row_id') {
+            return `__row_id_from_${parentAlias}`;
+        }
+        return `${parentAlias}.${this.sqlMaybeQuoteIdentifier(childName)}`;
+    }
+    sqlCreateFunction(id, funcText) {
+        return `CREATE TEMPORARY FUNCTION ${id}(param STRING) RETURNS STRING RETURN (\n${(0, utils_1.indent)(funcText)}\n);\n`;
+    }
+    sqlCreateFunctionCombineLastStage(lastStageName, fieldList) {
+        const namedStruct = this.buildNamedStructExpression(fieldList);
+        return `SELECT COLLECT_LIST(${namedStruct}) FROM ${lastStageName}\n`;
+    }
+    sqlSelectAliasAsStruct(alias, fieldList) {
+        const fields = fieldList
+            .map(f => `${alias}.${this.sqlMaybeQuoteIdentifier(f.rawName)}`)
+            .join(', ');
+        return `STRUCT(${fields})`;
+    }
+    sqlMaybeQuoteIdentifier(identifier) {
+        return '`' + identifier.replace(/`/g, '``') + '`';
+    }
+    sqlCreateTableAsSelect(tableName, sql) {
+        return `CREATE TABLE ${tableName} AS ${sql}`;
+    }
+    sqlNowExpr() {
+        return 'CURRENT_TIMESTAMP()';
+    }
+    sqlConvertToCivilTime(expr, timezone, _typeDef) {
+        // 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}')`,
+            typeDef: { type: 'timestamp' },
+        };
+    }
+    sqlConvertFromCivilTime(expr, timezone, _destTypeDef) {
+        // Convert from local timezone back to UTC
+        return `TO_UTC_TIMESTAMP(${expr}, '${timezone}')`;
+    }
+    sqlTruncate(expr, unit, _typeDef, _inCivilTime, _timezone) {
+        // Databricks DATE_TRUNC starts weeks on Monday; Malloy wants Sunday.
+        // Add 1 day before truncating, subtract 1 day after.
+        if (unit === 'week') {
+            return `(DATE_TRUNC('${unit}', ${expr} + INTERVAL 1 DAY) - INTERVAL 1 DAY)`;
+        }
+        return `DATE_TRUNC('${unit}', ${expr})`;
+    }
+    sqlOffsetTime(expr, op, magnitude, unit, _typeDef, _inCivilTime, _timezone) {
+        // Use TIMESTAMPADD which accepts expressions for magnitude,
+        // unlike INTERVAL which only accepts literals in Databricks.
+        let offsetUnit = unit.toUpperCase();
+        let offsetMag = magnitude;
+        if (unit === 'quarter') {
+            offsetUnit = 'MONTH';
+            offsetMag = `(${magnitude})*3`;
+        }
+        else if (unit === 'week') {
+            offsetUnit = 'DAY';
+            offsetMag = `(${magnitude})*7`;
+        }
+        const n = op === '+' ? offsetMag : `-(${offsetMag})`;
+        return `TIMESTAMPADD(${offsetUnit}, ${n}, ${expr})`;
+    }
+    sqlTimeExtractExpr(qi, te) {
+        const units = extractionMap[te.units] || te.units;
+        let extractFrom = te.e.sql;
+        if (malloy_types_1.TD.isTimestamp(te.e.typeDef)) {
+            const tz = (0, dialect_1.qtz)(qi);
+            if (tz) {
+                extractFrom = `FROM_UTC_TIMESTAMP(${extractFrom}, '${tz}')`;
+            }
+        }
+        if (extractionMap[te.units]) {
+            // DAYOFWEEK, DAYOFYEAR are functions
+            return `${units}(${extractFrom})`;
+        }
+        return `EXTRACT(${units} FROM ${extractFrom})`;
+    }
+    sqlCast(qi, cast) {
+        const srcSQL = cast.e.sql || 'internal-error-in-sql-generation';
+        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)`;
+        }
+        else if (op === 'date::timestamp' && tz) {
+            return `TO_UTC_TIMESTAMP(CAST(${srcSQL} AS TIMESTAMP_NTZ), '${tz}')`;
+        }
+        if (!malloy_types_1.TD.eq(srcTypeDef, dstTypeDef)) {
+            if (cast.safe) {
+                return `TRY_CAST(${srcSQL} AS ${dstSQLType})`;
+            }
+            if (malloy_types_1.TD.isString(dstTypeDef)) {
+                return `CAST(${srcSQL} AS STRING)`;
+            }
+            return `CAST(${srcSQL} AS ${dstSQLType})`;
+        }
+        return srcSQL;
+    }
+    sqlRegexpMatch(df) {
+        return `REGEXP_LIKE(${df.kids.expr.sql}, ${df.kids.regex.sql})`;
+    }
+    sqlDateLiteral(_qi, literal) {
+        return `DATE '${literal}'`;
+    }
+    sqlTimestampLiteral(qi, literal, timezone) {
+        const tz = timezone || (0, dialect_1.qtz)(qi);
+        if (tz) {
+            return `TO_UTC_TIMESTAMP(TIMESTAMP_NTZ '${literal}', '${tz}')`;
+        }
+        return `TIMESTAMP '${literal}'`;
+    }
+    sqlTimestamptzLiteral(_qi, _literal, _timezone) {
+        throw new Error('Databricks does not support timestamptz');
+    }
+    sqlMeasureTimeExpr(df) {
+        let lVal = df.kids.left.sql;
+        let rVal = df.kids.right.sql;
+        if (inSeconds[df.units]) {
+            lVal = `UNIX_MICROS(CAST(${lVal} AS TIMESTAMP))`;
+            rVal = `UNIX_MICROS(CAST(${rVal} AS TIMESTAMP))`;
+            const duration = `(${rVal}-${lVal})`;
+            const divisor = inSeconds[df.units] * 1000000;
+            return `FLOOR(${duration}/${divisor}.0)`;
+        }
+        throw new Error(`Unknown or unhandled Databricks time unit: ${df.units}`);
+    }
+    sqlSampleTable(tableSQL, sample) {
+        if (sample !== undefined) {
+            if ((0, malloy_types_1.isSamplingEnable)(sample) && sample.enable) {
+                sample = this.defaultSampling;
+            }
+            if ((0, malloy_types_1.isSamplingRows)(sample)) {
+                return `(SELECT * FROM ${tableSQL} LIMIT ${sample.rows})`;
+            }
+            else if ((0, malloy_types_1.isSamplingPercent)(sample)) {
+                return `(SELECT * FROM ${tableSQL} TABLESAMPLE (${sample.percent} PERCENT))`;
+            }
+        }
+        return tableSQL;
+    }
+    sqlLiteralString(literal) {
+        const noVirgule = literal.replace(/\\/g, '\\\\');
+        return "'" + noVirgule.replace(/'/g, "\\'") + "'";
+    }
+    sqlLiteralRegexp(literal) {
+        return "'" + literal.replace(/'/g, "''") + "'";
+    }
+    getDialectFunctionOverrides() {
+        return (0, functions_1.expandOverrideMap)(function_overrides_1.DATABRICKS_MALLOY_STANDARD_OVERLOADS);
+    }
+    getDialectFunctions() {
+        return (0, functions_1.expandBlueprintMap)(dialect_functions_1.DATABRICKS_DIALECT_FUNCTIONS);
+    }
+    castToString(expression) {
+        return `CAST(${expression} AS STRING)`;
+    }
+    concat(...values) {
+        return `CONCAT(${values.join(',')})`;
+    }
+    validateTypeName(sqlType) {
+        return sqlType.match(/^[A-Za-z\s(),0-9_]*$/) !== null;
+    }
+    sqlLiteralArray(lit) {
+        const array = lit.kids.values.map(val => val.sql);
+        return `ARRAY(${array.join(',')})`;
+    }
+    sqlLiteralRecord(lit) {
+        const pairs = Object.entries(lit.kids).map(([propName, propVal]) => `${this.sqlLiteralString(propName)}, ${propVal.sql}`);
+        return `NAMED_STRUCT(${pairs.join(', ')})`;
+    }
+}
+exports.DatabricksDialect = DatabricksDialect;
+//# sourceMappingURL=databricks.js.map

package/dist/dialect/databricks/dialect_functions.d.ts

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

package/dist/dialect/databricks/dialect_functions.js

@@ -0,0 +1,67 @@
+"use strict";
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DATABRICKS_DIALECT_FUNCTIONS = void 0;
+const util_1 = require("../functions/util");
+/*
+ * Databricks dialect function definitions.
+ *
+ * For simple functions, use the def() shorthand with the T convention:
+ *   ...def('func_name', {'arg': 'type'}, 'return_type')
+ *
+ * For functions needing SQL templates or multiple overloads,
+ * use full DefinitionBlueprint / OverloadedDefinitionBlueprint objects.
+ */
+// Shortcut so you can write things like: {array: T} and {dimension: T}
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const T = { generic: 'T' };
+// Databricks COLLECT_LIST/COLLECT_SET do not support ORDER BY inside
+// the aggregate call. Ordering is not supported for string_agg on
+// Databricks. See databricks-string-agg.md for details.
+const string_agg = {
+    default_separator: {
+        takes: { 'value': { dimension: 'string' } },
+        returns: { measure: 'string' },
+        impl: {
+            sql: "ARRAY_JOIN(COLLECT_LIST(${value}), ',')",
+        },
+    },
+    with_separator: {
+        takes: {
+            'value': { dimension: 'string' },
+            'separator': { literal: 'string' },
+        },
+        returns: { measure: 'string' },
+        impl: {
+            sql: 'ARRAY_JOIN(COLLECT_LIST(${value}), ${separator})',
+        },
+    },
+};
+const string_agg_distinct = {
+    default_separator: {
+        ...string_agg['default_separator'],
+        isSymmetric: true,
+        impl: {
+            sql: "ARRAY_JOIN(COLLECT_SET(${value}), ',')",
+        },
+    },
+    with_separator: {
+        ...string_agg['with_separator'],
+        isSymmetric: true,
+        impl: {
+            sql: 'ARRAY_JOIN(COLLECT_SET(${value}), ${separator})',
+        },
+    },
+};
+exports.DATABRICKS_DIALECT_FUNCTIONS = {
+    // Aggregate functions
+    string_agg,
+    string_agg_distinct,
+    // Scalar functions
+    ...(0, util_1.def)('repeat', { 'str': 'string', 'n': 'number' }, 'string'),
+    ...(0, util_1.def)('reverse', { 'str': 'string' }, 'string'),
+};
+//# sourceMappingURL=dialect_functions.js.map

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

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

package/dist/dialect/databricks/function_overrides.js

@@ -0,0 +1,68 @@
+"use strict";
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DATABRICKS_MALLOY_STANDARD_OVERLOADS = void 0;
+// Template strings use ${...values} for Malloy parameter interpolation.
+// The ELSE branch uses a JS template literal to inject `name`, so the
+// Malloy parameter reference must be escaped as \${...values}.
+function greatestOrLeastSQL(name) {
+    return ('CASE' +
+        ' WHEN SIZE(FILTER(ARRAY(${...values}), x -> x IS NULL)) > 0' +
+        ' THEN NULL' +
+        ` ELSE ${name}(\${...values})` +
+        ' END');
+}
+exports.DATABRICKS_MALLOY_STANDARD_OVERLOADS = {
+    // Databricks REGEXP_EXTRACT defaults to group index 1 (first capture group),
+    // but Malloy expects the full match (group 0). Explicitly pass idx=0.
+    regexp_extract: { sql: 'REGEXP_EXTRACT(${value}, ${pattern}, 0)' },
+    replace: {
+        regular_expression: {
+            sql: 'REGEXP_REPLACE(${value}, ${pattern}, ${replacement})',
+        },
+    },
+    trunc: {
+        to_integer: {
+            sql: 'CAST(${value} AS BIGINT)',
+        },
+        to_precision: {
+            sql: '(ABS(FLOOR(${value} * POW(10,${precision}))/POW(10,${precision}))*IF(${value} < 0, -1, 1))',
+        },
+    },
+    log: { sql: 'LOG(${base},${value})' },
+    div: { sql: 'FLOOR(${dividend} / ${divisor})' },
+    strpos: { sql: 'LOCATE(${search_string},${test_string})' },
+    starts_with: { sql: 'COALESCE(STARTSWITH(${value},${prefix}), false)' },
+    ends_with: { sql: 'COALESCE(ENDSWITH(${value},${suffix}), false)' },
+    trim: {
+        characters: {
+            sql: 'TRIM(BOTH ${trim_characters} FROM ${value})',
+        },
+    },
+    ltrim: {
+        characters: {
+            sql: 'TRIM(LEADING ${trim_characters} FROM ${value})',
+        },
+    },
+    rtrim: {
+        characters: {
+            sql: 'TRIM(TRAILING ${trim_characters} FROM ${value})',
+        },
+    },
+    byte_length: { sql: 'OCTET_LENGTH(${value})' },
+    chr: { sql: 'CHR(${value})' },
+    // Databricks has no IS_INF/IS_NAN functions; compare to special float values
+    is_inf: {
+        sql: "COALESCE(${value} = DOUBLE('infinity') OR ${value} = DOUBLE('-infinity'), false)",
+    },
+    is_nan: { sql: "COALESCE(${value} = DOUBLE('NaN'), false)" },
+    // Databricks ASCII() returns the Unicode codepoint of the first character
+    unicode: { function: 'ASCII' },
+    // Databricks GREATEST/LEAST skip nulls; Malloy expects null propagation
+    greatest: { sql: greatestOrLeastSQL('GREATEST') },
+    least: { sql: greatestOrLeastSQL('LEAST') },
+};
+//# sourceMappingURL=function_overrides.js.map

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

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