ts-prorm-orm 1.1.0

package/dist/dialects/mysql/index.js

@@ -0,0 +1,4058 @@
+"use strict";
+/**
+ * MySQL dialect implementation for the TypeScript ORM
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MySQLTransaction = exports.MySQLDialect = void 0;
+exports.createMySQLDialect = createMySQLDialect;
+const promise_1 = __importDefault(require("mysql2/promise"));
+const prorm_1 = require("../../prorm");
+const operators_1 = require("../../operators");
+/**
+ * Default retry options for connection
+ */
+const DEFAULT_RETRY_OPTIONS = {
+    max: 3,
+    timeout: 1000,
+    match: [
+        'ECONNREFUSED',
+        'ENOTFOUND',
+        'ETIMEDOUT',
+        'ER_ACCESS_DENIED_ERROR',
+        'ER_BAD_DB_ERROR',
+        'connect timeout',
+        'connection timeout',
+        'Too many connections',
+        'Lock wait timeout',
+    ],
+    backoff: false,
+    backoffMultiplier: 2,
+    backoffMax: 10000,
+};
+/**
+ * Default pool options for MySQL
+ */
+const DEFAULT_POOL_OPTIONS = {
+    max: 10,
+    min: 0,
+    acquire: 60000,
+    idle: 30000,
+    evict: 1000,
+    handleDisconnects: true,
+    onConnect: undefined,
+    onDisconnect: undefined,
+    enableEvents: false,
+    logPoolOperations: false,
+};
+/**
+ * MySQL dialect class that implements the Dialect interface
+ */
+class MySQLDialect {
+    constructor(config) {
+        this.name = 'mysql';
+        this.library = 'mysql2';
+        this.pool = null;
+        this._isConnected = false;
+        this.poolOptions = config.pool || {};
+        this.retryOptions = config.retry || {};
+        this.config = {
+            host: 'localhost',
+            port: 3306,
+            waitForConnections: true,
+            connectionLimit: this.poolOptions.max || DEFAULT_POOL_OPTIONS.max,
+            queueLimit: 0,
+            ...config,
+        };
+    }
+    /**
+     * Execute a function with retry logic
+     */
+    async withRetry(fn) {
+        const retryConfig = { ...DEFAULT_RETRY_OPTIONS, ...this.retryOptions };
+        let lastError;
+        const { backoff, backoffMultiplier, backoffMax, max, match, timeout } = retryConfig;
+        for (let attempt = 0; attempt <= max; attempt++) {
+            try {
+                return await fn();
+            }
+            catch (error) {
+                lastError = error;
+                const errorMessage = lastError.message;
+                // Check if this error should be retried
+                const shouldRetry = match.some((pattern) => errorMessage.toLowerCase().includes(pattern.toLowerCase()));
+                if (!shouldRetry || attempt === max) {
+                    throw lastError;
+                }
+                // Calculate delay - use exponential backoff if enabled
+                let delay;
+                if (backoff) {
+                    delay = timeout * Math.pow(backoffMultiplier || 2, attempt);
+                    delay = Math.min(delay, backoffMax || 10000);
+                }
+                else {
+                    delay = timeout;
+                }
+                // Add some jitter to avoid thundering herd
+                const jitter = Math.random() * 100;
+                await new Promise((resolve) => setTimeout(resolve, delay + jitter));
+            }
+        }
+        throw lastError;
+    }
+    /**
+     * Connect to the MySQL database with retry logic
+     */
+    async connect() {
+        await this.withRetry(async () => {
+            const poolConfig = {
+                host: this.config.host,
+                port: this.config.port,
+                user: this.config.username,
+                password: this.config.password,
+                database: this.config.database,
+                waitForConnections: this.config.waitForConnections,
+                connectionLimit: this.poolOptions.max || DEFAULT_POOL_OPTIONS.max,
+                queueLimit: this.config.queueLimit,
+                timezone: this.config.timezone || 'Z',
+                charset: this.config.charset || 'utf8mb4',
+                ssl: this.config.ssl,
+                supportBigNumbers: true,
+                bigNumberStrings: false,
+                dateStrings: false,
+                debug: this.config.debug,
+                trace: this.config.trace,
+            };
+            // Add connection timeout if configured
+            if (this.config.connectTimeout) {
+                poolConfig.connectTimeout = this.config.connectTimeout;
+            }
+            // Add idle timeout if configured
+            if (this.config.idleTimeout) {
+                poolConfig.idleTimeout = this.config.idleTimeout;
+            }
+            this.pool = promise_1.default.createPool(poolConfig);
+            // Test the connection
+            const connection = await this.pool.getConnection();
+            connection.release();
+            this._isConnected = true;
+        });
+    }
+    /**
+     * Disconnect from the MySQL database
+     */
+    async disconnect() {
+        if (this.pool) {
+            await this.pool.end();
+            this.pool = null;
+            this._isConnected = false;
+        }
+    }
+    /**
+     * Get the current connection pool
+     */
+    getConnection() {
+        return this.pool;
+    }
+    /**
+     * Check if connected
+     */
+    isConnected() {
+        return this._isConnected && this.pool !== null;
+    }
+    /**
+     * Execute a raw SQL query with retry support
+     */
+    async query(sql, options) {
+        // Default retry options for queries
+        const defaultQueryRetryOptions = {
+            max: 3,
+            timeout: 1000,
+            match: [
+                'ECONNREFUSED',
+                'ENOTFOUND',
+                'ETIMEDOUT',
+                'connect timeout',
+                'connection timeout',
+                'Too many connections',
+                'Lock wait timeout',
+                'Deadlock',
+            ],
+            backoff: false,
+            backoffMultiplier: 2,
+            backoffMax: 10000,
+        };
+        // Use retry options from query options, or fall back to dialect-level retry config
+        const retryOptions = options?.retry;
+        const effectiveRetry = retryOptions
+            ? {
+                ...defaultQueryRetryOptions,
+                ...retryOptions,
+                match: retryOptions.match || defaultQueryRetryOptions.match,
+            }
+            : this.retryOptions
+                ? { ...defaultQueryRetryOptions, ...this.retryOptions }
+                : null;
+        const executeQuery = async () => {
+            if (!this.pool) {
+                throw new Error('Not connected to database');
+            }
+            const isSelect = sql.trim().toUpperCase().startsWith('SELECT') ||
+                sql.trim().toUpperCase().startsWith('SHOW') ||
+                sql.trim().toUpperCase().startsWith('DESCRIBE') ||
+                sql.trim().toUpperCase().startsWith('EXPLAIN');
+            try {
+                // Apply replacements so parameterized queries (e.g. bulkInsert's
+                // `VALUES (?, ?)`) actually receive their bound values. Positional
+                // (array) replacements are bound by the driver; named (object)
+                // replacements are inlined via replaceReplacements.
+                const replacements = options?.replacements;
+                let finalSql = sql;
+                let bindValues;
+                if (replacements !== undefined && replacements !== null) {
+                    if (Array.isArray(replacements)) {
+                        bindValues = replacements;
+                    }
+                    else {
+                        finalSql = this.replaceReplacements(sql, replacements);
+                    }
+                }
+                const [rows, fields] = (await (bindValues !== undefined
+                    ? this.pool.query(finalSql, bindValues)
+                    : this.pool.query(finalSql)));
+                // Transform fields
+                const fieldInfo = fields
+                    ? fields.map((field) => ({
+                        name: field.name,
+                        type: String(field.type),
+                        length: field.length ?? 0,
+                        tableID: 0,
+                        columnID: 0,
+                        nullable: true,
+                        isEnum: false,
+                        isPrimaryKey: false,
+                    }))
+                    : [];
+                if (isSelect) {
+                    return {
+                        rows: rows,
+                        rowCount: rows.length,
+                        fields: fieldInfo,
+                    };
+                }
+                else {
+                    const result = rows;
+                    return {
+                        rows: [],
+                        rowCount: result?.affectedRows || 0,
+                        fields: fieldInfo,
+                    };
+                }
+            }
+            catch (error) {
+                throw new Error(`MySQL Query error: ${error}`);
+            }
+        };
+        // If retry options are provided, use retry logic
+        if (effectiveRetry && effectiveRetry.max > 0) {
+            return this.executeWithRetry(executeQuery, effectiveRetry);
+        }
+        return executeQuery();
+    }
+    /**
+     * 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, options) {
+        const { Readable } = require('stream');
+        const highWaterMark = options?.highWaterMark || 1000;
+        // Create a custom readable stream
+        const stream = new Readable({
+            objectMode: true,
+            highWaterMark,
+            read() { },
+        });
+        if (!this.pool) {
+            stream.destroy(new Error('Not connected to database'));
+            return stream;
+        }
+        // Use mysql2's createQueryStream for streaming
+        const mysql = require('mysql2/promise');
+        // @ts-ignore - createQueryStream is available in mysql2
+        const queryStream = this.pool.createQueryStream(sql);
+        queryStream.on('result', (row) => {
+            // For each row, push to our stream
+            // If stream buffer is full, pause the query
+            if (options?.mapToModel && options?.model) {
+                // Map to model instance if requested
+                const instance = new options.model();
+                Object.assign(instance, row);
+                const canContinue = stream.push(instance);
+                if (!canContinue) {
+                    queryStream.pause();
+                }
+            }
+            else {
+                const canContinue = stream.push(row);
+                if (!canContinue) {
+                    queryStream.pause();
+                }
+            }
+        });
+        queryStream.on('error', (queryErr) => {
+            stream.destroy(queryErr);
+        });
+        queryStream.on('end', () => {
+            stream.push(null);
+        });
+        return stream;
+    }
+    /**
+     * Execute a function with retry logic for query execution
+     */
+    async executeWithRetry(fn, retryOptions) {
+        let lastError;
+        const { backoff, backoffMultiplier, backoffMax } = retryOptions;
+        for (let attempt = 0; attempt <= retryOptions.max; attempt++) {
+            try {
+                return await fn();
+            }
+            catch (error) {
+                lastError = error;
+                const errorMessage = lastError.message;
+                // Check if this error should be retried
+                const shouldRetry = retryOptions.match.some((pattern) => errorMessage.toLowerCase().includes(pattern.toLowerCase()));
+                if (!shouldRetry || attempt === retryOptions.max) {
+                    throw lastError;
+                }
+                // Calculate delay - use exponential backoff if enabled
+                let delay;
+                if (backoff) {
+                    delay = retryOptions.timeout * Math.pow(backoffMultiplier || 2, attempt);
+                    delay = Math.min(delay, backoffMax || 10000);
+                }
+                else {
+                    delay = retryOptions.timeout;
+                }
+                // Add some jitter to avoid thundering herd
+                const jitter = Math.random() * 100;
+                await new Promise((resolve) => setTimeout(resolve, delay + jitter));
+            }
+        }
+        throw lastError;
+    }
+    /**
+     * Escape a value for use in a query
+     */
+    escape(value) {
+        // Handle Literal (raw SQL) values - insert directly without escaping
+        if (value instanceof prorm_1.Literal) {
+            return value.val;
+        }
+        if (value === null) {
+            return 'NULL';
+        }
+        if (typeof value === 'string') {
+            return `'${this.escapeString(value)}'`;
+        }
+        if (typeof value === 'number') {
+            return String(value);
+        }
+        if (typeof value === 'bigint') {
+            return value.toString();
+        }
+        if (typeof value === 'boolean') {
+            // Emit the TRUE/FALSE keyword literals rather than 1/0. Both compare
+            // identically for ordinary numeric/TINYINT boolean columns, but only
+            // the keyword form compares equal to a JSON boolean extracted via
+            // JSON_EXTRACT()/->  — `JSON_EXTRACT(col, '$.path') = 1` never matches
+            // a JSON `true` value on a real MySQL server, while `= TRUE` does.
+            return value ? 'TRUE' : 'FALSE';
+        }
+        if (value instanceof Date) {
+            return `'${this.formatDate(value)}'`;
+        }
+        if (Buffer.isBuffer(value)) {
+            return `X'${value.toString('hex')}'`;
+        }
+        // JSON stringify objects
+        return `'${this.escapeString(JSON.stringify(value))}'`;
+    }
+    /**
+     * Build a JSON extraction query for MySQL
+     * MySQL: JSON_EXTRACT(column, '$.path') and JSON_UNQUOTE(JSON_EXTRACT(...))
+     */
+    buildJsonExtract(column, path, asText = true) {
+        const columnRef = this.escapeId(column);
+        const normalizedPath = path.startsWith('$.') ? path : `$.${path}`;
+        if (asText) {
+            // MySQL needs JSON_UNQUOTE to get text value
+            return `JSON_UNQUOTE(JSON_EXTRACT(${columnRef}, '${normalizedPath}'))`;
+        }
+        return `JSON_EXTRACT(${columnRef}, '${normalizedPath}')`;
+    }
+    /**
+     * Build a JSON contains query for MySQL
+     * MySQL: JSON_CONTAINS(column, value[, path])
+     */
+    buildJsonContains(column, value, path) {
+        const columnRef = this.escapeId(column);
+        const values = [JSON.stringify(value)];
+        if (path) {
+            const normalizedPath = path.startsWith('$.') ? path : `$.${path}`;
+            return {
+                sql: `JSON_CONTAINS(${columnRef}, ?, '${normalizedPath}')`,
+                values,
+            };
+        }
+        return {
+            sql: `JSON_CONTAINS(${columnRef}, ?)`,
+            values,
+        };
+    }
+    /**
+     * Build a JSON has key query for MySQL
+     * MySQL: JSON_CONTAINS_PATH(column, 'one'|'all', '$.key')
+     */
+    buildJsonHasKey(column, key, type = 'one') {
+        const columnRef = this.escapeId(column);
+        const normalizedKey = key.startsWith('$.') ? key : `$.${key}`;
+        return `JSON_CONTAINS_PATH(${columnRef}, '${type}', '${normalizedKey}')`;
+    }
+    /**
+     * Build a JSON path query for MySQL
+     */
+    buildJsonPathQuery(column, path, value, operator = '=') {
+        const values = [];
+        const columnRef = this.escapeId(column);
+        const normalizedPath = path.startsWith('$.') ? path : `$.${path}`;
+        const jsonExtract = this.buildJsonExtract(column, normalizedPath, true);
+        if (value !== undefined) {
+            values.push(value);
+            return { sql: `${jsonExtract} ${operator} ?`, values };
+        }
+        return { sql: jsonExtract, values };
+    }
+    /**
+     * 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, pathValues) {
+        const columnRef = this.escapeId(column);
+        const values = [];
+        const parts = [];
+        for (const [path, value] of Object.entries(pathValues)) {
+            const normalizedPath = path.startsWith('$') ? path : `$.${path}`;
+            parts.push(`'${normalizedPath}', ?`);
+            values.push(value);
+        }
+        return {
+            sql: `JSON_SET(${columnRef}, ${parts.join(', ')})`,
+            values,
+        };
+    }
+    /**
+     * Build a JSON_REPLACE expression, updating values only at paths that already exist.
+     * MySQL: JSON_REPLACE(column, '$.path1', ?, ...)
+     */
+    buildJsonReplace(column, pathValues) {
+        const columnRef = this.escapeId(column);
+        const values = [];
+        const parts = [];
+        for (const [path, value] of Object.entries(pathValues)) {
+            const normalizedPath = path.startsWith('$') ? path : `$.${path}`;
+            parts.push(`'${normalizedPath}', ?`);
+            values.push(value);
+        }
+        return {
+            sql: `JSON_REPLACE(${columnRef}, ${parts.join(', ')})`,
+            values,
+        };
+    }
+    /**
+     * Build a JSON_INSERT expression, inserting values only at paths that do not already exist.
+     * MySQL: JSON_INSERT(column, '$.path1', ?, ...)
+     */
+    buildJsonInsert(column, pathValues) {
+        const columnRef = this.escapeId(column);
+        const values = [];
+        const parts = [];
+        for (const [path, value] of Object.entries(pathValues)) {
+            const normalizedPath = path.startsWith('$') ? path : `$.${path}`;
+            parts.push(`'${normalizedPath}', ?`);
+            values.push(value);
+        }
+        return {
+            sql: `JSON_INSERT(${columnRef}, ${parts.join(', ')})`,
+            values,
+        };
+    }
+    /**
+     * Build a JSON_REMOVE expression to remove data at the given paths.
+     * MySQL: JSON_REMOVE(column, '$.path1', '$.path2', ...)
+     */
+    buildJsonRemove(column, paths) {
+        const columnRef = this.escapeId(column);
+        const pathList = paths
+            .map((path) => `'${path.startsWith('$') ? path : `$.${path}`}'`)
+            .join(', ');
+        return `JSON_REMOVE(${columnRef}, ${pathList})`;
+    }
+    /**
+     * 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, ...documents) {
+        const columnRef = this.escapeId(column);
+        const values = documents.map((doc) => (typeof doc === 'string' ? doc : JSON.stringify(doc)));
+        const placeholders = values.map(() => '?').join(', ');
+        return {
+            sql: `JSON_MERGE_PATCH(${columnRef}, ${placeholders})`,
+            values,
+        };
+    }
+    /**
+     * 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, ...documents) {
+        const columnRef = this.escapeId(column);
+        const values = documents.map((doc) => (typeof doc === 'string' ? doc : JSON.stringify(doc)));
+        const placeholders = values.map(() => '?').join(', ');
+        return {
+            sql: `JSON_MERGE_PRESERVE(${columnRef}, ${placeholders})`,
+            values,
+        };
+    }
+    /**
+     * Build a JSON_ARRAYAGG aggregate expression.
+     * MySQL: JSON_ARRAYAGG(expr) - aggregates a column/expression (typically grouped)
+     * into a single JSON array.
+     */
+    buildJsonArrayAgg(expression, alias) {
+        const columnExpr = /[\s(]/.test(expression) ? expression : this.escapeId(expression);
+        const sql = `JSON_ARRAYAGG(${columnExpr})`;
+        return alias ? `${sql} AS ${this.escapeId(alias)}` : sql;
+    }
+    /**
+     * Build a JSON_OBJECTAGG aggregate expression.
+     * MySQL: JSON_OBJECTAGG(key, value) - aggregates key/value pairs (typically grouped)
+     * into a single JSON object.
+     */
+    buildJsonObjectAgg(keyExpression, valueExpression, alias) {
+        const keyExpr = /[\s(]/.test(keyExpression) ? keyExpression : this.escapeId(keyExpression);
+        const valueExpr = /[\s(]/.test(valueExpression)
+            ? valueExpression
+            : this.escapeId(valueExpression);
+        const sql = `JSON_OBJECTAGG(${keyExpr}, ${valueExpr})`;
+        return alias ? `${sql} AS ${this.escapeId(alias)}` : sql;
+    }
+    /**
+     * 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, rowPath, columns, alias) {
+        const columnDefs = columns
+            .map((col) => {
+            if (col.forOrdinality) {
+                return `${this.escapeId(col.name)} FOR ORDINALITY`;
+            }
+            return `${this.escapeId(col.name)} ${col.type} PATH '${col.path}'`;
+        })
+            .join(', ');
+        return `JSON_TABLE(${jsonExpression}, '${rowPath}' COLUMNS(${columnDefs})) AS ${this.escapeId(alias)}`;
+    }
+    /**
+     * Escape a string for SQL
+     */
+    escapeString(str) {
+        return str.replace(/'/g, "''").replace(/\\/g, '\\\\');
+    }
+    /**
+     * Format a date for MySQL
+     */
+    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}`;
+    }
+    /**
+     * Escape an identifier (table name, column name, etc.)
+     */
+    escapeId(identifier) {
+        const id = String(identifier ?? '');
+        return `\`${id.replace(/`/g, '``')}\``;
+    }
+    /**
+     * Quote an identifier (column name, table name)
+     * MySQL uses backticks for identifiers
+     */
+    quoteIdentifier(identifier) {
+        return this.escapeId(identifier);
+    }
+    /**
+     * 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) {
+        const parts = String(tableName ?? '').split('.');
+        return parts.map((part) => this.escapeId(part)).join('.');
+    }
+    /**
+     * Get the database version
+     */
+    async getDatabaseVersion() {
+        if (!this.pool) {
+            throw new Error('Not connected to database');
+        }
+        const result = await this.query('SELECT VERSION() as version');
+        return result.rows[0]?.version || 'Unknown';
+    }
+    /**
+     * Create a new table
+     */
+    async createTable(tableName, columns, options) {
+        const columnDefs = [];
+        for (const [columnName, definition] of Object.entries(columns)) {
+            columnDefs.push(this.getColumnDefinitionSql(columnName, definition));
+        }
+        // Add constraints from options
+        if (options?.constraints) {
+            for (const constraint of options.constraints) {
+                const constraintSql = this.buildConstraintSql(constraint);
+                if (constraintSql) {
+                    columnDefs.push(constraintSql);
+                }
+            }
+        }
+        let sql = 'CREATE TABLE';
+        if (options?.ifNotExists) {
+            sql += ' IF NOT EXISTS';
+        }
+        sql += ` ${this.escapeId(tableName)} (${columnDefs.join(', ')})`;
+        // Add engine (MySQL-specific)
+        if (options?.engine) {
+            sql += ` ENGINE=${options.engine}`;
+        }
+        // Add charset
+        if (options?.charset) {
+            sql += ` DEFAULT CHARSET=${options.charset}`;
+        }
+        // Add collation
+        if (options?.collate) {
+            sql += ` COLLATE ${options.collate}`;
+        }
+        // Add table comment (MySQL 5.5.3+)
+        if (options?.comment) {
+            sql += ` COMMENT='${this.escapeString(options.comment)}'`;
+        }
+        // Add initial auto-increment value
+        if (options?.initialAutoIncrement) {
+            sql += ` AUTO_INCREMENT=${options.initialAutoIncrement}`;
+        }
+        // Add row format
+        if (options?.rowFormat) {
+            sql += ` ROW_FORMAT=${options.rowFormat}`;
+        }
+        // Add unique keys (defined at table level)
+        // Support both old format (Record<string, string[]>) and new format (UniqueKeyOptions[])
+        if (options?.uniqueKeys) {
+            if (Array.isArray(options.uniqueKeys)) {
+                // New format: UniqueKeyOptions[]
+                for (const uk of options.uniqueKeys) {
+                    const uniqueName = uk.name || `${tableName}_${uk.fields.join('_')}_key`;
+                    columnDefs.push(`UNIQUE KEY \`${uniqueName}\` (${uk.fields.map((f) => this.escapeId(f)).join(', ')})`);
+                }
+            }
+            else {
+                // Legacy format: Record<string, string[]>
+                for (const [keyName, fields] of Object.entries(options.uniqueKeys)) {
+                    const uniqueName = keyName || `uq_${tableName}_${fields.join('_')}`;
+                    columnDefs.push(`UNIQUE KEY \`${uniqueName}\` (${fields.map((f) => this.escapeId(f)).join(', ')})`);
+                }
+            }
+        }
+        await this.query(sql);
+        // Create indexes after table creation
+        if (options?.indexes) {
+            for (const index of options.indexes) {
+                await this.addIndex(tableName, index.name || `idx_${tableName}_${index.fields.join('_')}`, index.fields, {
+                    unique: index.unique,
+                    type: index.type,
+                    using: index.using,
+                    where: index.where,
+                    expression: index.expression,
+                    include: index.include,
+                });
+            }
+        }
+    }
+    /**
+     * Build constraint SQL for table creation (MySQL)
+     */
+    buildConstraintSql(constraint) {
+        const name = constraint.name ? `CONSTRAINT \`${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 'FOREIGN KEY':
+                if (!constraint.references)
+                    return null;
+                // Handle composite foreign keys (string | string[])
+                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;
+            case 'CHECK':
+                if (!constraint.check)
+                    return null;
+                return `${name}CHECK (${constraint.check})`;
+            default:
+                return null;
+        }
+    }
+    /**
+     * Generate column definition SQL for MySQL
+     */
+    getColumnDefinitionSql(columnName, definition) {
+        let sql = `${this.escapeId(columnName)} ${this.getDataTypeSql(definition.type)}`;
+        // Column-level CHARACTER SET / COLLATE (MySQL only supports this on
+        // string types, but MySQL itself will raise a clear error for
+        // incompatible types - we don't need to validate that here). These must
+        // come immediately after the data type, before NOT NULL/DEFAULT/etc.
+        if (definition.charset) {
+            sql += ` CHARACTER SET ${this.escapeId(definition.charset)}`;
+        }
+        if (definition.collate) {
+            sql += ` COLLATE ${this.escapeId(definition.collate)}`;
+        }
+        if (definition.allowNull === false) {
+            sql += ' NOT NULL';
+        }
+        if (definition.defaultValue !== undefined) {
+            sql += ` DEFAULT ${this.getDefaultValue(definition.defaultValue)}`;
+        }
+        // Column visibility (MySQL 8.0+). Must come after DEFAULT and before
+        // AUTO_INCREMENT/UNIQUE/PRIMARY KEY per the MySQL column_definition
+        // grammar. Columns are VISIBLE by default, so only emit the keyword
+        // when the column is explicitly marked invisible.
+        if (definition.invisible) {
+            sql += ' INVISIBLE';
+        }
+        if (definition.primaryKey) {
+            sql += ' PRIMARY KEY';
+        }
+        if (definition.autoIncrement) {
+            sql += ' AUTO_INCREMENT';
+        }
+        if (definition.unique) {
+            if (typeof definition.unique === 'string') {
+                sql += ` UNIQUE KEY ${this.escapeId(definition.unique)}`;
+            }
+            else {
+                sql += ' UNIQUE';
+            }
+        }
+        if (definition.references) {
+            // Handle composite foreign keys (string | string[])
+            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}`;
+            }
+        }
+        if (definition.comment) {
+            sql += ` COMMENT '${this.escapeString(definition.comment)}'`;
+        }
+        return sql;
+    }
+    /**
+     * Get default value SQL
+     */
+    getDefaultValue(value) {
+        if (value === null) {
+            return 'NULL';
+        }
+        if (typeof value === 'string') {
+            // Check for MySQL functions
+            if (value.toUpperCase().includes('CURRENT_') || value.toUpperCase() === 'NULL') {
+                return value;
+            }
+            return `'${this.escapeString(value)}'`;
+        }
+        if (typeof value === 'number' || typeof value === 'boolean') {
+            return String(value);
+        }
+        if (value instanceof Date) {
+            return `'${this.formatDate(value)}'`;
+        }
+        // Handle DataType instances with toDefaultValue method (e.g., DataTypes.NOW)
+        if (typeof value === 'object' &&
+            value !== null &&
+            typeof value.toDefaultValue === 'function') {
+            return value.toDefaultValue();
+        }
+        return `'${this.escapeString(String(value))}'`;
+    }
+    /**
+     * Drop a table
+     */
+    async dropTable(tableName, options) {
+        let sql = 'DROP TABLE';
+        if (options?.ifExists) {
+            sql += ' IF EXISTS';
+        }
+        sql += ` ${this.escapeId(tableName)}`;
+        if (options?.cascade) {
+            sql += ' CASCADE';
+        }
+        await this.query(sql);
+    }
+    /**
+     * 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
+     */
+    async createPartitionedTable(tableName, columns, options) {
+        const columnDefs = [];
+        for (const [columnName, definition] of Object.entries(columns)) {
+            columnDefs.push(this.getColumnDefinitionSql(columnName, definition));
+        }
+        // Add constraints from options
+        if (options?.constraints) {
+            for (const constraint of options.constraints) {
+                const constraintSql = this.buildConstraintSql(constraint);
+                if (constraintSql) {
+                    columnDefs.push(constraintSql);
+                }
+            }
+        }
+        let sql = 'CREATE TABLE';
+        if (options?.ifNotExists) {
+            sql += ' IF NOT EXISTS';
+        }
+        sql += ` ${this.escapeId(tableName)} (${columnDefs.join(', ')})`;
+        // Add engine (MySQL-specific)
+        if (options?.engine) {
+            sql += ` ENGINE=${options.engine}`;
+        }
+        // Add partitioning
+        if (options?.partitionBy) {
+            const { type, column } = options.partitionBy;
+            const columnsStr = Array.isArray(column) ? column.join(', ') : column;
+            // Plain `PARTITION BY RANGE (...)`/`PARTITION BY LIST (...)` require the
+            // partitioning expression to evaluate to an integer; a real MySQL server
+            // rejects non-integer columns (e.g. VARCHAR) with "VALUES value for
+            // partition '...' must have type INT". The `COLUMNS` variant (MySQL
+            // 5.5+) supports non-integer column types (strings, dates, etc.) with
+            // identical partition-definition syntax, so use it unconditionally for
+            // RANGE/LIST partitioning to support both integer and non-integer
+            // partitioning columns.
+            const partitionKeyword = type === 'range' || type === 'list' ? `${type.toUpperCase()} COLUMNS` : type.toUpperCase();
+            sql += ` PARTITION BY ${partitionKeyword} (${columnsStr})`;
+            // Add partition definitions
+            // Handle partitions being a number (e.g., partitions: 2 for KEY partitioning)
+            const partitions = Array.isArray(options.partitions)
+                ? options.partitions
+                : typeof options.partitions === 'number'
+                    ? []
+                    : [];
+            if (partitions.length > 0) {
+                sql += ' (';
+                const partitionDefs = [];
+                for (const partition of partitions) {
+                    let partitionSql = `PARTITION ${this.escapeId(partition.name)}`;
+                    if (partition.bound) {
+                        const bound = partition.bound;
+                        // Check for list partition
+                        if ('values' in bound && bound.values && Array.isArray(bound.values)) {
+                            const values = bound.values
+                                .map((v) => (typeof v === 'string' ? `'${v}'` : v))
+                                .join(', ');
+                            partitionSql += ` VALUES IN (${values})`;
+                        }
+                        // Check for hash partition
+                        else if ('modulus' in bound && bound.modulus !== undefined) {
+                            const hashBound = bound;
+                            partitionSql += ` VALUES WITH (MODULUS ${hashBound.modulus}, REMAINDER ${hashBound.remainder})`;
+                        }
+                        // Default to range partition
+                        else {
+                            const rangeBound = bound;
+                            const from = rangeBound.from;
+                            const to = rangeBound.to || 'MAXVALUE';
+                            const fromStr = from instanceof Date ? from.toISOString().split('T')[0] : from;
+                            const toStr = to instanceof Date ? to.toISOString().split('T')[0] : to;
+                            partitionSql += ` VALUES LESS THAN (${toStr})`;
+                        }
+                    }
+                    partitionDefs.push(partitionSql);
+                }
+                sql += partitionDefs.join(', ') + ')';
+            }
+        }
+        await this.query(sql);
+    }
+    /**
+     * Create a partition for an existing partitioned table (MySQL 5.1+)
+     *
+     * @param options - Partition creation options
+     */
+    async createPartition(options) {
+        let sql = `ALTER TABLE ${this.escapeId(options.parentTable)} ADD PARTITION (`;
+        if (options.bound) {
+            const bound = options.bound;
+            // Check for list partition
+            if ('values' in bound && bound.values && Array.isArray(bound.values)) {
+                const values = bound.values.map((v) => (typeof v === 'string' ? `'${v}'` : v)).join(', ');
+                sql += `PARTITION ${this.escapeId(options.name)} VALUES IN (${values})`;
+            }
+            // Check for hash partition
+            else if ('modulus' in bound && bound.modulus !== undefined) {
+                const hashBound = bound;
+                sql += `PARTITION ${this.escapeId(options.name)} VALUES WITH (MODULUS ${hashBound.modulus}, REMAINDER ${hashBound.remainder})`;
+            }
+            // Default to range partition
+            else {
+                const rangeBound = bound;
+                const from = rangeBound.from;
+                const to = rangeBound.to || 'MAXVALUE';
+                const fromStr = from instanceof Date ? from.toISOString().split('T')[0] : from;
+                const toStr = to instanceof Date ? to.toISOString().split('T')[0] : to;
+                sql += `PARTITION ${this.escapeId(options.name)} VALUES LESS THAN (${toStr})`;
+            }
+        }
+        else {
+            sql += `PARTITION ${this.escapeId(options.name)}`;
+        }
+        sql += ')';
+        await this.query(sql);
+    }
+    /**
+     * Attach a partition (MySQL uses ADD PARTITION instead)
+     * Provided for PostgreSQL compatibility
+     *
+     * @param options - Partition attachment options
+     */
+    async attachPartition(options) {
+        // MySQL uses ADD PARTITION instead of ATTACH PARTITION
+        // This is for compatibility - we just add the partition
+        let sql = `ALTER TABLE ${this.escapeId(options.parentTable)} ADD PARTITION (`;
+        sql += `PARTITION ${this.escapeId(options.partitionName)}`;
+        sql += ')';
+        await this.query(sql);
+    }
+    /**
+     * Detach a partition (MySQL does not support this operation)
+     *
+     * @param options - Partition detachment options
+     */
+    async detachPartition(_options) {
+        throw new Error('MySQL does not support detaching partitions. Use DROP PARTITION instead.');
+    }
+    /**
+     * 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
+     */
+    async dropPartition(partitionName, options) {
+        // MySQL requires the parent table name
+        // If parentTable is not provided in options, look it up from
+        // INFORMATION_SCHEMA.PARTITIONS instead of guessing at the table name by
+        // splitting the partition name on underscores — that heuristic is
+        // ambiguous (both table and partition names may themselves contain
+        // underscores) and cannot be made correct in general.
+        let parentTable = options?.parentTable;
+        if (!parentTable) {
+            const lookupSql = `SELECT TABLE_NAME FROM INFORMATION_SCHEMA.PARTITIONS WHERE TABLE_SCHEMA = ${this.escape(this.config.database || '')} AND PARTITION_NAME = ${this.escape(partitionName)} LIMIT 1`;
+            const lookupResult = await this.query(lookupSql);
+            if (lookupResult.rows.length === 0) {
+                throw new Error(`Could not infer the parent table for partition '${partitionName}': no matching partition was found in INFORMATION_SCHEMA.PARTITIONS. Pass options.parentTable explicitly.`);
+            }
+            parentTable = lookupResult.rows[0].TABLE_NAME;
+        }
+        let sql = 'ALTER TABLE';
+        sql += ` ${this.escapeId(parentTable)} DROP PARTITION ${this.escapeId(partitionName)}`;
+        await this.query(sql);
+    }
+    /**
+     * 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
+     */
+    async addPartition(tableName, partitionName, partitionSpec) {
+        // The partition name must be part of the ADD PARTITION definition itself
+        // (`ADD PARTITION (PARTITION <name> VALUES ...)`) — omitting it produces
+        // an unnamed/invalid partition definition and MySQL rejects the statement.
+        let sql = `ALTER TABLE ${this.escapeId(tableName)} ADD PARTITION (PARTITION ${this.escapeId(partitionName)}`;
+        if (partitionSpec.values) {
+            sql += ` VALUES ${partitionSpec.values}`;
+        }
+        else if (partitionSpec.forValues) {
+            sql += ` VALUES ${partitionSpec.forValues}`;
+        }
+        sql += ')';
+        await this.query(sql);
+    }
+    /**
+     * List all partitions for a table (MySQL 5.1+)
+     *
+     * @param tableName - Name of the table
+     * @returns Array of partition metadata
+     */
+    async listPartitions(tableName) {
+        const sql = `SELECT PARTITION_NAME, PARTITION_ORDINAL_POSITION, PARTITION_DESCRIPTION, TABLE_ROWS FROM INFORMATION_SCHEMA.PARTITIONS WHERE TABLE_SCHEMA = ${this.escape(this.config.database || '')} AND TABLE_NAME = ${this.escape(tableName)} AND PARTITION_NAME IS NOT NULL ORDER BY PARTITION_ORDINAL_POSITION`;
+        const result = await this.query(sql);
+        return result.rows.map((row) => ({
+            name: row.PARTITION_NAME,
+            ordinal: row.PARTITION_ORDINAL_POSITION,
+            description: row.PARTITION_DESCRIPTION,
+            rows: row.TABLE_ROWS,
+        }));
+    }
+    /**
+     * 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
+     */
+    async hasPartition(tableName) {
+        const sql = `SELECT PARTITION_NAME FROM INFORMATION_SCHEMA.PARTITIONS WHERE TABLE_SCHEMA = ${this.escape(this.config.database || '')} AND TABLE_NAME = ${this.escape(tableName)}`;
+        const result = await this.query(sql);
+        return result.rows.length > 0;
+    }
+    /**
+     * Add a column to a table
+     */
+    async addColumn(tableName, columnName, definition) {
+        const sql = `ALTER TABLE ${this.escapeId(tableName)} ADD COLUMN ${this.getColumnDefinitionSql(columnName, definition)}`;
+        await this.query(sql);
+    }
+    /**
+     * Remove a column from a table
+     */
+    async removeColumn(tableName, columnName) {
+        const sql = `ALTER TABLE ${this.escapeId(tableName)} DROP COLUMN ${this.escapeId(columnName)}`;
+        await this.query(sql);
+    }
+    /**
+     * Change a column definition
+     */
+    async changeColumn(tableName, columnName, definition) {
+        const sql = `ALTER TABLE ${this.escapeId(tableName)} CHANGE ${this.escapeId(columnName)} ${this.getColumnDefinitionSql(columnName, definition)}`;
+        await this.query(sql);
+    }
+    /**
+     * Show all tables in the database
+     */
+    async showTables() {
+        const sql = 'SHOW TABLES';
+        const result = await this.query(sql);
+        const tableKey = `Tables_in_${this.config.database}`;
+        return result.rows.map((row) => row[tableKey]);
+    }
+    /**
+     * Get table status (MySQL implementation)
+     */
+    async getTableStatus(tableName) {
+        let sql = 'SHOW TABLE STATUS';
+        if (tableName) {
+            sql += ` LIKE '${this.escapeString(tableName)}'`;
+        }
+        const result = await this.query(sql);
+        return result.rows;
+    }
+    /**
+     * Get table create statement (MySQL implementation)
+     */
+    async getCreateTable(tableName) {
+        const sql = `SHOW CREATE TABLE ${this.escapeId(tableName)}`;
+        const result = await this.query(sql);
+        return result.rows[0]?.['Create Table'] || '';
+    }
+    /**
+     * Show constraints for a table
+     */
+    async showConstraints(tableName) {
+        const sql = `
+      SELECT
+        CONSTRAINT_NAME as name,
+        TABLE_NAME as tableName,
+        CONSTRAINT_TYPE as type
+      FROM information_schema.TABLE_CONSTRAINTS
+      WHERE TABLE_SCHEMA = ${this.escape(this.config.database || '')}
+      AND TABLE_NAME = ${this.escape(tableName)}
+    `;
+        const result = await this.query(sql);
+        return result.rows;
+    }
+    /**
+     * Show indexes for a table
+     */
+    async showIndexes(tableName) {
+        const sql = `
+      SELECT
+        INDEX_NAME as name,
+        TABLE_NAME as tableName,
+        NON_UNIQUE as nonUnique,
+        SEQ_IN_INDEX as seqInIndex,
+        COLUMN_NAME as columnName
+      FROM information_schema.STATISTICS
+      WHERE TABLE_SCHEMA = ${this.escape(this.config.database || '')}
+      AND TABLE_NAME = ${this.escape(tableName)}
+      ORDER BY INDEX_NAME, SEQ_IN_INDEX
+    `;
+        const result = await this.query(sql);
+        return result.rows;
+    }
+    /**
+     * Describe a table (get column information)
+     */
+    async describeTable(tableName) {
+        const sql = `DESCRIBE ${this.escapeId(tableName)}`;
+        const result = await this.query(sql);
+        const description = {};
+        for (const row of result.rows) {
+            const rowData = row;
+            description[rowData.Field] = {
+                type: rowData.Type,
+                allowNull: rowData.Null === 'YES',
+                defaultValue: rowData.Default,
+                primaryKey: rowData.Key === 'PRI',
+                autoIncrement: rowData.Extra?.includes('auto_increment') || false,
+            };
+        }
+        return description;
+    }
+    /**
+     * Rename a table
+     */
+    async renameTable(oldName, newName) {
+        const sql = `ALTER TABLE ${this.escapeId(oldName)} RENAME TO ${this.escapeId(newName)}`;
+        await this.query(sql);
+    }
+    // ============================================================================
+    // Schema methods (MySQL uses databases instead of schemas, these are not supported)
+    // ============================================================================
+    /**
+     * Create a schema - Not supported by MySQL (use CREATE DATABASE instead)
+     */
+    async createSchema(_schema) {
+        throw new Error('Not supported by MySQL: schemas are called databases. Use CREATE DATABASE instead.');
+    }
+    /**
+     * Drop a schema - Not supported by MySQL (use DROP DATABASE instead)
+     */
+    async dropSchema(_schema, _options) {
+        throw new Error('Not supported by MySQL: schemas are called databases. Use DROP DATABASE instead.');
+    }
+    /**
+     * Show all schemas - Not supported by MySQL (use SHOW DATABASES instead)
+     */
+    async showAllSchemas() {
+        throw new Error('Not supported by MySQL: schemas are called databases. Use SHOW DATABASES instead.');
+    }
+    /**
+     * List all schemas (databases) in MySQL
+     */
+    async listSchemas() {
+        const result = await this.query('SHOW DATABASES');
+        return result.rows.map((row) => row.Database);
+    }
+    // ============================================================================
+    // Extension methods (PostgreSQL-specific, not supported by MySQL)
+    // ============================================================================
+    /**
+     * Create a PostgreSQL extension - Not supported by MySQL
+     */
+    async createExtension(_extensionName, _options) {
+        throw new Error('Extensions are not supported by MySQL. This is a PostgreSQL-specific feature.');
+    }
+    /**
+     * Drop a PostgreSQL extension - Not supported by MySQL
+     */
+    async dropExtension(_extensionName, _options) {
+        throw new Error('Extensions are not supported by MySQL. This is a PostgreSQL-specific feature.');
+    }
+    /**
+     * Get all installed PostgreSQL extensions - Not supported by MySQL
+     */
+    async getExtensions() {
+        throw new Error('Extensions are not supported by MySQL. This is a PostgreSQL-specific feature.');
+    }
+    /**
+     * Check if a PostgreSQL extension is installed - Not supported by MySQL
+     */
+    async hasExtension(_extensionName) {
+        throw new Error('Extensions are not supported by MySQL. This is a PostgreSQL-specific feature.');
+    }
+    // ============================================================================
+    // View methods
+    // ============================================================================
+    /**
+     * Create a database view
+     */
+    async createView(viewName, query, options) {
+        const sql = options?.replace
+            ? `CREATE OR REPLACE VIEW ${this.escapeId(viewName)} AS ${query}`
+            : `CREATE VIEW ${this.escapeId(viewName)} AS ${query}`;
+        await this.query(sql);
+    }
+    /**
+     * Drop a database view
+     */
+    async dropView(viewName, options) {
+        const sql = options?.ifExists
+            ? `DROP VIEW IF EXISTS ${this.escapeId(viewName)}`
+            : `DROP VIEW ${this.escapeId(viewName)}`;
+        await this.query(sql);
+    }
+    /**
+     * Show all views in the database
+     */
+    async showViews() {
+        const result = await this.query("SHOW FULL TABLES WHERE Table_type = 'VIEW'");
+        return result.rows.map((row) => row[`Tables_in_${this.config.database}`]);
+    }
+    // ==================== Materialized View Emulation ====================
+    // MySQL does not support materialized views natively.
+    // We emulate them using a table + event scheduler combination.
+    /**
+     * Create a materialized view (emulated using table + event)
+     * Creates a table from the query and optionally creates a scheduled event to refresh it
+     */
+    async createMaterializedView(options) {
+        const schema = options.schema || this.config.database;
+        const tableName = this.quoteTable(`${schema}.${options.name}`);
+        // Build the CREATE TABLE statement (mimicking materialized view)
+        let sql = 'CREATE TABLE';
+        if (options.replace) {
+            sql = 'CREATE OR REPLACE TABLE';
+        }
+        else if (options.ifNotExists) {
+            sql = 'CREATE TABLE IF NOT EXISTS';
+        }
+        sql += ` ${tableName} AS ${options.query}`;
+        // Execute the table creation
+        await this.query(sql);
+        // Mark this table as a materialized view by adding a comment
+        if (options.comment) {
+            await this.query(`ALTER TABLE ${tableName} COMMENT ${this.escape(options.comment)}`);
+        }
+        // Add metadata to track this as a materialized view
+        await this.query(`
+      CREATE TABLE IF NOT EXISTS ${this.quoteTable(`${schema}._materialized_views`)} (
+        view_name VARCHAR(255) PRIMARY KEY,
+        query_text TEXT NOT NULL,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        refresh_event VARCHAR(255),
+        unique_index VARCHAR(255)
+      )
+    `);
+        // Store the materialized view metadata
+        await this.query(`INSERT INTO ${this.quoteTable(`${schema}._materialized_views`)} (view_name, query_text) VALUES (${this.escape(options.name)}, ${this.escape(options.query)}) ON DUPLICATE KEY UPDATE query_text = ${this.escape(options.query)}`);
+    }
+    /**
+     * Refresh a materialized view
+     * Truncates the table and re-inserts data from the query
+     */
+    async refreshMaterializedView(viewName, options) {
+        const schema = options?.schema || this.config.database;
+        // Get the query from metadata
+        const result = await this.query(`SELECT query_text FROM ${this.quoteTable(`${schema}._materialized_views`)} WHERE view_name = ${this.escape(viewName)}`, { plain: true });
+        const row = result.rows[0];
+        if (!row || !row.query_text) {
+            throw new Error(`Materialized view '${viewName}' does not exist in schema '${schema}'`);
+        }
+        const tableName = this.quoteTable(`${schema}.${viewName}`);
+        const query = row.query_text;
+        // Truncate and re-insert
+        await this.query(`TRUNCATE TABLE ${tableName}`);
+        await this.query(`INSERT INTO ${tableName} ${query}`);
+    }
+    /**
+     * Drop a materialized view
+     * Drops the table and removes metadata, optionally drops the refresh event
+     */
+    async dropMaterializedView(viewName, options) {
+        const schema = options?.schema || this.config.database;
+        const tableName = this.quoteTable(`${schema}.${viewName}`);
+        // Get the refresh event name from metadata
+        const metadataResult = await this.query(`SELECT refresh_event FROM ${this.quoteTable(`${schema}._materialized_views`)} WHERE view_name = ${this.escape(viewName)}`, { plain: true });
+        const metadataRow = metadataResult.rows[0];
+        // Drop the refresh event if it exists
+        if (metadataRow?.refresh_event) {
+            try {
+                await this.dropEvent(metadataRow.refresh_event, { schema, ifExists: true });
+            }
+            catch {
+                // Ignore if event doesn't exist
+            }
+        }
+        // Drop the table
+        const ifExists = options?.ifExists ? 'IF EXISTS ' : '';
+        await this.query(`DROP TABLE ${ifExists}${tableName}`);
+        // Remove metadata
+        await this.query(`DELETE FROM ${this.quoteTable(`${schema}._materialized_views`)} WHERE view_name = ${this.escape(viewName)}`);
+    }
+    /**
+     * Check if a materialized view exists
+     */
+    async hasMaterializedView(viewName, schema) {
+        const db = schema || this.config.database;
+        const result = await this.query(`SELECT view_name FROM ${this.quoteTable(`${db}._materialized_views`)} WHERE view_name = ${this.escape(viewName)}`, { plain: true });
+        return !!result;
+    }
+    /**
+     * Show all materialized views (tables created as materialized views)
+     */
+    async showMaterializedViews(schema) {
+        const db = schema || this.config.database;
+        const result = await this.query(`SELECT view_name FROM ${this.quoteTable(`${db}._materialized_views`)} ORDER BY view_name`);
+        return result.rows.map((row) => row.view_name);
+    }
+    // ==================== Event Scheduler ====================
+    /**
+     * Create an event (MySQL event scheduler)
+     */
+    async createEvent(options) {
+        const schema = options.schema || this.config.database;
+        const eventName = this.quoteIdentifier(options.name);
+        // Build schedule clause
+        let scheduleClause = '';
+        if (options.schedule.type === 'AT') {
+            scheduleClause = `AT ${options.schedule.timestamp}`;
+        }
+        else if (options.schedule.type === 'EVERY') {
+            scheduleClause = `EVERY ${options.schedule.intervalValue} ${options.schedule.intervalUnit}`;
+            if (options.schedule.starts) {
+                scheduleClause += ` STARTS ${options.schedule.starts}`;
+            }
+            if (options.schedule.ends) {
+                scheduleClause += ` ENDS ${options.schedule.ends}`;
+            }
+        }
+        let sql = 'CREATE EVENT';
+        if (options.ifNotExists) {
+            sql = 'CREATE EVENT IF NOT EXISTS';
+        }
+        else if (options.replace) {
+            sql = 'CREATE OR REPLACE EVENT';
+        }
+        sql += ` ${schema}.${eventName} ON SCHEDULE ${scheduleClause}`;
+        // Add ON COMPLETION clause
+        if (options.onCompletion === 'DROP') {
+            sql += ' ON COMPLETION DROP';
+        }
+        else {
+            sql += ' ON COMPLETION PRESERVE';
+        }
+        // Add status
+        if (options.status === 'DISABLED') {
+            sql += ' DISABLED';
+        }
+        else {
+            sql += ' ENABLED';
+        }
+        sql += `\nDO\nBEGIN\n${options.body}\nEND`;
+        // Add comment if provided
+        if (options.comment) {
+            sql += `\nCOMMENT ${this.escape(options.comment)}`;
+        }
+        await this.query(sql);
+    }
+    /**
+     * Drop an event
+     */
+    async dropEvent(eventName, options) {
+        const schema = options?.schema || this.config.database;
+        const ifExists = options?.ifExists ? 'IF EXISTS ' : '';
+        const sql = `DROP EVENT ${ifExists}${schema}.${this.quoteIdentifier(eventName)}`;
+        await this.query(sql);
+    }
+    /**
+     * Show all events in the database
+     */
+    async showEvents(schema) {
+        const db = schema || this.config.database;
+        const result = await this.query(`SHOW EVENTS FROM ${db}`);
+        return result.rows;
+    }
+    /**
+     * Alter an event (change schedule, body, or status)
+     */
+    async alterEvent(options) {
+        const schema = options.schema || this.config.database;
+        const eventName = this.quoteIdentifier(options.name);
+        let sql = `ALTER EVENT ${schema}.${eventName}`;
+        // Add schedule
+        if (options.schedule) {
+            let scheduleClause = '';
+            if (options.schedule.type === 'AT') {
+                scheduleClause = `AT ${options.schedule.timestamp}`;
+            }
+            else if (options.schedule.type === 'EVERY') {
+                scheduleClause = `EVERY ${options.schedule.intervalValue} ${options.schedule.intervalUnit}`;
+                if (options.schedule.starts) {
+                    scheduleClause += ` STARTS ${options.schedule.starts}`;
+                }
+                if (options.schedule.ends) {
+                    scheduleClause += ` ENDS ${options.schedule.ends}`;
+                }
+            }
+            sql += ` ON SCHEDULE ${scheduleClause}`;
+        }
+        // Add status
+        if (options.status) {
+            sql += ` ${options.status}`;
+        }
+        // Add comment
+        if (options.comment) {
+            sql += ` COMMENT ${this.escape(options.comment)}`;
+        }
+        // Add new body
+        if (options.body) {
+            sql += `\nDO\nBEGIN\n${options.body}\nEND`;
+        }
+        await this.query(sql);
+    }
+    // ==================== Stored Procedures ====================
+    /**
+     * Create a stored procedure with full PL/SQL support
+     * Supports IN, OUT, INOUT parameters, local variables, IF/ELSE, WHILE loops, cursors
+     */
+    async createStoredProcedure(options) {
+        const schema = options.schema || this.config.database;
+        const procName = this.quoteIdentifier(options.name);
+        // Check if procedure already exists and replace if requested
+        if (options.replace) {
+            try {
+                await this.dropStoredProcedure(options.name, { schema, ifExists: true });
+            }
+            catch {
+                // Ignore if doesn't exist
+            }
+        }
+        else if (options.ifNotExists) {
+            const exists = await this.hasStoredProcedure(options.name, schema);
+            if (exists) {
+                return;
+            }
+        }
+        let sql = `CREATE PROCEDURE ${schema}.${procName}`;
+        // Add parameters with full mode support (IN, OUT, INOUT). MySQL requires
+        // the parameter-list parentheses even when there are no parameters
+        // (`CREATE PROCEDURE name() BEGIN ... END`) — omitting them entirely is
+        // a syntax error against a real MySQL server.
+        if (options.params && options.params.length > 0) {
+            const params = options.params
+                .map((p) => {
+                const mode = p.mode ? `${p.mode} ` : '';
+                const paramName = this.quoteIdentifier(p.name);
+                const defaultPart = p.defaultValue !== undefined ? ` DEFAULT ${this.escape(p.defaultValue)}` : '';
+                return `${mode}${paramName} ${p.type}${defaultPart}`;
+            })
+                .join(', ');
+            sql += ` (${params})`;
+        }
+        else {
+            sql += ' ()';
+        }
+        // Add language and other options
+        if (options.language) {
+            sql += `\nLANGUAGE ${options.language}`;
+        }
+        sql += `\nBEGIN\n${options.body}\nEND`;
+        // Add comment if provided
+        if (options.comment) {
+            await this.query(`CREATE PROCEDURE ${schema}.${procName} COMMENT ${this.escape(options.comment)}`);
+        }
+        await this.query(sql);
+    }
+    /**
+     * Create a stored procedure with body builder for complex procedures
+     * Supports: IN parameters, OUT parameters, INOUT parameters, local variables,
+     * IF/ELSE, WHILE loops, cursors
+     */
+    async createProcedure(options) {
+        const schema = options.schema || this.config.database;
+        const procName = this.quoteIdentifier(options.name);
+        // Check if procedure already exists
+        if (options.replace) {
+            try {
+                await this.dropStoredProcedure(options.name, { schema, ifExists: true });
+            }
+            catch {
+                // Ignore if doesn't exist
+            }
+        }
+        else if (options.ifNotExists) {
+            const exists = await this.hasStoredProcedure(options.name, schema);
+            if (exists) {
+                return;
+            }
+        }
+        let sql = `CREATE PROCEDURE ${schema}.${procName}`;
+        // Add parameters with mode support (IN, OUT, INOUT). MySQL requires the
+        // parameter-list parentheses even when there are no parameters.
+        if (options.params && options.params.length > 0) {
+            const params = options.params
+                .map((p) => {
+                const mode = p.mode ? `${p.mode} ` : '';
+                const paramName = this.quoteIdentifier(p.name);
+                const defaultPart = p.defaultValue !== undefined ? ` DEFAULT ${this.escape(p.defaultValue)}` : '';
+                return `${mode}${paramName} ${p.type}${defaultPart}`;
+            })
+                .join(', ');
+            sql += ` (${params})`;
+        }
+        else {
+            sql += ' ()';
+        }
+        sql += `\nBEGIN\n${options.body}\nEND`;
+        await this.query(sql);
+        // Add comment if provided
+        if (options.comment) {
+            await this.query(`ALTER PROCEDURE ${schema}.${procName} COMMENT ${this.escape(options.comment)}`);
+        }
+    }
+    /**
+     * Build a stored procedure body with helper methods
+     * Provides a fluent API for building complex procedure bodies
+     */
+    buildProcedureBody() {
+        return new ProcedureBodyBuilder(this);
+    }
+    /**
+     * Execute a stored procedure with enhanced return handling
+     * Supports OUT parameters and result sets
+     */
+    async executeStoredProcedure(options) {
+        const schema = options.schema || this.config.database;
+        const procName = `${schema}.${this.quoteIdentifier(options.procedureName)}`;
+        let sql = `CALL ${procName}`;
+        if (options.params && Object.keys(options.params).length > 0) {
+            const params = Object.entries(options.params)
+                .map(([key, value]) => {
+                // Handle OUT parameters - they need @ prefix in MySQL
+                if (key.startsWith('@')) {
+                    return value !== undefined ? this.escape(value) : 'NULL';
+                }
+                return this.escape(value);
+            })
+                .join(', ');
+            sql += `(${params})`;
+        }
+        const result = await this.query(sql, { timeout: options.timeout });
+        // Return the result - MySQL returns results via result sets, not affectedRows
+        return result;
+    }
+    /**
+     * Drop a stored procedure
+     */
+    async dropStoredProcedure(procedureName, options) {
+        const schema = options?.schema || this.config.database;
+        const ifExists = options?.ifExists ? 'IF EXISTS ' : '';
+        const cascade = options?.cascade ? ' CASCADE' : '';
+        const sql = `DROP PROCEDURE ${ifExists}${schema}.${this.quoteIdentifier(procedureName)}${cascade}`;
+        await this.query(sql);
+    }
+    /**
+     * Drop a stored procedure (alias for dropStoredProcedure)
+     */
+    async dropProcedure(procedureName, options) {
+        return this.dropStoredProcedure(procedureName, options);
+    }
+    /**
+     * Check if a stored procedure exists
+     */
+    async hasStoredProcedure(procedureName, schema) {
+        const db = schema || this.config.database;
+        const sql = `SELECT ROUTINE_NAME FROM INFORMATION_SCHEMA.ROUTINES WHERE ROUTINE_SCHEMA = ${this.escape(db || '')} AND ROUTINE_NAME = ${this.escape(procedureName)} AND ROUTINE_TYPE = 'PROCEDURE'`;
+        // `query()` does not special-case the `plain` option — it always returns
+        // the full { rows, rowCount, fields } QueryResult, so `!!result` was
+        // always true (even with zero matching rows). Check row count instead.
+        const result = await this.query(sql, { plain: true });
+        return result.rows.length > 0;
+    }
+    /**
+     * List all stored procedures in the given (or configured) schema
+     *
+     * @param schema - Optional schema to list procedures from
+     * @returns Array of procedure names
+     */
+    async listProcedures(schema) {
+        const db = schema || this.config.database;
+        const sql = `SELECT ROUTINE_NAME FROM INFORMATION_SCHEMA.ROUTINES WHERE ROUTINE_SCHEMA = ${this.escape(db || '')} AND ROUTINE_TYPE = 'PROCEDURE' ORDER BY ROUTINE_NAME`;
+        const result = await this.query(sql);
+        return result.rows.map((row) => row.ROUTINE_NAME);
+    }
+    /**
+     * Create a foreign data wrapper (MySQL - not supported)
+     * @param fdwName - Foreign data wrapper name
+     * @param options - Options including handler function
+     */
+    async createForeignDataWrapper(_fdwName, _options) {
+        throw new Error('Foreign Data Wrappers are not supported by MySQL. This is a PostgreSQL-specific feature.');
+    }
+    async dropForeignDataWrapper(_fdwName, _options) {
+        throw new Error('Foreign Data Wrappers are not supported by MySQL. This is a PostgreSQL-specific feature.');
+    }
+    async createForeignServer(_serverName, _fdwName, _options) {
+        throw new Error('Foreign Data Wrappers are not supported by MySQL. This is a PostgreSQL-specific feature.');
+    }
+    async dropForeignServer(_serverName, _options) {
+        throw new Error('Foreign Data Wrappers are not supported by MySQL. This is a PostgreSQL-specific feature.');
+    }
+    async createForeignTable(_tableName, _columns, _options) {
+        throw new Error('Foreign Data Wrappers are not supported by MySQL. This is a PostgreSQL-specific feature.');
+    }
+    async changeOwner(_newOwner, _tableName) {
+        throw new Error('changeOwner is not supported in MySQL');
+    }
+    async addConstraint(_tableName, _options) {
+        throw new Error('addConstraint is not supported in MySQL');
+    }
+    async removeConstraint(_tableName, _constraintName) {
+        throw new Error('removeConstraint is not supported in MySQL');
+    }
+    async createSecurityPolicy(_policyName, _tableName, _options) {
+        throw new Error('Security policies are not supported in MySQL');
+    }
+    async dropSecurityPolicy(_policyName, _tableName) {
+        throw new Error('Security policies are not supported in MySQL');
+    }
+    // ==================== Triggers ====================
+    /**
+     * Create a trigger
+     */
+    async createTrigger(options) {
+        const timing = options.timing;
+        const events = (options.events || []).join(' OR ');
+        const level = options.level || 'ROW';
+        const tableName = this.quoteTable(options.tableName);
+        let sql = `CREATE TRIGGER ${this.quoteIdentifier(options.name)} ${timing} ${events} ON ${tableName} FOR EACH ${level}`;
+        if (options.timing === 'INSTEAD OF') {
+            sql = `CREATE TRIGGER ${this.quoteIdentifier(options.name)} INSTEAD OF ${events} ON ${tableName}`;
+        }
+        sql += `\nBEGIN\n${options.body}\nEND`;
+        if (options.replace) {
+            sql = sql.replace('CREATE TRIGGER', 'CREATE OR REPLACE TRIGGER');
+        }
+        await this.query(sql);
+    }
+    /**
+     * Drop a trigger
+     */
+    async dropTrigger(triggerName, tableName, options) {
+        const ifExists = options?.ifExists ? 'IF EXISTS ' : '';
+        const cascade = options?.cascade ? ' CASCADE' : '';
+        const sql = `DROP TRIGGER ${ifExists}${this.quoteIdentifier(triggerName)}`;
+        await this.query(sql);
+    }
+    /**
+     * Check if a trigger exists
+     */
+    async hasTrigger(triggerName, tableName) {
+        const sql = `SELECT TRIGGER_NAME FROM INFORMATION_SCHEMA.TRIGGERS WHERE TRIGGER_NAME = ${this.escape(triggerName)} AND EVENT_OBJECT_TABLE = ${this.escape(tableName)}`;
+        // `query()` does not special-case the `plain` option — it always returns
+        // the full { rows, rowCount, fields } QueryResult, so `!!result` was
+        // always true (even with zero matching rows). Check row count instead.
+        const result = await this.query(sql, { plain: true });
+        return result.rows.length > 0;
+    }
+    /**
+     * List all triggers, optionally filtered to a single table
+     *
+     * @param tableName - Optional table name to filter triggers by
+     * @returns Array of trigger names
+     */
+    async listTriggers(tableName) {
+        const schema = this.config.database;
+        let sql = `SELECT TRIGGER_NAME FROM INFORMATION_SCHEMA.TRIGGERS WHERE TRIGGER_SCHEMA = ${this.escape(schema || '')}`;
+        if (tableName) {
+            sql += ` AND EVENT_OBJECT_TABLE = ${this.escape(tableName)}`;
+        }
+        const result = await this.query(sql);
+        return result.rows.map((row) => row.TRIGGER_NAME);
+    }
+    // ==================== Sequences ====================
+    // MySQL doesn't have native sequences - use AUTO_INCREMENT with a sequence table
+    /**
+     * Create a sequence table with AUTO_INCREMENT
+     */
+    async createSequence(options) {
+        const schema = options.schema || this.config.database;
+        const tableName = this.quoteTable(`${schema}.${options.name}`);
+        // Build the CREATE TABLE statement
+        let sql = 'CREATE TABLE';
+        if (options.replace) {
+            sql = 'CREATE OR REPLACE TABLE';
+        }
+        else if (options.ifNotExists) {
+            sql = 'CREATE TABLE IF NOT EXISTS';
+        }
+        sql += ` ${tableName} (id INT AUTO_INCREMENT PRIMARY KEY)`;
+        if (options.startWith) {
+            // MySQL doesn't support START WITH in CREATE TABLE,
+            // so we insert an initial row to set the auto_increment value
+            await this.query(sql);
+            if (options.startWith > 1) {
+                const alterSql = `ALTER TABLE ${tableName} AUTO_INCREMENT = ${options.startWith}`;
+                await this.query(alterSql);
+            }
+            return;
+        }
+        await this.query(sql);
+    }
+    /**
+     * Drop a sequence table
+     */
+    async dropSequence(sequenceName, options) {
+        const schema = options?.schema || this.config.database;
+        const tableName = this.quoteTable(`${schema}.${sequenceName}`);
+        const ifExists = options?.ifExists ? 'IF EXISTS ' : '';
+        const sql = `DROP TABLE ${ifExists}${tableName}`;
+        await this.query(sql);
+    }
+    /**
+     * Get next value from AUTO_INCREMENT
+     */
+    async nextSequenceValue(sequenceName) {
+        const schema = this.config.database;
+        const tableName = this.quoteTable(`${schema}.${sequenceName}`);
+        // Insert a dummy row to get the next auto_increment value, then delete it
+        // This is the standard way to get next value in MySQL without a separate sequence
+        const sql = `INSERT INTO ${tableName} () VALUES ()`;
+        await this.query(sql);
+        // Get the last auto_increment value
+        const result = await this.query('SELECT LAST_INSERT_ID() as value');
+        return result.rows[0]?.value;
+    }
+    /**
+     * Check if a sequence table exists
+     */
+    async hasSequence(sequenceName) {
+        const schema = this.config.database;
+        const sql = `SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA = ${this.escape(schema || '')} AND TABLE_NAME = ${this.escape(sequenceName)}`;
+        const result = await this.query(sql);
+        return result.rows.length > 0;
+    }
+    /**
+     * List all sequences in the database (MySQL - simulated via tables)
+     * @returns Array of sequence names
+     */
+    async listSequences() {
+        const schema = this.config.database;
+        const sql = `SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA = ${this.escape(schema || '')} AND TABLE_NAME LIKE '%_sequence%'`;
+        const result = await this.query(sql);
+        return result.rows.map((row) => row.TABLE_NAME);
+    }
+    // ==================== Row-Level Security (RLS) ====================
+    async createPolicy(_options) {
+        throw new Error('Row-level security is not supported by MySQL');
+    }
+    async dropPolicy(_policyName, _tableName, _options) {
+        throw new Error('Row-level security is not supported by MySQL');
+    }
+    async enableRLS(_tableName, _schema) {
+        throw new Error('Row-level security is not supported by MySQL');
+    }
+    async enableRowLevelSecurity(_tableName, _schema) {
+        throw new Error('Row-level security is not supported by MySQL');
+    }
+    async disableRLS(_tableName, _schema) {
+        throw new Error('Row-level security is not supported by MySQL');
+    }
+    async hasPolicy(_policyName, _tableName) {
+        return false;
+    }
+    // ==================== Comments ====================
+    /**
+     * Add comment to a table
+     */
+    async commentTable(tableName, comment) {
+        const sql = `ALTER TABLE ${this.quoteTable(tableName)} COMMENT = ${this.escape(comment)}`;
+        await this.query(sql);
+    }
+    /**
+     * Add comment to a column
+     */
+    async commentColumn(tableName, columnName, comment) {
+        const sql = `ALTER TABLE ${this.quoteTable(tableName)} MODIFY ${this.quoteIdentifier(columnName)} COMMENT ${this.escape(comment)}`;
+        await this.query(sql);
+    }
+    // ==================== Advanced Indexes ====================
+    /**
+     * 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.
+     */
+    async createPartialIndex(_tableName, _indexName, _fields, _where, _options) {
+        throw new Error('MySQL does not support partial/filtered indexes (CREATE INDEX ... WHERE ...). ' +
+            'This is a PostgreSQL/SQL Server/SQLite-only feature. Consider a generated ' +
+            'column plus a regular index, or a CHECK constraint, as a workaround.');
+    }
+    /**
+     * Create an expression index - Not supported in MySQL < 8.0
+     */
+    async createExpressionIndex(tableName, indexName, expression, options) {
+        const fieldsSql = `((${expression}))`;
+        let sql = `CREATE INDEX ${this.quoteIdentifier(indexName)} ON ${this.quoteTable(tableName)} ${fieldsSql}`;
+        if (options?.unique)
+            sql = sql.replace('CREATE INDEX', 'CREATE UNIQUE INDEX');
+        await this.query(sql);
+    }
+    // ==================== Identity & Computed Columns ====================
+    /**
+     * Create an identity column - Not fully supported in MySQL
+     */
+    async createIdentityColumn(tableName, columnName, options) {
+        const startWith = options?.startWith || 1;
+        const sql = `ALTER TABLE ${this.quoteTable(tableName)} MODIFY ${this.quoteIdentifier(columnName)} INT AUTO_INCREMENT = ${startWith}`;
+        await this.query(sql);
+    }
+    /**
+     * Create a computed column - Not supported in MySQL (except in generated columns)
+     */
+    async createComputedColumn(tableName, columnName, expression, options) {
+        const persisted = options?.persisted ? 'STORED' : 'VIRTUAL';
+        const type = options?.type || 'INT';
+        const sql = `ALTER TABLE ${this.quoteTable(tableName)} ADD COLUMN ${this.quoteIdentifier(columnName)} ${type} GENERATED ALWAYS AS (${expression}) ${persisted}`;
+        await this.query(sql);
+    }
+    // ============================================================================
+    // Foreign Data Wrapper methods (PostgreSQL-specific, not supported by MySQL)
+    // ============================================================================
+    /**
+     * Build CREATE SERVER query - Not supported by MySQL
+     */
+    buildCreateServerQuery(_name, _opts) {
+        throw new Error('Foreign Data Wrappers are not supported by MySQL. This is a PostgreSQL-specific feature.');
+    }
+    /**
+     * Build ALTER SERVER query - Not supported by MySQL
+     */
+    buildAlterServerQuery(_name, _opts) {
+        throw new Error('Foreign Data Wrappers are not supported by MySQL. This is a PostgreSQL-specific feature.');
+    }
+    /**
+     * Build DROP SERVER query - Not supported by MySQL
+     */
+    buildDropServerQuery(_name, _opts) {
+        throw new Error('Foreign Data Wrappers are not supported by MySQL. This is a PostgreSQL-specific feature.');
+    }
+    /**
+     * Build CREATE USER MAPPING query - Not supported by MySQL
+     */
+    buildCreateUserMappingQuery(_opts) {
+        throw new Error('Foreign Data Wrappers are not supported by MySQL. This is a PostgreSQL-specific feature.');
+    }
+    /**
+     * Build ALTER USER MAPPING query - Not supported by MySQL
+     */
+    buildAlterUserMappingQuery(_opts) {
+        throw new Error('Foreign Data Wrappers are not supported by MySQL. This is a PostgreSQL-specific feature.');
+    }
+    /**
+     * Build DROP USER MAPPING query - Not supported by MySQL
+     */
+    buildDropUserMappingQuery(_serverName, _user, _opts) {
+        throw new Error('Foreign Data Wrappers are not supported by MySQL. This is a PostgreSQL-specific feature.');
+    }
+    /**
+     * Build CREATE FOREIGN TABLE query - Not supported by MySQL
+     */
+    buildCreateForeignTableQuery(_tableName, _opts) {
+        throw new Error('Foreign Data Wrappers are not supported by MySQL. This is a PostgreSQL-specific feature.');
+    }
+    /**
+     * Build DROP FOREIGN TABLE query - Not supported by MySQL
+     */
+    buildDropForeignTableQuery(_tableName, _opts) {
+        throw new Error('Foreign Data Wrappers are not supported by MySQL. This is a PostgreSQL-specific feature.');
+    }
+    /**
+     * Build IMPORT FOREIGN SCHEMA query - Not supported by MySQL
+     */
+    buildImportForeignSchemaQuery(_remoteSchema, _serverName, _opts) {
+        throw new Error('Foreign Data Wrappers are not supported by MySQL. This is a PostgreSQL-specific feature.');
+    }
+    /**
+     * Get servers query - Not supported by MySQL
+     */
+    getServersQuery() {
+        throw new Error('Foreign Data Wrappers are not supported by MySQL. This is a PostgreSQL-specific feature.');
+    }
+    // ============================================================================
+    // User management methods (MySQL-specific implementation)
+    // ============================================================================
+    // ============================================================================
+    // ============================================================================
+    // Utility methods
+    // ============================================================================
+    /**
+     * Replace placeholders in SQL with actual values
+     * Supports both named (:param) and positional (?) placeholders
+     */
+    replaceReplacements(sql, replacements) {
+        if (!replacements) {
+            return sql;
+        }
+        if (Array.isArray(replacements)) {
+            // Positional replacements (?)
+            let result = sql;
+            for (const value of replacements) {
+                result = result.replace(/\?/, this.escape(value));
+            }
+            return result;
+        }
+        // Named replacements (:param)
+        let result = sql;
+        for (const [key, value] of Object.entries(replacements)) {
+            const escapedValue = this.escape(value);
+            // Match :paramName with optional word boundary
+            result = result.replace(new RegExp(`:${key}(?![\\w])`, 'g'), escapedValue);
+        }
+        return result;
+    }
+    // ============================================================================
+    // Subquery includes helper
+    // ============================================================================
+    /**
+     * Build a subquery for includes with LIMIT/OFFSET support
+     */
+    buildSubqueryIncludes(sql, includes, tableName, queryValues) {
+        // Build WHERE clause for the main query to filter by included model's foreign key
+        const include = includes[0];
+        const model = include.model;
+        const through = include.through;
+        const throughTable = through?.tableName || `${tableName}_${model.tableName}`;
+        // For many-to-many relationships, we need a subquery with JOIN
+        if (include.through) {
+            const whereClause = this.buildWhereClause(include.where ?? {});
+            const onCondition = include.on
+                ? this.buildWhereClause(include.on)
+                : `${this.escapeId(tableName)}.${this.escapeId(include.foreignKey || 'id')} = ${this.escapeId(throughTable)}.${this.escapeId(include.sourceKey || 'id')}`;
+            sql = `${sql} WHERE ${onCondition}`;
+            if (whereClause.sql) {
+                sql += ` AND ${whereClause.sql}`;
+                queryValues.push(...whereClause.values);
+            }
+            // Add LIMIT/OFFSET for pagination
+            sql += this.buildLimitOffset(include.limit, include.offset);
+        }
+        else {
+            // For regular hasMany/belongsTo, use subquery with IN
+            const foreignKey = include.foreignKey || `${tableName}_id`;
+            const subquery = `SELECT ${this.escapeId(foreignKey)} FROM ${this.escapeId(model.tableName || include.model.toString())}`;
+            const whereClause = include.where
+                ? this.buildWhereClause(include.where)
+                : { sql: '1=1', values: [] };
+            sql = `${sql} WHERE ${this.escapeId(foreignKey)} IN (${subquery} WHERE ${whereClause.sql})`;
+            queryValues.push(...whereClause.values);
+        }
+        return sql;
+    }
+    /**
+     * Add an index to a table
+     * Supports expression indexes and INCLUDE columns (MySQL 8.0+)
+     */
+    async addIndex(tableName, indexName, fields = [], options) {
+        let sql = 'CREATE';
+        if (options?.unique) {
+            sql += ' UNIQUE';
+        }
+        // MySQL's index-type modifier (FULLTEXT/SPATIAL) goes BEFORE the INDEX
+        // keyword: `CREATE FULLTEXT INDEX name ON ...`, not `CREATE INDEX
+        // FULLTEXT name ON ...` (which is a syntax error).
+        if (options?.type) {
+            sql += ` ${options.type} INDEX`;
+        }
+        else {
+            sql += ' INDEX';
+        }
+        sql += ` ${this.escapeId(indexName)} ON ${this.escapeId(tableName)}`;
+        // Handle expression index (MySQL 8.0+)
+        if (options?.expression) {
+            sql += ` ((${options.expression}))`;
+        }
+        else {
+            sql += ` (${fields.map((f) => this.escapeId(f)).join(', ')})`;
+        }
+        if (options?.using) {
+            sql += ` USING ${options.using}`;
+        }
+        // MySQL has no `INCLUDE (...)` covering-index syntax (that's a
+        // PostgreSQL 11+ / SQL Server construct). Emitting it would produce a
+        // syntax error against a real MySQL server, so reject it explicitly
+        // instead of generating invalid SQL.
+        if (options?.include && options.include.length > 0) {
+            throw new Error('MySQL does not support INCLUDE (...) covering-index columns. ' +
+                'This is a PostgreSQL/SQL Server-only feature; consider adding the ' +
+                'columns to the index key list itself instead.');
+        }
+        // MySQL has no partial/filtered index support at any version (unlike
+        // PostgreSQL/SQL Server/SQLite) — there is no `WHERE` clause on
+        // `CREATE INDEX`. Emitting one would produce a syntax error against a
+        // real MySQL server, so reject it explicitly instead.
+        if (options?.where && Object.keys(options.where).length > 0) {
+            throw new Error('MySQL does not support partial/filtered indexes (CREATE INDEX ... WHERE ...). ' +
+                'This is a PostgreSQL/SQL Server/SQLite-only feature. Consider a generated ' +
+                'column plus a regular index, or a CHECK constraint, as a workaround.');
+        }
+        // Index visibility (MySQL 8.0+). INVISIBLE goes at the end of the
+        // CREATE INDEX statement. Indexes are VISIBLE by default.
+        if (options?.invisible) {
+            sql += ' INVISIBLE';
+        }
+        await this.query(sql);
+    }
+    /**
+     * Remove an index from a table
+     */
+    async removeIndex(tableName, indexName) {
+        const sql = `DROP INDEX ${this.escapeId(indexName)} ON ${this.escapeId(tableName)}`;
+        await this.query(sql);
+    }
+    /**
+     * Create an index on a table with full options support
+     * Supports expression indexes and INCLUDE columns (MySQL 8.0+)
+     */
+    async createIndex(tableName, indexDef) {
+        const fields = indexDef.fields || [];
+        let sql = 'CREATE';
+        if (indexDef.unique) {
+            sql += ' UNIQUE';
+        }
+        // MySQL's index-type modifier (FULLTEXT/SPATIAL) goes BEFORE the INDEX
+        // keyword: `CREATE FULLTEXT INDEX name ON ...`, not `CREATE INDEX
+        // FULLTEXT name ON ...` (which is a syntax error).
+        if (indexDef.type) {
+            sql += ` ${indexDef.type} INDEX`;
+        }
+        else {
+            sql += ' INDEX';
+        }
+        sql += ` ${this.escapeId(indexDef.name)} ON ${this.escapeId(tableName)}`;
+        // Handle expression index (MySQL 8.0+)
+        if (indexDef.expression) {
+            sql += ` ((${indexDef.expression}))`;
+        }
+        else {
+            // Each field may be a bare column name or "column DIRECTION"
+            // (e.g. "created_at DESC") — quote only the identifier portion so
+            // the direction keyword isn't mangled into the escaped identifier.
+            sql += ` (${fields
+                .map((f) => {
+                const match = f.match(/^(.+?)\s+(ASC|DESC)$/i);
+                return match ? `${this.escapeId(match[1])} ${match[2].toUpperCase()}` : this.escapeId(f);
+            })
+                .join(', ')})`;
+        }
+        if (indexDef.using) {
+            sql += ` USING ${indexDef.using}`;
+        }
+        // MySQL has no `INCLUDE (...)` covering-index syntax (that's a
+        // PostgreSQL 11+ / SQL Server construct). Emitting it would produce a
+        // syntax error against a real MySQL server, so reject it explicitly
+        // instead of generating invalid SQL.
+        if (indexDef.include && indexDef.include.length > 0) {
+            throw new Error('MySQL does not support INCLUDE (...) covering-index columns. ' +
+                'This is a PostgreSQL/SQL Server-only feature; consider adding the ' +
+                'columns to the index key list itself instead.');
+        }
+        // MySQL has no partial/filtered index support at any version (unlike
+        // PostgreSQL/SQL Server/SQLite) — there is no `WHERE` clause on
+        // `CREATE INDEX`. Emitting one would produce a syntax error against a
+        // real MySQL server, so reject it explicitly instead.
+        if (indexDef.where && Object.keys(indexDef.where).length > 0) {
+            throw new Error('MySQL does not support partial/filtered indexes (CREATE INDEX ... WHERE ...). ' +
+                'This is a PostgreSQL/SQL Server/SQLite-only feature. Consider a generated ' +
+                'column plus a regular index, or a CHECK constraint, as a workaround.');
+        }
+        // Index visibility (MySQL 8.0+). INVISIBLE goes at the end of the
+        // CREATE INDEX statement. Indexes are VISIBLE by default.
+        if (indexDef.invisible) {
+            sql += ' INVISIBLE';
+        }
+        await this.query(sql);
+    }
+    /**
+     * 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
+     */
+    async alterColumnVisibility(tableName, columnName, invisible) {
+        const sql = `ALTER TABLE ${this.escapeId(tableName)} ALTER COLUMN ${this.escapeId(columnName)} SET ${invisible ? 'INVISIBLE' : 'VISIBLE'}`;
+        await this.query(sql);
+    }
+    /**
+     * 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
+     */
+    async alterIndexVisibility(tableName, indexName, invisible) {
+        const sql = `ALTER TABLE ${this.escapeId(tableName)} ALTER INDEX ${this.escapeId(indexName)} ${invisible ? 'INVISIBLE' : 'VISIBLE'}`;
+        await this.query(sql);
+    }
+    /**
+     * Build a FULLTEXT index on a table
+     * MySQL-specific full-text search index
+     */
+    async createFulltextIndex(tableName, indexName, fields, options) {
+        const sql = `CREATE FULLTEXT INDEX ${this.escapeId(indexName)} ON ${this.escapeId(tableName)} (${fields.map((f) => this.escapeId(f)).join(', ')})${options?.parser ? ` WITH PARSER ${options.parser}` : ''}`;
+        await this.query(sql);
+    }
+    /**
+     * Build a SPATIAL index on a table
+     * MySQL-specific spatial index for geometry columns
+     * Requires MySQL 5.7+ and InnoDB
+     */
+    async createSpatialIndex(tableName, indexName, fields, options) {
+        // MySQL requires NOT NULL constraint on spatial columns for SPATIAL index
+        const sql = `CREATE SPATIAL INDEX ${this.escapeId(indexName)} ON ${this.escapeId(tableName)} (${fields.map((f) => this.escapeId(f)).join(', ')})`;
+        await this.query(sql);
+    }
+    /**
+     * 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, castType, path = '$[*]') {
+        const columnRef = this.escapeId(jsonColumn);
+        return `CAST(${columnRef}->'${path}' AS ${castType} ARRAY)`;
+    }
+    /**
+     * 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)' });
+     */
+    async createMultiValuedIndex(tableName, indexName, jsonColumn, options) {
+        const expression = this.buildMultiValuedIndexExpression(jsonColumn, options.castType, options.path);
+        const sql = `CREATE INDEX ${this.escapeId(indexName)} ON ${this.escapeId(tableName)} ((${expression}))`;
+        await this.query(sql);
+    }
+    /**
+     * Bulk insert records into a table
+     */
+    async bulkInsert(tableName, records, _options) {
+        if (records.length === 0) {
+            return { rows: [], rowCount: 0, fields: [] };
+        }
+        const columns = Object.keys(records[0]);
+        const values = [];
+        const placeholders = [];
+        for (const record of records) {
+            const rowPlaceholders = [];
+            for (let i = 0; i < columns.length; i++) {
+                rowPlaceholders.push('?');
+                values.push(record[columns[i]]);
+            }
+            placeholders.push(`(${rowPlaceholders.join(', ')})`);
+        }
+        const sql = `INSERT INTO ${this.quoteTable(tableName)} (${columns.map((c) => this.escapeId(c)).join(', ')}) VALUES ${placeholders.join(', ')}`;
+        return this.query(sql, { replacements: values });
+    }
+    /**
+     * Add a foreign key to a table
+     */
+    async addForeignKey(tableName, columnName, referencedTableName, referencedColumnName, options) {
+        const constraintName = options?.name || `${tableName}_${columnName}_fkey`;
+        const 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) {
+            await this.query(sql + ' ' + clauses.join(' '));
+        }
+        else {
+            await this.query(sql);
+        }
+    }
+    /**
+     * Rename a column
+     */
+    async renameColumn(tableName, oldColumnName, newColumnName) {
+        // MySQL uses CHANGE COLUMN syntax
+        const describe = await this.describeTable(tableName);
+        const columnDef = describe[oldColumnName];
+        if (!columnDef) {
+            throw new Error(`Column ${oldColumnName} does not exist in table ${tableName}`);
+        }
+        let sql = `ALTER TABLE ${this.quoteTable(tableName)} CHANGE ${this.escapeId(oldColumnName)} ${this.escapeId(newColumnName)} ${columnDef.type}`;
+        if (!columnDef.allowNull) {
+            sql += ' NOT NULL';
+        }
+        if (columnDef.defaultValue !== undefined) {
+            sql += ` DEFAULT ${this.escape(columnDef.defaultValue)}`;
+        }
+        await this.query(sql);
+    }
+    /**
+     * Create a user mapping (MySQL doesn't support user mappings)
+     */
+    async createUserMapping(_userName, _serverName, _options) {
+        throw new Error('Foreign Data Wrappers are not supported by MySQL. This is a PostgreSQL-specific feature.');
+    }
+    /**
+     * Drop a user mapping (MySQL doesn't support user mappings)
+     */
+    async dropUserMapping(_userName, _serverName, _options) {
+        throw new Error('Foreign Data Wrappers are not supported by MySQL. This is a PostgreSQL-specific feature.');
+    }
+    /**
+     * ST_Distance - calculate distance between two geometries
+     * MySQL 8.0+ spatial function
+     */
+    stDistance(geom1, geom2, srid) {
+        const sridStr = srid ? `, ${srid}` : '';
+        return `ST_Distance(${geom1}, ST_GeomFromText(${geom2}${sridStr}))`;
+    }
+    /**
+     * ST_Within - check if geometry A is within geometry B
+     * MySQL 8.0+ spatial function
+     */
+    stWithin(geom1, geom2, srid) {
+        const sridStr = srid ? `, ${srid}` : '';
+        return `ST_Within(${geom1}, ST_GeomFromText(${geom2}${sridStr}))`;
+    }
+    /**
+     * ST_Contains - check if geometry A contains geometry B
+     * MySQL 8.0+ spatial function
+     */
+    stContains(geom1, geom2, srid) {
+        const sridStr = srid ? `, ${srid}` : '';
+        return `ST_Contains(${geom1}, ST_GeomFromText(${geom2}${sridStr}))`;
+    }
+    /**
+     * ST_Intersects - check if two geometries intersect
+     * MySQL 8.0+ spatial function
+     */
+    stIntersects(geom1, geom2, srid) {
+        const sridStr = srid ? `, ${srid}` : '';
+        return `ST_Intersects(${geom1}, ST_GeomFromText(${geom2}${sridStr}))`;
+    }
+    /**
+     * ST_DWithin - check if geometries are within a given distance
+     * MySQL 8.0+ spatial function
+     */
+    stDWithin(geom1, geom2, distance, srid) {
+        const sridStr = srid ? `, ${srid}` : '';
+        return `ST_DWithin(${geom1}, ST_GeomFromText(${geom2}${sridStr}), ${distance})`;
+    }
+    /**
+     * ST_GeomFromText - create geometry from WKT text
+     */
+    stGeomFromText(wkt, srid) {
+        const sridStr = srid ? `, ${srid}` : '';
+        return `ST_GeomFromText(${this.escape(wkt)}${sridStr})`;
+    }
+    /**
+     * ST_GeomFromGeoJSON - create geometry from GeoJSON
+     */
+    stGeomFromGeoJSON(geojson, srid) {
+        const sridStr = srid ? `, ${srid}` : '';
+        return `ST_GeomFromGeoJSON(${this.escape(geojson)}${sridStr})`;
+    }
+    /**
+     * ST_AsGeoJSON - convert geometry to GeoJSON
+     */
+    stAsGeoJSON(geom) {
+        return `ST_AsGeoJSON(${geom})`;
+    }
+    /**
+     * ST_AsText - convert geometry to WKT
+     */
+    stAsText(geom) {
+        return `ST_AsText(${geom})`;
+    }
+    /**
+     * Build a MATCH AGAINST full-text search expression
+     * SQL: MATCH(columns) AGAINST(searchTerm [IN NATURAL LANGUAGE MODE | IN BOOLEAN MODE])
+     */
+    buildMatchAgainst(columns, searchTerm, options) {
+        const cols = Array.isArray(columns) ? columns : [columns];
+        const columnList = cols.map((c) => this.escapeId(c)).join(', ');
+        const mode = options?.mode || 'natural';
+        let modeStr = mode === 'boolean' ? 'IN BOOLEAN MODE' : 'IN NATURAL LANGUAGE MODE';
+        if (options?.modifier) {
+            modeStr =
+                options.modifier === 'WITH QUERY EXPANSION'
+                    ? 'WITH QUERY EXPANSION'
+                    : 'IN NATURAL LANGUAGE MODE WITH QUERY EXPANSION';
+        }
+        return `MATCH(${columnList}) AGAINST(${this.escape(searchTerm)} ${modeStr})`;
+    }
+    /**
+     * Drop an index from a table
+     */
+    async dropIndex(tableName, indexName, options) {
+        let sql = 'DROP INDEX';
+        if (options?.ifExists) {
+            sql += ' IF EXISTS';
+        }
+        sql += ` ${this.escapeId(indexName)} ON ${this.escapeId(tableName)}`;
+        if (options?.cascade) {
+            sql += ' CASCADE';
+        }
+        await this.query(sql);
+    }
+    /**
+     * Create a constraint on a table
+     */
+    async createConstraint(tableName, constraintDef) {
+        const fields = constraintDef.fields?.map((f) => this.escapeId(f)).join(', ');
+        switch (constraintDef.type) {
+            case 'PRIMARY KEY':
+                if (!fields) {
+                    throw new Error('Primary key constraint requires fields');
+                }
+                await this.query(`ALTER TABLE ${this.escapeId(tableName)} ADD CONSTRAINT ${this.escapeId(constraintDef.name)} PRIMARY KEY (${fields})`);
+                break;
+            case 'UNIQUE':
+                if (!fields) {
+                    throw new Error('Unique constraint requires fields');
+                }
+                await this.query(`ALTER TABLE ${this.escapeId(tableName)} ADD CONSTRAINT ${this.escapeId(constraintDef.name)} UNIQUE (${fields})`);
+                break;
+            case 'FOREIGN KEY': {
+                if (!fields || !constraintDef.references) {
+                    throw new Error('Foreign key constraint requires fields and references');
+                }
+                // Handle composite foreign keys (string | string[])
+                const refField = constraintDef.references.field;
+                const refFieldSql = Array.isArray(refField)
+                    ? `(${refField.map((f) => this.escapeId(f)).join(', ')})`
+                    : `(${this.escapeId(refField)})`;
+                let sql = `ALTER TABLE ${this.escapeId(tableName)} ADD CONSTRAINT ${this.escapeId(constraintDef.name)} `;
+                sql += `FOREIGN KEY (${fields}) REFERENCES ${this.escapeId(constraintDef.references.table)}${refFieldSql}`;
+                if (constraintDef.references.onDelete) {
+                    sql += ` ON DELETE ${constraintDef.references.onDelete}`;
+                }
+                if (constraintDef.references.onUpdate) {
+                    sql += ` ON UPDATE ${constraintDef.references.onUpdate}`;
+                }
+                await this.query(sql);
+                break;
+            }
+            case 'CHECK':
+                if (!constraintDef.check) {
+                    throw new Error('Check constraint requires a check expression');
+                }
+                await this.query(`ALTER TABLE ${this.escapeId(tableName)} ADD CONSTRAINT ${this.escapeId(constraintDef.name)} CHECK (${constraintDef.check})`);
+                break;
+            default:
+                throw new Error(`Unknown constraint type: ${constraintDef.type}`);
+        }
+    }
+    /**
+     * Drop a constraint from a table
+     */
+    async dropConstraint(tableName, constraintName, options) {
+        let sql = `ALTER TABLE ${this.escapeId(tableName)} DROP CONSTRAINT`;
+        if (options?.ifExists) {
+            sql += ' IF EXISTS';
+        }
+        sql += ` ${this.escapeId(constraintName)}`;
+        if (options?.cascade) {
+            sql += ' CASCADE';
+        }
+        await this.query(sql);
+    }
+    /**
+     * Begin a new transaction
+     */
+    async startTransaction(options) {
+        if (!this.pool) {
+            throw new Error('Not connected to database');
+        }
+        const connection = await this.pool.getConnection();
+        if (options?.isolationLevel) {
+            await connection.query(`SET TRANSACTION ISOLATION LEVEL ${options.isolationLevel.replace(/_/g, ' ')}`);
+        }
+        await connection.beginTransaction();
+        const transaction = new MySQLTransaction(connection, options);
+        return transaction;
+    }
+    /**
+     * Commit a transaction
+     */
+    async commitTransaction(transaction) {
+        const mysqlTx = transaction;
+        if (mysqlTx.connection) {
+            await mysqlTx.connection.commit();
+            mysqlTx.connection.release();
+            mysqlTx.finished = true;
+        }
+    }
+    /**
+     * Rollback a transaction
+     */
+    async rollbackTransaction(transaction) {
+        const mysqlTx = transaction;
+        if (mysqlTx.connection) {
+            await mysqlTx.connection.rollback();
+            mysqlTx.connection.release();
+            mysqlTx.finished = true;
+        }
+    }
+    /**
+     * Get the SQL for a data type
+     */
+    getDataTypeSql(dataType) {
+        if (typeof dataType === 'string') {
+            return dataType;
+        }
+        if (!dataType || typeof dataType !== 'object') {
+            return 'VARCHAR(255)';
+        }
+        const dt = dataType;
+        switch (dt.key) {
+            case 'STRING':
+                return `VARCHAR(${dt.length || 255})`;
+            case 'CHAR':
+                return `CHAR(${dt.length || 1})`;
+            case 'TEXT':
+                if (dt.length === 65535)
+                    return 'TEXT';
+                if (dt.length === 16777215)
+                    return 'MEDIUMTEXT';
+                if (dt.length === 4294967295)
+                    return 'LONGTEXT';
+                return dt.length ? `VARCHAR(${dt.length})` : 'TEXT';
+            case 'INTEGER':
+                let intType = 'INT';
+                if (dt.length === 1)
+                    intType = 'TINYINT';
+                else if (dt.length === 2)
+                    intType = 'SMALLINT';
+                else if (dt.length === 3)
+                    intType = 'MEDIUMINT';
+                else if (dt.length === 8)
+                    intType = 'BIGINT';
+                if (dt.unsigned)
+                    intType += ' UNSIGNED';
+                return intType;
+            case 'BIGINT':
+                let bigIntType = 'BIGINT';
+                if (dt.unsigned)
+                    bigIntType += ' UNSIGNED';
+                return bigIntType;
+            case 'FLOAT':
+                return dt.length ? `FLOAT(${dt.length},${dt.decimals || 2})` : 'FLOAT';
+            case 'DOUBLE':
+                return dt.length ? `DOUBLE(${dt.length},${dt.decimals || 2})` : 'DOUBLE';
+            case 'DECIMAL':
+                return `DECIMAL(${dt.precision || 10},${dt.scale || 0})`;
+            case 'BOOLEAN':
+                return 'TINYINT(1)';
+            case 'DATE':
+                return dt.precision ? `DATETIME(${dt.precision})` : 'DATETIME';
+            case 'DATEONLY':
+                return 'DATE';
+            case 'TIME':
+                return dt.precision ? `TIME(${dt.precision})` : 'TIME';
+            case 'BLOB':
+                if (dt.length === 'tiny')
+                    return 'TINYBLOB';
+                if (dt.length === 'medium')
+                    return 'MEDIUMBLOB';
+                if (dt.length === 'long')
+                    return 'LONGBLOB';
+                return 'BLOB';
+            case 'ENUM':
+                const values = dt.values || [];
+                return `ENUM(${values.map((v) => `'${v}'`).join(',')})`;
+            case 'JSON':
+                return 'JSON';
+            case 'JSONB':
+                return 'JSON';
+            case 'UUID':
+                return 'CHAR(36)';
+            case 'GEOMETRY': {
+                const sridSql = dt.srid ? ` SRID ${dt.srid}` : '';
+                if (dt.type) {
+                    return `${String(dt.type).toUpperCase()}${sridSql}`;
+                }
+                return `GEOMETRY${sridSql}`;
+            }
+            case 'GEOGRAPHY': {
+                // MySQL has no native GEOGRAPHY type; store as (typed) GEOMETRY.
+                const sridSql = dt.srid ? ` SRID ${dt.srid}` : '';
+                if (dt.type) {
+                    return `${String(dt.type).toUpperCase()}${sridSql}`;
+                }
+                return `GEOMETRY${sridSql}`;
+            }
+            case 'POINT':
+            case 'LINESTRING':
+            case 'POLYGON':
+            case 'MULTIPOINT':
+            case 'MULTILINESTRING':
+            case 'MULTIPOLYGON':
+            case 'GEOMETRYCOLLECTION': {
+                const sridSql = dt.srid ? ` SRID ${dt.srid}` : '';
+                return `${dt.key}${sridSql}`;
+            }
+            case 'BIT':
+                return `BIT(${dt.length || 1})`;
+            case 'YEAR':
+                return dt.length ? `YEAR(${dt.length})` : 'YEAR';
+            case 'SET': {
+                const setValues = dt.values || [];
+                return `SET(${setValues.map((v) => `'${v}'`).join(',')})`;
+            }
+            case 'VIRTUAL':
+                // Virtual fields don't create a database column - return empty string
+                return '';
+            default:
+                return 'VARCHAR(255)';
+        }
+    }
+    /**
+     * Build a WHERE clause from a WhereOptions object
+     */
+    buildWhereClause(where, options) {
+        const values = [];
+        if (!where ||
+            (Object.keys(where).length === 0 && Object.getOwnPropertySymbols(where).length === 0)) {
+            return { sql: '', values };
+        }
+        const buildCondition = (condition) => {
+            if (!condition) {
+                return { sql: '', values: [] };
+            }
+            if (typeof condition !== 'object') {
+                values.push(condition);
+                return { sql: '?', values: [condition] };
+            }
+            // Operator keys (Op.isNotNull, Op.match, Op.json('path'), ...) are
+            // Symbols, which Object.entries()/Object.keys() silently drop. Without
+            // this normalization step every Symbol-keyed operator condition here
+            // was falling through to the `= ?` equality branch below, binding the
+            // raw operator-value object as an opaque param (e.g. producing
+            // `WHERE email = ?` bound to `{ [Symbol(isNotNull)]: true }`) instead
+            // of the intended SQL — a real MySQL server then either matches
+            // nothing or rejects the query outright.
+            const rawCond = condition;
+            const topSymbols = Object.getOwnPropertySymbols(rawCond);
+            const normalizedCond = { ...rawCond };
+            for (const sym of topSymbols) {
+                const strKey = (0, operators_1.operatorToWhereKey)(sym);
+                if (strKey)
+                    normalizedCond[strKey] = rawCond[sym];
+            }
+            const cond = normalizedCond;
+            // Handle logical operators
+            if (cond.$and || cond.$or || cond.$not) {
+                const conditions = [];
+                if (cond.$and) {
+                    const andConditions = cond.$and.map((c) => {
+                        const result = buildCondition(c);
+                        return result.sql;
+                    });
+                    conditions.push(`(${andConditions.join(' AND ')})`);
+                }
+                if (cond.$or) {
+                    const orConditions = cond.$or.map((c) => {
+                        const result = buildCondition(c);
+                        return result.sql;
+                    });
+                    conditions.push(`(${orConditions.join(' OR ')})`);
+                }
+                if (cond.$not) {
+                    const result = buildCondition(cond.$not);
+                    conditions.push(`NOT (${result.sql})`);
+                }
+                return { sql: conditions.join(' AND '), values };
+            }
+            // Handle field conditions
+            const fieldConditions = [];
+            for (const [key, value] of Object.entries(cond)) {
+                if (key.startsWith('$'))
+                    continue;
+                if (value && typeof value === 'object') {
+                    // Same Symbol-key normalization as above, but for the nested
+                    // per-field operator object (e.g. `{ email: { [Op.isNotNull]: true } }`).
+                    const rawValueObj = value;
+                    const symbolKeys = Object.getOwnPropertySymbols(rawValueObj);
+                    const normalizedObj = {
+                        ...rawValueObj,
+                    };
+                    for (const sym of symbolKeys) {
+                        // Op.json(path) creates Symbol.for(`json:${path}`) — a family of
+                        // distinct symbols, not the fixed set operatorToWhereKey()
+                        // recognizes — so handle it directly here rather than via
+                        // operatorToWhereKey().
+                        const symDesc = sym.description || '';
+                        if (symDesc.startsWith('json:')) {
+                            normalizedObj[`$json:${symDesc.substring(5)}`] = rawValueObj[sym];
+                            continue;
+                        }
+                        const strKey = (0, operators_1.operatorToWhereKey)(sym);
+                        if (strKey)
+                            normalizedObj[strKey] = rawValueObj[sym];
+                    }
+                    const valueObj = normalizedObj;
+                    const jsonPathEntry = Object.keys(valueObj).find((k) => k.startsWith('$json:'));
+                    if (valueObj.$eq !== undefined) {
+                        values.push(valueObj.$eq);
+                        fieldConditions.push(`${this.escapeId(key)} = ?`);
+                    }
+                    else if (valueObj.$ne !== undefined) {
+                        values.push(valueObj.$ne);
+                        fieldConditions.push(`${this.escapeId(key)} != ?`);
+                    }
+                    else if (valueObj.$gt !== undefined) {
+                        values.push(valueObj.$gt);
+                        fieldConditions.push(`${this.escapeId(key)} > ?`);
+                    }
+                    else if (valueObj.$gte !== undefined) {
+                        values.push(valueObj.$gte);
+                        fieldConditions.push(`${this.escapeId(key)} >= ?`);
+                    }
+                    else if (valueObj.$lt !== undefined) {
+                        values.push(valueObj.$lt);
+                        fieldConditions.push(`${this.escapeId(key)} < ?`);
+                    }
+                    else if (valueObj.$lte !== undefined) {
+                        values.push(valueObj.$lte);
+                        fieldConditions.push(`${this.escapeId(key)} <= ?`);
+                    }
+                    else if (valueObj.$like !== undefined) {
+                        values.push(valueObj.$like);
+                        fieldConditions.push(`${this.escapeId(key)} LIKE ?`);
+                    }
+                    else if (valueObj.$notLike !== undefined) {
+                        values.push(valueObj.$notLike);
+                        fieldConditions.push(`${this.escapeId(key)} NOT LIKE ?`);
+                    }
+                    else if (valueObj.$startsWith !== undefined) {
+                        values.push(valueObj.$startsWith + '%');
+                        fieldConditions.push(`${this.escapeId(key)} LIKE ?`);
+                    }
+                    else if (valueObj.$notStartsWith !== undefined) {
+                        values.push(valueObj.$notStartsWith + '%');
+                        fieldConditions.push(`${this.escapeId(key)} NOT LIKE ?`);
+                    }
+                    else if (valueObj.$endsWith !== undefined) {
+                        values.push('%' + valueObj.$endsWith);
+                        fieldConditions.push(`${this.escapeId(key)} LIKE ?`);
+                    }
+                    else if (valueObj.$notEndsWith !== undefined) {
+                        values.push('%' + valueObj.$notEndsWith);
+                        fieldConditions.push(`${this.escapeId(key)} NOT LIKE ?`);
+                    }
+                    else if (valueObj.$substring !== undefined) {
+                        values.push('%' + valueObj.$substring + '%');
+                        fieldConditions.push(`${this.escapeId(key)} LIKE ?`);
+                    }
+                    else if (valueObj.$notSubstring !== undefined) {
+                        values.push('%' + valueObj.$notSubstring + '%');
+                        fieldConditions.push(`${this.escapeId(key)} NOT LIKE ?`);
+                    }
+                    else if (valueObj.$in) {
+                        const inValues = valueObj.$in;
+                        values.push(...inValues);
+                        fieldConditions.push(`${this.escapeId(key)} IN (${inValues.map(() => '?').join(',')})`);
+                    }
+                    else if (valueObj.$notIn) {
+                        const notInValues = valueObj.$notIn;
+                        values.push(...notInValues);
+                        fieldConditions.push(`${this.escapeId(key)} NOT IN (${notInValues.map(() => '?').join(',')})`);
+                    }
+                    else if (valueObj.$between) {
+                        const between = valueObj.$between;
+                        values.push(between[0], between[1]);
+                        fieldConditions.push(`${this.escapeId(key)} BETWEEN ? AND ?`);
+                    }
+                    else if (valueObj.$notBetween) {
+                        const notBetween = valueObj.$notBetween;
+                        values.push(notBetween[0], notBetween[1]);
+                        fieldConditions.push(`${this.escapeId(key)} NOT BETWEEN ? AND ?`);
+                    }
+                    else if (valueObj.$isNull !== undefined) {
+                        if (valueObj.$isNull) {
+                            fieldConditions.push(`${this.escapeId(key)} IS NULL`);
+                        }
+                        else {
+                            fieldConditions.push(`${this.escapeId(key)} IS NOT NULL`);
+                        }
+                    }
+                    else if (valueObj.$isNotNull !== undefined) {
+                        if (valueObj.$isNotNull) {
+                            fieldConditions.push(`${this.escapeId(key)} IS NOT NULL`);
+                        }
+                        else {
+                            fieldConditions.push(`${this.escapeId(key)} IS NULL`);
+                        }
+                    }
+                    else if (valueObj.$col !== undefined) {
+                        fieldConditions.push(`${this.escapeId(key)} = ${this.escapeId(String(valueObj.$col))}`);
+                    }
+                    else if (valueObj.$regexp !== undefined) {
+                        values.push(valueObj.$regexp);
+                        fieldConditions.push(`${this.escapeId(key)} REGEXP ?`);
+                    }
+                    else if (valueObj.$notRegexp !== undefined) {
+                        values.push(valueObj.$notRegexp);
+                        fieldConditions.push(`${this.escapeId(key)} NOT REGEXP ?`);
+                    }
+                    else if (valueObj.$match !== undefined) {
+                        // MySQL full-text search: MATCH(columns) AGAINST(term [mode]).
+                        // Format: { $match: 'term' } or { $match: { columns, mode, searchTerm } }
+                        const matchValue = valueObj.$match;
+                        const searchTerm = typeof matchValue === 'string'
+                            ? matchValue
+                            : (matchValue?.searchTerm ?? '');
+                        const matchColumns = matchValue?.columns || [key];
+                        const mode = matchValue?.mode === 'boolean' ? 'IN BOOLEAN MODE' : 'IN NATURAL LANGUAGE MODE';
+                        const columnList = matchColumns.map((c) => this.escapeId(c)).join(', ');
+                        values.push(searchTerm);
+                        fieldConditions.push(`MATCH(${columnList}) AGAINST(? ${mode})`);
+                    }
+                    else if (jsonPathEntry) {
+                        // Op.json('path') -> Symbol.for('json:path'), normalized above to `$json:path`.
+                        const jsonPath = jsonPathEntry.substring(6);
+                        const normalizedPath = jsonPath.startsWith('$.') ? jsonPath : `$.${jsonPath}`;
+                        const compareValue = valueObj[jsonPathEntry];
+                        if (compareValue !== undefined) {
+                            values.push(compareValue);
+                            fieldConditions.push(`JSON_EXTRACT(${this.escapeId(key)}, '${normalizedPath}') = ?`);
+                        }
+                        else {
+                            fieldConditions.push(`JSON_EXTRACT(${this.escapeId(key)}, '${normalizedPath}') IS NOT NULL`);
+                        }
+                    }
+                    else {
+                        values.push(value);
+                        fieldConditions.push(`${this.escapeId(key)} = ?`);
+                    }
+                }
+                else {
+                    values.push(value);
+                    fieldConditions.push(`${this.escapeId(key)} = ?`);
+                }
+            }
+            return { sql: fieldConditions.join(' AND '), values };
+        };
+        const result = buildCondition(where);
+        return { sql: result.sql, values: result.values };
+    }
+    /**
+     * Build an ORDER BY clause
+     */
+    buildOrderClause(order, options) {
+        const orderArray = order;
+        if (!orderArray || !Array.isArray(orderArray) || orderArray.length === 0) {
+            return '';
+        }
+        const orderParts = [];
+        for (const item of orderArray) {
+            if (Array.isArray(item)) {
+                const field = typeof item[0] === 'string' ? this.escapeId(item[0]) : item[0];
+                const direction = item[1] ? ` ${item[1]}` : '';
+                orderParts.push(`${field}${direction}`);
+            }
+            else if (typeof item === 'string') {
+                orderParts.push(item);
+            }
+            else if (item && typeof item === 'object') {
+                const itemArr = item;
+                const [modelOrString, field] = itemArr;
+                const model = typeof modelOrString === 'string'
+                    ? modelOrString
+                    : modelOrString.tableName || '';
+                const fieldStr = typeof field === 'string' ? field : '';
+                orderParts.push(`${model ? `${this.escapeId(model)}.` : ''}${this.escapeId(fieldStr)}`);
+            }
+        }
+        return orderParts.length > 0 ? `ORDER BY ${orderParts.join(', ')}` : '';
+    }
+    /**
+     * Build a LIMIT/OFFSET clause
+     */
+    buildLimitOffset(limit, offset) {
+        let sql = '';
+        if (limit !== undefined) {
+            sql += ` LIMIT ${Number(limit)}`;
+            if (offset !== undefined) {
+                sql += ` OFFSET ${Number(offset)}`;
+            }
+        }
+        else if (offset !== undefined) {
+            // MySQL does not support OFFSET without LIMIT. Use the documented
+            // maximum unsigned BIGINT as the LIMIT to effectively return all rows.
+            sql += ` LIMIT 18446744073709551615 OFFSET ${Number(offset)}`;
+        }
+        return sql;
+    }
+    /**
+     * Build an INSERT query
+     */
+    buildInsertQuery(tableName, values, options) {
+        const columns = Object.keys(values);
+        const processedValues = [];
+        const placeholders = [];
+        // Process each value - handle Literal differently
+        for (const value of Object.values(values)) {
+            if (value instanceof prorm_1.Literal) {
+                // For Literal values, inline the SQL directly
+                placeholders.push(value.val);
+            }
+            else {
+                // For regular values, use parameterized placeholder
+                placeholders.push('?');
+                processedValues.push(value);
+            }
+        }
+        let sql = `INSERT INTO ${this.escapeId(tableName)} (${columns.map((c) => this.escapeId(c)).join(', ')}) VALUES (${placeholders.join(', ')})`;
+        if (options?.upsert) {
+            // The `VALUES(col)` function form is deprecated as of MySQL 8.0.20 and
+            // will be removed in a future release. Use the row-alias form instead.
+            sql += ' AS new_vals';
+            const updateColumns = columns
+                .map((c) => `${this.escapeId(c)} = new_vals.${this.escapeId(c)}`)
+                .join(', ');
+            const conflictFields = options.conflictFields || columns;
+            sql += ` ON DUPLICATE KEY UPDATE ${updateColumns}`;
+        }
+        return { sql, values: processedValues };
+    }
+    /**
+     * Build an UPSERT query for MySQL
+     * Uses ON DUPLICATE KEY UPDATE syntax
+     */
+    buildUpsertQuery(tableName, values, options) {
+        const columns = Object.keys(values);
+        const processedValues = [];
+        const placeholders = [];
+        // Process each value - handle Literal differently
+        for (const value of Object.values(values)) {
+            if (value instanceof prorm_1.Literal) {
+                // For Literal values, inline the SQL directly
+                placeholders.push(value.val);
+            }
+            else {
+                // For regular values, use parameterized placeholder
+                placeholders.push('?');
+                processedValues.push(value);
+            }
+        }
+        // Determine which fields to update
+        const updateFields = options?.updateOnDuplicate && options.updateOnDuplicate.length > 0
+            ? options.updateOnDuplicate
+            : columns;
+        let sql = `INSERT INTO ${this.escapeId(tableName)} (${columns.map((c) => this.escapeId(c)).join(', ')}) VALUES (${placeholders.join(', ')})`;
+        // The `VALUES(col)` function form is deprecated as of MySQL 8.0.20 and
+        // will be removed in a future release. Use the row-alias form instead.
+        sql += ' AS new_vals';
+        // Add ON DUPLICATE KEY UPDATE clause
+        const updateClauses = updateFields
+            .map((c) => `${this.escapeId(c)} = new_vals.${this.escapeId(c)}`)
+            .join(', ');
+        sql += ` ON DUPLICATE KEY UPDATE ${updateClauses}`;
+        // MySQL (unlike PostgreSQL/SQLite/MariaDB 10.5+) does not support the
+        // RETURNING clause at all. Emitting it would produce a syntax error
+        // against a real MySQL server, so fail fast instead of generating
+        // invalid SQL. Callers should instead re-select the row after the
+        // upsert (e.g. using LAST_INSERT_ID() or the known unique key).
+        if (options?.returning) {
+            throw new Error('MySQL does not support the RETURNING clause. Re-fetch the row after the upsert instead.');
+        }
+        return { sql, values: processedValues };
+    }
+    /**
+     * 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, fields, where, options) {
+        const by = options?.by ?? 1;
+        const setClauses = [];
+        const queryValues = [];
+        // Handle different field formats
+        if (typeof fields === 'string') {
+            // Single field: increment('count')
+            setClauses.push(`${this.escapeId(fields)} = ${this.escapeId(fields)} + ?`);
+            queryValues.push(by);
+        }
+        else if (Array.isArray(fields)) {
+            // Array of fields: increment(['count', 'value'], { by: 5 })
+            for (const field of fields) {
+                setClauses.push(`${this.escapeId(field)} = ${this.escapeId(field)} + ?`);
+                queryValues.push(by);
+            }
+        }
+        else {
+            // Object: increment({ count: 1, value: 10 })
+            for (const [field, value] of Object.entries(fields)) {
+                setClauses.push(`${this.escapeId(field)} = ${this.escapeId(field)} + ?`);
+                queryValues.push(value);
+            }
+        }
+        // Build WHERE clause
+        const whereClause = this.buildWhereClause(where);
+        queryValues.push(...whereClause.values);
+        const sql = `UPDATE ${this.escapeId(tableName)} SET ${setClauses.join(', ')} WHERE ${whereClause.sql}`;
+        return { sql, values: queryValues };
+    }
+    /**
+     * Build an UPDATE query
+     */
+    buildUpdateQuery(tableName, values, where, options) {
+        const setClauses = [];
+        const queryValues = [];
+        for (const [key, value] of Object.entries(values)) {
+            if (value instanceof prorm_1.Literal) {
+                // For Literal values, inline the SQL directly
+                setClauses.push(`${this.escapeId(key)} = ${value.val}`);
+            }
+            else {
+                // For regular values, use parameterized placeholder
+                setClauses.push(`${this.escapeId(key)} = ?`);
+                queryValues.push(value);
+            }
+        }
+        const whereClause = this.buildWhereClause(where);
+        let sql = `UPDATE ${this.escapeId(tableName)} SET ${setClauses.join(', ')}`;
+        if (whereClause.sql) {
+            sql += ` WHERE ${whereClause.sql}`;
+        }
+        if (options?.limit) {
+            sql += ` LIMIT ${options.limit}`;
+        }
+        return { sql, values: [...queryValues, ...whereClause.values] };
+    }
+    /**
+     * Build a DELETE query
+     */
+    buildDeleteQuery(tableName, where, options) {
+        const whereClause = this.buildWhereClause(where);
+        let sql = `DELETE FROM ${this.escapeId(tableName)}`;
+        if (whereClause.sql) {
+            sql += ` WHERE ${whereClause.sql}`;
+        }
+        if (options?.limit) {
+            sql += ` LIMIT ${options.limit}`;
+        }
+        return { sql, values: whereClause.values };
+    }
+    /**
+     * Check if a value is a function expression (fn('COUNT', ...))
+     */
+    isFnExpression(value) {
+        return value !== null && typeof value === 'object' && value.__type === 'fn';
+    }
+    /**
+     * Check if a value is a column expression (col('name'))
+     */
+    isColExpression(value) {
+        return value !== null && typeof value === 'object' && value.__type === 'col';
+    }
+    /**
+     * Check if a value is a literal expression (literal('sql'))
+     */
+    isLiteralExpression(value) {
+        return value !== null && typeof value === 'object' && value.__type === 'literal';
+    }
+    /**
+     * Compile a function expression to SQL
+     */
+    compileFnExpression(fnExpr) {
+        const args = fnExpr.args.map((arg) => {
+            if (this.isColExpression(arg)) {
+                return this.escapeId(arg.col);
+            }
+            else if (typeof arg === 'string') {
+                return this.escape(arg);
+            }
+            else if (this.isFnExpression(arg)) {
+                return this.compileFnExpression(arg);
+            }
+            else {
+                return String(arg);
+            }
+        });
+        return `${fnExpr.fn}(${args.join(', ')})`;
+    }
+    /**
+     * Build SELECT clause with support for function expressions and aliases
+     * Handles: 'field', ['field'], ['field', 'alias'], [fn('COUNT', 'id'), 'count']
+     */
+    buildSelectClause(attributes) {
+        if (!attributes)
+            return '*';
+        if (Array.isArray(attributes)) {
+            const parts = attributes.map((attr) => {
+                // Handle array format: [expression, alias] or [fn, alias]
+                if (Array.isArray(attr)) {
+                    const [expr, alias] = attr;
+                    let sql;
+                    if (this.isFnExpression(expr)) {
+                        sql = this.compileFnExpression(expr);
+                    }
+                    else if (this.isColExpression(expr)) {
+                        sql = this.escapeId(expr.col);
+                    }
+                    else if (this.isLiteralExpression(expr)) {
+                        sql = expr.sql;
+                    }
+                    else if (typeof expr === 'string') {
+                        // Check if it's a column reference or literal SQL
+                        if (expr.includes('(') || expr.includes(' ')) {
+                            sql = expr; // Literal SQL
+                        }
+                        else {
+                            sql = this.escapeId(expr);
+                        }
+                    }
+                    else {
+                        sql = String(expr);
+                    }
+                    return `${sql} AS ${this.escapeId(alias)}`;
+                }
+                else if (this.isFnExpression(attr)) {
+                    // Function without alias - let DB assign a name
+                    return this.compileFnExpression(attr);
+                }
+                else if (this.isColExpression(attr)) {
+                    return this.escapeId(attr.col);
+                }
+                else if (this.isLiteralExpression(attr)) {
+                    return attr.sql;
+                }
+                else if (typeof attr === 'string') {
+                    // Plain column name
+                    return this.escapeId(attr);
+                }
+                return String(attr);
+            });
+            return parts.join(', ');
+        }
+        else if (attributes.include) {
+            return attributes.include.map((a) => this.escapeId(a)).join(', ');
+        }
+        else if (attributes.exclude) {
+            // MySQL doesn't support EXCEPT, we handle this differently
+            return '*';
+        }
+        return '*';
+    }
+    /**
+     * Build GROUP BY clause with support for function expressions and aliases
+     * Handles: 'field', ['field1', 'field2'], [[fn('COUNT', 'id'), 'count']]
+     */
+    buildGroupByClause(group) {
+        if (!group)
+            return '';
+        const groupArray = Array.isArray(group) ? group : [group];
+        if (groupArray.length === 0)
+            return '';
+        const parts = groupArray.map((field) => {
+            if (Array.isArray(field)) {
+                // Array format: [expression, alias] or [fn, alias]
+                const [expr, alias] = field;
+                let sql;
+                if (this.isFnExpression(expr)) {
+                    sql = this.compileFnExpression(expr);
+                }
+                else if (this.isColExpression(expr)) {
+                    sql = this.escapeId(expr.col);
+                }
+                else if (this.isLiteralExpression(expr)) {
+                    sql = expr.sql;
+                }
+                else if (typeof expr === 'string') {
+                    sql = this.escapeId(expr);
+                }
+                else {
+                    sql = String(expr);
+                }
+                // Alias is optional in GROUP BY
+                if (alias) {
+                    return `${sql} AS ${this.escapeId(alias)}`;
+                }
+                return sql;
+            }
+            else if (this.isFnExpression(field)) {
+                return this.compileFnExpression(field);
+            }
+            else if (this.isColExpression(field)) {
+                return this.escapeId(field.col);
+            }
+            else if (this.isLiteralExpression(field)) {
+                return field.sql;
+            }
+            else if (typeof field === 'string') {
+                if (field.includes('.')) {
+                    return field
+                        .split('.')
+                        .map((part) => this.escapeId(part))
+                        .join('.');
+                }
+                return this.escapeId(field);
+            }
+            return String(field);
+        });
+        return `GROUP BY ${parts.join(', ')}`;
+    }
+    /**
+     * Build a WHERE clause condition using standard operators (Op.gt, Op.eq, etc.)
+     */
+    buildCondition(condition, values, paramChar = '?') {
+        if (!condition || (typeof condition === 'object' && Object.keys(condition).length === 0)) {
+            return '';
+        }
+        // Handle logical operators
+        if ('$and' in condition) {
+            const andParts = condition.$and.map((c) => this.buildCondition(c, values, paramChar));
+            return `(${andParts.join(' AND ')})`;
+        }
+        if ('$or' in condition) {
+            const orParts = condition.$or.map((c) => this.buildCondition(c, values, paramChar));
+            return `(${orParts.join(' OR ')})`;
+        }
+        if ('$not' in condition) {
+            return `NOT (${this.buildCondition(condition.$not, values, paramChar)})`;
+        }
+        // Handle regular conditions
+        const conditions = [];
+        for (const [key, value] of Object.entries(condition)) {
+            if (key.startsWith('$'))
+                continue; // Skip logical operators
+            let sql = '';
+            // Check if value is an operator object
+            if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
+                const opKeys = Object.keys(value);
+                if (opKeys.length === 1) {
+                    const opKey = opKeys[0];
+                    const opValue = value[opKey];
+                    // Map Op symbol to string
+                    if (opKey === 'Symbol(eq)' || opKey === 'Symbol(operators.eq)') {
+                        sql = `${this.escapeId(key)} = ${paramChar}`;
+                        values.push(opValue);
+                    }
+                    else if (opKey === 'Symbol(ne)' || opKey === 'Symbol(operators.ne)') {
+                        sql = `${this.escapeId(key)} != ${paramChar}`;
+                        values.push(opValue);
+                    }
+                    else if (opKey === 'Symbol(gt)' || opKey === 'Symbol(operators.gt)') {
+                        sql = `${this.escapeId(key)} > ${paramChar}`;
+                        values.push(opValue);
+                    }
+                    else if (opKey === 'Symbol(gte)' || opKey === 'Symbol(operators.gte)') {
+                        sql = `${this.escapeId(key)} >= ${paramChar}`;
+                        values.push(opValue);
+                    }
+                    else if (opKey === 'Symbol(lt)' || opKey === 'Symbol(operators.lt)') {
+                        sql = `${this.escapeId(key)} < ${paramChar}`;
+                        values.push(opValue);
+                    }
+                    else if (opKey === 'Symbol(lte)' || opKey === 'Symbol(operators.lte)') {
+                        sql = `${this.escapeId(key)} <= ${paramChar}`;
+                        values.push(opValue);
+                    }
+                    else if (opKey === 'Symbol(in)' || opKey === 'Symbol(operators.in)') {
+                        sql = `${this.escapeId(key)} IN (${paramChar})`;
+                        values.push(opValue);
+                    }
+                    else if (opKey === 'Symbol(notIn)' || opKey === 'Symbol(operators.notIn)') {
+                        sql = `${this.escapeId(key)} NOT IN (${paramChar})`;
+                        values.push(opValue);
+                    }
+                    else if (opKey === 'Symbol(between)' || opKey === 'Symbol(operators.between)') {
+                        sql = `${this.escapeId(key)} BETWEEN ${paramChar} AND ${paramChar}`;
+                        values.push(...opValue);
+                    }
+                    else if (opKey === 'Symbol(notBetween)' || opKey === 'Symbol(operators.notBetween)') {
+                        sql = `${this.escapeId(key)} NOT BETWEEN ${paramChar} AND ${paramChar}`;
+                        values.push(...opValue);
+                    }
+                    else if (opKey === 'Symbol(isNull)' || opKey === 'Symbol(operators.isNull)') {
+                        sql = `${this.escapeId(key)} IS NULL`;
+                    }
+                    else if (opKey === 'Symbol(isNotNull)' || opKey === 'Symbol(operators.isNotNull)') {
+                        sql = `${this.escapeId(key)} IS NOT NULL`;
+                    }
+                    else if (opKey === 'Symbol(like)' || opKey === 'Symbol(operators.like)') {
+                        sql = `${this.escapeId(key)} LIKE ${paramChar}`;
+                        values.push(opValue);
+                    }
+                    else if (opKey === 'Symbol(notLike)' || opKey === 'Symbol(operators.notLike)') {
+                        sql = `${this.escapeId(key)} NOT LIKE ${paramChar}`;
+                        values.push(opValue);
+                    }
+                    else if (opKey === 'Symbol(iLike)' || opKey === 'Symbol(operators.iLike)') {
+                        sql = `${this.escapeId(key)} ILIKE ${paramChar}`;
+                        values.push(opValue);
+                    }
+                    else if (opKey === 'Symbol(notILike)' || opKey === 'Symbol(operators.notILike)') {
+                        sql = `${this.escapeId(key)} NOT ILIKE ${paramChar}`;
+                        values.push(opValue);
+                    }
+                }
+                if (!sql) {
+                    // Fallback: treat as equals
+                    sql = `${this.escapeId(key)} = ${paramChar}`;
+                    values.push(value);
+                }
+            }
+            else if (Array.isArray(value)) {
+                // Handle IN arrays
+                sql = `${this.escapeId(key)} IN (${value.map(() => paramChar).join(', ')})`;
+                values.push(...value);
+            }
+            else {
+                // Simple equality
+                sql = `${this.escapeId(key)} = ${paramChar}`;
+                values.push(value);
+            }
+            if (sql) {
+                conditions.push(sql);
+            }
+        }
+        return conditions.join(' AND ');
+    }
+    /**
+     * Build a HAVING clause with support for standard Op operators
+     */
+    buildHavingClause(having) {
+        const values = [];
+        if (!having || (typeof having === 'object' && Object.keys(having).length === 0)) {
+            return { sql: '', values };
+        }
+        // Use the condition builder with Op operator support
+        const sql = this.buildCondition(having, values);
+        return { sql, values };
+    }
+    /**
+     * 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).
+     */
+    buildWithClause(ctes, recursive, queryValues) {
+        if (!ctes || ctes.length === 0)
+            return '';
+        const parts = ctes.map((cte) => {
+            const columns = cte.columns && cte.columns.length > 0
+                ? ` (${cte.columns.map((c) => this.escapeId(c)).join(', ')})`
+                : '';
+            let cteSql;
+            if (typeof cte.query === 'string') {
+                cteSql = cte.query;
+            }
+            else {
+                cteSql = cte.query.sql;
+                if (cte.query.values && cte.query.values.length > 0) {
+                    queryValues.push(...cte.query.values);
+                }
+            }
+            return `${this.escapeId(cte.name)}${columns} AS (${cteSql})`;
+        });
+        return `WITH ${recursive ? 'RECURSIVE ' : ''}${parts.join(', ')} `;
+    }
+    /**
+     * Build a SELECT query
+     */
+    buildSelectQuery(options) {
+        const queryValues = [];
+        // Build WITH [RECURSIVE] clause (Common Table Expressions), MySQL 8.0+
+        const withClause = this.buildWithClause(options.with, options.withRecursive, queryValues);
+        // Build SELECT clause
+        const selectSql = this.buildSelectClause(options.attributes);
+        // Handle DISTINCT (for COUNT(DISTINCT col))
+        let distinctClause = '';
+        if (options.distinct) {
+            if (options.col) {
+                distinctClause = `DISTINCT ${this.escapeId(options.col)} `;
+            }
+            else {
+                distinctClause = 'DISTINCT ';
+            }
+        }
+        let sql = `${withClause}SELECT ${distinctClause}${selectSql} FROM ${this.escapeId(options.tableName)}`;
+        // Build JOIN clause (for includes) or use subquery IN pattern
+        if (options.include && options.include.length > 0) {
+            if (options.subQuery) {
+                // Use subquery IN pattern for includes
+                sql = this.buildSubqueryIncludes(sql, options.include, options.tableName, queryValues);
+            }
+            else {
+                // Use JOIN for includes (default behavior)
+                for (const include of options.include) {
+                    const joinType = include.required ? 'INNER JOIN' : 'LEFT JOIN';
+                    const modelTableName = include.model.tableName;
+                    const alias = include.as || modelTableName;
+                    const tableNameStr = modelTableName || include.model.toString();
+                    sql += ` ${joinType} ${this.escapeId(tableNameStr)} ${this.escapeId(alias)}`;
+                    if (include.where) {
+                        const whereClause = this.buildWhereClause(include.where);
+                        sql += ` ON ${whereClause.sql}`;
+                        queryValues.push(...whereClause.values);
+                    }
+                }
+            }
+        }
+        // Build WHERE clause
+        if (options.where) {
+            const whereClause = this.buildWhereClause(options.where);
+            if (whereClause.sql) {
+                sql += ` WHERE ${whereClause.sql}`;
+                queryValues.push(...whereClause.values);
+            }
+        }
+        // Build GROUP BY clause
+        if (options.group) {
+            const groupByClause = this.buildGroupByClause(options.group);
+            if (groupByClause) {
+                sql += ` ${groupByClause}`;
+            }
+        }
+        // Build HAVING clause
+        if (options.having) {
+            const havingClause = this.buildHavingClause(options.having);
+            if (havingClause.sql) {
+                sql += ` HAVING ${havingClause.sql}`;
+                queryValues.push(...havingClause.values);
+            }
+        }
+        // Build ORDER BY clause
+        if (options.order) {
+            const orderClause = this.buildOrderClause(options.order);
+            if (orderClause) {
+                sql += ` ${orderClause}`;
+            }
+        }
+        // Build LIMIT/OFFSET clause
+        sql += this.buildLimitOffset(options.limit, options.offset);
+        // Handle row-level locking
+        if (options.lock) {
+            // lock: true is equivalent to 'UPDATE'
+            let lockType;
+            let nowait = false;
+            let skipLocked = false;
+            if (options.lock === true) {
+                lockType = 'UPDATE';
+            }
+            else if (typeof options.lock === 'string') {
+                lockType = options.lock;
+            }
+            else if (typeof options.lock === 'object') {
+                // Handle { level: 'UPDATE', nowait: true } or { level: 'UPDATE', skipLocked: true }
+                lockType = options.lock.level || (options.lock.of ? 'UPDATE' : undefined);
+                nowait = options.lock.nowait === true;
+                skipLocked = options.lock.skipLocked === true;
+            }
+            if (lockType === 'UPDATE') {
+                sql += ' FOR UPDATE';
+                // MySQL 8.0+ supports table-scoped locking via `FOR UPDATE OF <table>`
+                if (typeof options.lock === 'object' && options.lock.of) {
+                    const model = options.lock.of;
+                    if (model.tableName) {
+                        sql += ` OF ${this.escapeId(model.tableName)}`;
+                    }
+                }
+                // MySQL 8.0+ supports NOWAIT and SKIP LOCKED
+                if (nowait) {
+                    sql += ' NOWAIT';
+                }
+                else if (skipLocked) {
+                    sql += ' SKIP LOCKED';
+                }
+            }
+            else if (lockType === 'SHARE') {
+                sql += ' LOCK IN SHARE MODE';
+                // MySQL 8.0+ supports NOWAIT for SHARE mode
+                if (nowait) {
+                    sql += ' NOWAIT';
+                }
+                // MySQL doesn't support SKIP LOCKED for LOCK IN SHARE MODE
+            }
+        }
+        // Build UNION clause if provided
+        if (options.union && options.union.length > 0) {
+            const unionType = options.unionType || 'UNION';
+            for (const unionQuery of options.union) {
+                const unionModel = unionQuery.model;
+                const unionTableName = unionModel.tableName || unionModel.name || '';
+                // Build the union query
+                let unionSql = `SELECT * FROM ${this.escapeId(unionTableName)}`;
+                // Add WHERE clause for union query
+                if (unionQuery.where) {
+                    const whereClause = this.buildWhereClause(unionQuery.where);
+                    if (whereClause.sql) {
+                        unionSql += ` WHERE ${whereClause.sql}`;
+                        queryValues.push(...whereClause.values);
+                    }
+                }
+                // Add ORDER BY for union query
+                if (unionQuery.order) {
+                    const orderClause = this.buildOrderClause(unionQuery.order);
+                    if (orderClause) {
+                        unionSql += ` ${orderClause}`;
+                    }
+                }
+                // Add LIMIT for union query
+                if (unionQuery.limit) {
+                    unionSql += ` LIMIT ${unionQuery.limit}`;
+                }
+                // Add OFFSET for union query
+                if (unionQuery.offset) {
+                    unionSql += ` OFFSET ${unionQuery.offset}`;
+                }
+                sql += ` ${unionType} ${unionSql}`;
+            }
+        }
+        return { sql, values: queryValues };
+    }
+    // ---------------------------------------------------------------------------
+    // User / privilege management
+    // ---------------------------------------------------------------------------
+    /**
+     * Escape a password string – replaces single quotes so it is safe to embed
+     * between single-quote delimiters in SQL.
+     */
+    escapePassword(pw) {
+        return pw.replace(/'/g, "\\'");
+    }
+    /**
+     * Format a MySQL user identity as  'username'@'host'
+     */
+    formatUserIdentity(username, host = '%') {
+        return `'${username}'@'${host}'`;
+    }
+    /**
+     * 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.
+     */
+    formatPrivilegeScope(scope) {
+        switch (scope.level) {
+            case 'global':
+                return { scopeSql: '*.*', columnPrefix: null };
+            case 'database':
+                return { scopeSql: `\`${scope.database}\`.*`, columnPrefix: null };
+            case 'table': {
+                const db = scope.database ? `\`${scope.database}\`.` : '';
+                return { scopeSql: `${db}\`${scope.table}\``, columnPrefix: null };
+            }
+            case 'column': {
+                const db = scope.database ? `\`${scope.database}\`.` : '';
+                const cols = scope.columns.map((c) => `\`${c}\``).join(', ');
+                return {
+                    scopeSql: `${db}\`${scope.table}\``,
+                    columnPrefix: cols,
+                };
+            }
+            case 'routine': {
+                const db = scope.database ? `\`${scope.database}\`.` : '';
+                const type = scope.routineType || 'PROCEDURE';
+                return { scopeSql: `${type} ${db}\`${scope.routine}\``, columnPrefix: null };
+            }
+        }
+    }
+    buildCreateUserQuery(username, options = {}) {
+        const host = options.host ?? '%';
+        const identity = this.formatUserIdentity(username, host);
+        let sql = 'CREATE USER';
+        if (options.ifNotExists)
+            sql += ' IF NOT EXISTS';
+        sql += ` ${identity}`;
+        // Authentication
+        if (options.authPlugin && options.password) {
+            sql += ` IDENTIFIED WITH ${options.authPlugin} BY '${this.escapePassword(options.password)}'`;
+        }
+        else if (options.authPlugin && options.passwordHash) {
+            sql += ` IDENTIFIED WITH ${options.authPlugin} AS '${this.escapePassword(options.passwordHash)}'`;
+        }
+        else if (options.password) {
+            sql += ` IDENTIFIED BY '${this.escapePassword(options.password)}'`;
+        }
+        // SSL
+        if (options.requireSSL === true) {
+            sql += ' REQUIRE SSL';
+        }
+        // Resource limits
+        const limits = [];
+        if (options.maxQueriesPerHour != null)
+            limits.push(`MAX_QUERIES_PER_HOUR ${options.maxQueriesPerHour}`);
+        if (options.maxUpdatesPerHour != null)
+            limits.push(`MAX_UPDATES_PER_HOUR ${options.maxUpdatesPerHour}`);
+        if (options.maxConnectionsPerHour != null)
+            limits.push(`MAX_CONNECTIONS_PER_HOUR ${options.maxConnectionsPerHour}`);
+        if (options.maxConnections != null)
+            limits.push(`MAX_USER_CONNECTIONS ${options.maxConnections}`);
+        if (limits.length > 0)
+            sql += ` WITH ${limits.join(' ')}`;
+        // Password expiry
+        if (options.expirePassword != null) {
+            if (options.expirePassword === true) {
+                sql += ' PASSWORD EXPIRE';
+            }
+            else if (options.expirePassword === false) {
+                sql += ' PASSWORD EXPIRE NEVER';
+            }
+            else if (options.expirePassword instanceof Date) {
+                // MySQL doesn't support a specific expiry date; emit EXPIRE DEFAULT
+                sql += ' PASSWORD EXPIRE DEFAULT';
+            }
+        }
+        // Account lock
+        if (options.accountLocked === true)
+            sql += ' ACCOUNT LOCK';
+        if (options.accountLocked === false)
+            sql += ' ACCOUNT UNLOCK';
+        // Comment (MySQL 8.0.21+)
+        if (options.comment) {
+            sql += ` COMMENT '${options.comment.replace(/'/g, "\\'")}'`;
+        }
+        return sql;
+    }
+    buildAlterUserQuery(username, options) {
+        const host = options.host ?? '%';
+        const identity = this.formatUserIdentity(username, host);
+        let sql = `ALTER USER ${identity}`;
+        // Authentication
+        if (options.authPlugin && options.password) {
+            sql += ` IDENTIFIED WITH ${options.authPlugin} BY '${this.escapePassword(options.password)}'`;
+        }
+        else if (options.password) {
+            sql += ` IDENTIFIED BY '${this.escapePassword(options.password)}'`;
+        }
+        // SSL
+        if (options.requireSSL === true) {
+            sql += ' REQUIRE SSL';
+        }
+        else if (options.requireSSL === 'NONE' || options.requireSSL === false) {
+            sql += ' REQUIRE NONE';
+        }
+        // Resource limits
+        const limits = [];
+        if (options.maxQueriesPerHour != null)
+            limits.push(`MAX_QUERIES_PER_HOUR ${options.maxQueriesPerHour}`);
+        if (options.maxUpdatesPerHour != null)
+            limits.push(`MAX_UPDATES_PER_HOUR ${options.maxUpdatesPerHour}`);
+        if (options.maxConnectionsPerHour != null)
+            limits.push(`MAX_CONNECTIONS_PER_HOUR ${options.maxConnectionsPerHour}`);
+        if (options.maxConnections != null)
+            limits.push(`MAX_USER_CONNECTIONS ${options.maxConnections}`);
+        if (limits.length > 0)
+            sql += ` WITH ${limits.join(' ')}`;
+        // Password expiry policy
+        if (options.passwordExpirePolicy != null) {
+            const policy = options.passwordExpirePolicy;
+            if (policy === 'DEFAULT')
+                sql += ' PASSWORD EXPIRE DEFAULT';
+            else if (policy === 'NEVER')
+                sql += ' PASSWORD EXPIRE NEVER';
+            else if (policy === 'INTERVAL')
+                sql += ' PASSWORD EXPIRE INTERVAL';
+            else if (typeof policy === 'number')
+                sql += ` PASSWORD EXPIRE INTERVAL ${policy} DAY`;
+        }
+        // Account lock / unlock
+        if (options.unlockAccount)
+            sql += ' ACCOUNT UNLOCK';
+        else if (options.accountLocked)
+            sql += ' ACCOUNT LOCK';
+        return sql;
+    }
+    buildDropUserQuery(username, options = {}) {
+        const host = options.host ?? '%';
+        const identity = this.formatUserIdentity(username, host);
+        let sql = 'DROP USER';
+        if (options.ifExists)
+            sql += ' IF EXISTS';
+        sql += ` ${identity}`;
+        return sql;
+    }
+    getUsersQuery() {
+        return 'SELECT User, Host, plugin, password_expired, account_locked FROM mysql.user';
+    }
+    /**
+     * Create a database user
+     */
+    async createUser(username, options) {
+        const sql = this.buildCreateUserQuery(username, options);
+        await this.query(sql);
+    }
+    buildGrantQuery(options) {
+        const { scopeSql, columnPrefix } = this.formatPrivilegeScope(options.on);
+        const privList = options.privileges.join(', ');
+        // For column-level grants the privilege list needs to wrap the columns
+        let grantPriv;
+        if (columnPrefix !== null) {
+            // e.g. SELECT (`col1`, `col2`)  – columnPrefix already has backtick-quoted cols
+            grantPriv = `${privList} (${columnPrefix})`;
+        }
+        else {
+            grantPriv = privList;
+        }
+        const recipients = (Array.isArray(options.to) ? options.to : [options.to])
+            .map((u) => {
+            // If the string already contains '@' treat it as a full identity
+            if (u.includes('@'))
+                return u;
+            return this.formatUserIdentity(u, options.host ?? '%');
+        })
+            .join(', ');
+        let sql = `GRANT ${grantPriv} ON ${scopeSql} TO ${recipients}`;
+        if (options.withGrantOption)
+            sql += ' WITH GRANT OPTION';
+        return sql;
+    }
+    buildRevokeQuery(options) {
+        const { scopeSql, columnPrefix } = this.formatPrivilegeScope(options.on);
+        const privList = options.privileges.join(', ');
+        let revokePriv;
+        if (columnPrefix !== null) {
+            revokePriv = `${privList} (${columnPrefix})`;
+        }
+        else {
+            revokePriv = privList;
+        }
+        const targets = (Array.isArray(options.from) ? options.from : [options.from])
+            .map((u) => {
+            if (u.includes('@'))
+                return u;
+            return this.formatUserIdentity(u, options.host ?? '%');
+        })
+            .join(', ');
+        let sql;
+        if (options.grantOptionFor) {
+            sql = `REVOKE GRANT OPTION FOR ${revokePriv} ON ${scopeSql} FROM ${targets}`;
+        }
+        else {
+            sql = `REVOKE ${revokePriv} ON ${scopeSql} FROM ${targets}`;
+        }
+        return sql;
+    }
+    buildShowGrantsQuery(username, host = '%') {
+        return `SHOW GRANTS FOR ${this.formatUserIdentity(username, host)}`;
+    }
+    buildFlushPrivilegesQuery() {
+        return 'FLUSH PRIVILEGES';
+    }
+    // ---- Roles (MySQL 8+) ----
+    buildCreateRoleQuery(roleName, options = {}) {
+        let sql = 'CREATE ROLE';
+        if (options.ifNotExists)
+            sql += ' IF NOT EXISTS';
+        sql += ` '${roleName}'`;
+        return sql;
+    }
+    buildDropRoleQuery(roleName, options = {}) {
+        let sql = 'DROP ROLE';
+        if (options.ifExists)
+            sql += ' IF EXISTS';
+        sql += ` '${roleName}'`;
+        return sql;
+    }
+    buildGrantRoleQuery(role, to, options = {}) {
+        const recipients = (Array.isArray(to) ? to : [to])
+            .map((u) => (u.includes('@') ? u : this.formatUserIdentity(u, '%')))
+            .join(', ');
+        let sql = `GRANT '${role}' TO ${recipients}`;
+        if (options.withAdminOption)
+            sql += ' WITH ADMIN OPTION';
+        return sql;
+    }
+    buildRevokeRoleQuery(role, from, _options = {}) {
+        const targets = (Array.isArray(from) ? from : [from])
+            .map((u) => (u.includes('@') ? u : this.formatUserIdentity(u, '%')))
+            .join(', ');
+        return `REVOKE '${role}' FROM ${targets}`;
+    }
+    getRolesQuery() {
+        return 'SELECT role_name AS role FROM information_schema.APPLICABLE_ROLES';
+    }
+    /**
+     * Generate SQL for creating a MySQL database
+     */
+    createDatabaseSQL(options) {
+        const parts = [];
+        parts.push(`CREATE DATABASE ${this.quoteIdentifier(options.name)}`);
+        if (options.encoding) {
+            parts.push(`CHARACTER SET = '${options.encoding}'`);
+        }
+        if (options.collate) {
+            parts.push(`COLLATE = '${options.collate}'`);
+        }
+        return parts.join(' ');
+    }
+    /**
+     * Generate SQL for dropping a MySQL database
+     */
+    dropDatabaseSQL(name) {
+        return `DROP DATABASE IF EXISTS ${this.quoteIdentifier(name)}`;
+    }
+    /**
+     * Generate SQL for creating a savepoint
+     */
+    createSavepointSQL(name) {
+        const savepointName = name || `sp_${Date.now()}`;
+        return `SAVEPOINT ${savepointName}`;
+    }
+    /**
+     * Generate SQL for releasing a savepoint
+     */
+    releaseSavepointSQL(name) {
+        return `RELEASE SAVEPOINT ${name}`;
+    }
+    /**
+     * Generate SQL for rolling back to a savepoint
+     */
+    rollbackToSavepointSQL(name) {
+        return `ROLLBACK TO SAVEPOINT ${name}`;
+    }
+}
+exports.MySQLDialect = MySQLDialect;
+/**
+ * MySQL-specific transaction class
+ */
+class MySQLTransaction {
+    constructor(connection, options) {
+        this.finished = false;
+        this.parent = null;
+        this.savepoints = [];
+        this.connection = null;
+        this.savepointCount = 0;
+        this.id = `tx_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+        this.options = options || {};
+        this.connection = connection;
+    }
+    async commit() {
+        if (this.connection) {
+            await this.connection.commit();
+        }
+        this.finished = true;
+    }
+    async rollback() {
+        if (this.connection) {
+            await this.connection.rollback();
+        }
+        this.finished = true;
+    }
+    /**
+     * Create a savepoint
+     */
+    async createSavepoint(name) {
+        const savepointName = name || `sp_${this.savepointCount++}`;
+        if (this.connection) {
+            await this.connection.query(`SAVEPOINT ${savepointName}`);
+            this.savepoints.push(savepointName);
+        }
+        return savepointName;
+    }
+    /**
+     * Rollback to a savepoint
+     */
+    async rollbackToSavepoint(name) {
+        if (this.connection) {
+            await this.connection.query(`ROLLBACK TO SAVEPOINT ${name}`);
+        }
+    }
+    /**
+     * Release a savepoint
+     */
+    async releaseSavepoint(name) {
+        if (this.connection) {
+            await this.connection.query(`RELEASE SAVEPOINT ${name}`);
+            this.savepoints = this.savepoints.filter((sp) => sp !== name);
+        }
+    }
+}
+exports.MySQLTransaction = MySQLTransaction;
+// ==================== Procedure Body Builder ====================
+/**
+ * Helper class for building stored procedure bodies with full PL/SQL support
+ * Supports: IN/OUT/INOUT parameters, local variables, IF/ELSE, WHILE loops, cursors
+ */
+class ProcedureBodyBuilder {
+    constructor(dialect) {
+        this.statements = [];
+        this.dialect = dialect;
+    }
+    /**
+     * Declare a local variable
+     */
+    declare(name, type, defaultValue) {
+        const defaultPart = defaultValue !== undefined
+            ? ` DEFAULT ${this.dialect.escape(defaultValue)}`
+            : '';
+        this.statements.push(`DECLARE ${this.dialect.quoteIdentifier(name)} ${type}${defaultPart};`);
+        return this;
+    }
+    /**
+     * Set a variable value
+     */
+    set(name, value) {
+        this.statements.push(`SET ${this.dialect.quoteIdentifier(name)} = ${this.dialect.escape(value)};`);
+        return this;
+    }
+    /**
+     * Set a variable from a SELECT query (single value)
+     */
+    setFromSelect(name, query) {
+        this.statements.push(`SET ${this.dialect.quoteIdentifier(name)} = (${query});`);
+        return this;
+    }
+    /**
+     * IF condition
+     */
+    if(condition, then) {
+        this.statements.push(`IF ${condition} THEN`);
+        const thenBuilder = new ProcedureBodyBuilder(this.dialect);
+        then(thenBuilder);
+        this.statements.push(...thenBuilder.statements.map((s) => '  ' + s));
+        this.statements.push('END IF;');
+        return this;
+    }
+    /**
+     * IF/ELSE condition
+     */
+    ifElse(condition, then, else_) {
+        this.statements.push(`IF ${condition} THEN`);
+        const thenBuilder = new ProcedureBodyBuilder(this.dialect);
+        then(thenBuilder);
+        this.statements.push(...thenBuilder.statements.map((s) => '  ' + s));
+        this.statements.push('ELSE');
+        const elseBuilder = new ProcedureBodyBuilder(this.dialect);
+        else_(elseBuilder);
+        this.statements.push(...elseBuilder.statements.map((s) => '  ' + s));
+        this.statements.push('END IF;');
+        return this;
+    }
+    /**
+     * WHILE loop
+     */
+    whileLoop(condition, do_) {
+        this.statements.push(`WHILE ${condition} DO`);
+        const loopBuilder = new ProcedureBodyBuilder(this.dialect);
+        do_(loopBuilder);
+        this.statements.push(...loopBuilder.statements.map((s) => '  ' + s));
+        this.statements.push('END WHILE;');
+        return this;
+    }
+    /**
+     * REPEAT loop (do-while)
+     */
+    repeatLoop(do_, condition) {
+        this.statements.push('REPEAT');
+        const loopBuilder = new ProcedureBodyBuilder(this.dialect);
+        do_(loopBuilder);
+        this.statements.push(...loopBuilder.statements.map((s) => '  ' + s));
+        this.statements.push(`UNTIL ${condition} END REPEAT;`);
+        return this;
+    }
+    /**
+     * FOR loop over a query
+     */
+    forLoop(variableName, query, do_) {
+        const itemVar = this.dialect.quoteIdentifier(variableName);
+        this.statements.push(`FOR ${itemVar} IN (${query}) DO`);
+        const loopBuilder = new ProcedureBodyBuilder(this.dialect);
+        do_(loopBuilder, variableName);
+        this.statements.push(...loopBuilder.statements.map((s) => '  ' + s));
+        this.statements.push('END FOR;');
+        return this;
+    }
+    /**
+     * Declare and open a cursor
+     */
+    declareCursor(name, query) {
+        this.statements.push(`DECLARE ${this.dialect.quoteIdentifier(name)} CURSOR FOR ${query};`);
+        return this;
+    }
+    /**
+     * Open a cursor
+     */
+    openCursor(name) {
+        this.statements.push(`OPEN ${this.dialect.quoteIdentifier(name)};`);
+        return this;
+    }
+    /**
+     * Fetch from cursor into variables
+     */
+    fetchCursor(name, into) {
+        const intoVars = into.map((v) => this.dialect.quoteIdentifier(v)).join(', ');
+        this.statements.push(`FETCH ${this.dialect.quoteIdentifier(name)} INTO ${intoVars};`);
+        return this;
+    }
+    /**
+     * Close a cursor
+     */
+    closeCursor(name) {
+        this.statements.push(`CLOSE ${this.dialect.quoteIdentifier(name)};`);
+        return this;
+    }
+    /**
+     * Execute a raw SQL statement
+     */
+    sql(statement) {
+        this.statements.push(statement);
+        return this;
+    }
+    /**
+     * Call another stored procedure
+     */
+    call(procedureName, params) {
+        let sql = `CALL ${procedureName}`;
+        if (params && Object.keys(params).length > 0) {
+            const paramStr = Object.entries(params)
+                .map(([key, value]) => this.dialect.escape(value))
+                .join(', ');
+            sql += `(${paramStr})`;
+        }
+        sql += ';';
+        this.statements.push(sql);
+        return this;
+    }
+    /**
+     * Insert statement
+     */
+    insert(tableName, data) {
+        const columns = Object.keys(data).map((k) => this.dialect.quoteIdentifier(k)).join(', ');
+        const values = Object.values(data).map((v) => this.dialect.escape(v)).join(', ');
+        this.statements.push(`INSERT INTO ${tableName} (${columns}) VALUES (${values});`);
+        return this;
+    }
+    /**
+     * Update statement
+     */
+    update(tableName, data, where) {
+        const setClause = Object.entries(data)
+            .map(([k, v]) => `${this.dialect.quoteIdentifier(k)} = ${this.dialect.escape(v)}`)
+            .join(', ');
+        let sql = `UPDATE ${tableName} SET ${setClause}`;
+        if (where) {
+            sql += ` WHERE ${where}`;
+        }
+        sql += ';';
+        this.statements.push(sql);
+        return this;
+    }
+    /**
+     * Delete statement
+     */
+    delete(tableName, where) {
+        let sql = `DELETE FROM ${tableName}`;
+        if (where) {
+            sql += ` WHERE ${where}`;
+        }
+        sql += ';';
+        this.statements.push(sql);
+        return this;
+    }
+    /**
+     * SELECT INTO statement
+     */
+    selectInto(variables, query) {
+        const vars = variables.map((v) => this.dialect.quoteIdentifier(v)).join(', ');
+        this.statements.push(`SELECT ${vars} INTO ${vars} FROM ${query};`);
+        return this;
+    }
+    /**
+     * Add a comment
+     */
+    comment(text) {
+        this.statements.push(`-- ${text}`);
+        return this;
+    }
+    /**
+     * Build the final procedure body
+     */
+    build() {
+        return this.statements.join('\n');
+    }
+}
+/**
+ * Create a new MySQL dialect instance
+ */
+function createMySQLDialect(options) {
+    return new MySQLDialect(options || {});
+}
+exports.default = MySQLDialect;