ts-prorm-orm 1.1.0 → 1.2.0

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

@@ -0,0 +1,1241 @@
+/**
+ * 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
+ */
+type Pool = any;
+type PoolConnection = any;
+import { Dialect, DialectOptions, ColumnDefinition, TableOptions, DropTableOptions, TableDescription, IndexOptions, InsertOptions, UpdateOptions, DeleteOptions, SelectOptions, UpsertQueryOptions, ViewOptions, DropViewOptions, DropSchemaOptions, CreateExtensionOptions, DropExtensionOptions, ExtensionInfo, MaterializedViewOptions, RefreshOptions, DropMaterializedViewOptions } from '../dialect';
+import { Transaction, TransactionOptions, QueryResult, QueryOptions, DataType, WhereOptions, Order, CreatePartitionOptions, AttachPartitionOptions, DetachPartitionOptions, StoredProcedureOptions, CreateProcedureOptions, DropStoredProcedureOptions, ExecuteStoredProcedureOptions, TriggerOptions, DropTriggerOptions, SequenceOptions, DropSequenceOptions, PolicyOptions, DropPolicyOptions, PartitionDefinition, CreateEventOptions, DropEventOptions, AlterEventOptions, StreamOptions } from '../../types';
+import { Readable } from 'stream';
+/**
+ * MariaDB-specific column options for enhanced features
+ */
+export interface MariaDBColumnDefinition extends ColumnDefinition {
+    /**
+     * Initial value for AUTO_INCREMENT
+     */
+    autoIncrementInit?: number;
+    /**
+     * For virtual columns - either 'VIRTUAL' or 'STORED'
+     */
+    generated?: 'VIRTUAL' | 'STORED';
+    /**
+     * Expression for generated (virtual) columns
+     */
+    generationExpression?: string;
+    /**
+     * Storage setting for CONNECT engine columns
+     */
+    storage?: string;
+    /**
+     * MariaDB-specific on delete constraint
+     */
+    onDelete?: 'RESTRICT' | 'CASCADE' | 'SET NULL' | 'NO ACTION' | 'SET DEFAULT';
+    /**
+     * MariaDB-specific on update constraint
+     */
+    onUpdate?: 'RESTRICT' | 'CASCADE' | 'SET NULL' | 'NO ACTION';
+}
+/**
+ * MariaDB-specific table options
+ */
+export interface MariaDBTableOptions extends TableOptions {
+    /**
+     * Storage engine (InnoDB, Aria, XtraDB, MyISAM, CONNECT, etc.)
+     */
+    engine?: string;
+    /**
+     * AUTO_INCREMENT initial value
+     */
+    autoIncrement?: number;
+    /**
+     * Row format (Dynamic, Fixed, Compressed, etc.)
+     */
+    rowFormat?: string;
+    /**
+     * Key block size
+     */
+    keyBlockSize?: number;
+    /**
+     * Table comment
+     */
+    tableComment?: string;
+    /**
+     * Check constraint
+     */
+    check?: string;
+    /**
+     * For CONNECT storage engine - specify the type
+     * (ODBC, JDBC, MYSQL, XML, JSON, CSV, etc.)
+     */
+    connectType?: string;
+    /**
+     * CONNECT storage engine options
+     */
+    connectOptions?: Record<string, string>;
+    /**
+     * Enable MariaDB 10.3+ system-versioned (application-time temporal) tables
+     * by emitting `WITH SYSTEM VERSIONING` after the table's other options.
+     * See https://mariadb.com/kb/en/system-versioned-tables/
+     */
+    systemVersioning?: boolean;
+}
+/**
+ * Options describing a MariaDB 10.3+ `FOR SYSTEM_TIME` temporal query
+ * clause, used with `SelectOptions` to query system-versioned tables.
+ */
+export type MariaDBSystemTimeOptions = {
+    type: 'ALL';
+} | {
+    type: 'AS_OF';
+    timestamp: string | Date;
+} | {
+    type: 'BETWEEN';
+    start: string | Date;
+    end: string | Date;
+} | {
+    type: 'FROM_TO';
+    start: string | Date;
+    end: string | Date;
+};
+/**
+ * Cycle-detection clause for a recursive CTE, added in MariaDB 10.6.
+ * Renders as `CYCLE <columns> SET <setColumn>[ TO <setValue> DEFAULT
+ * <defaultValue>] USING <usingColumn>`.
+ * See https://mariadb.com/kb/en/with-recursive-common-table-expressions-overview/
+ */
+export interface MariaDBCteCycleOptions {
+    /** Columns that must be tracked for cycle detection. */
+    columns: string[];
+    /** Boolean marker column set to indicate a cycle was detected. */
+    setColumn: string;
+    /** Value written to `setColumn` when a cycle is detected (default: `1`). */
+    setValue?: string | number;
+    /** Value written to `setColumn` when no cycle is detected (default: `0`). */
+    defaultValue?: string | number;
+    /** Column used internally to track the traversal path. */
+    usingColumn: string;
+}
+/**
+ * A single Common Table Expression definition, optionally recursive and/or
+ * with MariaDB 10.6 cycle detection.
+ */
+export interface MariaDBCteDefinition {
+    name: string;
+    columns?: string[];
+    query: string;
+    /** Emit `WITH RECURSIVE` for this (and the whole) CTE list. */
+    recursive?: boolean;
+    /** MariaDB 10.6+ `CYCLE ... SET ... USING` cycle-detection clause. */
+    cycle?: MariaDBCteCycleOptions;
+}
+/**
+ * MariaDB dialect class that implements the Dialect interface
+ * Extends MySQL compatibility with MariaDB-specific features
+ */
+export declare class MariaDBDialect implements Dialect {
+    readonly name = "mariadb";
+    readonly library = "mariadb";
+    private pool;
+    private _isConnected;
+    private config;
+    constructor(config: MariaDBDialectOptions);
+    /**
+     * Connect to the MariaDB database
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from the MariaDB database
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Get the current connection pool
+     */
+    getConnection(): Pool | null;
+    /**
+     * Check if connected
+     */
+    isConnected(): boolean;
+    /**
+     * Stream query results by paging through `sql` via repeated
+     * dialect-appropriate LIMIT/OFFSET queries (see
+     * `createPaginatedQueryStream()` in `src/dialects/query-stream-helper.ts`)
+     * instead of loading the whole result set into memory at once.
+     * @param sql - The SELECT statement to stream
+     * @param options - Streaming options (batch size, backpressure watermark, model mapping)
+     */
+    queryStream(sql: string, options?: StreamOptions): Readable;
+    /**
+     * Execute a raw SQL query with retry support
+     */
+    query(sql: string, options?: QueryOptions): Promise<QueryResult>;
+    /**
+     * Execute a function with retry logic for query execution
+     */
+    private executeWithRetry;
+    /**
+     * Escape a value for use in a query
+     */
+    escape(value: unknown): string;
+    /**
+     * Build a JSON extraction query for MariaDB
+     * MariaDB: JSON_EXTRACT(column, '$.path') and JSON_UNQUOTE(JSON_EXTRACT(...))
+     */
+    buildJsonExtract(column: string, path: string, asText?: boolean): string;
+    /**
+     * Build a JSON contains query for MariaDB
+     * MariaDB: JSON_CONTAINS(column, value[, path])
+     */
+    buildJsonContains(column: string, value: unknown, path?: string): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * Build a JSON has key query for MariaDB
+     * MariaDB: JSON_CONTAINS_PATH(column, 'one'|'all', '$.key')
+     */
+    buildJsonHasKey(column: string, key: string, type?: 'one' | 'all'): string;
+    /**
+     * Build a JSON path query for MariaDB
+     */
+    buildJsonPathQuery(column: string, path: string, value?: unknown, operator?: string): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * 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: string, pathValues: Record<string, unknown>): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * Build a JSON_REPLACE expression, updating values only at paths that already exist.
+     * MariaDB: JSON_REPLACE(column, '$.path1', ?, ...) (10.2.3+)
+     */
+    buildJsonReplace(column: string, pathValues: Record<string, unknown>): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * Build a JSON_INSERT expression, inserting values only at paths that do not already exist.
+     * MariaDB: JSON_INSERT(column, '$.path1', ?, ...) (10.2.3+)
+     */
+    buildJsonInsert(column: string, pathValues: Record<string, unknown>): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * Build a JSON_REMOVE expression to remove data at the given paths.
+     * MariaDB: JSON_REMOVE(column, '$.path1', '$.path2', ...) (10.2.3+)
+     */
+    buildJsonRemove(column: string, paths: string[]): string;
+    /**
+     * Build a JSON_MERGE_PATCH expression (RFC 7396 merge patch semantics: object keys
+     * set to JSON null remove the key; non-object values fully replace).
+     * MariaDB: JSON_MERGE_PATCH(column, ?, ?, ...) (10.2.4+)
+     */
+    buildJsonMergePatch(column: string, ...documents: unknown[]): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * Build a JSON_MERGE_PRESERVE expression (auto-wraps/merges without dropping keys or
+     * array members, unlike JSON_MERGE_PATCH). 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: string, ...documents: unknown[]): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * The MariaDB value types accepted by COLUMN_CREATE / COLUMN_ADD /
+     * COLUMN_GET. These map to the `AS <type>` cast used by COLUMN_GET and the
+     * inline `<value> AS <type>` annotation used by COLUMN_CREATE/COLUMN_ADD.
+     */
+    private static readonly DYNAMIC_COLUMN_TYPES;
+    private assertDynamicColumnType;
+    /**
+     * Build a `COLUMN_CREATE(key, value [AS type], ...)` expression that packs a
+     * set of named values into a MariaDB dynamic-column BLOB.
+     *
+     * @param pairs Ordered key -> value (or `{ value, type }`) map. `type` is an
+     *   optional MariaDB dynamic-column type applied as `value AS type`.
+     * @returns `{ sql, values }` with `?` placeholders for every key and value.
+     *
+     * @example
+     * buildColumnCreate({ color: 'blue', size: { value: 42, type: 'INTEGER' } })
+     * // COLUMN_CREATE(?, ?, ?, ? AS INTEGER)  values: ['color','blue','size',42]
+     */
+    buildColumnCreate(pairs: Record<string, unknown | {
+        value: unknown;
+        type?: string;
+    }>): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * Build a `COLUMN_ADD(column, key, value [AS type], ...)` expression that
+     * inserts/updates named values in an existing dynamic-column BLOB.
+     */
+    buildColumnAdd(column: string, pairs: Record<string, unknown | {
+        value: unknown;
+        type?: string;
+    }>): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * Build a `COLUMN_GET(column, key AS type)` expression that extracts a single
+     * value from a dynamic-column BLOB, cast to the requested MariaDB type
+     * (defaults to `CHAR`).
+     */
+    buildColumnGet(column: string, key: string, type?: string): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * Build a `COLUMN_DELETE(column, key, ...)` expression that removes one or
+     * more keys from a dynamic-column BLOB.
+     */
+    buildColumnDelete(column: string, ...keys: string[]): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * Build a `COLUMN_EXISTS(column, key)` predicate that returns 1 if the given
+     * key exists in the dynamic-column BLOB.
+     */
+    buildColumnExists(column: string, key: string): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * Build a `COLUMN_LIST(column)` expression returning a comma-separated list
+     * of the keys present in a dynamic-column BLOB.
+     */
+    buildColumnList(column: string): string;
+    /**
+     * Build a `COLUMN_CHECK(column)` predicate that validates a dynamic-column
+     * BLOB is well-formed.
+     */
+    buildColumnCheck(column: string): string;
+    /**
+     * Build a `COLUMN_JSON(column)` expression that serializes an entire
+     * dynamic-column BLOB to a JSON object.
+     */
+    buildColumnJson(column: string): string;
+    /**
+     * Escape a string for SQL
+     */
+    private escapeString;
+    /**
+     * Format a date for MariaDB
+     */
+    private formatDate;
+    /**
+     * Escape an identifier (table name, column name, etc.)
+     * MariaDB uses backticks for identifiers (same as MySQL)
+     */
+    escapeId(identifier: unknown): string;
+    /**
+     * Escape an array of identifiers
+     */
+    private escapeIdList;
+    /**
+     * Quote an identifier (column name, table name)
+     * MariaDB uses backticks for identifiers
+     */
+    quoteIdentifier(identifier: string): string;
+    /**
+     * Quote a table name
+     * Same as quoteIdentifier for MariaDB
+     */
+    quoteTable(tableName: string): string;
+    /**
+     * Get the database version
+     */
+    getDatabaseVersion(): Promise<string>;
+    /**
+     * Get MariaDB-specific version info
+     */
+    getMariaDBVersionInfo(): Promise<{
+        version: string;
+        versionNumber: number;
+        storageEngine: string;
+    }>;
+    /**
+     * Reset AUTO_INCREMENT for a table
+     */
+    resetAutoIncrement(tableName: string, newValue?: number): Promise<void>;
+    /**
+     * Get table status (includes additional MariaDB info)
+     */
+    getTableStatus(tableName?: string): Promise<Record<string, any>[]>;
+    /**
+     * Get table create statement
+     */
+    getCreateTable(tableName: string): Promise<string>;
+    /**
+     * Create a new table with MariaDB-specific options
+     */
+    createTable(tableName: string, columns: Record<string, ColumnDefinition>, options?: TableOptions): Promise<void>;
+    /**
+     * Build constraint SQL for table creation (MariaDB)
+     */
+    private buildConstraintSql;
+    /**
+     * Generate column definition SQL for MariaDB
+     */
+    private getColumnDefinitionSql;
+    /**
+     * Get default value SQL
+     */
+    private getDefaultValue;
+    /**
+     * Drop a table
+     */
+    dropTable(tableName: string, options?: DropTableOptions): Promise<void>;
+    /**
+     * 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
+     */
+    createPartitionedTable(tableName: string, columns: Record<string, ColumnDefinition>, options?: TableOptions & {
+        partitionBy: {
+            type: 'range' | 'list' | 'hash' | 'key' | 'linear key' | 'linear_hkey' | 'rows';
+            column: string | string[];
+        };
+        partitions?: PartitionDefinition[];
+    }): Promise<void>;
+    /**
+     * Create a partition for an existing partitioned table (MariaDB)
+     *
+     * @param options - Partition creation options
+     */
+    createPartition(options: CreatePartitionOptions): Promise<void>;
+    /**
+     * Attach a partition (MariaDB uses ADD PARTITION instead)
+     * Provided for PostgreSQL compatibility
+     *
+     * @param options - Partition attachment options
+     */
+    attachPartition(options: AttachPartitionOptions): Promise<void>;
+    /**
+     * Detach a partition (MariaDB does not support this operation)
+     *
+     * @param options - Partition detachment options
+     */
+    detachPartition(_options: DetachPartitionOptions): Promise<void>;
+    /**
+     * Drop a partition (MariaDB)
+     *
+     * @param partitionName - Name of the partition to drop
+     * @param options - Drop options including partition name and optional parent table
+     */
+    dropPartition(partitionName: string, options?: {
+        ifExists?: boolean;
+        cascade?: boolean;
+        parentTable?: string;
+    }): Promise<void>;
+    /**
+     * Add a partition to an existing partitioned table (MariaDB)
+     * @param tableName - Name of the partitioned table
+     * @param partitionName - Name for the new partition
+     * @param partitionSpec - Partition specification
+     */
+    addPartition(tableName: string, partitionName: string, partitionSpec: {
+        values?: string;
+        forValues?: string;
+    }): Promise<void>;
+    /**
+     * Check if a table has partitions (MariaDB)
+     *
+     * @param tableName - Name of the table to check
+     * @returns Promise<boolean> - True if the table has partitions
+     */
+    hasPartition(tableName: string): Promise<boolean>;
+    /**
+     * Add a column to a table
+     */
+    addColumn(tableName: string, columnName: string, definition: ColumnDefinition): Promise<void>;
+    /**
+     * Remove a column from a table
+     */
+    removeColumn(tableName: string, columnName: string): Promise<void>;
+    /**
+     * Change a column definition
+     */
+    changeColumn(tableName: string, columnName: string, definition: ColumnDefinition): Promise<void>;
+    /**
+     * Show all tables in the database
+     */
+    showTables(): Promise<string[]>;
+    /**
+     * Show constraints for a table
+     */
+    showConstraints(tableName: string): Promise<any[]>;
+    /**
+     * Show indexes for a table
+     */
+    showIndexes(tableName: string): Promise<any[]>;
+    /**
+     * Describe a table (get column information)
+     */
+    describeTable(tableName: string): Promise<TableDescription>;
+    /**
+     * Rename a table
+     */
+    renameTable(oldName: string, newName: string): Promise<void>;
+    /**
+     * Show all views in the database
+     */
+    showViews(): Promise<string[]>;
+    /**
+     * Create a trigger
+     */
+    createTrigger(options: TriggerOptions): Promise<void>;
+    /**
+     * Drop a trigger
+     */
+    dropTrigger(triggerName: string, tableName: string, options?: DropTriggerOptions): Promise<void>;
+    /**
+     * Check if a trigger exists
+     */
+    hasTrigger(triggerName: string, tableName: string): Promise<boolean>;
+    /**
+     * Create a sequence
+     */
+    createSequence(options: SequenceOptions): Promise<void>;
+    /**
+     * Drop a sequence
+     */
+    dropSequence(sequenceName: string, options?: DropSequenceOptions): Promise<void>;
+    /**
+     * Get next value from a sequence
+     */
+    nextSequenceValue(sequenceName: string): Promise<number>;
+    /**
+     * Check if a sequence exists
+     */
+    hasSequence(sequenceName: string): Promise<boolean>;
+    /**
+     * List all sequences in the database (MariaDB)
+     * @returns Array of sequence names
+     */
+    listSequences(): Promise<string[]>;
+    createPolicy(_options: PolicyOptions): Promise<void>;
+    dropPolicy(_policyName: string, _tableName: string, _options?: DropPolicyOptions): Promise<void>;
+    enableRLS(_tableName: string, _schema?: string): Promise<void>;
+    enableRowLevelSecurity(_tableName: string, _schema?: string): Promise<void>;
+    disableRLS(_tableName: string, _schema?: string): Promise<void>;
+    hasPolicy(_policyName: string, _tableName: string): Promise<boolean>;
+    /**
+     * Add comment to a table
+     */
+    commentTable(tableName: string, comment: string): Promise<void>;
+    /**
+     * Add comment to a column
+     */
+    commentColumn(tableName: string, columnName: string, comment: string): Promise<void>;
+    /**
+     * Create an expression index
+     */
+    createExpressionIndex(tableName: string, indexName: string, expression: string, options?: IndexOptions): Promise<void>;
+    /**
+     * Create an identity column (MariaDB 10.4+)
+     */
+    createIdentityColumn(tableName: string, columnName: string, options?: {
+        startWith?: number;
+        incrementBy?: number;
+        minvalue?: number;
+        maxvalue?: number;
+        cycle?: boolean;
+    }): Promise<void>;
+    /**
+     * Create a computed column (virtual column)
+     */
+    createComputedColumn(tableName: string, columnName: string, expression: string, options?: {
+        persisted?: boolean;
+        type?: string;
+    }): Promise<void>;
+    /**
+     * Create a database view
+     */
+    createView(viewName: string, query: string, options?: ViewOptions): Promise<void>;
+    /**
+     * Drop a database view
+     */
+    dropView(viewName: string, options?: DropViewOptions): Promise<void>;
+    /**
+     * Create a schema
+     * MariaDB databases are like schemas - uses CREATE DATABASE
+     */
+    createSchema(schema: string): Promise<void>;
+    /**
+     * Drop a schema
+     * MariaDB databases are like schemas - uses DROP DATABASE
+     */
+    dropSchema(schema: string, options?: DropSchemaOptions): Promise<void>;
+    /**
+     * Show all schemas
+     * MariaDB databases are like schemas - shows all databases
+     */
+    showAllSchemas(): Promise<string[]>;
+    /**
+     * List all schemas (databases)
+     */
+    listSchemas(): Promise<string[]>;
+    /**
+     * Create a stored procedure with full PL/SQL support
+     * Supports: IN parameters, OUT parameters, INOUT parameters, local variables,
+     * IF/ELSE, WHILE loops, cursors
+     */
+    createStoredProcedure(options: StoredProcedureOptions): Promise<void>;
+    /**
+     * Create a stored procedure with body builder for complex procedures
+     * Supports: IN parameters, OUT parameters, INOUT parameters, local variables,
+     * IF/ELSE, WHILE loops, cursors
+     */
+    createProcedure(options: CreateProcedureOptions): Promise<void>;
+    /**
+     * Drop a stored procedure
+     */
+    dropStoredProcedure(procedureName: string, options?: DropStoredProcedureOptions): Promise<void>;
+    /**
+     * Drop a stored procedure (alias for dropStoredProcedure)
+     */
+    dropProcedure(procedureName: string, options?: DropStoredProcedureOptions): Promise<void>;
+    /**
+     * Execute a stored procedure with enhanced return handling
+     * Supports OUT parameters and result sets
+     */
+    executeStoredProcedure(options: ExecuteStoredProcedureOptions): Promise<QueryResult>;
+    /**
+     * Check if a stored procedure exists
+     */
+    hasStoredProcedure(procedureName: string, schema?: string): Promise<boolean>;
+    /**
+     * Create a foreign data wrapper (MariaDB - not supported)
+     * @param fdwName - Foreign data wrapper name
+     * @param options - Options including handler function
+     */
+    createForeignDataWrapper(_fdwName: string, _options?: {
+        handler?: string;
+    }): Promise<void>;
+    dropForeignDataWrapper(_fdwName: string, _options?: {
+        ifExists?: boolean;
+    }): Promise<void>;
+    createForeignServer(_serverName: string, _fdwName: string, _options?: {
+        options?: Record<string, string>;
+        ifNotExists?: boolean;
+    }): Promise<void>;
+    dropForeignServer(_serverName: string, _options?: {
+        ifExists?: boolean;
+        cascade?: boolean;
+    }): Promise<void>;
+    createForeignTable(_tableName: string, _columns: Record<string, {
+        type: string;
+    }>, _options?: {
+        serverName?: string;
+        ifNotExists?: boolean;
+    }): Promise<void>;
+    changeOwner(_newOwner: string, _tableName: string): Promise<void>;
+    addConstraint(_tableName: string, _options: {
+        type: 'UNIQUE' | 'CHECK' | 'PRIMARY KEY' | 'FOREIGN KEY';
+        fields: string[];
+        name?: string;
+        references?: {
+            table: string;
+            fields: string[];
+        };
+        check?: string;
+    }): Promise<void>;
+    removeConstraint(_tableName: string, _constraintName: string): Promise<void>;
+    createSecurityPolicy(_policyName: string, _tableName: string, _options?: {
+        predicate?: string;
+    }): Promise<void>;
+    dropSecurityPolicy(_policyName: string, _tableName: string): Promise<void>;
+    /**
+     * Create a materialized view (emulated using a table)
+     * MariaDB does not support native materialized views, so we create a table
+     * that can be refreshed manually
+     */
+    createMaterializedView(options: MaterializedViewOptions): Promise<void>;
+    /**
+     * Refresh a materialized view (emulated)
+     * Drops and recreates the table with fresh data
+     */
+    refreshMaterializedView(viewName: string, options?: RefreshOptions): Promise<void>;
+    /**
+     * Drop a materialized view (emulated)
+     */
+    dropMaterializedView(viewName: string, options?: DropMaterializedViewOptions): Promise<void>;
+    /**
+     * Check if a materialized view exists (emulated)
+     * Checks for tables with mv_query: prefix in comment
+     */
+    hasMaterializedView(viewName: string): Promise<boolean>;
+    /**
+     * Show all materialized views (emulated)
+     * Lists tables with mv_query: prefix in comment
+     */
+    showMaterializedViews(): Promise<string[]>;
+    /**
+     * Create an event (MariaDB event scheduler)
+     */
+    createEvent(options: CreateEventOptions): Promise<void>;
+    /**
+     * Drop an event
+     */
+    dropEvent(eventName: string, options?: DropEventOptions): Promise<void>;
+    /**
+     * Show all events in the database
+     */
+    showEvents(schema?: string): Promise<any[]>;
+    /**
+     * Alter an event (change schedule, body, or status)
+     */
+    alterEvent(options: AlterEventOptions): Promise<void>;
+    /**
+     * Create a PostgreSQL extension (not supported by MariaDB)
+     */
+    createExtension(_extensionName: string, _options?: CreateExtensionOptions): Promise<void>;
+    /**
+     * Drop a PostgreSQL extension (not supported by MariaDB)
+     */
+    dropExtension(_extensionName: string, _options?: DropExtensionOptions): Promise<void>;
+    /**
+     * Get all installed PostgreSQL extensions (not supported by MariaDB)
+     */
+    getExtensions(): Promise<ExtensionInfo[]>;
+    /**
+     * Check if a PostgreSQL extension is installed (not supported by MariaDB)
+     */
+    hasExtension(_extensionName: string): Promise<boolean>;
+    /**
+     * Add an index to a table
+     * Supports expression indexes and INCLUDE columns (MariaDB 10.0+)
+     */
+    addIndex(tableName: string, indexName: string, fields?: string[], options?: IndexOptions): Promise<void>;
+    /**
+     * Remove an index from a table
+     */
+    removeIndex(tableName: string, indexName: string): Promise<void>;
+    /**
+     * Create a partial index (index with WHERE clause)
+     * MariaDB supports partial indexes since version 10.0.3
+     */
+    createPartialIndex(tableName: string, indexName: string, fields: string[], where: string, options?: IndexOptions): Promise<void>;
+    /**
+     * Create an index on a table with full options support
+     */
+    createIndex(tableName: string, indexDef: {
+        name: string;
+        unique?: boolean;
+        type?: string;
+        using?: string;
+        fields: string[];
+        where?: WhereOptions;
+        invisible?: boolean;
+    }): Promise<void>;
+    /**
+     * 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
+     */
+    alterColumnVisibility(tableName: string, columnName: string, invisible: boolean): Promise<void>;
+    /**
+     * 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
+     */
+    alterIndexVisibility(tableName: string, indexName: string, invisible: boolean): Promise<void>;
+    /**
+     * Drop an index from a table
+     */
+    dropIndex(tableName: string, indexName: string, options?: {
+        ifExists?: boolean;
+        cascade?: boolean;
+    }): Promise<void>;
+    /**
+     * Create a constraint on a table
+     */
+    createConstraint(tableName: string, constraintDef: {
+        name: string;
+        type: 'PRIMARY KEY' | 'UNIQUE' | 'FOREIGN KEY' | 'CHECK';
+        fields?: string[];
+        references?: {
+            table: string;
+            field: string;
+            onDelete?: string;
+            onUpdate?: string;
+        };
+        check?: string;
+    }): Promise<void>;
+    /**
+     * Drop a constraint from a table
+     */
+    dropConstraint(tableName: string, constraintName: string, options?: {
+        ifExists?: boolean;
+        cascade?: boolean;
+    }): Promise<void>;
+    /**
+     * Begin a new transaction
+     */
+    startTransaction(options?: TransactionOptions): Promise<Transaction>;
+    /**
+     * Commit a transaction
+     */
+    commitTransaction(transaction: Transaction): Promise<void>;
+    /**
+     * Rollback a transaction
+     */
+    rollbackTransaction(transaction: Transaction): Promise<void>;
+    /**
+     * Get the SQL for a data type with MariaDB-specific types
+     */
+    getDataTypeSql(dataType: DataType): string;
+    /**
+     * Build a WHERE clause from a WhereOptions object
+     */
+    buildWhereClause(where: WhereOptions, options?: {
+        replacements?: Record<string, unknown>;
+    }): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * Build an ORDER BY clause
+     */
+    buildOrderClause(order: Order, options?: {
+        replacements?: Record<string, unknown>;
+    }): string;
+    /**
+     * Build a LIMIT/OFFSET clause
+     */
+    buildLimitOffset(limit?: number | string, offset?: number | string): string;
+    /**
+     * Build an INSERT query with MariaDB ON DUPLICATE KEY UPDATE support
+     */
+    buildInsertQuery(tableName: string, values: Record<string, unknown>, options?: InsertOptions): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * Build an UPSERT query for MariaDB
+     * Uses ON DUPLICATE KEY UPDATE syntax (same as MySQL)
+     */
+    buildUpsertQuery(tableName: string, values: Record<string, unknown>, options?: UpsertQueryOptions): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * Build an increment query
+     * @param tableName - Table name
+     * @param fields - Fields to increment
+     * @param where - Where clause
+     * @param options - Query options (by: number)
+     */
+    buildIncrementQuery(tableName: string, fields: string | string[] | Record<string, number>, where: WhereOptions, options?: {
+        by?: number;
+    }): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * Build an UPDATE query
+     */
+    buildUpdateQuery(tableName: string, values: Record<string, unknown>, where: WhereOptions, options?: UpdateOptions): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * Build a DELETE query
+     */
+    buildDeleteQuery(tableName: string, where: WhereOptions, options?: DeleteOptions): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * Check if a value is a function expression (fn('COUNT', ...))
+     */
+    private isFnExpression;
+    /**
+     * Check if a value is a column expression (col('name'))
+     */
+    private isColExpression;
+    /**
+     * Check if a value is a literal expression (literal('sql'))
+     */
+    /**
+     * Render a literal expression, substituting any `bindings` into its `?`
+     * placeholders with dialect-correct escaping. `literalExpr(sql)` with no
+     * bindings is unchanged; `literalExpr('x > ?', [v])` no longer requires the
+     * caller to concatenate the value into the string themselves.
+     */
+    private literalSql;
+    private isLiteralExpression;
+    /**
+     * Compile a function expression to SQL
+     */
+    private compileFnExpression;
+    /**
+     * Build SELECT clause with support for function expressions and aliases
+     * Handles: 'field', ['field'], ['field', 'alias'], [fn('COUNT', 'id'), 'count']
+     */
+    private buildSelectClause;
+    /**
+     * Build GROUP BY clause with support for function expressions and aliases
+     * Handles: 'field', ['field1', 'field2'], [[fn('COUNT', 'id'), 'count']]
+     */
+    private buildGroupByClause;
+    /**
+     * Build a WHERE clause condition using standard operators (Op.gt, Op.eq, etc.)
+     */
+    private buildCondition;
+    /**
+     * Build a HAVING clause with support for standard Op operators
+     */
+    private buildHavingClause;
+    /**
+     * Build a SELECT query with support for Common Table Expressions (CTEs)
+     */
+    buildSelectQuery(options: SelectOptions): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * Escape a password string – replaces single quotes so it is safe to embed
+     * between single-quote delimiters in SQL.
+     */
+    private escapePassword;
+    /**
+     * Format a MariaDB user identity as  'username'@'host'
+     */
+    private formatUserIdentity;
+    /**
+     * Format a MariaDB privilege scope.
+     */
+    private formatPrivilegeScope;
+    buildCreateUserQuery(username: string, options?: import('../../user-management').CreateUserOptions): string;
+    buildAlterUserQuery(username: string, options: import('../../user-management').AlterUserOptions): string;
+    buildDropUserQuery(username: string, options?: {
+        host?: string;
+        ifExists?: boolean;
+    }): string;
+    getUsersQuery(): string;
+    buildGrantQuery(options: import('../../user-management').GrantOptions): string;
+    buildRevokeQuery(options: import('../../user-management').RevokeOptions): string;
+    buildShowGrantsQuery(username: string, host?: string): string;
+    buildFlushPrivilegesQuery(): string;
+    buildCreateRoleQuery(roleName: string, options?: import('../../user-management').RoleOptions): string;
+    buildDropRoleQuery(roleName: string, options?: {
+        ifExists?: boolean;
+        cascade?: boolean;
+    }): string;
+    buildGrantRoleQuery(role: string, to: string | string[], options?: {
+        withAdminOption?: boolean;
+    }): string;
+    buildRevokeRoleQuery(role: string, from: string | string[], _options?: {
+        cascade?: boolean;
+    }): string;
+    getRolesQuery(): string;
+    /**
+     * 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: string, replacements?: Record<string, unknown> | unknown[]): string;
+    /**
+     * Build a CREATE SERVER query for foreign data wrappers (PostgreSQL only)
+     */
+    buildCreateServerQuery(_name: string, _opts: any): string;
+    /**
+     * Build an ALTER SERVER query for foreign data wrappers (PostgreSQL only)
+     */
+    buildAlterServerQuery(_name: string, _opts: any): string;
+    /**
+     * Build a DROP SERVER query for foreign data wrappers (PostgreSQL only)
+     */
+    buildDropServerQuery(_name: string, _opts?: {
+        ifExists?: boolean;
+        cascade?: boolean;
+    }): string;
+    /**
+     * Build a CREATE USER MAPPING query for foreign data wrappers (PostgreSQL only)
+     */
+    buildCreateUserMappingQuery(_opts: any): string;
+    /**
+     * Build an ALTER USER MAPPING query for foreign data wrappers (PostgreSQL only)
+     */
+    buildAlterUserMappingQuery(_opts: any): string;
+    /**
+     * Build a DROP USER MAPPING query for foreign data wrappers (PostgreSQL only)
+     */
+    buildDropUserMappingQuery(_serverName: string, _user: string, _opts?: {
+        ifExists?: boolean;
+    }): string;
+    /**
+     * Build a CREATE FOREIGN TABLE query for foreign data wrappers (PostgreSQL only)
+     */
+    buildCreateForeignTableQuery(_tableName: string, _opts: any): string;
+    /**
+     * Build a DROP FOREIGN TABLE query for foreign data wrappers (PostgreSQL only)
+     */
+    buildDropForeignTableQuery(_tableName: string, _opts?: {
+        ifExists?: boolean;
+        cascade?: boolean;
+    }): string;
+    /**
+     * Build an IMPORT FOREIGN SCHEMA query for foreign data wrappers (PostgreSQL only)
+     */
+    buildImportForeignSchemaQuery(_remoteSchema: string, _serverName: string, _opts?: any): string;
+    /**
+     * Get query to list foreign servers (PostgreSQL only)
+     */
+    getServersQuery(): string;
+    /**
+     * Generate SQL for creating a MariaDB database
+     */
+    createDatabaseSQL(options: {
+        name: string;
+        encoding?: string;
+        collate?: string;
+    }): string;
+    /**
+     * Generate SQL for dropping a MariaDB database
+     */
+    dropDatabaseSQL(name: string): string;
+    /**
+     * Generate SQL for creating a savepoint
+     */
+    createSavepointSQL(name?: string): string;
+    /**
+     * Generate SQL for releasing a savepoint
+     */
+    releaseSavepointSQL(name: string): string;
+    /**
+     * Generate SQL for rolling back to a savepoint
+     */
+    rollbackToSavepointSQL(name: string): string;
+    /**
+     * Bulk insert records into a table
+     */
+    bulkInsert(tableName: string, records: Record<string, any>[], _options?: any): Promise<QueryResult>;
+    /**
+     * Add a foreign key to a table
+     */
+    addForeignKey(tableName: string, columnName: string, referencedTableName: string, referencedColumnName: string, options?: {
+        name?: string;
+        onDelete?: 'CASCADE' | 'RESTRICT' | 'SET NULL' | 'NO ACTION';
+        onUpdate?: 'CASCADE' | 'RESTRICT' | 'SET NULL' | 'NO ACTION';
+    }): Promise<void>;
+    /**
+     * Rename a column
+     */
+    renameColumn(tableName: string, oldColumnName: string, newColumnName: string): Promise<void>;
+    /**
+     * Create a fulltext index
+     */
+    createFulltextIndex(tableName: string, indexName: string, fields: string[], options?: {
+        parser?: string;
+        comment?: string;
+    }): Promise<void>;
+    /**
+     * Create a spatial index
+     */
+    createSpatialIndex(tableName: string, indexName: string, fields: string[], options?: {
+        storage?: string;
+        srid?: number;
+    }): Promise<void>;
+    /**
+     * 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: string, geom2: string, srid?: number): string;
+    /**
+     * ST_Within - check if geometry A is within geometry B
+     * MariaDB 10.1+ spatial function
+     */
+    stWithin(geom1: string, geom2: string, srid?: number): string;
+    /**
+     * ST_Contains - check if geometry A contains geometry B
+     * MariaDB 10.1+ spatial function
+     */
+    stContains(geom1: string, geom2: string, srid?: number): string;
+    /**
+     * ST_Intersects - check if two geometries intersect
+     * MariaDB 10.1+ spatial function
+     */
+    stIntersects(geom1: string, geom2: string, srid?: number): string;
+    /**
+     * ST_DWithin - check if geometries are within a given distance
+     * MariaDB 10.1+ spatial function
+     */
+    stDWithin(geom1: string, geom2: string, distance: number, srid?: number): string;
+    /**
+     * ST_GeomFromText - create geometry from WKT text
+     */
+    stGeomFromText(wkt: string, srid?: number): string;
+    /**
+     * ST_GeomFromGeoJSON - create geometry from GeoJSON
+     * MariaDB 10.2.4+ spatial function
+     */
+    stGeomFromGeoJSON(geojson: string, srid?: number): string;
+    /**
+     * ST_AsGeoJSON - convert geometry to GeoJSON
+     * MariaDB 10.2.4+ spatial function
+     */
+    stAsGeoJSON(geom: string): string;
+    /**
+     * ST_AsText - convert geometry to WKT
+     */
+    stAsText(geom: string): string;
+    /**
+     * Create a user mapping (MariaDB doesn't support user mappings)
+     */
+    createUserMapping(_userName: string, _serverName: string, _options?: any): Promise<void>;
+    /**
+     * Drop a user mapping (MariaDB doesn't support user mappings)
+     */
+    dropUserMapping(_userName: string, _serverName: string, _options?: any): Promise<void>;
+    /**
+     * 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: string, rowPath: string, columns: Array<{
+        name: string;
+        type?: string;
+        path?: string;
+        forOrdinality?: boolean;
+    }>, alias: string): string;
+}
+/**
+ * MariaDB-specific transaction class
+ */
+export declare class MariaDBTransaction implements Transaction {
+    id: string;
+    finished: boolean;
+    options: TransactionOptions;
+    parent: Transaction | null;
+    savepoints: string[];
+    connection: PoolConnection | null;
+    constructor(connection: PoolConnection, options?: TransactionOptions);
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+}
+export interface MariaDBDialectOptions extends DialectOptions {
+    host?: string;
+    port?: number;
+    database?: string;
+    username?: string;
+    password?: string;
+    timezone?: string;
+    charset?: string;
+    collation?: string;
+    waitForConnections?: boolean;
+    connectionLimit?: number;
+    queueLimit?: number;
+    ssl?: any;
+    debug?: boolean;
+    trace?: boolean;
+    insertIdAsNumber?: boolean;
+    decimalAsFloat?: boolean;
+}
+/**
+ * Create a new MariaDB dialect instance
+ */
+export declare function createMariaDBDialect(options?: MariaDBDialectOptions): MariaDBDialect;
+/**
+ * MariaDB storage engines
+ */
+export declare const MariaDBStorageEngines: {
+    readonly INNODB: "InnoDB";
+    readonly ARIA: "Aria";
+    readonly XTRADB: "XtraDB";
+    readonly MYISAM: "MyISAM";
+    readonly MEMORY: "MEMORY";
+    readonly CONNECT: "CONNECT";
+    readonly CSV: "CSV";
+    readonly HEAP: "HEAP";
+    readonly MERGE: "MERGE";
+    readonly MRG_MYISAM: "MRG_MyISAM";
+    readonly BLACKHOLE: "BLACKHOLE";
+    readonly FEDERATED: "Federated";
+    readonly FEDERATEDX: "FederatedX";
+};
+/**
+ * MariaDB CONNECT storage engine types
+ */
+export declare const MariaDBConnectTypes: {
+    readonly ODBC: "ODBC";
+    readonly JDBC: "JDBC";
+    readonly MYSQL: "MYSQL";
+    readonly XML: "XML";
+    readonly JSON: "JSON";
+    readonly CSV: "CSV";
+    readonly FMT: "FMT";
+    readonly DBF: "DBF";
+    readonly INI: "INI";
+    readonly WMI: "WMI";
+    readonly PROXY: "PROXY";
+    readonly XCOL: "XCOL";
+    readonly PIVOT: "PIVOT";
+    readonly VIR: "VIR";
+    readonly BLOB: "BLOB";
+};
+/**
+ * MariaDB row formats
+ */
+export declare const MariaDBRowFormats: {
+    readonly DEFAULT: "DEFAULT";
+    readonly DYNAMIC: "DYNAMIC";
+    readonly FIXED: "FIXED";
+    readonly COMPRESSED: "COMPRESSED";
+    readonly REDUNDANT: "REDUNDANT";
+    readonly PAGE: "PAGE";
+};
+export default MariaDBDialect;