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

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.');
         }
@@ -50,7 +79,10 @@ export class AbstractSqlDriver extends DatabaseDriver {
         const populate = this.autoJoinOneToOneOwner(meta, options.populate, options.fields);
         const joinedProps = this.joinedProps(meta, populate, options);
         const schema = this.getSchemaName(meta, options);
-        const qb = this.createQueryBuilder(meta.class, options.ctx, connectionType, false, options.logging, undefined, options.em).withSchema(schema);
+        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);
@@ -88,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 = {}) {
@@ -204,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;
         }
@@ -221,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);
         }
@@ -529,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);
@@ -554,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;
@@ -586,9 +623,12 @@ export class AbstractSqlDriver extends DatabaseDriver {
         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));
@@ -618,9 +658,12 @@ export class AbstractSqlDriver extends DatabaseDriver {
                 }
             }
             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));
@@ -828,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) {
@@ -861,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 ??
@@ -906,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)
@@ -1051,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);
         }
@@ -1069,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));
     }
     /**
@@ -1099,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);
@@ -1118,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
@@ -1159,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)) {
@@ -1172,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 },
         };
@@ -1201,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,
@@ -1217,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) {
@@ -1340,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.
      */
@@ -1364,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 }));
@@ -1430,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;
@@ -1544,6 +1727,13 @@ export class AbstractSqlDriver extends DatabaseDriver {
                     const targetPath = `${pathPrefix}${basePath}[${targetMeta.className}]`;
                     const schema = targetMeta.schema === '*' ? (options?.schema ?? this.config.get('schema')) : targetMeta.schema;
                     qb.addPolymorphicJoin(prop, targetMeta, options.parentTableAlias, tableAlias, JoinType.leftJoin, targetPath, schema);
+                    // For polymorphic targets that are TPT child entities, INNER JOIN parent tables so that
+                    // filter conditions referencing parent-table columns resolve to the correct alias. The
+                    // INNER JOINs get nested inside the polymorphic LEFT JOIN by processNestedJoins, which
+                    // keeps the resulting query valid for rows pointing to other polymorphic targets.
+                    if (targetMeta.inheritanceType === 'tpt' && targetMeta.tptParent) {
+                        this.addTPTParentJoinsForRelation(qb, targetMeta, tableAlias, targetPath);
+                    }
                     // For polymorphic targets that are TPT base classes, also LEFT JOIN
                     // all descendant tables so child-specific fields can be selected.
                     if (targetMeta.inheritanceType === 'tpt' && targetMeta.tptChildren?.length && !ref) {
@@ -1592,17 +1782,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
             qb.join(field, tableAlias, {}, joinType, path, schema);
             // For relations to TPT child entities, INNER JOIN parent tables (GH #7469)
             if (meta2.inheritanceType === 'tpt' && meta2.tptParent) {
-                let childAlias = tableAlias;
-                let childMeta = meta2;
-                while (childMeta.tptParent) {
-                    const parentMeta = childMeta.tptParent;
-                    const parentAlias = qb.getNextAlias(parentMeta.className);
-                    qb.createAlias(parentMeta.class, parentAlias);
-                    qb.state.tptAlias[`${tableAlias}:${parentMeta.className}`] = parentAlias;
-                    qb.addPropertyJoin(childMeta.tptParentProp, childAlias, parentAlias, JoinType.innerJoin, `${path}.[tpt]${childMeta.className}`);
-                    childAlias = parentAlias;
-                    childMeta = parentMeta;
-                }
+                this.addTPTParentJoinsForRelation(qb, meta2, tableAlias, path);
             }
             // For relations to TPT base classes, add LEFT JOINs for all child tables (polymorphic loading)
             if (meta2.inheritanceType === 'tpt' && meta2.tptChildren?.length && !ref) {
@@ -1650,6 +1830,25 @@ export class AbstractSqlDriver extends DatabaseDriver {
         }
         return fields;
     }
+    /**
+     * Walks the TPT inheritance chain of `leafMeta` and INNER JOINs each parent table.
+     * Registers the parent aliases in `qb.state.tptAlias` so column resolution finds them
+     * when filter conditions reference parent-table columns.
+     * @internal
+     */
+    addTPTParentJoinsForRelation(qb, leafMeta, leafAlias, basePath) {
+        let childAlias = leafAlias;
+        let childMeta = leafMeta;
+        while (childMeta.tptParent) {
+            const parentMeta = childMeta.tptParent;
+            const parentAlias = qb.getNextAlias(parentMeta.className);
+            qb.createAlias(parentMeta.class, parentAlias);
+            qb.state.tptAlias[`${leafAlias}:${parentMeta.className}`] = parentAlias;
+            qb.addPropertyJoin(childMeta.tptParentProp, childAlias, parentAlias, JoinType.innerJoin, `${basePath}.[tpt]${childMeta.className}`);
+            childAlias = parentAlias;
+            childMeta = parentMeta;
+        }
+    }
     /**
      * Adds LEFT JOINs and fields for TPT polymorphic loading when populating a relation to a TPT base class.
      * @internal
@@ -1761,18 +1960,19 @@ export class AbstractSqlDriver extends DatabaseDriver {
             });
         }
         const aliased = this.platform.quoteIdentifier(`${tableAlias}__${prop.fieldNames[0]}`);
+        const sourceAlias = qb.helper.getTPTAliasForProperty(prop.name, tableAlias);
         if (prop.customTypes?.some(type => !!type?.convertToJSValueSQL)) {
             return prop.fieldNames.map((col, idx) => {
                 if (!prop.customTypes[idx]?.convertToJSValueSQL) {
                     return col;
                 }
-                const prefixed = this.platform.quoteIdentifier(`${tableAlias}.${col}`);
+                const prefixed = this.platform.quoteIdentifier(`${sourceAlias}.${col}`);
                 const aliased = this.platform.quoteIdentifier(`${tableAlias}__${col}`);
                 return raw(`${prop.customTypes[idx].convertToJSValueSQL(prefixed, this.platform)} as ${aliased}`);
             });
         }
         if (prop.customType?.convertToJSValueSQL) {
-            const prefixed = this.platform.quoteIdentifier(`${tableAlias}.${prop.fieldNames[0]}`);
+            const prefixed = this.platform.quoteIdentifier(`${sourceAlias}.${prop.fieldNames[0]}`);
             return [raw(`${prop.customType.convertToJSValueSQL(prefixed, this.platform)} as ${aliased}`)];
         }
         if (prop.formula) {
@@ -1781,7 +1981,6 @@ export class AbstractSqlDriver extends DatabaseDriver {
             const columns = meta.createColumnMappingObject(tableAlias);
             return [raw(`${this.evaluateFormula(prop.formula, columns, table)} as ${aliased}`)];
         }
-        const sourceAlias = qb.helper.getTPTAliasForProperty(prop.name, tableAlias);
         return prop.fieldNames.map(fieldName => {
             return raw('?? as ??', [`${sourceAlias}.${fieldName}`, `${tableAlias}__${fieldName}`]);
         });
@@ -1798,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';
@@ -1824,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());
             }
@@ -1833,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

@@ -30,7 +30,8 @@ export declare abstract class AbstractSqlPlatform extends Platform {
     getSearchJsonPropertyKey(path: string[], type: string, aliased: boolean, value?: unknown): string | RawQueryFragment;
     /**
      * Quotes a key for use inside a JSON path expression (e.g. `$.key`).
-     * Simple alphanumeric keys are left unquoted; others are wrapped in double quotes.
+     * Simple alphanumeric keys are left unquoted; others are wrapped in double quotes
+     * with embedded `\` and `"` escaped per the JSON path string syntax.
      * @internal
      */
     quoteJsonKey(key: string): string;
@@ -50,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

@@ -66,18 +66,23 @@ export class AbstractSqlPlatform extends Platform {
     }
     getSearchJsonPropertyKey(path, type, aliased, value) {
         const [a, ...b] = path;
+        const jsonPath = this.quoteValue(`$.${b.map(this.quoteJsonKey).join('.')}`);
         if (aliased) {
-            return raw(alias => `json_extract(${this.quoteIdentifier(`${alias}.${a}`)}, '$.${b.map(this.quoteJsonKey).join('.')}')`);
+            return raw(alias => `json_extract(${this.quoteIdentifier(`${alias}.${a}`)}, ${jsonPath})`);
         }
-        return raw(`json_extract(${this.quoteIdentifier(a)}, '$.${b.map(this.quoteJsonKey).join('.')}')`);
+        return raw(`json_extract(${this.quoteIdentifier(a)}, ${jsonPath})`);
     }
     /**
      * Quotes a key for use inside a JSON path expression (e.g. `$.key`).
-     * Simple alphanumeric keys are left unquoted; others are wrapped in double quotes.
+     * Simple alphanumeric keys are left unquoted; others are wrapped in double quotes
+     * with embedded `\` and `"` escaped per the JSON path string syntax.
      * @internal
      */
     quoteJsonKey(key) {
-        return /^[a-z]\w*$/i.exec(key) ? key : `"${key}"`;
+        if (/^[a-z]\w*$/i.test(key)) {
+            return key;
+        }
+        return `"${key.replaceAll('\\', '\\\\').replaceAll('"', '\\"')}"`;
     }
     getJsonIndexDefinition(index) {
         return index.columnNames.map(column => {
@@ -123,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)) {