ts-prorm-orm 1.1.0 → 1.2.0

package/dist/dialects/mssql/index.d.ts

@@ -0,0 +1,729 @@
+/**
+ * MSSQL (SQL Server) dialect implementation for the TypeScript ORM
+ * Experimental implementation using the mssql driver
+ */
+import { ConnectionPool } from 'mssql';
+import { Dialect, DialectOptions, ColumnDefinition, TableOptions, DropTableOptions, TableDescription, IndexOptions, IndexDefinition, InsertOptions, UpdateOptions, DeleteOptions, SelectOptions, UpsertQueryOptions, DropSchemaOptions, ViewOptions, DropViewOptions, MaterializedViewOptions, RefreshOptions, DropMaterializedViewOptions, ConstraintDefinition, DropConstraintOptions, BuildOptions, FdwForeignServerOptions, FdwAlterForeignServerOptions, FdwUserMappingOptions, FdwForeignTableOptions, FdwImportForeignSchemaOptions, ExtensionInfo } from '../dialect';
+import { Transaction, TransactionOptions, QueryResult, QueryOptions, DataType, WhereOptions, Order, PoolOptions, RetryOptions, CreatePartitionOptions, AttachPartitionOptions, DetachPartitionOptions, StoredProcedureOptions, DropStoredProcedureOptions, ExecuteStoredProcedureOptions, TriggerOptions, DropTriggerOptions, SequenceOptions, DropSequenceOptions, PolicyOptions, DropPolicyOptions, StreamOptions } from '../../types';
+import { Readable } from 'stream';
+import { CreateUserOptions, AlterUserOptions, GrantOptions, RevokeOptions, RoleOptions } from '../../user-management';
+/**
+ * Options describing a SQL Server system-versioned temporal table.
+ * When present on `TableOptions.temporal`, `createTable` will emit the
+ * hidden `PERIOD FOR SYSTEM_TIME` column pair plus
+ * `WITH (SYSTEM_VERSIONING = ON (HISTORY_TABLE = ...))`.
+ */
+export interface MSSQLTemporalOptions {
+    /** Name of the history table that stores prior row versions. */
+    historyTableName?: string;
+    /** Schema for the history table (defaults to the same schema as the main table). */
+    historySchema?: string;
+    /** Column name for the "row start" hidden period column (default: ValidFrom). */
+    startColumnName?: string;
+    /** Column name for the "row end" hidden period column (default: ValidTo). */
+    endColumnName?: string;
+    /**
+     * Whether the period columns should be marked HIDDEN (excluded from
+     * `SELECT *`). Defaults to true, matching typical SQL Server usage.
+     */
+    hiddenPeriodColumns?: boolean;
+    /**
+     * Retention policy applied to the history table, e.g. "6 MONTHS".
+     * Emitted as `HISTORY_RETENTION_PERIOD = ...` inside the WITH clause.
+     */
+    historyRetentionPeriod?: string;
+}
+/**
+ * `TableOptions` extended with SQL Server system-versioned temporal table
+ * support. Structurally compatible with `TableOptions` — existing callers
+ * that don't need temporal tables are unaffected.
+ */
+export interface MSSQLTableOptions extends TableOptions {
+    temporal?: MSSQLTemporalOptions;
+}
+/**
+ * A single Common Table Expression definition for T-SQL's `WITH` clause.
+ *
+ * Note: unlike Postgres/SQLite/MySQL 8+, T-SQL does not use a `RECURSIVE`
+ * keyword — `WITH cte AS (anchor UNION ALL recursive-member)` is valid and
+ * recursive on its own. The `recursive` flag is accepted here purely as
+ * documentation/intent for the caller (and so the same shape can be shared
+ * across dialects); it is a no-op in the generated T-SQL. Building the
+ * `UNION ALL` between the anchor and recursive member is the caller's
+ * responsibility inside `query` — the builder just wires up the `WITH`
+ * prefix.
+ */
+export interface MSSQLCteDefinition {
+    /** Name the CTE is referenced by in the outer query (and, for recursive
+     * CTEs, self-referenced by within its own recursive member). */
+    name: string;
+    /** The CTE body, e.g. `SELECT id, parentId FROM T WHERE ... UNION ALL SELECT ...`. */
+    query: string;
+    /** Documentation-only intent flag; T-SQL needs no `RECURSIVE` keyword. */
+    recursive?: boolean;
+    /** Optional explicit column list: `name (col1, col2) AS (...)`. */
+    columns?: string[];
+}
+/**
+ * `SelectOptions` extended with SQL Server `FOR SYSTEM_TIME` clause support
+ * for querying system-versioned temporal tables. Only one of
+ * `temporalAsOf` / `temporalBetween` / `temporalAll` should be set at a time;
+ * if more than one is present, `temporalAsOf` wins, then `temporalBetween`.
+ */
+export interface MSSQLSelectOptions extends SelectOptions {
+    /** `FOR SYSTEM_TIME AS OF <timestamp>` — point-in-time snapshot. */
+    temporalAsOf?: Date;
+    /** `FOR SYSTEM_TIME BETWEEN <start> AND <end>` — inclusive range. */
+    temporalBetween?: [Date, Date];
+    /** `FOR SYSTEM_TIME ALL` — current rows plus full history. */
+    temporalAll?: boolean;
+    /**
+     * One or more Common Table Expressions to prefix the query with, e.g.
+     * `WITH cte1 AS (...), cte2 (col1, col2) AS (...) SELECT ...`.
+     * T-SQL has no `RECURSIVE` keyword — recursive CTEs are written the same
+     * way as non-recursive ones, distinguished only by the `UNION ALL`
+     * self-reference inside the CTE body.
+     */
+    cte?: MSSQLCteDefinition[];
+    /** Alias for `cte` (Postgres/SQLite-style naming). */
+    with?: MSSQLCteDefinition[];
+    /**
+     * Append a `FOR JSON PATH|AUTO` clause to the SELECT so SQL Server itself
+     * renders the result set as a single JSON document/array, e.g.:
+     *   SELECT ... FOR JSON PATH, ROOT('data'), INCLUDE_NULL_VALUES
+     * Always emitted last (T-SQL requires `FOR JSON` to be the final clause of
+     * the statement).
+     */
+    forJson?: MSSQLForJsonOptions;
+}
+/**
+ * Options controlling SQL Server's `FOR JSON` output clause.
+ * See: https://learn.microsoft.com/sql/relational-databases/json/format-query-results-as-json-with-for-json-sql-server
+ */
+export interface MSSQLForJsonOptions {
+    /** `AUTO` infers nesting from the query shape; `PATH` uses dotted column aliases to control nesting/naming. */
+    mode: 'PATH' | 'AUTO';
+    /** Wraps the JSON output in `{ "<root>": [ ... ] }` via `ROOT('<root>')`. */
+    root?: string;
+    /** Include JSON properties for NULL values (by default SQL Server omits them) via `INCLUDE_NULL_VALUES`. */
+    includeNullValues?: boolean;
+    /**
+     * Removes the outer `[ ]` array wrapper via `WITHOUT_ARRAY_WRAPPER`.
+     * Intended for queries that are known to return at most one row/object;
+     * SQL Server does not validate this at parse time.
+     */
+    withoutArrayWrapper?: boolean;
+}
+/**
+ * MSSQL dialect options
+ */
+/**
+ * `InsertOptions` extended with SQL Server `IDENTITY_INSERT` support.
+ *
+ * SQL Server rejects explicit values for an `IDENTITY` column unless
+ * `SET IDENTITY_INSERT <table> ON` is in effect for the session, and only
+ * one table per session may have it enabled at a time. This is opt-in
+ * (rather than auto-detected from the column definitions) because whether a
+ * given INSERT is *intended* to supply an explicit identity value is a
+ * caller-level decision this dialect has no reliable way to infer from the
+ * values object alone.
+ */
+export interface MSSQLInsertOptions extends InsertOptions {
+    /**
+     * When true, wraps the INSERT with
+     * `SET IDENTITY_INSERT <table> ON` / `... OFF` so explicit values can be
+     * supplied for an IDENTITY column. `OFF` is always issued afterwards, even
+     * if the INSERT throws (try/finally), so the session-level setting never
+     * leaks into unrelated subsequent inserts.
+     */
+    identityInsert?: boolean;
+}
+/**
+ * `bulkInsert` options: `InsertOptions` plus SQL Server's `IDENTITY_INSERT`
+ * toggle (see `MSSQLInsertOptions`) and row/parameter batching controls.
+ */
+export interface MSSQLBulkInsertOptions extends InsertOptions {
+    /** See `MSSQLInsertOptions.identityInsert`. Applied around the whole batch (all chunks). */
+    identityInsert?: boolean;
+    /**
+     * Override the number of rows per INSERT statement. Defaults to
+     * `min(1000, floor(2100 / columnsPerRow))`, matching T-SQL's row-value
+     * constructor limit (1,000 rows) and parameterized-query limit (2,100
+     * parameters). Values above the computed safe maximum are clamped down to
+     * it; this option can only make batches *smaller*, not bypass the limits.
+     */
+    batchSize?: number;
+}
+export interface MSSQLDialectOptions extends DialectOptions {
+    pool?: PoolOptions;
+    retry?: RetryOptions;
+    debug?: boolean;
+    connectionTimeout?: number;
+    requestTimeout?: number;
+    trustServerCertificate?: boolean;
+    encrypt?: boolean;
+    enableArithAbort?: boolean;
+}
+/**
+ * MSSQL dialect class that implements the Dialect interface
+ */
+export declare class MSSQLDialect implements Dialect {
+    readonly name = "mssql";
+    readonly library = "mssql";
+    private pool;
+    private _isConnected;
+    private config;
+    private poolOptions;
+    private retryOptions;
+    constructor(config: MSSQLDialectOptions);
+    private withRetry;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    getConnection(): ConnectionPool | null;
+    isConnected(): boolean;
+    /**
+     * 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: string, options?: StreamOptions): Readable;
+    query(sql: string, _options?: QueryOptions): Promise<QueryResult>;
+    escape(value: unknown): string;
+    private formatDate;
+    escapeId(identifier: unknown): string;
+    quoteIdentifier(identifier: string): string;
+    quoteTable(tableName: string, schema?: string): string;
+    getDatabaseVersion(): Promise<string>;
+    createTable(tableName: string, columns: Record<string, ColumnDefinition>, options?: MSSQLTableOptions): Promise<void>;
+    /**
+     * 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`.
+     */
+    disableSystemVersioning(tableName: string, schema?: string): Promise<void>;
+    /**
+     * 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.
+     */
+    dropTemporalTable(tableName: string, options?: DropTableOptions & {
+        schema?: string;
+        dropHistoryTable?: boolean;
+        historyTableName?: string;
+    }): Promise<void>;
+    private getColumnDefinitionSql;
+    private buildConstraintSql;
+    dropTable(tableName: string, options?: DropTableOptions): Promise<void>;
+    createPartitionedTable(_tableName: string, _columns: Record<string, ColumnDefinition>, _options?: TableOptions & {
+        partitionBy: {
+            type: 'range' | 'list' | 'hash';
+            column: string | string[];
+        };
+        partitions?: {
+            name: string;
+            bound?: unknown;
+            tablespace?: string;
+            storageParameters?: Record<string, string | number>;
+        }[];
+    }): Promise<void>;
+    createPartition(_options: CreatePartitionOptions): Promise<void>;
+    attachPartition(_options: AttachPartitionOptions): Promise<void>;
+    detachPartition(_options: DetachPartitionOptions): Promise<void>;
+    dropPartition(_partitionName: string, _options?: {
+        ifExists?: boolean;
+        cascade?: boolean;
+    }): Promise<void>;
+    /**
+     * 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
+     */
+    addPartition(_tableName: string, _partitionName: string, _partitionSpec: {
+        values?: string;
+        forValues?: string;
+    }): Promise<void>;
+    createView(viewName: string, query: string, options?: ViewOptions): Promise<void>;
+    dropView(viewName: string, options?: DropViewOptions): Promise<void>;
+    createMaterializedView(options: MaterializedViewOptions): Promise<void>;
+    refreshMaterializedView(viewName: string, _options?: RefreshOptions): Promise<void>;
+    dropMaterializedView(viewName: string, options?: DropMaterializedViewOptions): Promise<void>;
+    hasMaterializedView(viewName: string): Promise<boolean>;
+    createStoredProcedure(options: StoredProcedureOptions): Promise<void>;
+    dropStoredProcedure(procedureName: string, options?: DropStoredProcedureOptions): Promise<void>;
+    /**
+     * Drop a stored procedure (alias for dropStoredProcedure)
+     */
+    dropProcedure(procedureName: string, options?: DropStoredProcedureOptions): Promise<void>;
+    /**
+     * Create a stored procedure (alias for createStoredProcedure)
+     */
+    createProcedure(options: StoredProcedureOptions): Promise<void>;
+    executeStoredProcedure(options: ExecuteStoredProcedureOptions): Promise<QueryResult>;
+    hasStoredProcedure(procedureName: string, schema?: string): Promise<boolean>;
+    createTrigger(options: TriggerOptions): Promise<void>;
+    dropTrigger(triggerName: string, tableName: string, options?: DropTriggerOptions): Promise<void>;
+    hasTrigger(triggerName: string, tableName: string): Promise<boolean>;
+    createSequence(options: SequenceOptions): Promise<void>;
+    dropSequence(sequenceName: string, options?: DropSequenceOptions): Promise<void>;
+    nextSequenceValue(sequenceName: string): Promise<number>;
+    hasSequence(sequenceName: string): Promise<boolean>;
+    /**
+     * List all sequences in the database (MSSQL)
+     * @returns Array of sequence names
+     */
+    listSequences(): Promise<string[]>;
+    /**
+     * Create a security policy with predicate function (MSSQL RLS)
+     */
+    createPolicy(options: PolicyOptions): Promise<void>;
+    /**
+     * Drop a security policy (MSSQL RLS)
+     */
+    dropPolicy(policyName: string, _tableName: string, options?: DropPolicyOptions): Promise<void>;
+    /**
+     * 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.
+     */
+    enableRLS(tableName: string, schema?: string): Promise<void>;
+    /**
+     * Disable row-level security on a table (MSSQL)
+     * This drops all security policies associated with the table
+     */
+    disableRLS(tableName: string, schema?: string): Promise<void>;
+    /**
+     * Check if a security policy exists (MSSQL RLS)
+     */
+    hasPolicy(policyName: string, tableName: string): Promise<boolean>;
+    commentTable(tableName: string, comment: string): Promise<void>;
+    commentColumn(tableName: string, columnName: string, comment: string): Promise<void>;
+    createPartialIndex(tableName: string, indexName: string, fields: string[], where: string, options?: IndexOptions): Promise<void>;
+    createExpressionIndex(tableName: string, indexName: string, expression: string, options?: IndexOptions & {
+        computedColumnName?: string;
+        persisted?: boolean;
+    }): Promise<void>;
+    createIdentityColumn(tableName: string, columnName: string, options?: {
+        startWith?: number;
+        incrementBy?: number;
+        minvalue?: number;
+        maxvalue?: number;
+        cycle?: boolean;
+    }): Promise<void>;
+    createComputedColumn(tableName: string, columnName: string, expression: string, options?: {
+        persisted?: boolean;
+        type?: string;
+    }): Promise<void>;
+    addColumn(tableName: string, columnName: string, definition: ColumnDefinition): Promise<void>;
+    removeColumn(tableName: string, columnName: string): Promise<void>;
+    changeColumn(tableName: string, columnName: string, definition: ColumnDefinition): Promise<void>;
+    showTables(): Promise<string[]>;
+    /**
+     * Get table status (MSSQL implementation)
+     */
+    getTableStatus(tableName?: string): Promise<Record<string, any>[]>;
+    /**
+     * Get table create statement (MSSQL implementation)
+     */
+    getCreateTable(tableName: string): Promise<string>;
+    /**
+     * Check if a table has partitions (MSSQL implementation)
+     */
+    hasPartition(tableName: string): Promise<boolean>;
+    /**
+     * Show constraints for a table
+     */
+    showConstraints(tableName: string): Promise<any[]>;
+    /**
+     * Show indexes for a table
+     */
+    showIndexes(tableName: string): Promise<any[]>;
+    showViews(): Promise<string[]>;
+    showMaterializedViews(): Promise<string[]>;
+    describeTable(tableName: string): Promise<TableDescription>;
+    renameTable(oldName: string, newName: string): Promise<void>;
+    addIndex(tableName: string, indexName: string, fields: string[], options?: IndexOptions): Promise<void>;
+    removeIndex(tableName: string, indexName: string): Promise<void>;
+    createIndex(tableName: string, indexDef: IndexDefinition): Promise<void>;
+    dropIndex(tableName: string, indexName: string, _options?: {
+        ifExists?: boolean;
+        cascade?: boolean;
+    }): Promise<void>;
+    /**
+     * Create a SQL Server columnstore index — the storage format used for
+     * analytic/warehouse workloads.
+     *
+     * A *clustered* columnstore index (`clustered: true`, the default) converts
+     * the entire table to columnar storage and therefore takes NO column list —
+     * emitting one is a T-SQL syntax error, which is why the generic
+     * `addIndex()` (which always appends `(cols)`) cannot express it. A
+     * *nonclustered* columnstore index is layered on top of a rowstore table and
+     * DOES take an explicit column list.
+     *
+     * @param tableName - Table to build the columnstore index on
+     * @param indexName - Name for the index
+     * @param options.clustered - Clustered (whole-table columnar) when true/omitted; nonclustered when false
+     * @param options.columns - Columns for a nonclustered columnstore index (required when `clustered` is false; ignored when clustered)
+     * @param options.where - Filtered-index predicate (nonclustered columnstore only, SQL Server 2016+)
+     * @param options.compressionDelay - `COMPRESSION_DELAY = <n> MINUTES` WITH option
+     */
+    createColumnstoreIndex(tableName: string, indexName: string, options?: {
+        clustered?: boolean;
+        columns?: string[];
+        where?: string;
+        compressionDelay?: number;
+    }): Promise<void>;
+    createConstraint(tableName: string, constraintDef: ConstraintDefinition): Promise<void>;
+    dropConstraint(tableName: string, constraintName: string, _options?: DropConstraintOptions): Promise<void>;
+    startTransaction(_options?: TransactionOptions): Promise<Transaction>;
+    commitTransaction(_transaction: Transaction): Promise<void>;
+    rollbackTransaction(_transaction: Transaction): Promise<void>;
+    createSchema(schema: string): Promise<void>;
+    dropSchema(schema: string, options?: DropSchemaOptions): Promise<void>;
+    showAllSchemas(): Promise<string[]>;
+    /**
+     * List all schemas
+     */
+    listSchemas(): Promise<string[]>;
+    getDataTypeSql(dataType: DataType): string;
+    buildWhereClause(where: WhereOptions, _options?: BuildOptions): {
+        sql: string;
+        values: unknown[];
+    };
+    buildOrderClause(order: Order, _options?: BuildOptions): string;
+    buildLimitOffset(limit?: number | string, offset?: number | string, hasOrderBy?: boolean): string;
+    buildInsertQuery(tableName: string, values: Record<string, unknown>, options?: InsertOptions): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * 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`.
+     */
+    insert(tableName: string, values: Record<string, unknown>, options?: MSSQLInsertOptions): Promise<QueryResult>;
+    buildUpdateQuery(tableName: string, values: Record<string, unknown>, where: WhereOptions, options?: UpdateOptions): {
+        sql: string;
+        values: unknown[];
+    };
+    buildDeleteQuery(tableName: string, where: WhereOptions, options?: DeleteOptions): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * Render one CTE definition as `name [(cols)] AS (query)`.
+     */
+    private buildCteDefinition;
+    /**
+     * 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.
+     */
+    private buildCteClause;
+    /**
+     * 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]`).
+     */
+    private formatAttribute;
+    private formatAttributeExpr;
+    buildSelectQuery(options: MSSQLSelectOptions): {
+        sql: string;
+        values: unknown[];
+    };
+    buildUpsertQuery(tableName: string, values: Record<string, unknown>, options?: UpsertQueryOptions): {
+        sql: string;
+        values: unknown[];
+    };
+    buildIncrementQuery(tableName: string, fields: string | string[] | Record<string, number>, where: WhereOptions, options?: {
+        by?: number;
+    }): {
+        sql: string;
+        values: unknown[];
+    };
+    buildJsonExtract(column: string, path: string, asText?: boolean): string;
+    buildCreateServerQuery(_name: string, _opts: FdwForeignServerOptions): string;
+    buildAlterServerQuery(_name: string, _opts: FdwAlterForeignServerOptions): string;
+    buildDropServerQuery(_name: string, _opts?: {
+        ifExists?: boolean;
+        cascade?: boolean;
+    }): string;
+    buildCreateUserMappingQuery(_opts: FdwUserMappingOptions): string;
+    buildAlterUserMappingQuery(_opts: FdwUserMappingOptions): string;
+    buildDropUserMappingQuery(_serverName: string, _user: string, _opts?: {
+        ifExists?: boolean;
+    }): string;
+    buildCreateForeignTableQuery(_tableName: string, _opts: FdwForeignTableOptions): string;
+    buildDropForeignTableQuery(_tableName: string, _opts?: {
+        ifExists?: boolean;
+        cascade?: boolean;
+    }): string;
+    buildImportForeignSchemaQuery(_remoteSchema: string, _serverName: string, _opts?: FdwImportForeignSchemaOptions): string;
+    getServersQuery(): string;
+    createForeignDataWrapper(_fdwName: string, _options?: {
+        handler?: string;
+    }): Promise<void>;
+    dropForeignDataWrapper(_fdwName: string, _options?: {
+        ifExists?: boolean;
+    }): Promise<void>;
+    createForeignServer(_serverName: string, _fdwName: string, _options?: {
+        options?: Record<string, string>;
+        ifNotExists?: boolean;
+    }): Promise<void>;
+    dropForeignServer(_serverName: string, _options?: {
+        ifExists?: boolean;
+        cascade?: boolean;
+    }): Promise<void>;
+    createForeignTable(_tableName: string, _columns: Record<string, {
+        type: string;
+    }>, _options?: {
+        serverName?: string;
+        ifNotExists?: boolean;
+    }): Promise<void>;
+    createUserMapping(_serverName: string, _userName: string, _options?: {
+        username?: string;
+        password?: string;
+    }): Promise<void>;
+    dropUserMapping(_serverName: string, _userName: string, _options?: {
+        ifExists?: boolean;
+    }): Promise<void>;
+    /**
+     * Change the owner (authorization principal) of a table. SQL Server has no
+     * `ALTER TABLE ... OWNER TO` — object ownership is changed with
+     * `ALTER AUTHORIZATION ON OBJECT::<table> TO <principal>`, which is the
+     * T-SQL equivalent (pass `SCHEMA OWNER` as the principal to revert to the
+     * containing schema's owner).
+     */
+    changeOwner(newOwner: string, tableName: string): Promise<void>;
+    /**
+     * Add a table constraint via `ALTER TABLE ... ADD CONSTRAINT`. Delegates to
+     * `createConstraint`/`buildConstraintSql`, mapping the `references.fields`
+     * array shape onto the `references.field` shape those helpers expect.
+     */
+    addConstraint(tableName: string, options: {
+        type: 'UNIQUE' | 'CHECK' | 'PRIMARY KEY' | 'FOREIGN KEY';
+        fields: string[];
+        name?: string;
+        references?: {
+            table: string;
+            fields: string[];
+        };
+        check?: string;
+    }): Promise<void>;
+    /**
+     * Drop a named table constraint via `ALTER TABLE ... DROP CONSTRAINT`.
+     */
+    removeConstraint(tableName: string, constraintName: string): Promise<void>;
+    createSecurityPolicy(policyName: string, tableName: string, options?: {
+        predicate?: string;
+        schema?: string;
+    }): Promise<void>;
+    dropSecurityPolicy(policyName: string, tableName: string): Promise<void>;
+    /**
+     * 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.
+     */
+    private maxBulkInsertRowsPerBatch;
+    /**
+     * 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).
+     */
+    bulkInsert(tableName: string, records: Record<string, any>[], options?: MSSQLBulkInsertOptions): Promise<QueryResult>;
+    /**
+     * Add a foreign key to a table
+     */
+    addForeignKey(tableName: string, columnName: string, referencedTableName: string, referencedColumnName: string, options?: {
+        name?: string;
+        onDelete?: 'CASCADE' | 'RESTRICT' | 'SET NULL' | 'NO ACTION';
+        onUpdate?: 'CASCADE' | 'RESTRICT' | 'SET NULL' | 'NO ACTION';
+    }): Promise<void>;
+    /**
+     * Rename a column
+     */
+    renameColumn(tableName: string, oldColumnName: string, newColumnName: string): Promise<void>;
+    /**
+     * 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>
+     */
+    createFulltextIndex(tableName: string, keyIndexName: string, fields: string[], options?: {
+        parser?: string;
+        comment?: string;
+        /** Fulltext catalog to use/create. Defaults to 'default_fulltext_catalog'. */
+        catalogName?: string;
+        /** Set to false to skip catalog creation (e.g. it's already guaranteed to exist). */
+        createCatalog?: boolean;
+    }): Promise<void>;
+    /**
+     * Create a spatial index (MSSQL supports spatial indexes)
+     */
+    createSpatialIndex(tableName: string, indexName: string, fields: string[], options?: {
+        storage?: string;
+        srid?: number;
+    }): Promise<void>;
+    /**
+     * Build CREATE LOGIN and CREATE USER statements for MSSQL.
+     * MSSQL uses LOGIN for server-level authentication and USER for database-level access.
+     */
+    buildCreateUserQuery(username: string, options?: CreateUserOptions): string;
+    private escapePassword;
+    /**
+     * Build ALTER LOGIN and ALTER USER statements for MSSQL.
+     */
+    buildAlterUserQuery(username: string, options: AlterUserOptions): string;
+    /**
+     * Build DROP USER and DROP LOGIN statements for MSSQL.
+     * Must drop USER first, then LOGIN (due to dependencies).
+     */
+    buildDropUserQuery(username: string, options?: {
+        ifExists?: boolean;
+    }): string;
+    /**
+     * Get list of users from MSSQL.
+     */
+    getUsersQuery(): string;
+    /**
+     * Build GRANT statement for MSSQL.
+     */
+    buildGrantQuery(options: GrantOptions): string;
+    /**
+     * Build REVOKE statement for MSSQL.
+     */
+    buildRevokeQuery(options: RevokeOptions): string;
+    /**
+     * Build SHOW GRANTS query for MSSQL.
+     * Queries sys.database_permissions for database-level permissions.
+     */
+    buildShowGrantsQuery(username: string, _host?: string): string;
+    buildFlushPrivilegesQuery(): string;
+    /**
+     * Build CREATE ROLE statement for MSSQL.
+     */
+    buildCreateRoleQuery(roleName: string, options?: RoleOptions): string;
+    /**
+     * Build DROP ROLE statement for MSSQL.
+     */
+    buildDropRoleQuery(roleName: string, options?: {
+        ifExists?: boolean;
+        cascade?: boolean;
+    }): string;
+    /**
+     * Build GRANT role statement for MSSQL.
+     * Uses ALTER ROLE ADD MEMBER (MSSQL syntax).
+     */
+    buildGrantRoleQuery(role: string, to: string | string[], options?: {
+        withAdminOption?: boolean;
+    }): string;
+    /**
+     * Build REVOKE role statement for MSSQL.
+     * Uses ALTER ROLE DROP MEMBER (MSSQL syntax).
+     */
+    buildRevokeRoleQuery(role: string, from: string | string[], options?: {
+        cascade?: boolean;
+    }): string;
+    /**
+     * Get roles query for MSSQL.
+     */
+    getRolesQuery(): string;
+    createDatabaseSQL(options: {
+        name: string;
+        encoding?: string;
+        lcCollate?: string;
+        lcCtype?: string;
+        template?: string;
+        tablespace?: string;
+        collate?: string;
+        isTemplate?: boolean;
+    }): string;
+    dropDatabaseSQL(name: string): string;
+    createSavepointSQL(name?: string): string;
+    releaseSavepointSQL(_name: string): string;
+    rollbackToSavepointSQL(name: string): string;
+    createExtension(_extensionName: string, _options?: unknown): Promise<void>;
+    dropExtension(_extensionName: string, _options?: unknown): Promise<void>;
+    getExtensions(): Promise<ExtensionInfo[]>;
+    hasExtension(_extensionName: string): Promise<boolean>;
+    buildJsonQuery(column: string, path: string, value?: unknown, operator?: string): {
+        sql: string;
+        values: unknown[];
+    };
+    replaceReplacements(sql: string, _replacements?: Record<string, unknown> | unknown[]): string;
+    protected formatValue(value: unknown): string;
+    /**
+     * ST_Distance - calculate distance between two geometries (MSSQL)
+     */
+    stDistance(geom1: string, geom2: string, srid?: number): string;
+    /**
+     * ST_Within - check if geometry A is within geometry B (MSSQL)
+     */
+    stWithin(geom1: string, geom2: string, srid?: number): string;
+    /**
+     * ST_Contains - check if geometry A contains geometry B (MSSQL)
+     */
+    stContains(geom1: string, geom2: string, srid?: number): string;
+    /**
+     * ST_Intersects - check if geometries intersect (MSSQL)
+     */
+    stIntersects(geom1: string, geom2: string, srid?: number): string;
+    /**
+     * ST_DWithin - check if geometries are within a given distance (MSSQL)
+     */
+    stDWithin(geom1: string, geom2: string, distance: number, srid?: number): string;
+    /**
+     * ST_AsText - convert geometry to text representation (MSSQL)
+     */
+    stAsText(geom: string): string;
+    /**
+     * ST_GeomFromText - create geometry from text (MSSQL)
+     */
+    stGeomFromText(wkt: string, srid?: number): string;
+    /**
+     * 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: string, rowPath: string, columns: Array<{
+        name: string;
+        type?: string;
+        path?: string;
+        forOrdinality?: boolean;
+    }>, alias: string): string;
+}
+export declare function createMSSQLDialect(config: MSSQLDialectOptions): MSSQLDialect;