@mikro-orm/sql 7.1.0-dev.9 → 7.1.0

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

@@ -1,6 +1,23 @@
 import { CompiledQuery, Kysely } from 'kysely';
 import { Connection, EventType, isRaw, Utils, } from '@mikro-orm/core';
 import { NativeQueryBuilder } from './query/NativeQueryBuilder.js';
+/**
+ * Pulls cancellation controls out of a `loggerContext` payload, returning the abort options
+ * and a sanitized context that no longer carries them. The QueryBuilder/EM stash
+ * `signal`/`inflightQueryAbortStrategy` on `loggerContext` to avoid widening the public
+ * connection API; stripping them prevents leakage into user `Logger.logQuery` payloads.
+ */
+function extractAbortOptions(loggerContext) {
+    const ctx = loggerContext;
+    if (ctx?.signal == null && ctx?.inflightQueryAbortStrategy == null) {
+        return { loggerContext };
+    }
+    const { signal, inflightQueryAbortStrategy, ...rest } = ctx;
+    return {
+        abort: { signal, inflightQueryAbortStrategy },
+        loggerContext: rest,
+    };
+}
 /** Base class for SQL database connections, built on top of Kysely. */
 export class AbstractSqlConnection extends Connection {
     #client;
@@ -183,17 +200,19 @@ export class AbstractSqlConnection extends Connection {
         await this.ensureConnection();
         const q = this.prepareQuery(query, params);
         const sql = this.getSql(q.query, q.formatted, loggerContext);
+        const { abort, loggerContext: cleanCtx } = extractAbortOptions(loggerContext);
         return this.executeQuery(sql, async () => {
             const compiled = CompiledQuery.raw(q.formatted);
-            const res = await (ctx ?? this.#client).executeQuery(compiled);
+            const res = await (ctx ?? this.#client).executeQuery(compiled, abort);
             return this.transformRawResult(res, method);
-        }, { ...q, ...loggerContext });
+        }, { ...q, ...cleanCtx });
     }
     /** 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);
+        const { abort, loggerContext: cleanCtx } = extractAbortOptions(loggerContext);
         // construct the compiled query manually with `kind: 'SelectQueryNode'` to avoid sqlite validation for select queries when streaming
         const compiled = {
             query: {
@@ -203,11 +222,13 @@ 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, abort ? { signal: abort.signal } : undefined);
             this.logQuery(sql, {
                 sql,
                 params,
-                ...loggerContext,
+                ...cleanCtx,
                 affected: Utils.isPlainObject(res) ? res.affectedRows : undefined,
             });
             for await (const items of res) {
@@ -217,7 +238,7 @@ export class AbstractSqlConnection extends Connection {
             }
         }
         catch (e) {
-            this.logQuery(sql, { sql, params, ...loggerContext, level: 'error' });
+            this.logQuery(sql, { sql, params, ...cleanCtx, level: 'error' });
             throw e;
         }
     }

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.
@@ -118,6 +118,13 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
     mergeJoinedResult<T extends object>(rawResults: EntityData<T>[], meta: EntityMetadata<T>, joinedProps: PopulateOptions<T>[]): EntityData<T>[];
     protected shouldHaveColumn<T, U>(meta: EntityMetadata<T>, prop: EntityProperty<U>, populate: readonly PopulateOptions<U>[], fields?: readonly InternalField<U>[], exclude?: readonly InternalField<U>[]): boolean;
     protected getFieldsForJoinedLoad<T extends object>(qb: AnyQueryBuilder<T>, meta: EntityMetadata<T>, options: FieldsForJoinedLoadOptions<T>): InternalField<T>[];
+    /**
+     * 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
+     */
+    protected addTPTParentJoinsForRelation<T extends object>(qb: AnyQueryBuilder<T>, leafMeta: EntityMetadata, leafAlias: string, basePath: string): void;
     /**
      * Adds LEFT JOINs and fields for TPT polymorphic loading when populating a relation to a TPT base class.
      * @internal
@@ -147,6 +154,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

@@ -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];
@@ -57,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);
@@ -95,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 = {}) {
@@ -211,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;
         }
@@ -228,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);
         }
@@ -536,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);
@@ -561,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;
@@ -593,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));
@@ -625,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));
@@ -802,13 +838,19 @@ export class AbstractSqlDriver extends DatabaseDriver {
                     else {
                         const field = prop.fieldNames[0];
                         if (!duplicates.includes(field) || !usedDups.includes(field)) {
+                            const rowValue = row[prop.name];
+                            const rowValueIsRaw = isRaw(rowValue);
                             if (prop.customType &&
                                 !prop.object &&
                                 'convertToDatabaseValueSQL' in prop.customType &&
-                                row[prop.name] != null &&
-                                !isRaw(row[prop.name])) {
+                                rowValue != null &&
+                                !rowValueIsRaw) {
                                 keys.push(prop.customType.convertToDatabaseValueSQL('?', this.platform));
                             }
+                            else if (rowValueIsRaw && /^\s*(?:with|select)\b/i.test(rowValue.sql)) {
+                                // raw subqueries must be parenthesized when inlined as a VALUES position
+                                keys.push('(?)');
+                            }
                             else {
                                 keys.push('?');
                             }
@@ -835,7 +877,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) {
@@ -868,6 +910,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 ??
@@ -913,6 +956,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)
@@ -1058,7 +1102,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);
         }
@@ -1076,6 +1120,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));
     }
     /**
@@ -1146,6 +1191,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
@@ -1187,7 +1233,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)) {
@@ -1224,7 +1270,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,
@@ -1240,10 +1286,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) {
@@ -1684,6 +1733,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) {
@@ -1732,17 +1788,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) {
@@ -1790,6 +1836,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
@@ -1901,18 +1966,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) {
@@ -1921,7 +1987,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}`]);
         });
@@ -1938,6 +2003,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';
@@ -1964,7 +2080,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());
             }
@@ -1973,6 +2089,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)) {

package/PivotCollectionPersister.d.ts

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

package/PivotCollectionPersister.js

@@ -44,12 +44,14 @@ export class PivotCollectionPersister {
     #ctx;
     #schema;
     #loggerContext;
-    constructor(meta, driver, ctx, schema, loggerContext) {
+    #abort;
+    constructor(meta, driver, ctx, schema, loggerContext, abort) {
         this.#meta = meta;
         this.#driver = driver;
         this.#ctx = ctx;
         this.#schema = schema;
         this.#loggerContext = loggerContext;
+        this.#abort = abort;
         this.#batchSize = this.#driver.config.get('batchSize');
     }
     enqueueUpdate(prop, insertDiff, deleteDiff, pks, isInitialized = true) {
@@ -153,6 +155,7 @@ export class PivotCollectionPersister {
                     ctx: this.#ctx,
                     schema: this.#schema,
                     loggerContext: this.#loggerContext,
+                    ...this.#abort,
                 });
             }
         }
@@ -166,6 +169,7 @@ export class PivotCollectionPersister {
                     convertCustomTypes: false,
                     processCollections: false,
                     loggerContext: this.#loggerContext,
+                    ...this.#abort,
                 });
             }
         }
@@ -181,6 +185,7 @@ export class PivotCollectionPersister {
                     upsert: true,
                     onConflictAction: 'ignore',
                     loggerContext: this.#loggerContext,
+                    ...this.#abort,
                 });
             }
         }