@mikro-orm/sql 7.1.0-dev.4 → 7.1.0-dev.40

package/PivotCollectionPersister.d.ts

@@ -1,8 +1,8 @@
-import { type Dictionary, type EntityMetadata, type EntityProperty, type Primary, type Transaction } from '@mikro-orm/core';
+import { type AbortQueryOptions, type Dictionary, type EntityMetadata, type EntityProperty, type Primary, type Transaction } from '@mikro-orm/core';
 import { type AbstractSqlDriver } from './AbstractSqlDriver.js';
 export declare class PivotCollectionPersister<Entity extends object> {
     #private;
-    constructor(meta: EntityMetadata<Entity>, driver: AbstractSqlDriver, ctx?: Transaction, schema?: string, loggerContext?: Dictionary);
+    constructor(meta: EntityMetadata<Entity>, driver: AbstractSqlDriver, ctx?: Transaction, schema?: string, loggerContext?: Dictionary, abort?: AbortQueryOptions);
     enqueueUpdate(prop: EntityProperty<Entity>, insertDiff: Primary<Entity>[][], deleteDiff: Primary<Entity>[][] | boolean, pks: Primary<Entity>[], isInitialized?: boolean): void;
     private enqueueInsert;
     private enqueueUpsert;

package/PivotCollectionPersister.js

@@ -1,3 +1,4 @@
+import { QueryHelper, } from '@mikro-orm/core';
 class InsertStatement {
     order;
     #keys;
@@ -43,12 +44,14 @@ export class PivotCollectionPersister {
     #ctx;
     #schema;
     #loggerContext;
-    constructor(meta, driver, ctx, schema, loggerContext) {
+    #abort;
+    constructor(meta, driver, ctx, schema, loggerContext, abort) {
         this.#meta = meta;
         this.#driver = driver;
         this.#ctx = ctx;
         this.#schema = schema;
         this.#loggerContext = loggerContext;
+        this.#abort = abort;
         this.#batchSize = this.#driver.config.get('batchSize');
     }
     enqueueUpdate(prop, insertDiff, deleteDiff, pks, isInitialized = true) {
@@ -106,6 +109,16 @@ export class PivotCollectionPersister {
     buildPivotKeysAndData(prop, fks, pks, deleteAll = false) {
         let data;
         let keys;
+        // Union-target polymorphic M:N prepends the per-row discriminator to `fks` in syncCollections;
+        // Rails-style polymorphic M:N uses a static discriminatorValue on the prop. Normalize to a single
+        // "current row's discriminator" value so the prepend block below handles both cases uniformly.
+        let rowDiscriminator;
+        if (QueryHelper.isUnionTargetPolymorphic(prop) && !deleteAll && fks.length > 0) {
+            [rowDiscriminator, ...fks] = fks;
+        }
+        else if (prop.polymorphic && prop.discriminatorColumn && prop.discriminatorValue) {
+            rowDiscriminator = prop.discriminatorValue;
+        }
         if (deleteAll) {
             data = pks;
             keys = prop.joinColumns;
@@ -116,8 +129,8 @@ export class PivotCollectionPersister {
                 ? [...prop.inverseJoinColumns, ...prop.joinColumns]
                 : [...prop.joinColumns, ...prop.inverseJoinColumns];
         }
-        if (prop.polymorphic && prop.discriminatorColumn && prop.discriminatorValue) {
-            data = [prop.discriminatorValue, ...data];
+        if (rowDiscriminator !== undefined) {
+            data = [rowDiscriminator, ...data];
             keys = [prop.discriminatorColumn, ...keys];
         }
         return { data, keys };
@@ -142,6 +155,7 @@ export class PivotCollectionPersister {
                     ctx: this.#ctx,
                     schema: this.#schema,
                     loggerContext: this.#loggerContext,
+                    ...this.#abort,
                 });
             }
         }
@@ -155,6 +169,7 @@ export class PivotCollectionPersister {
                     convertCustomTypes: false,
                     processCollections: false,
                     loggerContext: this.#loggerContext,
+                    ...this.#abort,
                 });
             }
         }
@@ -170,6 +185,7 @@ export class PivotCollectionPersister {
                     upsert: true,
                     onConflictAction: 'ignore',
                     loggerContext: this.#loggerContext,
+                    ...this.#abort,
                 });
             }
         }

package/README.md

@@ -2,7 +2,7 @@
   <a href="https://mikro-orm.io"><img src="https://raw.githubusercontent.com/mikro-orm/mikro-orm/master/docs/static/img/logo-readme.svg?sanitize=true" alt="MikroORM" /></a>
 </h1>
 
-TypeScript ORM for Node.js based on Data Mapper, [Unit of Work](https://mikro-orm.io/docs/unit-of-work/) and [Identity Map](https://mikro-orm.io/docs/identity-map/) patterns. Supports MongoDB, MySQL, MariaDB, PostgreSQL, SQLite (including libSQL), MSSQL and Oracle databases.
+TypeScript ORM for Node.js based on Data Mapper, [Unit of Work](https://mikro-orm.io/docs/unit-of-work/) and [Identity Map](https://mikro-orm.io/docs/identity-map/) patterns. Supports MongoDB, MySQL, MariaDB, PostgreSQL (including CockroachDB and PGlite), SQLite (including libSQL), MSSQL and Oracle databases.
 
 > Heavily inspired by [Doctrine](https://www.doctrine-project.org/) and [Hibernate](https://hibernate.org/).
 
@@ -19,6 +19,7 @@ Install a driver package for your database:
 
 ```sh
 npm install @mikro-orm/postgresql   # PostgreSQL
+npm install @mikro-orm/pglite       # PGlite (embedded PostgreSQL in WASM)
 npm install @mikro-orm/mysql        # MySQL
 npm install @mikro-orm/mariadb      # MariaDB
 npm install @mikro-orm/sqlite       # SQLite

package/SqlEntityManager.d.ts

@@ -1,4 +1,4 @@
-import { type EntitySchemaWithMeta, EntityManager, type AnyEntity, type ConnectionType, type EntityData, type EntityName, type EntityRepository, type GetRepository, type QueryResult, type FilterQuery, type LoggingOptions, type RawQueryFragment } from '@mikro-orm/core';
+import { type AbortQueryOptions, type EntitySchemaWithMeta, EntityManager, type AnyEntity, type ConnectionType, type CountByOptions, type Dictionary, type EntityData, type EntityKey, type EntityName, type EntityRepository, type FilterQuery, type GetRepository, type LoggingOptions, type QueryResult, type RawQueryFragment } from '@mikro-orm/core';
 import type { AbstractSqlDriver } from './AbstractSqlDriver.js';
 import type { NativeQueryBuilder } from './query/NativeQueryBuilder.js';
 import type { QueryBuilder } from './query/QueryBuilder.js';
@@ -6,6 +6,13 @@ import type { SqlEntityRepository } from './SqlEntityRepository.js';
 import type { Kysely } from 'kysely';
 import type { InferClassEntityDB, InferKyselyDB } from './typings.js';
 import { type MikroKyselyPluginOptions } from './plugin/index.js';
+/** Options for the modern signature of `SqlEntityManager.execute()`. */
+export interface EmExecuteOptions extends AbortQueryOptions {
+    /** Result shape — `'all'` for rows, `'get'` for a single row, `'run'` for affected count. Defaults to `'all'`. */
+    method?: 'all' | 'get' | 'run';
+    /** Logger context payload forwarded to `Logger.logQuery`. */
+    loggerContext?: LoggingOptions;
+}
 /** Options for `SqlEntityManager.getKysely()`. */
 export interface GetKyselyOptions extends MikroKyselyPluginOptions {
     /** Connection type to use (`'read'` or `'write'`). */
@@ -24,11 +31,47 @@ export declare class SqlEntityManager<Driver extends AbstractSqlDriver = Abstrac
      */
     qb<Entity extends object, RootAlias extends string = never>(entityName: EntityName<Entity>, alias?: RootAlias, type?: ConnectionType, loggerContext?: LoggingOptions): QueryBuilder<Entity, RootAlias>;
     /**
-     * Returns configured Kysely instance.
+     * Returns a configured Kysely instance bound to this EntityManager.
+     *
+     * When the EntityManager is inside a transaction (e.g. within `em.transactional(...)`, or after
+     * `em.begin()`), the returned Kysely instance automatically uses the transaction context, so any
+     * queries executed via Kysely's own `.execute()` / `.executeTakeFirst*()` participate in the
+     * current transaction.
+     *
+     * If you need a Kysely instance that is **not** bound to the current transaction (e.g. to perform
+     * a side query against the pool while inside a transactional block), fork the EntityManager first:
+     *
+     * ```ts
+     * await em.transactional(async em => {
+     *   // bound to the current transaction
+     *   await em.getKysely().selectFrom('user').selectAll().execute();
+     *
+     *   // bound to the pool, runs outside the transaction
+     *   await em.fork().getKysely().selectFrom('audit_log').selectAll().execute();
+     * });
+     * ```
+     *
+     * The `options.type` (`'read'` / `'write'`) is only honored outside a transaction — inside a
+     * transaction the connection is already pinned.
      */
     getKysely<TDB = undefined, TOptions extends GetKyselyOptions = GetKyselyOptions>(options?: TOptions): Kysely<TDB extends undefined ? InferKyselyDB<EntitiesFromManager<this>, TOptions> & InferClassEntityDB<AllEntitiesFromManager<this>, TOptions> : TDB>;
-    /** Executes a raw SQL query, using the current transaction context if available. */
+    /**
+     * Executes a raw SQL query, using the current transaction context if available. The fork-level
+     * `signal` / `inflightQueryAbortStrategy` (set via `em.fork({ signal })`) is applied automatically.
+     * For per-call cancellation use the options-bag overload below.
+     */
     execute<T extends QueryResult | EntityData<AnyEntity> | EntityData<AnyEntity>[] = EntityData<AnyEntity>[]>(query: string | NativeQueryBuilder | RawQueryFragment, params?: any[], method?: 'all' | 'get' | 'run', loggerContext?: LoggingOptions): Promise<T>;
+    /**
+     * Executes a raw SQL query with an options bag carrying `method`, `loggerContext`, `signal`
+     * and `inflightQueryAbortStrategy`. Per-call `signal` / `inflightQueryAbortStrategy` override
+     * the fork-level defaults set via `em.fork({ signal })`. The current transaction context is
+     * applied automatically.
+     */
+    execute<T extends QueryResult | EntityData<AnyEntity> | EntityData<AnyEntity>[] = EntityData<AnyEntity>[]>(query: string | NativeQueryBuilder | RawQueryFragment, params: any[], options: EmExecuteOptions): Promise<T>;
+    /**
+     * @inheritDoc
+     */
+    countBy<Entity extends object>(entityName: EntityName<Entity>, groupBy: EntityKey<Entity> | readonly EntityKey<Entity>[], options?: CountByOptions<Entity>): Promise<Dictionary<number>>;
     getRepository<T extends object, U extends EntityRepository<T> = SqlEntityRepository<T>>(entityName: EntityName<T>): GetRepository<T, U>;
     protected applyDiscriminatorCondition<Entity extends object>(entityName: EntityName<Entity>, where: FilterQuery<Entity>): FilterQuery<Entity>;
 }

package/SqlEntityManager.js

@@ -1,4 +1,4 @@
-import { EntityManager, } from '@mikro-orm/core';
+import { EntityManager, raw, Utils, } from '@mikro-orm/core';
 import { MikroKyselyPlugin } from './plugin/index.js';
 /**
  * @inheritDoc
@@ -9,7 +9,9 @@ export class SqlEntityManager extends EntityManager {
      */
     createQueryBuilder(entityName, alias, type, loggerContext) {
         const context = this.getContext(false);
-        return this.driver.createQueryBuilder(entityName, context.getTransactionContext(), type, true, loggerContext ?? context.loggerContext, alias, this);
+        const qb = this.driver.createQueryBuilder(entityName, context.getTransactionContext(), type, true, loggerContext ?? context.loggerContext, alias, this);
+        qb.setAbortOptions(context.getAbortOptions());
+        return qb;
     }
     /**
      * Shortcut for `createQueryBuilder()`
@@ -18,10 +20,33 @@ export class SqlEntityManager extends EntityManager {
         return this.createQueryBuilder(entityName, alias, type, loggerContext);
     }
     /**
-     * Returns configured Kysely instance.
+     * Returns a configured Kysely instance bound to this EntityManager.
+     *
+     * When the EntityManager is inside a transaction (e.g. within `em.transactional(...)`, or after
+     * `em.begin()`), the returned Kysely instance automatically uses the transaction context, so any
+     * queries executed via Kysely's own `.execute()` / `.executeTakeFirst*()` participate in the
+     * current transaction.
+     *
+     * If you need a Kysely instance that is **not** bound to the current transaction (e.g. to perform
+     * a side query against the pool while inside a transactional block), fork the EntityManager first:
+     *
+     * ```ts
+     * await em.transactional(async em => {
+     *   // bound to the current transaction
+     *   await em.getKysely().selectFrom('user').selectAll().execute();
+     *
+     *   // bound to the pool, runs outside the transaction
+     *   await em.fork().getKysely().selectFrom('audit_log').selectAll().execute();
+     * });
+     * ```
+     *
+     * The `options.type` (`'read'` / `'write'`) is only honored outside a transaction — inside a
+     * transaction the connection is already pinned.
      */
     getKysely(options = {}) {
-        let kysely = this.getConnection(options.type).getClient();
+        const context = this.getContext(false);
+        const ctx = context.getTransactionContext();
+        let kysely = ctx ?? this.getConnection(options.type).getClient();
         if (options.columnNamingStrategy != null ||
             options.tableNamingStrategy != null ||
             options.processOnCreateHooks != null ||
@@ -31,9 +56,54 @@ export class SqlEntityManager extends EntityManager {
         }
         return kysely;
     }
-    /** Executes a raw SQL query, using the current transaction context if available. */
-    async execute(query, params = [], method = 'all', loggerContext) {
-        return this.getDriver().execute(query, params, method, this.getContext(false).getTransactionContext(), loggerContext);
+    async execute(query, params = [], methodOrOptions = 'all', loggerContext) {
+        const opts = typeof methodOrOptions === 'string' ? { method: methodOrOptions, loggerContext } : methodOrOptions;
+        const context = this.getContext(false);
+        // Per-field fallback to fork-level abort, matching `EntityManager.prepareOptions` semantics.
+        const fork = context.getAbortOptions();
+        const hasAbort = opts.signal != null || opts.inflightQueryAbortStrategy != null || fork != null;
+        // Connection layer carries abort piggy-backed on `loggerContext`; merge only when needed.
+        const merged = hasAbort || opts.loggerContext ? { ...opts.loggerContext } : undefined;
+        if (merged && hasAbort) {
+            merged.signal = opts.signal ?? fork?.signal;
+            merged.inflightQueryAbortStrategy = opts.inflightQueryAbortStrategy ?? fork?.inflightQueryAbortStrategy;
+        }
+        return this.getDriver().execute(query, params, opts.method ?? 'all', context.getTransactionContext(), merged);
+    }
+    /**
+     * @inheritDoc
+     */
+    async countBy(entityName, groupBy, options = {}) {
+        const em = this.getContext(false);
+        options = { ...options };
+        em.prepareOptions(options);
+        const meta = em.getMetadata().find(entityName);
+        const fields = Utils.asArray(groupBy);
+        const { where: rawWhere, ...countOptions } = options;
+        await em.tryFlush(entityName, options);
+        const where = await em.processWhere(entityName, rawWhere ?? {}, options, 'read');
+        const qb = em.createQueryBuilder(meta.class);
+        qb
+            .select([...fields, raw('count(*) as cnt')])
+            .where(where)
+            .groupBy(fields);
+        if (countOptions.having) {
+            qb.having(countOptions.having);
+        }
+        if (countOptions.schema) {
+            qb.withSchema(countOptions.schema);
+        }
+        const rows = await qb.execute('all', { mapResults: false });
+        const results = {};
+        for (const row of rows) {
+            const keyParts = fields.map(f => {
+                const col = meta.properties[f]?.fieldNames?.[0] ?? f;
+                return String(row[col]);
+            });
+            const key = keyParts.join(Utils.PK_SEPARATOR);
+            results[key] = +row.cnt;
+        }
+        return results;
     }
     getRepository(entityName) {
         return super.getRepository(entityName);

package/SqlMikroORM.d.ts

@@ -0,0 +1,23 @@
+import { type AnyEntity, type EntityClass, type EntityManager, type EntityManagerType, type EntitySchema, type IDatabaseDriver, MikroORM, type Options } from '@mikro-orm/core';
+import type { AbstractSqlDriver } from './AbstractSqlDriver.js';
+import type { SqlEntityManager } from './SqlEntityManager.js';
+/** Configuration options shared by all SQL drivers. */
+export type SqlOptions<D extends AbstractSqlDriver = AbstractSqlDriver, EM extends SqlEntityManager<D> = SqlEntityManager<D>, Entities extends readonly (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]> = Partial<Options<D, EM, Entities>>;
+/**
+ * Creates a type-safe configuration object for any SQL driver. The driver class
+ * must be passed via `options.driver` (e.g. `SqliteDriver`, `MySqlDriver`, …).
+ */
+export declare function defineSqlConfig<D extends AbstractSqlDriver = AbstractSqlDriver, EM extends SqlEntityManager<D> = SqlEntityManager<D>, Entities extends readonly (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]>(options: Partial<Options<D, EM, Entities>>): Partial<Options<D, EM, Entities>>;
+/**
+ * Generic entry point for SQL drivers. Use this when consuming `@mikro-orm/sql`
+ * directly with a Kysely dialect; for the bundled driver packages prefer
+ * `@mikro-orm/sqlite`, `@mikro-orm/postgresql`, etc.
+ *
+ * @inheritDoc
+ */
+export declare class SqlMikroORM<D extends AbstractSqlDriver = AbstractSqlDriver, EM extends SqlEntityManager<D> = SqlEntityManager<D>, Entities extends readonly (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]> extends MikroORM<D, EM, Entities> {
+    /**
+     * @inheritDoc
+     */
+    static init<D extends IDatabaseDriver = AbstractSqlDriver, EM extends EntityManager<D> = D[typeof EntityManagerType] & EntityManager<D>, Entities extends readonly (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]>(options: Partial<Options<D, EM, Entities>>): Promise<MikroORM<D, EM, Entities>>;
+}

package/SqlMikroORM.js

@@ -0,0 +1,23 @@
+import { defineConfig, MikroORM, } from '@mikro-orm/core';
+/**
+ * Creates a type-safe configuration object for any SQL driver. The driver class
+ * must be passed via `options.driver` (e.g. `SqliteDriver`, `MySqlDriver`, …).
+ */
+export function defineSqlConfig(options) {
+    return defineConfig(options);
+}
+/**
+ * Generic entry point for SQL drivers. Use this when consuming `@mikro-orm/sql`
+ * directly with a Kysely dialect; for the bundled driver packages prefer
+ * `@mikro-orm/sqlite`, `@mikro-orm/postgresql`, etc.
+ *
+ * @inheritDoc
+ */
+export class SqlMikroORM extends MikroORM {
+    /**
+     * @inheritDoc
+     */
+    static async init(options) {
+        return super.init(options);
+    }
+}

package/dialects/mysql/BaseMySqlPlatform.d.ts

@@ -17,6 +17,7 @@ export declare class BaseMySqlPlatform extends AbstractSqlPlatform {
     supportsMultiColumnCountDistinct(): boolean;
     /** @internal */
     createNativeQueryBuilder(): MySqlNativeQueryBuilder;
+    formatIndexHint(indexNames: string[]): string;
     getDefaultCharset(): string;
     init(orm: MikroORM): void;
     getBeginTransactionSQL(options?: {
@@ -34,11 +35,9 @@ export declare class BaseMySqlPlatform extends AbstractSqlPlatform {
     getDefaultMappedType(type: string): Type<unknown>;
     isNumericColumn(mappedType: Type<unknown>): boolean;
     supportsUnsigned(): boolean;
-    /**
-     * Returns the default name of index for the given columns
-     * cannot go past 64 character length for identifiers in MySQL
-     */
-    getIndexName(tableName: string, columns: string[], type: 'index' | 'unique' | 'foreign' | 'primary' | 'sequence'): string;
+    /** MySQL/MariaDB identifier limit. */
+    getMaxIdentifierLength(): number;
+    getIndexName(tableName: string, columns: string[], type: 'index' | 'unique' | 'foreign' | 'primary' | 'sequence' | 'check'): string;
     getDefaultPrimaryName(tableName: string, columns: string[]): string;
     supportsCreatingFullTextIndex(): boolean;
     getFullTextWhereClause(): string;

package/dialects/mysql/BaseMySqlPlatform.js

@@ -1,4 +1,4 @@
-import { Utils, QueryOrder, DecimalType, DoubleType, } from '@mikro-orm/core';
+import { QueryOrder, DecimalType, DoubleType, } from '@mikro-orm/core';
 import { MySqlSchemaHelper } from './MySqlSchemaHelper.js';
 import { MySqlExceptionConverter } from './MySqlExceptionConverter.js';
 import { AbstractSqlPlatform } from '../../AbstractSqlPlatform.js';
@@ -25,6 +25,9 @@ export class BaseMySqlPlatform extends AbstractSqlPlatform {
     createNativeQueryBuilder() {
         return new MySqlNativeQueryBuilder(this);
     }
+    formatIndexHint(indexNames) {
+        return `use index(${indexNames.join(', ')})`;
+    }
     getDefaultCharset() {
         return 'utf8mb4';
     }
@@ -83,19 +86,15 @@ export class BaseMySqlPlatform extends AbstractSqlPlatform {
     supportsUnsigned() {
         return true;
     }
-    /**
-     * Returns the default name of index for the given columns
-     * cannot go past 64 character length for identifiers in MySQL
-     */
+    /** MySQL/MariaDB identifier limit. */
+    getMaxIdentifierLength() {
+        return 64;
+    }
     getIndexName(tableName, columns, type) {
         if (type === 'primary') {
             return this.getDefaultPrimaryName(tableName, columns);
         }
-        const indexName = super.getIndexName(tableName, columns, type);
-        if (indexName.length > 64) {
-            return `${indexName.substring(0, 56 - type.length)}_${Utils.hash(indexName, 5)}_${type}`;
-        }
-        return indexName;
+        return super.getIndexName(tableName, columns, type);
     }
     getDefaultPrimaryName(tableName, columns) {
         return 'PRIMARY'; // https://dev.mysql.com/doc/refman/8.0/en/create-table.html#create-table-indexes-keys

package/dialects/mysql/MySqlSchemaHelper.d.ts

@@ -1,5 +1,5 @@
 import { type Dictionary, type Transaction, type Type } from '@mikro-orm/core';
-import type { CheckDef, Column, ForeignKey, IndexDef, Table, TableDifference } from '../../typings.js';
+import type { CheckDef, Column, ForeignKey, IndexDef, Table, TableDifference, SqlTriggerDef } from '../../typings.js';
 import type { AbstractSqlConnection } from '../../AbstractSqlConnection.js';
 import { SchemaHelper } from '../../schema/SchemaHelper.js';
 import type { DatabaseSchema } from '../../schema/DatabaseSchema.js';
@@ -11,7 +11,12 @@ export declare class MySqlSchemaHelper extends SchemaHelper {
         'current_timestamp(?)': string[];
         '0': string[];
     };
+    private static readonly PARTIAL_INDEX_RE;
     getSchemaBeginning(charset: string, disableForeignKeys?: boolean): string;
+    getSetSchemaSQL(schema: string): string;
+    getResetSchemaSQL(defaultSchema: string): string;
+    supportsMigrationSchema(): boolean;
+    tableExists(connection: AbstractSqlConnection, tableName: string, schemaName: string | undefined, ctx?: Transaction): Promise<boolean>;
     disableForeignKeysSQL(): string;
     enableForeignKeysSQL(): string;
     finalizeTable(table: DatabaseTable, charset: string, collate?: string): string;
@@ -22,8 +27,10 @@ export declare class MySqlSchemaHelper extends SchemaHelper {
     getAllIndexes(connection: AbstractSqlConnection, tables: Table[], ctx?: Transaction): Promise<Dictionary<IndexDef[]>>;
     getCreateIndexSQL(tableName: string, index: IndexDef, partialExpression?: boolean): string;
     /**
-     * Build the column list for a MySQL index, with MySQL-specific handling for collation.
-     * MySQL requires collation to be specified as an expression: (column_name COLLATE collation_name)
+     * Build the column list for a MySQL index. MySQL requires collation via an expression:
+     * `(column COLLATE collation_name)`. Partial indexes (`where`) are emulated via functional
+     * indexes — requires MySQL 8.0.13+. MariaDB does not support inline functional indexes
+     * and overrides to throw at a higher level.
      */
     protected getIndexColumns(index: IndexDef): string;
     /**
@@ -32,6 +39,9 @@ export declare class MySqlSchemaHelper extends SchemaHelper {
     protected appendMySqlIndexSuffix(sql: string, index: IndexDef): string;
     getAllColumns(connection: AbstractSqlConnection, tables: Table[], ctx?: Transaction): Promise<Dictionary<Column[]>>;
     getAllChecks(connection: AbstractSqlConnection, tables: Table[], ctx?: Transaction): Promise<Dictionary<CheckDef[]>>;
+    /** Generates SQL to create MySQL triggers. MySQL requires one trigger per event. */
+    createTrigger(table: DatabaseTable, trigger: SqlTriggerDef): string;
+    getAllTriggers(connection: AbstractSqlConnection, tables: Table[]): Promise<Dictionary<SqlTriggerDef[]>>;
     getAllForeignKeys(connection: AbstractSqlConnection, tables: Table[], ctx?: Transaction): Promise<Dictionary<Dictionary<ForeignKey>>>;
     getPreAlterTable(tableDiff: TableDifference, safe: boolean): string[];
     getRenameColumnSQL(tableName: string, oldColumnName: string, to: Column): string;