@mikro-orm/sql 7.0.17-dev.9 → 7.0.18-dev.0

package/AbstractSqlDriver.js

@@ -3,6 +3,28 @@ import { QueryBuilder } from './query/QueryBuilder.js';
 import { JoinType, QueryType } from './query/enums.js';
 import { SqlEntityManager } from './SqlEntityManager.js';
 import { PivotCollectionPersister } from './PivotCollectionPersister.js';
+/** Extracts cancellation controls from any options bag that extends `AbortQueryOptions`. */
+function pickAbortOptions(options) {
+    if (!options || (options.signal == null && options.inflightQueryAbortStrategy == null)) {
+        return undefined;
+    }
+    return {
+        signal: options.signal,
+        inflightQueryAbortStrategy: options.inflightQueryAbortStrategy,
+    };
+}
+/**
+ * Returns a `loggerContext` payload that carries the abort fields alongside any existing
+ * context. The connection layer strips them before logging — this avoids widening the public
+ * `Connection.execute()` signature.
+ */
+function withAbortContext(loggerContext, options) {
+    const abort = pickAbortOptions(options);
+    if (!abort) {
+        return loggerContext;
+    }
+    return { ...loggerContext, ...abort };
+}
 /** Base class for SQL database drivers, implementing find/insert/update/delete using QueryBuilder. */
 export class AbstractSqlDriver extends DatabaseDriver {
     [EntityManagerType];
@@ -34,6 +56,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.');
         }
@@ -53,6 +82,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
         const qb = this.createQueryBuilder(meta.class, options.ctx, connectionType, false, options.logging, undefined, options.em)
             .withSchema(schema)
             .cache(false);
+        qb.setAbortOptions(pickAbortOptions(options));
         const fields = this.buildFields(meta, populate, joinedProps, qb, qb.alias, options, schema);
         const orderBy = this.buildOrderBy(qb, meta, populate, options);
         const populateWhere = this.buildPopulateWhere(meta, joinedProps, options);
@@ -90,6 +120,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 = {}) {
@@ -206,7 +239,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
         const asKeyword = this.platform.usesAsKeyword() ? ' as ' : ' ';
         native.from(raw(`(${expression})${asKeyword}${this.platform.quoteIdentifier(qb.alias)}`));
         const query = native.compile();
-        const res = await this.execute(query.sql, query.params, 'all', options.ctx);
+        const res = await this.execute(query.sql, query.params, 'all', options.ctx, withAbortContext(options.loggerContext, options));
         if (type === QueryType.COUNT) {
             return res[0].count;
         }
@@ -223,7 +256,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, withAbortContext(options.loggerContext, options), options.chunkSize);
         for await (const row of res) {
             yield this.mapResult(row, meta);
         }
@@ -531,6 +564,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
         const joinedProps = this.joinedProps(meta, populate, options);
         const schema = this.getSchemaName(meta, options);
         const qb = this.createQueryBuilder(entityName, options.ctx, options.connectionType, false, options.logging);
+        qb.setAbortOptions(pickAbortOptions(options));
         const populateWhere = this.buildPopulateWhere(meta, joinedProps, options);
         if (meta && !Utils.isEmpty(populate)) {
             this.buildFields(meta, populate, joinedProps, qb, qb.alias, options, schema);
@@ -556,6 +590,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
         const meta = this.metadata.get(entityName);
         const collections = this.extractManyToMany(meta, data);
         const qb = this.createQueryBuilder(entityName, options.ctx, 'write', options.convertCustomTypes, options.loggerContext).withSchema(this.getSchemaName(meta, options));
+        qb.setAbortOptions(pickAbortOptions(options));
         const res = await this.rethrow(qb.insert(data).execute('run', false));
         res.row = res.row || {};
         let pk;
@@ -576,6 +611,115 @@ 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 abort = pickAbortOptions(options);
+        const selectQb = this.createQueryBuilder(meta.class, options.ctx, 'read', options.convertCustomTypes, options.loggerContext).withSchema(this.getSchemaName(meta, options));
+        selectQb.select(selectFields).where(where);
+        selectQb.setAbortOptions(abort);
+        const insertQb = this.createQueryBuilder(meta.class, options.ctx, 'write', options.convertCustomTypes, options.loggerContext).withSchema(this.getSchemaName(meta, options));
+        insertQb.setAbortOptions(abort);
+        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 abort = pickAbortOptions(options);
+            const selectQb = this.createQueryBuilder(tableMeta.class, options.ctx, 'read', options.convertCustomTypes, options.loggerContext).withSchema(this.getSchemaName(tableMeta, options));
+            selectQb.select(selectFields).where(sourceWhere);
+            selectQb.setAbortOptions(abort);
+            const insertQb = this.createQueryBuilder(tableMeta.class, options.ctx, 'write', options.convertCustomTypes, options.loggerContext).withSchema(this.getSchemaName(tableMeta, options));
+            insertQb.setAbortOptions(abort);
+            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;
@@ -727,7 +871,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
         if (transform) {
             sql = transform(sql);
         }
-        const res = await this.execute(sql, params, 'run', options.ctx, options.loggerContext);
+        const res = await this.execute(sql, params, 'run', options.ctx, withAbortContext(options.loggerContext, options));
         let pk;
         /* v8 ignore next */
         if (pks.length > 1) {
@@ -760,6 +904,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
         }
         if (Utils.hasObjectKeys(data)) {
             const qb = this.createQueryBuilder(entityName, options.ctx, 'write', options.convertCustomTypes, options.loggerContext).withSchema(this.getSchemaName(meta, options));
+            qb.setAbortOptions(pickAbortOptions(options));
             if (options.upsert) {
                 /* v8 ignore next */
                 const uniqueFields = options.onConflictFields ??
@@ -805,6 +950,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
                     ? Object.keys(where[0]).flatMap(key => Utils.splitPrimaryKeys(key))
                     : meta.primaryKeys);
             const qb = this.createQueryBuilder(entityName, options.ctx, 'write', options.convertCustomTypes, options.loggerContext).withSchema(this.getSchemaName(meta, options));
+            qb.setAbortOptions(pickAbortOptions(options));
             const returning = getOnConflictReturningFields(meta, data[0], uniqueFields, options);
             qb.insert(data)
                 .onConflict(uniqueFields)
@@ -950,7 +1096,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
         if (transform) {
             sql = transform(sql, params);
         }
-        const res = await this.rethrow(this.execute(sql, params, 'run', options.ctx, options.loggerContext));
+        const res = await this.rethrow(this.execute(sql, params, 'run', options.ctx, withAbortContext(options.loggerContext, options)));
         for (let i = 0; i < collections.length; i++) {
             await this.processManyToMany(meta, where[i], collections[i], false, options);
         }
@@ -968,6 +1114,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
         const qb = this.createQueryBuilder(entityName, options.ctx, 'write', false, options.loggerContext)
             .delete(where)
             .withSchema(this.getSchemaName(meta, options));
+        qb.setAbortOptions(pickAbortOptions(options));
         return this.rethrow(qb.execute('run', false));
     }
     /**
@@ -998,8 +1145,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);
@@ -1017,6 +1185,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
             if (coll.property.kind === ReferenceKind.ONE_TO_MANY) {
                 const cols = coll.property.referencedColumnNames;
                 const qb = this.createQueryBuilder(coll.property.targetMeta.class, options?.ctx, 'write').withSchema(this.getSchemaName(meta, options));
+                qb.setAbortOptions(pickAbortOptions(options));
                 if (coll.getSnapshot() === undefined) {
                     if (coll.property.orphanRemoval) {
                         const query = qb
@@ -1058,7 +1227,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
                 schema = this.config.get('schema');
             }
             const tableName = `${schema ?? '_'}.${pivotMeta.tableName}`;
-            const persister = (groups[tableName] ??= new PivotCollectionPersister(pivotMeta, this, options?.ctx, schema, options?.loggerContext));
+            const persister = (groups[tableName] ??= new PivotCollectionPersister(pivotMeta, this, options?.ctx, schema, options?.loggerContext, pickAbortOptions(options)));
             persister.enqueueUpdate(coll.property, insertDiff, deleteDiff, pks, coll.isInitialized());
         }
         for (const persister of Utils.values(groups)) {
@@ -1071,21 +1240,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 },
         };
@@ -1100,7 +1264,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,
@@ -1116,10 +1280,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) {
@@ -1239,6 +1406,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.
      */
@@ -1263,6 +1526,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 }));
@@ -1329,6 +1607,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;
@@ -1713,6 +1997,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';
@@ -1739,7 +2074,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
         for (const prop of meta.relations) {
             if (collections[prop.name]) {
                 const pivotMeta = this.metadata.get(prop.pivotEntity);
-                const persister = new PivotCollectionPersister(pivotMeta, this, options?.ctx, options?.schema, options?.loggerContext);
+                const persister = new PivotCollectionPersister(pivotMeta, this, options?.ctx, options?.schema, options?.loggerContext, pickAbortOptions(options));
                 persister.enqueueUpdate(prop, collections[prop.name], clear, pks);
                 await this.rethrow(persister.execute());
             }
@@ -1748,6 +2083,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
     async lockPessimistic(entity, options) {
         const meta = helper(entity).__meta;
         const qb = this.createQueryBuilder(meta.class, options.ctx, undefined, undefined, options.logging).withSchema(options.schema ?? meta.schema);
+        qb.setAbortOptions(pickAbortOptions(options));
         const cond = Utils.getPrimaryKeyCond(entity, meta.primaryKeys);
         qb.select(raw('1'))
             .where(cond)

package/AbstractSqlPlatform.d.ts

@@ -51,8 +51,19 @@ export declare abstract class AbstractSqlPlatform extends Platform {
      * @internal
      */
     quoteCollation(collation: string): string;
-    /** @internal */
-    protected validateCollationName(collation: string): void;
+    /**
+     * PG ICU locale names include hyphens (`en-US-x-icu`) and libc locales include dots (`en_US.utf8`),
+     * so word-chars alone would reject valid real-world collations.
+     * @internal
+     */
+    validateCollationName(collation: string): void;
+    /**
+     * Whether collation names compare case-insensitively in this dialect. MySQL/MariaDB, MSSQL, and
+     * SQLite use case-insensitive collation identifiers; PostgreSQL stores them as case-sensitive
+     * names in `pg_collation` (e.g. `en-US-x-icu` is distinct from `EN-US-X-ICU`).
+     * @internal
+     */
+    caseInsensitiveCollationNames(): boolean;
     /** @internal */
     validateJsonPropertyName(name: string): void;
     /**

package/AbstractSqlPlatform.js

@@ -128,12 +128,25 @@ export class AbstractSqlPlatform extends Platform {
         this.validateCollationName(collation);
         return this.quoteIdentifier(collation);
     }
-    /** @internal */
+    /**
+     * PG ICU locale names include hyphens (`en-US-x-icu`) and libc locales include dots (`en_US.utf8`),
+     * so word-chars alone would reject valid real-world collations.
+     * @internal
+     */
     validateCollationName(collation) {
-        if (!/^[\w]+$/.test(collation)) {
-            throw new Error(`Invalid collation name: '${collation}'. Collation names must contain only word characters.`);
+        if (!/^[\w\-.]+$/.test(collation)) {
+            throw new Error(`Invalid collation name: '${collation}'. Collation names must contain only word characters, hyphens, and dots.`);
         }
     }
+    /**
+     * Whether collation names compare case-insensitively in this dialect. MySQL/MariaDB, MSSQL, and
+     * SQLite use case-insensitive collation identifiers; PostgreSQL stores them as case-sensitive
+     * names in `pg_collation` (e.g. `en-US-x-icu` is distinct from `EN-US-X-ICU`).
+     * @internal
+     */
+    caseInsensitiveCollationNames() {
+        return true;
+    }
     /** @internal */
     validateJsonPropertyName(name) {
         if (!AbstractSqlPlatform.#JSON_PROPERTY_NAME_RE.test(name)) {

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;