@mikro-orm/sql 7.0.0-dev.99 → 7.0.0-rc.0

package/query/QueryBuilderHelper.d.ts

@@ -1,6 +1,6 @@
-import { type Dictionary, type EntityData, type EntityKey, type EntityMetadata, type EntityProperty, type FlatQueryOrderMap, LockMode, type QBFilterQuery, RawQueryFragment } from '@mikro-orm/core';
+import { type Dictionary, type EntityData, type EntityKey, type EntityMetadata, type EntityName, type EntityProperty, type FilterQuery, type FlatQueryOrderMap, type FormulaTable, LockMode, type QueryOrderMap, Raw, type RawQueryFragmentSymbol } from '@mikro-orm/core';
 import { JoinType, QueryType } from './enums.js';
-import type { Field, JoinOptions } from '../typings.js';
+import type { InternalField, JoinOptions } from '../typings.js';
 import type { AbstractSqlDriver } from '../AbstractSqlDriver.js';
 import { NativeQueryBuilder } from './NativeQueryBuilder.js';
 /**
@@ -12,11 +12,17 @@ export declare class QueryBuilderHelper {
     private readonly aliasMap;
     private readonly subQueries;
     private readonly driver;
+    private readonly tptAliasMap;
     private readonly platform;
     private readonly metadata;
-    constructor(entityName: string, alias: string, aliasMap: Dictionary<Alias<any>>, subQueries: Dictionary<string>, driver: AbstractSqlDriver);
-    mapper(field: string | RawQueryFragment, type?: QueryType): string;
-    mapper(field: string | RawQueryFragment, type?: QueryType, value?: any, alias?: string | null): string;
+    constructor(entityName: EntityName, alias: string, aliasMap: Dictionary<Alias<any>>, subQueries: Dictionary<string>, driver: AbstractSqlDriver, tptAliasMap?: Dictionary<string>);
+    /**
+     * For TPT inheritance, finds the correct alias for a property based on which entity owns it.
+     * Returns the main alias if not a TPT property or if the property belongs to the main entity.
+     */
+    getTPTAliasForProperty(propName: string, defaultAlias: string): string;
+    mapper(field: string | Raw | RawQueryFragmentSymbol, type?: QueryType): string;
+    mapper(field: string | Raw | RawQueryFragmentSymbol, type?: QueryType, value?: any, alias?: string | null, schema?: string): string;
     processData(data: Dictionary, convertCustomTypes: boolean, multi?: boolean): any;
     joinOneToReference(prop: EntityProperty, ownerAlias: string, alias: string, type: JoinType, cond?: Dictionary, schema?: string): JoinOptions;
     joinManyToOneReference(prop: EntityProperty, ownerAlias: string, alias: string, type: JoinType, cond?: Dictionary, schema?: string): JoinOptions;
@@ -26,9 +32,9 @@ export declare class QueryBuilderHelper {
         sql: string;
         params: unknown[];
     };
-    mapJoinColumns(type: QueryType, join: JoinOptions): (string | RawQueryFragment)[];
+    mapJoinColumns(type: QueryType, join: JoinOptions): (string | Raw)[];
     isOneToOneInverse(field: string, meta?: EntityMetadata): boolean;
-    getTableName(entityName: string): string;
+    getTableName(entityName: EntityName): string;
     /**
      * Checks whether the RE can be rewritten to simple LIKE query
      */
@@ -45,9 +51,10 @@ export declare class QueryBuilderHelper {
     private processObjectSubCondition;
     private getValueReplacement;
     private getOperatorReplacement;
+    validateQueryOrder<T>(orderBy: QueryOrderMap<T>): void;
     getQueryOrder(type: QueryType, orderBy: FlatQueryOrderMap | FlatQueryOrderMap[], populate: Dictionary<string>): string[];
     getQueryOrderFromObject(type: QueryType, orderBy: FlatQueryOrderMap, populate: Dictionary<string>): string[];
-    finalize(type: QueryType, qb: NativeQueryBuilder, meta?: EntityMetadata, data?: Dictionary, returning?: Field<any>[]): void;
+    finalize(type: QueryType, qb: NativeQueryBuilder, meta?: EntityMetadata, data?: Dictionary, returning?: InternalField<any>[]): void;
     splitField<T>(field: EntityKey<T>, greedyAlias?: boolean): [string, EntityKey<T>, string | undefined];
     getLockSQL(qb: NativeQueryBuilder, lockMode: LockMode, lockTables?: string[], joinsMap?: Dictionary<JoinOptions>): void;
     updateVersionProperty(qb: NativeQueryBuilder, data: Dictionary): void;
@@ -57,17 +64,18 @@ export declare class QueryBuilderHelper {
     private fieldName;
     getProperty(field: string, alias?: string): EntityProperty | undefined;
     isTableNameAliasRequired(type: QueryType): boolean;
-    processOnConflictCondition(cond: QBFilterQuery, schema?: string): QBFilterQuery;
+    processOnConflictCondition(cond: FilterQuery<any>, schema?: string): FilterQuery<any>;
+    createFormulaTable(alias: string, meta: EntityMetadata, schema?: string): FormulaTable;
 }
 export interface Alias<T> {
     aliasName: string;
-    entityName: string;
-    metadata?: EntityMetadata<T>;
+    entityName: EntityName<T>;
+    meta: EntityMetadata<T>;
     subQuery?: NativeQueryBuilder;
 }
 export interface OnConflictClause<T> {
-    fields: string[] | RawQueryFragment;
+    fields: string[] | Raw;
     ignore?: boolean;
-    merge?: EntityData<T> | Field<T>[];
-    where?: QBFilterQuery<T>;
+    merge?: EntityData<T> | InternalField<T>[];
+    where?: FilterQuery<T>;
 }

package/query/QueryBuilderHelper.js

@@ -1,4 +1,4 @@
-import { ALIAS_REPLACEMENT, ALIAS_REPLACEMENT_RE, ArrayType, isRaw, LockMode, OptimisticLockError, QueryOperator, QueryOrderNumeric, raw, RawQueryFragment, ReferenceKind, Utils, ValidationError, } from '@mikro-orm/core';
+import { ALIAS_REPLACEMENT, ALIAS_REPLACEMENT_RE, ArrayType, inspect, isRaw, LockMode, OptimisticLockError, QueryOperator, QueryOrderNumeric, raw, Raw, QueryHelper, ReferenceKind, Utils, ValidationError, } from '@mikro-orm/core';
 import { JoinType, QueryType } from './enums.js';
 import { NativeQueryBuilder } from './NativeQueryBuilder.js';
 /**
@@ -10,21 +10,51 @@ export class QueryBuilderHelper {
     aliasMap;
     subQueries;
     driver;
+    tptAliasMap;
     platform;
     metadata;
-    constructor(entityName, alias, aliasMap, subQueries, driver) {
+    constructor(entityName, alias, aliasMap, subQueries, driver, tptAliasMap = {}) {
         this.entityName = entityName;
         this.alias = alias;
         this.aliasMap = aliasMap;
         this.subQueries = subQueries;
         this.driver = driver;
+        this.tptAliasMap = tptAliasMap;
         this.platform = this.driver.getPlatform();
         this.metadata = this.driver.getMetadata();
     }
-    mapper(field, type = QueryType.SELECT, value, alias) {
+    /**
+     * For TPT inheritance, finds the correct alias for a property based on which entity owns it.
+     * Returns the main alias if not a TPT property or if the property belongs to the main entity.
+     */
+    getTPTAliasForProperty(propName, defaultAlias) {
+        const meta = this.aliasMap[defaultAlias]?.meta ?? this.metadata.get(this.entityName);
+        if (meta?.inheritanceType !== 'tpt' || !meta.tptParent) {
+            return defaultAlias;
+        }
+        // Check if property is in the main entity's ownProps
+        if (meta.ownProps?.some(p => p.name === propName || p.fieldNames?.includes(propName))) {
+            return defaultAlias;
+        }
+        // Walk up the TPT hierarchy to find which parent owns this property
+        let parentMeta = meta.tptParent;
+        while (parentMeta) {
+            const parentAlias = this.tptAliasMap[parentMeta.className];
+            if (parentAlias && parentMeta.ownProps?.some(p => p.name === propName || p.fieldNames?.includes(propName))) {
+                return parentAlias;
+            }
+            parentMeta = parentMeta.tptParent;
+        }
+        // Property not found in hierarchy, return default alias
+        return defaultAlias;
+    }
+    mapper(field, type = QueryType.SELECT, value, alias, schema) {
         if (isRaw(field)) {
             return raw(field.sql, field.params);
         }
+        if (Raw.isKnownFragmentSymbol(field)) {
+            return Raw.getKnownFragment(field);
+        }
         /* v8 ignore next */
         if (typeof field !== 'string') {
             return field;
@@ -60,20 +90,17 @@ export class QueryBuilderHelper {
             }
             return raw('(' + parts.map(part => this.platform.quoteIdentifier(part)).join(', ') + ')');
         }
-        const rawField = RawQueryFragment.getKnownFragment(field);
-        if (rawField) {
-            return rawField;
-        }
-        const aliasPrefix = isTableNameAliasRequired ? this.alias + '.' : '';
         const [a, f] = this.splitField(field);
         const prop = this.getProperty(f, a);
+        // For TPT inheritance, resolve the correct alias for this property
+        // Only apply TPT resolution when `a` is an actual table alias (in aliasMap),
+        // not when it's an embedded property name like 'profile1.identity.links'
+        const isTableAlias = !!this.aliasMap[a];
+        const baseAlias = isTableAlias ? a : this.alias;
+        const resolvedAlias = isTableAlias ? this.getTPTAliasForProperty(prop?.name ?? f, a) : this.alias;
+        const aliasPrefix = isTableNameAliasRequired ? resolvedAlias + '.' : '';
         const fkIdx2 = prop?.fieldNames.findIndex(name => name === f) ?? -1;
         const fkIdx = fkIdx2 === -1 ? 0 : fkIdx2;
-        let ret = field;
-        // embeddable nested path instead of a regular property with table alias, reset alias
-        if (prop?.name === a && prop.embeddedProps[f]) {
-            return aliasPrefix + prop.fieldNames[fkIdx];
-        }
         if (a === prop?.embedded?.[0]) {
             return aliasPrefix + prop.fieldNames[fkIdx];
         }
@@ -85,7 +112,10 @@ export class QueryBuilderHelper {
             const alias2 = this.platform.quoteIdentifier(a).toString();
             const aliased = this.platform.quoteIdentifier(prop.fieldNames[0]).toString();
             const as = alias === null ? '' : ` as ${aliased}`;
-            let value = prop.formula(alias2);
+            const meta = this.aliasMap[a]?.meta ?? this.metadata.get(this.entityName);
+            const table = this.createFormulaTable(alias2, meta, schema);
+            const columns = meta.createColumnMappingObject(p => this.getTPTAliasForProperty(p.name, a), alias2);
+            let value = this.driver.evaluateFormula(prop.formula, columns, table);
             if (!this.isTableNameAliasRequired(type)) {
                 value = value.replaceAll(alias2 + '.', '');
             }
@@ -107,17 +137,14 @@ export class QueryBuilderHelper {
             }
             return raw(`${valueSQL} as ${this.platform.quoteIdentifier(alias ?? prop.fieldNames[fkIdx])}`);
         }
-        // do not wrap custom expressions
-        if (!rawField) {
-            ret = this.prefix(field, false, false, fkIdx);
-        }
+        let ret = this.prefix(field, false, false, fkIdx);
         if (alias) {
             ret += ' as ' + alias;
         }
         if (!isTableNameAliasRequired || this.isPrefixed(ret) || noPrefix) {
             return ret;
         }
-        return this.alias + '.' + ret;
+        return resolvedAlias + '.' + ret;
     }
     processData(data, convertCustomTypes, multi = false) {
         if (Array.isArray(data)) {
@@ -133,12 +160,20 @@ export class QueryBuilderHelper {
     }
     joinOneToReference(prop, ownerAlias, alias, type, cond = {}, schema) {
         const prop2 = prop.targetMeta.properties[prop.mappedBy || prop.inversedBy];
-        const table = this.getTableName(prop.type);
+        const table = this.getTableName(prop.targetMeta.class);
         const joinColumns = prop.owner ? prop.referencedColumnNames : prop2.joinColumns;
         const inverseJoinColumns = prop.referencedColumnNames;
         const primaryKeys = prop.owner ? prop.joinColumns : prop2.referencedColumnNames;
         schema ??= prop.targetMeta?.schema === '*' ? '*' : this.driver.getSchemaName(prop.targetMeta);
         cond = Utils.merge(cond, prop.where);
+        // For inverse side of polymorphic relations, add discriminator condition
+        if (!prop.owner && prop2.polymorphic && prop2.discriminatorColumn && prop2.discriminatorMap) {
+            const ownerMeta = this.aliasMap[ownerAlias]?.meta ?? this.metadata.get(this.entityName);
+            const discriminatorValue = QueryHelper.findDiscriminatorValue(prop2.discriminatorMap, ownerMeta.class);
+            if (discriminatorValue) {
+                cond[`${alias}.${prop2.discriminatorColumn}`] = discriminatorValue;
+            }
+        }
         return {
             prop, type, cond, ownerAlias, alias, table, schema,
             joinColumns, inverseJoinColumns, primaryKeys,
@@ -147,10 +182,12 @@ export class QueryBuilderHelper {
     joinManyToOneReference(prop, ownerAlias, alias, type, cond = {}, schema) {
         return {
             prop, type, cond, ownerAlias, alias,
-            table: this.getTableName(prop.type),
+            table: this.getTableName(prop.targetMeta.class),
             schema: prop.targetMeta?.schema === '*' ? '*' : this.driver.getSchemaName(prop.targetMeta, { schema }),
             joinColumns: prop.referencedColumnNames,
-            primaryKeys: prop.fieldNames,
+            // For polymorphic relations, fieldNames includes the discriminator column which is not
+            // part of the join condition - use joinColumns (the FK columns only) instead
+            primaryKeys: prop.polymorphic ? prop.joinColumns : prop.fieldNames,
         };
     }
     joinManyToManyReference(prop, ownerAlias, alias, pivotAlias, type, cond, path, schema) {
@@ -172,7 +209,7 @@ export class QueryBuilderHelper {
         if (type === JoinType.pivotJoin) {
             return ret;
         }
-        const prop2 = prop.owner ? pivotMeta.relations[1] : pivotMeta.relations[0];
+        const prop2 = pivotMeta.relations[prop.owner ? 1 : 0];
         ret[`${pivotAlias}.${prop2.name}#${alias}`] = this.joinManyToOneReference(prop2, pivotAlias, alias, type, cond, schema);
         ret[`${pivotAlias}.${prop2.name}#${alias}`].path = path;
         const tmp = prop2.referencedTableName.split('.');
@@ -205,8 +242,11 @@ export class QueryBuilderHelper {
             join.primaryKeys.forEach((primaryKey, idx) => {
                 const right = `${join.alias}.${join.joinColumns[idx]}`;
                 if (join.prop.formula) {
-                    const alias = this.platform.quoteIdentifier(join.ownerAlias);
-                    const left = join.prop.formula(alias);
+                    const quotedAlias = this.platform.quoteIdentifier(join.ownerAlias).toString();
+                    const ownerMeta = this.aliasMap[join.ownerAlias]?.meta ?? this.metadata.get(this.entityName);
+                    const table = this.createFormulaTable(quotedAlias, ownerMeta, schema);
+                    const columns = ownerMeta.createColumnMappingObject(p => this.getTPTAliasForProperty(p.name, join.ownerAlias), quotedAlias);
+                    const left = this.driver.evaluateFormula(join.prop.formula, columns, table);
                     conditions.push(`${left} = ${this.platform.quoteIdentifier(right)}`);
                     return;
                 }
@@ -216,11 +256,20 @@ export class QueryBuilderHelper {
                 conditions.push(`${left} = ${this.platform.quoteIdentifier(right)}`);
             });
         }
-        if (join.prop.targetMeta?.discriminatorValue && !join.path?.endsWith('[pivot]')) {
+        if (join.prop.targetMeta?.root.inheritanceType === 'sti' && join.prop.targetMeta?.discriminatorValue && !join.path?.endsWith('[pivot]')) {
             const typeProperty = join.prop.targetMeta.root.discriminatorColumn;
             const alias = join.inverseAlias ?? join.alias;
             join.cond[`${alias}.${typeProperty}`] = join.prop.targetMeta.discriminatorValue;
         }
+        // For polymorphic relations, add discriminator condition to filter by target entity type
+        if (join.prop.polymorphic && join.prop.discriminatorColumn && join.prop.discriminatorMap) {
+            const discriminatorValue = QueryHelper.findDiscriminatorValue(join.prop.discriminatorMap, join.prop.targetMeta.class);
+            if (discriminatorValue) {
+                const discriminatorCol = this.platform.quoteIdentifier(`${join.ownerAlias}.${join.prop.discriminatorColumn}`);
+                conditions.push(`${discriminatorCol} = ?`);
+                params.push(discriminatorValue);
+            }
+        }
         let sql = method + ' ';
         if (join.nested) {
             sql += `(${this.platform.quoteIdentifier(table)} as ${this.platform.quoteIdentifier(join.alias)}`;
@@ -243,7 +292,7 @@ export class QueryBuilderHelper {
         this.alias = oldAlias;
         if (subquery.sql) {
             conditions.push(subquery.sql);
-            params.push(...subquery.params);
+            subquery.params.forEach(p => params.push(p));
         }
         if (conditions.length > 0) {
             sql += ` on ${conditions.join(' and ')}`;
@@ -265,11 +314,11 @@ export class QueryBuilderHelper {
     isOneToOneInverse(field, meta) {
         meta ??= this.metadata.find(this.entityName);
         const prop = meta.properties[field.replace(/:ref$/, '')];
-        return prop && prop.kind === ReferenceKind.ONE_TO_ONE && !prop.owner;
+        return prop?.kind === ReferenceKind.ONE_TO_ONE && !prop.owner;
     }
     getTableName(entityName) {
         const meta = this.metadata.find(entityName);
-        return meta ? meta.collection : entityName;
+        return meta?.tableName ?? Utils.className(entityName);
     }
     /**
      * Checks whether the RE can be rewritten to simple LIKE query
@@ -332,7 +381,7 @@ export class QueryBuilderHelper {
     _appendQueryCondition(type, cond, operator) {
         const parts = [];
         const params = [];
-        for (const k of Object.keys(cond)) {
+        for (const k of Utils.getObjectQueryKeys(cond)) {
             if (k === '$and' || k === '$or') {
                 if (operator) {
                     this.append(() => this.appendGroupCondition(type, k, cond[k]), parts, params, operator);
@@ -344,7 +393,7 @@ export class QueryBuilderHelper {
             if (k === '$not') {
                 const res = this._appendQueryCondition(type, cond[k]);
                 parts.push(`not (${res.sql})`);
-                params.push(...res.params);
+                res.params.forEach(p => params.push(p));
                 continue;
             }
             this.append(() => this.appendQuerySubCondition(type, cond, k), parts, params);
@@ -362,7 +411,6 @@ export class QueryBuilderHelper {
     appendQuerySubCondition(type, cond, key) {
         const parts = [];
         const params = [];
-        const fields = Utils.splitPrimaryKeys(key);
         if (this.isSimpleRegExp(cond[key])) {
             parts.push(`${this.platform.quoteIdentifier(this.mapper(key, type))} like ?`);
             params.push(this.getRegExpParam(cond[key]));
@@ -372,19 +420,21 @@ export class QueryBuilderHelper {
             return this.processObjectSubCondition(cond, key, type);
         }
         const op = cond[key] === null ? 'is' : '=';
-        const raw = RawQueryFragment.getKnownFragment(key);
-        if (raw) {
+        if (Raw.isKnownFragmentSymbol(key)) {
+            const raw = Raw.getKnownFragment(key);
             const sql = raw.sql.replaceAll(ALIAS_REPLACEMENT, this.alias);
             const value = Utils.asArray(cond[key]);
             params.push(...raw.params);
             if (value.length > 0) {
-                const val = this.getValueReplacement(fields, value[0], params, key);
+                const k = key;
+                const val = this.getValueReplacement([k], value[0], params, k);
                 parts.push(`${sql} ${op} ${val}`);
                 return { sql: parts.join(' and '), params };
             }
             parts.push(sql);
             return { sql: parts.join(' and '), params };
         }
+        const fields = Utils.splitPrimaryKeys(key);
         if (this.subQueries[key]) {
             const val = this.getValueReplacement(fields, cond[key], params, key);
             parts.push(`(${this.subQueries[key]}) ${op} ${val}`);
@@ -404,9 +454,7 @@ export class QueryBuilderHelper {
         }
         // grouped condition for one field, e.g. `{ age: { $gte: 10, $lt: 50 } }`
         if (size > 1) {
-            const rawField = RawQueryFragment.getKnownFragment(key);
             const subCondition = Object.entries(value).map(([subKey, subValue]) => {
-                key = rawField?.clone().toString() ?? key;
                 return ({ [key]: { [subKey]: subValue } });
             });
             for (const sub of subCondition) {
@@ -424,7 +472,8 @@ export class QueryBuilderHelper {
             throw ValidationError.invalidQueryCondition(cond);
         }
         const replacement = this.getOperatorReplacement(op, value);
-        const fields = Utils.splitPrimaryKeys(key);
+        const rawField = Raw.isKnownFragmentSymbol(key);
+        const fields = rawField ? [key] : Utils.splitPrimaryKeys(key);
         if (fields.length > 1 && Array.isArray(value[op])) {
             const singleTuple = !value[op].every((v) => Array.isArray(v));
             if (!this.platform.allowsComparingTuples()) {
@@ -452,12 +501,15 @@ export class QueryBuilderHelper {
             parts.push(`(${this.subQueries[key]}) ${replacement} ${val}`);
             return { sql: parts.join(' and '), params };
         }
-        const [a, f] = this.splitField(key);
-        const prop = this.getProperty(f, a);
+        const [a, f] = rawField ? [] : this.splitField(key);
+        const prop = f && this.getProperty(f, a);
+        if (prop && [ReferenceKind.ONE_TO_MANY, ReferenceKind.MANY_TO_MANY].includes(prop.kind)) {
+            return { sql: '', params };
+        }
         if (op === '$fulltext') {
             /* v8 ignore next */
             if (!prop) {
-                throw new Error(`Cannot use $fulltext operator on ${key}, property not found`);
+                throw new Error(`Cannot use $fulltext operator on ${String(key)}, property not found`);
             }
             const { sql, params: params2 } = raw(this.platform.getFullTextWhereClause(prop), {
                 column: this.mapper(key, type, undefined, null),
@@ -469,7 +521,7 @@ export class QueryBuilderHelper {
         else if (['$in', '$nin'].includes(op) && Array.isArray(value[op]) && value[op].length === 0) {
             parts.push(`1 = ${op === '$in' ? 0 : 1}`);
         }
-        else if (value[op] instanceof RawQueryFragment || value[op] instanceof NativeQueryBuilder) {
+        else if (value[op] instanceof Raw || value[op] instanceof NativeQueryBuilder) {
             const query = value[op] instanceof NativeQueryBuilder ? value[op].toRaw() : value[op];
             const mappedKey = this.mapper(key, type, query, null);
             let sql = query.sql;
@@ -501,7 +553,7 @@ export class QueryBuilderHelper {
                 params.push(item);
             }
             else {
-                value.forEach(v => params.push(v));
+                value.forEach(p => params.push(p));
             }
             return `(${value.map(() => '?').join(', ')})`;
         }
@@ -528,6 +580,31 @@ export class QueryBuilderHelper {
         }
         return replacement;
     }
+    validateQueryOrder(orderBy) {
+        const strKeys = [];
+        const rawKeys = [];
+        for (const key of Utils.getObjectQueryKeys(orderBy)) {
+            const raw = Raw.getKnownFragment(key);
+            if (raw) {
+                rawKeys.push(raw);
+            }
+            else {
+                strKeys.push(key);
+            }
+        }
+        if (strKeys.length > 0 && rawKeys.length > 0) {
+            const example = [
+                ...strKeys.map(key => ({ [key]: orderBy[key] })),
+                ...rawKeys.map(rawKey => ({ [`raw('${rawKey.sql}')`]: orderBy[rawKey] })),
+            ];
+            throw new Error([
+                `Invalid "orderBy": You are mixing field-based keys and raw SQL fragments inside a single object.`,
+                `This is not allowed because object key order cannot reliably preserve evaluation order.`,
+                `To fix this, split them into separate objects inside an array:\n`,
+                `orderBy: ${inspect(example, { depth: 5 }).replace(/"raw\('(.*)'\)"/g, `[raw('$1')]`)}`,
+            ].join('\n'));
+        }
+    }
     getQueryOrder(type, orderBy, populate) {
         if (Array.isArray(orderBy)) {
             return orderBy.flatMap(o => this.getQueryOrder(type, o, populate));
@@ -536,11 +613,11 @@ export class QueryBuilderHelper {
     }
     getQueryOrderFromObject(type, orderBy, populate) {
         const ret = [];
-        for (const key of Object.keys(orderBy)) {
+        for (const key of Utils.getObjectQueryKeys(orderBy)) {
             const direction = orderBy[key];
             const order = typeof direction === 'number' ? QueryOrderNumeric[direction] : direction;
-            const raw = RawQueryFragment.getKnownFragment(key);
-            if (raw) {
+            if (Raw.isKnownFragmentSymbol(key)) {
+                const raw = Raw.getKnownFragment(key);
                 ret.push(...this.platform.getOrderByExpression(this.platform.formatQuery(raw.sql, raw.params), order));
                 continue;
             }
@@ -549,7 +626,7 @@ export class QueryBuilderHelper {
                 let [alias, field] = this.splitField(f, true);
                 alias = populate[alias] || alias;
                 const prop = this.getProperty(field, alias);
-                const noPrefix = (prop?.persist === false && !prop.formula && !prop.embedded) || RawQueryFragment.isKnownFragment(f);
+                const noPrefix = (prop?.persist === false && !prop.formula && !prop.embedded) || Raw.isKnownFragment(f);
                 const column = this.mapper(noPrefix ? field : `${alias}.${field}`, type, undefined, null);
                 /* v8 ignore next */
                 const rawColumn = typeof column === 'string' ? column.split('.').map(e => this.platform.quoteIdentifier(e)).join('.') : column;
@@ -592,14 +669,15 @@ export class QueryBuilderHelper {
         if (type === QueryType.UPDATE) {
             const returningProps = meta.hydrateProps.filter(prop => prop.fieldNames && isRaw(data[prop.fieldNames[0]]));
             if (returningProps.length > 0) {
-                qb.returning(returningProps.flatMap(prop => {
+                const fields = returningProps.flatMap((prop) => {
                     if (prop.hasConvertToJSValueSQL) {
                         const aliased = this.platform.quoteIdentifier(prop.fieldNames[0]);
                         const sql = prop.customType.convertToJSValueSQL(aliased, this.platform) + ' as ' + this.platform.quoteIdentifier(prop.fieldNames[0]);
                         return [raw(sql)];
                     }
                     return prop.fieldNames;
-                }));
+                });
+                qb.returning(fields);
             }
         }
     }
@@ -624,7 +702,7 @@ export class QueryBuilderHelper {
     getLockSQL(qb, lockMode, lockTables = [], joinsMap) {
         const meta = this.metadata.find(this.entityName);
         if (lockMode === LockMode.OPTIMISTIC && meta && !meta.versionProperty) {
-            throw OptimisticLockError.lockFailed(this.entityName);
+            throw OptimisticLockError.lockFailed(Utils.className(this.entityName));
         }
         if (lockMode !== LockMode.OPTIMISTIC && lockTables.length === 0 && joinsMap) {
             const joins = Object.values(joinsMap);
@@ -650,9 +728,11 @@ export class QueryBuilderHelper {
     prefix(field, always = false, quote = false, idx) {
         let ret;
         if (!this.isPrefixed(field)) {
-            const alias = always ? (quote ? this.alias : this.platform.quoteIdentifier(this.alias)) + '.' : '';
-            const fieldName = this.fieldName(field, this.alias, always, idx);
-            if (fieldName instanceof RawQueryFragment) {
+            // For TPT inheritance, resolve the correct alias for this property
+            const tptAlias = this.getTPTAliasForProperty(field, this.alias);
+            const alias = always ? (quote ? tptAlias : this.platform.quoteIdentifier(tptAlias)) + '.' : '';
+            const fieldName = this.fieldName(field, tptAlias, always, idx);
+            if (fieldName instanceof Raw) {
                 return fieldName.sql;
             }
             ret = alias + fieldName;
@@ -660,11 +740,16 @@ export class QueryBuilderHelper {
         else {
             const [a, ...rest] = field.split('.');
             const f = rest.join('.');
-            const fieldName = this.fieldName(f, a, always, idx);
-            if (fieldName instanceof RawQueryFragment) {
+            // For TPT inheritance, resolve the correct alias for this property
+            // Only apply TPT resolution when `a` is an actual table alias (in aliasMap),
+            // not when it's an embedded property name like 'profile1.identity.links'
+            const isTableAlias = !!this.aliasMap[a];
+            const resolvedAlias = isTableAlias ? this.getTPTAliasForProperty(f, a) : a;
+            const fieldName = this.fieldName(f, resolvedAlias, always, idx);
+            if (fieldName instanceof Raw) {
                 return fieldName.sql;
             }
-            ret = a + '.' + fieldName;
+            ret = resolvedAlias + '.' + fieldName;
         }
         if (quote) {
             return this.platform.quoteIdentifier(ret);
@@ -683,7 +768,7 @@ export class QueryBuilderHelper {
         }
         for (const sub of subCondition) {
             // skip nesting parens if the value is simple = scalar or object without operators or with only single key, being the operator
-            const keys = Object.keys(sub);
+            const keys = Utils.getObjectQueryKeys(sub);
             const val = sub[keys[0]];
             const simple = !Utils.isPlainObject(val) || Utils.getObjectKeysSize(val) === 1 || Object.keys(val).every(k => !Utils.isOperator(k));
             if (keys.length === 1 && simple) {
@@ -719,27 +804,20 @@ export class QueryBuilderHelper {
     }
     getProperty(field, alias) {
         const entityName = this.aliasMap[alias]?.entityName || this.entityName;
-        const meta = this.metadata.find(entityName);
+        const meta = this.metadata.get(entityName);
         // check if `alias` is not matching an embedded property name instead of alias, e.g. `address.city`
-        if (alias && meta) {
+        if (alias) {
             const prop = meta.properties[alias];
             if (prop?.kind === ReferenceKind.EMBEDDED) {
-                // we want to select the full object property so hydration works as expected
-                if (prop.object) {
-                    return prop;
-                }
                 const parts = field.split('.');
                 const nest = (p) => parts.length > 0 ? nest(p.embeddedProps[parts.shift()]) : p;
                 return nest(prop);
             }
         }
-        if (meta) {
-            if (meta.properties[field]) {
-                return meta.properties[field];
-            }
-            return meta.relations.find(prop => prop.fieldNames?.some(name => field === name));
+        if (meta.properties[field]) {
+            return meta.properties[field];
         }
-        return undefined;
+        return meta.relations.find(prop => prop.fieldNames?.some(name => field === name));
     }
     isTableNameAliasRequired(type) {
         return [QueryType.SELECT, QueryType.COUNT].includes(type);
@@ -753,4 +831,15 @@ export class QueryBuilderHelper {
         }
         return cond;
     }
+    createFormulaTable(alias, meta, schema) {
+        const effectiveSchema = schema ?? (meta.schema !== '*' ? meta.schema : undefined);
+        const qualifiedName = effectiveSchema ? `${effectiveSchema}.${meta.tableName}` : meta.tableName;
+        return {
+            alias,
+            name: meta.tableName,
+            schema: effectiveSchema,
+            qualifiedName,
+            toString: () => alias,
+        };
+    }
 }

package/query/ScalarCriteriaNode.js

@@ -8,11 +8,11 @@ import { QueryBuilder } from './QueryBuilder.js';
 export class ScalarCriteriaNode extends CriteriaNode {
     process(qb, 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, matchPopulateJoins });
+        const nestedAlias = qb.getAliasForJoinPath(this.getPath(options), { ...options, matchPopulateJoins });
         if (this.shouldJoin(qb, nestedAlias)) {
             const path = this.getPath();
             const parentPath = this.parent.getPath(); // the parent is always there, otherwise `shouldJoin` would return `false`
-            const nestedAlias = qb.getAliasForJoinPath(path) || qb.getNextAlias(this.prop?.pivotTable ?? this.entityName);
+            const nestedAlias = qb.getAliasForJoinPath(path) || qb.getNextAlias(this.prop?.pivotEntity ?? this.entityName);
             const field = this.aliased(this.prop.name, options?.alias);
             const type = this.prop.kind === ReferenceKind.MANY_TO_MANY ? JoinType.pivotJoin : JoinType.leftJoin;
             qb.join(field, nestedAlias, undefined, type, path);

package/query/raw.d.ts

@@ -1,6 +1,13 @@
 import { type AnyString, type Dictionary, type EntityKey, type RawQueryFragment } from '@mikro-orm/core';
-import type { SelectQueryBuilder } from 'kysely';
-import { QueryBuilder } from './QueryBuilder.js';
+import type { SelectQueryBuilder as KyselySelectQueryBuilder } from 'kysely';
+/** @internal Type for QueryBuilder instances passed to raw() - uses toRaw to distinguish from Kysely QueryBuilder */
+type QueryBuilderLike = {
+    toQuery(): {
+        sql: string;
+        params: readonly unknown[];
+    };
+    toRaw(): RawQueryFragment;
+};
 /**
  * Creates raw SQL query fragment that can be assigned to a property or part of a filter. This fragment is represented
  * by `RawQueryFragment` class instance that can be serialized to a string, so it can be used both as an object value
@@ -56,4 +63,5 @@ import { QueryBuilder } from './QueryBuilder.js';
  * export class Author { ... }
  * ```
  */
-export declare function raw<T extends object = any, R = any>(sql: SelectQueryBuilder<any, any, any> | QueryBuilder<T> | EntityKey<T> | EntityKey<T>[] | AnyString | ((alias: string) => string) | RawQueryFragment, params?: readonly unknown[] | Dictionary<unknown>): NoInfer<R>;
+export declare function raw<R = RawQueryFragment & symbol, T extends object = any>(sql: QueryBuilderLike | KyselySelectQueryBuilder<any, any, any> | EntityKey<T> | EntityKey<T>[] | AnyString | ((alias: string) => string) | RawQueryFragment, params?: readonly unknown[] | Dictionary<unknown>): R;
+export {};

package/query/raw.js

@@ -1,5 +1,4 @@
 import { raw as raw_, Utils } from '@mikro-orm/core';
-import { QueryBuilder } from './QueryBuilder.js';
 /**
  * Creates raw SQL query fragment that can be assigned to a property or part of a filter. This fragment is represented
  * by `RawQueryFragment` class instance that can be serialized to a string, so it can be used both as an object value
@@ -60,7 +59,7 @@ export function raw(sql, params) {
         const query = sql.compile();
         return raw_(query.sql, query.parameters);
     }
-    if (sql instanceof QueryBuilder) {
+    if (Utils.isObject(sql) && 'toQuery' in sql) {
         const query = sql.toQuery();
         return raw_(query.sql, query.params);
     }