ts-prorm-orm 1.1.0

package/dist/dialects/mssql/index.js

@@ -0,0 +1,2296 @@
+"use strict";
+/**
+ * MSSQL (SQL Server) dialect implementation for the TypeScript ORM
+ * Experimental implementation using the mssql driver
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MSSQLDialect = void 0;
+exports.createMSSQLDialect = createMSSQLDialect;
+const mssql_1 = require("mssql");
+const types_1 = require("../../types");
+const query_stream_helper_1 = require("../query-stream-helper");
+const prorm_1 = require("../../prorm");
+/**
+ * Default retry options for connection
+ */
+const DEFAULT_RETRY_OPTIONS = {
+    max: 3,
+    timeout: 1000,
+    match: [
+        'ECONNREFUSED',
+        'ENOTFOUND',
+        'ETIMEDOUT',
+        'Login failed',
+        'connection timeout',
+        'Too many connections',
+        'Lock wait timeout',
+    ],
+    backoff: false,
+    backoffMultiplier: 2,
+    backoffMax: 10000,
+};
+/**
+ * Table partitioning has shipped in SQL Server Standard Edition since 2016
+ * SP1 (it previously required Enterprise Edition) — the older "Enterprise
+ * Edition required" message was factually outdated. The generic
+ * partitioning API used by this ORM (declarative range/list/hash
+ * partitions) also doesn't map cleanly onto SQL Server's actual mechanism,
+ * which is `CREATE PARTITION FUNCTION` + `CREATE PARTITION SCHEME` — a
+ * structurally different, session/database-level object model rather than
+ * per-table declarative partitioning as in Postgres/MySQL. That mechanism
+ * isn't modeled here; use raw SQL via `query()` to create partition
+ * functions/schemes directly.
+ */
+const PARTITIONING_UNSUPPORTED_MESSAGE = 'Table partitioning is available in SQL Server Standard Edition (2016 SP1+) and Enterprise ' +
+    'Edition, but requires CREATE PARTITION FUNCTION / CREATE PARTITION SCHEME objects, which are ' +
+    'structurally different from declarative per-table partitioning and are not modeled by this ' +
+    'generic partitioning API. Use raw SQL via query() to create partition functions/schemes directly.';
+/**
+ * MSSQL dialect class that implements the Dialect interface
+ */
+class MSSQLDialect {
+    constructor(config) {
+        this.name = 'mssql';
+        this.library = 'mssql';
+        this.pool = null;
+        this._isConnected = false;
+        this.poolOptions = config.pool || {};
+        this.retryOptions = config.retry || {};
+        this.config = {
+            host: 'localhost',
+            port: 1433,
+            database: 'master',
+            username: 'sa',
+            password: '',
+            ...config,
+        };
+    }
+    async withRetry(fn) {
+        const retryConfig = { ...DEFAULT_RETRY_OPTIONS, ...this.retryOptions };
+        let lastError;
+        const { backoff, backoffMultiplier, backoffMax } = retryConfig;
+        const maxRetries = retryConfig.max ?? 3;
+        const matchPatterns = retryConfig.match ?? [];
+        const timeout = retryConfig.timeout ?? 1000;
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+            try {
+                return await fn();
+            }
+            catch (error) {
+                lastError = error;
+                const errorMessage = lastError.message;
+                const shouldRetry = matchPatterns.some((pattern) => errorMessage.toLowerCase().includes(pattern.toLowerCase()));
+                if (!shouldRetry || attempt === maxRetries) {
+                    throw lastError;
+                }
+                let delay;
+                if (backoff) {
+                    delay = timeout * Math.pow(backoffMultiplier || 2, attempt);
+                    delay = Math.min(delay, backoffMax || 10000);
+                }
+                else {
+                    delay = timeout;
+                }
+                const jitter = Math.random() * 100;
+                await new Promise((resolve) => setTimeout(resolve, delay + jitter));
+            }
+        }
+        throw lastError;
+    }
+    async connect() {
+        await this.withRetry(async () => {
+            const poolConfig = {
+                server: this.config.host || 'localhost',
+                port: this.config.port || 1433,
+                database: this.config.database || 'master',
+                user: this.config.username || 'sa',
+                password: this.config.password || '',
+                pool: {
+                    max: this.poolOptions.max || 10,
+                    min: this.poolOptions.min || 0,
+                    idleTimeoutMillis: this.poolOptions.idle || 30000,
+                },
+                options: {
+                    encrypt: this.config.encrypt ?? true,
+                    trustServerCertificate: this.config.trustServerCertificate ?? true,
+                    enableArithAbort: this.config.enableArithAbort ?? true,
+                    connectTimeout: this.config.connectionTimeout || 30000,
+                    requestTimeout: this.config.requestTimeout || 30000,
+                },
+            };
+            this.pool = new mssql_1.ConnectionPool(poolConfig);
+            try {
+                await this.pool.connect();
+                this._isConnected = true;
+            }
+            catch (error) {
+                this._isConnected = false;
+                throw error;
+            }
+        });
+    }
+    async disconnect() {
+        if (this.pool) {
+            await this.pool.close();
+            this.pool = null;
+            this._isConnected = false;
+        }
+    }
+    getConnection() {
+        return this.pool;
+    }
+    isConnected() {
+        return this._isConnected && this.pool !== null;
+    }
+    /**
+     * Stream query results by paging through `sql` via repeated
+     * dialect-appropriate LIMIT/OFFSET queries (see
+     * `createPaginatedQueryStream()` in `src/dialects/query-stream-helper.ts`)
+     * instead of loading the whole result set into memory at once.
+     * @param sql - The SELECT statement to stream
+     * @param options - Streaming options (batch size, backpressure watermark, model mapping)
+     */
+    queryStream(sql, options) {
+        return (0, query_stream_helper_1.createPaginatedQueryStream)(this, sql, options);
+    }
+    async query(sql, _options) {
+        if (!this.pool) {
+            throw new Error('Not connected to database');
+        }
+        try {
+            // Named (@param) bind values are passed under different option keys
+            // (`replacements` or `bindings`) depending on the call site, either as
+            // a named object (@tableName) or a positional array (@p1, @p2, ...).
+            // Without wiring these into a parameterized request, SQL Server would
+            // receive the literal "@param" text and fail with
+            // "must declare scalar variable".
+            const bindValues = (_options?.replacements ?? _options?.bindings);
+            let result;
+            if (Array.isArray(bindValues) && bindValues.length > 0) {
+                const request = this.pool.request();
+                bindValues.forEach((value, index) => request.input(`p${index + 1}`, value));
+                result = await request.query(sql);
+            }
+            else if (bindValues && !Array.isArray(bindValues) && Object.keys(bindValues).length > 0) {
+                const request = this.pool.request();
+                for (const [key, value] of Object.entries(bindValues)) {
+                    request.input(key, value);
+                }
+                result = await request.query(sql);
+            }
+            else {
+                result = await this.pool.query(sql);
+            }
+            const rows = result.recordset ? Array.from(result.recordset) : [];
+            const rowCount = result.rowsAffected?.[0] || 0;
+            const fields = [];
+            const recordset = result.recordset;
+            if (recordset && recordset.columns) {
+                for (const [name, col] of Object.entries(recordset.columns)) {
+                    const colObj = col;
+                    fields.push({
+                        name: name,
+                        type: colObj.type || 'unknown',
+                        length: colObj.length || 0,
+                        tableID: 0,
+                        columnID: 0,
+                        nullable: colObj.nullable !== false,
+                        isEnum: false,
+                        isPrimaryKey: false,
+                    });
+                }
+            }
+            return { rows, rowCount, fields, lastInsertRowid: undefined };
+        }
+        catch (error) {
+            throw new Error(`Query failed: ${error.message}`);
+        }
+    }
+    escape(value) {
+        if (value instanceof prorm_1.Literal) {
+            return value.val;
+        }
+        if (value === null)
+            return 'NULL';
+        if (value === undefined)
+            return 'NULL';
+        if (typeof value === 'boolean')
+            return value ? '1' : '0';
+        if (typeof value === 'number')
+            return String(value);
+        if (value instanceof Date)
+            return this.formatDate(value);
+        if (Buffer.isBuffer(value))
+            return `0x${value.toString('hex')}`;
+        if (Array.isArray(value) || typeof value === 'object') {
+            return `'${JSON.stringify(value).replace(/'/g, "''")}'`;
+        }
+        return `'${String(value).replace(/'/g, "''")}'`;
+    }
+    formatDate(date) {
+        const year = date.getFullYear();
+        const month = String(date.getMonth() + 1).padStart(2, '0');
+        const day = String(date.getDate()).padStart(2, '0');
+        const hours = String(date.getHours()).padStart(2, '0');
+        const minutes = String(date.getMinutes()).padStart(2, '0');
+        const seconds = String(date.getSeconds()).padStart(2, '0');
+        const milliseconds = String(date.getMilliseconds()).padStart(3, '0');
+        return `'${year}-${month}-${day} ${hours}:${minutes}:${seconds}.${milliseconds}'`;
+    }
+    escapeId(identifier) {
+        const id = String(identifier ?? '');
+        return `[${id.replace(/\]/g, ']]')}]`;
+    }
+    quoteIdentifier(identifier) {
+        return this.escapeId(identifier);
+    }
+    quoteTable(tableName, schema) {
+        if (schema) {
+            return `${this.escapeId(schema)}.${this.escapeId(tableName)}`;
+        }
+        return this.escapeId(tableName);
+    }
+    async getDatabaseVersion() {
+        const result = await this.query('SELECT @@VERSION AS version');
+        return result.rows[0]?.version || 'unknown';
+    }
+    async createTable(tableName, columns, options) {
+        const columnDefs = [];
+        for (const [columnName, definition] of Object.entries(columns)) {
+            columnDefs.push(this.getColumnDefinitionSql(columnName, definition));
+        }
+        if (options?.indexes) {
+            for (const index of options.indexes) {
+                const indexName = index.name || `${tableName}_${index.fields.join('_')}_idx`;
+                const unique = index.unique ? 'UNIQUE ' : '';
+                const fields = index.fields.map((f) => this.escapeId(f)).join(', ');
+                columnDefs.push(`${unique}INDEX ${indexName} (${fields})`);
+            }
+        }
+        if (options?.constraints) {
+            for (const constraint of options.constraints) {
+                const constraintSql = this.buildConstraintSql(constraint);
+                if (constraintSql)
+                    columnDefs.push(constraintSql);
+            }
+        }
+        let withClause = '';
+        if (options?.temporal) {
+            const temporal = options.temporal;
+            const startCol = temporal.startColumnName || 'ValidFrom';
+            const endCol = temporal.endColumnName || 'ValidTo';
+            const hidden = temporal.hiddenPeriodColumns === false ? '' : ' HIDDEN';
+            // Hidden period columns tracking each row's system-time validity window.
+            columnDefs.push(`${this.escapeId(startCol)} DATETIME2 GENERATED ALWAYS AS ROW START${hidden} NOT NULL ` +
+                `DEFAULT SYSUTCDATETIME()`);
+            columnDefs.push(`${this.escapeId(endCol)} DATETIME2 GENERATED ALWAYS AS ROW END${hidden} NOT NULL ` +
+                `DEFAULT CONVERT(DATETIME2, '9999-12-31 23:59:59.9999999')`);
+            columnDefs.push(`PERIOD FOR SYSTEM_TIME (${this.escapeId(startCol)}, ${this.escapeId(endCol)})`);
+            const historyTableName = temporal.historyTableName || `${tableName}History`;
+            const historySchema = temporal.historySchema;
+            const historyTableRef = historySchema
+                ? `${this.escapeId(historySchema)}.${this.escapeId(historyTableName)}`
+                : this.escapeId(historyTableName);
+            const versioningParts = [`HISTORY_TABLE = ${historyTableRef}`];
+            if (temporal.historyRetentionPeriod) {
+                versioningParts.push(`HISTORY_RETENTION_PERIOD = ${temporal.historyRetentionPeriod}`);
+            }
+            withClause = ` WITH (SYSTEM_VERSIONING = ON (${versioningParts.join(', ')}))`;
+        }
+        let sql = 'CREATE TABLE';
+        sql += ` ${this.escapeId(tableName)} (${columnDefs.join(', ')})`;
+        sql += withClause;
+        await this.query(sql);
+    }
+    /**
+     * Disable system-versioning on a temporal table. Required before the
+     * table (or its schema) can be dropped or structurally altered in ways
+     * incompatible with an active `PERIOD FOR SYSTEM_TIME`.
+     */
+    async disableSystemVersioning(tableName, schema) {
+        const table = this.quoteTable(tableName, schema);
+        await this.query(`ALTER TABLE ${table} SET (SYSTEM_VERSIONING = OFF)`);
+    }
+    /**
+     * Drop a system-versioned temporal table: disables SYSTEM_VERSIONING on
+     * the current table, then drops the table itself. Pass
+     * `dropHistoryTable`/`historyTableName` to also drop the associated
+     * history table.
+     */
+    async dropTemporalTable(tableName, options) {
+        await this.disableSystemVersioning(tableName, options?.schema);
+        await this.dropTable(tableName, options);
+        if (options?.dropHistoryTable) {
+            const historyTableName = options.historyTableName || `${tableName}History`;
+            await this.dropTable(historyTableName, { ifExists: true, schema: options.schema });
+        }
+    }
+    getColumnDefinitionSql(columnName, definition) {
+        let sql = `${this.escapeId(columnName)} ${this.getDataTypeSql(definition.type)}`;
+        // SPARSE must appear immediately after the data type, before the
+        // NULL/NOT NULL clause, per T-SQL column-definition syntax:
+        //   column_name <data_type> [ SPARSE ] [ NULL | NOT NULL ] ...
+        // SQL Server requires SPARSE columns to allow NULL — fail fast with a
+        // clear error rather than emitting DDL SQL Server will reject.
+        if (definition.sparse) {
+            if (definition.allowNull === false) {
+                throw new Error(`Column "${columnName}" cannot be SPARSE and NOT NULL — SQL Server requires SPARSE columns to allow NULL.`);
+            }
+            sql += ' SPARSE';
+        }
+        if (definition.allowNull === false)
+            sql += ' NOT NULL';
+        if (definition.defaultValue !== undefined) {
+            if (definition.defaultValue === null)
+                sql += ' DEFAULT NULL';
+            else if (typeof definition.defaultValue === 'string')
+                sql += ` DEFAULT ${definition.defaultValue}`;
+            else
+                sql += ` DEFAULT ${this.formatValue(definition.defaultValue)}`;
+        }
+        if (definition.primaryKey)
+            sql += ' PRIMARY KEY';
+        if (definition.autoIncrement)
+            sql += ' IDENTITY(1,1)';
+        if (definition.unique) {
+            if (typeof definition.unique === 'string')
+                sql += ` UNIQUE ${this.escapeId(definition.unique)}`;
+            else
+                sql += ' UNIQUE';
+        }
+        if (definition.references) {
+            const refField = definition.references.field;
+            const refFieldSql = Array.isArray(refField)
+                ? `(${refField.map((f) => this.escapeId(f)).join(', ')})`
+                : `(${this.escapeId(refField)})`;
+            sql += ` REFERENCES ${this.escapeId(definition.references.table)}${refFieldSql}`;
+            if (definition.references.onDelete)
+                sql += ` ON DELETE ${definition.references.onDelete}`;
+            if (definition.references.onUpdate)
+                sql += ` ON UPDATE ${definition.references.onUpdate}`;
+        }
+        return sql;
+    }
+    buildConstraintSql(constraint) {
+        const name = constraint.name ? `CONSTRAINT ${this.escapeId(constraint.name)} ` : '';
+        const fields = constraint.fields?.map((f) => this.escapeId(f)).join(', ') || '';
+        switch (constraint.type) {
+            case 'PRIMARY KEY':
+                return `${name}PRIMARY KEY (${fields})`;
+            case 'UNIQUE':
+                return `${name}UNIQUE (${fields})`;
+            case 'CHECK':
+                return `${name}CHECK (${constraint.check})`;
+            case 'FOREIGN KEY':
+                if (!constraint.references)
+                    return null;
+                const refField = constraint.references.field;
+                const refFieldSql = Array.isArray(refField)
+                    ? `(${refField.map((f) => this.escapeId(f)).join(', ')})`
+                    : `(${this.escapeId(refField)})`;
+                let fkSql = `${name}FOREIGN KEY (${fields}) `;
+                fkSql += `REFERENCES ${this.escapeId(constraint.references.table)}${refFieldSql}`;
+                if (constraint.references.onDelete)
+                    fkSql += ` ON DELETE ${constraint.references.onDelete}`;
+                if (constraint.references.onUpdate)
+                    fkSql += ` ON UPDATE ${constraint.references.onUpdate}`;
+                return fkSql;
+            default:
+                return null;
+        }
+    }
+    async dropTable(tableName, options) {
+        if (options?.cascade) {
+            throw new Error('MSSQL DROP TABLE does not support CASCADE. T-SQL has no cascading drop for tables; ' +
+                'drop dependent foreign keys/objects manually in dependency order before dropping this table.');
+        }
+        let sql = 'DROP TABLE';
+        if (options?.ifExists)
+            sql += ' IF EXISTS';
+        sql += ` ${this.escapeId(tableName)}`;
+        await this.query(sql);
+    }
+    async createPartitionedTable(_tableName, _columns, _options) {
+        throw new Error(PARTITIONING_UNSUPPORTED_MESSAGE);
+    }
+    async createPartition(_options) {
+        throw new Error(PARTITIONING_UNSUPPORTED_MESSAGE);
+    }
+    async attachPartition(_options) {
+        throw new Error(PARTITIONING_UNSUPPORTED_MESSAGE);
+    }
+    async detachPartition(_options) {
+        throw new Error(PARTITIONING_UNSUPPORTED_MESSAGE);
+    }
+    async dropPartition(_partitionName, _options) {
+        throw new Error(PARTITIONING_UNSUPPORTED_MESSAGE);
+    }
+    /**
+     * Add a partition to an existing partitioned table (MSSQL)
+     * @param tableName - Name of the partitioned table
+     * @param partitionName - Name for the new partition
+     * @param partitionSpec - Partition specification
+     */
+    async addPartition(_tableName, _partitionName, _partitionSpec) {
+        throw new Error(PARTITIONING_UNSUPPORTED_MESSAGE);
+    }
+    async createView(viewName, query, options) {
+        // T-SQL has no `CREATE OR REPLACE VIEW` syntax. Use `CREATE OR ALTER VIEW`
+        // (SQL Server 2016 SP1+), which is the correct equivalent.
+        let sql = options?.replace ? 'CREATE OR ALTER VIEW' : 'CREATE VIEW';
+        sql += ` ${this.escapeId(viewName)} AS ${query}`;
+        await this.query(sql);
+    }
+    async dropView(viewName, options) {
+        if (options?.cascade) {
+            throw new Error('MSSQL DROP VIEW does not support CASCADE. T-SQL has no cascading drop for views; ' +
+                'drop dependent objects manually in dependency order before dropping this view.');
+        }
+        let sql = 'DROP VIEW';
+        if (options?.ifExists)
+            sql += ' IF EXISTS';
+        sql += ` ${this.escapeId(viewName)}`;
+        await this.query(sql);
+    }
+    async createMaterializedView(options) {
+        const schema = options.schema || 'dbo';
+        const viewName = options.name;
+        // MSSQL uses indexed views as equivalent to materialized views
+        // First create the view
+        let sql = `CREATE VIEW ${this.escapeId(schema)}.${this.escapeId(viewName)} AS ${options.query}`;
+        if (options.replace) {
+            // T-SQL has no `CREATE OR REPLACE VIEW`. `CREATE OR ALTER VIEW`
+            // (SQL Server 2016 SP1+) is the correct equivalent and redefines the
+            // view in a single statement (note: this drops any indexes on the
+            // view, so callers should recreate `uniqueIndex` afterwards, which
+            // this method already does below).
+            sql = `CREATE OR ALTER VIEW ${this.escapeId(schema)}.${this.escapeId(viewName)} AS ${options.query}`;
+        }
+        else if (options.ifNotExists) {
+            await this.query(`IF NOT EXISTS (SELECT * FROM sys.views WHERE name = '${viewName}' AND schema_id = SCHEMA_ID('${schema}')) ${sql}`);
+            return;
+        }
+        await this.query(sql);
+        // Add a unique clustered index to make it a "materialized" view
+        // Note: MSSQL indexed views require all columns in the SELECT to be included in the unique index
+        // For simplicity, we create the index without specific columns - this will fail if view has multiple columns
+        // Users should manually add the unique index for production use
+        if (options.uniqueIndex) {
+            // Try to create index on a placeholder - this may fail for complex views
+            // In production, user should manually create the unique clustered index
+            await this.query(`-- Note: MSSQL indexed views require unique clustered index on all columns
+        -- Please create manually: CREATE UNIQUE CLUSTERED INDEX ${this.escapeId(options.uniqueIndex)} ON ${this.escapeId(schema)}.${this.escapeId(viewName)} (column1, column2, ...)`);
+        }
+    }
+    async refreshMaterializedView(viewName, _options) {
+        // In MSSQL indexed views are automatically maintained
+        // To "refresh", we need to rebuild the index
+        const parts = viewName.split('.');
+        const vName = parts[parts.length - 1];
+        const schema = parts.length > 1 ? parts[0] : 'dbo';
+        // Rebuild all indexes on the view
+        await this.query(`ALTER INDEX ALL ON ${this.escapeId(schema)}.${this.escapeId(vName)} REBUILD`);
+    }
+    async dropMaterializedView(viewName, options) {
+        if (options?.cascade) {
+            throw new Error('MSSQL DROP VIEW does not support CASCADE. T-SQL has no cascading drop for views; ' +
+                'drop dependent objects manually in dependency order before dropping this view.');
+        }
+        const parts = viewName.split('.');
+        const vName = parts[parts.length - 1];
+        const schema = parts.length > 1 ? parts[0] : 'dbo';
+        const sql = options?.ifExists
+            ? `IF EXISTS (SELECT * FROM sys.views WHERE name = '${vName}' AND schema_id = SCHEMA_ID('${schema}')) DROP VIEW ${this.escapeId(schema)}.${this.escapeId(vName)}`
+            : `DROP VIEW ${this.escapeId(schema)}.${this.escapeId(vName)}`;
+        await this.query(sql);
+    }
+    async hasMaterializedView(viewName) {
+        const parts = viewName.split('.');
+        const vName = parts[parts.length - 1];
+        const schema = parts.length > 1 ? parts[0] : 'dbo';
+        const sql = `SELECT name FROM sys.views WHERE name = '${vName}' AND schema_id = SCHEMA_ID('${schema}')`;
+        const result = await this.query(sql);
+        return result.rows.length > 0;
+    }
+    async createStoredProcedure(options) {
+        const schema = options.schema || 'dbo';
+        const procName = options.name;
+        let sql = 'CREATE PROCEDURE ';
+        if (options.ifNotExists) {
+            sql = `IF NOT EXISTS (SELECT * FROM sys.procedures WHERE name = '${procName}' AND schema_id = SCHEMA_ID('${schema}')) CREATE PROCEDURE `;
+        }
+        sql += `${this.escapeId(schema)}.${this.escapeId(procName)}`;
+        // Add parameters
+        if (options.params && options.params.length > 0) {
+            const params = options.params
+                .map((p) => {
+                const mode = p.mode === 'OUT' ? 'OUTPUT' : p.mode === 'INOUT' ? 'OUTPUT' : '';
+                return `@${p.name} ${p.type} ${mode}`.trim();
+            })
+                .join(', ');
+            sql += ` (${params})`;
+        }
+        if (options.comment) {
+            sql += `\nAS -- ${options.comment}`;
+        }
+        sql += `\nAS\nBEGIN\n${options.body}\nEND`;
+        if (options.replace) {
+            // For replace, we need to drop and recreate
+            await this.query(`DROP PROCEDURE IF EXISTS ${this.escapeId(schema)}.${this.escapeId(procName)}`);
+            sql = sql.replace('IF NOT EXISTS', '').replace('CREATE PROCEDURE ', 'CREATE PROCEDURE ');
+        }
+        await this.query(sql);
+    }
+    async dropStoredProcedure(procedureName, options) {
+        const schema = options?.schema || 'dbo';
+        const sql = options?.ifExists
+            ? `IF EXISTS (SELECT * FROM sys.procedures WHERE name = '${procedureName}' AND schema_id = SCHEMA_ID('${schema}')) DROP PROCEDURE ${this.escapeId(schema)}.${this.escapeId(procedureName)}`
+            : `DROP PROCEDURE ${this.escapeId(schema)}.${this.escapeId(procedureName)}`;
+        await this.query(sql);
+    }
+    /**
+     * Drop a stored procedure (alias for dropStoredProcedure)
+     */
+    async dropProcedure(procedureName, options) {
+        return this.dropStoredProcedure(procedureName, options);
+    }
+    /**
+     * Create a stored procedure (alias for createStoredProcedure)
+     */
+    async createProcedure(options) {
+        return this.createStoredProcedure(options);
+    }
+    async executeStoredProcedure(options) {
+        const schema = options.schema || 'dbo';
+        const procName = `${this.escapeId(schema)}.${this.escapeId(options.procedureName)}`;
+        let sql = `EXEC ${procName}`;
+        if (options.params && Object.keys(options.params).length > 0) {
+            const params = Object.entries(options.params)
+                .map(([name, value]) => {
+                if (value === undefined || value === null) {
+                    return `@${name} = NULL`;
+                }
+                return `@${name} = ${this.escape(value)}`;
+            })
+                .join(', ');
+            sql += ` ${params}`;
+        }
+        return this.query(sql, { timeout: options.timeout });
+    }
+    async hasStoredProcedure(procedureName, schema) {
+        const db = schema || 'dbo';
+        const sql = `SELECT name FROM sys.procedures WHERE name = @procedureName AND schema_id = SCHEMA_ID(@schema)`;
+        const result = await this.query(sql, { bindings: { procedureName, schema: db } });
+        return result.rows.length > 0;
+    }
+    async createTrigger(options) {
+        const timing = options.timing;
+        const events = (options.events || []).join(' OR ');
+        const tableName = options.schema
+            ? `${this.escapeId(options.schema)}.${this.escapeId(options.tableName)}`
+            : this.quoteTable(options.tableName);
+        let sql = `CREATE TRIGGER ${this.escapeId(options.name)} ${timing} ${events} ON ${tableName}`;
+        if (options.timing === 'INSTEAD OF') {
+            sql = `CREATE TRIGGER ${this.escapeId(options.name)} INSTEAD OF ${events} ON ${tableName}`;
+        }
+        sql += `\nAS\nBEGIN\n${options.body}\nEND`;
+        if (options.replace) {
+            // T-SQL has no `CREATE OR REPLACE TRIGGER` syntax. `CREATE OR ALTER
+            // TRIGGER` (SQL Server 2016 SP1+) is the correct equivalent.
+            sql = sql.replace('CREATE TRIGGER', 'CREATE OR ALTER TRIGGER');
+        }
+        await this.query(sql);
+    }
+    async dropTrigger(triggerName, tableName, options) {
+        const sql = options?.ifExists
+            ? `IF EXISTS (SELECT * FROM sys.triggers WHERE name = '${triggerName}') DROP TRIGGER ${this.escapeId(triggerName)}`
+            : `DROP TRIGGER ${this.escapeId(triggerName)}`;
+        await this.query(sql);
+    }
+    async hasTrigger(triggerName, tableName) {
+        const sql = `SELECT name FROM sys.triggers t
+      JOIN sys.tables tb ON t.parent_id = tb.object_id
+      WHERE t.name = @triggerName AND tb.name = @tableName`;
+        const result = await this.query(sql, { bindings: { triggerName, tableName } });
+        return result.rows.length > 0;
+    }
+    async createSequence(options) {
+        const schema = options.schema || 'dbo';
+        const seqName = options.name;
+        let sql = 'CREATE SEQUENCE ';
+        if (options.ifNotExists) {
+            sql = `IF NOT EXISTS (SELECT * FROM sys.sequences WHERE name = '${seqName}' AND schema_id = SCHEMA_ID('${schema}')) CREATE SEQUENCE `;
+        }
+        sql += `${this.escapeId(schema)}.${this.escapeId(seqName)}`;
+        const parts = [];
+        if (options.startWith !== undefined) {
+            parts.push(`START WITH ${options.startWith}`);
+        }
+        if (options.incrementBy !== undefined) {
+            parts.push(`INCREMENT BY ${options.incrementBy}`);
+        }
+        if (options.minvalue !== undefined) {
+            parts.push(`MINVALUE ${options.minvalue}`);
+        }
+        if (options.maxvalue !== undefined) {
+            parts.push(`MAXVALUE ${options.maxvalue}`);
+        }
+        if (options.cycle) {
+            parts.push('CYCLE');
+        }
+        if (options.cache !== undefined) {
+            parts.push(`CACHE ${options.cache}`);
+        }
+        if (parts.length > 0) {
+            sql += `\n${parts.join('\n')}`;
+        }
+        if (options.replace) {
+            await this.query(`DROP SEQUENCE IF EXISTS ${this.escapeId(schema)}.${this.escapeId(seqName)}`);
+            sql = sql.replace('IF NOT EXISTS', '').replace('CREATE SEQUENCE ', 'CREATE SEQUENCE ');
+        }
+        await this.query(sql);
+    }
+    async dropSequence(sequenceName, options) {
+        const schema = options?.schema || 'dbo';
+        const sql = options?.ifExists
+            ? `IF EXISTS (SELECT * FROM sys.sequences WHERE name = '${sequenceName}' AND schema_id = SCHEMA_ID('${schema}')) DROP SEQUENCE ${this.escapeId(schema)}.${this.escapeId(sequenceName)}`
+            : `DROP SEQUENCE ${this.escapeId(schema)}.${this.escapeId(sequenceName)}`;
+        await this.query(sql);
+    }
+    async nextSequenceValue(sequenceName) {
+        // Extract schema from sequence name if present
+        const parts = sequenceName.split('.');
+        const seqName = parts[parts.length - 1];
+        const schema = parts.length > 1 ? parts[0] : 'dbo';
+        const sql = `SELECT NEXT VALUE FOR ${this.escapeId(schema)}.${this.escapeId(seqName)} AS next_val`;
+        const result = await this.query(sql);
+        return result.rows[0]?.next_val;
+    }
+    async hasSequence(sequenceName) {
+        const parts = sequenceName.split('.');
+        const seqName = parts[parts.length - 1];
+        const schema = parts.length > 1 ? parts[0] : 'dbo';
+        const sql = `SELECT name FROM sys.sequences WHERE name = @seqName AND schema_id = SCHEMA_ID(@schema)`;
+        const result = await this.query(sql, { bindings: { seqName, schema } });
+        return result.rows.length > 0;
+    }
+    /**
+     * List all sequences in the database (MSSQL)
+     * @returns Array of sequence names
+     */
+    async listSequences() {
+        const sql = `SELECT s.name AS sequence_name, SCHEMA_NAME(s.schema_id) AS schema_name FROM sys.sequences s ORDER BY schema_name, sequence_name`;
+        const result = await this.query(sql);
+        return result.rows.map((row) => `${row.schema_name}.${row.sequence_name}`);
+    }
+    /**
+     * Create a security policy with predicate function (MSSQL RLS)
+     */
+    async createPolicy(options) {
+        const schema = options.schema || 'dbo';
+        const tableName = `${this.escapeId(schema)}.${this.escapeId(options.tableName)}`;
+        const policyName = this.escapeId(options.name);
+        // SQL Server RLS uses CREATE SECURITY POLICY
+        let sql = `CREATE SECURITY POLICY ${policyName}`;
+        if (options.predicateFunction) {
+            sql += `\nADD FILTER PREDICATE ${options.predicateFunction}(${options.column || 'NULL'})`;
+        }
+        else if (options.using) {
+            // If no predicate function is provided but using clause exists,
+            // we need a predicate function (not directly supported in CREATE SECURITY POLICY)
+            // The user should provide predicateFunction for proper MSSQL RLS
+            throw new Error('MSSQL RLS requires a predicate function. Use predicateFunction option to specify the security predicate function (e.g., "dbo.fn_SecurityPredicate")');
+        }
+        sql += `\nON ${tableName}`;
+        await this.query(sql);
+    }
+    /**
+     * Drop a security policy (MSSQL RLS)
+     */
+    async dropPolicy(policyName, _tableName, options) {
+        // T-SQL's DROP SECURITY POLICY takes no `ON <table>` clause and no
+        // CASCADE — a security policy is dropped by name alone (it may have
+        // predicates on multiple tables). `tableName` is accepted for parity
+        // with other dialects' dropPolicy signatures but unused here.
+        const schema = options?.schema || 'dbo';
+        const ifExists = options?.ifExists ? 'IF EXISTS ' : '';
+        const sql = `DROP SECURITY POLICY ${ifExists}${this.escapeId(schema)}.${this.escapeId(policyName)}`;
+        await this.query(sql);
+    }
+    /**
+     * Enable row-level security on a table (MSSQL)
+     * Note: In SQL Server, RLS is automatically enabled when a security policy is created.
+     * This method can be used to explicitly enable RLS if needed.
+     */
+    async enableRLS(tableName, schema) {
+        const schemaName = schema || 'dbo';
+        // In SQL Server, RLS is enabled by creating a security policy.
+        // This method is kept for API compatibility but doesn't need to do anything
+        // as createPolicy will handle enabling RLS.
+        // However, we can verify the table exists.
+        const sql = `SELECT OBJECT_ID('${schemaName}.${tableName}') AS TableId`;
+        const result = await this.query(sql);
+        if (!result.rows || result.rows.length === 0) {
+            throw new Error(`Table ${schemaName}.${tableName} does not exist`);
+        }
+    }
+    /**
+     * Disable row-level security on a table (MSSQL)
+     * This drops all security policies associated with the table
+     */
+    async disableRLS(tableName, schema) {
+        const schemaName = schema || 'dbo';
+        // Find and drop all security policies for this table
+        const sql = `
+      SELECT name FROM sys.security_policies
+      WHERE schema_id = SCHEMA_ID('${schemaName}')
+      AND OBJECT_ID(CONCAT('${schemaName}.', name)) IN (
+        SELECT object_id FROM sys.security_predicates
+        WHERE class = 1 -- TABLE
+        AND schema_id = SCHEMA_ID('${schemaName}')
+        AND object_id = OBJECT_ID('${schemaName}.${tableName}')
+      )
+    `;
+        const result = await this.query(sql);
+        if (result.rows && result.rows.length > 0) {
+            for (const row of result.rows) {
+                const dropSql = `DROP SECURITY POLICY ${this.escapeId(schemaName)}.${this.escapeId(row.name)} ON ${this.escapeId(schemaName)}.${this.escapeId(tableName)}`;
+                await this.query(dropSql);
+            }
+        }
+    }
+    /**
+     * Check if a security policy exists (MSSQL RLS)
+     */
+    async hasPolicy(policyName, tableName) {
+        const sql = `
+      SELECT sp.name AS policyname
+      FROM sys.security_policies sp
+      INNER JOIN sys.security_predicates spred ON sp.object_id = spred.object_id
+      WHERE sp.name = @policyName
+      AND spred.parent_object_id = OBJECT_ID(@tableName)
+    `;
+        const result = await this.query(sql, { bindings: { policyName, tableName } });
+        return result.rows && result.rows.length > 0;
+    }
+    async commentTable(tableName, comment) {
+        const sql = `EXEC sp_addextendedproperty 'MS_Description', @comment, 'TABLE', null, null, null, null, null, null, null, null, 'SCHEMA', 'dbo', 'TABLE', @tableName`;
+        await this.query(sql, { bindings: { comment, tableName } });
+    }
+    async commentColumn(tableName, columnName, comment) {
+        const sql = `EXEC sp_addextendedproperty 'MS_Description', @comment, 'COLUMN', null, null, null, null, null, null, null, null, 'SCHEMA', 'dbo', 'TABLE', @tableName, 'COLUMN', @columnName`;
+        await this.query(sql, { bindings: { comment, tableName, columnName } });
+    }
+    async createPartialIndex(tableName, indexName, fields, where, options) {
+        // MSSQL supports filtered indexes which are equivalent to partial indexes
+        let sql = 'CREATE';
+        if (options?.unique)
+            sql += ' UNIQUE';
+        sql += ` INDEX ${this.escapeId(indexName)} ON ${this.escapeId(tableName)}`;
+        sql += ` (${fields.map((f) => this.escapeId(f)).join(', ')})`;
+        sql += ` WHERE ${where}`;
+        if (options?.using) {
+            sql += ` USING ${options.using}`;
+        }
+        await this.query(sql);
+    }
+    async createExpressionIndex(tableName, indexName, expression, options) {
+        // SQL Server does not support indexing an arbitrary expression directly
+        // (unlike Postgres). The only way to index an expression is to first add
+        // a computed column for it, then build a normal index on that column.
+        // We default the computed column to PERSISTED so it's materialized on
+        // disk and indexable without SQL Server re-evaluating the expression
+        // (and re-checking determinism) on every index seek/scan.
+        const computedColumnName = options?.computedColumnName || `${indexName}_expr`;
+        const persisted = options?.persisted !== false;
+        await this.createComputedColumn(tableName, computedColumnName, expression, {
+            persisted,
+        });
+        let sql = 'CREATE';
+        if (options?.unique)
+            sql += ' UNIQUE';
+        sql += ` INDEX ${this.escapeId(indexName)} ON ${this.escapeId(tableName)}`;
+        sql += ` (${this.escapeId(computedColumnName)})`;
+        if (options?.using) {
+            sql += ` USING ${options.using}`;
+        }
+        await this.query(sql);
+    }
+    async createIdentityColumn(tableName, columnName, options) {
+        const startWith = options?.startWith || 1;
+        const incrementBy = options?.incrementBy || 1;
+        const sql = `ALTER TABLE ${this.escapeId(tableName)} ADD ${this.escapeId(columnName)} INT IDENTITY(${startWith},${incrementBy})`;
+        await this.query(sql);
+    }
+    async createComputedColumn(tableName, columnName, expression, options) {
+        const persisted = options?.persisted ? 'PERSISTED' : '';
+        const type = options?.type || 'AS';
+        const sql = `ALTER TABLE ${this.escapeId(tableName)} ADD ${this.escapeId(columnName)} ${type} (${expression}) ${persisted}`;
+        await this.query(sql);
+    }
+    async addColumn(tableName, columnName, definition) {
+        const sql = `ALTER TABLE ${this.escapeId(tableName)} ADD ${this.getColumnDefinitionSql(columnName, definition)}`;
+        await this.query(sql);
+    }
+    async removeColumn(tableName, columnName) {
+        const sql = `ALTER TABLE ${this.escapeId(tableName)} DROP COLUMN ${this.escapeId(columnName)}`;
+        await this.query(sql);
+    }
+    async changeColumn(tableName, columnName, definition) {
+        const sql = `ALTER TABLE ${this.escapeId(tableName)} ALTER COLUMN ${this.getColumnDefinitionSql(columnName, definition)}`;
+        await this.query(sql);
+    }
+    async showTables() {
+        const result = await this.query("SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_TYPE = 'BASE TABLE'");
+        return result.rows.map((row) => row.TABLE_NAME);
+    }
+    /**
+     * Get table status (MSSQL implementation)
+     */
+    async getTableStatus(tableName) {
+        const sql = tableName
+            ? `SELECT TABLE_NAME, TABLE_TYPE FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = @tableName`
+            : `SELECT TABLE_NAME, TABLE_TYPE FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_TYPE = 'BASE TABLE'`;
+        const result = tableName
+            ? await this.query(sql, { bindings: { tableName } })
+            : await this.query(sql);
+        return result.rows;
+    }
+    /**
+     * Get table create statement (MSSQL implementation)
+     */
+    async getCreateTable(tableName) {
+        const sql = `
+      SELECT OBJECT_DEFINITION(OBJECT_ID(@tableName)) AS CreateStatement
+    `;
+        const result = await this.query(sql, { bindings: { tableName } });
+        return result.rows[0]?.CreateStatement || '';
+    }
+    /**
+     * Check if a table has partitions (MSSQL implementation)
+     */
+    async hasPartition(tableName) {
+        const sql = `
+      SELECT 1 FROM sys.partitions p
+      JOIN sys.tables t ON p.object_id = t.object_id
+      WHERE t.name = @tableName AND p.index_id IN (0, 1)
+    `;
+        const result = await this.query(sql, { bindings: { tableName } });
+        // Check if there are multiple partitions (base table has 1 partition by default)
+        return result.rows.length > 1;
+    }
+    /**
+     * Show constraints for a table
+     */
+    async showConstraints(tableName) {
+        const sql = `
+      SELECT
+        tc.CONSTRAINT_NAME AS name,
+        tc.TABLE_NAME AS tableName,
+        tc.CONSTRAINT_TYPE AS type,
+        kcu.COLUMN_NAME AS columnName
+      FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS AS tc
+      LEFT JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE AS kcu
+        ON tc.CONSTRAINT_NAME = kcu.CONSTRAINT_NAME
+        AND tc.TABLE_SCHEMA = kcu.TABLE_SCHEMA
+      WHERE tc.TABLE_NAME = @tableName
+      ORDER BY tc.CONSTRAINT_NAME
+    `;
+        const result = await this.query(sql, { bindings: { tableName } });
+        return result.rows;
+    }
+    /**
+     * Show indexes for a table
+     */
+    async showIndexes(tableName) {
+        const sql = `
+      SELECT
+        i.name AS name,
+        OBJECT_NAME(i.object_id) AS tableName,
+        i.is_unique AS isUnique,
+        i.type AS type,
+        ic.column_id AS columnId,
+        COL_NAME(ic.object_id, ic.column_id) AS columnName
+      FROM sys.indexes i
+      LEFT JOIN sys.index_columns ic
+        ON i.object_id = ic.object_id
+        AND i.index_id = ic.index_id
+      WHERE OBJECT_NAME(i.object_id) = @tableName
+      AND i.is_primary_key = 0
+      ORDER BY i.name, ic.key_ordinal
+    `;
+        const result = await this.query(sql, { bindings: { tableName } });
+        return result.rows;
+    }
+    async showViews() {
+        const result = await this.query("SELECT TABLE_NAME FROM INFORMATION_SCHEMA.VIEWS WHERE TABLE_SCHEMA = 'dbo'");
+        return result.rows.map((row) => row.TABLE_NAME);
+    }
+    async showMaterializedViews() {
+        // In MSSQL, indexed views are the equivalent of materialized views
+        // Return all views that have a unique clustered index
+        const result = await this.query(`
+      SELECT v.name AS view_name, SCHEMA_NAME(v.schema_id) AS schema_name
+      FROM sys.views v
+      INNER JOIN sys.indexes i ON v.object_id = i.object_id
+      WHERE i.type = 1 AND i.is_unique = 1
+      ORDER BY schema_name, view_name
+    `);
+        return result.rows.map((row) => `${row.schema_name}.${row.view_name}`);
+    }
+    async describeTable(tableName) {
+        const result = await this.query(`
+      SELECT c.COLUMN_NAME, c.DATA_TYPE, c.IS_NULLABLE, c.COLUMN_DEFAULT
+      FROM INFORMATION_SCHEMA.COLUMNS c
+      WHERE c.TABLE_NAME = @tableName
+      ORDER BY c.ORDINAL_POSITION
+    `, { bindings: { tableName } });
+        const description = {};
+        for (const row of result.rows) {
+            description[row.COLUMN_NAME] = {
+                type: row.DATA_TYPE,
+                allowNull: row.IS_NULLABLE === 'YES',
+                defaultValue: row.COLUMN_DEFAULT,
+                primaryKey: false,
+                autoIncrement: false,
+            };
+        }
+        return description;
+    }
+    async renameTable(oldName, newName) {
+        const sql = `EXEC sp_rename @objname = @oldName, @newname = @newName`;
+        await this.query(sql, { bindings: { oldName, newName } });
+    }
+    async addIndex(tableName, indexName, fields, options) {
+        const fieldsArr = fields || [];
+        let sql = 'CREATE';
+        if (options?.unique)
+            sql += ' UNIQUE';
+        if (options?.type)
+            sql += ` ${options.type}`;
+        sql += ' INDEX';
+        sql += ` ${this.escapeId(indexName)} ON ${this.escapeId(tableName)}`;
+        sql += ` (${fieldsArr.map((f) => this.escapeId(f)).join(', ')})`;
+        if (options?.using)
+            sql += ` USING ${options.using}`;
+        // Filtered index predicate (a real, commonly-used MSSQL feature) - was
+        // previously accepted by createIndex() but silently dropped here.
+        if (options?.where) {
+            const whereClause = this.buildWhereClause(options.where);
+            sql += ` WHERE ${whereClause.sql}`;
+        }
+        await this.query(sql);
+    }
+    async removeIndex(tableName, indexName) {
+        const sql = `DROP INDEX ${this.escapeId(indexName)} ON ${this.escapeId(tableName)}`;
+        await this.query(sql);
+    }
+    async createIndex(tableName, indexDef) {
+        await this.addIndex(tableName, indexDef.name, indexDef.fields, {
+            unique: indexDef.unique,
+            type: indexDef.type,
+            using: indexDef.using,
+            where: indexDef.where,
+        });
+    }
+    async dropIndex(tableName, indexName, _options) {
+        await this.removeIndex(tableName, indexName);
+    }
+    async createConstraint(tableName, constraintDef) {
+        const sql = `ALTER TABLE ${this.escapeId(tableName)} ADD ${this.buildConstraintSql(constraintDef)}`;
+        await this.query(sql);
+    }
+    async dropConstraint(tableName, constraintName, _options) {
+        const sql = `ALTER TABLE ${this.escapeId(tableName)} DROP CONSTRAINT ${this.escapeId(constraintName)}`;
+        await this.query(sql);
+    }
+    async startTransaction(_options) {
+        await this.query('BEGIN TRANSACTION');
+        return new types_1.Transaction({ autocommit: false });
+    }
+    async commitTransaction(_transaction) {
+        await this.query('COMMIT TRANSACTION');
+    }
+    async rollbackTransaction(_transaction) {
+        await this.query('ROLLBACK TRANSACTION');
+    }
+    async createSchema(schema) {
+        const sql = `CREATE SCHEMA ${this.escapeId(schema)}`;
+        await this.query(sql);
+    }
+    async dropSchema(schema, options) {
+        if (options?.cascade) {
+            throw new Error('MSSQL DROP SCHEMA does not support CASCADE. T-SQL requires a schema to be empty before ' +
+                'it can be dropped; drop or move all objects out of the schema manually first.');
+        }
+        let sql = 'DROP SCHEMA';
+        if (options?.ifExists)
+            sql += ' IF EXISTS';
+        sql += ` ${this.escapeId(schema)}`;
+        await this.query(sql);
+    }
+    async showAllSchemas() {
+        const result = await this.query("SELECT SCHEMA_NAME FROM INFORMATION_SCHEMA.SCHEMATA WHERE SCHEMA_NAME NOT IN ('INFORMATION_SCHEMA', 'sys')");
+        return result.rows.map((row) => row.SCHEMA_NAME);
+    }
+    /**
+     * List all schemas
+     */
+    async listSchemas() {
+        return this.showAllSchemas();
+    }
+    getDataTypeSql(dataType) {
+        if (typeof dataType === 'string')
+            return dataType;
+        if (!dataType || typeof dataType !== 'object')
+            return 'NVARCHAR(255)';
+        const dt = dataType;
+        switch (dt.key) {
+            case 'STRING':
+                if (dt.length === 'max')
+                    return 'NVARCHAR(MAX)';
+                return `NVARCHAR(${String(dt.length || 255)})`;
+            case 'CHAR':
+                return `CHAR(${String(dt.length || 1)})`;
+            case 'TEXT': {
+                // MSSQL has no MySQL-style TEXT/MEDIUMTEXT/LONGTEXT length tiers, and
+                // the legacy TEXT/NTEXT types are deprecated since SQL Server 2005 in
+                // favor of VARCHAR(MAX)/NVARCHAR(MAX). Map an explicit, reasonable
+                // length to NVARCHAR(n) (max non-MAX length is 4000 for NVARCHAR),
+                // and anything unbounded/larger (including legacy MySQL length
+                // sentinels like 65535/16777215/4294967295 that used to be
+                // misinterpreted here) to NVARCHAR(MAX).
+                if (dt.length === undefined || dt.length === null || dt.length === 'max') {
+                    return 'NVARCHAR(MAX)';
+                }
+                const len = Number(dt.length);
+                if (!Number.isFinite(len) || len <= 0 || len > 4000)
+                    return 'NVARCHAR(MAX)';
+                return `NVARCHAR(${len})`;
+            }
+            case 'INTEGER': {
+                let intType = 'INT';
+                if (dt.length === 1)
+                    intType = 'TINYINT';
+                else if (dt.length === 2)
+                    intType = 'SMALLINT';
+                else if (dt.length === 8)
+                    intType = 'BIGINT';
+                return intType;
+            }
+            case 'BIGINT':
+                return 'BIGINT';
+            case 'FLOAT':
+                return dt.length ? `FLOAT(${String(dt.length)})` : 'FLOAT';
+            case 'DOUBLE':
+                return 'FLOAT';
+            case 'DECIMAL':
+                return `DECIMAL(${String(dt.precision || 10)},${String(dt.scale || 0)})`;
+            case 'BOOLEAN':
+                return 'BIT';
+            case 'DATE':
+                return dt.precision ? `DATETIME2(${String(dt.precision)})` : 'DATETIME2';
+            case 'DATEONLY':
+                return 'DATE';
+            case 'TIME':
+                return dt.precision ? `TIME(${String(dt.precision)})` : 'TIME';
+            case 'BLOB':
+                return 'VARBINARY(MAX)';
+            case 'ENUM':
+                return 'NVARCHAR(255)';
+            case 'JSON':
+                return 'NVARCHAR(MAX)';
+            case 'JSONB':
+                return 'NVARCHAR(MAX)';
+            case 'UUID':
+                return 'UNIQUEIDENTIFIER';
+            case 'GEOMETRY':
+                return 'GEOMETRY';
+            case 'VIRTUAL':
+                return '';
+            default:
+                return 'NVARCHAR(255)';
+        }
+    }
+    buildWhereClause(where, _options) {
+        const values = [];
+        if (!where || Object.keys(where).length === 0) {
+            return { sql: '', values };
+        }
+        // Operator objects (e.g. { age: { $gt: 18 } }) and top-level logical
+        // operators ($and/$or/$not) used to be silently dropped here (any key
+        // starting with `$` hit `continue`), which meant filters like $or/$gt
+        // vanished from the generated SQL and queries silently returned more
+        // rows than intended. This now translates the operators supported
+        // across the ORM (mirroring the Postgres dialect's buildWhereClause)
+        // and throws for anything it doesn't recognize instead of dropping it.
+        const buildCondition = (condition) => {
+            if (!condition || typeof condition !== 'object') {
+                return '';
+            }
+            const cond = condition;
+            const logicalParts = [];
+            if (cond.$and !== undefined) {
+                const subConditions = cond.$and
+                    .map((c) => buildCondition(c))
+                    .filter(Boolean);
+                if (subConditions.length > 0) {
+                    logicalParts.push(`(${subConditions.join(' AND ')})`);
+                }
+            }
+            if (cond.$or !== undefined) {
+                const subConditions = cond.$or
+                    .map((c) => buildCondition(c))
+                    .filter(Boolean);
+                if (subConditions.length > 0) {
+                    logicalParts.push(`(${subConditions.join(' OR ')})`);
+                }
+            }
+            if (cond.$not !== undefined) {
+                const subCondition = buildCondition(cond.$not);
+                if (subCondition) {
+                    logicalParts.push(`NOT (${subCondition})`);
+                }
+            }
+            const fieldParts = [];
+            for (const [key, value] of Object.entries(cond)) {
+                if (key.startsWith('$'))
+                    continue;
+                if (value === null) {
+                    fieldParts.push(`${this.escapeId(key)} IS NULL`);
+                }
+                else if (Array.isArray(value)) {
+                    if (value.length === 0) {
+                        // An empty IN-list matches nothing.
+                        fieldParts.push('1 = 0');
+                    }
+                    else {
+                        const placeholders = value
+                            .map((v) => {
+                            values.push(v);
+                            return `@p${values.length}`;
+                        })
+                            .join(', ');
+                        fieldParts.push(`${this.escapeId(key)} IN (${placeholders})`);
+                    }
+                }
+                else if (value instanceof Date || value instanceof prorm_1.Literal) {
+                    values.push(value);
+                    fieldParts.push(`${this.escapeId(key)} = @p${values.length}`);
+                }
+                else if (value && typeof value === 'object') {
+                    const valueObj = value;
+                    const operatorKeys = Object.keys(valueObj).filter((k) => k.startsWith('$'));
+                    if (operatorKeys.length === 0) {
+                        values.push(value);
+                        fieldParts.push(`${this.escapeId(key)} = @p${values.length}`);
+                        continue;
+                    }
+                    for (const op of operatorKeys) {
+                        const opValue = valueObj[op];
+                        switch (op) {
+                            case '$eq':
+                                values.push(opValue);
+                                fieldParts.push(`${this.escapeId(key)} = @p${values.length}`);
+                                break;
+                            case '$ne':
+                                values.push(opValue);
+                                fieldParts.push(`${this.escapeId(key)} <> @p${values.length}`);
+                                break;
+                            case '$gt':
+                                values.push(opValue);
+                                fieldParts.push(`${this.escapeId(key)} > @p${values.length}`);
+                                break;
+                            case '$gte':
+                                values.push(opValue);
+                                fieldParts.push(`${this.escapeId(key)} >= @p${values.length}`);
+                                break;
+                            case '$lt':
+                                values.push(opValue);
+                                fieldParts.push(`${this.escapeId(key)} < @p${values.length}`);
+                                break;
+                            case '$lte':
+                                values.push(opValue);
+                                fieldParts.push(`${this.escapeId(key)} <= @p${values.length}`);
+                                break;
+                            case '$like':
+                                values.push(opValue);
+                                fieldParts.push(`${this.escapeId(key)} LIKE @p${values.length}`);
+                                break;
+                            case '$notLike':
+                                values.push(opValue);
+                                fieldParts.push(`${this.escapeId(key)} NOT LIKE @p${values.length}`);
+                                break;
+                            case '$in': {
+                                const inValues = opValue || [];
+                                if (inValues.length === 0) {
+                                    fieldParts.push('1 = 0');
+                                }
+                                else {
+                                    const placeholders = inValues
+                                        .map((v) => {
+                                        values.push(v);
+                                        return `@p${values.length}`;
+                                    })
+                                        .join(', ');
+                                    fieldParts.push(`${this.escapeId(key)} IN (${placeholders})`);
+                                }
+                                break;
+                            }
+                            case '$notIn': {
+                                const notInValues = opValue || [];
+                                if (notInValues.length === 0) {
+                                    fieldParts.push('1 = 1');
+                                }
+                                else {
+                                    const placeholders = notInValues
+                                        .map((v) => {
+                                        values.push(v);
+                                        return `@p${values.length}`;
+                                    })
+                                        .join(', ');
+                                    fieldParts.push(`${this.escapeId(key)} NOT IN (${placeholders})`);
+                                }
+                                break;
+                            }
+                            case '$between': {
+                                const [lo, hi] = opValue;
+                                values.push(lo, hi);
+                                fieldParts.push(`${this.escapeId(key)} BETWEEN @p${values.length - 1} AND @p${values.length}`);
+                                break;
+                            }
+                            case '$notBetween': {
+                                const [lo, hi] = opValue;
+                                values.push(lo, hi);
+                                fieldParts.push(`${this.escapeId(key)} NOT BETWEEN @p${values.length - 1} AND @p${values.length}`);
+                                break;
+                            }
+                            case '$isNull':
+                                fieldParts.push(opValue ? `${this.escapeId(key)} IS NULL` : `${this.escapeId(key)} IS NOT NULL`);
+                                break;
+                            default:
+                                throw new Error(`Unsupported WHERE operator "${op}" for the MSSQL dialect. ` +
+                                    'Supported operators: $eq, $ne, $gt, $gte, $lt, $lte, $like, $notLike, ' +
+                                    '$in, $notIn, $between, $notBetween, $isNull, $and, $or, $not.');
+                        }
+                    }
+                }
+                else {
+                    values.push(value);
+                    fieldParts.push(`${this.escapeId(key)} = @p${values.length}`);
+                }
+            }
+            return [...logicalParts, ...fieldParts].join(' AND ');
+        };
+        const sql = buildCondition(where);
+        return { sql, values };
+    }
+    buildOrderClause(order, _options) {
+        if (!order || (Array.isArray(order) && order.length === 0))
+            return '';
+        const orderParts = [];
+        const processOrder = (orderItem) => {
+            if (typeof orderItem === 'string') {
+                const parts = orderItem.split(' ');
+                if (parts.length === 1) {
+                    orderParts.push(this.escapeId(parts[0]));
+                }
+                else {
+                    orderParts.push(`${this.escapeId(parts[0])} ${parts[1].toUpperCase()}`);
+                }
+            }
+            else if (typeof orderItem === 'object' && orderItem !== null) {
+                for (const [key, value] of Object.entries(orderItem)) {
+                    if (key === '$raw') {
+                        orderParts.push(String(value));
+                    }
+                    else {
+                        const direction = value?.toUpperCase() || 'ASC';
+                        orderParts.push(`${this.escapeId(key)} ${direction}`);
+                    }
+                }
+            }
+        };
+        if (Array.isArray(order)) {
+            order.forEach(processOrder);
+        }
+        else {
+            processOrder(order);
+        }
+        return orderParts.length > 0 ? `ORDER BY ${orderParts.join(', ')}` : '';
+    }
+    buildLimitOffset(limit, offset, hasOrderBy = false) {
+        let sql = '';
+        if (offset !== undefined || limit !== undefined) {
+            // SQL Server requires an ORDER BY clause to precede OFFSET/FETCH — without
+            // one, SQL Server raises "The OFFSET clause is not allowed... unless
+            // ORDER BY is also specified." Callers that know they already emitted an
+            // ORDER BY should pass hasOrderBy=true; otherwise we inject a harmless
+            // no-op ORDER BY so pagination still works instead of failing at runtime.
+            if (!hasOrderBy) {
+                sql += ' ORDER BY (SELECT NULL)';
+            }
+            // SQL Server requires OFFSET to precede FETCH; default to 0 rows skipped
+            // when only a limit is supplied.
+            sql += ` OFFSET ${Number(offset ?? 0)} ROWS`;
+        }
+        if (limit !== undefined) {
+            sql += ` FETCH NEXT ${Number(limit)} ROWS ONLY`;
+        }
+        return sql;
+    }
+    buildInsertQuery(tableName, values, options) {
+        const columns = Object.keys(values);
+        const processedValues = [];
+        const placeholders = [];
+        for (const value of Object.values(values)) {
+            if (value instanceof prorm_1.Literal) {
+                placeholders.push(value.val);
+            }
+            else {
+                processedValues.push(value);
+                placeholders.push(`@p${processedValues.length}`);
+            }
+        }
+        let sql = `INSERT INTO ${this.escapeId(tableName)} (${columns.map((c) => this.escapeId(c)).join(', ')}) VALUES (${placeholders.join(', ')})`;
+        if (options?.returning) {
+            if (options.returning === true) {
+                sql += ' OUTPUT INSERTED.*';
+            }
+            else if (Array.isArray(options.returning)) {
+                sql += ` OUTPUT INSERTED.${options.returning.map((c) => this.escapeId(c)).join(', INSERTED.')}`;
+            }
+        }
+        return { sql, values: processedValues };
+    }
+    /**
+     * Execute a single-row INSERT, optionally toggling `IDENTITY_INSERT` for
+     * tables where an explicit value is being supplied for an IDENTITY column
+     * (see `MSSQLInsertOptions.identityInsert`). Unlike `buildInsertQuery`
+     * (which only builds SQL text), this method actually runs the query, which
+     * is required to bracket it with `SET IDENTITY_INSERT ... ON/OFF`.
+     */
+    async insert(tableName, values, options) {
+        const { sql, values: queryValues } = this.buildInsertQuery(tableName, values, options);
+        if (!options?.identityInsert) {
+            return this.query(sql, { replacements: queryValues });
+        }
+        const table = this.quoteTable(tableName, options?.schema);
+        await this.query(`SET IDENTITY_INSERT ${table} ON`);
+        try {
+            return await this.query(sql, { replacements: queryValues });
+        }
+        finally {
+            // Always turn IDENTITY_INSERT back off, even on failure, since it's a
+            // session-level setting and only one table per session may have it on.
+            await this.query(`SET IDENTITY_INSERT ${table} OFF`);
+        }
+    }
+    buildUpdateQuery(tableName, values, where, options) {
+        const processedValues = [];
+        const setClauses = [];
+        for (const [key, value] of Object.entries(values)) {
+            if (value instanceof prorm_1.Literal) {
+                setClauses.push(`${this.escapeId(key)} = ${value.val}`);
+            }
+            else {
+                processedValues.push(value);
+                setClauses.push(`${this.escapeId(key)} = @p${processedValues.length}`);
+            }
+        }
+        let sql = `UPDATE ${this.escapeId(tableName)} SET ${setClauses.join(', ')}`;
+        if (where && Object.keys(where).length > 0) {
+            const whereClause = this.buildWhereClause(where);
+            sql += ` WHERE ${whereClause.sql}`;
+            processedValues.push(...whereClause.values);
+        }
+        if (options?.limit) {
+            sql = sql.replace('UPDATE', `UPDATE TOP(${options.limit})`);
+        }
+        if (options?.returning) {
+            if (options.returning === true) {
+                sql += ' OUTPUT INSERTED.*';
+            }
+            else if (Array.isArray(options.returning)) {
+                sql += ` OUTPUT INSERTED.${options.returning.map((c) => this.escapeId(c)).join(', INSERTED.')}`;
+            }
+        }
+        return { sql, values: processedValues };
+    }
+    buildDeleteQuery(tableName, where, options) {
+        let sql = `DELETE FROM ${this.escapeId(tableName)}`;
+        const processedValues = [];
+        if (where && Object.keys(where).length > 0) {
+            const whereClause = this.buildWhereClause(where);
+            sql += ` WHERE ${whereClause.sql}`;
+            processedValues.push(...whereClause.values);
+        }
+        if (options?.limit) {
+            sql = sql.replace('DELETE', `DELETE TOP(${options.limit})`);
+        }
+        if (options?.returning) {
+            if (options.returning === true) {
+                sql += ' OUTPUT DELETED.*';
+            }
+            else if (Array.isArray(options.returning)) {
+                sql += ` OUTPUT DELETED.${options.returning.map((c) => this.escapeId(c)).join(', DELETED.')}`;
+            }
+        }
+        return { sql, values: processedValues };
+    }
+    /**
+     * Render one CTE definition as `name [(cols)] AS (query)`.
+     */
+    buildCteDefinition(cte) {
+        const nameSql = this.escapeId(cte.name);
+        const columnsSql = cte.columns && cte.columns.length > 0
+            ? ` (${cte.columns.map((c) => this.escapeId(c)).join(', ')})`
+            : '';
+        return `${nameSql}${columnsSql} AS (${cte.query})`;
+    }
+    /**
+     * Build the `WITH cte1 AS (...), cte2 AS (...)` prefix for a SELECT.
+     * T-SQL (unlike Postgres/SQLite) never uses a `RECURSIVE` keyword — even
+     * recursive CTEs are introduced with plain `WITH`. The `recursive` flag on
+     * each definition is accepted for API parity with other dialects but does
+     * not change the emitted SQL.
+     */
+    buildCteClause(ctes) {
+        if (!ctes || ctes.length === 0)
+            return '';
+        return `WITH ${ctes.map((c) => this.buildCteDefinition(c)).join(', ')} `;
+    }
+    /**
+     * Format a single SELECT-list attribute, handling plain column names as
+     * well as the `[expr, alias]` tuple / `col()` / `fn()` / `literal()`
+     * expression shapes produced by helpers such as the window-function
+     * builders in `src/query-builders/functions/window.ts` (`.as('alias')`
+     * returns `[{ __type: 'literal', sql }, alias]`).
+     */
+    formatAttribute(attr) {
+        if (attr === '*')
+            return '*';
+        if (Array.isArray(attr)) {
+            const [expr, alias] = attr;
+            const exprSql = this.formatAttributeExpr(expr);
+            return alias ? `${exprSql} AS ${this.escapeId(String(alias))}` : exprSql;
+        }
+        return this.formatAttributeExpr(attr);
+    }
+    formatAttributeExpr(expr) {
+        if (expr !== null && typeof expr === 'object') {
+            const e = expr;
+            if (e.__type === 'literal' || '$literal' in e) {
+                return (e.sql ?? e.$literal);
+            }
+            if (e.__type === 'col' && e.col) {
+                return this.escapeId(e.col);
+            }
+        }
+        if (typeof expr === 'string') {
+            return this.escapeId(expr);
+        }
+        return String(expr);
+    }
+    buildSelectQuery(options) {
+        // Captured so the TOP-clause insertion below can be scoped to the outer
+        // query only — a CTE body is itself a SELECT statement, so a blind
+        // `sql.replace('SELECT', ...)` over the whole accumulated string would
+        // otherwise splice TOP(n) into the CTE's inner SELECT instead of the
+        // outer one whenever a `cte`/`with` option is present.
+        const cteClause = this.buildCteClause(options.cte || options.with);
+        let sql = cteClause + 'SELECT';
+        const queryValues = [];
+        if (options.distinct)
+            sql += ' DISTINCT';
+        if (options.attributes) {
+            if (Array.isArray(options.attributes)) {
+                sql += ` ${options.attributes.map((c) => this.formatAttribute(c)).join(', ')}`;
+            }
+        }
+        else {
+            sql += ' *';
+        }
+        const tableName = this.quoteTable(options.tableName, options.schema);
+        sql += ` FROM ${tableName}`;
+        // SQL Server system-versioned temporal table clause. Must immediately
+        // follow the table reference, before any JOINs/WHERE/etc.
+        if (options.temporalAsOf) {
+            sql += ` FOR SYSTEM_TIME AS OF ${this.escape(options.temporalAsOf)}`;
+        }
+        else if (options.temporalBetween) {
+            const [start, end] = options.temporalBetween;
+            sql += ` FOR SYSTEM_TIME BETWEEN ${this.escape(start)} AND ${this.escape(end)}`;
+        }
+        else if (options.temporalAll) {
+            sql += ' FOR SYSTEM_TIME ALL';
+        }
+        if (options.include && options.include.length > 0) {
+            for (const include of options.include) {
+                // CROSS APPLY / OUTER APPLY — a lateral join, needed for anything an
+                // ordinary JOIN can't express: invoking a table-valued function (or a
+                // correlated subquery that references outer columns) once per outer
+                // row. This is also how OPENJSON's row-shredding output gets joined
+                // back to the driving table on a per-row basis.
+                const includeAny = include;
+                if (includeAny.apply) {
+                    const applyType = String(includeAny.apply).toUpperCase() === 'OUTER' ? 'OUTER APPLY' : 'CROSS APPLY';
+                    const applySource = includeAny.tableFunction || includeAny.subquery;
+                    if (!applySource) {
+                        throw new Error('APPLY join requires a "tableFunction" or "subquery" expression on the include (e.g. include.tableFunction = "OPENJSON(t.data)")');
+                    }
+                    const aliasSql = include.as ? ` AS ${this.escapeId(include.as)}` : '';
+                    sql += ` ${applyType} ${applySource}${aliasSql}`;
+                    continue;
+                }
+                const joinType = include.required ? 'INNER JOIN' : 'LEFT JOIN';
+                const joinModel = include.model;
+                const joinTableName = joinModel.tableName || joinModel.name || '';
+                const joinAlias = include.as || joinTableName;
+                sql += ` ${joinType} ${this.quoteTable(joinTableName)} AS ${this.escapeId(joinAlias)}`;
+                if (include.on) {
+                    const onClause = this.buildWhereClause(include.on);
+                    sql += ` ON ${onClause.sql}`;
+                    queryValues.push(...onClause.values);
+                }
+            }
+        }
+        if (options.where && Object.keys(options.where).length > 0) {
+            const whereClause = this.buildWhereClause(options.where);
+            sql += ` WHERE ${whereClause.sql}`;
+            queryValues.push(...whereClause.values);
+        }
+        if (options.group) {
+            const groupBy = Array.isArray(options.group) ? options.group : [options.group];
+            sql += ` GROUP BY ${groupBy.map((g) => this.escapeId(g)).join(', ')}`;
+            if (options.having && Object.keys(options.having).length > 0) {
+                const havingClause = this.buildWhereClause(options.having);
+                sql += ` HAVING ${havingClause.sql}`;
+                queryValues.push(...havingClause.values);
+            }
+        }
+        let orderClause = '';
+        if (options.order) {
+            orderClause = this.buildOrderClause(options.order);
+            if (orderClause)
+                sql += ` ${orderClause}`;
+        }
+        // SQL Server does not allow TOP and OFFSET/FETCH in the same SELECT statement.
+        // Use TOP for a simple limit with no offset; use OFFSET/FETCH for pagination.
+        if (options.offset !== undefined) {
+            sql += this.buildLimitOffset(options.limit, options.offset, !!orderClause);
+        }
+        else if (options.limit !== undefined) {
+            // T-SQL requires TOP to come after DISTINCT: `SELECT DISTINCT TOP(n) ...`,
+            // not `SELECT TOP(n) DISTINCT ...`. A blind `sql.replace('SELECT', ...)`
+            // would insert TOP before DISTINCT since 'SELECT' is matched first.
+            const topClause = `TOP(${Number(options.limit)})`;
+            // Scope the replace to everything after the CTE prefix (see comment
+            // above `cteClause`) so a `SELECT` inside a CTE body never gets matched
+            // instead of the outer query's own SELECT.
+            const head = sql.slice(0, cteClause.length);
+            const rest = sql.slice(cteClause.length);
+            const newRest = options.distinct
+                ? rest.replace('SELECT DISTINCT', `SELECT DISTINCT ${topClause}`)
+                : rest.replace('SELECT', `SELECT ${topClause}`);
+            sql = head + newRest;
+        }
+        // `FOR JSON` must be the last clause in the statement — always append it
+        // after TOP/OFFSET-FETCH have already been spliced in above.
+        if (options.forJson) {
+            const { mode, root, includeNullValues, withoutArrayWrapper } = options.forJson;
+            let forJsonSql = `FOR JSON ${mode}`;
+            const jsonOptions = [];
+            if (root)
+                jsonOptions.push(`ROOT('${root.replace(/'/g, "''")}')`);
+            if (includeNullValues)
+                jsonOptions.push('INCLUDE_NULL_VALUES');
+            if (withoutArrayWrapper)
+                jsonOptions.push('WITHOUT_ARRAY_WRAPPER');
+            if (jsonOptions.length > 0)
+                forJsonSql += `, ${jsonOptions.join(', ')}`;
+            sql += ` ${forJsonSql}`;
+        }
+        return { sql, values: queryValues };
+    }
+    buildUpsertQuery(tableName, values, options) {
+        const columns = Object.keys(values);
+        const queryValues = Object.values(values);
+        const updateFields = options?.updateOnDuplicate && options.updateOnDuplicate.length > 0
+            ? options.updateOnDuplicate
+            : columns;
+        const conflictFields = options?.conflictFields || columns;
+        const sourceValues = columns.map((c, i) => `@p${i + 1} AS ${this.escapeId(c)}`).join(', ');
+        const onClauses = conflictFields
+            .map((c) => `target.${this.escapeId(c)} = source.${this.escapeId(c)}`)
+            .join(' AND ');
+        const updateSet = updateFields
+            .map((c) => `${this.escapeId(c)} = source.${this.escapeId(c)}`)
+            .join(', ');
+        const insertColumns = columns.map((c) => this.escapeId(c)).join(', ');
+        const insertValues = columns.map((c) => `source.${this.escapeId(c)}`).join(', ');
+        let sql = `MERGE INTO ${this.escapeId(tableName)} AS target USING (SELECT ${sourceValues}) AS source ON ${onClauses} WHEN MATCHED THEN UPDATE SET ${updateSet} WHEN NOT MATCHED THEN INSERT (${insertColumns}) VALUES (${insertValues})`;
+        if (options?.returning) {
+            if (options.returning === true) {
+                sql += ' OUTPUT INSERTED.*';
+            }
+            else if (Array.isArray(options.returning)) {
+                sql += ` OUTPUT INSERTED.${options.returning.map((c) => this.escapeId(c)).join(', INSERTED.')}`;
+            }
+        }
+        // SQL Server requires MERGE statements to be terminated with a semicolon.
+        sql += ';';
+        return { sql, values: queryValues };
+    }
+    buildIncrementQuery(tableName, fields, where, options) {
+        const by = options?.by ?? 1;
+        const queryValues = [];
+        let setClauses;
+        if (typeof fields === 'string') {
+            queryValues.push(by);
+            setClauses = [`${this.escapeId(fields)} = ${this.escapeId(fields)} + @p1`];
+        }
+        else if (Array.isArray(fields)) {
+            setClauses = fields.map((field, index) => {
+                queryValues.push(by);
+                return `${this.escapeId(field)} = ${this.escapeId(field)} + @p${index + 1}`;
+            });
+        }
+        else {
+            setClauses = Object.entries(fields).map(([field, value], index) => {
+                queryValues.push(value);
+                return `${this.escapeId(field)} = ${this.escapeId(field)} + @p${index + 1}`;
+            });
+        }
+        let sql = `UPDATE ${this.escapeId(tableName)} SET ${setClauses.join(', ')}`;
+        if (where && Object.keys(where).length > 0) {
+            const whereClause = this.buildWhereClause(where);
+            sql += ` WHERE ${whereClause.sql}`;
+            queryValues.push(...whereClause.values);
+        }
+        return { sql, values: queryValues };
+    }
+    buildJsonExtract(column, path, asText = true) {
+        const columnRef = this.escapeId(column);
+        const normalizedPath = path.startsWith('$.') ? path : `$.${path}`;
+        if (asText)
+            return `JSON_VALUE(${columnRef}, '${normalizedPath}')`;
+        return `JSON_QUERY(${columnRef}, '${normalizedPath}')`;
+    }
+    // Foreign Data Wrapper stubs - not supported in MSSQL
+    buildCreateServerQuery(_name, _opts) {
+        throw new Error('Foreign Data Wrappers are not supported by MSSQL. This is a PostgreSQL-specific feature. Consider using MSSQL linked servers (sp_addlinkedserver) instead.');
+    }
+    buildAlterServerQuery(_name, _opts) {
+        throw new Error('Foreign Data Wrappers are not supported by MSSQL. This is a PostgreSQL-specific feature. Consider using MSSQL linked servers (sp_addlinkedserver) instead.');
+    }
+    buildDropServerQuery(_name, _opts) {
+        throw new Error('Foreign Data Wrappers are not supported by MSSQL. This is a PostgreSQL-specific feature. Consider using MSSQL linked servers (sp_addlinkedserver) instead.');
+    }
+    buildCreateUserMappingQuery(_opts) {
+        throw new Error('Foreign Data Wrappers are not supported by MSSQL. This is a PostgreSQL-specific feature. Consider using MSSQL linked servers (sp_addlinkedserver) instead.');
+    }
+    buildAlterUserMappingQuery(_opts) {
+        throw new Error('Foreign Data Wrappers are not supported by MSSQL. This is a PostgreSQL-specific feature. Consider using MSSQL linked servers (sp_addlinkedserver) instead.');
+    }
+    buildDropUserMappingQuery(_serverName, _user, _opts) {
+        throw new Error('Foreign Data Wrappers are not supported by MSSQL. This is a PostgreSQL-specific feature. Consider using MSSQL linked servers (sp_addlinkedserver) instead.');
+    }
+    buildCreateForeignTableQuery(_tableName, _opts) {
+        throw new Error('Foreign Data Wrappers are not supported by MSSQL. This is a PostgreSQL-specific feature. Consider using MSSQL linked servers (sp_addlinkedserver) instead.');
+    }
+    buildDropForeignTableQuery(_tableName, _opts) {
+        throw new Error('Foreign Data Wrappers are not supported by MSSQL. This is a PostgreSQL-specific feature. Consider using MSSQL linked servers (sp_addlinkedserver) instead.');
+    }
+    buildImportForeignSchemaQuery(_remoteSchema, _serverName, _opts) {
+        throw new Error('Foreign Data Wrappers are not supported by MSSQL. This is a PostgreSQL-specific feature. Consider using MSSQL linked servers (sp_addlinkedserver) instead.');
+    }
+    getServersQuery() {
+        throw new Error('Foreign Data Wrappers are not supported by MSSQL. This is a PostgreSQL-specific feature. Consider using MSSQL linked servers (sp_addlinkedserver) instead.');
+    }
+    // Foreign Data Wrapper stubs - not supported in MSSQL (async methods)
+    async createForeignDataWrapper(_fdwName, _options) {
+        throw new Error('Foreign Data Wrappers are not supported by MSSQL. This is a PostgreSQL-specific feature. Consider using MSSQL linked servers (sp_addlinkedserver) instead.');
+    }
+    async dropForeignDataWrapper(_fdwName, _options) {
+        throw new Error('Foreign Data Wrappers are not supported by MSSQL. This is a PostgreSQL-specific feature. Consider using MSSQL linked servers (sp_addlinkedserver) instead.');
+    }
+    async createForeignServer(_serverName, _fdwName, _options) {
+        throw new Error('Foreign Data Wrappers are not supported by MSSQL. This is a PostgreSQL-specific feature. Consider using MSSQL linked servers (sp_addlinkedserver) instead.');
+    }
+    async dropForeignServer(_serverName, _options) {
+        throw new Error('Foreign Data Wrappers are not supported by MSSQL. This is a PostgreSQL-specific feature. Consider using MSSQL linked servers (sp_addlinkedserver) instead.');
+    }
+    async createForeignTable(_tableName, _columns, _options) {
+        throw new Error('Foreign Data Wrappers are not supported by MSSQL. This is a PostgreSQL-specific feature. Consider using MSSQL linked servers (sp_addlinkedserver) instead.');
+    }
+    async createUserMapping(_serverName, _userName, _options) {
+        throw new Error('Foreign Data Wrappers are not supported by MSSQL. This is a PostgreSQL-specific feature. Consider using MSSQL linked servers (sp_addlinkedserver) instead.');
+    }
+    async dropUserMapping(_serverName, _userName, _options) {
+        throw new Error('Foreign Data Wrappers are not supported by MSSQL. This is a PostgreSQL-specific feature. Consider using MSSQL linked servers (sp_addlinkedserver) instead.');
+    }
+    async changeOwner(_newOwner, _tableName) {
+        throw new Error('changeOwner is not supported in MSSQL');
+    }
+    async addConstraint(_tableName, _options) {
+        throw new Error('addConstraint is not supported in MSSQL');
+    }
+    async removeConstraint(_tableName, _constraintName) {
+        throw new Error('removeConstraint is not supported in MSSQL');
+    }
+    async createSecurityPolicy(policyName, tableName, options) {
+        const schema = options?.schema || 'dbo';
+        // A security predicate is a function-call expression (e.g.
+        // "dbo.fn_security_predicate(col)"), not an identifier — bracket-escaping
+        // it with escapeId() would corrupt the SQL (e.g. turn it into the
+        // meaningless identifier "[dbo.fn_security_predicate(col)]"). It must be
+        // spliced in raw, the same way createPolicy() handles predicateFunction.
+        const predicate = options?.predicate || '(1=1)';
+        const sql = `CREATE SECURITY POLICY ${this.escapeId(policyName)} ADD FILTER PREDICATE ${predicate} ON ${this.escapeId(schema)}.${this.escapeId(tableName)}`;
+        await this.query(sql);
+    }
+    async dropSecurityPolicy(policyName, tableName) {
+        const sql = `DROP SECURITY POLICY ${this.escapeId(policyName)}`;
+        await this.query(sql);
+    }
+    /**
+     * Compute the maximum number of rows per multi-row `INSERT ... VALUES`
+     * statement for a table with `columnsPerRow` columns, respecting two
+     * distinct T-SQL limits:
+     *  - A table-value constructor (`VALUES (...), (...), ...`) is capped at
+     *    1,000 rows.
+     *  - A single parameterized batch/RPC is capped at 2,100 parameters.
+     * The smaller of the two (per row) wins.
+     */
+    maxBulkInsertRowsPerBatch(columnsPerRow) {
+        const paramLimited = Math.floor(2100 / Math.max(1, columnsPerRow));
+        return Math.max(1, Math.min(1000, paramLimited));
+    }
+    /**
+     * Bulk insert records into a table.
+     *
+     * T-SQL caps a single `INSERT ... VALUES (...), (...), ...` statement at
+     * 1,000 rows (table-value constructor limit) and 2,100 parameters per
+     * batch. For batches that would exceed either limit, this splits the
+     * records into multiple INSERT statements, executed inside a single
+     * `BEGIN TRANSACTION` / `COMMIT TRANSACTION` so the whole call stays
+     * atomic (SQL Server nests transactions via `@@TRANCOUNT`, so this is safe
+     * even if the caller already has an outer transaction open — only the
+     * outermost COMMIT actually commits, and a ROLLBACK at any nesting level
+     * rolls back the entire transaction, mirroring the BEGIN/COMMIT/ROLLBACK
+     * TRANSACTION pattern already used by `startTransaction`/`commitTransaction`
+     * /`rollbackTransaction` on this dialect).
+     */
+    async bulkInsert(tableName, records, options) {
+        if (records.length === 0) {
+            return { rows: [], rowCount: 0, fields: [] };
+        }
+        const columns = Object.keys(records[0]);
+        const table = this.quoteTable(tableName, options?.schema);
+        const columnList = columns.map((c) => this.escapeId(c)).join(', ');
+        const safeMaxRows = this.maxBulkInsertRowsPerBatch(columns.length);
+        const rowsPerBatch = options?.batchSize && options.batchSize > 0
+            ? Math.min(options.batchSize, safeMaxRows)
+            : safeMaxRows;
+        const chunks = [];
+        for (let i = 0; i < records.length; i += rowsPerBatch) {
+            chunks.push(records.slice(i, i + rowsPerBatch));
+        }
+        const buildChunkSql = (chunk) => {
+            const values = [];
+            const placeholders = [];
+            for (const record of chunk) {
+                const rowPlaceholders = [];
+                for (const column of columns) {
+                    rowPlaceholders.push(`@p${values.length + 1}`);
+                    values.push(record[column]);
+                }
+                placeholders.push(`(${rowPlaceholders.join(', ')})`);
+            }
+            let sql = `INSERT INTO ${table} (${columnList}) VALUES ${placeholders.join(', ')}`;
+            if (options?.returning) {
+                if (options.returning === true) {
+                    sql += ' OUTPUT INSERTED.*';
+                }
+                else if (Array.isArray(options.returning)) {
+                    sql += ` OUTPUT INSERTED.${options.returning.map((c) => this.escapeId(c)).join(', INSERTED.')}`;
+                }
+            }
+            return { sql, values };
+        };
+        const aggregated = { rows: [], rowCount: 0, fields: [] };
+        const needsTransaction = chunks.length > 1;
+        const identityInsert = options?.identityInsert === true;
+        if (identityInsert) {
+            await this.query(`SET IDENTITY_INSERT ${table} ON`);
+        }
+        try {
+            if (needsTransaction) {
+                await this.query('BEGIN TRANSACTION');
+            }
+            try {
+                for (const chunk of chunks) {
+                    const { sql, values } = buildChunkSql(chunk);
+                    const result = await this.query(sql, { replacements: values });
+                    aggregated.rows.push(...result.rows);
+                    aggregated.rowCount += result.rowCount;
+                    if (result.fields.length > 0 && aggregated.fields.length === 0) {
+                        aggregated.fields = result.fields;
+                    }
+                }
+                if (needsTransaction) {
+                    await this.query('COMMIT TRANSACTION');
+                }
+            }
+            catch (error) {
+                if (needsTransaction) {
+                    await this.query('ROLLBACK TRANSACTION');
+                }
+                throw error;
+            }
+        }
+        finally {
+            if (identityInsert) {
+                // Always turn IDENTITY_INSERT back off, even on failure, since it's
+                // a session-level setting and only one table per session may have
+                // it on at a time.
+                await this.query(`SET IDENTITY_INSERT ${table} OFF`);
+            }
+        }
+        return aggregated;
+    }
+    /**
+     * Add a foreign key to a table
+     */
+    async addForeignKey(tableName, columnName, referencedTableName, referencedColumnName, options) {
+        const constraintName = options?.name || `${tableName}_${columnName}_fkey`;
+        let sql = `ALTER TABLE ${this.quoteTable(tableName)} ADD CONSTRAINT ${this.escapeId(constraintName)} FOREIGN KEY (${this.escapeId(columnName)}) REFERENCES ${this.quoteTable(referencedTableName)}(${this.escapeId(referencedColumnName)})`;
+        const clauses = [];
+        if (options?.onDelete) {
+            clauses.push(`ON DELETE ${options.onDelete}`);
+        }
+        if (options?.onUpdate) {
+            clauses.push(`ON UPDATE ${options.onUpdate}`);
+        }
+        if (clauses.length > 0) {
+            sql += ' ' + clauses.join(' ');
+        }
+        await this.query(sql);
+    }
+    /**
+     * Rename a column
+     */
+    async renameColumn(tableName, oldColumnName, newColumnName) {
+        const sql = `EXEC sp_rename @objname = @objName, @newname = @newColumnName, @objtype = 'COLUMN'`;
+        await this.query(sql, {
+            bindings: { objName: `${tableName}.${oldColumnName}`, newColumnName },
+        });
+    }
+    /**
+     * Create a fulltext index (MSSQL supports fulltext search).
+     *
+     * SQL Server fulltext indexes are always keyed off a pre-existing UNIQUE
+     * (usually the primary key) index on the table — `keyIndexName` must name
+     * that existing index, not the fulltext index itself (fulltext indexes
+     * don't have their own name in T-SQL). Fulltext indexes also always belong
+     * to a fulltext catalog; this method creates the catalog if it doesn't
+     * already exist before issuing `CREATE FULLTEXT INDEX`.
+     *
+     * Real syntax produced:
+     *   CREATE FULLTEXT INDEX ON table (col1, col2) KEY INDEX <keyIndexName> ON <catalogName>
+     */
+    async createFulltextIndex(tableName, keyIndexName, fields, options) {
+        const catalogName = options?.catalogName || 'default_fulltext_catalog';
+        if (options?.createCatalog !== false) {
+            await this.query(`IF NOT EXISTS (SELECT 1 FROM sys.fulltext_catalogs WHERE name = '${catalogName}') CREATE FULLTEXT CATALOG ${this.escapeId(catalogName)}`);
+        }
+        const languageClause = options?.parser ? ` LANGUAGE ${options.parser}` : '';
+        const columnList = fields.map((f) => `${this.escapeId(f)}${languageClause}`).join(', ');
+        const sql = `CREATE FULLTEXT INDEX ON ${this.quoteTable(tableName)} (${columnList}) KEY INDEX ${this.escapeId(keyIndexName)} ON ${this.escapeId(catalogName)}`;
+        await this.query(sql);
+    }
+    /**
+     * Create a spatial index (MSSQL supports spatial indexes)
+     */
+    async createSpatialIndex(tableName, indexName, fields, options) {
+        const sql = `CREATE SPATIAL INDEX ${this.escapeId(indexName)} ON ${this.quoteTable(tableName)} (${fields.map((f) => this.escapeId(f)).join(', ')})`;
+        await this.query(sql);
+    }
+    // ---- User Management (MSSQL) ----
+    /**
+     * Build CREATE LOGIN and CREATE USER statements for MSSQL.
+     * MSSQL uses LOGIN for server-level authentication and USER for database-level access.
+     */
+    buildCreateUserQuery(username, options = {}) {
+        const loginName = this.escapeId(username);
+        const password = options.password || '';
+        // CREATE LOGIN statement (server-level)
+        let loginSql = 'CREATE LOGIN';
+        if (options.ifNotExists) {
+            loginSql = `IF NOT EXISTS (SELECT name FROM sys.server_principals WHERE name = '${username}') CREATE LOGIN`;
+        }
+        loginSql += ` ${loginName} WITH PASSWORD = '${this.escapePassword(password)}'`;
+        // CREATE USER statement (database-level)
+        const userSql = `CREATE USER ${this.escapeId(username)} FOR LOGIN ${loginName}`;
+        return `${loginSql}; ${userSql}`;
+    }
+    escapePassword(password) {
+        return password.replace(/'/g, "''");
+    }
+    /**
+     * Build ALTER LOGIN and ALTER USER statements for MSSQL.
+     */
+    buildAlterUserQuery(username, options) {
+        const loginName = this.escapeId(username);
+        let sql = `ALTER LOGIN ${loginName}`;
+        if (options.password) {
+            sql += ` WITH PASSWORD = '${this.escapePassword(options.password)}'`;
+        }
+        if (options.unlockAccount) {
+            sql += ' UNLOCK';
+        }
+        else if (options.accountLocked) {
+            sql += ' DISABLE';
+        }
+        return sql;
+    }
+    /**
+     * Build DROP USER and DROP LOGIN statements for MSSQL.
+     * Must drop USER first, then LOGIN (due to dependencies).
+     */
+    buildDropUserQuery(username, options) {
+        const userName = this.escapeId(username);
+        const loginName = this.escapeId(username);
+        let userSql = 'DROP USER';
+        let loginSql = 'DROP LOGIN';
+        if (options?.ifExists) {
+            userSql = `IF EXISTS (SELECT name FROM sys.database_principals WHERE name = '${username}' AND type = 'U') DROP USER`;
+            loginSql = `IF EXISTS (SELECT name FROM sys.server_principals WHERE name = '${username}') DROP LOGIN`;
+        }
+        // Must drop USER before LOGIN (database-level depends on server-level)
+        return `${userSql} ${userName}; ${loginSql} ${loginName}`;
+    }
+    /**
+     * Get list of users from MSSQL.
+     */
+    getUsersQuery() {
+        return `SELECT name AS user, type_desc AS type, create_date, modify_date
+      FROM sys.database_principals
+      WHERE type IN ('U', 'S')
+      AND name NOT LIKE '#%'`;
+    }
+    /**
+     * Build GRANT statement for MSSQL.
+     */
+    buildGrantQuery(options) {
+        const privileges = options.privileges.join(', ');
+        let scopeSql;
+        switch (options.on.level) {
+            case 'global':
+                scopeSql = '*.*';
+                break;
+            case 'database':
+                scopeSql = `${this.escapeId(options.on.database)}.*`;
+                break;
+            case 'table': {
+                const db = options.on.database ? `${this.escapeId(options.on.database)}.` : '';
+                scopeSql = `${db}${this.escapeId(options.on.table)}`;
+                break;
+            }
+            case 'column': {
+                const dbCol = options.on.database ? `${this.escapeId(options.on.database)}.` : '';
+                const cols = options.on.columns.map((c) => this.escapeId(c)).join(', ');
+                scopeSql = `${dbCol}${this.escapeId(options.on.table)} (${cols})`;
+                break;
+            }
+            case 'routine': {
+                const dbRoutine = options.on.database ? `${this.escapeId(options.on.database)}.` : '';
+                const routineType = options.on.routineType || 'PROCEDURE';
+                scopeSql = `${routineType} ${dbRoutine}${this.escapeId(options.on.routine)}`;
+                break;
+            }
+            default:
+                scopeSql = '*.*';
+        }
+        const recipients = (Array.isArray(options.to) ? options.to : [options.to])
+            .map((r) => this.escapeId(r))
+            .join(', ');
+        let sql = `GRANT ${privileges} ON ${scopeSql} TO ${recipients}`;
+        if (options.withGrantOption) {
+            sql += ' WITH GRANT OPTION';
+        }
+        return sql;
+    }
+    /**
+     * Build REVOKE statement for MSSQL.
+     */
+    buildRevokeQuery(options) {
+        const privileges = options.privileges.join(', ');
+        let scopeSql;
+        switch (options.on.level) {
+            case 'global':
+                scopeSql = '*.*';
+                break;
+            case 'database':
+                scopeSql = `${this.escapeId(options.on.database)}.*`;
+                break;
+            case 'table': {
+                const db = options.on.database ? `${this.escapeId(options.on.database)}.` : '';
+                scopeSql = `${db}${this.escapeId(options.on.table)}`;
+                break;
+            }
+            case 'column': {
+                const dbCol = options.on.database ? `${this.escapeId(options.on.database)}.` : '';
+                const cols = options.on.columns.map((c) => this.escapeId(c)).join(', ');
+                scopeSql = `${dbCol}${this.escapeId(options.on.table)} (${cols})`;
+                break;
+            }
+            case 'routine': {
+                const dbRoutine = options.on.database ? `${this.escapeId(options.on.database)}.` : '';
+                const routineType = options.on.routineType || 'PROCEDURE';
+                scopeSql = `${routineType} ${dbRoutine}${this.escapeId(options.on.routine)}`;
+                break;
+            }
+            default:
+                scopeSql = '*.*';
+        }
+        const targets = (Array.isArray(options.from) ? options.from : [options.from])
+            .map((r) => this.escapeId(r))
+            .join(', ');
+        let sql;
+        if (options.grantOptionFor) {
+            sql = `REVOKE GRANT OPTION FOR ${privileges} ON ${scopeSql} FROM ${targets}`;
+        }
+        else {
+            sql = `REVOKE ${privileges} ON ${scopeSql} FROM ${targets}`;
+        }
+        if (options.cascade) {
+            sql += ' CASCADE';
+        }
+        if (options.restrict) {
+            sql += ' RESTRICT';
+        }
+        return sql;
+    }
+    /**
+     * Build SHOW GRANTS query for MSSQL.
+     * Queries sys.database_permissions for database-level permissions.
+     */
+    buildShowGrantsQuery(username, _host) {
+        return `SELECT
+      pr.name AS grantee,
+      pr.type_desc AS grantee_type,
+      perm.permission_name,
+      perm.state_desc AS permission_state,
+      OBJECT_NAME(perm.major_id) AS object_name,
+      col_name(perm.major_id, perm.minor_id) AS column_name
+    FROM sys.database_principals pr
+    LEFT JOIN sys.database_permissions perm ON pr.principal_id = perm.grantee_principal_id
+    WHERE pr.name = '${username}'
+    ORDER BY perm.permission_name`;
+    }
+    buildFlushPrivilegesQuery() {
+        // MSSQL does not have FLUSH PRIVILEGES - permissions are automatic
+        return '-- MSSQL does not require FLUSH PRIVILEGES - permissions are automatically synced';
+    }
+    // ---- Roles (MSSQL) ----
+    /**
+     * Build CREATE ROLE statement for MSSQL.
+     */
+    buildCreateRoleQuery(roleName, options = {}) {
+        let sql = 'CREATE ROLE';
+        if (options.ifNotExists) {
+            sql = `IF NOT EXISTS (SELECT name FROM sys.database_principals WHERE name = '${roleName}' AND type = 'R') CREATE ROLE`;
+        }
+        sql += ` ${this.escapeId(roleName)}`;
+        return sql;
+    }
+    /**
+     * Build DROP ROLE statement for MSSQL.
+     */
+    buildDropRoleQuery(roleName, options) {
+        let sql = 'DROP ROLE';
+        if (options?.ifExists) {
+            sql = `IF EXISTS (SELECT name FROM sys.database_principals WHERE name = '${roleName}' AND type = 'R') DROP ROLE`;
+        }
+        sql += ` ${this.escapeId(roleName)}`;
+        if (options?.cascade) {
+            sql += ' CASCADE';
+        }
+        return sql;
+    }
+    /**
+     * Build GRANT role statement for MSSQL.
+     * Uses ALTER ROLE ADD MEMBER (MSSQL syntax).
+     */
+    buildGrantRoleQuery(role, to, options) {
+        const recipients = (Array.isArray(to) ? to : [to]).map((r) => this.escapeId(r)).join(', ');
+        let sql = `ALTER ROLE ${this.escapeId(role)} ADD MEMBER ${recipients}`;
+        if (options?.withAdminOption) {
+            sql += ' WITH GRANT OPTION';
+        }
+        return sql;
+    }
+    /**
+     * Build REVOKE role statement for MSSQL.
+     * Uses ALTER ROLE DROP MEMBER (MSSQL syntax).
+     */
+    buildRevokeRoleQuery(role, from, options) {
+        const targets = (Array.isArray(from) ? from : [from]).map((r) => this.escapeId(r)).join(', ');
+        let sql = `ALTER ROLE ${this.escapeId(role)} DROP MEMBER ${targets}`;
+        if (options?.cascade) {
+            sql += ' CASCADE';
+        }
+        return sql;
+    }
+    /**
+     * Get roles query for MSSQL.
+     */
+    getRolesQuery() {
+        return `SELECT name AS role FROM sys.database_principals WHERE type = 'R' AND name NOT IN ('public', 'db_owner', 'db_accessadmin', 'db_securityadmin', 'db_ddladmin', 'db_backupoperator', 'db_datareader', 'db_datawriter', 'db_denydatareader', 'db_denydatawriter')`;
+    }
+    // Database creation/drop stubs
+    createDatabaseSQL(options) {
+        const parts = [];
+        parts.push(`CREATE DATABASE ${this.quoteIdentifier(options.name)}`);
+        if (options.collate)
+            parts.push(`COLLATE = '${options.collate}'`);
+        return parts.join(' ');
+    }
+    dropDatabaseSQL(name) {
+        return `DROP DATABASE IF EXISTS ${this.quoteIdentifier(name)}`;
+    }
+    // Savepoint stubs
+    // T-SQL has no `SAVEPOINT` keyword — the equivalent statement is
+    // `SAVE TRANSACTION <name>` / `ROLLBACK TRANSACTION <name>`. There is also
+    // no `RELEASE SAVEPOINT` concept in T-SQL: a savepoint created with
+    // SAVE TRANSACTION is implicitly released when the outer transaction
+    // commits or rolls back, so releaseSavepointSQL() is a documented no-op.
+    createSavepointSQL(name) {
+        const savepointName = name || `sp_${Date.now()}`;
+        return `SAVE TRANSACTION ${savepointName}`;
+    }
+    releaseSavepointSQL(_name) {
+        // T-SQL has no RELEASE SAVEPOINT statement; savepoints created via
+        // SAVE TRANSACTION are automatically released on COMMIT/ROLLBACK.
+        // Return a harmless no-op statement so callers that unconditionally
+        // execute the returned SQL don't send an empty batch.
+        return '-- RELEASE SAVEPOINT is a no-op in T-SQL (SQL Server has no equivalent statement)';
+    }
+    rollbackToSavepointSQL(name) {
+        return `ROLLBACK TRANSACTION ${name}`;
+    }
+    // Extension stubs - not supported in MSSQL
+    createExtension(_extensionName, _options) {
+        throw new Error('Extensions are not supported by MSSQL. This is a PostgreSQL-specific feature.');
+    }
+    dropExtension(_extensionName, _options) {
+        throw new Error('Extensions are not supported by MSSQL. This is a PostgreSQL-specific feature.');
+    }
+    getExtensions() {
+        throw new Error('Extensions are not supported by MSSQL. This is a PostgreSQL-specific feature.');
+    }
+    hasExtension(_extensionName) {
+        throw new Error('Extensions are not supported by MSSQL. This is a PostgreSQL-specific feature.');
+    }
+    // JSON query builder
+    buildJsonQuery(column, path, value, operator = '=') {
+        const values = [];
+        const jsonExtract = this.buildJsonExtract(column, path, true);
+        if (value !== undefined) {
+            values.push(value);
+            return { sql: `${jsonExtract} ${operator} @p1`, values };
+        }
+        return { sql: jsonExtract, values };
+    }
+    // ReplaceReplacements method
+    replaceReplacements(sql, _replacements) {
+        // Basic implementation - for full implementation would need more complex logic
+        return sql;
+    }
+    formatValue(value) {
+        if (value === null || value === undefined)
+            return 'NULL';
+        if (typeof value === 'boolean')
+            return value ? '1' : '0';
+        if (typeof value === 'number')
+            return String(value);
+        if (value instanceof Date)
+            return this.formatDate(value);
+        if (Buffer.isBuffer(value))
+            return `0x${value.toString('hex')}`;
+        if (Array.isArray(value) || typeof value === 'object')
+            return this.escape(JSON.stringify(value));
+        return this.escape(String(value));
+    }
+    // ==================== Spatial Functions ====================
+    /**
+     * ST_Distance - calculate distance between two geometries (MSSQL)
+     */
+    stDistance(geom1, geom2, srid) {
+        const sridStr = srid ? `, ${srid}` : '';
+        return `geometry::STGeomFromText(${geom1},${sridStr}).STDistance(geometry::STGeomFromText(${geom2}${sridStr}))`;
+    }
+    /**
+     * ST_Within - check if geometry A is within geometry B (MSSQL)
+     */
+    stWithin(geom1, geom2, srid) {
+        const sridStr = srid ? `, ${srid}` : '';
+        return `geometry::STGeomFromText(${geom1},${sridStr}).STWithin(geometry::STGeomFromText(${geom2}${sridStr}))`;
+    }
+    /**
+     * ST_Contains - check if geometry A contains geometry B (MSSQL)
+     */
+    stContains(geom1, geom2, srid) {
+        const sridStr = srid ? `, ${srid}` : '';
+        return `geometry::STGeomFromText(${geom1},${sridStr}).STContains(geometry::STGeomFromText(${geom2}${sridStr}))`;
+    }
+    /**
+     * ST_Intersects - check if geometries intersect (MSSQL)
+     */
+    stIntersects(geom1, geom2, srid) {
+        const sridStr = srid ? `, ${srid}` : '';
+        return `geometry::STGeomFromText(${geom1},${sridStr}).STIntersects(geometry::STGeomFromText(${geom2}${sridStr}))`;
+    }
+    /**
+     * ST_DWithin - check if geometries are within a given distance (MSSQL)
+     */
+    stDWithin(geom1, geom2, distance, srid) {
+        const sridStr = srid ? `, ${srid}` : '';
+        return `geometry::STGeomFromText(${geom1},${sridStr}).STDistance(geometry::STGeomFromText(${geom2}${sridStr})) <= ${distance}`;
+    }
+    /**
+     * ST_AsText - convert geometry to text representation (MSSQL)
+     */
+    stAsText(geom) {
+        return `${geom}.STAsText()`;
+    }
+    /**
+     * ST_GeomFromText - create geometry from text (MSSQL)
+     */
+    stGeomFromText(wkt, srid) {
+        return srid ? `geometry::STGeomFromText('${wkt}', ${srid})` : `geometry::STGeomFromText('${wkt}', 0)`;
+    }
+    /**
+     * Build an OPENJSON expression to shred a JSON document/array into relational rows.
+     * MSSQL has no `JSON_TABLE` function; `OPENJSON(expr, path) WITH (...)` is the real
+     * equivalent, using explicit JSON-path-per-column instead of Oracle/MySQL's COLUMNS(...)
+     * clause. Note: unlike JSON_TABLE, OPENJSON has no `FOR ORDINALITY` column concept, so
+     * columns flagged `forOrdinality` are not supported here.
+     * MSSQL: OPENJSON(expr, '$.path') WITH (name type '$.path', ...) AS alias
+     */
+    buildJsonTable(jsonExpression, rowPath, columns, alias) {
+        if (columns.some((col) => col.forOrdinality)) {
+            throw new Error('MSSQL OPENJSON does not support FOR ORDINALITY columns; omit forOrdinality and use a JSON path instead');
+        }
+        const columnDefs = columns
+            .map((col) => `${this.escapeId(col.name)} ${col.type} '${col.path}'`)
+            .join(', ');
+        return `OPENJSON(${jsonExpression}, '${rowPath}') WITH (${columnDefs}) AS ${this.escapeId(alias)}`;
+    }
+}
+exports.MSSQLDialect = MSSQLDialect;
+function createMSSQLDialect(config) {
+    return new MSSQLDialect(config);
+}