ts-prorm-orm 1.1.0 → 1.2.0

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

@@ -0,0 +1,1233 @@
+/**
+ * MySQL dialect implementation for the TypeScript ORM
+ */
+import { Pool, PoolConnection } from 'mysql2/promise';
+import { Dialect, DialectOptions, ColumnDefinition, TableOptions, DropTableOptions, TableDescription, IndexOptions, InsertOptions, UpdateOptions, DeleteOptions, SelectOptions, DropSchemaOptions, CreateExtensionOptions, DropExtensionOptions, ExtensionInfo, ViewOptions, DropViewOptions, MaterializedViewOptions, RefreshOptions, DropMaterializedViewOptions, FdwForeignServerOptions, FdwAlterForeignServerOptions, FdwUserMappingOptions, FdwForeignTableOptions, FdwImportForeignSchemaOptions } from '../dialect';
+import { Transaction, TransactionOptions, QueryResult, QueryOptions, StreamOptions, DataType, WhereOptions, Order, PoolOptions, RetryOptions, CreatePartitionOptions, AttachPartitionOptions, DetachPartitionOptions, StoredProcedureOptions, DropStoredProcedureOptions, ExecuteStoredProcedureOptions, TriggerOptions, DropTriggerOptions, SequenceOptions, DropSequenceOptions, PolicyOptions, DropPolicyOptions, PartitionDefinition, CreateEventOptions, DropEventOptions, AlterEventOptions, CreateProcedureOptions } from '../../types';
+/**
+ * A single Common Table Expression definition for `WITH [RECURSIVE] ... AS (...)`.
+ * MySQL 8.0+ supports standard CTE syntax, including `WITH RECURSIVE` for
+ * hierarchical/graph queries (org charts, category trees, etc).
+ */
+export interface MySQLCteDefinition {
+    /** Name the CTE is referenced by (in the outer query's FROM/JOIN, or by other CTEs). */
+    name: string;
+    /** Optional explicit column list: `WITH name (col1, col2) AS (...)`. */
+    columns?: string[];
+    /** The CTE body. Either a raw SQL string, or a pre-built `{ sql, values }` pair. */
+    query: string | {
+        sql: string;
+        values?: unknown[];
+    };
+}
+/**
+ * Extension of the shared `SelectOptions` type with MySQL-specific additions
+ * that don't (yet) exist on the dialect-agnostic interface. Kept local to this
+ * file so no shared types need to change: `with`/`withRecursive` are optional,
+ * so any plain `SelectOptions` value remains a valid `MySQLSelectOptions`.
+ */
+export interface MySQLSelectOptions extends SelectOptions {
+    /** Common Table Expressions to prepend as `WITH [RECURSIVE] ...`. */
+    with?: MySQLCteDefinition[];
+    /**
+     * Whether to emit `WITH RECURSIVE` instead of plain `WITH`. MySQL only has
+     * one `RECURSIVE` keyword for the entire `WITH` clause (it cannot be set
+     * per-CTE), so this is a single flag rather than per-definition.
+     */
+    withRecursive?: boolean;
+}
+/**
+ * MySQL dialect class that implements the Dialect interface
+ */
+export declare class MySQLDialect implements Dialect {
+    readonly name: string;
+    readonly library: string;
+    private pool;
+    private _isConnected;
+    private config;
+    private poolOptions;
+    private retryOptions;
+    constructor(config: MySQLDialectOptions);
+    /**
+     * Execute a function with retry logic
+     */
+    private withRetry;
+    /**
+     * Connect to the MySQL database with retry logic
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from the MySQL database
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Get the current connection pool
+     */
+    getConnection(): Pool | null;
+    /**
+     * Check if connected
+     */
+    isConnected(): boolean;
+    /**
+     * Execute a raw SQL query with retry support
+     */
+    query(sql: string, options?: QueryOptions): Promise<QueryResult>;
+    /**
+     * Execute a query and stream results using MySQL2 stream
+     * Uses MySQL2's stream API for efficient memory usage with large datasets
+     * @param sql - The SQL query string
+     * @param options - Stream options
+     * @returns Readable stream for streaming results
+     */
+    queryStream(sql: string, options?: StreamOptions): import('stream').Readable;
+    /**
+     * Execute a function with retry logic for query execution
+     */
+    private executeWithRetry;
+    /**
+     * Escape a value for use in a query
+     */
+    escape(value: unknown): string;
+    /**
+     * Build a JSON extraction query for MySQL
+     * MySQL: JSON_EXTRACT(column, '$.path') and JSON_UNQUOTE(JSON_EXTRACT(...))
+     */
+    buildJsonExtract(column: string, path: string, asText?: boolean): string;
+    /**
+     * Build a JSON contains query for MySQL
+     * MySQL: JSON_CONTAINS(column, value[, path])
+     */
+    buildJsonContains(column: string, value: unknown, path?: string): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * Build a JSON has key query for MySQL
+     * MySQL: JSON_CONTAINS_PATH(column, 'one'|'all', '$.key')
+     */
+    buildJsonHasKey(column: string, key: string, type?: 'one' | 'all'): string;
+    /**
+     * Build a JSON path query for MySQL
+     */
+    buildJsonPathQuery(column: string, path: string, value?: unknown, operator?: string): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * Build a JSON_SET expression to write values at given paths.
+     * MySQL: JSON_SET(column, '$.path1', ?, '$.path2', ?, ...)
+     * Unlike JSON_REPLACE, JSON_SET creates the path if it does not already exist;
+     * unlike JSON_INSERT, it will overwrite an existing value at that path.
+     */
+    buildJsonSet(column: string, pathValues: Record<string, unknown>): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * Build a JSON_REPLACE expression, updating values only at paths that already exist.
+     * MySQL: JSON_REPLACE(column, '$.path1', ?, ...)
+     */
+    buildJsonReplace(column: string, pathValues: Record<string, unknown>): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * Build a JSON_INSERT expression, inserting values only at paths that do not already exist.
+     * MySQL: JSON_INSERT(column, '$.path1', ?, ...)
+     */
+    buildJsonInsert(column: string, pathValues: Record<string, unknown>): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * Build a JSON_REMOVE expression to remove data at the given paths.
+     * MySQL: JSON_REMOVE(column, '$.path1', '$.path2', ...)
+     */
+    buildJsonRemove(column: string, paths: string[]): string;
+    /**
+     * Build a JSON_MERGE_PATCH expression (RFC 7396 merge patch semantics: object keys
+     * set to JSON null remove the key; non-object values fully replace).
+     * MySQL: JSON_MERGE_PATCH(column, ?, ?, ...)
+     */
+    buildJsonMergePatch(column: string, ...documents: unknown[]): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * Build a JSON_MERGE_PRESERVE expression (auto-wraps/merges without dropping keys or
+     * array members, unlike JSON_MERGE_PATCH).
+     * MySQL: JSON_MERGE_PRESERVE(column, ?, ?, ...)
+     */
+    buildJsonMergePreserve(column: string, ...documents: unknown[]): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * Build a JSON_ARRAYAGG aggregate expression.
+     * MySQL: JSON_ARRAYAGG(expr) - aggregates a column/expression (typically grouped)
+     * into a single JSON array.
+     */
+    buildJsonArrayAgg(expression: string, alias?: string): string;
+    /**
+     * Build a JSON_OBJECTAGG aggregate expression.
+     * MySQL: JSON_OBJECTAGG(key, value) - aggregates key/value pairs (typically grouped)
+     * into a single JSON object.
+     */
+    buildJsonObjectAgg(keyExpression: string, valueExpression: string, alias?: string): string;
+    /**
+     * Build a JSON_TABLE expression to shred a JSON document/array into relational rows
+     * (MySQL 8.0+). Useful to project a JSON array column into rows instead of a
+     * correlated subquery.
+     * MySQL: JSON_TABLE(expr, '$[*]' COLUMNS(name type PATH '$.path', ...)) AS alias
+     */
+    buildJsonTable(jsonExpression: string, rowPath: string, columns: Array<{
+        name: string;
+        type?: string;
+        path?: string;
+        forOrdinality?: boolean;
+    }>, alias: string): string;
+    /**
+     * Escape a string for SQL
+     */
+    private escapeString;
+    /**
+     * Format a date for MySQL
+     */
+    private formatDate;
+    /**
+     * Escape an identifier (table name, column name, etc.)
+     */
+    escapeId(identifier: unknown): string;
+    /**
+     * Quote an identifier (column name, table name)
+     * MySQL uses backticks for identifiers
+     */
+    quoteIdentifier(identifier: string): string;
+    /**
+     * Quote a table name
+     *
+     * Callers frequently pass a `schema.table` compound name (e.g.
+     * `` this.quoteTable(`${schema}.${name}`) ``). `escapeId()` alone wraps
+     * the *whole* string in a single pair of backticks, which makes the dot a
+     * literal character in one identifier (`` `schema.table` ``) rather than
+     * a real schema qualifier (`` `schema`.`table` ``) — against a real
+     * MySQL server this creates/references a table whose actual name
+     * literally contains a dot, which then doesn't match how e.g.
+     * `INFORMATION_SCHEMA.TABLES.TABLE_NAME` reports it elsewhere. Quote each
+     * dot-separated segment independently so `schema.table` round-trips
+     * correctly; a bare name (no dot) is unaffected.
+     */
+    quoteTable(tableName: string): string;
+    /**
+     * Get the database version
+     */
+    getDatabaseVersion(): Promise<string>;
+    /**
+     * Create a new table
+     */
+    createTable(tableName: string, columns: Record<string, ColumnDefinition>, options?: TableOptions): Promise<void>;
+    /**
+     * Build constraint SQL for table creation (MySQL)
+     */
+    private buildConstraintSql;
+    /**
+     * Generate column definition SQL for MySQL
+     */
+    private getColumnDefinitionSql;
+    /**
+     * Get default value SQL
+     */
+    private getDefaultValue;
+    /**
+     * Drop a table
+     */
+    dropTable(tableName: string, options?: DropTableOptions): Promise<void>;
+    /**
+     * Create a partitioned table (MySQL 5.1+)
+     *
+     * MySQL supports RANGE, LIST, HASH, and KEY partitioning.
+     * Partitions are defined in the CREATE TABLE statement.
+     *
+     * @param tableName - Name of the table to create
+     * @param columns - Column definitions
+     * @param options - Table options including partition configuration
+     */
+    createPartitionedTable(tableName: string, columns: Record<string, ColumnDefinition>, options?: TableOptions & {
+        partitionBy: {
+            type: 'range' | 'list' | 'hash' | 'key';
+            column: string | string[];
+        };
+        partitions?: PartitionDefinition[];
+    }): Promise<void>;
+    /**
+     * Create a partition for an existing partitioned table (MySQL 5.1+)
+     *
+     * @param options - Partition creation options
+     */
+    createPartition(options: CreatePartitionOptions): Promise<void>;
+    /**
+     * Attach a partition (MySQL uses ADD PARTITION instead)
+     * Provided for PostgreSQL compatibility
+     *
+     * @param options - Partition attachment options
+     */
+    attachPartition(options: AttachPartitionOptions): Promise<void>;
+    /**
+     * Detach a partition (MySQL does not support this operation)
+     *
+     * @param options - Partition detachment options
+     */
+    detachPartition(_options: DetachPartitionOptions): Promise<void>;
+    /**
+     * Drop a partition (MySQL 5.1+)
+     *
+     * @param partitionName - Name of the partition to drop
+     * @param options - Drop options including partition name and optional parent table
+     */
+    dropPartition(partitionName: string, options?: {
+        ifExists?: boolean;
+        cascade?: boolean;
+        parentTable?: string;
+    }): Promise<void>;
+    /**
+     * Add a partition to an existing partitioned table (MySQL 5.1+)
+     * @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>;
+    /**
+     * List all partitions for a table (MySQL 5.1+)
+     *
+     * @param tableName - Name of the table
+     * @returns Array of partition metadata
+     */
+    listPartitions(tableName: string): Promise<Array<{
+        name: string;
+        ordinal: number;
+        description: string | null;
+        rows: number | null;
+    }>>;
+    /**
+     * Check if a table has partitions (MySQL 5.1+)
+     *
+     * @param tableName - Name of the table to check
+     * @returns Promise<boolean> - True if the table has partitions
+     */
+    hasPartition(tableName: string): Promise<boolean>;
+    /**
+     * Add a column to a table
+     */
+    addColumn(tableName: string, columnName: string, definition: ColumnDefinition): Promise<void>;
+    /**
+     * Remove a column from a table
+     */
+    removeColumn(tableName: string, columnName: string): Promise<void>;
+    /**
+     * Change a column definition
+     */
+    changeColumn(tableName: string, columnName: string, definition: ColumnDefinition): Promise<void>;
+    /**
+     * Show all tables in the database
+     */
+    showTables(): Promise<string[]>;
+    /**
+     * Get table status (MySQL implementation)
+     */
+    getTableStatus(tableName?: string): Promise<Record<string, any>[]>;
+    /**
+     * Get table create statement (MySQL implementation)
+     */
+    getCreateTable(tableName: string): Promise<string>;
+    /**
+     * Show constraints for a table
+     */
+    showConstraints(tableName: string): Promise<any[]>;
+    /**
+     * Show indexes for a table
+     */
+    showIndexes(tableName: string): Promise<any[]>;
+    /**
+     * Describe a table (get column information)
+     */
+    describeTable(tableName: string): Promise<TableDescription>;
+    /**
+     * Rename a table
+     */
+    renameTable(oldName: string, newName: string): Promise<void>;
+    /**
+     * Create a schema (database). `CREATE SCHEMA` is a MySQL synonym for
+     * `CREATE DATABASE`; emitted with `IF NOT EXISTS` for idempotency.
+     */
+    createSchema(schema: string): Promise<void>;
+    /**
+     * Drop a schema (database). `DROP SCHEMA` is a MySQL synonym for
+     * `DROP DATABASE`. MySQL has no `CASCADE` on `DROP DATABASE` (dropping a
+     * database always removes all of its tables), so `options.cascade` is
+     * accepted for interface parity but has no additional effect.
+     */
+    dropSchema(schema: string, options?: DropSchemaOptions): Promise<void>;
+    /**
+     * Show all schemas (databases) via `SHOW DATABASES`.
+     */
+    showAllSchemas(): Promise<string[]>;
+    /**
+     * List all schemas (databases) in MySQL
+     */
+    listSchemas(): Promise<string[]>;
+    /**
+     * Create a PostgreSQL extension - Not supported by MySQL
+     */
+    createExtension(_extensionName: string, _options?: CreateExtensionOptions): Promise<void>;
+    /**
+     * Drop a PostgreSQL extension - Not supported by MySQL
+     */
+    dropExtension(_extensionName: string, _options?: DropExtensionOptions): Promise<void>;
+    /**
+     * Get all installed PostgreSQL extensions - Not supported by MySQL
+     */
+    getExtensions(): Promise<ExtensionInfo[]>;
+    /**
+     * Check if a PostgreSQL extension is installed - Not supported by MySQL
+     */
+    hasExtension(_extensionName: string): Promise<boolean>;
+    /**
+     * Create a database view
+     */
+    createView(viewName: string, query: string, options?: ViewOptions): Promise<void>;
+    /**
+     * Drop a database view
+     */
+    dropView(viewName: string, options?: DropViewOptions): Promise<void>;
+    /**
+     * Show all views in the database
+     */
+    showViews(): Promise<string[]>;
+    /**
+     * Create a materialized view (emulated using table + event)
+     * Creates a table from the query and optionally creates a scheduled event to refresh it
+     */
+    createMaterializedView(options: MaterializedViewOptions): Promise<void>;
+    /**
+     * Refresh a materialized view
+     * Truncates the table and re-inserts data from the query
+     */
+    refreshMaterializedView(viewName: string, options?: RefreshOptions): Promise<void>;
+    /**
+     * Drop a materialized view
+     * Drops the table and removes metadata, optionally drops the refresh event
+     */
+    dropMaterializedView(viewName: string, options?: DropMaterializedViewOptions): Promise<void>;
+    /**
+     * Check if a materialized view exists
+     */
+    hasMaterializedView(viewName: string, schema?: string): Promise<boolean>;
+    /**
+     * Show all materialized views (tables created as materialized views)
+     */
+    showMaterializedViews(schema?: string): Promise<string[]>;
+    /**
+     * Create an event (MySQL event scheduler)
+     */
+    createEvent(options: CreateEventOptions): Promise<void>;
+    /**
+     * Drop an event
+     */
+    dropEvent(eventName: string, options?: DropEventOptions): Promise<void>;
+    /**
+     * Show all events in the database
+     */
+    showEvents(schema?: string): Promise<any[]>;
+    /**
+     * Alter an event (change schedule, body, or status)
+     */
+    alterEvent(options: AlterEventOptions): Promise<void>;
+    /**
+     * Create a stored procedure with full PL/SQL support
+     * Supports IN, OUT, INOUT parameters, local variables, IF/ELSE, WHILE loops, cursors
+     */
+    createStoredProcedure(options: StoredProcedureOptions): Promise<void>;
+    /**
+     * Create a stored procedure with body builder for complex procedures
+     * Supports: IN parameters, OUT parameters, INOUT parameters, local variables,
+     * IF/ELSE, WHILE loops, cursors
+     */
+    createProcedure(options: CreateProcedureOptions): Promise<void>;
+    /**
+     * Build a stored procedure body with helper methods
+     * Provides a fluent API for building complex procedure bodies
+     */
+    buildProcedureBody(): ProcedureBodyBuilder;
+    /**
+     * Execute a stored procedure with enhanced return handling
+     * Supports OUT parameters and result sets
+     */
+    executeStoredProcedure(options: ExecuteStoredProcedureOptions): Promise<QueryResult>;
+    /**
+     * Drop a stored procedure
+     */
+    dropStoredProcedure(procedureName: string, options?: DropStoredProcedureOptions): Promise<void>;
+    /**
+     * Drop a stored procedure (alias for dropStoredProcedure)
+     */
+    dropProcedure(procedureName: string, options?: DropStoredProcedureOptions): Promise<void>;
+    /**
+     * Check if a stored procedure exists
+     */
+    hasStoredProcedure(procedureName: string, schema?: string): Promise<boolean>;
+    /**
+     * List all stored procedures in the given (or configured) schema
+     *
+     * @param schema - Optional schema to list procedures from
+     * @returns Array of procedure names
+     */
+    listProcedures(schema?: string): Promise<string[]>;
+    /**
+     * Create a foreign data wrapper (MySQL - not supported)
+     * @param fdwName - Foreign data wrapper name
+     * @param options - Options including handler function
+     */
+    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>;
+    changeOwner(_newOwner: string, _tableName: string): Promise<void>;
+    /**
+     * Build an `ALTER TABLE ... ADD [CONSTRAINT name] ...` statement for the
+     * simple {@link addConstraint} form (synchronous, no execution). MySQL fully
+     * supports adding PRIMARY KEY / UNIQUE / FOREIGN KEY / CHECK constraints via
+     * ALTER TABLE, so this is a first-class capability — no raw SQL required.
+     */
+    buildAddConstraintSql(tableName: string, options: {
+        type: 'UNIQUE' | 'CHECK' | 'PRIMARY KEY' | 'FOREIGN KEY';
+        fields: string[];
+        name?: string;
+        references?: {
+            table: string;
+            fields: string[];
+        };
+        check?: string;
+    }): string;
+    /**
+     * Add a constraint to an existing table via `ALTER TABLE ... ADD CONSTRAINT`.
+     * MySQL supports this natively (the previous "not supported" error was wrong
+     * and forced callers into raw SQL).
+     */
+    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 constraint via `ALTER TABLE ... DROP CONSTRAINT` (MySQL
+     * 8.0.16+ accepts the generic form for CHECK/FK/PK/UNIQUE constraints). For
+     * kind-specific drops on older servers use {@link dropConstraint} with the
+     * appropriate clause.
+     */
+    removeConstraint(tableName: string, constraintName: string): Promise<void>;
+    createSecurityPolicy(_policyName: string, _tableName: string, _options?: {
+        predicate?: string;
+    }): Promise<void>;
+    dropSecurityPolicy(_policyName: string, _tableName: string): Promise<void>;
+    /**
+     * Create a trigger
+     */
+    createTrigger(options: TriggerOptions): Promise<void>;
+    /**
+     * Drop a trigger
+     */
+    dropTrigger(triggerName: string, tableName: string, options?: DropTriggerOptions): Promise<void>;
+    /**
+     * Check if a trigger exists
+     */
+    hasTrigger(triggerName: string, tableName: string): Promise<boolean>;
+    /**
+     * List all triggers, optionally filtered to a single table
+     *
+     * @param tableName - Optional table name to filter triggers by
+     * @returns Array of trigger names
+     */
+    listTriggers(tableName?: string): Promise<string[]>;
+    /**
+     * Create a sequence table with AUTO_INCREMENT
+     */
+    createSequence(options: SequenceOptions): Promise<void>;
+    /**
+     * Drop a sequence table
+     */
+    dropSequence(sequenceName: string, options?: DropSequenceOptions): Promise<void>;
+    /**
+     * Get next value from AUTO_INCREMENT
+     */
+    nextSequenceValue(sequenceName: string): Promise<number>;
+    /**
+     * Check if a sequence table exists
+     */
+    hasSequence(sequenceName: string): Promise<boolean>;
+    /**
+     * List all sequences in the database (MySQL - simulated via tables)
+     * @returns Array of sequence names
+     */
+    listSequences(): Promise<string[]>;
+    createPolicy(_options: PolicyOptions): Promise<void>;
+    dropPolicy(_policyName: string, _tableName: string, _options?: DropPolicyOptions): Promise<void>;
+    enableRLS(_tableName: string, _schema?: string): Promise<void>;
+    enableRowLevelSecurity(_tableName: string, _schema?: string): Promise<void>;
+    disableRLS(_tableName: string, _schema?: string): Promise<void>;
+    hasPolicy(_policyName: string, _tableName: string): Promise<boolean>;
+    /**
+     * Add comment to a table
+     */
+    commentTable(tableName: string, comment: string): Promise<void>;
+    /**
+     * Add comment to a column
+     */
+    commentColumn(tableName: string, columnName: string, comment: string): Promise<void>;
+    /**
+     * Create a partial index - NOT SUPPORTED by MySQL at any version.
+     *
+     * MySQL has no `CREATE INDEX ... WHERE ...` (filtered/partial index)
+     * syntax at any version, unlike PostgreSQL/SQL Server/SQLite. A previous
+     * version of this method built that syntax anyway, which a real MySQL
+     * server rejects with a syntax error — reject it explicitly instead,
+     * consistent with how `createIndex()` handles a `where` clause.
+     */
+    createPartialIndex(_tableName: string, _indexName: string, _fields: string[], _where: string, _options?: IndexOptions): Promise<void>;
+    /**
+     * Create an expression index - Not supported in MySQL < 8.0
+     */
+    createExpressionIndex(tableName: string, indexName: string, expression: string, options?: IndexOptions): Promise<void>;
+    /**
+     * Create an identity column - Not fully supported in MySQL
+     */
+    createIdentityColumn(tableName: string, columnName: string, options?: {
+        startWith?: number;
+        incrementBy?: number;
+    }): Promise<void>;
+    /**
+     * Create a computed column - Not supported in MySQL (except in generated columns)
+     */
+    createComputedColumn(tableName: string, columnName: string, expression: string, options?: {
+        persisted?: boolean;
+        type?: string;
+    }): Promise<void>;
+    /**
+     * Build CREATE SERVER query - Not supported by MySQL
+     */
+    buildCreateServerQuery(_name: string, _opts: FdwForeignServerOptions): string;
+    /**
+     * Build ALTER SERVER query - Not supported by MySQL
+     */
+    buildAlterServerQuery(_name: string, _opts: FdwAlterForeignServerOptions): string;
+    /**
+     * Build DROP SERVER query - Not supported by MySQL
+     */
+    buildDropServerQuery(_name: string, _opts?: {
+        ifExists?: boolean;
+        cascade?: boolean;
+    }): string;
+    /**
+     * Build CREATE USER MAPPING query - Not supported by MySQL
+     */
+    buildCreateUserMappingQuery(_opts: FdwUserMappingOptions): string;
+    /**
+     * Build ALTER USER MAPPING query - Not supported by MySQL
+     */
+    buildAlterUserMappingQuery(_opts: FdwUserMappingOptions): string;
+    /**
+     * Build DROP USER MAPPING query - Not supported by MySQL
+     */
+    buildDropUserMappingQuery(_serverName: string, _user: string, _opts?: {
+        ifExists?: boolean;
+    }): string;
+    /**
+     * Build CREATE FOREIGN TABLE query - Not supported by MySQL
+     */
+    buildCreateForeignTableQuery(_tableName: string, _opts: FdwForeignTableOptions): string;
+    /**
+     * Build DROP FOREIGN TABLE query - Not supported by MySQL
+     */
+    buildDropForeignTableQuery(_tableName: string, _opts?: {
+        ifExists?: boolean;
+        cascade?: boolean;
+    }): string;
+    /**
+     * Build IMPORT FOREIGN SCHEMA query - Not supported by MySQL
+     */
+    buildImportForeignSchemaQuery(_remoteSchema: string, _serverName: string, _opts?: FdwImportForeignSchemaOptions): string;
+    /**
+     * Get servers query - Not supported by MySQL
+     */
+    getServersQuery(): string;
+    /**
+     * Replace placeholders in SQL with actual values
+     * Supports both named (:param) and positional (?) placeholders
+     */
+    replaceReplacements(sql: string, replacements?: Record<string, unknown> | unknown[]): string;
+    /**
+     * Build a subquery for includes with LIMIT/OFFSET support
+     */
+    private buildSubqueryIncludes;
+    /**
+     * Add an index to a table
+     * Supports expression indexes and INCLUDE columns (MySQL 8.0+)
+     */
+    addIndex(tableName: string, indexName: string, fields?: string[], options?: IndexOptions): Promise<void>;
+    /**
+     * Remove an index from a table
+     */
+    removeIndex(tableName: string, indexName: string): Promise<void>;
+    /**
+     * Create an index on a table with full options support
+     * Supports expression indexes and INCLUDE columns (MySQL 8.0+)
+     */
+    createIndex(tableName: string, indexDef: {
+        name: string;
+        unique?: boolean;
+        type?: string;
+        using?: string;
+        fields: string[];
+        where?: WhereOptions;
+        expression?: string;
+        include?: string[];
+        invisible?: boolean;
+    }): Promise<void>;
+    /**
+     * Toggle visibility of an existing column (MySQL 8.0+).
+     *
+     * Uses `ALTER TABLE ... ALTER COLUMN ... SET VISIBLE|INVISIBLE`, which
+     * only changes metadata (fast, in-place) rather than rewriting the
+     * table like `MODIFY COLUMN` would. Useful for zero-downtime column
+     * rollout: add the column invisible, backfill it, then flip it visible
+     * once verified.
+     *
+     * @param tableName - Name of the table
+     * @param columnName - Name of the column to toggle
+     * @param invisible - true to hide the column, false to make it visible
+     */
+    alterColumnVisibility(tableName: string, columnName: string, invisible: boolean): Promise<void>;
+    /**
+     * Toggle visibility of an existing index (MySQL 8.0+).
+     *
+     * Uses `ALTER TABLE ... ALTER INDEX ... VISIBLE|INVISIBLE`, which only
+     * changes metadata rather than rebuilding the index. Useful for testing
+     * the impact of dropping an index (or rolling one out) without the cost
+     * of a destructive DROP/CREATE INDEX cycle. Note: a table's primary key
+     * cannot be made invisible.
+     *
+     * @param tableName - Name of the table
+     * @param indexName - Name of the index to toggle
+     * @param invisible - true to hide the index from the optimizer, false to make it visible
+     */
+    alterIndexVisibility(tableName: string, indexName: string, invisible: boolean): Promise<void>;
+    /**
+     * Build a FULLTEXT index on a table
+     * MySQL-specific full-text search index
+     */
+    createFulltextIndex(tableName: string, indexName: string, fields: string[], options?: {
+        parser?: string;
+        comment?: string;
+    }): Promise<void>;
+    /**
+     * Build a SPATIAL index on a table
+     * MySQL-specific spatial index for geometry columns
+     * Requires MySQL 5.7+ and InnoDB
+     */
+    createSpatialIndex(tableName: string, indexName: string, fields: string[], options?: {
+        /** Storage engine for the index (InnoDB or MyISAM) */
+        storage?: 'InnoDB' | 'MyISAM';
+        /** SRID for the spatial reference system (typically 4326 for WGS84) */
+        srid?: number;
+    }): Promise<void>;
+    /**
+     * Build a multi-valued index expression for a JSON array column (MySQL 8.0.17+).
+     * Multi-valued indexes let `JSON_CONTAINS`/`MEMBER OF` perform many-to-many-in-JSON
+     * lookups efficiently against a scalar-typed JSON array.
+     * MySQL: (CAST(column->'$[*]' AS <castType> ARRAY))
+     */
+    buildMultiValuedIndexExpression(jsonColumn: string, castType: string, path?: string): string;
+    /**
+     * Create a multi-valued index on a JSON array column (MySQL 8.0.17+).
+     *
+     * @example
+     * // CREATE INDEX idx_tags ON products ((CAST(tags->'$[*]' AS CHAR(20) ARRAY)))
+     * await dialect.createMultiValuedIndex('products', 'idx_tags', 'tags', { castType: 'CHAR(20)' });
+     */
+    createMultiValuedIndex(tableName: string, indexName: string, jsonColumn: string, options: {
+        castType: string;
+        path?: string;
+    }): Promise<void>;
+    /**
+     * Bulk insert records into a table
+     */
+    bulkInsert(tableName: string, records: Record<string, any>[], _options?: any): 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 user mapping (MySQL doesn't support user mappings)
+     */
+    createUserMapping(_userName: string, _serverName: string, _options?: any): Promise<void>;
+    /**
+     * Drop a user mapping (MySQL doesn't support user mappings)
+     */
+    dropUserMapping(_userName: string, _serverName: string, _options?: any): Promise<void>;
+    /**
+     * ST_Distance - calculate distance between two geometries
+     * MySQL 8.0+ spatial function
+     */
+    stDistance(geom1: string, geom2: string, srid?: number): string;
+    /**
+     * ST_Within - check if geometry A is within geometry B
+     * MySQL 8.0+ spatial function
+     */
+    stWithin(geom1: string, geom2: string, srid?: number): string;
+    /**
+     * ST_Contains - check if geometry A contains geometry B
+     * MySQL 8.0+ spatial function
+     */
+    stContains(geom1: string, geom2: string, srid?: number): string;
+    /**
+     * ST_Intersects - check if two geometries intersect
+     * MySQL 8.0+ spatial function
+     */
+    stIntersects(geom1: string, geom2: string, srid?: number): string;
+    /**
+     * ST_DWithin - check if geometries are within a given distance
+     * MySQL 8.0+ spatial function
+     */
+    stDWithin(geom1: string, geom2: string, distance: number, srid?: number): string;
+    /**
+     * ST_GeomFromText - create geometry from WKT text
+     */
+    stGeomFromText(wkt: string, srid?: number): string;
+    /**
+     * ST_GeomFromGeoJSON - create geometry from GeoJSON
+     */
+    stGeomFromGeoJSON(geojson: string, srid?: number): string;
+    /**
+     * ST_AsGeoJSON - convert geometry to GeoJSON
+     */
+    stAsGeoJSON(geom: string): string;
+    /**
+     * ST_AsText - convert geometry to WKT
+     */
+    stAsText(geom: string): string;
+    /**
+     * Build a MATCH AGAINST full-text search expression
+     * SQL: MATCH(columns) AGAINST(searchTerm [IN NATURAL LANGUAGE MODE | IN BOOLEAN MODE])
+     */
+    buildMatchAgainst(columns: string | string[], searchTerm: string, options?: {
+        mode?: 'natural' | 'boolean';
+        modifier?: 'WITH QUERY EXPANSION' | 'IN NATURAL LANGUAGE MODE WITH QUERY EXPANSION';
+    }): string;
+    /**
+     * Drop an index from a table
+     */
+    dropIndex(tableName: string, indexName: string, options?: {
+        ifExists?: boolean;
+        cascade?: boolean;
+    }): Promise<void>;
+    /**
+     * Create a constraint on a table
+     */
+    createConstraint(tableName: string, constraintDef: {
+        name: string;
+        type: 'PRIMARY KEY' | 'UNIQUE' | 'FOREIGN KEY' | 'CHECK';
+        fields?: string[];
+        references?: {
+            table: string;
+            field: string;
+            onDelete?: string;
+            onUpdate?: string;
+        };
+        check?: string;
+    }): Promise<void>;
+    /**
+     * Drop a constraint from a table
+     */
+    dropConstraint(tableName: string, constraintName: string, options?: {
+        ifExists?: boolean;
+        cascade?: boolean;
+    }): Promise<void>;
+    /**
+     * Begin a new transaction
+     */
+    startTransaction(options?: TransactionOptions): Promise<Transaction>;
+    /**
+     * Commit a transaction
+     */
+    commitTransaction(transaction: Transaction): Promise<void>;
+    /**
+     * Rollback a transaction
+     */
+    rollbackTransaction(transaction: Transaction): Promise<void>;
+    /**
+     * Get the SQL for a data type
+     */
+    getDataTypeSql(dataType: DataType): string;
+    /**
+     * Build a WHERE clause from a WhereOptions object
+     */
+    buildWhereClause(where: WhereOptions, options?: {
+        replacements?: Record<string, unknown>;
+    }): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * Build an ORDER BY clause
+     */
+    buildOrderClause(order: Order, options?: {
+        replacements?: Record<string, unknown>;
+    }): string;
+    /**
+     * Build a LIMIT/OFFSET clause
+     */
+    buildLimitOffset(limit?: number | string, offset?: number | string): string;
+    /**
+     * Build an INSERT query
+     */
+    buildInsertQuery(tableName: string, values: Record<string, unknown>, options?: InsertOptions): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * Build an UPSERT query for MySQL
+     * Uses ON DUPLICATE KEY UPDATE syntax
+     */
+    buildUpsertQuery(tableName: string, values: Record<string, unknown>, options?: {
+        conflictFields?: string[];
+        updateOnDuplicate?: string[];
+        returning?: boolean | string[];
+    }): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * Build an increment query
+     * @param tableName - Table name
+     * @param fields - Fields to increment
+     * @param where - Where clause
+     * @param options - Query options (by: number)
+     */
+    buildIncrementQuery(tableName: string, fields: string | string[] | Record<string, number>, where: WhereOptions, options?: {
+        by?: number;
+    }): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * Build an UPDATE query
+     */
+    buildUpdateQuery(tableName: string, values: Record<string, unknown>, where: WhereOptions, options?: UpdateOptions): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * Build a DELETE query
+     */
+    buildDeleteQuery(tableName: string, where: WhereOptions, options?: DeleteOptions): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * Check if a value is a function expression (fn('COUNT', ...))
+     */
+    private isFnExpression;
+    /**
+     * Check if a value is a column expression (col('name'))
+     */
+    private isColExpression;
+    /**
+     * Check if a value is a literal expression (literal('sql'))
+     */
+    /**
+     * Render a literal expression, substituting any `bindings` into its `?`
+     * placeholders with dialect-correct escaping. `literalExpr(sql)` with no
+     * bindings is unchanged; `literalExpr('x > ?', [v])` no longer requires the
+     * caller to concatenate the value into the string themselves.
+     */
+    private literalSql;
+    private isLiteralExpression;
+    /**
+     * Compile a function expression to SQL
+     */
+    private compileFnExpression;
+    /**
+     * Build SELECT clause with support for function expressions and aliases
+     * Handles: 'field', ['field'], ['field', 'alias'], [fn('COUNT', 'id'), 'count']
+     */
+    private buildSelectClause;
+    /**
+     * Build GROUP BY clause with support for function expressions and aliases
+     * Handles: 'field', ['field1', 'field2'], [[fn('COUNT', 'id'), 'count']]
+     */
+    private buildGroupByClause;
+    /**
+     * Build a WHERE clause condition using standard operators (Op.gt, Op.eq, etc.)
+     */
+    private buildCondition;
+    /**
+     * Build a HAVING clause with support for standard Op operators
+     */
+    private buildHavingClause;
+    /**
+     * Build a `WITH [RECURSIVE] name (cols) AS (query), ...` prefix for the
+     * given CTE definitions. MySQL 8.0+ supports standard recursive CTE syntax
+     * (a single `RECURSIVE` keyword applies to the whole `WITH` clause, not
+     * per-CTE).
+     */
+    private buildWithClause;
+    /**
+     * Build a SELECT query
+     */
+    buildSelectQuery(options: MySQLSelectOptions): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * Escape a password string – replaces single quotes so it is safe to embed
+     * between single-quote delimiters in SQL.
+     */
+    private escapePassword;
+    /**
+     * Format a MySQL user identity as  'username'@'host'
+     */
+    private formatUserIdentity;
+    /**
+     * Format a MySQL privilege scope to the ON … part of a GRANT / REVOKE.
+     * Returns { scopeSql, columnPrefix } where columnPrefix is the
+     * "SELECT (col1, col2)" fragment that must precede ON for column-level grants.
+     */
+    private formatPrivilegeScope;
+    buildCreateUserQuery(username: string, options?: import('../../user-management').CreateUserOptions): string;
+    buildAlterUserQuery(username: string, options: import('../../user-management').AlterUserOptions): string;
+    buildDropUserQuery(username: string, options?: {
+        host?: string;
+        ifExists?: boolean;
+    }): string;
+    getUsersQuery(): string;
+    /**
+     * Create a database user
+     */
+    createUser(username: string, options?: Record<string, any>): Promise<void>;
+    buildGrantQuery(options: import('../../user-management').GrantOptions): string;
+    buildRevokeQuery(options: import('../../user-management').RevokeOptions): string;
+    buildShowGrantsQuery(username: string, host?: string): string;
+    buildFlushPrivilegesQuery(): string;
+    buildCreateRoleQuery(roleName: string, options?: import('../../user-management').RoleOptions): string;
+    buildDropRoleQuery(roleName: string, options?: {
+        ifExists?: boolean;
+        cascade?: boolean;
+    }): string;
+    buildGrantRoleQuery(role: string, to: string | string[], options?: {
+        withAdminOption?: boolean;
+    }): string;
+    buildRevokeRoleQuery(role: string, from: string | string[], _options?: {
+        cascade?: boolean;
+    }): string;
+    getRolesQuery(): string;
+    /**
+     * Generate SQL for creating a MySQL database
+     */
+    createDatabaseSQL(options: {
+        name: string;
+        encoding?: string;
+        collate?: string;
+    }): string;
+    /**
+     * Generate SQL for dropping a MySQL database
+     */
+    dropDatabaseSQL(name: string): string;
+    /**
+     * Generate SQL for creating a savepoint
+     */
+    createSavepointSQL(name?: string): string;
+    /**
+     * Generate SQL for releasing a savepoint
+     */
+    releaseSavepointSQL(name: string): string;
+    /**
+     * Generate SQL for rolling back to a savepoint
+     */
+    rollbackToSavepointSQL(name: string): string;
+}
+/**
+ * MySQL-specific transaction class
+ */
+export declare class MySQLTransaction implements Transaction {
+    id: string;
+    finished: boolean;
+    options: TransactionOptions;
+    parent: Transaction | null;
+    savepoints: string[];
+    connection: PoolConnection | null;
+    private savepointCount;
+    constructor(connection: PoolConnection, options?: TransactionOptions);
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+    /**
+     * Create a savepoint
+     */
+    createSavepoint(name?: string): Promise<string>;
+    /**
+     * Rollback to a savepoint
+     */
+    rollbackToSavepoint(name: string): Promise<void>;
+    /**
+     * Release a savepoint
+     */
+    releaseSavepoint(name: string): Promise<void>;
+}
+export interface MySQLDialectOptions extends DialectOptions {
+    host?: string;
+    port?: number;
+    database?: string;
+    username?: string;
+    password?: string;
+    timezone?: string;
+    charset?: string;
+    collation?: string;
+    waitForConnections?: boolean;
+    connectionLimit?: number;
+    queueLimit?: number;
+    ssl?: any;
+    debug?: boolean;
+    trace?: boolean;
+    /** Connection pool options */
+    pool?: PoolOptions;
+    /** Retry options for connection */
+    retry?: RetryOptions;
+    /** Connection timeout in milliseconds */
+    connectTimeout?: number;
+    /** Idle timeout in milliseconds */
+    idleTimeout?: number;
+}
+/**
+ * Helper class for building stored procedure bodies with full PL/SQL support
+ * Supports: IN/OUT/INOUT parameters, local variables, IF/ELSE, WHILE loops, cursors
+ */
+declare class ProcedureBodyBuilder {
+    private statements;
+    private dialect;
+    constructor(dialect: MySQLDialect);
+    /**
+     * Declare a local variable
+     */
+    declare(name: string, type: string, defaultValue?: unknown): this;
+    /**
+     * Set a variable value
+     */
+    set(name: string, value: unknown): this;
+    /**
+     * Set a variable from a SELECT query (single value)
+     */
+    setFromSelect(name: string, query: string): this;
+    /**
+     * IF condition
+     */
+    if(condition: string, then: (builder: ProcedureBodyBuilder) => void): this;
+    /**
+     * IF/ELSE condition
+     */
+    ifElse(condition: string, then: (builder: ProcedureBodyBuilder) => void, else_: (builder: ProcedureBodyBuilder) => void): this;
+    /**
+     * WHILE loop
+     */
+    whileLoop(condition: string, do_: (builder: ProcedureBodyBuilder) => void): this;
+    /**
+     * REPEAT loop (do-while)
+     */
+    repeatLoop(do_: (builder: ProcedureBodyBuilder) => void, condition: string): this;
+    /**
+     * FOR loop over a query
+     */
+    forLoop(variableName: string, query: string, do_: (builder: ProcedureBodyBuilder, itemVar: string) => void): this;
+    /**
+     * Declare and open a cursor
+     */
+    declareCursor(name: string, query: string): this;
+    /**
+     * Open a cursor
+     */
+    openCursor(name: string): this;
+    /**
+     * Fetch from cursor into variables
+     */
+    fetchCursor(name: string, into: string[]): this;
+    /**
+     * Close a cursor
+     */
+    closeCursor(name: string): this;
+    /**
+     * Execute a raw SQL statement
+     */
+    sql(statement: string): this;
+    /**
+     * Call another stored procedure
+     */
+    call(procedureName: string, params?: Record<string, unknown>): this;
+    /**
+     * Insert statement
+     */
+    insert(tableName: string, data: Record<string, unknown>): this;
+    /**
+     * Update statement
+     */
+    update(tableName: string, data: Record<string, unknown>, where?: string): this;
+    /**
+     * Delete statement
+     */
+    delete(tableName: string, where?: string): this;
+    /**
+     * SELECT INTO statement
+     */
+    selectInto(variables: string[], query: string): this;
+    /**
+     * Add a comment
+     */
+    comment(text: string): this;
+    /**
+     * Build the final procedure body
+     */
+    build(): string;
+}
+/**
+ * Create a new MySQL dialect instance
+ */
+export declare function createMySQLDialect(options?: MySQLDialectOptions): MySQLDialect;
+export default MySQLDialect;