ts-prorm-orm 1.1.0

package/dist/dialects/mariadb/index.js

@@ -0,0 +1,3590 @@
+"use strict";
+/**
+ * MariaDB dialect implementation for the TypeScript ORM
+ *
+ * This dialect provides support for MariaDB-specific features including:
+ * - AUTO_INCREMENT with initial value and offset
+ * - Sequence support (MariaDB 10.0+)
+ * - Storage engines (InnoDB, Aria, XtraDB, etc.)
+ * - Virtual columns (computed columns)
+ * - JSON enhancements
+ * - CONNECT storage engine types
+ * - Enhanced ON DELETE/UPDATE constraints
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MariaDBRowFormats = exports.MariaDBConnectTypes = exports.MariaDBStorageEngines = exports.MariaDBTransaction = exports.MariaDBDialect = void 0;
+exports.createMariaDBDialect = createMariaDBDialect;
+const mariadb = __importStar(require("mariadb"));
+const query_stream_helper_1 = require("../query-stream-helper");
+const prorm_1 = require("../../prorm");
+const operators_1 = require("../../operators");
+/**
+ * MariaDB dialect class that implements the Dialect interface
+ * Extends MySQL compatibility with MariaDB-specific features
+ */
+class MariaDBDialect {
+    constructor(config) {
+        this.name = 'mariadb';
+        this.library = 'mariadb';
+        this.pool = null;
+        this._isConnected = false;
+        this.config = {
+            host: 'localhost',
+            port: 3306,
+            waitForConnections: true,
+            connectionLimit: 10,
+            queueLimit: 0,
+            ...config,
+        };
+    }
+    /**
+     * Connect to the MariaDB database
+     */
+    async connect() {
+        try {
+            this.pool = mariadb.createPool({
+                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.config.connectionLimit,
+                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,
+                // MariaDB-specific options
+                insertIdAsNumber: true,
+                decimalAsFloat: false,
+            });
+            // Test the connection
+            const connection = await this.pool.getConnection();
+            connection.release();
+            this._isConnected = true;
+        }
+        catch (error) {
+            throw new Error(`Failed to connect to MariaDB database: ${error}`);
+        }
+    }
+    /**
+     * Disconnect from the MariaDB 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;
+    }
+    /**
+     * Stream query results by paging through `sql` via repeated
+     * dialect-appropriate LIMIT/OFFSET queries (see
+     * `createPaginatedQueryStream()` in `src/dialects/query-stream-helper.ts`)
+     * instead of loading the whole result set into memory at once.
+     * @param sql - The SELECT statement to stream
+     * @param options - Streaming options (batch size, backpressure watermark, model mapping)
+     */
+    queryStream(sql, options) {
+        return (0, query_stream_helper_1.createPaginatedQueryStream)(this, sql, options);
+    }
+    /**
+     * 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,
+        };
+        const retryOptions = options?.retry;
+        const effectiveRetry = retryOptions
+            ? {
+                ...defaultQueryRetryOptions,
+                ...retryOptions,
+                match: retryOptions.match || defaultQueryRetryOptions.match,
+            }
+            : 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') ||
+                sql.trim().toUpperCase().startsWith('WITH'); // CTE queries
+            // Apply replacements (named :param or positional ?) before executing.
+            // The mariadb driver receives a fully-bound SQL string.
+            const finalSql = options?.replacements
+                ? this.replaceReplacements(sql, options.replacements)
+                : sql;
+            try {
+                const result = await this.pool.query(finalSql);
+                // Handle result based on query type
+                if (isSelect) {
+                    const rows = result;
+                    // Extract field info from the result metadata if available
+                    const fieldInfo = [];
+                    return {
+                        rows,
+                        rowCount: rows.length,
+                        fields: fieldInfo,
+                    };
+                }
+                else {
+                    const resultSet = result;
+                    return {
+                        rows: [],
+                        rowCount: resultSet?.affectedRows || 0,
+                        fields: [],
+                    };
+                }
+            }
+            catch (error) {
+                throw new Error(`MariaDB Query error: ${error}`);
+            }
+        };
+        // If retry options are provided, use retry logic
+        if (effectiveRetry && (effectiveRetry.max ?? 0) > 0) {
+            return this.executeWithRetry(executeQuery, effectiveRetry);
+        }
+        return executeQuery();
+    }
+    /**
+     * 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') {
+            return value ? '1' : '0';
+        }
+        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 MariaDB
+     * MariaDB: 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) {
+            // MariaDB 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 MariaDB
+     * MariaDB: 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 MariaDB
+     * MariaDB: 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 MariaDB
+     */
+    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.
+     * MariaDB: JSON_SET(column, '$.path1', ?, '$.path2', ?, ...) (10.2.3+)
+     * 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.
+     * MariaDB: JSON_REPLACE(column, '$.path1', ?, ...) (10.2.3+)
+     */
+    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.
+     * MariaDB: JSON_INSERT(column, '$.path1', ?, ...) (10.2.3+)
+     */
+    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.
+     * MariaDB: JSON_REMOVE(column, '$.path1', '$.path2', ...) (10.2.3+)
+     */
+    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).
+     * MariaDB: JSON_MERGE_PATCH(column, ?, ?, ...) (10.2.4+)
+     */
+    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). MariaDB kept the legacy JSON_MERGE name as
+     * a deprecated alias for JSON_MERGE_PRESERVE; we always emit the explicit name.
+     * MariaDB: JSON_MERGE_PRESERVE(column, ?, ?, ...) (10.2.4+)
+     */
+    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,
+        };
+    }
+    /**
+     * Escape a string for SQL
+     */
+    escapeString(str) {
+        return str.replace(/'/g, "''").replace(/\\/g, '\\\\');
+    }
+    /**
+     * Format a date for MariaDB
+     */
+    formatDate(date) {
+        // Use UTC getters since the connection pool normalizes to UTC (timezone: 'Z').
+        // Using local-time getters here would produce a date string offset from
+        // what the server/client actually store, silently shifting inserted dates.
+        const year = date.getUTCFullYear();
+        const month = String(date.getUTCMonth() + 1).padStart(2, '0');
+        const day = String(date.getUTCDate()).padStart(2, '0');
+        const hours = String(date.getUTCHours()).padStart(2, '0');
+        const minutes = String(date.getUTCMinutes()).padStart(2, '0');
+        const seconds = String(date.getUTCSeconds()).padStart(2, '0');
+        const milliseconds = String(date.getUTCMilliseconds()).padStart(3, '0');
+        return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}.${milliseconds}`;
+    }
+    /**
+     * Escape an identifier (table name, column name, etc.)
+     * MariaDB uses backticks for identifiers (same as MySQL)
+     */
+    escapeId(identifier) {
+        const id = String(identifier ?? '');
+        return `\`${id.replace(/`/g, '``')}\``;
+    }
+    /**
+     * Escape an array of identifiers
+     */
+    escapeIdList(identifiers) {
+        if (Array.isArray(identifiers)) {
+            return identifiers.map((id) => this.escapeId(id)).join(', ');
+        }
+        return this.escapeId(identifiers);
+    }
+    /**
+     * Quote an identifier (column name, table name)
+     * MariaDB uses backticks for identifiers
+     */
+    quoteIdentifier(identifier) {
+        return this.escapeId(identifier);
+    }
+    /**
+     * Quote a table name
+     * Same as quoteIdentifier for MariaDB
+     */
+    quoteTable(tableName) {
+        return this.escapeId(tableName);
+    }
+    /**
+     * 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';
+    }
+    /**
+     * Get MariaDB-specific version info
+     */
+    async getMariaDBVersionInfo() {
+        if (!this.pool) {
+            throw new Error('Not connected to database');
+        }
+        const versionResult = await this.query('SELECT VERSION() as version');
+        const version = versionResult.rows[0]?.version || '';
+        // Extract version number (e.g., 10.11.4 -> 110401)
+        const versionMatch = version.match(/(\d+)\.(\d+)\.(\d+)/);
+        const versionNumber = versionMatch
+            ? parseInt(versionMatch[1]) * 10000 +
+                parseInt(versionMatch[2]) * 100 +
+                parseInt(versionMatch[3])
+            : 0;
+        // Get default storage engine
+        const engineResult = await this.query('SELECT @@default_storage_engine as engine');
+        const storageEngine = engineResult.rows[0]?.engine || 'InnoDB';
+        return {
+            version,
+            versionNumber,
+            storageEngine,
+        };
+    }
+    /**
+     * Reset AUTO_INCREMENT for a table
+     */
+    async resetAutoIncrement(tableName, newValue) {
+        let sql = `ALTER TABLE ${this.escapeId(tableName)} AUTO_INCREMENT`;
+        if (newValue !== undefined) {
+            sql += ` = ${newValue}`;
+        }
+        await this.query(sql);
+    }
+    /**
+     * Get table status (includes additional MariaDB info)
+     */
+    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
+     */
+    async getCreateTable(tableName) {
+        const sql = `SHOW CREATE TABLE ${this.escapeId(tableName)}`;
+        const result = await this.query(sql);
+        return result.rows[0]?.['Create Table'] || '';
+    }
+    /**
+     * Create a new table with MariaDB-specific options
+     */
+    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(', ')})`;
+        const mariaOptions = options;
+        // MariaDB-specific storage engine (default is InnoDB in newer versions)
+        if (mariaOptions?.engine) {
+            sql += ` ENGINE=${mariaOptions.engine}`;
+        }
+        else {
+            sql += ' ENGINE=InnoDB';
+        }
+        if (options?.charset) {
+            sql += ` DEFAULT CHARSET=${options.charset}`;
+        }
+        if (options?.collate) {
+            sql += ` COLLATE ${options.collate}`;
+        }
+        // MariaDB-specific table options
+        // Support both autoIncrement (MariaDB-specific) and initialAutoIncrement (standard)
+        if (mariaOptions?.autoIncrement) {
+            sql += ` AUTO_INCREMENT=${mariaOptions.autoIncrement}`;
+        }
+        else if (options?.initialAutoIncrement) {
+            sql += ` AUTO_INCREMENT=${options.initialAutoIncrement}`;
+        }
+        // Support both MariaDB-specific rowFormat and standard rowFormat option
+        if (mariaOptions?.rowFormat) {
+            sql += ` ROW_FORMAT=${mariaOptions.rowFormat}`;
+        }
+        else if (options?.rowFormat) {
+            sql += ` ROW_FORMAT=${options.rowFormat}`;
+        }
+        if (mariaOptions?.keyBlockSize) {
+            sql += ` KEY_BLOCK_SIZE=${mariaOptions.keyBlockSize}`;
+        }
+        // Support both tableComment (MariaDB-specific) and comment (standard)
+        if (mariaOptions?.tableComment) {
+            sql += ` COMMENT='${this.escapeString(mariaOptions.tableComment)}'`;
+        }
+        else if (options?.comment) {
+            sql += ` COMMENT='${this.escapeString(options.comment)}'`;
+        }
+        if (mariaOptions?.check) {
+            sql += ` CHECK(${mariaOptions.check})`;
+        }
+        // CONNECT storage engine specific options
+        if (mariaOptions?.connectType) {
+            sql = sql.replace(/ENGINE=\w+/, 'ENGINE=CONNECT');
+            sql += ` TYPE=${mariaOptions.connectType}`;
+            if (mariaOptions.connectOptions) {
+                const connectOpts = Object.entries(mariaOptions.connectOptions)
+                    .map(([key, value]) => `${key}='${value}'`)
+                    .join(', ');
+                sql += ` OPTIONS(${connectOpts})`;
+            }
+        }
+        // MariaDB 10.3+ system-versioned (temporal) tables
+        if (mariaOptions?.systemVersioning) {
+            sql += ' WITH SYSTEM VERSIONING';
+        }
+        await this.query(sql);
+        // Create unique keys after table creation
+        // 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`;
+                    await this.addIndex(tableName, uniqueName, uk.fields, { unique: true });
+                }
+            }
+            else {
+                // Legacy format: Record<string, string[]>
+                for (const [keyName, fields] of Object.entries(options.uniqueKeys)) {
+                    const uniqueName = keyName || `uq_${tableName}_${fields.join('_')}`;
+                    await this.addIndex(tableName, uniqueName, fields, { unique: true });
+                }
+            }
+        }
+        // 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 (MariaDB)
+     */
+    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 refFieldMB = constraint.references.field;
+                const refFieldSqlMB = Array.isArray(refFieldMB)
+                    ? `(\`${refFieldMB.join('`, `')}\`)`
+                    : `\`${refFieldMB}\``;
+                let fkSql = `${name}FOREIGN KEY (${fields}) `;
+                fkSql += `REFERENCES \`${constraint.references.table}\`(${refFieldSqlMB})`;
+                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 MariaDB
+     */
+    getColumnDefinitionSql(columnName, definition) {
+        const colDef = definition;
+        let sql = `${this.escapeId(columnName)} ${this.getDataTypeSql(definition.type)}`;
+        if (definition.allowNull === false) {
+            sql += ' NOT NULL';
+        }
+        if (definition.defaultValue !== undefined) {
+            sql += ` DEFAULT ${this.getDefaultValue(definition.defaultValue)}`;
+        }
+        // Column visibility (MariaDB 10.3+). INVISIBLE is placed as a suffix
+        // after the column definition (after DEFAULT, before PRIMARY
+        // KEY/AUTO_INCREMENT/UNIQUE), same keyword as MySQL. Columns are
+        // VISIBLE by default, so only emit it when explicitly invisible.
+        if (definition.invisible) {
+            sql += ' INVISIBLE';
+        }
+        if (definition.primaryKey) {
+            sql += ' PRIMARY KEY';
+        }
+        if (definition.autoIncrement) {
+            sql += ' AUTO_INCREMENT';
+            if (colDef.autoIncrementInit !== undefined) {
+                sql += `=${colDef.autoIncrementInit}`;
+            }
+        }
+        if (definition.unique) {
+            if (typeof definition.unique === 'string') {
+                sql += ` UNIQUE KEY ${this.escapeId(definition.unique)}`;
+            }
+            else {
+                sql += ' UNIQUE';
+            }
+        }
+        // Handle generated (virtual) columns - MariaDB 5.2+
+        if (colDef.generated && colDef.generationExpression) {
+            sql += ` AS (${colDef.generationExpression})`;
+            sql += ` ${colDef.generated}`;
+        }
+        // Storage engine specific setting
+        if (colDef.storage) {
+            sql += ` STORAGE ${colDef.storage}`;
+        }
+        // References with enhanced ON DELETE/UPDATE support
+        if (definition.references) {
+            const refFields = Array.isArray(definition.references.field)
+                ? definition.references.field.map((f) => this.escapeId(f)).join(', ')
+                : this.escapeId(definition.references.field);
+            sql += ` REFERENCES ${this.escapeId(definition.references.table)}(${refFields})`;
+            if (colDef.onDelete || definition.references.onDelete) {
+                sql += ` ON DELETE ${colDef.onDelete || definition.references.onDelete}`;
+            }
+            if (colDef.onUpdate || definition.references.onUpdate) {
+                sql += ` ON UPDATE ${colDef.onUpdate || definition.references.onUpdate}`;
+            }
+        }
+        else if (colDef.onDelete || colDef.onUpdate) {
+            // Standalone referential actions for foreign keys
+            if (colDef.onDelete) {
+                sql += ` ON DELETE ${colDef.onDelete}`;
+            }
+            if (colDef.onUpdate) {
+                sql += ` ON UPDATE ${colDef.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 MariaDB 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 (MariaDB)
+     *
+     * MariaDB supports partitioning with types: RANGE, LIST, HASH, KEY, LINEAR KEY, ROWS.
+     * 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 (MariaDB-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;
+            // Normalize type for MariaDB (linear key can be specified as "LINEAR KEY" or "LINEAR HASH")
+            let partitionType = type.toUpperCase();
+            if (type === 'linear key' || type === 'linear_hkey') {
+                partitionType = 'LINEAR HASH';
+            }
+            sql += ` PARTITION BY ${partitionType} (${columnsStr})`;
+            // Add partition definitions
+            if (options.partitions && options.partitions.length > 0) {
+                sql += ' (';
+                const partitionDefs = [];
+                for (const partition of options.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 (MariaDB)
+     *
+     * @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 (MariaDB uses ADD PARTITION instead)
+     * Provided for PostgreSQL compatibility
+     *
+     * @param options - Partition attachment options
+     */
+    async attachPartition(options) {
+        // MariaDB 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 (MariaDB does not support this operation)
+     *
+     * @param options - Partition detachment options
+     */
+    async detachPartition(_options) {
+        throw new Error('MariaDB does not support detaching partitions. Use DROP PARTITION instead.');
+    }
+    /**
+     * Drop a partition (MariaDB)
+     *
+     * @param partitionName - Name of the partition to drop
+     * @param options - Drop options including partition name and optional parent table
+     */
+    async dropPartition(partitionName, options) {
+        // MariaDB requires the parent table name
+        // If parentTable is not provided in options, try to extract from partition name
+        // (assumes format: parent_partition)
+        let parentTable = options?.parentTable;
+        if (!parentTable) {
+            const parts = partitionName.split('_');
+            parentTable = parts.slice(0, -1).join('_') || partitionName;
+        }
+        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 (MariaDB)
+     * @param tableName - Name of the partitioned table
+     * @param partitionName - Name for the new partition
+     * @param partitionSpec - Partition specification
+     */
+    async addPartition(tableName, partitionName, partitionSpec) {
+        let sql = `ALTER TABLE ${this.escapeId(tableName)} ADD PARTITION (`;
+        if (partitionSpec.values) {
+            sql += `VALUES ${partitionSpec.values}`;
+        }
+        else if (partitionSpec.forValues) {
+            sql += `FOR VALUES ${partitionSpec.forValues}`;
+        }
+        sql += ')';
+        await this.query(sql);
+    }
+    /**
+     * Check if a table has partitions (MariaDB)
+     *
+     * @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]);
+    }
+    /**
+     * 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);
+    }
+    /**
+     * 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) => Object.values(row)[0]);
+    }
+    // ==================== Stored Procedures ====================
+    // ==================== 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.escapeId(options.name)} ${timing} ${events} ON ${tableName} FOR EACH ${level}`;
+        if (options.timing === 'INSTEAD OF') {
+            sql = `CREATE TRIGGER ${this.escapeId(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) {
+        if (options?.cascade) {
+            throw new Error('MariaDB DROP TRIGGER does not support CASCADE; the cascade option is not supported for dropTrigger.');
+        }
+        const ifExists = options?.ifExists ? 'IF EXISTS ' : '';
+        const sql = `DROP TRIGGER ${ifExists}${this.escapeId(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)}`;
+        const result = await this.query(sql, { plain: true });
+        return !!result;
+    }
+    // ==================== Sequences ====================
+    // MariaDB 10.0+ supports sequences
+    /**
+     * Create a sequence
+     */
+    async createSequence(options) {
+        const schema = options.schema || (this.config.database ?? 'public');
+        const seqName = `${this.escapeId(schema)}.${this.escapeId(options.name)}`;
+        let sql = 'CREATE SEQUENCE';
+        if (options.replace) {
+            sql = 'CREATE OR REPLACE SEQUENCE';
+        }
+        else if (options.ifNotExists) {
+            sql = 'CREATE SEQUENCE IF NOT EXISTS';
+        }
+        if (options.temporary) {
+            // `sql.replace('CREATE', 'CREATE TEMPORARY SEQUENCE')` used to
+            // duplicate the SEQUENCE keyword (`CREATE TEMPORARY SEQUENCE
+            // SEQUENCE ...`), a syntax error on a real server; insert TEMPORARY
+            // right after CREATE instead of also re-adding SEQUENCE.
+            sql = sql.replace('CREATE', 'CREATE TEMPORARY');
+        }
+        sql += ` ${seqName}`;
+        if (options.startWith)
+            sql += ` START WITH ${options.startWith}`;
+        if (options.incrementBy)
+            sql += ` INCREMENT BY ${options.incrementBy}`;
+        if (options.minvalue)
+            sql += ` MINVALUE ${options.minvalue}`;
+        if (options.maxvalue)
+            sql += ` MAXVALUE ${options.maxvalue}`;
+        if (options.cycle)
+            sql += ` CYCLE`;
+        if (options.cache)
+            sql += ` CACHE ${options.cache}`;
+        await this.query(sql);
+    }
+    /**
+     * Drop a sequence
+     */
+    async dropSequence(sequenceName, options) {
+        const schema = options?.schema || (this.config.database ?? 'public');
+        const ifExists = options?.ifExists ? 'IF EXISTS ' : '';
+        const cascade = options?.cascade ? ' CASCADE' : '';
+        const sql = `DROP SEQUENCE ${ifExists}${this.escapeId(schema)}.${this.escapeId(sequenceName)}${cascade}`;
+        await this.query(sql);
+    }
+    /**
+     * Get next value from a sequence
+     */
+    async nextSequenceValue(sequenceName) {
+        const sql = `SELECT NEXT VALUE FOR ${this.escapeId(sequenceName)} as value`;
+        const result = await this.query(sql, { raw: true });
+        return result.rows?.[0]?.value;
+    }
+    /**
+     * Check if a sequence exists
+     */
+    async hasSequence(sequenceName) {
+        const sql = `SELECT sequence_name FROM information_schema.sequences WHERE sequence_name = ${this.escape(sequenceName)}`;
+        const result = await this.query(sql, { plain: true });
+        return !!result;
+    }
+    /**
+     * List all sequences in the database (MariaDB)
+     * @returns Array of sequence names
+     */
+    async listSequences() {
+        const sql = `SELECT sequence_name FROM information_schema.sequences ORDER BY sequence_name`;
+        const result = await this.query(sql);
+        return result.rows.map((row) => row.sequence_name);
+    }
+    // ==================== Row-Level Security (RLS) ====================
+    async createPolicy(_options) {
+        throw new Error('Row-level security is not supported by MariaDB');
+    }
+    async dropPolicy(_policyName, _tableName, _options) {
+        throw new Error('Row-level security is not supported by MariaDB');
+    }
+    async enableRLS(_tableName, _schema) {
+        throw new Error('Row-level security is not supported by MariaDB');
+    }
+    async enableRowLevelSecurity(_tableName, _schema) {
+        throw new Error('Row-level security is not supported by MariaDB');
+    }
+    async disableRLS(_tableName, _schema) {
+        throw new Error('Row-level security is not supported by MariaDB');
+    }
+    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)} CHANGE ${this.escapeId(columnName)} ${this.escapeId(columnName)} COMMENT ${this.escape(comment)}`;
+        await this.query(sql);
+    }
+    // ==================== Advanced Indexes ====================
+    /**
+     * Create an expression index
+     */
+    async createExpressionIndex(tableName, indexName, expression, options) {
+        const fieldsSql = `((${expression}))`;
+        let sql = `CREATE INDEX ${this.escapeId(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 (MariaDB 10.4+)
+     */
+    async createIdentityColumn(tableName, columnName, options) {
+        // `MODIFY col BIGINT AUTO_INCREMENT = <n>` is not valid MariaDB syntax
+        // (the starting value can't be set inline on the column definition);
+        // the starting value must be set via a separate `ALTER TABLE ...
+        // AUTO_INCREMENT = <n>` table-option statement.
+        const sql = `ALTER TABLE ${this.quoteTable(tableName)} MODIFY ${this.escapeId(columnName)} BIGINT AUTO_INCREMENT`;
+        await this.query(sql);
+        if (options?.startWith) {
+            await this.query(`ALTER TABLE ${this.quoteTable(tableName)} AUTO_INCREMENT = ${options.startWith}`);
+        }
+    }
+    /**
+     * Create a computed column (virtual column)
+     */
+    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.escapeId(columnName)} ${type} GENERATED ALWAYS AS (${expression}) ${persisted}`;
+        await this.query(sql);
+    }
+    /**
+     * Create a database view
+     */
+    async createView(viewName, query, options) {
+        const orReplace = options?.replace ? 'OR REPLACE' : '';
+        const sql = `CREATE VIEW ${orReplace} ${this.escapeId(viewName)} AS ${query}`;
+        await this.query(sql);
+    }
+    /**
+     * Drop a database view
+     */
+    async dropView(viewName, options) {
+        const ifExists = options?.ifExists ? 'IF EXISTS ' : '';
+        const cascade = options?.cascade ? ' CASCADE' : '';
+        const sql = `DROP VIEW ${ifExists}${this.escapeId(viewName)}${cascade}`;
+        await this.query(sql);
+    }
+    /**
+     * Create a schema
+     * MariaDB databases are like schemas - uses CREATE DATABASE
+     */
+    async createSchema(schema) {
+        const sql = `CREATE DATABASE ${this.escapeId(schema)}`;
+        await this.query(sql);
+    }
+    /**
+     * Drop a schema
+     * MariaDB databases are like schemas - uses DROP DATABASE
+     */
+    async dropSchema(schema, options) {
+        const ifExists = options?.ifExists ? 'IF EXISTS ' : '';
+        const cascade = options?.cascade ? ' CASCADE' : '';
+        const sql = `DROP DATABASE ${ifExists}${this.escapeId(schema)}${cascade}`;
+        await this.query(sql);
+    }
+    /**
+     * Show all schemas
+     * MariaDB databases are like schemas - shows all databases
+     */
+    async showAllSchemas() {
+        const result = await this.query('SHOW DATABASES', { raw: true });
+        return result.rows?.map((row) => row.Database) || [];
+    }
+    /**
+     * List all schemas (databases)
+     */
+    async listSchemas() {
+        return this.showAllSchemas();
+    }
+    // ==================== Stored Procedures ====================
+    /**
+     * Create a stored procedure with full PL/SQL support
+     * Supports: IN parameters, OUT parameters, 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
+        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). MariaDB requires
+        // the parameter-list parens even when there are zero parameters —
+        // `CREATE PROCEDURE name BEGIN ... END` (no parens at all) is a syntax
+        // error on a real server; `CREATE PROCEDURE name () BEGIN ... END` is
+        // required (confirmed against a live server).
+        const params = options.params && options.params.length > 0
+            ? 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})`;
+        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)}`);
+        }
+    }
+    /**
+     * 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). MariaDB requires
+        // the parameter-list parens even when there are zero parameters —
+        // `CREATE PROCEDURE name BEGIN ... END` (no parens at all) is a syntax
+        // error on a real server; `CREATE PROCEDURE name () BEGIN ... END` is
+        // required (confirmed against a live server).
+        const params = options.params && options.params.length > 0
+            ? 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})`;
+        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)}`);
+        }
+    }
+    /**
+     * 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}${this.escapeId(schema)}.${this.escapeId(procedureName)}${cascade}`;
+        await this.query(sql);
+    }
+    /**
+     * Drop a stored procedure (alias for dropStoredProcedure)
+     */
+    async dropProcedure(procedureName, options) {
+        return this.dropStoredProcedure(procedureName, options);
+    }
+    /**
+     * 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 MariaDB
+                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 result;
+    }
+    /**
+     * 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_NAME = ${this.escape(procedureName)} AND ROUTINE_SCHEMA = ${this.escape(db || '')} AND ROUTINE_TYPE = 'PROCEDURE'`;
+        const result = await this.query(sql, { plain: true });
+        return !!result;
+    }
+    /**
+     * Create a foreign data wrapper (MariaDB - 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 MariaDB. This is a PostgreSQL-specific feature.');
+    }
+    async dropForeignDataWrapper(_fdwName, _options) {
+        throw new Error('Foreign Data Wrappers are not supported by MariaDB. This is a PostgreSQL-specific feature.');
+    }
+    async createForeignServer(_serverName, _fdwName, _options) {
+        throw new Error('Foreign Data Wrappers are not supported by MariaDB. This is a PostgreSQL-specific feature.');
+    }
+    async dropForeignServer(_serverName, _options) {
+        throw new Error('Foreign Data Wrappers are not supported by MariaDB. This is a PostgreSQL-specific feature.');
+    }
+    async createForeignTable(_tableName, _columns, _options) {
+        throw new Error('Foreign Data Wrappers are not supported by MariaDB. This is a PostgreSQL-specific feature.');
+    }
+    async changeOwner(_newOwner, _tableName) {
+        throw new Error('changeOwner is not supported in MariaDB');
+    }
+    async addConstraint(_tableName, _options) {
+        throw new Error('addConstraint is not supported in MariaDB');
+    }
+    async removeConstraint(_tableName, _constraintName) {
+        throw new Error('removeConstraint is not supported in MariaDB');
+    }
+    async createSecurityPolicy(_policyName, _tableName, _options) {
+        throw new Error('Security policies are not supported in MariaDB');
+    }
+    async dropSecurityPolicy(_policyName, _tableName) {
+        throw new Error('Security policies are not supported in MariaDB');
+    }
+    // ==================== Materialized Views ====================
+    // MariaDB does not have native materialized views, so we emulate them
+    /**
+     * Create a materialized view (emulated using a table)
+     * MariaDB does not support native materialized views, so we create a table
+     * that can be refreshed manually
+     */
+    async createMaterializedView(options) {
+        const viewName = options.schema
+            ? `${this.escapeId(options.schema)}.${this.escapeId(options.name)}`
+            : this.escapeId(options.name);
+        // Drop existing view if replace is specified
+        if (options.replace) {
+            try {
+                await this.dropMaterializedView(options.name, { schema: options.schema, ifExists: true });
+            }
+            catch {
+                // Ignore if doesn't exist
+            }
+        }
+        else if (options.ifNotExists) {
+            const exists = await this.hasMaterializedView(options.name);
+            if (exists) {
+                return;
+            }
+        }
+        // Create table as the materialized view
+        let sql = `CREATE TABLE ${viewName} AS ${options.query}`;
+        await this.query(sql);
+        // Store the original query in comment (for refresh support)
+        const commentValue = options.comment
+            ? `mv_query:${options.query} | ${options.comment}`
+            : `mv_query:${options.query}`;
+        await this.query(`ALTER TABLE ${viewName} COMMENT ${this.escape(commentValue)}`);
+    }
+    /**
+     * Refresh a materialized view (emulated)
+     * Drops and recreates the table with fresh data
+     */
+    async refreshMaterializedView(viewName, options) {
+        const schema = options?.schema || this.config.database || '';
+        const fullViewName = schema
+            ? `${this.escapeId(schema)}.${this.escapeId(viewName)}`
+            : this.escapeId(viewName);
+        // Get the original query from the comment (stored during creation)
+        const result = await this.query(`SELECT TABLE_COMMENT FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = ${this.escape(viewName)} AND TABLE_SCHEMA = ${this.escape(schema)}`, { raw: true });
+        if (!result.rows || result.rows.length === 0) {
+            throw new Error(`Materialized view ${viewName} does not exist`);
+        }
+        const comment = result.rows[0]?.TABLE_COMMENT;
+        if (!comment || !comment.startsWith('mv_query:')) {
+            throw new Error(`Cannot refresh materialized view ${viewName}: original query not found. Recreate the view using createMaterializedView().`);
+        }
+        const originalQuery = comment.replace('mv_query:', '');
+        // Drop and recreate the table
+        await this.query(`DROP TABLE ${fullViewName}`);
+        let sql = `CREATE TABLE ${fullViewName} AS ${originalQuery}`;
+        await this.query(sql);
+    }
+    /**
+     * Drop a materialized view (emulated)
+     */
+    async dropMaterializedView(viewName, options) {
+        const schema = options?.schema || this.config.database || '';
+        const ifExists = options?.ifExists ? 'IF EXISTS ' : '';
+        const cascade = options?.cascade ? ' CASCADE' : '';
+        const fullViewName = schema
+            ? `${this.escapeId(schema)}.${this.escapeId(viewName)}`
+            : this.escapeId(viewName);
+        const sql = `DROP TABLE ${ifExists}${fullViewName}${cascade}`;
+        await this.query(sql);
+    }
+    /**
+     * Check if a materialized view exists (emulated)
+     * Checks for tables with mv_query: prefix in comment
+     */
+    async hasMaterializedView(viewName) {
+        const sql = `SELECT 1 FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = ${this.escape(viewName)} AND TABLE_COMMENT LIKE 'mv_query:%'`;
+        const result = await this.query(sql, { plain: true });
+        return !!result;
+    }
+    /**
+     * Show all materialized views (emulated)
+     * Lists tables with mv_query: prefix in comment
+     */
+    async showMaterializedViews() {
+        const result = await this.query(`SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_COMMENT LIKE 'mv_query:%' ORDER BY TABLE_NAME`, { raw: true });
+        return result.rows?.map((row) => row.TABLE_NAME) || [];
+    }
+    // ==================== Event Scheduler ====================
+    // MariaDB fully supports the MySQL event scheduler syntax (CREATE/ALTER/DROP EVENT,
+    // SHOW EVENTS, ON SCHEDULE AT/EVERY, ON COMPLETION [NOT] PRESERVE). The event_scheduler
+    // system variable must be turned ON for events to actually run, same as MySQL.
+    /**
+     * Create an event (MariaDB 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);
+    }
+    /**
+     * Create a PostgreSQL extension (not supported by MariaDB)
+     */
+    async createExtension(_extensionName, _options) {
+        throw new Error('Extensions are not supported by MariaDB. This is a PostgreSQL-specific feature.');
+    }
+    /**
+     * Drop a PostgreSQL extension (not supported by MariaDB)
+     */
+    async dropExtension(_extensionName, _options) {
+        throw new Error('Extensions are not supported by MariaDB. This is a PostgreSQL-specific feature.');
+    }
+    /**
+     * Get all installed PostgreSQL extensions (not supported by MariaDB)
+     */
+    async getExtensions() {
+        throw new Error('Extensions are not supported by MariaDB. This is a PostgreSQL-specific feature.');
+    }
+    /**
+     * Check if a PostgreSQL extension is installed (not supported by MariaDB)
+     */
+    async hasExtension(_extensionName) {
+        throw new Error('Extensions are not supported by MariaDB. This is a PostgreSQL-specific feature.');
+    }
+    /**
+     * Add an index to a table
+     * Supports expression indexes and INCLUDE columns (MariaDB 10.0+)
+     */
+    async addIndex(tableName, indexName, fields = [], options) {
+        let sql = 'CREATE';
+        if (options?.unique) {
+            sql += ' UNIQUE';
+        }
+        if (options?.type) {
+            // MariaDB requires the index-type keyword (e.g. FULLTEXT, SPATIAL)
+            // immediately before INDEX: `CREATE FULLTEXT INDEX ...`, not
+            // `CREATE INDEX FULLTEXT ...` (which is a syntax error).
+            sql += ` ${options.type} INDEX`;
+        }
+        else {
+            sql += ' INDEX';
+        }
+        sql += ` ${this.escapeId(indexName)} ON ${this.escapeId(tableName)}`;
+        // Handle expression index (MariaDB 10.0+)
+        if (options?.expression) {
+            sql += ` ((${options.expression}))`;
+        }
+        else {
+            sql += ` (${fields.map((f) => this.escapeId(f)).join(', ')})`;
+        }
+        if (options?.using) {
+            sql += ` USING ${options.using}`;
+        }
+        // Add INCLUDE columns for covering index (MariaDB 10.2.3+)
+        if (options?.include && options.include.length > 0) {
+            sql += ` INCLUDE (${options.include.map((f) => this.escapeId(f)).join(', ')})`;
+        }
+        // Add WHERE clause for partial index (MariaDB 10.0.3+)
+        if (options?.where && Object.keys(options.where).length > 0) {
+            const whereClause = this.buildWhereClause(options.where);
+            sql += ` WHERE ${whereClause.sql}`;
+        }
+        // Index visibility (MariaDB 10.6+). Unlike MySQL, MariaDB uses the
+        // `IGNORED` keyword for indexes (not `INVISIBLE` — that keyword is
+        // reserved for columns in MariaDB). Ignored indexes are still
+        // maintained but skipped by the optimizer. Indexes are not ignored
+        // by default.
+        if (options?.invisible) {
+            sql += ' IGNORED';
+        }
+        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 a partial index (index with WHERE clause)
+     * MariaDB supports partial indexes since version 10.0.3
+     */
+    async createPartialIndex(tableName, indexName, fields, where, options) {
+        const fieldsSql = fields.map((f) => this.escapeId(f)).join(', ');
+        let sql = `CREATE INDEX ${this.escapeId(indexName)} ON ${this.quoteTable(tableName)} (${fieldsSql}) WHERE ${where}`;
+        if (options?.unique)
+            sql = sql.replace('CREATE INDEX', 'CREATE UNIQUE INDEX');
+        await this.query(sql);
+    }
+    /**
+     * Create an index on a table with full options support
+     */
+    async createIndex(tableName, indexDef) {
+        const fields = indexDef.fields || [];
+        let sql = 'CREATE';
+        if (indexDef.unique) {
+            sql += ' UNIQUE';
+        }
+        if (indexDef.type) {
+            // MariaDB requires the index-type keyword (e.g. FULLTEXT, SPATIAL)
+            // immediately before INDEX: `CREATE FULLTEXT INDEX ...`, not
+            // `CREATE INDEX FULLTEXT ...` (which is a syntax error).
+            sql += ` ${indexDef.type} INDEX`;
+        }
+        else {
+            sql += ' INDEX';
+        }
+        sql += ` ${this.escapeId(indexDef.name)} ON ${this.escapeId(tableName)}`;
+        sql += ` (${fields.map((f) => this.escapeId(f)).join(', ')})`;
+        if (indexDef.using) {
+            sql += ` USING ${indexDef.using}`;
+        }
+        // Add WHERE clause for partial index (MariaDB 10.0.3+)
+        if (indexDef.where && Object.keys(indexDef.where).length > 0) {
+            const whereClause = this.buildWhereClause(indexDef.where);
+            sql += ` WHERE ${whereClause.sql}`;
+        }
+        // Index visibility (MariaDB 10.6+). Unlike MySQL, MariaDB uses
+        // `IGNORED` (not `INVISIBLE`) for indexes. Not ignored by default.
+        if (indexDef.invisible) {
+            sql += ' IGNORED';
+        }
+        await this.query(sql);
+    }
+    /**
+     * Toggle visibility of an existing column (MariaDB 10.3+).
+     *
+     * Unlike MySQL 8 (`ALTER TABLE ... ALTER COLUMN col SET VISIBLE|INVISIBLE`),
+     * MariaDB has no `ALTER COLUMN ... SET INVISIBLE` syntax at all (confirmed
+     * against a live server: `ERROR 1064 ... near 'INVISIBLE'`). MariaDB only
+     * supports the `INVISIBLE` keyword as part of a full column redefinition
+     * via `ALTER TABLE ... MODIFY col_definition [INVISIBLE]`, so this reads
+     * the column's current definition first and reissues it with the
+     * visibility keyword added or omitted. 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 description = await this.describeTable(tableName);
+        const column = description[columnName];
+        if (!column) {
+            throw new Error(`Column '${columnName}' not found on table '${tableName}'`);
+        }
+        let sql = `ALTER TABLE ${this.escapeId(tableName)} MODIFY ${this.escapeId(columnName)} ${column.type}`;
+        sql += column.allowNull ? ' NULL' : ' NOT NULL';
+        if (column.defaultValue !== null && column.defaultValue !== undefined) {
+            const isRawDefault = /^(CURRENT_TIMESTAMP|NULL)\b/i.test(String(column.defaultValue)) ||
+                /\(.*\)/.test(String(column.defaultValue));
+            sql += ` DEFAULT ${isRawDefault ? column.defaultValue : this.escape(column.defaultValue)}`;
+        }
+        if (column.autoIncrement) {
+            sql += ' AUTO_INCREMENT';
+        }
+        // MariaDB only recognizes the `INVISIBLE` keyword; there is no
+        // corresponding `VISIBLE` keyword to make it explicit (confirmed
+        // against a live server: `ERROR 1064 ... near 'VISIBLE'`) — a column
+        // is visible simply by omitting `INVISIBLE`.
+        if (invisible) {
+            sql += ' INVISIBLE';
+        }
+        await this.query(sql);
+    }
+    /**
+     * Toggle visibility of an existing index (MariaDB 10.6+).
+     *
+     * Uses `ALTER TABLE ... ALTER INDEX ... [NOT] IGNORED`. Unlike MySQL,
+     * which uses `VISIBLE`/`INVISIBLE` for indexes, MariaDB reserves those
+     * keywords for columns and instead marks indexes as "ignored" by the
+     * optimizer (the index is still maintained, just skipped during query
+     * planning). A table's primary key cannot be ignored.
+     *
+     * @param tableName - Name of the table
+     * @param indexName - Name of the index to toggle
+     * @param invisible - true to mark the index IGNORED, false to mark it NOT IGNORED
+     */
+    async alterIndexVisibility(tableName, indexName, invisible) {
+        const sql = `ALTER TABLE ${this.escapeId(tableName)} ALTER INDEX ${this.escapeId(indexName)} ${invisible ? 'IGNORED' : 'NOT IGNORED'}`;
+        await this.query(sql);
+    }
+    /**
+     * 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)}`;
+        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})`);
+                return;
+            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})`);
+                return;
+            case 'FOREIGN KEY': {
+                if (!fields || !constraintDef.references) {
+                    throw new Error('Foreign key constraint requires fields and references');
+                }
+                let sql = `ALTER TABLE ${this.escapeId(tableName)} ADD CONSTRAINT ${this.escapeId(constraintDef.name)} `;
+                sql += `FOREIGN KEY (${fields}) REFERENCES ${this.escapeId(constraintDef.references.table)}(${this.escapeId(constraintDef.references.field)})`;
+                if (constraintDef.references.onDelete) {
+                    sql += ` ON DELETE ${constraintDef.references.onDelete}`;
+                }
+                if (constraintDef.references.onUpdate) {
+                    sql += ` ON UPDATE ${constraintDef.references.onUpdate}`;
+                }
+                await this.query(sql);
+                return;
+            }
+            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})`);
+                return;
+            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 MariaDBTransaction(connection, options);
+        return transaction;
+    }
+    /**
+     * Commit a transaction
+     */
+    async commitTransaction(transaction) {
+        const mariaDbTx = transaction;
+        if (mariaDbTx.connection) {
+            await mariaDbTx.connection.commit();
+            mariaDbTx.connection.release();
+            mariaDbTx.finished = true;
+        }
+    }
+    /**
+     * Rollback a transaction
+     */
+    async rollbackTransaction(transaction) {
+        const mariaDbTx = transaction;
+        if (mariaDbTx.connection) {
+            await mariaDbTx.connection.rollback();
+            mariaDbTx.connection.release();
+            mariaDbTx.finished = true;
+        }
+    }
+    /**
+     * Get the SQL for a data type with MariaDB-specific types
+     */
+    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':
+                // MariaDB-specific text types
+                if (dt.length === 65535)
+                    return 'TEXT';
+                if (dt.length === 16777215)
+                    return 'MEDIUMTEXT';
+                if (dt.length === 4294967295)
+                    return 'LONGTEXT';
+                if (dt.length === 255)
+                    return 'TINYTEXT';
+                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':
+                // MariaDB has native BOOLEAN type
+                return 'BOOLEAN';
+            case 'DATE':
+                return dt.precision ? `DATETIME(${dt.precision})` : 'DATETIME';
+            case 'DATEONLY':
+                return 'DATE';
+            case 'TIME':
+                return dt.precision ? `TIME(${dt.precision})` : 'TIME';
+            case 'BLOB':
+                // MariaDB-specific blob types
+                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':
+                // MariaDB 10.2+ has native JSON support
+                return 'JSON';
+            case 'JSONB':
+                return 'JSON';
+            case 'UUID':
+                return 'CHAR(36)';
+            case 'GEOMETRY':
+                return 'GEOMETRY';
+            case 'VIRTUAL':
+                // MariaDB-specific virtual columns
+                return 'VIRTUAL';
+            case 'STORED':
+                return 'STORED';
+            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 title = ?` bound to `{ [Symbol(match)]: {...} }`) instead of
+            // the intended SQL — a real MariaDB server then matches nothing.
+            // (Ported from the equivalent, already-existing normalization in
+            // src/dialects/mysql/index.ts, which mariadb's buildWhereClause never
+            // had.)
+            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. `{ title: { [Op.match]: ... } }`).
+                    const rawValueObj = value;
+                    const symbolKeys = Object.getOwnPropertySymbols(rawValueObj);
+                    const normalizedObj = {
+                        ...rawValueObj,
+                    };
+                    for (const sym of symbolKeys) {
+                        const strKey = (0, operators_1.operatorToWhereKey)(sym);
+                        if (strKey)
+                            normalizedObj[strKey] = rawValueObj[sym];
+                    }
+                    const valueObj = normalizedObj;
+                    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.$regexp !== undefined) {
+                        values.push(valueObj.$regexp);
+                        fieldConditions.push(`${this.escapeId(key)} REGEXP ?`);
+                    }
+                    else if (valueObj.$match !== undefined) {
+                        // MariaDB full-text search: MATCH(columns) AGAINST(term [mode]).
+                        // Format: { $match: 'term' } or
+                        // { $match: { columns, mode, searchTerm } }. MATCH()'s column
+                        // list must exactly match the column list of a FULLTEXT index
+                        // on the table (in natural-language mode), so callers that
+                        // indexed multiple columns together need to pass all of them
+                        // via `columns`, not rely on the single `key` the condition is
+                        // attached to. (Ported from the equivalent, already-existing
+                        // handling in src/dialects/mysql/index.ts, which mariadb's
+                        // buildWhereClause never had.)
+                        const matchValue = valueObj.$match;
+                        const searchTerm = typeof matchValue === 'string'
+                            ? matchValue
+                            : (matchValue?.searchTerm ?? '');
+                        const matchColumns = matchValue?.columns || [key];
+                        const matchMode = matchValue?.mode;
+                        const modeSql = matchMode === 'boolean'
+                            ? 'IN BOOLEAN MODE'
+                            : matchMode === 'query expansion'
+                                ? 'WITH QUERY EXPANSION'
+                                : 'IN NATURAL LANGUAGE MODE';
+                        const columnList = matchColumns.map((c) => this.escapeId(c)).join(', ');
+                        values.push(searchTerm);
+                        fieldConditions.push(`MATCH(${columnList}) AGAINST(? ${modeSql})`);
+                    }
+                    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) {
+            // MariaDB (like MySQL) does not support OFFSET without LIMIT. Use the
+            // documented maximum unsigned BIGINT as the LIMIT to return all rows.
+            sql += ` LIMIT 18446744073709551615 OFFSET ${Number(offset)}`;
+        }
+        return sql;
+    }
+    /**
+     * Build an INSERT query with MariaDB ON DUPLICATE KEY UPDATE support
+     */
+    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(', ')})`;
+        // MariaDB supports ON DUPLICATE KEY UPDATE (same as MySQL)
+        if (options?.upsert) {
+            const updateColumns = columns
+                .map((c) => `${this.escapeId(c)} = VALUES(${this.escapeId(c)})`)
+                .join(', ');
+            sql += ` ON DUPLICATE KEY UPDATE ${updateColumns}`;
+        }
+        // MariaDB 10.5+ supports ON CONFLICT DO NOTHING
+        // This would require additional logic for MariaDB-specific upsert handling
+        // MariaDB 10.5+ supports RETURNING on plain INSERT (unlike MySQL), but
+        // MariaDB rejects RETURNING when combined with ON DUPLICATE KEY UPDATE.
+        // Suppress RETURNING in that case.
+        if (options?.returning && !options?.upsert) {
+            const returningCols = options.returning === true
+                ? '*'
+                : options.returning.map((c) => this.escapeId(c)).join(', ');
+            sql += ` RETURNING ${returningCols}`;
+        }
+        return { sql, values: processedValues };
+    }
+    /**
+     * Build an UPSERT query for MariaDB
+     * Uses ON DUPLICATE KEY UPDATE syntax (same as MySQL)
+     */
+    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(', ')})`;
+        // Add ON DUPLICATE KEY UPDATE clause
+        const updateClauses = updateFields
+            .map((c) => `${this.escapeId(c)} = VALUES(${this.escapeId(c)})`)
+            .join(', ');
+        sql += ` ON DUPLICATE KEY UPDATE ${updateClauses}`;
+        // MariaDB rejects RETURNING when combined with ON DUPLICATE KEY UPDATE,
+        // which this query always uses. RETURNING is therefore intentionally
+        // not appended here.
+        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}`;
+        }
+        // MariaDB 10.5+ supports RETURNING on plain UPDATE (unlike MySQL)
+        if (options?.returning) {
+            const returningCols = options.returning === true
+                ? '*'
+                : options.returning.map((c) => this.escapeId(c)).join(', ');
+            sql += ` RETURNING ${returningCols}`;
+        }
+        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}`;
+        }
+        // MariaDB 10.5+ supports RETURNING on plain DELETE (unlike MySQL)
+        if (options?.returning) {
+            const returningCols = options.returning === true
+                ? '*'
+                : options.returning.map((c) => this.escapeId(c)).join(', ');
+            sql += ` RETURNING ${returningCols}`;
+        }
+        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) {
+            // Note: this `exclude` is a Prorm-style attribute exclusion list
+            // (i.e. "select all columns except these"), unrelated to the SQL
+            // EXCEPT set operator. MariaDB doesn't expose column introspection
+            // here, so we fall back to `SELECT *`.
+            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)} LIKE ${paramChar}`; // MariaDB uses LIKE for case-insensitive
+                        values.push(opValue);
+                    }
+                    else if (opKey === 'Symbol(notILike)' || opKey === 'Symbol(operators.notILike)') {
+                        sql = `${this.escapeId(key)} NOT LIKE ${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 SELECT query with support for Common Table Expressions (CTEs)
+     */
+    buildSelectQuery(options) {
+        const queryValues = [];
+        // Handle CTE (WITH clause) if present. Supports plain CTEs, MariaDB
+        // 10.2+ `WITH RECURSIVE` (any CTE in the list marked `recursive: true`
+        // promotes the whole WITH clause to `WITH RECURSIVE`, matching MariaDB's
+        // single-keyword-per-statement grammar), and the MariaDB 10.6+
+        // `CYCLE ... SET ... USING` cycle-detection clause.
+        let cteSql = '';
+        if (options.cte) {
+            const cte = options.cte;
+            const isRecursive = cte.some((c) => c.recursive);
+            cteSql = cte
+                .map((c) => {
+                const columns = c.columns ? `(${c.columns.join(', ')})` : '';
+                let cteDef = `${this.escapeId(c.name)}${columns} AS (${c.query})`;
+                if (c.cycle) {
+                    const cycleCols = c.cycle.columns.map((col) => this.escapeId(col)).join(', ');
+                    const setValue = c.cycle.setValue !== undefined ? ` TO ${c.cycle.setValue}` : '';
+                    const defaultValue = c.cycle.defaultValue !== undefined ? ` DEFAULT ${c.cycle.defaultValue}` : '';
+                    cteDef += ` CYCLE ${cycleCols} SET ${this.escapeId(c.cycle.setColumn)}${setValue}${defaultValue} USING ${this.escapeId(c.cycle.usingColumn)}`;
+                }
+                return cteDef;
+            })
+                .join(', ');
+            cteSql = `WITH ${isRecursive ? 'RECURSIVE ' : ''}${cteSql} `;
+        }
+        // Build SELECT clause. Delegate to `buildSelectClause`, which understands
+        // fn()/col()/literal() expressions and `[expr, alias]` tuples (the same
+        // shape produced by the window-function builders in
+        // `src/query-builders/functions/window.ts`, e.g. `rowNumber().as('rn')`).
+        // Previously this duplicated a narrower inline implementation that called
+        // `this.escapeId(a)` on every attribute unconditionally, which silently
+        // mangled any non-string attribute (window-function tuples included)
+        // into garbage identifiers instead of passing them through.
+        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 = `${cteSql}SELECT ${distinctClause}${selectSql} FROM ${this.escapeId(options.tableName)}`;
+        // MariaDB 10.3+ system-versioned (temporal) table querying:
+        // `FOR SYSTEM_TIME AS OF ...` / `BETWEEN ... AND ...` / `FROM ... TO ...`
+        // / `ALL`. This is a MariaDB/SQL:2011 feature MySQL lacks entirely.
+        const forSystemTime = options.forSystemTime;
+        if (forSystemTime) {
+            switch (forSystemTime.type) {
+                case 'ALL':
+                    sql += ' FOR SYSTEM_TIME ALL';
+                    break;
+                case 'AS_OF':
+                    sql += ' FOR SYSTEM_TIME AS OF ?';
+                    queryValues.push(forSystemTime.timestamp);
+                    break;
+                case 'BETWEEN':
+                    sql += ' FOR SYSTEM_TIME BETWEEN ? AND ?';
+                    queryValues.push(forSystemTime.start, forSystemTime.end);
+                    break;
+                case 'FROM_TO':
+                    sql += ' FOR SYSTEM_TIME FROM ? TO ?';
+                    queryValues.push(forSystemTime.start, forSystemTime.end);
+                    break;
+                default:
+                    break;
+            }
+        }
+        // Build JOIN clause (for includes)
+        if (options.include && options.include.length > 0) {
+            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 skipLocked = false;
+            let noWait = false;
+            if (options.lock === true) {
+                lockType = 'UPDATE';
+            }
+            else if (typeof options.lock === 'string') {
+                lockType = options.lock;
+            }
+            else if (typeof options.lock === 'object' && options.lock !== null) {
+                // lock: { of: Model, mode: 'UPDATE' | 'SHARE', skipLocked?, noWait? }
+                lockType = options.lock.mode || (options.lock.of ? 'UPDATE' : undefined);
+                skipLocked = !!options.lock.skipLocked;
+                noWait = !!options.lock.noWait;
+            }
+            if (lockType === 'UPDATE') {
+                sql += ' FOR UPDATE';
+            }
+            else if (lockType === 'SHARE') {
+                // MariaDB 10.6+ prefers `FOR SHARE` over the legacy `LOCK IN SHARE MODE`
+                // syntax, but only `LOCK IN SHARE MODE` supports no modifiers, so use
+                // `FOR SHARE` whenever a SKIP LOCKED/NOWAIT modifier is requested.
+                if (skipLocked || noWait) {
+                    sql += ' FOR SHARE';
+                }
+                else {
+                    sql += ' LOCK IN SHARE MODE';
+                }
+            }
+            // MariaDB 10.6+ locking modifiers
+            if (lockType === 'UPDATE' || lockType === 'SHARE') {
+                if (skipLocked) {
+                    sql += ' SKIP LOCKED';
+                }
+                else if (noWait) {
+                    sql += ' NOWAIT';
+                }
+            }
+        }
+        // Build UNION/EXCEPT/INTERSECT clause if provided
+        // MariaDB 10.3+ supports EXCEPT/EXCEPT ALL/INTERSECT/INTERSECT ALL in
+        // addition to UNION/UNION ALL.
+        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
+    // MariaDB syntax is nearly identical to MySQL; the only notable difference is
+    // that roles are created without quotes (CREATE ROLE rolename).
+    // ---------------------------------------------------------------------------
+    /**
+     * 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 MariaDB user identity as  'username'@'host'
+     */
+    formatUserIdentity(username, host = '%') {
+        return `'${username}'@'${host}'`;
+    }
+    /**
+     * Format a MariaDB privilege scope.
+     */
+    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}`;
+        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)}'`;
+        }
+        if (options.requireSSL === true)
+            sql += ' REQUIRE SSL';
+        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(' ')}`;
+        if (options.expirePassword != null) {
+            if (options.expirePassword === true)
+                sql += ' PASSWORD EXPIRE';
+            else if (options.expirePassword === false)
+                sql += ' PASSWORD EXPIRE NEVER';
+            else
+                sql += ' PASSWORD EXPIRE DEFAULT';
+        }
+        if (options.accountLocked === true)
+            sql += ' ACCOUNT LOCK';
+        if (options.accountLocked === false)
+            sql += ' ACCOUNT UNLOCK';
+        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}`;
+        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)}'`;
+        }
+        if (options.requireSSL === true) {
+            sql += ' REQUIRE SSL';
+        }
+        else if (options.requireSSL === 'NONE' || options.requireSSL === false) {
+            sql += ' REQUIRE NONE';
+        }
+        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(' ')}`;
+        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`;
+        }
+        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';
+    }
+    buildGrantQuery(options) {
+        const { scopeSql, columnPrefix } = this.formatPrivilegeScope(options.on);
+        const privList = options.privileges.join(', ');
+        const grantPriv = columnPrefix !== null ? `${privList} (${columnPrefix})` : privList;
+        const recipients = (Array.isArray(options.to) ? options.to : [options.to])
+            .map((u) => (u.includes('@') ? u : 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(', ');
+        const revokePriv = columnPrefix !== null ? `${privList} (${columnPrefix})` : privList;
+        const targets = (Array.isArray(options.from) ? options.from : [options.from])
+            .map((u) => (u.includes('@') ? u : this.formatUserIdentity(u, options.host ?? '%')))
+            .join(', ');
+        if (options.grantOptionFor) {
+            return `REVOKE GRANT OPTION FOR ${revokePriv} ON ${scopeSql} FROM ${targets}`;
+        }
+        return `REVOKE ${revokePriv} ON ${scopeSql} FROM ${targets}`;
+    }
+    buildShowGrantsQuery(username, host = '%') {
+        return `SHOW GRANTS FOR ${this.formatUserIdentity(username, host)}`;
+    }
+    buildFlushPrivilegesQuery() {
+        return 'FLUSH PRIVILEGES';
+    }
+    // ---- Roles (MariaDB) ----
+    // MariaDB uses unquoted role names in CREATE / DROP ROLE.
+    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';
+    }
+    /**
+     * Replace placeholders in SQL with actual values
+     * Supports both named (:param) and positional (?) placeholders
+     * @param sql - SQL string with placeholders
+     * @param replacements - Values to replace (object for named, array for positional)
+     * @returns SQL with placeholders replaced with escaped values
+     */
+    replaceReplacements(sql, replacements) {
+        if (!replacements)
+            return sql;
+        let result = sql;
+        if (Array.isArray(replacements)) {
+            // Positional placeholders (?)
+            let index = 0;
+            result = sql.replace(/\?/g, () => {
+                if (index >= replacements.length) {
+                    return '?';
+                }
+                const value = replacements[index++];
+                return this.escape(value);
+            });
+        }
+        else {
+            // Named placeholders (:param)
+            for (const [key, value] of Object.entries(replacements)) {
+                const placeholder = new RegExp(`:${key}\\b`, 'g');
+                result = result.replace(placeholder, this.escape(value));
+            }
+        }
+        return result;
+    }
+    // ---------------------------------------------------------------------------
+    // Foreign Data Wrapper methods (PostgreSQL only - not supported in MariaDB)
+    // ---------------------------------------------------------------------------
+    /**
+     * Build a CREATE SERVER query for foreign data wrappers (PostgreSQL only)
+     */
+    buildCreateServerQuery(_name, _opts) {
+        throw new Error('Foreign Data Wrappers are not supported by MariaDB. This is a PostgreSQL-specific feature.');
+    }
+    /**
+     * Build an ALTER SERVER query for foreign data wrappers (PostgreSQL only)
+     */
+    buildAlterServerQuery(_name, _opts) {
+        throw new Error('Foreign Data Wrappers are not supported by MariaDB. This is a PostgreSQL-specific feature.');
+    }
+    /**
+     * Build a DROP SERVER query for foreign data wrappers (PostgreSQL only)
+     */
+    buildDropServerQuery(_name, _opts) {
+        throw new Error('Foreign Data Wrappers are not supported by MariaDB. This is a PostgreSQL-specific feature.');
+    }
+    /**
+     * Build a CREATE USER MAPPING query for foreign data wrappers (PostgreSQL only)
+     */
+    buildCreateUserMappingQuery(_opts) {
+        throw new Error('Foreign Data Wrappers are not supported by MariaDB. This is a PostgreSQL-specific feature.');
+    }
+    /**
+     * Build an ALTER USER MAPPING query for foreign data wrappers (PostgreSQL only)
+     */
+    buildAlterUserMappingQuery(_opts) {
+        throw new Error('Foreign Data Wrappers are not supported by MariaDB. This is a PostgreSQL-specific feature.');
+    }
+    /**
+     * Build a DROP USER MAPPING query for foreign data wrappers (PostgreSQL only)
+     */
+    buildDropUserMappingQuery(_serverName, _user, _opts) {
+        throw new Error('Foreign Data Wrappers are not supported by MariaDB. This is a PostgreSQL-specific feature.');
+    }
+    /**
+     * Build a CREATE FOREIGN TABLE query for foreign data wrappers (PostgreSQL only)
+     */
+    buildCreateForeignTableQuery(_tableName, _opts) {
+        throw new Error('Foreign Data Wrappers are not supported by MariaDB. This is a PostgreSQL-specific feature.');
+    }
+    /**
+     * Build a DROP FOREIGN TABLE query for foreign data wrappers (PostgreSQL only)
+     */
+    buildDropForeignTableQuery(_tableName, _opts) {
+        throw new Error('Foreign Data Wrappers are not supported by MariaDB. This is a PostgreSQL-specific feature.');
+    }
+    /**
+     * Build an IMPORT FOREIGN SCHEMA query for foreign data wrappers (PostgreSQL only)
+     */
+    buildImportForeignSchemaQuery(_remoteSchema, _serverName, _opts) {
+        throw new Error('Foreign Data Wrappers are not supported by MariaDB. This is a PostgreSQL-specific feature.');
+    }
+    /**
+     * Get query to list foreign servers (PostgreSQL only)
+     */
+    getServersQuery() {
+        throw new Error('Foreign Data Wrappers are not supported by MariaDB. This is a PostgreSQL-specific feature.');
+    }
+    /**
+     * Generate SQL for creating a MariaDB 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 MariaDB 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}`;
+    }
+    /**
+     * 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`;
+        let sql = `ALTER TABLE ${this.quoteTable(tableName)} ADD CONSTRAINT ${this.escapeId(constraintName)} FOREIGN KEY (${this.escapeId(columnName)}) REFERENCES ${this.quoteTable(referencedTableName)}(${this.escapeId(referencedColumnName)})`;
+        const clauses = [];
+        if (options?.onDelete) {
+            clauses.push(`ON DELETE ${options.onDelete}`);
+        }
+        if (options?.onUpdate) {
+            clauses.push(`ON UPDATE ${options.onUpdate}`);
+        }
+        if (clauses.length > 0) {
+            sql += ' ' + clauses.join(' ');
+        }
+        await this.query(sql);
+    }
+    /**
+     * Rename a column
+     */
+    async renameColumn(tableName, oldColumnName, newColumnName) {
+        const 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 fulltext 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);
+    }
+    /**
+     * Create a spatial index
+     */
+    async createSpatialIndex(tableName, indexName, fields, options) {
+        const sql = `CREATE SPATIAL INDEX ${this.escapeId(indexName)} ON ${this.escapeId(tableName)} (${fields.map((f) => this.escapeId(f)).join(', ')})`;
+        await this.query(sql);
+    }
+    /**
+     * ST_Distance - calculate distance between two geometries
+     * MariaDB has provided the OGC-standard ST_ spatial function aliases since 10.1,
+     * so the syntax is identical to MySQL's.
+     */
+    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
+     * MariaDB 10.1+ 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
+     * MariaDB 10.1+ 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
+     * MariaDB 10.1+ 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
+     * MariaDB 10.1+ 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
+     * MariaDB 10.2.4+ spatial function
+     */
+    stGeomFromGeoJSON(geojson, srid) {
+        const sridStr = srid ? `, ${srid}` : '';
+        return `ST_GeomFromGeoJSON(${this.escape(geojson)}${sridStr})`;
+    }
+    /**
+     * ST_AsGeoJSON - convert geometry to GeoJSON
+     * MariaDB 10.2.4+ spatial function
+     */
+    stAsGeoJSON(geom) {
+        return `ST_AsGeoJSON(${geom})`;
+    }
+    /**
+     * ST_AsText - convert geometry to WKT
+     */
+    stAsText(geom) {
+        return `ST_AsText(${geom})`;
+    }
+    /**
+     * Create a user mapping (MariaDB doesn't support user mappings)
+     */
+    async createUserMapping(_userName, _serverName, _options) {
+        throw new Error('Foreign Data Wrappers are not supported by MariaDB. This is a PostgreSQL-specific feature.');
+    }
+    /**
+     * Drop a user mapping (MariaDB doesn't support user mappings)
+     */
+    async dropUserMapping(_userName, _serverName, _options) {
+        throw new Error('Foreign Data Wrappers are not supported by MariaDB. This is a PostgreSQL-specific feature.');
+    }
+    /**
+     * Build a JSON_TABLE expression to shred a JSON document/array into relational rows
+     * (MariaDB 10.6+). Useful to project a JSON array column into rows instead of a
+     * correlated subquery.
+     * MariaDB: 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)}`;
+    }
+}
+exports.MariaDBDialect = MariaDBDialect;
+/**
+ * MariaDB-specific transaction class
+ */
+class MariaDBTransaction {
+    constructor(connection, options) {
+        this.finished = false;
+        this.parent = null;
+        this.savepoints = [];
+        this.connection = null;
+        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;
+    }
+}
+exports.MariaDBTransaction = MariaDBTransaction;
+/**
+ * Create a new MariaDB dialect instance
+ */
+function createMariaDBDialect(options) {
+    return new MariaDBDialect(options || {});
+}
+/**
+ * MariaDB storage engines
+ */
+exports.MariaDBStorageEngines = {
+    INNODB: 'InnoDB',
+    ARIA: 'Aria',
+    XTRADB: 'XtraDB',
+    MYISAM: 'MyISAM',
+    MEMORY: 'MEMORY',
+    CONNECT: 'CONNECT',
+    CSV: 'CSV',
+    HEAP: 'HEAP',
+    MERGE: 'MERGE',
+    MRG_MYISAM: 'MRG_MyISAM',
+    BLACKHOLE: 'BLACKHOLE',
+    FEDERATED: 'Federated',
+    FEDERATEDX: 'FederatedX',
+};
+/**
+ * MariaDB CONNECT storage engine types
+ */
+exports.MariaDBConnectTypes = {
+    ODBC: 'ODBC',
+    JDBC: 'JDBC',
+    MYSQL: 'MYSQL',
+    XML: 'XML',
+    JSON: 'JSON',
+    CSV: 'CSV',
+    FMT: 'FMT',
+    DBF: 'DBF',
+    INI: 'INI',
+    WMI: 'WMI',
+    PROXY: 'PROXY',
+    XCOL: 'XCOL',
+    PIVOT: 'PIVOT',
+    VIR: 'VIR',
+    BLOB: 'BLOB',
+};
+/**
+ * MariaDB row formats
+ */
+exports.MariaDBRowFormats = {
+    DEFAULT: 'DEFAULT',
+    DYNAMIC: 'DYNAMIC',
+    FIXED: 'FIXED',
+    COMPRESSED: 'COMPRESSED',
+    REDUNDANT: 'REDUNDANT',
+    PAGE: 'PAGE',
+};
+exports.default = MariaDBDialect;