@mikro-orm/sql 7.1.0-dev.2 → 7.1.0-dev.21

package/AbstractSqlConnection.d.ts

@@ -60,7 +60,7 @@ export declare abstract class AbstractSqlConnection extends Connection {
     /** Executes a SQL query and returns the result based on the method: `'all'` for rows, `'get'` for single row, `'run'` for affected count. */
     execute<T extends QueryResult | EntityData<AnyEntity> | EntityData<AnyEntity>[] = EntityData<AnyEntity>[]>(query: string | NativeQueryBuilder | RawQueryFragment, params?: readonly unknown[], method?: 'all' | 'get' | 'run', ctx?: Transaction, loggerContext?: LoggingOptions): Promise<T>;
     /** Executes a SQL query and returns an async iterable that yields results row by row. */
-    stream<T extends EntityData<AnyEntity>>(query: string | NativeQueryBuilder | RawQueryFragment, params?: readonly unknown[], ctx?: Transaction<Kysely<any>>, loggerContext?: LoggingOptions): AsyncIterableIterator<T>;
+    stream<T extends EntityData<AnyEntity>>(query: string | NativeQueryBuilder | RawQueryFragment, params?: readonly unknown[], ctx?: Transaction<Kysely<any>>, loggerContext?: LoggingOptions, chunkSize?: number): AsyncIterableIterator<T>;
     /** @inheritDoc */
     executeDump(dump: string): Promise<void>;
     protected getSql(query: string, formatted: string, context?: LogContext): string;

package/AbstractSqlConnection.js

@@ -190,7 +190,7 @@ export class AbstractSqlConnection extends Connection {
         }, { ...q, ...loggerContext });
     }
     /** Executes a SQL query and returns an async iterable that yields results row by row. */
-    async *stream(query, params = [], ctx, loggerContext) {
+    async *stream(query, params = [], ctx, loggerContext, chunkSize) {
         await this.ensureConnection();
         const q = this.prepareQuery(query, params);
         const sql = this.getSql(q.query, q.formatted, loggerContext);
@@ -203,7 +203,7 @@ export class AbstractSqlConnection extends Connection {
             parameters: [],
         };
         try {
-            const res = (ctx ?? this.getClient()).getExecutor().stream(compiled, 1);
+            const res = (ctx ?? this.getClient()).getExecutor().stream(compiled, chunkSize ?? 100);
             this.logQuery(sql, {
                 sql,
                 params,

package/AbstractSqlDriver.d.ts

@@ -31,7 +31,7 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
     protected findFromVirtual<T extends object>(entityName: EntityName<T>, where: ObjectQuery<T>, options: FindOptions<T, any> | CountOptions<T, any>, type: QueryType): Promise<EntityData<T>[] | number>;
     protected streamFromVirtual<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, options: StreamOptions<T, any>): AsyncIterableIterator<EntityData<T>>;
     protected wrapVirtualExpressionInSubquery<T extends object>(meta: EntityMetadata<T>, expression: string, where: FilterQuery<T>, options: FindOptions<T, any>, type: QueryType): Promise<T[] | number>;
-    protected wrapVirtualExpressionInSubqueryStream<T extends object>(meta: EntityMetadata<T>, expression: string, where: FilterQuery<T>, options: FindOptions<T, any, any, any>, type: QueryType.SELECT): AsyncIterableIterator<T>;
+    protected wrapVirtualExpressionInSubqueryStream<T extends object>(meta: EntityMetadata<T>, expression: string, where: FilterQuery<T>, options: StreamOptions<T, any, any, any>, type: QueryType.SELECT): AsyncIterableIterator<T>;
     /**
      * Virtual entities have no PKs, so to-many populate joins can't be deduplicated.
      * Force balanced strategy to load to-many relations via separate queries.
@@ -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>;
@@ -130,6 +147,13 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
     mapPropToFieldNames<T extends object>(qb: AnyQueryBuilder<T>, prop: EntityProperty<T>, tableAlias: string, meta: EntityMetadata<T>, schema?: string, explicitFields?: readonly InternalField<T>[]): InternalField<T>[];
     /** @internal */
     createQueryBuilder<T extends object>(entityName: EntityName<T> | AnyQueryBuilder<T>, ctx?: Transaction, preferredConnectionType?: ConnectionType, convertCustomTypes?: boolean, loggerContext?: LoggingOptions, alias?: string, em?: SqlEntityManager): AnyQueryBuilder<T>;
+    /**
+     * Renders a `FilterQuery` predicate into a SQL fragment (without the `WHERE` keyword and
+     * without table-alias prefixes) suitable for inlining into a partial-index DDL statement.
+     * Used by `DatabaseTable.addIndex` when the user passes an object `where` on `@Index` /
+     * `@Unique`. Strings are returned unchanged.
+     */
+    renderPartialIndexWhere<T extends object>(entityName: EntityName<T>, where: string | FilterQuery<T>): string;
     protected resolveConnectionType(args: {
         ctx?: Transaction;
         connectionType?: ConnectionType;

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 = {}) {
@@ -221,7 +231,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
         native.from(raw(`(${expression})${asKeyword}${this.platform.quoteIdentifier(qb.alias)}`));
         const query = native.compile();
         const connectionType = this.resolveConnectionType({ ctx: options.ctx, connectionType: options.connectionType });
-        const res = this.getConnection(connectionType).stream(query.sql, query.params, options.ctx, options.loggerContext);
+        const res = this.getConnection(connectionType).stream(query.sql, query.params, options.ctx, options.loggerContext, options.chunkSize);
         for await (const row of res) {
             yield this.mapResult(row, meta);
         }
@@ -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;
@@ -1695,6 +1944,57 @@ export class AbstractSqlDriver extends DatabaseDriver {
         }
         return qb;
     }
+    /**
+     * Renders a `FilterQuery` predicate into a SQL fragment (without the `WHERE` keyword and
+     * without table-alias prefixes) suitable for inlining into a partial-index DDL statement.
+     * Used by `DatabaseTable.addIndex` when the user passes an object `where` on `@Index` /
+     * `@Unique`. Strings are returned unchanged.
+     */
+    renderPartialIndexWhere(entityName, where) {
+        if (typeof where === 'string') {
+            return where;
+        }
+        const name = Utils.className(entityName);
+        if (where == null || (Utils.isPlainObject(where) && Object.keys(where).length === 0)) {
+            throw new Error(`Cannot render partial-index predicate for entity '${name}': \`where\` is empty.`);
+        }
+        const alias = '__p';
+        const qb = this.createQueryBuilder(entityName, undefined, undefined, undefined, undefined, alias);
+        qb.where(where);
+        const sql = qb.getFormattedQuery();
+        // Relation traversal produces join clauses whose aliased identifiers can't be inlined
+        // into a CREATE INDEX ... WHERE clause — reject with a clear error rather than emitting broken DDL.
+        if (/\bjoin\b/i.test(sql.split(/\bwhere\b/i)[0])) {
+            throw new Error(`Cannot render partial-index predicate for entity '${name}': \`where\` may not traverse relations.`);
+        }
+        // Anchor at end-of-string only — the synthetic QB has no top-level order by / limit /
+        // group by / having / offset, so any such keyword inside the captured predicate is
+        // inside a subquery and must not terminate the match.
+        const match = /\bwhere\s+([\s\S]+)$/i.exec(sql);
+        if (!match) {
+            throw new Error(`Failed to render partial-index predicate for entity '${name}': ${sql}`);
+        }
+        const quote = (s) => this.platform.quoteIdentifier(s);
+        const aliasPrefix = new RegExp(`${quote(alias).replace(/[[\]]/g, '\\$&')}\\.`, 'g');
+        const stripped = match[1].replace(aliasPrefix, '').trim();
+        // Any qualified column reference remaining after the alias strip points at another table or
+        // subquery and can't be inlined into a CREATE INDEX ... WHERE predicate. Covers both
+        // QB-generated sub-aliases (quoted, e.g. `"e0"."col"`) and raw fragments with bare refs
+        // (e.g. `raw('other_table.col = 1')`). String literals are erased first so dots inside
+        // them (e.g. JSON path operands like `'$.path'`) don't trip the guard.
+        // Both patterns use a `(?!\s*\()` lookahead so schema-qualified function calls
+        // (`pg_catalog.lower(name)`, `"public".my_func(col)`) are accepted — only `<id>.<id>` not
+        // followed by `(` is treated as a cross-table column reference.
+        const withoutStrings = stripped.replace(/'(?:[^']|'')*'/g, "''");
+        const quotedIdent = String.raw `(?:"(?:[^"]|"")+"|\`(?:[^\`]|\`\`)+\`|\[(?:[^\]]|\]\])+\])`;
+        const anyIdent = `(?:${quotedIdent}|[A-Za-z_]\\w*)`;
+        const quotedCrossRef = new RegExp(`${quotedIdent}\\s*\\.\\s*${anyIdent}(?!\\s*\\()`);
+        const bareCrossRef = /\b[A-Za-z_]\w*\s*\.\s*[A-Za-z_]\w*\b(?!\s*\()/;
+        if (quotedCrossRef.test(withoutStrings) || bareCrossRef.test(withoutStrings)) {
+            throw new Error(`Cannot render partial-index predicate for entity '${name}': \`where\` references another table or subquery which cannot be inlined into a CREATE INDEX ... WHERE clause.`);
+        }
+        return stripped;
+    }
     resolveConnectionType(args) {
         if (args.ctx) {
             return 'write';

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';
     }