ts-prorm-orm 1.1.0

package/dist/dialects/databricks/index.js

@@ -0,0 +1,517 @@
+"use strict";
+/**
+ * Databricks SQL dialect implementation for the TypeScript ORM.
+ *
+ * Databricks SQL is built on Apache Spark SQL and the Delta Lake table format
+ * (a.k.a. the "lakehouse"). It uses backtick-quoted identifiers, exactly like
+ * MySQL/Spark SQL, so this dialect EXTENDS {@link MySQLDialect} purely to reuse
+ * the backtick quoting/escaping scaffolding and the general query-building
+ * skeleton, then overrides the pieces where Spark/Delta grammar genuinely
+ * differs from MySQL. A real deployment would connect over the Databricks SQL
+ * driver (Databricks SQL Warehouse / `@databricks/sql`) rather than mysql2 —
+ * the inherited connection code is not used against a real cluster.
+ *
+ * Notable differences from MySQL that this dialect overrides:
+ *
+ * - Default port is 443 (Databricks SQL Warehouses are reached over HTTPS),
+ *   not 3306.
+ * - CREATE TABLE emits Delta/Spark grammar: `USING DELTA` (the table's data
+ *   source/format, default DELTA; also PARQUET/CSV/JSON/etc.), `PARTITIONED BY
+ *   (cols)`, `CLUSTERED BY (cols) INTO n BUCKETS`, `TBLPROPERTIES (...)`,
+ *   `LOCATION 's3://...'` (external/unmanaged tables), and a trailing
+ *   `COMMENT '...'`. There is no MySQL `ENGINE=`/`ROW_FORMAT=`/charset concept.
+ * - CTAS: {@link DatabricksDialect.buildCreateTableAsSelect} emits
+ *   `CREATE TABLE ... USING DELTA AS SELECT ...`.
+ * - Upsert is expressed as a Delta Lake `MERGE INTO target USING source ON ...
+ *   WHEN MATCHED THEN UPDATE SET ... WHEN NOT MATCHED THEN INSERT ...`
+ *   statement (see {@link DatabricksDialect.buildUpsertQuery}) rather than
+ *   MySQL's `INSERT ... ON DUPLICATE KEY UPDATE`.
+ * - Auto-increment columns use Delta's `GENERATED ALWAYS AS IDENTITY` identity
+ *   columns instead of MySQL's `AUTO_INCREMENT`.
+ * - Type mapping uses Spark SQL types: `STRING` (there is no `VARCHAR`/`TEXT`),
+ *   `BIGINT`, `INT`, `DOUBLE`, `FLOAT`, `BOOLEAN`, `TIMESTAMP`, `DATE`,
+ *   `BINARY`, `DECIMAL(p,s)`, and the complex types `ARRAY<>`, `MAP<>`,
+ *   `STRUCT<>` (see {@link DatabricksDialect.getDataTypeSql}).
+ * - PRIMARY KEY / FOREIGN KEY constraints in Databricks are INFORMATIONAL only
+ *   (they are declared `NOT ENFORCED` and used by the optimizer for query
+ *   planning); they do not enforce uniqueness or referential integrity. This
+ *   dialect emits them inline as informational constraints and never relies on
+ *   them for correctness.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatabricksDialect = void 0;
+exports.createDatabricksDialect = createDatabricksDialect;
+const index_1 = require("../mysql/index");
+const prorm_1 = require("../../prorm");
+/**
+ * Databricks SQL dialect. See the file header for the full list of
+ * Spark/Delta-specific overrides.
+ */
+class DatabricksDialect extends index_1.MySQLDialect {
+    constructor(config) {
+        // Databricks SQL Warehouses are reached over HTTPS on port 443.
+        super({ port: 443, ...config });
+        this.name = 'databricks';
+    }
+    /**
+     * Map an ORM {@link DataType} to a Spark SQL / Delta type. The key
+     * difference from MySQL is that character types collapse to `STRING`
+     * (Spark SQL has no `VARCHAR(n)`/`TEXT`), and the complex types
+     * `ARRAY<>`/`MAP<>`/`STRUCT<>` are supported.
+     */
+    getDataTypeSql(dataType) {
+        if (typeof dataType === 'string') {
+            const upper = dataType.trim().toUpperCase();
+            // Normalize MySQL-ish character types written as raw strings to STRING.
+            if (/^(VARCHAR|CHARACTER VARYING|NVARCHAR|CHAR|N?TEXT|TINYTEXT|MEDIUMTEXT|LONGTEXT|CLOB)\b/.test(upper)) {
+                return 'STRING';
+            }
+            return dataType;
+        }
+        if (!dataType || typeof dataType !== 'object') {
+            return 'STRING';
+        }
+        const dt = dataType;
+        switch (dt.key) {
+            case 'STRING':
+            case 'CHAR':
+            case 'TEXT':
+            case 'ENUM':
+            case 'SET':
+            case 'UUID':
+            case 'JSON':
+            case 'JSONB':
+                // Spark SQL has no VARCHAR/TEXT/ENUM/JSON column types; store as STRING.
+                return 'STRING';
+            case 'INTEGER':
+                if (dt.length === 1)
+                    return 'TINYINT';
+                if (dt.length === 2)
+                    return 'SMALLINT';
+                if (dt.length === 8)
+                    return 'BIGINT';
+                return 'INT';
+            case 'BIGINT':
+                return 'BIGINT';
+            case 'FLOAT':
+                return 'FLOAT';
+            case 'DOUBLE':
+                return 'DOUBLE';
+            case 'DECIMAL':
+                return `DECIMAL(${dt.precision || 10},${dt.scale || 0})`;
+            case 'BOOLEAN':
+                return 'BOOLEAN';
+            case 'DATE':
+                // A full timestamp (date + time) maps to Spark TIMESTAMP.
+                return 'TIMESTAMP';
+            case 'DATEONLY':
+                return 'DATE';
+            case 'TIME':
+                // Spark SQL has no standalone TIME type; represent as STRING.
+                return 'STRING';
+            case 'BLOB':
+                return 'BINARY';
+            case 'ARRAY':
+                return `ARRAY<${this.getComplexElementType(dt.type)}>`;
+            case 'MAP':
+                return `MAP<${this.getComplexElementType(dt.keyType) || 'STRING'}, ${this.getComplexElementType(dt.valueType)}>`;
+            case 'STRUCT': {
+                const fields = dt.fields || {};
+                const fieldSql = Object.entries(fields)
+                    .map(([name, type]) => `${name}: ${this.getDataTypeSql(type)}`)
+                    .join(', ');
+                return `STRUCT<${fieldSql}>`;
+            }
+            default:
+                // Anything not explicitly Spark-mapped falls through to STRING rather
+                // than an unsupported MySQL type like VARCHAR(255).
+                return 'STRING';
+        }
+    }
+    /**
+     * Resolve the element/value type for a complex (ARRAY/MAP) type, defaulting
+     * to `STRING` when the element type is unspecified.
+     */
+    getComplexElementType(type) {
+        if (type === undefined || type === null) {
+            return 'STRING';
+        }
+        return this.getDataTypeSql(type);
+    }
+    /**
+     * Build a single column definition for a Databricks CREATE TABLE. Emits
+     * Delta `GENERATED ALWAYS AS IDENTITY` for auto-increment columns and an
+     * informational (not-enforced) inline `PRIMARY KEY` where requested.
+     */
+    buildColumnDefinitionSql(columnName, definition) {
+        let sql = `${this.escapeId(columnName)} ${this.getDataTypeSql(definition.type)}`;
+        if (definition.allowNull === false) {
+            sql += ' NOT NULL';
+        }
+        if (definition.autoIncrement) {
+            // Delta identity columns; there is no MySQL-style AUTO_INCREMENT.
+            sql += ' GENERATED ALWAYS AS IDENTITY';
+        }
+        if (definition.defaultValue !== undefined && !definition.autoIncrement) {
+            sql += ` DEFAULT ${this.escape(definition.defaultValue)}`;
+        }
+        if (definition.primaryKey) {
+            // Informational only in Databricks (declared NOT ENFORCED). Kept for
+            // optimizer hints; never relied on for uniqueness.
+            sql += ' PRIMARY KEY';
+        }
+        if (definition.comment) {
+            sql += ` COMMENT ${this.escape(definition.comment)}`;
+        }
+        return sql;
+    }
+    /**
+     * Build the `CREATE TABLE` statement using Delta/Spark grammar. Exposed
+     * synchronously (separate from the async {@link createTable}) so callers can
+     * inspect the generated SQL without a live connection.
+     */
+    buildCreateTableSql(tableName, columns, options) {
+        const columnDefs = Object.entries(columns).map(([name, def]) => this.buildColumnDefinitionSql(name, def));
+        let sql = 'CREATE TABLE';
+        if (options?.ifNotExists) {
+            sql += ' IF NOT EXISTS';
+        }
+        sql += ` ${this.escapeId(tableName)} (${columnDefs.join(', ')})`;
+        // Data source / format. Delta is the default when unspecified.
+        const format = options?.using || 'DELTA';
+        sql += ` USING ${format}`;
+        if (options?.partitionedBy && options.partitionedBy.length > 0) {
+            sql += ` PARTITIONED BY (${options.partitionedBy.map((c) => this.escapeId(c)).join(', ')})`;
+        }
+        if (options?.clusteredBy && options.clusteredBy.columns.length > 0) {
+            const cols = options.clusteredBy.columns.map((c) => this.escapeId(c)).join(', ');
+            sql += ` CLUSTERED BY (${cols}) INTO ${options.clusteredBy.buckets} BUCKETS`;
+        }
+        if (options?.location) {
+            sql += ` LOCATION ${this.escape(options.location)}`;
+        }
+        if (options?.comment) {
+            sql += ` COMMENT ${this.escape(options.comment)}`;
+        }
+        if (options?.tblproperties && Object.keys(options.tblproperties).length > 0) {
+            const props = Object.entries(options.tblproperties)
+                .map(([k, v]) => `'${k}'=${this.escape(v)}`)
+                .join(', ');
+            sql += ` TBLPROPERTIES (${props})`;
+        }
+        return sql;
+    }
+    /**
+     * Create a table using Delta/Spark grammar. Delegates SQL generation to
+     * {@link buildCreateTableSql} and executes it.
+     */
+    async createTable(tableName, columns, options) {
+        await this.query(this.buildCreateTableSql(tableName, columns, options));
+    }
+    /**
+     * Build a `CREATE TABLE ... USING <format> AS SELECT ...` (CTAS) statement.
+     * The column list and types are inferred from the SELECT, so only the format
+     * and (optionally) partitioning/location apply.
+     */
+    buildCreateTableAsSelect(tableName, selectQuery, options) {
+        let sql = 'CREATE TABLE';
+        if (options?.ifNotExists) {
+            sql += ' IF NOT EXISTS';
+        }
+        sql += ` ${this.escapeId(tableName)}`;
+        sql += ` USING ${options?.using || 'DELTA'}`;
+        if (options?.partitionedBy && options.partitionedBy.length > 0) {
+            sql += ` PARTITIONED BY (${options.partitionedBy.map((c) => this.escapeId(c)).join(', ')})`;
+        }
+        if (options?.location) {
+            sql += ` LOCATION ${this.escape(options.location)}`;
+        }
+        if (options?.comment) {
+            sql += ` COMMENT ${this.escape(options.comment)}`;
+        }
+        if (options?.tblproperties && Object.keys(options.tblproperties).length > 0) {
+            const props = Object.entries(options.tblproperties)
+                .map(([k, v]) => `'${k}'=${this.escape(v)}`)
+                .join(', ');
+            sql += ` TBLPROPERTIES (${props})`;
+        }
+        sql += ` AS ${selectQuery.trim().replace(/;\s*$/, '')}`;
+        return sql;
+    }
+    /**
+     * Build a Delta Lake `MERGE INTO` upsert. Delta has no MySQL-style
+     * `ON DUPLICATE KEY UPDATE`; instead the row(s) to upsert are supplied as an
+     * inline `source` relation and matched against the target on the conflict
+     * (key) columns:
+     *
+     *   MERGE INTO `t` AS target
+     *   USING (SELECT ? AS `id`, ? AS `name`) AS source
+     *   ON target.`id` = source.`id`
+     *   WHEN MATCHED THEN UPDATE SET target.`name` = source.`name`
+     *   WHEN NOT MATCHED THEN INSERT (`id`, `name`) VALUES (source.`id`, source.`name`)
+     *
+     * @param tableName - Target table.
+     * @param values - Column/value pairs for the row to upsert.
+     * @param options - `conflictFields` picks the ON/match key columns (defaults
+     *   to all columns); `updateOnDuplicate` restricts which columns the
+     *   WHEN MATCHED branch updates (defaults to all non-key columns).
+     */
+    buildUpsertQuery(tableName, values, options) {
+        if (options?.returning) {
+            // Delta MERGE does not support a RETURNING clause; re-select instead.
+            throw new Error('Databricks (Delta MERGE) does not support the RETURNING clause. Re-fetch the row after the upsert instead.');
+        }
+        const columns = Object.keys(values);
+        if (columns.length === 0) {
+            throw new Error('buildUpsertQuery requires at least one column to upsert.');
+        }
+        const processedValues = [];
+        // Build the inline source relation: SELECT ? AS `col`, ...
+        const sourceSelect = columns
+            .map((col) => {
+            const value = values[col];
+            if (value instanceof prorm_1.Literal) {
+                return `${value.val} AS ${this.escapeId(col)}`;
+            }
+            processedValues.push(value);
+            return `? AS ${this.escapeId(col)}`;
+        })
+            .join(', ');
+        const conflictFields = options?.conflictFields && options.conflictFields.length > 0
+            ? options.conflictFields
+            : columns;
+        const onClause = conflictFields
+            .map((c) => `target.${this.escapeId(c)} = source.${this.escapeId(c)}`)
+            .join(' AND ');
+        // Columns to update when matched: explicit list, or everything that isn't
+        // part of the match key.
+        const updateFields = options?.updateOnDuplicate && options.updateOnDuplicate.length > 0
+            ? options.updateOnDuplicate
+            : columns.filter((c) => !conflictFields.includes(c));
+        const target = this.escapeId(tableName);
+        let sql = `MERGE INTO ${target} AS target USING (SELECT ${sourceSelect}) AS source ON ${onClause}`;
+        if (updateFields.length > 0) {
+            const setClause = updateFields
+                .map((c) => `target.${this.escapeId(c)} = source.${this.escapeId(c)}`)
+                .join(', ');
+            sql += ` WHEN MATCHED THEN UPDATE SET ${setClause}`;
+        }
+        const insertCols = columns.map((c) => this.escapeId(c)).join(', ');
+        const insertVals = columns.map((c) => `source.${this.escapeId(c)}`).join(', ');
+        sql += ` WHEN NOT MATCHED THEN INSERT (${insertCols}) VALUES (${insertVals})`;
+        return { sql, values: processedValues };
+    }
+    // ---------------------------------------------------------------------------
+    // CRUD overrides — Spark SQL / Delta diverges from MySQL here.
+    // ---------------------------------------------------------------------------
+    /**
+     * Build a `LIMIT`/`OFFSET` tail. Spark SQL supports `LIMIT n` and, since
+     * Spark 3.4 / Databricks Runtime 11+, a standalone `OFFSET n` (with or
+     * without a preceding `LIMIT`). Unlike MySQL there is NO need for the
+     * `LIMIT 18446744073709551615 OFFSET n` sentinel trick — Spark accepts
+     * `OFFSET` on its own — so this override drops that MySQL-only hack.
+     *
+     * NOTE: `OFFSET` is only valid on the outermost query and requires a
+     * recent Spark/DBR; on older runtimes it raises a parser error. For deep
+     * pagination prefer a keyset/`WHERE` predicate over large offsets.
+     */
+    buildLimitOffset(limit, offset) {
+        let sql = '';
+        if (limit !== undefined) {
+            sql += ` LIMIT ${Number(limit)}`;
+        }
+        if (offset !== undefined) {
+            sql += ` OFFSET ${Number(offset)}`;
+        }
+        return sql;
+    }
+    /**
+     * Build an INSERT. A plain insert (`INSERT INTO t (cols) VALUES (...)`) is
+     * valid Spark SQL and reuses the inherited MySQL builder verbatim. When the
+     * caller sets `upsert`, MySQL would emit `... ON DUPLICATE KEY UPDATE`, which
+     * Spark/Delta rejects — so route to a Delta `MERGE INTO` instead.
+     */
+    buildInsertQuery(tableName, values, options) {
+        if (options?.upsert) {
+            return this.buildUpsertQuery(tableName, values, {
+                conflictFields: options.conflictFields,
+                updateOnDuplicate: options.updateOnDuplicate,
+            });
+        }
+        return super.buildInsertQuery(tableName, values);
+    }
+    /**
+     * Build an UPDATE. Delta Lake supports `UPDATE t SET ... WHERE ...`, but
+     * (unlike MySQL) it does NOT support a trailing `LIMIT` on UPDATE, nor a
+     * `RETURNING` clause. Strip `LIMIT` and reject `RETURNING` rather than emit
+     * SQL Spark would reject.
+     */
+    buildUpdateQuery(tableName, values, where, options) {
+        if (options?.returning) {
+            throw new Error('Databricks (Delta) does not support RETURNING on UPDATE. Re-fetch the rows after the update instead.');
+        }
+        // Reuse the inherited builder but never emit LIMIT (Delta UPDATE has none).
+        return super.buildUpdateQuery(tableName, values, where, { ...options, limit: undefined });
+    }
+    /**
+     * Build a DELETE. Delta Lake supports `DELETE FROM t WHERE ...`, but not a
+     * trailing `LIMIT` or `RETURNING`. Strip `LIMIT` and reject `RETURNING`.
+     */
+    buildDeleteQuery(tableName, where, options) {
+        if (options?.returning) {
+            throw new Error('Databricks (Delta) does not support RETURNING on DELETE. Re-fetch/track the rows before deleting instead.');
+        }
+        return super.buildDeleteQuery(tableName, where, { ...options, limit: undefined });
+    }
+    // ---------------------------------------------------------------------------
+    // DDL overrides — Spark ALTER TABLE grammar differs from MySQL.
+    // ---------------------------------------------------------------------------
+    /**
+     * Column spec for `ALTER TABLE ... ADD COLUMNS`. Spark only accepts
+     * `name type [COMMENT '...']` (optionally `FIRST`/`AFTER col`) here — it does
+     * NOT accept `NOT NULL`, `DEFAULT`, `PRIMARY KEY`, or identity clauses on an
+     * added column, so those are intentionally omitted (unlike the full CREATE
+     * TABLE column definition).
+     */
+    buildAddColumnSpecSql(columnName, definition) {
+        let sql = `${this.escapeId(columnName)} ${this.getDataTypeSql(definition.type)}`;
+        if (definition.comment) {
+            sql += ` COMMENT ${this.escape(definition.comment)}`;
+        }
+        return sql;
+    }
+    /**
+     * Build `ALTER TABLE t ADD COLUMNS (col type ...)`. Spark uses the plural
+     * `ADD COLUMNS (...)` with a parenthesised list — NOT MySQL's singular
+     * `ADD COLUMN col ...`.
+     */
+    buildAddColumnSql(tableName, columnName, definition) {
+        return `ALTER TABLE ${this.escapeId(tableName)} ADD COLUMNS (${this.buildAddColumnSpecSql(columnName, definition)})`;
+    }
+    async addColumn(tableName, columnName, definition) {
+        await this.query(this.buildAddColumnSql(tableName, columnName, definition));
+    }
+    /**
+     * Build `ALTER TABLE t DROP COLUMN col`. Valid Delta grammar (requires Delta
+     * column-mapping mode to be enabled on the table); identical in shape to
+     * MySQL, so behaviourally inherited but surfaced as a sync builder for tests.
+     */
+    buildDropColumnSql(tableName, columnName) {
+        return `ALTER TABLE ${this.escapeId(tableName)} DROP COLUMN ${this.escapeId(columnName)}`;
+    }
+    async removeColumn(tableName, columnName) {
+        await this.query(this.buildDropColumnSql(tableName, columnName));
+    }
+    /**
+     * Build `ALTER TABLE t RENAME COLUMN old TO new`. Spark/Delta uses
+     * `RENAME COLUMN`; MySQL uses `CHANGE old new <type>` (which also requires
+     * re-stating the type). This override needs no `DESCRIBE` round-trip.
+     */
+    buildRenameColumnSql(tableName, oldColumnName, newColumnName) {
+        return `ALTER TABLE ${this.escapeId(tableName)} RENAME COLUMN ${this.escapeId(oldColumnName)} TO ${this.escapeId(newColumnName)}`;
+    }
+    async renameColumn(tableName, oldColumnName, newColumnName) {
+        await this.query(this.buildRenameColumnSql(tableName, oldColumnName, newColumnName));
+    }
+    /**
+     * Delta only supports a narrow set of in-place column alterations
+     * (comment, nullability, ordering — and, on recent runtimes, limited type
+     * widening). MySQL's `CHANGE col <full-def>` is not valid Spark SQL, so
+     * rather than emit something a cluster would reject, expose the two
+     * supported primitives explicitly and fail fast on the generic path.
+     */
+    async changeColumn(_tableName, _columnName, _definition) {
+        throw new Error('Databricks (Delta) does not support MySQL-style CHANGE COLUMN. Use renameColumn(), ' +
+            'setColumnComment(), or setColumnNullability() for the supported in-place alterations; ' +
+            'arbitrary type changes require rewriting the table.');
+    }
+    /** Build `ALTER TABLE t ALTER COLUMN col COMMENT '...'` (Delta-supported). */
+    buildSetColumnCommentSql(tableName, columnName, comment) {
+        return `ALTER TABLE ${this.escapeId(tableName)} ALTER COLUMN ${this.escapeId(columnName)} COMMENT ${this.escape(comment)}`;
+    }
+    async setColumnComment(tableName, columnName, comment) {
+        await this.query(this.buildSetColumnCommentSql(tableName, columnName, comment));
+    }
+    /**
+     * Build `ALTER TABLE t ALTER COLUMN col SET|DROP NOT NULL` (Delta-supported).
+     */
+    buildSetColumnNullabilitySql(tableName, columnName, notNull) {
+        const action = notNull ? 'SET NOT NULL' : 'DROP NOT NULL';
+        return `ALTER TABLE ${this.escapeId(tableName)} ALTER COLUMN ${this.escapeId(columnName)} ${action}`;
+    }
+    async setColumnNullability(tableName, columnName, notNull) {
+        await this.query(this.buildSetColumnNullabilitySql(tableName, columnName, notNull));
+    }
+    /**
+     * Build `DROP TABLE [IF EXISTS] t`. Spark has no `CASCADE` on `DROP TABLE`
+     * (that's a MySQL/Postgres construct), so the inherited CASCADE handling is
+     * overridden away.
+     */
+    buildDropTableSql(tableName, options) {
+        let sql = 'DROP TABLE';
+        if (options?.ifExists) {
+            sql += ' IF EXISTS';
+        }
+        sql += ` ${this.escapeId(tableName)}`;
+        return sql;
+    }
+    async dropTable(tableName, options) {
+        await this.query(this.buildDropTableSql(tableName, options));
+    }
+    /**
+     * Build `ALTER TABLE t SET TBLPROPERTIES ('k'='v', ...)` — the Delta/Spark
+     * way to change table-level options after creation.
+     */
+    buildSetTablePropertiesSql(tableName, properties) {
+        const props = Object.entries(properties)
+            .map(([k, v]) => `'${k}'=${this.escape(v)}`)
+            .join(', ');
+        return `ALTER TABLE ${this.escapeId(tableName)} SET TBLPROPERTIES (${props})`;
+    }
+    async setTableProperties(tableName, properties) {
+        await this.query(this.buildSetTablePropertiesSql(tableName, properties));
+    }
+    /** Build `ALTER TABLE t UNSET TBLPROPERTIES [IF EXISTS] ('k', ...)`. */
+    buildUnsetTablePropertiesSql(tableName, keys, ifExists = false) {
+        const list = keys.map((k) => `'${k}'`).join(', ');
+        return `ALTER TABLE ${this.escapeId(tableName)} UNSET TBLPROPERTIES ${ifExists ? 'IF EXISTS ' : ''}(${list})`;
+    }
+    async unsetTableProperties(tableName, keys, ifExists = false) {
+        await this.query(this.buildUnsetTablePropertiesSql(tableName, keys, ifExists));
+    }
+    async addIndex(_tableName, _indexName, _fields, _options) {
+        throw new Error(DatabricksDialect.INDEX_UNSUPPORTED);
+    }
+    async createIndex(_tableName, _indexDef) {
+        throw new Error(DatabricksDialect.INDEX_UNSUPPORTED);
+    }
+    async removeIndex(_tableName, _indexName) {
+        throw new Error(DatabricksDialect.INDEX_UNSUPPORTED);
+    }
+    async dropIndex(_tableName, _indexName) {
+        throw new Error(DatabricksDialect.INDEX_UNSUPPORTED);
+    }
+    async createFulltextIndex() {
+        throw new Error(DatabricksDialect.INDEX_UNSUPPORTED);
+    }
+    async createSpatialIndex() {
+        throw new Error(DatabricksDialect.INDEX_UNSUPPORTED);
+    }
+}
+exports.DatabricksDialect = DatabricksDialect;
+// ---------------------------------------------------------------------------
+// Secondary indexes — unsupported by Spark SQL / Delta.
+// ---------------------------------------------------------------------------
+// Spark SQL has no generic `CREATE INDEX`. Databricks offers only specialized
+// constructs (e.g. Bloom-filter indexes, Z-ORDER / liquid clustering) that
+// don't map to the ORM's index API. Fail fast instead of emitting the
+// inherited MySQL `CREATE INDEX ... ON ...`, which a cluster would reject.
+DatabricksDialect.INDEX_UNSUPPORTED = 'Databricks (Spark SQL / Delta) does not support generic secondary indexes ' +
+    '(CREATE INDEX). Use liquid clustering / Z-ORDER (OPTIMIZE ... ZORDER BY), ' +
+    'partitioning, or a Bloom-filter index instead.';
+/**
+ * Convenience factory mirroring the other dialects' `create*Dialect` helpers.
+ */
+function createDatabricksDialect(options) {
+    return new DatabricksDialect(options || {});
+}