@mikro-orm/sql 7.3.0-dev.0 → 7.3.0-dev.10

package/AbstractSqlDriver.js

@@ -850,9 +850,13 @@ export class AbstractSqlDriver extends DatabaseDriver {
                 props.forEach(prop => {
                     // For STI with conflicting fieldNames, use discriminator to determine which field gets value
                     if (prop.stiFieldNames && prop.stiFieldNameMap && meta.discriminatorColumn) {
-                        const activeField = prop.stiFieldNameMap[row[meta.discriminatorColumn]];
+                        // the map misses subtypes whose props were not initialized yet during discovery (root column owner, grandchildren)
+                        const discriminator = row[meta.discriminatorColumn];
+                        const childClass = meta.discriminatorMap?.[discriminator];
+                        const activeField = prop.stiFieldNameMap[discriminator] ??
+                            (childClass && this.metadata.find(childClass)?.properties[prop.name]?.fieldNames[0]);
                         for (const field of prop.stiFieldNames) {
-                            params.push(field === activeField ? row[prop.name] : null);
+                            params.push(field === activeField ? (row[prop.name] ?? null) : null);
                             keys.push('?');
                         }
                         return;
@@ -1809,7 +1813,11 @@ export class AbstractSqlDriver extends DatabaseDriver {
         if (!this.platform.shouldHaveColumn(prop, populate, exclude)) {
             return false;
         }
-        if (!fields || fields.includes('*') || prop.primary || meta.root.discriminatorColumn === prop.name) {
+        if (!fields ||
+            fields.includes('*') ||
+            prop.primary ||
+            meta.root.discriminatorColumn === prop.name ||
+            meta.root.targetKeys?.includes(prop.name)) {
             return true;
         }
         return fields.some(f => f === prop.name || f.toString().startsWith(prop.name + '.'));
@@ -1865,11 +1873,9 @@ export class AbstractSqlDriver extends DatabaseDriver {
                         const tptMeta = this.metadata.get(targetMeta.class);
                         this.addTPTPolymorphicJoinsForRelation(qb, tptMeta, tableAlias, fields);
                     }
-                    if (ref) {
-                        // For filter :ref hints, schedule filter check for each target (no field selection)
-                        qb.scheduleFilterCheck(targetPath);
-                    }
-                    else {
+                    // target filters apply per target, both for filter :ref hints and populated relations
+                    qb.scheduleFilterCheck(targetPath);
+                    if (!ref) {
                         // Select fields from each target table
                         fields.push(...this.getFieldsForJoinedLoad(qb, targetMeta, {
                             ...options,
@@ -2469,6 +2475,8 @@ export class AbstractSqlDriver extends DatabaseDriver {
             }
             if (!options.fields.includes('*') && !options.fields.includes(`${qb.alias}.*`)) {
                 ret.unshift(...meta.primaryKeys.filter(pk => !options.fields.includes(pk)));
+                // `targetKey` values identify the entity like its PK, references resolve it by them
+                ret.push(...(meta.root.targetKeys ?? []).filter(key => meta.properties[key] && !options.fields.includes(key)));
             }
             if (meta.root.inheritanceType === 'sti' &&
                 !options.fields.includes(`${qb.alias}.${meta.root.discriminatorColumn}`)) {

package/SqlEntityManager.js

@@ -1,4 +1,4 @@
-import { EntityManager, raw, Utils, } from '@mikro-orm/core';
+import { EntityManager, QueryFlag, raw, Utils, } from '@mikro-orm/core';
 import { MikroKyselyPlugin } from './plugin/index.js';
 /**
  * @inheritDoc
@@ -87,6 +87,7 @@ export class SqlEntityManager extends EntityManager {
         // match `em.count()` semantics: an active transaction always wins over the requested connection type
         const connectionType = em.getTransactionContext() ? 'write' : options.connectionType;
         const qb = em.createQueryBuilder(meta.class, undefined, connectionType);
+        qb.unsetFlag(QueryFlag.CONVERT_CUSTOM_TYPES);
         qb
             .select([...fields, raw('count(*) as cnt')])
             .where(where)

package/dialects/postgresql/PostgreSqlSchemaHelper.js

@@ -387,6 +387,8 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
       data_type,
       is_identity,
       identity_generation,
+      identity_start,
+      identity_increment,
       generation_expression,
       pg_catalog.col_description(pgc.oid, cols.ordinal_position::int) column_comment,
       coll.collname as collation_name
@@ -433,6 +435,14 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
                 type += `(${col.numeric_precision},${col.numeric_scale})`;
             }
             const length = this.inferLengthFromColumnType(type) === -1 ? -1 : col.length;
+            // a descending sequence starts at -1 by default
+            const defaultIdentityStart = col.identity_increment?.startsWith('-') ? '-1' : '1';
+            // read back non-default identity options, so `identity (start with 1000)` does not diff against plain `identity`
+            const identityOptions = [
+                col.identity_start !== defaultIdentityStart && `start with ${col.identity_start}`,
+                col.identity_increment !== '1' && `increment by ${col.identity_increment}`,
+            ].filter(Boolean);
+            const identitySuffix = identityOptions.length > 0 ? ` (${identityOptions.join(' ')})` : '';
             const column = {
                 name: col.column_name,
                 type,
@@ -445,9 +455,7 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
                 unsigned: increments,
                 autoincrement: increments,
                 generated: col.is_identity === 'YES'
-                    ? col.identity_generation === 'BY DEFAULT'
-                        ? 'by default as identity'
-                        : 'identity'
+                    ? (col.identity_generation === 'BY DEFAULT' ? 'by default as identity' : 'identity') + identitySuffix
                     : col.generation_expression
                         ? col.generation_expression + ' stored'
                         : undefined,
@@ -1032,7 +1040,7 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
                     columnType = this.quote(columnType);
                 }
             }
-            if (column.generated === 'by default as identity') {
+            if (column.generated?.startsWith('by default as identity')) {
                 columnType += ` generated ${column.generated}`;
             }
             else if (column.generated) {

package/dialects/sqlite/SqliteSchemaHelper.js

@@ -499,7 +499,9 @@ export class SqliteSchemaHelper extends SchemaHelper {
         if (Utils.hasObjectKeys(diff.removedChecks) ||
             Utils.hasObjectKeys(diff.changedChecks) ||
             Utils.hasObjectKeys(diff.changedForeignKeys) ||
-            Utils.hasObjectKeys(diff.changedColumns)) {
+            Utils.hasObjectKeys(diff.changedColumns) ||
+            // sqlite can only add or change a primary key by rebuilding the table
+            [...Object.values(diff.addedIndexes), ...Object.values(diff.changedIndexes)].some(index => index.primary)) {
             return this.getAlterTempTableSQL(diff);
         }
         for (const index of Object.values(diff.removedIndexes)) {
@@ -644,10 +646,11 @@ export class SqliteSchemaHelper extends SchemaHelper {
             first.replace(`create table ${quotedName}`, `create table ${quotedTempName}`),
         ];
         const columns = [];
+        const renamedFrom = Object.fromEntries(Object.entries(changedTable.renamedColumns).map(([oldName, column]) => [column.name, oldName]));
         for (const column of changedTable.toTable.getColumns()) {
-            const fromColumn = changedTable.fromTable.getColumn(column.name);
-            if (fromColumn) {
-                columns.push(this.quote(column.name));
+            const fromName = renamedFrom[column.name] ?? column.name;
+            if (changedTable.fromTable.getColumn(fromName)) {
+                columns.push(this.quote(fromName));
             }
             else {
                 columns.push(`null as ${this.quote(column.name)}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/sql",
-  "version": "7.3.0-dev.0",
+  "version": "7.3.0-dev.10",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
   "keywords": [
     "data-mapper",
@@ -50,10 +50,10 @@
     "kysely": "0.29.6"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^7.2.1"
+    "@mikro-orm/core": "^7.2.2"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.3.0-dev.0"
+    "@mikro-orm/core": "7.3.0-dev.10"
   },
   "engines": {
     "node": ">= 22.17.0"

package/plugin/transformer.d.ts

@@ -92,6 +92,7 @@ export declare class MikroTransformer extends OperationNodeTransformer {
      * This is called for SELECT queries when columnNamingStrategy is 'property'
      */
     transformResult(rows: Record<string, any>[] | undefined, entityMap: Map<string, EntityMetadata>): Record<string, any>[] | undefined;
+    private getResultMaps;
     buildGlobalFieldMap(entityMap: Map<string, EntityMetadata>): Record<string, EntityProperty>;
     buildGlobalRelationFieldMap(entityMap: Map<string, EntityMetadata>): Record<string, string>;
     /**
@@ -108,6 +109,6 @@ export declare class MikroTransformer extends OperationNodeTransformer {
     /**
      * Transform a single row by mapping column names to property names
      */
-    transformRow(row: Record<string, any>, fieldToPropertyMap: Record<string, EntityProperty>, relationFieldMap: Record<string, string>): Record<string, any>;
+    transformRow(row: Record<string, any>, fieldEntries: [string, EntityProperty][], relationEntries: [string, string][]): Record<string, any>;
     prepareOutputValue(prop: EntityProperty | undefined, value: unknown): unknown;
 }

package/plugin/transformer.js

@@ -1,5 +1,12 @@
 import { ReferenceKind, isRaw, } from '@mikro-orm/core';
 import { AliasNode, ColumnNode, ColumnUpdateNode, IdentifierNode, OperationNodeTransformer, PrimitiveValueListNode, RawNode, ReferenceNode, SchemableIdentifierNode, SelectAllNode, SelectionNode, TableNode, ValueListNode, ValueNode, ValuesNode, } from 'kysely';
+/** Past this many query shapes the cache of one metadata storage starts over, so generated aliases cannot grow it. */
+const RESULT_MAPS_LIMIT = 1000;
+/**
+ * Result maps per query shape (the aliases and entities of its entity map). They are derived from metadata alone, so
+ * they are built once and shared by every transformer, as `getKysely()` creates a new one per call.
+ */
+const resultMapsCache = new WeakMap();
 const EXPANDABLE_KINDS = new Set([
     ReferenceKind.SCALAR,
     ReferenceKind.EMBEDDED,
@@ -884,12 +891,7 @@ export class MikroTransformer extends OperationNodeTransformer {
         if (byEntity) {
             return byEntity;
         }
-        const allMetadata = Array.from(this.#metadata);
-        const byTable = allMetadata.find(m => m.tableName === name);
-        if (byTable) {
-            return byTable;
-        }
-        return undefined;
+        return this.#metadata.getByTableName(name);
     }
     /**
      * Transform result rows by mapping database column names to property names
@@ -906,11 +908,35 @@ export class MikroTransformer extends OperationNodeTransformer {
         if (entityMap.size === 0) {
             return rows;
         }
-        // Build a global mapping from database field names to property objects
-        const fieldToPropertyMap = this.buildGlobalFieldMap(entityMap);
-        const relationFieldMap = this.buildGlobalRelationFieldMap(entityMap);
+        // The global mapping from database field names to property objects, built once per query shape
+        const { fields, relations } = this.getResultMaps(entityMap);
         // Transform each row
-        return rows.map(row => this.transformRow(row, fieldToPropertyMap, relationFieldMap));
+        return rows.map(row => this.transformRow(row, fields, relations));
+    }
+    getResultMaps(entityMap) {
+        let byShape = resultMapsCache.get(this.#metadata);
+        if (!byShape) {
+            byShape = new Map();
+            resultMapsCache.set(this.#metadata, byShape);
+        }
+        let shape = '';
+        for (const [alias, meta] of entityMap) {
+            shape += `${alias}\0${meta._id}\0`;
+        }
+        const cached = byShape.get(shape);
+        if (cached && Array.from(entityMap.values()).every((meta, i) => meta.props === cached.props[i])) {
+            return cached;
+        }
+        if (byShape.size >= RESULT_MAPS_LIMIT) {
+            byShape.clear();
+        }
+        const maps = {
+            props: Array.from(entityMap.values(), meta => meta.props),
+            fields: Object.entries(this.buildGlobalFieldMap(entityMap)),
+            relations: Object.entries(this.buildGlobalRelationFieldMap(entityMap)),
+        };
+        byShape.set(shape, maps);
+        return maps;
     }
     buildGlobalFieldMap(entityMap) {
         const map = {};
@@ -986,10 +1012,10 @@ export class MikroTransformer extends OperationNodeTransformer {
     /**
      * Transform a single row by mapping column names to property names
      */
-    transformRow(row, fieldToPropertyMap, relationFieldMap) {
+    transformRow(row, fieldEntries, relationEntries) {
         const transformed = { ...row };
         // First pass: map regular fields from fieldName to propertyName and convert values
-        for (const [fieldName, prop] of Object.entries(fieldToPropertyMap)) {
+        for (const [fieldName, prop] of fieldEntries) {
             if (!(fieldName in transformed)) {
                 continue;
             }
@@ -1011,7 +1037,7 @@ export class MikroTransformer extends OperationNodeTransformer {
         // Second pass: handle relation fields
         // Only run if columnNamingStrategy is 'property', as we don't want to rename FKs otherwise
         if (this.#options.columnNamingStrategy === 'property') {
-            for (const [fieldName, relationPropertyName] of Object.entries(relationFieldMap)) {
+            for (const [fieldName, relationPropertyName] of relationEntries) {
                 if (fieldName in transformed && !(relationPropertyName in transformed)) {
                     // Move the foreign key value to the relation property name
                     transformed[relationPropertyName] = transformed[fieldName];

package/query/CriteriaNode.d.ts

@@ -17,6 +17,8 @@ export declare class CriteriaNode<T extends object> implements ICriteriaNode<T>
     index?: number;
     constructor(metadata: MetadataStorage, entityName: EntityName<T>, parent?: ICriteriaNode<T> | undefined, key?: EntityKey<T> | RawQueryFragmentSymbol | undefined, validate?: boolean, strict?: boolean);
     process(qb: IQueryBuilder<T>, options?: ICriteriaNodeProcessOptions): any;
+    /** Whether this node holds the condition for a single target of a polymorphic relation (e.g. `imageable[Article]`). */
+    isPolymorphicBranch(): boolean;
     unwrap(): any;
     shouldInline(payload: any): boolean;
     willAutoJoin(qb: IQueryBuilder<T>, alias?: string, options?: ICriteriaNodeProcessOptions): boolean;

package/query/CriteriaNode.js

@@ -1,4 +1,4 @@
-import { RawQueryFragment, ReferenceKind, Utils, inspect, } from '@mikro-orm/core';
+import { QueryHelper, RawQueryFragment, ReferenceKind, Utils, inspect, } from '@mikro-orm/core';
 /**
  * Helper for working with deeply nested where/orderBy/having criteria. Uses composite pattern to build tree from the payload.
  * Auto-joins relations and converts payload from { books: { publisher: { name: '...' } } } to { 'publisher_alias.name': '...' }
@@ -28,7 +28,9 @@ export class CriteriaNode {
                 return;
             }
             for (const k of pks) {
-                this.prop = meta.props.find(prop => prop.name === k || (prop.fieldNames?.length === 1 && prop.fieldNames[0] === k && prop.persist !== false));
+                const [name, target] = QueryHelper.splitPolymorphicKey(k);
+                this.prop = meta.props.find(prop => (prop.name === name && (!target || QueryHelper.findTargetMetas(prop, k).length > 0)) ||
+                    (prop.fieldNames?.length === 1 && prop.fieldNames[0] === k && prop.persist !== false));
                 const isProp = this.prop || meta.props.find(prop => (prop.fieldNames || []).includes(k));
                 // do not validate if the key is prefixed or type casted (e.g. `k::text`)
                 if (validate && !isProp && !k.includes('.') && !k.includes('::') && !Utils.isOperator(k)) {
@@ -40,6 +42,10 @@ export class CriteriaNode {
     process(qb, options) {
         return this.payload;
     }
+    /** Whether this node holds the condition for a single target of a polymorphic relation (e.g. `imageable[Article]`). */
+    isPolymorphicBranch() {
+        return !!this.prop?.polymorphic && typeof this.key === 'string' && this.key.endsWith(']');
+    }
     unwrap() {
         return this.payload;
     }

package/query/CriteriaNodeFactory.js

@@ -1,4 +1,4 @@
-import { GroupOperator, isRaw, JsonType, RawQueryFragment, ReferenceKind, Utils, ValidationError, } from '@mikro-orm/core';
+import { GroupOperator, isRaw, JsonType, QueryHelper, RawQueryFragment, ReferenceKind, Utils, ValidationError, } from '@mikro-orm/core';
 import { ObjectCriteriaNode } from './ObjectCriteriaNode.js';
 import { ArrayCriteriaNode } from './ArrayCriteriaNode.js';
 import { ScalarCriteriaNode } from './ScalarCriteriaNode.js';
@@ -50,8 +50,9 @@ export class CriteriaNodeFactory {
     }
     static createObjectItemNode(metadata, entityName, node, payload, key, meta, validate = true) {
         const rawField = RawQueryFragment.isKnownFragmentSymbol(key);
-        const prop = rawField ? null : meta?.properties[key];
-        const childEntity = prop && prop.kind !== ReferenceKind.SCALAR ? prop.targetMeta.class : entityName;
+        const prop = rawField ? null : meta?.properties[QueryHelper.splitPolymorphicKey(key)[0]];
+        const target = rawField ? undefined : QueryHelper.findTargetMeta(prop, key);
+        const childEntity = prop && prop.kind !== ReferenceKind.SCALAR && target ? target.class : entityName;
         const isNotEmbedded = rawField || prop?.kind !== ReferenceKind.EMBEDDED;
         const val = payload[key];
         if (isNotEmbedded && prop?.customType instanceof JsonType) {

package/query/ObjectCriteriaNode.d.ts

@@ -5,6 +5,8 @@ import type { ICriteriaNodeProcessOptions, IQueryBuilder } from '../typings.js';
  */
 export declare class ObjectCriteriaNode<T extends object> extends CriteriaNode<T> {
     process(qb: IQueryBuilder<T>, options?: ICriteriaNodeProcessOptions): any;
+    /** Orders by the first non-null value of the property across the joined polymorphic targets. */
+    private processPolymorphicOrderBy;
     isStrict(): boolean;
     unwrap(): any;
     willAutoJoin(qb: IQueryBuilder<T>, alias?: string, options?: ICriteriaNodeProcessOptions): boolean;

package/query/ObjectCriteriaNode.js

@@ -1,4 +1,4 @@
-import { ALIAS_REPLACEMENT, GroupOperator, QueryFlag, raw, RawQueryFragment, ReferenceKind, Utils, } from '@mikro-orm/core';
+import { ALIAS_REPLACEMENT, GroupOperator, QueryFlag, QueryHelper, raw, RawQueryFragment, ReferenceKind, Utils, } from '@mikro-orm/core';
 import { CriteriaNode } from './CriteriaNode.js';
 import { JoinType, QueryType } from './enums.js';
 const COLLECTION_OPERATORS = ['$some', '$none', '$every', '$size', '$all'];
@@ -7,6 +7,10 @@ const COLLECTION_OPERATORS = ['$some', '$none', '$every', '$size', '$all'];
  */
 export class ObjectCriteriaNode extends CriteriaNode {
     process(qb, options) {
+        const targets = this.isPolymorphicBranch() ? QueryHelper.findTargetMetas(this.prop, this.key) : [];
+        if (options?.type === 'orderBy' && targets.length > 1) {
+            return this.processPolymorphicOrderBy(qb, targets, options);
+        }
         const matchPopulateJoins = options?.matchPopulateJoins ||
             (this.prop && [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(this.prop.kind));
         const nestedAlias = qb.getAliasForJoinPath(this.getPath(options), { ...options, matchPopulateJoins });
@@ -99,7 +103,7 @@ export class ObjectCriteriaNode extends CriteriaNode {
             // with an exclusive condition on the join columns:
             // - if the owning column is null, the row is missing, we don't apply the filter
             // - if the target column is not null, the row is matched, we apply the filter
-            if (toOneProperty && this.prop.nullable && this.isStrict()) {
+            if (toOneProperty && this.prop.nullable && this.isStrict() && !this.isPolymorphicBranch()) {
                 const key = this.prop.owner ? this.prop.name : this.prop.referencedPKs;
                 qb.andWhere({
                     $or: [
@@ -109,7 +113,7 @@ export class ObjectCriteriaNode extends CriteriaNode {
                 });
             }
         }
-        return keys.reduce((o, field) => {
+        const ret = keys.reduce((o, field) => {
             const childNode = this.payload[field];
             const payload = childNode.process(qb, { ...options, alias: this.prop ? alias : ownerAlias });
             const operator = Utils.isOperator(field);
@@ -149,6 +153,31 @@ export class ObjectCriteriaNode extends CriteriaNode {
             }
             return o;
         }, {});
+        // the target is left joined, so its condition must only match rows that point to it
+        if (this.isPolymorphicBranch() && alias && options?.type !== 'orderBy') {
+            const pk = this.metadata.find(this.entityName).primaryKeys[0];
+            this.inlineCondition(`${alias}.${pk}`, ret, { $ne: null });
+        }
+        return ret;
+    }
+    /** Orders by the first non-null value of the property across the joined polymorphic targets. */
+    processPolymorphicOrderBy(qb, targets, options) {
+        const ownerAlias = options.alias || qb.alias;
+        const aliases = targets.map(target => {
+            const path = `${this.parent.getPath()}.${this.prop.name}[${target.className}]`;
+            const alias = qb.getAliasForJoinPath(path, { ...options, matchPopulateJoins: true });
+            if (alias) {
+                return alias;
+            }
+            const newAlias = qb.getNextAlias(target.class);
+            qb.addPolymorphicJoin(this.prop, target, ownerAlias, newAlias, JoinType.leftJoin, path);
+            return newAlias;
+        });
+        return Utils.getObjectQueryKeys(this.payload).reduce((o, field) => {
+            const columns = targets.map((target, i) => `${aliases[i]}.${target.properties[field].fieldNames[0]}`);
+            o[raw(`coalesce(${columns.map(() => '??').join(', ')})`, columns)] = this.payload[field].payload;
+            return o;
+        }, {});
     }
     isStrict() {
         return (this.strict ||
@@ -186,8 +215,9 @@ export class ObjectCriteriaNode extends CriteriaNode {
         const operator = Utils.isObject(payload) &&
             Utils.getObjectQueryKeys(payload).every(k => {
                 if (k === '$not' && Utils.isPlainObject(payload[k])) {
-                    // $not wrapping non-operator conditions (entity props) should be inlined
-                    return Utils.getObjectQueryKeys(payload[k]).every(ik => Utils.isOperator(ik, false));
+                    // $not wrapping non-operator conditions (entity props) or an empty one should be inlined
+                    const inner = Utils.getObjectQueryKeys(payload[k]);
+                    return inner.length > 0 && inner.every(ik => Utils.isOperator(ik, false));
                 }
                 return Utils.isOperator(k, false);
             });
@@ -211,16 +241,19 @@ export class ObjectCriteriaNode extends CriteriaNode {
         this.inlineCondition(key, obj, value);
     }
     inlineChildPayload(o, payload, field, alias, childAlias) {
-        const prop = this.metadata.find(this.entityName).properties[field];
+        const prop = this.payload[field].prop;
         for (const k of Utils.getObjectQueryKeys(payload)) {
             if (RawQueryFragment.isKnownFragmentSymbol(k)) {
                 o[k] = payload[k];
             }
             else if (k === '$not' &&
                 Utils.isPlainObject(payload[k]) &&
-                Utils.getObjectQueryKeys(payload[k]).some(ik => !Utils.isOperator(ik, false))) {
-                // $not wraps entity conditions (from auto-join), inline at current level
-                this.inlineCondition(k, o, payload[k]);
+                (!Utils.hasObjectKeys(payload[k]) ||
+                    Utils.getObjectQueryKeys(payload[k]).some(ik => !Utils.isOperator(ik, false)))) {
+                // $not wraps entity conditions (from auto-join) or an empty one, inline at current level with the same key mapping
+                const inner = {};
+                this.inlineChildPayload(inner, payload[k], field, alias, childAlias);
+                this.inlineCondition(k, o, inner);
             }
             else if (Utils.isOperator(k, false)) {
                 const tmp = payload[k];
@@ -273,6 +306,10 @@ export class ObjectCriteriaNode extends CriteriaNode {
         if (keys.some(k => this.isCollectionOperator(k))) {
             return true;
         }
+        // the target's discriminator is checked in the join condition, so it is needed even for PK conditions
+        if (this.isPolymorphicBranch()) {
+            return !nestedAlias;
+        }
         const meta = this.metadata.find(this.entityName);
         const embeddable = this.prop.kind === ReferenceKind.EMBEDDED;
         const knownKey = [ReferenceKind.SCALAR, ReferenceKind.MANY_TO_ONE, ReferenceKind.EMBEDDED].includes(this.prop.kind) ||
@@ -291,6 +328,13 @@ export class ObjectCriteriaNode extends CriteriaNode {
             });
         const primaryKeys = knownKey &&
             keys.every(key => {
+                if (key === '$not') {
+                    // e.g. `{ author: { $not: { id: 1 } } }` compares the FK column, relation PKs still need the join
+                    const childPayload = this.payload[key].payload;
+                    return (Utils.isPlainObject(childPayload) &&
+                        Utils.getObjectQueryKeys(childPayload).every(k => meta.primaryKeys.includes(k) &&
+                            meta.properties[k].kind === ReferenceKind.SCALAR));
+                }
                 if (typeof key !== 'string' || !meta.primaryKeys.includes(key)) {
                     return false;
                 }
@@ -317,10 +361,16 @@ export class ObjectCriteriaNode extends CriteriaNode {
         if (this.prop.kind === ReferenceKind.MANY_TO_MANY && (scalar || operator)) {
             qb.join(field, nestedAlias, undefined, JoinType.pivotJoin, path);
         }
+        else if (this.isPolymorphicBranch()) {
+            const targetMeta = this.metadata.find(this.entityName);
+            qb.addPolymorphicJoin(this.prop, targetMeta, alias, nestedAlias, JoinType.leftJoin, path);
+        }
         else {
             const prev = qb.state.fields?.slice();
             const toOneProperty = [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(this.prop.kind);
-            const joinType = toOneProperty && !this.prop.nullable ? JoinType.innerJoin : JoinType.leftJoin;
+            // ordering must not drop rows whose polymorphic relation points to another target
+            const orderByPolymorphic = this.prop.polymorphic && options?.type === 'orderBy';
+            const joinType = toOneProperty && !this.prop.nullable && !orderByPolymorphic ? JoinType.innerJoin : JoinType.leftJoin;
             qb[method](field, nestedAlias, undefined, joinType, path);
             if (!qb.hasFlag(QueryFlag.INFER_POPULATE)) {
                 qb.state.fields = prev;

package/query/QueryBuilder.js

@@ -1032,9 +1032,11 @@ export class QueryBuilder {
      * @internal
      */
     addPolymorphicJoin(prop, targetMeta, ownerAlias, alias, type, path, schema) {
-        // Override referencedColumnNames to use the specific target's PK columns
+        // Override referencedColumnNames to use the specific target's PK (or `targetKey`) columns
         // (polymorphic targets may have different PK column names, e.g. org_id vs user_id)
-        const referencedColumnNames = targetMeta.getPrimaryProps().flatMap(pk => pk.fieldNames);
+        const referencedColumnNames = prop.targetKey
+            ? targetMeta.properties[prop.targetKey].fieldNames
+            : targetMeta.getPrimaryProps().flatMap(pk => pk.fieldNames);
         const targetProp = { ...prop, targetMeta, referencedColumnNames };
         const aliasedName = `${ownerAlias}.${prop.name}[${targetMeta.className}]#${alias}`;
         this.#state.joins[aliasedName] = this.helper.joinManyToOneReference(targetProp, ownerAlias, alias, type, {}, schema);

package/schema/SchemaHelper.js

@@ -474,10 +474,16 @@ export class SchemaHelper {
         for (const foreignKey of Object.values(diff.changedForeignKeys)) {
             ret.push(this.createForeignKey(diff.toTable, foreignKey));
         }
-        for (const index of Object.values(diff.addedIndexes)) {
-            ret.push(this.createIndex(index, diff.toTable));
-        }
-        for (const index of Object.values(diff.changedIndexes)) {
+        for (const index of [...Object.values(diff.addedIndexes), ...Object.values(diff.changedIndexes)]) {
+            const addedColumn = diff.addedColumns[index.columnNames[0]];
+            // an added autoincrement PK column already declares the primary key inline
+            if (index.primary &&
+                !index.composite &&
+                addedColumn?.autoincrement &&
+                addedColumn.primary &&
+                !this.hasNonDefaultPrimaryKeyName(diff.toTable)) {
+                continue;
+            }
             ret.push(this.createIndex(index, diff.toTable, true));
         }
         for (const [oldIndexName, index] of Object.entries(diff.renamedIndexes)) {

package/typings.d.ts

@@ -1,5 +1,5 @@
 import type { Generated, Kysely } from 'kysely';
-import type { CheckCallback, DeferMode, Dictionary, EntityName, EntityProperty, EntitySchemaWithMeta, ExtractDefineEntityProperties, FilterQuery, GroupOperator, IndexColumnOptions, InferEntityName, Opt, Primary, PrimaryProperty, QueryFlag, QueryOrderMap, RawQueryFragment, RoutineIgnoreField, Scalar, Type } from '@mikro-orm/core';
+import type { CheckCallback, DeferMode, Dictionary, EntityName, EntityMetadata, EntityProperty, EntitySchemaWithMeta, ExtractDefineEntityProperties, FilterQuery, GroupOperator, IndexColumnOptions, InferEntityName, Opt, Primary, PrimaryProperty, QueryFlag, QueryOrderMap, RawQueryFragment, RoutineIgnoreField, Scalar, Type } from '@mikro-orm/core';
 import type { JoinType, QueryType } from './query/enums.js';
 import type { DatabaseSchema } from './schema/DatabaseSchema.js';
 import type { DatabaseTable } from './schema/DatabaseTable.js';
@@ -295,6 +295,8 @@ export interface IQueryBuilder<T> {
     scheduleFilterCheck(path: string): void;
     /** @internal */
     ensureTPTJoins(): void;
+    /** @internal */
+    addPolymorphicJoin(prop: EntityProperty, targetMeta: EntityMetadata, ownerAlias: string, alias: string, type: JoinType, path: string, schema?: string): void;
     withSchema(schema: string): this;
 }
 export interface ICriteriaNodeProcessOptions {