@mikro-orm/sql 7.1.0-dev.1 → 7.1.0-dev.11

package/AbstractSqlDriver.d.ts

@@ -52,6 +52,12 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
     private mapJoinedProp;
     count<T extends object>(entityName: EntityName<T>, where: any, options?: CountOptions<T>): Promise<number>;
     nativeInsert<T extends object>(entityName: EntityName<T>, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T>): Promise<QueryResult<T>>;
+    nativeClone<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, overrides?: EntityData<T>, options?: NativeInsertUpdateOptions<T>): Promise<QueryResult<T>>;
+    private nativeCloneSimple;
+    private nativeCloneTPT;
+    private mapCloneOverrides;
+    private buildCloneFields;
+    private getCloneableProps;
     nativeInsertMany<T extends object>(entityName: EntityName<T>, data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T>, transform?: (sql: string) => string): Promise<QueryResult<T>>;
     nativeUpdate<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T> & UpsertOptions<T>): Promise<QueryResult<T>>;
     nativeUpdateMany<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>[], data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T> & UpsertManyOptions<T>, transform?: (sql: string, params: any[]) => string): Promise<QueryResult<T>>;
@@ -77,11 +83,22 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
      * Uses single query with join via virtual relation on pivot.
      */
     protected loadPolymorphicPivotInverseSide<T extends object, O extends object>(prop: EntityProperty, owners: Primary<O>[][], where: FilterQuery<any>, orderBy?: OrderDefinition<T>, ctx?: Transaction, options?: FindOptions<T, any, any, any>): Promise<Dictionary<T[]>>;
+    /**
+     * Load a union-target polymorphic M:N pivot (e.g. Post.attachments -> Image | Video).
+     * Each pivot row's discriminator column selects which target table to hydrate.
+     */
+    protected loadFromUnionTargetPolymorphicPivotTable<T extends object, O extends object>(prop: EntityProperty, owners: Primary<O>[][], where?: FilterQuery<any>, orderBy?: OrderDefinition<T>, ctx?: Transaction, options?: FindOptions<T, any, any, any>, pivotJoin?: boolean): Promise<Dictionary<T[]>>;
     /**
      * Build a map from owner PKs to their related entities from pivot table results.
      */
     private buildPivotResultMap;
     private wrapPopulateFilter;
+    /**
+     * The pivot query builder doesn't convert custom types — manually convert owner PKs to the DB
+     * representation. Returns `needsConversion` + `pkProp` so the caller can convert result FKs back
+     * to JS format for consistent key hashing in `buildPivotResultMap`.
+     */
+    private convertOwnerPksForPivotQuery;
     private getPivotOrderBy;
     execute<T extends QueryResult | EntityData<AnyEntity> | EntityData<AnyEntity>[] = EntityData<AnyEntity>[]>(query: string | NativeQueryBuilder | RawQueryFragment, params?: any[], method?: 'all' | 'get' | 'run', ctx?: Transaction, loggerContext?: LoggingOptions): Promise<T>;
     stream<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, options: StreamOptions<T, any, any, any>): AsyncIterableIterator<T>;

package/AbstractSqlDriver.js

@@ -34,6 +34,13 @@ export class AbstractSqlDriver extends DatabaseDriver {
         return { alias, name: meta.tableName, schema: effectiveSchema, qualifiedName, toString: () => alias };
     }
     validateSqlOptions(options) {
+        if (options.using && !options.indexHint) {
+            const names = Utils.asArray(options.using);
+            const hint = this.platform.formatIndexHint(names);
+            if (hint) {
+                options.indexHint = hint;
+            }
+        }
         if (options.collation != null && typeof options.collation !== 'string') {
             throw new Error('Collation option for SQL drivers must be a string (collation name). Use a CollationOptions object only with MongoDB.');
         }
@@ -88,6 +95,9 @@ export class AbstractSqlDriver extends DatabaseDriver {
         if (options.em) {
             await qb.applyJoinedFilters(options.em, options.filters);
         }
+        if (options._partitionLimit) {
+            qb.setPartitionLimit(options._partitionLimit);
+        }
         return qb;
     }
     async find(entityName, where, options = {}) {
@@ -574,6 +584,109 @@ export class AbstractSqlDriver extends DatabaseDriver {
         await this.processManyToMany(meta, pk, collections, false, options);
         return res;
     }
+    async nativeClone(entityName, where, overrides, options = {}) {
+        options.convertCustomTypes ??= true;
+        const meta = this.metadata.get(entityName);
+        if (meta.inheritanceType === 'tpt' || meta.tptParent) {
+            return this.nativeCloneTPT(meta, where, overrides, options);
+        }
+        return this.nativeCloneSimple(meta, where, overrides, options);
+    }
+    async nativeCloneSimple(meta, where, overrides, options = {}) {
+        const props = this.getCloneableProps(meta);
+        const mappedOverrides = this.mapCloneOverrides(overrides, meta, options);
+        const { selectFields, insertColumns } = this.buildCloneFields(props, mappedOverrides, meta);
+        const selectQb = this.createQueryBuilder(meta.class, options.ctx, 'read', options.convertCustomTypes, options.loggerContext).withSchema(this.getSchemaName(meta, options));
+        selectQb.select(selectFields).where(where);
+        const insertQb = this.createQueryBuilder(meta.class, options.ctx, 'write', options.convertCustomTypes, options.loggerContext).withSchema(this.getSchemaName(meta, options));
+        return this.rethrow(insertQb
+            .insertFrom(selectQb, { columns: insertColumns })
+            .execute('run', false));
+    }
+    async nativeCloneTPT(leafMeta, where, overrides, options = {}) {
+        const hierarchy = [];
+        let current = leafMeta;
+        while (current) {
+            hierarchy.unshift(current);
+            current = current.tptParent;
+        }
+        const rootMeta = hierarchy[0];
+        let newPk;
+        let rootResult;
+        for (const tableMeta of hierarchy) {
+            const props = this.getCloneableProps(tableMeta, true);
+            const mappedOverrides = this.mapCloneOverrides(overrides, tableMeta, options);
+            const { selectFields, insertColumns } = this.buildCloneFields(props, mappedOverrides, tableMeta);
+            // For child tables, prepend the new PK value
+            if (tableMeta !== rootMeta && newPk != null) {
+                for (const pkName of tableMeta.primaryKeys) {
+                    const prop = tableMeta.properties[pkName];
+                    for (const fieldName of prop.fieldNames) {
+                        insertColumns.unshift(fieldName);
+                        selectFields.unshift(raw('? as ??', [newPk, fieldName]));
+                    }
+                }
+            }
+            const sourceWhere = tableMeta === rootMeta ? where : (Utils.extractPK(where, tableMeta) ?? where);
+            const selectQb = this.createQueryBuilder(tableMeta.class, options.ctx, 'read', options.convertCustomTypes, options.loggerContext).withSchema(this.getSchemaName(tableMeta, options));
+            selectQb.select(selectFields).where(sourceWhere);
+            const insertQb = this.createQueryBuilder(tableMeta.class, options.ctx, 'write', options.convertCustomTypes, options.loggerContext).withSchema(this.getSchemaName(tableMeta, options));
+            const res = await this.rethrow(insertQb
+                .insertFrom(selectQb, { columns: insertColumns })
+                .execute('run', false));
+            if (tableMeta === rootMeta) {
+                rootResult = res;
+                newPk = res.insertId ?? res.row?.[rootMeta.primaryKeys[0]];
+            }
+        }
+        return rootResult;
+    }
+    mapCloneOverrides(overrides, meta, options) {
+        if (!overrides) {
+            return undefined;
+        }
+        return super.mapDataToFieldNames(overrides, true, meta.properties, options.convertCustomTypes);
+    }
+    buildCloneFields(props, mappedOverrides, meta) {
+        const selectFields = [];
+        const insertColumns = [];
+        for (const prop of props) {
+            for (const fieldName of prop.fieldNames) {
+                insertColumns.push(fieldName);
+                if (mappedOverrides && fieldName in mappedOverrides) {
+                    selectFields.push(raw('? as ??', [mappedOverrides[fieldName], fieldName]));
+                }
+                else if (meta.versionProperty === prop.name) {
+                    const initial = prop.runtimeType === 'Date' ? new Date() : 1;
+                    selectFields.push(raw('? as ??', [initial, fieldName]));
+                }
+                else {
+                    selectFields.push(fieldName);
+                }
+            }
+        }
+        return { selectFields, insertColumns };
+    }
+    getCloneableProps(meta, ownProps) {
+        return (ownProps ? (meta.ownProps ?? meta.props) : meta.props).filter(prop => {
+            if (prop.persist === false) {
+                return false;
+            }
+            if (prop.primary) {
+                return false;
+            }
+            if (!prop.fieldNames?.length) {
+                return false;
+            }
+            if ([ReferenceKind.ONE_TO_MANY, ReferenceKind.MANY_TO_MANY].includes(prop.kind)) {
+                return false;
+            }
+            if (prop.kind === ReferenceKind.EMBEDDED && !prop.object) {
+                return false;
+            }
+            return true;
+        });
+    }
     async nativeInsertMany(entityName, data, options = {}, transform) {
         options.processCollections ??= true;
         options.convertCustomTypes ??= true;
@@ -996,8 +1109,29 @@ export class AbstractSqlDriver extends DatabaseDriver {
             const pks = wrapped.getPrimaryKeys(true);
             const snap = coll.getSnapshot();
             const includes = (arr, item) => !!arr.find(i => this.comparePrimaryKeyArrays(i, item));
-            const snapshot = snap ? snap.map(item => helper(item).getPrimaryKeys(true)) : [];
-            const current = coll.getItems(false).map(item => helper(item).getPrimaryKeys(true));
+            // For union-target polymorphic M:N, prepend the per-row discriminator value so the pivot
+            // persister can write it alongside the FK id. Memoized per sync-run because a collection can
+            // hold hundreds of items of the same few types, and findDiscriminatorValue walks the prototype
+            // chain + re-scans Object.entries each call.
+            const isUnionTargetMN = QueryHelper.isUnionTargetPolymorphic(coll.property);
+            const classToDisc = new Map();
+            const toDiff = (item) => {
+                const keys = helper(item).getPrimaryKeys(true);
+                if (!isUnionTargetMN) {
+                    return keys;
+                }
+                let disc = classToDisc.get(item.constructor);
+                if (!classToDisc.has(item.constructor)) {
+                    disc = QueryHelper.findDiscriminatorValue(coll.property.discriminatorMap, item.constructor);
+                    if (disc === undefined) {
+                        throw new Error(`Cannot resolve discriminator value for ${item.constructor.name} in ${coll.property.name}; the class is not part of the union target list.`);
+                    }
+                    classToDisc.set(item.constructor, disc);
+                }
+                return [disc, ...keys];
+            };
+            const snapshot = snap ? snap.map(toDiff) : [];
+            const current = coll.getItems(false).map(toDiff);
             const deleteDiff = snap ? snapshot.filter(item => !includes(current, item)) : true;
             const insertDiff = current.filter(item => !includes(snapshot, item));
             const target = snapshot.filter(item => includes(current, item)).concat(...insertDiff);
@@ -1069,21 +1203,16 @@ export class AbstractSqlDriver extends DatabaseDriver {
             return {};
         }
         const pivotMeta = this.metadata.get(prop.pivotEntity);
+        if (prop.discriminatorColumn && QueryHelper.isUnionTargetPolymorphic(prop)) {
+            return this.loadFromUnionTargetPolymorphicPivotTable(prop, owners, where, orderBy, ctx, options, pivotJoin);
+        }
         if (prop.polymorphic && prop.discriminatorColumn && prop.discriminatorValue) {
             return this.loadFromPolymorphicPivotTable(prop, owners, where, orderBy, ctx, options, pivotJoin);
         }
         const pivotProp1 = pivotMeta.relations[prop.owner ? 1 : 0];
         const pivotProp2 = pivotMeta.relations[prop.owner ? 0 : 1];
         const ownerMeta = pivotProp2.targetMeta;
-        // The pivot query builder doesn't convert custom types, so we need to manually
-        // convert owner PKs to DB format for the query and convert result FKs back to
-        // JS format for consistent key hashing in buildPivotResultMap.
-        const pkProp = ownerMeta.properties[ownerMeta.primaryKeys[0]];
-        const needsConversion = pkProp?.customType?.ensureComparable(ownerMeta, pkProp) && !ownerMeta.compositePK;
-        let ownerPks = ownerMeta.compositePK ? owners : owners.map(o => o[0]);
-        if (needsConversion) {
-            ownerPks = ownerPks.map(v => pkProp.customType.convertToDatabaseValue(v, this.platform, { mode: 'query' }));
-        }
+        const { ownerPks, needsConversion, pkProp } = this.convertOwnerPksForPivotQuery(owners, ownerMeta);
         const cond = {
             [pivotProp2.name]: { $in: ownerPks },
         };
@@ -1098,7 +1227,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
         const fields = pivotJoin
             ? [pivotProp1.name, pivotProp2.name]
             : [pivotProp1.name, pivotProp2.name, ...childFields];
-        const res = await this.find(pivotMeta.class, where, {
+        const pivotFindOptions = {
             ctx,
             ...options,
             fields,
@@ -1114,10 +1243,13 @@ export class AbstractSqlDriver extends DatabaseDriver {
                 },
             ],
             populateWhere: undefined,
-            // @ts-ignore
             _populateWhere: 'infer',
             populateFilter: this.wrapPopulateFilter(options, pivotProp2.name),
-        });
+        };
+        if (pivotFindOptions._partitionLimit) {
+            pivotFindOptions._partitionLimit.partitionBy = pivotProp2.name;
+        }
+        const res = await this.find(pivotMeta.class, where, pivotFindOptions);
         // Convert result FK values back to JS format so key hashing
         // in buildPivotResultMap is consistent with the owner keys.
         if (needsConversion) {
@@ -1237,6 +1369,102 @@ export class AbstractSqlDriver extends DatabaseDriver {
         });
         return this.buildPivotResultMap(owners, res, tagProp.name, ownerRelationName);
     }
+    /**
+     * Load a union-target polymorphic M:N pivot (e.g. Post.attachments -> Image | Video).
+     * Each pivot row's discriminator column selects which target table to hydrate.
+     */
+    async loadFromUnionTargetPolymorphicPivotTable(prop, owners, where = {}, orderBy, ctx, options = {}, pivotJoin) {
+        // :ref hints cannot be honored for union-target — EntityLoader.getReference needs a concrete
+        // class per item, but the ref-mode map only carries flat PK values and would hydrate every
+        // row as the first polymorph target. Fail loudly instead of silently corrupting the collection.
+        if (pivotJoin) {
+            throw new Error(`The ':ref' populate hint is not supported for union-target polymorphic M:N on ${prop.name}. Use a regular populate hint instead.`);
+        }
+        const pivotMeta = this.metadata.get(prop.pivotEntity);
+        const targets = prop.polymorphTargets;
+        const ownerProp = pivotMeta.relations.find(r => r.persist !== false && !r.polymorphic);
+        const discriminatorColumn = prop.discriminatorColumn;
+        const ownerMeta = ownerProp.targetMeta;
+        const { ownerPks, needsConversion, pkProp } = this.convertOwnerPksForPivotQuery(owners, ownerMeta);
+        const pivotRows = (await this.find(pivotMeta.class, { [ownerProp.name]: { $in: ownerPks } }, {
+            ctx,
+            orderBy: this.getPivotOrderBy(prop, ownerProp, orderBy, options?.orderBy),
+            fields: [ownerProp.name, discriminatorColumn, prop.discriminator],
+            populateWhere: undefined,
+            // @ts-ignore
+            _populateWhere: 'infer',
+        }));
+        /* v8 ignore next 7 - custom-type PK conversion, tested via loadFromPivotTable path */
+        if (needsConversion) {
+            for (const item of pivotRows) {
+                const fk = item[ownerProp.name];
+                if (fk != null) {
+                    item[ownerProp.name] = pkProp.customType.convertToJSValue(fk, this.platform);
+                }
+            }
+        }
+        const classMeta = new Map(targets.map(t => [t.class, t]));
+        const rowsByTarget = new Map();
+        for (const row of pivotRows) {
+            const discValue = row[discriminatorColumn];
+            const targetClass = prop.discriminatorMap[discValue];
+            const targetMeta = classMeta.get(targetClass);
+            /* v8 ignore next 3 - defensive: unknown discriminator value */
+            if (!targetMeta) {
+                continue;
+            }
+            const list = rowsByTarget.get(targetMeta) ?? [];
+            list.push(row);
+            rowsByTarget.set(targetMeta, list);
+        }
+        // Strip the outer find's orderBy/fields/exclude before bulk-loading targets by PK — those apply
+        // to the owner query, not each polymorph target (Image and Video wouldn't share an orderBy field).
+        // populateFilter is a filter on the populated collection; since union-target splits the pivot
+        // and target queries, we merge it into the target-level `where` instead of wrapping it on the
+        // pivot query (where joins to target tables aren't available).
+        // Hoisted above the loop since `options` doesn't change per target.
+        const { orderBy: _o, fields: _f, exclude: _e, populateFilter, ...childOptions } = options;
+        const populate = options.populate ?? [];
+        const orphanedRows = new Set();
+        for (const [targetMeta, rows] of rowsByTarget) {
+            const targetIds = rows.map(r => r[prop.discriminator]);
+            // Union-target pivot stores one scalar FK per row; composite-PK targets are rejected at
+            // metadata validation time, so a single primary key column is guaranteed here.
+            const pkCol = targetMeta.primaryKeys[0];
+            let cond = { [pkCol]: { $in: targetIds } };
+            if (!Utils.isEmpty(where)) {
+                cond = { $and: [cond, where] };
+            }
+            if (!Utils.isEmpty(populateFilter)) {
+                cond = { $and: [cond, populateFilter] };
+            }
+            const results = (await this.find(targetMeta.class, cond, {
+                ctx,
+                ...childOptions,
+                populate: populate,
+            }));
+            const byPk = new Map();
+            for (const row of results) {
+                Object.defineProperty(row, 'constructor', {
+                    value: targetMeta.class,
+                    enumerable: false,
+                    configurable: true,
+                });
+                byPk.set(Utils.getPrimaryKeyHash([row[pkCol]]), row);
+            }
+            for (const row of rows) {
+                const pkHash = Utils.getPrimaryKeyHash([row[prop.discriminator]]);
+                const entity = byPk.get(pkHash);
+                if (entity == null) {
+                    orphanedRows.add(row);
+                    continue;
+                }
+                row[prop.discriminator] = entity;
+            }
+        }
+        const result = orphanedRows.size > 0 ? pivotRows.filter(r => !orphanedRows.has(r)) : pivotRows;
+        return this.buildPivotResultMap(owners, result, ownerProp.name, prop.discriminator);
+    }
     /**
      * Build a map from owner PKs to their related entities from pivot table results.
      */
@@ -1261,6 +1489,21 @@ export class AbstractSqlDriver extends DatabaseDriver {
         }
         return undefined;
     }
+    /**
+     * The pivot query builder doesn't convert custom types — manually convert owner PKs to the DB
+     * representation. Returns `needsConversion` + `pkProp` so the caller can convert result FKs back
+     * to JS format for consistent key hashing in `buildPivotResultMap`.
+     */
+    convertOwnerPksForPivotQuery(owners, ownerMeta) {
+        const pkProp = ownerMeta.properties[ownerMeta.primaryKeys[0]];
+        const needsConversion = !!pkProp?.customType?.ensureComparable(ownerMeta, pkProp) && !ownerMeta.compositePK;
+        let ownerPks = ownerMeta.compositePK ? owners : owners.map(o => o[0]);
+        /* v8 ignore next 4 - custom-type PK conversion, tested via loadFromPivotTable path */
+        if (needsConversion) {
+            ownerPks = ownerPks.map(v => pkProp.customType.convertToDatabaseValue(v, this.platform, { mode: 'query' }));
+        }
+        return { ownerPks, needsConversion, pkProp };
+    }
     getPivotOrderBy(prop, pivotProp, orderBy, parentOrderBy) {
         if (!Utils.isEmpty(orderBy) || RawQueryFragment.hasObjectFragments(orderBy)) {
             return Utils.asArray(orderBy).map(o => ({ [pivotProp.name]: o }));
@@ -1327,6 +1570,12 @@ export class AbstractSqlDriver extends DatabaseDriver {
             if (ref && [ReferenceKind.ONE_TO_ONE, ReferenceKind.MANY_TO_ONE].includes(prop.kind)) {
                 return true;
             }
+            // Union-target polymorphic M:N cannot be loaded via a single JOIN because rows span multiple
+            // target tables; fall through to SELECT_IN which dispatches through `loadFromPivotTable`.
+            // Polymorphic M:1 (to-one with target_type discriminator) is handled via LEFT JOINs elsewhere.
+            if (prop.kind === ReferenceKind.MANY_TO_MANY && QueryHelper.isUnionTargetPolymorphic(prop) && prop.owner) {
+                return false;
+            }
             // skip redundant joins for 1:1 owner population hints when using `mapToPk`
             if (prop.kind === ReferenceKind.ONE_TO_ONE && prop.mapToPk && prop.owner) {
                 return false;

package/PivotCollectionPersister.js

@@ -1,3 +1,4 @@
+import { QueryHelper, } from '@mikro-orm/core';
 class InsertStatement {
     order;
     #keys;
@@ -106,6 +107,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 +127,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 };

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 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';
@@ -29,6 +29,10 @@ export declare class SqlEntityManager<Driver extends AbstractSqlDriver = Abstrac
     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. */
     execute<T extends QueryResult | EntityData<AnyEntity> | EntityData<AnyEntity>[] = EntityData<AnyEntity>[]>(query: string | NativeQueryBuilder | RawQueryFragment, params?: any[], method?: 'all' | 'get' | 'run', loggerContext?: LoggingOptions): 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
@@ -35,6 +35,41 @@ export class SqlEntityManager extends EntityManager {
     async execute(query, params = [], method = 'all', loggerContext) {
         return this.getDriver().execute(query, params, method, this.getContext(false).getTransactionContext(), loggerContext);
     }
+    /**
+     * @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/dialects/mssql/MsSqlNativeQueryBuilder.js

@@ -56,6 +56,10 @@ export class MsSqlNativeQueryBuilder extends NativeQueryBuilder {
         return this.combineParts();
     }
     compileInsert() {
+        if (this.options.insertSubQuery) {
+            super.compileInsert();
+            return;
+        }
         if (!this.options.data) {
             throw new Error('No data provided');
         }

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?: {

package/dialects/mysql/BaseMySqlPlatform.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';
     }

package/dialects/mysql/MySqlNativeQueryBuilder.js

@@ -3,6 +3,17 @@ import { NativeQueryBuilder } from '../../query/NativeQueryBuilder.js';
 /** @internal */
 export class MySqlNativeQueryBuilder extends NativeQueryBuilder {
     compileInsert() {
+        if (this.options.insertSubQuery) {
+            super.compileInsert();
+            // Inject 'ignore' after 'insert' for MySQL's INSERT IGNORE ... SELECT syntax
+            if (this.options.onConflict?.ignore) {
+                const insertIdx = this.parts.indexOf('insert');
+                if (insertIdx >= 0) {
+                    this.parts.splice(insertIdx + 1, 0, 'ignore');
+                }
+            }
+            return;
+        }
         if (!this.options.data) {
             throw new Error('No data provided');
         }

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';
@@ -32,6 +32,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;

package/dialects/mysql/MySqlSchemaHelper.js

@@ -64,11 +64,15 @@ export class MySqlSchemaHelper extends SchemaHelper {
         const checks = await this.getAllChecks(connection, tables, ctx);
         const fks = await this.getAllForeignKeys(connection, tables, ctx);
         const enums = await this.getAllEnumDefinitions(connection, tables, ctx);
+        const triggers = await this.getAllTriggers(connection, tables);
         for (const t of tables) {
             const key = this.getTableKey(t);
             const table = schema.addTable(t.table_name, t.schema_name, t.table_comment);
             const pks = await this.getPrimaryKeys(connection, indexes[key], table.name, table.schema);
             table.init(columns[key], indexes[key], checks[key], pks, fks[key], enums[key]);
+            if (triggers[key]) {
+                table.setTriggers(triggers[key]);
+            }
         }
     }
     async getAllIndexes(connection, tables, ctx) {
@@ -264,6 +268,85 @@ export class MySqlSchemaHelper extends SchemaHelper {
         }
         return ret;
     }
+    /** Generates SQL to create MySQL triggers. MySQL requires one trigger per event. */
+    createTrigger(table, trigger) {
+        if (trigger.expression) {
+            return trigger.expression;
+        }
+        /* v8 ignore next 3 */
+        if (trigger.timing === 'instead of') {
+            throw new Error(`MySQL does not support INSTEAD OF triggers. Use BEFORE or AFTER for trigger "${trigger.name}".`);
+        }
+        /* v8 ignore next 5 */
+        if (trigger.forEach === 'statement') {
+            throw new Error(`MySQL does not support FOR EACH STATEMENT triggers. Use FOR EACH ROW for trigger "${trigger.name}".`);
+        }
+        const timing = trigger.timing.toUpperCase();
+        const ret = [];
+        for (const event of trigger.events) {
+            const name = trigger.events.length > 1 ? `${trigger.name}_${event}` : trigger.name;
+            ret.push(`create trigger ${this.quote(name)} ${timing} ${event.toUpperCase()} on ${table.getQuotedName()} for each ROW begin ${trigger.body}; end`);
+        }
+        return ret.join(';\n');
+    }
+    async getAllTriggers(connection, tables) {
+        const names = tables.map(t => this.platform.quoteValue(t.table_name)).join(', ');
+        const sql = `select trigger_name as trigger_name, event_object_table as table_name, nullif(event_object_schema, schema()) as schema_name,
+      event_manipulation as event, action_timing as timing,
+      action_orientation as for_each, action_statement as body
+    from information_schema.triggers
+    where event_object_schema = database()
+      and event_object_table in (${names})
+    order by trigger_name, event_manipulation`;
+        const allTriggers = await connection.execute(sql);
+        const ret = {};
+        // First pass: collect all raw trigger names per table to detect multi-event groups.
+        // A base name is only used for grouping if multiple triggers share it (e.g. trg_multi_insert + trg_multi_update).
+        const namesByTable = new Map();
+        for (const row of allTriggers) {
+            const key = this.getTableKey(row);
+            namesByTable.set(key, [...(namesByTable.get(key) ?? []), row.trigger_name]);
+        }
+        const triggerMap = new Map();
+        for (const row of allTriggers) {
+            const key = this.getTableKey(row);
+            const eventLower = row.event.toLowerCase();
+            const tableNames = namesByTable.get(key) ?? [];
+            // Only strip event suffix when another trigger with the same base exists for this table
+            const candidateBase = row.trigger_name.endsWith(`_${eventLower}`)
+                ? row.trigger_name.slice(0, -eventLower.length - 1)
+                : null;
+            const baseName = candidateBase && tableNames.some(n => n !== row.trigger_name && n.startsWith(`${candidateBase}_`))
+                ? candidateBase
+                : row.trigger_name;
+            const dedupeKey = `${key}:${baseName}`;
+            if (triggerMap.has(dedupeKey)) {
+                const existing = triggerMap.get(dedupeKey);
+                const event = eventLower;
+                if (!existing.events.includes(event)) {
+                    existing.events.push(event);
+                }
+                continue;
+            }
+            ret[key] ??= [];
+            // Strip BEGIN/END wrapper from MySQL action_statement
+            let body = row.body ?? '';
+            const beginEndMatch = /^\s*begin\s+([\s\S]*)\s*end\s*$/i.exec(body);
+            if (beginEndMatch) {
+                body = beginEndMatch[1].trim().replace(/;\s*$/, '');
+            }
+            const trigger = {
+                name: baseName,
+                timing: row.timing.toLowerCase(),
+                events: [eventLower],
+                forEach: (row.for_each ?? 'row').toLowerCase(),
+                body,
+            };
+            ret[key].push(trigger);
+            triggerMap.set(dedupeKey, trigger);
+        }
+        return ret;
+    }
     async getAllForeignKeys(connection, tables, ctx) {
         const sql = `select k.constraint_name as constraint_name, nullif(k.table_schema, schema()) as schema_name, k.table_name as table_name, k.column_name as column_name, k.referenced_table_name as referenced_table_name, k.referenced_column_name as referenced_column_name, c.update_rule as update_rule, c.delete_rule as delete_rule
         from information_schema.key_column_usage k