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

package/AbstractSqlDriver.js

@@ -1,4 +1,4 @@
-import { ALIAS_REPLACEMENT_RE, DatabaseDriver, EntityManagerType, getLoadingStrategy, getOnConflictFields, getOnConflictReturningFields, helper, isRaw, LoadStrategy, parseJsonSafe, QueryFlag, QueryHelper, QueryOrder, raw, RawQueryFragment, ReferenceKind, Utils, } from '@mikro-orm/core';
+import { ALIAS_REPLACEMENT_RE, DatabaseDriver, EntityManagerType, getLoadingStrategy, getOnConflictFields, getOnConflictReturningFields, helper, isRaw, LoadStrategy, parseJsonSafe, PolymorphicRef, QueryFlag, QueryHelper, QueryOrder, raw, RawQueryFragment, ReferenceKind, Utils, } from '@mikro-orm/core';
 import { QueryBuilder } from './query/QueryBuilder.js';
 import { JoinType, QueryType } from './query/enums.js';
 import { SqlEntityManager } from './SqlEntityManager.js';
@@ -17,6 +17,29 @@ export class AbstractSqlDriver extends DatabaseDriver {
     getPlatform() {
         return this.platform;
     }
+    /** Evaluates a formula callback, handling both string and Raw return values. */
+    evaluateFormula(formula, columns, table) {
+        const result = formula(columns, table);
+        return isRaw(result) ? this.platform.formatQuery(result.sql, result.params) : result;
+    }
+    /** For TPT entities, returns ownProps (columns in this table); otherwise returns all props. */
+    getTableProps(meta) {
+        return meta.inheritanceType === 'tpt' && meta.ownProps ? meta.ownProps : meta.props;
+    }
+    /** Creates a FormulaTable object for use in formula callbacks. */
+    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 };
+    }
+    validateSqlOptions(options) {
+        if (options.collation != null && typeof options.collation !== 'string') {
+            throw new Error('Collation option for SQL drivers must be a string (collation name). Use a CollationOptions object only with MongoDB.');
+        }
+        if (options.indexHint != null && typeof options.indexHint !== 'string') {
+            throw new Error('indexHint for SQL drivers must be a string (e.g. \'force index(my_index)\'). Use an object only with MongoDB.');
+        }
+    }
     createEntityManager(useContext) {
         const EntityManagerClass = this.config.get('entityManager', SqlEntityManager);
         return new EntityManagerClass(this.config, this, this.metadata, useContext);
@@ -25,14 +48,16 @@ export class AbstractSqlDriver extends DatabaseDriver {
         const connectionType = this.resolveConnectionType({ ctx: options.ctx, connectionType: options.connectionType });
         const populate = this.autoJoinOneToOneOwner(meta, options.populate, options.fields);
         const joinedProps = this.joinedProps(meta, populate, options);
-        const qb = this.createQueryBuilder(meta.className, options.ctx, connectionType, false, options.logging, undefined, options.em);
-        const fields = this.buildFields(meta, populate, joinedProps, qb, qb.alias, 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 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);
         Utils.asArray(options.flags).forEach(flag => qb.setFlag(flag));
         if (Utils.isPrimaryKey(where, meta.compositePK)) {
             where = { [Utils.getPrimaryKeyHash(meta.primaryKeys)]: where };
         }
+        this.validateSqlOptions(options);
         const { first, last, before, after } = options;
         const isCursorPagination = [first, last, before, after].some(v => v != null);
         qb.__populateWhere = options._populateWhere;
@@ -43,9 +68,9 @@ export class AbstractSqlDriver extends DatabaseDriver {
             .groupBy(options.groupBy)
             .having(options.having)
             .indexHint(options.indexHint)
+            .collation(options.collation)
             .comment(options.comments)
-            .hintComment(options.hintComments)
-            .withSchema(this.getSchemaName(meta, options));
+            .hintComment(options.hintComments);
         if (isCursorPagination) {
             const { orderBy: newOrderBy, where } = this.processCursorOptions(meta, options, orderBy);
             qb.andWhere(where).orderBy(newOrderBy);
@@ -66,8 +91,8 @@ export class AbstractSqlDriver extends DatabaseDriver {
     }
     async find(entityName, where, options = {}) {
         options = { populate: [], orderBy: [], ...options };
-        const meta = this.metadata.find(entityName);
-        if (meta?.virtual) {
+        const meta = this.metadata.get(entityName);
+        if (meta.virtual) {
             return this.findVirtual(entityName, where, options);
         }
         const qb = await this.createQueryBuilderFromOptions(meta, where, options);
@@ -165,16 +190,12 @@ export class AbstractSqlDriver extends DatabaseDriver {
         yield* res;
     }
     async wrapVirtualExpressionInSubquery(meta, expression, where, options, type) {
-        const qb = await this.createQueryBuilderFromOptions(meta, where, options);
+        const qb = await this.createQueryBuilderFromOptions(meta, where, this.forceBalancedStrategy(options));
         qb.setFlag(QueryFlag.DISABLE_PAGINATE);
         const isCursorPagination = [options.first, options.last, options.before, options.after].some(v => v != null);
         const native = qb.getNativeQuery(false);
         if (type === QueryType.COUNT) {
-            native
-                .clear('select')
-                .clear('limit')
-                .clear('offset')
-                .count();
+            native.clear('select').clear('limit').clear('offset').count();
         }
         native.from(raw(`(${expression}) as ${this.platform.quoteIdentifier(qb.alias)}`));
         const query = native.compile();
@@ -188,7 +209,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
         return res.map(row => this.mapResult(row, meta));
     }
     async *wrapVirtualExpressionInSubqueryStream(meta, expression, where, options, type) {
-        const qb = await this.createQueryBuilderFromOptions(meta, where, options);
+        const qb = await this.createQueryBuilderFromOptions(meta, where, this.forceBalancedStrategy(options));
         qb.unsetFlag(QueryFlag.DISABLE_PAGINATE);
         const native = qb.getNativeQuery(false);
         native.from(raw(`(${expression}) as ${this.platform.quoteIdentifier(qb.alias)}`));
@@ -199,7 +220,34 @@ export class AbstractSqlDriver extends DatabaseDriver {
             yield this.mapResult(row, meta);
         }
     }
+    /**
+     * 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.
+     */
+    forceBalancedStrategy(options) {
+        const clearStrategy = (hints) => {
+            return hints.map(hint => ({
+                ...hint,
+                strategy: undefined,
+                children: hint.children ? clearStrategy(hint.children) : undefined,
+            }));
+        };
+        const opts = { ...options, strategy: 'balanced' };
+        if (Array.isArray(opts.populate)) {
+            opts.populate = clearStrategy(opts.populate);
+        }
+        return opts;
+    }
     mapResult(result, meta, populate = [], qb, map = {}) {
+        // For TPT inheritance, map aliased parent table columns back to their field names
+        if (qb && meta.inheritanceType === 'tpt' && meta.tptParent) {
+            this.mapTPTColumns(result, meta, qb);
+        }
+        // For TPT polymorphic queries (querying a base class), map child table fields
+        if (qb && meta.inheritanceType === 'tpt' && meta.allTPTDescendants?.length) {
+            const mainAlias = qb.mainAlias?.aliasName ?? 'e0';
+            this.mapTPTChildFields(result, meta, mainAlias, qb, result);
+        }
         const ret = super.mapResult(result, meta);
         /* v8 ignore next */
         if (!ret) {
@@ -211,6 +259,33 @@ export class AbstractSqlDriver extends DatabaseDriver {
         }
         return ret;
     }
+    /**
+     * Maps aliased columns from TPT parent tables back to their original field names.
+     * TPT parent columns are selected with aliases like `parent_alias__column_name`,
+     * and need to be renamed back to `column_name` for the result mapper to work.
+     */
+    mapTPTColumns(result, meta, qb) {
+        const tptAliases = qb._tptAlias;
+        // Walk up the TPT hierarchy
+        let parentMeta = meta.tptParent;
+        while (parentMeta) {
+            const parentAlias = tptAliases[parentMeta.className];
+            if (parentAlias) {
+                // Rename columns from this parent table
+                for (const prop of parentMeta.ownProps) {
+                    for (const fieldName of prop.fieldNames) {
+                        const aliasedKey = `${parentAlias}__${fieldName}`;
+                        if (aliasedKey in result) {
+                            // Copy the value to the unaliased field name and remove the aliased key
+                            result[fieldName] = result[aliasedKey];
+                            delete result[aliasedKey];
+                        }
+                    }
+                }
+            }
+            parentMeta = parentMeta.tptParent;
+        }
+    }
     mapJoinedProps(result, meta, populate, qb, root, map, parentJoinPath) {
         const joinedProps = this.joinedProps(meta, populate);
         joinedProps.forEach(hint => {
@@ -220,8 +295,45 @@ export class AbstractSqlDriver extends DatabaseDriver {
             if (!prop) {
                 return;
             }
+            // Polymorphic to-one: iterate targets, find the matching one, build entity from its columns.
+            // Skip :ref hints — no JOINs were created, so the FK reference is already set by the result mapper.
+            if (prop.polymorphic && prop.polymorphTargets?.length && !ref && [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
+                const basePath = parentJoinPath ? `${parentJoinPath}.${prop.name}` : `${meta.name}.${prop.name}`;
+                const pathPrefix = !parentJoinPath ? '[populate]' : '';
+                let matched = false;
+                for (const targetMeta of prop.polymorphTargets) {
+                    const targetPath = `${pathPrefix}${basePath}[${targetMeta.className}]`;
+                    const relationAlias = qb.getAliasForJoinPath(targetPath, { matchPopulateJoins: true });
+                    const meta2 = targetMeta;
+                    const targetProps = meta2.props.filter(p => this.platform.shouldHaveColumn(p, hint.children || []));
+                    const hasPK = meta2.getPrimaryProps().every(pk => pk.fieldNames.every(name => root[`${relationAlias}__${name}`] != null));
+                    if (hasPK && !matched) {
+                        matched = true;
+                        let relationPojo = {};
+                        const tz = this.platform.getTimezone();
+                        for (const p of targetProps) {
+                            this.mapJoinedProp(relationPojo, p, relationAlias, root, tz, meta2);
+                        }
+                        // Inject the entity class constructor so that the factory creates the correct type
+                        Object.defineProperty(relationPojo, 'constructor', { value: meta2.class, enumerable: false, configurable: true });
+                        result[prop.name] = relationPojo;
+                        const populateChildren = hint.children || [];
+                        this.mapJoinedProps(relationPojo, meta2, populateChildren, qb, root, map, targetPath);
+                    }
+                    // Clean up aliased columns for ALL targets (even non-matching ones)
+                    for (const p of targetProps) {
+                        for (const name of p.fieldNames) {
+                            delete root[`${relationAlias}__${name}`];
+                        }
+                    }
+                }
+                if (!matched) {
+                    result[prop.name] = null;
+                }
+                return;
+            }
             const pivotRefJoin = prop.kind === ReferenceKind.MANY_TO_MANY && ref;
-            const meta2 = this.metadata.find(prop.type);
+            const meta2 = prop.targetMeta;
             let path = parentJoinPath ? `${parentJoinPath}.${prop.name}` : `${meta.name}.${prop.name}`;
             if (!parentJoinPath) {
                 path = '[populate]' + path;
@@ -237,7 +349,8 @@ export class AbstractSqlDriver extends DatabaseDriver {
             // pivot ref joins via joined strategy need to be handled separately here, as they dont join the target entity
             if (pivotRefJoin) {
                 let item;
-                if (prop.inverseJoinColumns.length > 1) { // composite keys
+                if (prop.inverseJoinColumns.length > 1) {
+                    // composite keys
                     item = prop.inverseJoinColumns.map(name => root[`${relationAlias}__${name}`]);
                 }
                 else {
@@ -252,10 +365,8 @@ export class AbstractSqlDriver extends DatabaseDriver {
                 }
                 return;
             }
-            const mapToPk = !!(ref || prop.mapToPk);
-            const targetProps = mapToPk
-                ? meta2.getPrimaryProps()
-                : meta2.props.filter(prop => this.platform.shouldHaveColumn(prop, hint.children || []));
+            const mapToPk = !hint.dataOnly && !!(ref || prop.mapToPk);
+            const targetProps = mapToPk ? meta2.getPrimaryProps() : meta2.props.filter(prop => this.platform.shouldHaveColumn(prop, hint.children || []));
             // If the primary key value for the relation is null, we know we haven't joined to anything
             // and therefore we don't return any record (since all values would be null)
             const hasPK = meta2.getPrimaryProps().every(pk => pk.fieldNames.every(name => {
@@ -280,7 +391,8 @@ export class AbstractSqlDriver extends DatabaseDriver {
                 .filter(prop => !ref && prop.persist === false && prop.fieldNames)
                 .forEach(prop => {
                 /* v8 ignore next */
-                if (prop.fieldNames.length > 1) { // composite keys
+                if (prop.fieldNames.length > 1) {
+                    // composite keys
                     relationPojo[prop.name] = prop.fieldNames.map(name => root[`${relationAlias}__${name}`]);
                 }
                 else {
@@ -290,41 +402,10 @@ export class AbstractSqlDriver extends DatabaseDriver {
             });
             const tz = this.platform.getTimezone();
             for (const prop of targetProps) {
-                if (prop.fieldNames.every(name => typeof root[`${relationAlias}__${name}`] === 'undefined')) {
-                    continue;
-                }
-                if (prop.fieldNames.length > 1) { // composite keys
-                    const fk = prop.fieldNames.map(name => root[`${relationAlias}__${name}`]);
-                    const pk = Utils.mapFlatCompositePrimaryKey(fk, prop);
-                    relationPojo[prop.name] = pk.every(val => val != null) ? pk : null;
-                }
-                else if (prop.runtimeType === 'Date') {
-                    const alias = `${relationAlias}__${prop.fieldNames[0]}`;
-                    const value = root[alias];
-                    if (tz && tz !== 'local' && typeof value === 'string' && !value.includes('+') && value.lastIndexOf('-') < 11 && !value.endsWith('Z')) {
-                        relationPojo[prop.name] = this.platform.parseDate(value + tz);
-                    }
-                    else if (['string', 'number'].includes(typeof value)) {
-                        relationPojo[prop.name] = this.platform.parseDate(value);
-                    }
-                    else {
-                        relationPojo[prop.name] = value;
-                    }
-                }
-                else {
-                    const alias = `${relationAlias}__${prop.fieldNames[0]}`;
-                    relationPojo[prop.name] = root[alias];
-                    if (prop.kind === ReferenceKind.EMBEDDED && (prop.object || meta.embeddable)) {
-                        const item = parseJsonSafe(relationPojo[prop.name]);
-                        if (Array.isArray(item)) {
-                            relationPojo[prop.name] = item.map(row => row == null ? row : this.comparator.mapResult(prop.type, row));
-                        }
-                        else {
-                            relationPojo[prop.name] = item == null ? item : this.comparator.mapResult(prop.type, item);
-                        }
-                    }
-                }
+                this.mapJoinedProp(relationPojo, prop, relationAlias, root, tz, meta2);
             }
+            // Handle TPT polymorphic child fields - map fields from child table aliases
+            this.mapTPTChildFields(relationPojo, meta2, relationAlias, qb, root);
             // properties can be mapped to multiple places, e.g. when sharing a column in multiple FKs,
             // so we need to delete them after everything is mapped from given level
             for (const prop of targetProps) {
@@ -348,6 +429,65 @@ export class AbstractSqlDriver extends DatabaseDriver {
             this.mapJoinedProps(relationPojo, meta2, populateChildren, qb, root, map, path);
         });
     }
+    /**
+     * Maps a single property from a joined result row into the relation pojo.
+     * Handles polymorphic FKs, composite keys, Date parsing, and embedded objects.
+     */
+    mapJoinedProp(relationPojo, prop, relationAlias, root, tz, meta, options) {
+        if (prop.fieldNames.every(name => typeof root[`${relationAlias}__${name}`] === 'undefined')) {
+            return;
+        }
+        if (prop.polymorphic) {
+            const discriminatorAlias = `${relationAlias}__${prop.fieldNames[0]}`;
+            const discriminatorValue = root[discriminatorAlias];
+            const pkFieldNames = prop.fieldNames.slice(1);
+            const pkValues = pkFieldNames.map(name => root[`${relationAlias}__${name}`]);
+            const pkValue = pkValues.length === 1 ? pkValues[0] : pkValues;
+            if (discriminatorValue != null && pkValue != null) {
+                relationPojo[prop.name] = new PolymorphicRef(discriminatorValue, pkValue);
+            }
+            else {
+                relationPojo[prop.name] = null;
+            }
+        }
+        else if (prop.fieldNames.length > 1) {
+            // composite keys
+            const fk = prop.fieldNames.map(name => root[`${relationAlias}__${name}`]);
+            const pk = Utils.mapFlatCompositePrimaryKey(fk, prop);
+            relationPojo[prop.name] = pk.every(val => val != null) ? pk : null;
+        }
+        else if (prop.runtimeType === 'Date') {
+            const alias = `${relationAlias}__${prop.fieldNames[0]}`;
+            const value = root[alias];
+            if (tz && tz !== 'local' && typeof value === 'string' && !value.includes('+') && value.lastIndexOf('-') < 11 && !value.endsWith('Z')) {
+                relationPojo[prop.name] = this.platform.parseDate(value + tz);
+            }
+            else if (['string', 'number'].includes(typeof value)) {
+                relationPojo[prop.name] = this.platform.parseDate(value);
+            }
+            else {
+                relationPojo[prop.name] = value;
+            }
+        }
+        else {
+            const alias = `${relationAlias}__${prop.fieldNames[0]}`;
+            relationPojo[prop.name] = root[alias];
+            if (prop.kind === ReferenceKind.EMBEDDED && (prop.object || meta.embeddable)) {
+                const item = parseJsonSafe(relationPojo[prop.name]);
+                if (Array.isArray(item)) {
+                    relationPojo[prop.name] = item.map(row => (row == null ? row : this.comparator.mapResult(prop.targetMeta, row)));
+                }
+                else {
+                    relationPojo[prop.name] = item == null ? item : this.comparator.mapResult(prop.targetMeta, item);
+                }
+            }
+        }
+        if (options?.deleteFromRoot) {
+            for (const name of prop.fieldNames) {
+                delete root[`${relationAlias}__${name}`];
+            }
+        }
+    }
     async count(entityName, where, options = {}) {
         const meta = this.metadata.get(entityName);
         if (meta.virtual) {
@@ -356,19 +496,22 @@ export class AbstractSqlDriver extends DatabaseDriver {
         options = { populate: [], ...options };
         const populate = options.populate;
         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);
         const populateWhere = this.buildPopulateWhere(meta, joinedProps, options);
         if (meta && !Utils.isEmpty(populate)) {
-            this.buildFields(meta, populate, joinedProps, qb, qb.alias, options);
+            this.buildFields(meta, populate, joinedProps, qb, qb.alias, options, schema);
         }
+        this.validateSqlOptions(options);
         qb.__populateWhere = options._populateWhere;
         qb.indexHint(options.indexHint)
+            .collation(options.collation)
             .comment(options.comments)
             .hintComment(options.hintComments)
             .groupBy(options.groupBy)
             .having(options.having)
             .populate(populate, joinedProps.length > 0 ? populateWhere : undefined, joinedProps.length > 0 ? options.populateFilter : undefined)
-            .withSchema(this.getSchemaName(meta, options))
+            .withSchema(schema)
             .where(where);
         if (options.em) {
             await qb.applyJoinedFilters(options.em, options.filters);
@@ -377,19 +520,19 @@ export class AbstractSqlDriver extends DatabaseDriver {
     }
     async nativeInsert(entityName, data, options = {}) {
         options.convertCustomTypes ??= true;
-        const meta = this.metadata.find(entityName);
-        const collections = this.extractManyToMany(entityName, data);
-        const pks = meta?.primaryKeys ?? [this.config.getNamingStrategy().referenceColumnName()];
+        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));
         const res = await this.rethrow(qb.insert(data).execute('run', false));
         res.row = res.row || {};
         let pk;
-        if (pks.length > 1) { // owner has composite pk
-            pk = Utils.getPrimaryKeyCond(data, pks);
+        if (meta.primaryKeys.length > 1) {
+            // owner has composite pk
+            pk = Utils.getPrimaryKeyCond(data, meta.primaryKeys);
         }
         else {
             /* v8 ignore next */
-            res.insertId = data[pks[0]] ?? res.insertId ?? res.row[pks[0]];
+            res.insertId = data[meta.primaryKeys[0]] ?? res.insertId ?? res.row[meta.primaryKeys[0]];
             pk = [res.insertId];
         }
         await this.processManyToMany(meta, pk, collections, false, options);
@@ -398,25 +541,26 @@ export class AbstractSqlDriver extends DatabaseDriver {
     async nativeInsertMany(entityName, data, options = {}, transform) {
         options.processCollections ??= true;
         options.convertCustomTypes ??= true;
-        const meta = this.metadata.find(entityName)?.root;
-        const collections = options.processCollections ? data.map(d => this.extractManyToMany(entityName, d)) : [];
-        const pks = this.getPrimaryKeyFields(entityName);
+        const entityMeta = this.metadata.get(entityName);
+        const meta = entityMeta.inheritanceType === 'tpt' ? entityMeta : entityMeta.root;
+        const collections = options.processCollections ? data.map(d => this.extractManyToMany(meta, d)) : [];
+        const pks = this.getPrimaryKeyFields(meta);
         const set = new Set();
         data.forEach(row => Utils.keys(row).forEach(k => set.add(k)));
-        const props = [...set].map(name => meta?.properties[name] ?? { name, fieldNames: [name] });
-        let fields = Utils.flatten(props.map(prop => prop.fieldNames));
+        const props = [...set].map(name => meta.properties[name] ?? { name, fieldNames: [name] });
+        // For STI with conflicting fieldNames, include all alternative columns
+        let fields = Utils.flatten(props.map(prop => prop.stiFieldNames ?? prop.fieldNames));
         const duplicates = Utils.findDuplicates(fields);
         const params = [];
         if (duplicates.length) {
             fields = Utils.unique(fields);
         }
-        /* v8 ignore next */
-        const tableName = meta ? this.getTableName(meta, options) : this.platform.quoteIdentifier(entityName);
+        const tableName = this.getTableName(meta, options);
         let sql = `insert into ${tableName} `;
         sql += fields.length > 0 ? '(' + fields.map(k => this.platform.quoteIdentifier(k)).join(', ') + ')' : `(${this.platform.quoteIdentifier(pks[0])})`;
-        if (meta && this.platform.usesOutputStatement()) {
-            const returningProps = meta.props
-                .filter(prop => prop.persist !== false && prop.defaultRaw || prop.autoincrement || prop.generated)
+        if (this.platform.usesOutputStatement()) {
+            const returningProps = this.getTableProps(meta)
+                .filter(prop => (prop.persist !== false && prop.defaultRaw) || prop.autoincrement || prop.generated)
                 .filter(prop => !(prop.name in data[0]) || isRaw(data[0][prop.name]));
             const returningFields = Utils.flatten(returningProps.map(prop => prop.fieldNames));
             sql += returningFields.length > 0 ? ` output ${returningFields.map(field => 'inserted.' + this.platform.quoteIdentifier(field)).join(', ')}` : '';
@@ -457,25 +601,44 @@ export class AbstractSqlDriver extends DatabaseDriver {
             params.push(value);
         };
         if (fields.length > 0 || this.platform.usesDefaultKeyword()) {
-            sql += data.map(row => {
+            sql += data
+                .map(row => {
                 const keys = [];
                 const usedDups = [];
                 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]];
+                        for (const field of prop.stiFieldNames) {
+                            params.push(field === activeField ? row[prop.name] : null);
+                            keys.push('?');
+                        }
+                        return;
+                    }
                     if (prop.fieldNames.length > 1) {
                         const newFields = [];
-                        const allParam = [...(Utils.asArray(row[prop.name]) ?? prop.fieldNames.map(() => null))];
+                        let rawParam;
+                        const target = row[prop.name];
+                        if (prop.polymorphic && target instanceof PolymorphicRef) {
+                            rawParam = target.toTuple();
+                        }
+                        else {
+                            rawParam = Utils.asArray(target) ?? prop.fieldNames.map(() => null);
+                        }
+                        // Deep flatten nested arrays when needed (for deeply nested composite keys like Tag -> Comment -> Post -> User)
+                        const needsFlatten = rawParam.length !== prop.fieldNames.length && rawParam.some(v => Array.isArray(v));
+                        const allParam = needsFlatten ? Utils.flatten(rawParam, true) : rawParam;
                         // TODO(v7): instead of making this conditional here, the entity snapshot should respect `ownColumns`,
                         //  but that means changing the compiled PK getters, which might be seen as breaking
                         const columns = allParam.length > 1 ? prop.fieldNames : prop.ownColumns;
-                        const newParam = [];
+                        const param = [];
                         columns.forEach((field, idx) => {
                             if (usedDups.includes(field)) {
                                 return;
                             }
                             newFields.push(field);
-                            newParam.push(allParam[idx]);
+                            param.push(allParam[idx]);
                         });
-                        const param = Utils.flatten(newParam);
                         newFields.forEach((field, idx) => {
                             if (!duplicates.includes(field) || !usedDups.includes(field)) {
                                 params.push(param[idx]);
@@ -499,11 +662,12 @@ export class AbstractSqlDriver extends DatabaseDriver {
                     }
                 });
                 return '(' + (keys.join(', ') || 'default') + ')';
-            }).join(', ');
+            })
+                .join(', ');
         }
         if (meta && this.platform.usesReturningStatement()) {
-            const returningProps = meta.props
-                .filter(prop => prop.persist !== false && prop.defaultRaw || prop.autoincrement || prop.generated)
+            const returningProps = this.getTableProps(meta)
+                .filter(prop => (prop.persist !== false && prop.defaultRaw) || prop.autoincrement || prop.generated)
                 .filter(prop => !(prop.name in data[0]) || isRaw(data[0][prop.name]));
             const returningFields = Utils.flatten(returningProps.map(prop => prop.fieldNames));
             /* v8 ignore next */
@@ -515,7 +679,8 @@ export class AbstractSqlDriver extends DatabaseDriver {
         const res = await this.execute(sql, params, 'run', options.ctx, options.loggerContext);
         let pk;
         /* v8 ignore next */
-        if (pks.length > 1) { // owner has composite pk
+        if (pks.length > 1) {
+            // owner has composite pk
             pk = data.map(d => Utils.getPrimaryKeyCond(d, pks));
         }
         else {
@@ -531,17 +696,16 @@ export class AbstractSqlDriver extends DatabaseDriver {
     }
     async nativeUpdate(entityName, where, data, options = {}) {
         options.convertCustomTypes ??= true;
-        const meta = this.metadata.find(entityName);
-        const pks = this.getPrimaryKeyFields(entityName);
-        const collections = this.extractManyToMany(entityName, data);
+        const meta = this.metadata.get(entityName);
+        const pks = this.getPrimaryKeyFields(meta);
+        const collections = this.extractManyToMany(meta, data);
         let res = { affectedRows: 0, insertId: 0, row: {} };
         if (Utils.isPrimaryKey(where) && pks.length === 1) {
             /* v8 ignore next */
-            where = { [meta?.primaryKeys[0] ?? pks[0]]: where };
+            where = { [meta.primaryKeys[0] ?? pks[0]]: where };
         }
         if (Utils.hasObjectKeys(data)) {
-            const qb = this.createQueryBuilder(entityName, options.ctx, 'write', options.convertCustomTypes, options.loggerContext)
-                .withSchema(this.getSchemaName(meta, options));
+            const qb = this.createQueryBuilder(entityName, options.ctx, 'write', options.convertCustomTypes, options.loggerContext).withSchema(this.getSchemaName(meta, options));
             if (options.upsert) {
                 /* v8 ignore next */
                 const uniqueFields = options.onConflictFields ?? (Utils.isPlainObject(where) ? Utils.keys(where) : meta.primaryKeys);
@@ -556,14 +720,15 @@ export class AbstractSqlDriver extends DatabaseDriver {
                 if (options.onConflictAction === 'ignore') {
                     qb.ignore();
                 }
+                if (options.onConflictWhere) {
+                    qb.where(options.onConflictWhere);
+                }
             }
             else {
                 qb.update(data).where(where);
                 // reload generated columns and version fields
                 const returning = [];
-                meta?.props
-                    .filter(prop => (prop.generated && !prop.primary) || prop.version)
-                    .forEach(prop => returning.push(prop.name));
+                meta.props.filter(prop => (prop.generated && !prop.primary) || prop.version).forEach(prop => returning.push(prop.name));
                 qb.returning(returning);
             }
             res = await this.rethrow(qb.execute('run', false));
@@ -578,7 +743,8 @@ export class AbstractSqlDriver extends DatabaseDriver {
         options.convertCustomTypes ??= true;
         const meta = this.metadata.get(entityName);
         if (options.upsert) {
-            const uniqueFields = options.onConflictFields ?? (Utils.isPlainObject(where[0]) ? Object.keys(where[0]).flatMap(key => Utils.splitPrimaryKeys(key)) : meta.primaryKeys);
+            const uniqueFields = options.onConflictFields ??
+                (Utils.isPlainObject(where[0]) ? 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));
             const returning = getOnConflictReturningFields(meta, data[0], uniqueFields, options);
             qb.insert(data)
@@ -591,9 +757,12 @@ export class AbstractSqlDriver extends DatabaseDriver {
             if (options.onConflictAction === 'ignore') {
                 qb.ignore();
             }
+            if (options.onConflictWhere) {
+                qb.where(options.onConflictWhere);
+            }
             return this.rethrow(qb.execute('run', false));
         }
-        const collections = options.processCollections ? data.map(d => this.extractManyToMany(entityName, d)) : [];
+        const collections = options.processCollections ? data.map(d => this.extractManyToMany(meta, d)) : [];
         const keys = new Set();
         const fields = new Set();
         const returning = new Set();
@@ -606,10 +775,10 @@ export class AbstractSqlDriver extends DatabaseDriver {
             }
         }
         // reload generated columns and version fields
-        meta?.props
-            .filter(prop => prop.generated || prop.version || prop.primary)
-            .forEach(prop => returning.add(prop.name));
-        const pkCond = Utils.flatten(meta.primaryKeys.map(pk => meta.properties[pk].fieldNames)).map(pk => `${this.platform.quoteIdentifier(pk)} = ?`).join(' and ');
+        meta.props.filter(prop => prop.generated || prop.version || prop.primary).forEach(prop => returning.add(prop.name));
+        const pkCond = Utils.flatten(meta.primaryKeys.map(pk => meta.properties[pk].fieldNames))
+            .map(pk => `${this.platform.quoteIdentifier(pk)} = ?`)
+            .join(' and ');
         const params = [];
         let sql = `update ${this.getTableName(meta, options)} set `;
         const addParams = (prop, value) => {
@@ -628,6 +797,14 @@ export class AbstractSqlDriver extends DatabaseDriver {
         };
         for (const key of keys) {
             const prop = meta.properties[key] ?? meta.root.properties[key];
+            if (prop.polymorphic && prop.fieldNames.length > 1) {
+                for (let idx = 0; idx < data.length; idx++) {
+                    const rowValue = data[idx][key];
+                    if (rowValue instanceof PolymorphicRef) {
+                        data[idx][key] = rowValue.toTuple();
+                    }
+                }
+            }
             prop.fieldNames.forEach((fieldName, fieldNameIdx) => {
                 if (fields.has(fieldName) || (prop.ownColumns && !prop.ownColumns.includes(fieldName))) {
                     return;
@@ -699,12 +876,14 @@ export class AbstractSqlDriver extends DatabaseDriver {
         return res;
     }
     async nativeDelete(entityName, where, options = {}) {
-        const meta = this.metadata.find(entityName);
-        const pks = this.getPrimaryKeyFields(entityName);
+        const meta = this.metadata.get(entityName);
+        const pks = this.getPrimaryKeyFields(meta);
         if (Utils.isPrimaryKey(where) && pks.length === 1) {
             where = { [pks[0]]: where };
         }
-        const qb = this.createQueryBuilder(entityName, options.ctx, 'write', false, options.loggerContext).delete(where).withSchema(this.getSchemaName(meta, options));
+        const qb = this.createQueryBuilder(entityName, options.ctx, 'write', false, options.loggerContext)
+            .delete(where)
+            .withSchema(this.getSchemaName(meta, options));
         return this.rethrow(qb.execute('run', false));
     }
     /**
@@ -753,45 +932,42 @@ export class AbstractSqlDriver extends DatabaseDriver {
             }
             if (coll.property.kind === ReferenceKind.ONE_TO_MANY) {
                 const cols = coll.property.referencedColumnNames;
-                const qb = this.createQueryBuilder(coll.property.type, options?.ctx, 'write')
-                    .withSchema(this.getSchemaName(meta, options));
+                const qb = this.createQueryBuilder(coll.property.targetMeta.class, options?.ctx, 'write').withSchema(this.getSchemaName(meta, options));
                 if (coll.getSnapshot() === undefined) {
                     if (coll.property.orphanRemoval) {
-                        const query = qb.delete({ [coll.property.mappedBy]: pks })
-                            .andWhere({ [cols.join(Utils.PK_SEPARATOR)]: { $nin: insertDiff } });
+                        const query = qb.delete({ [coll.property.mappedBy]: pks }).andWhere({ [cols.join(Utils.PK_SEPARATOR)]: { $nin: insertDiff } });
                         await this.rethrow(query.execute());
                         continue;
                     }
-                    const query = qb.update({ [coll.property.mappedBy]: null })
+                    const query = qb
+                        .update({ [coll.property.mappedBy]: null })
                         .where({ [coll.property.mappedBy]: pks })
                         .andWhere({ [cols.join(Utils.PK_SEPARATOR)]: { $nin: insertDiff } });
                     await this.rethrow(query.execute());
                     continue;
                 }
                 /* v8 ignore next */
-                const query = qb.update({ [coll.property.mappedBy]: pks })
-                    .where({ [cols.join(Utils.PK_SEPARATOR)]: { $in: insertDiff } });
+                const query = qb.update({ [coll.property.mappedBy]: pks }).where({ [cols.join(Utils.PK_SEPARATOR)]: { $in: insertDiff } });
                 await this.rethrow(query.execute());
                 continue;
             }
-            /* v8 ignore next */
             const pivotMeta = this.metadata.find(coll.property.pivotEntity);
             let schema = pivotMeta.schema;
             if (schema === '*') {
                 if (coll.property.owner) {
-                    schema = wrapped.getSchema() === '*' ? options?.schema ?? this.config.get('schema') : wrapped.getSchema();
+                    schema = wrapped.getSchema() === '*' ? (options?.schema ?? this.config.get('schema')) : wrapped.getSchema();
                 }
                 else {
                     const targetMeta = coll.property.targetMeta;
                     const targetSchema = (coll[0] ?? snap?.[0]) && helper(coll[0] ?? snap?.[0]).getSchema();
-                    schema = targetMeta.schema === '*' ? options?.schema ?? targetSchema ?? this.config.get('schema') : targetMeta.schema;
+                    schema = targetMeta.schema === '*' ? (options?.schema ?? targetSchema ?? this.config.get('schema')) : targetMeta.schema;
                 }
             }
             else if (schema == null) {
                 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));
             persister.enqueueUpdate(coll.property, insertDiff, deleteDiff, pks, coll.isInitialized());
         }
         for (const persister of Utils.values(groups)) {
@@ -799,13 +975,17 @@ export class AbstractSqlDriver extends DatabaseDriver {
         }
     }
     async loadFromPivotTable(prop, owners, where = {}, orderBy, ctx, options, pivotJoin) {
+        /* v8 ignore next */
         if (owners.length === 0) {
             return {};
         }
-        const pivotMeta = this.metadata.find(prop.pivotEntity);
+        const pivotMeta = this.metadata.get(prop.pivotEntity);
+        if (prop.polymorphic && prop.discriminatorColumn && prop.discriminatorValue) {
+            return this.loadFromPolymorphicPivotTable(prop, owners, where, orderBy, ctx, options, pivotJoin);
+        }
         const pivotProp1 = pivotMeta.relations[prop.owner ? 1 : 0];
         const pivotProp2 = pivotMeta.relations[prop.owner ? 0 : 1];
-        const ownerMeta = this.metadata.find(pivotProp2.type);
+        const ownerMeta = pivotProp2.targetMeta;
         const cond = {
             [pivotProp2.name]: { $in: ownerMeta.compositePK ? owners : owners.map(o => o[0]) },
         };
@@ -817,34 +997,143 @@ export class AbstractSqlDriver extends DatabaseDriver {
         const populate = this.autoJoinOneToOneOwner(prop.targetMeta, options?.populate ?? [], options?.fields);
         const childFields = !Utils.isEmpty(options?.fields) ? options.fields.map(f => `${pivotProp1.name}.${f}`) : [];
         const childExclude = !Utils.isEmpty(options?.exclude) ? options.exclude.map(f => `${pivotProp1.name}.${f}`) : [];
-        const fields = pivotJoin
-            ? [pivotProp1.name, pivotProp2.name]
-            : [pivotProp1.name, pivotProp2.name, ...childFields];
-        const res = await this.find(pivotMeta.className, where, {
+        const fields = pivotJoin ? [pivotProp1.name, pivotProp2.name] : [pivotProp1.name, pivotProp2.name, ...childFields];
+        const res = await this.find(pivotMeta.class, where, {
             ctx,
             ...options,
             fields,
             exclude: childExclude,
             orderBy: this.getPivotOrderBy(prop, pivotProp1, orderBy, options?.orderBy),
+            populate: [
+                {
+                    field: populateField,
+                    strategy: LoadStrategy.JOINED,
+                    joinType: JoinType.innerJoin,
+                    children: populate,
+                    dataOnly: pivotProp1.mapToPk && !pivotJoin,
+                },
+            ],
+            populateWhere: undefined,
+            // @ts-ignore
+            _populateWhere: 'infer',
+            populateFilter: this.wrapPopulateFilter(options, pivotProp2.name),
+        });
+        return this.buildPivotResultMap(owners, res, pivotProp2.name, pivotProp1.name);
+    }
+    /**
+     * Load from a polymorphic M:N pivot table.
+     */
+    async loadFromPolymorphicPivotTable(prop, owners, where = {}, orderBy, ctx, options, pivotJoin) {
+        const pivotMeta = this.metadata.get(prop.pivotEntity);
+        // Find the M:1 relation on the pivot pointing to the target entity.
+        // We exclude virtual polymorphic owner relations (persist: false) and non-M:1 relations.
+        const inverseProp = pivotMeta.relations.find(r => r.kind === ReferenceKind.MANY_TO_ONE && r.persist !== false && r.targetMeta === prop.targetMeta);
+        if (inverseProp) {
+            return this.loadPolymorphicPivotOwnerSide(prop, owners, where, orderBy, ctx, options, pivotJoin, inverseProp);
+        }
+        return this.loadPolymorphicPivotInverseSide(prop, owners, where, orderBy, ctx, options);
+    }
+    /**
+     * Load from owner side of polymorphic M:N (e.g., Post -> Tags)
+     */
+    async loadPolymorphicPivotOwnerSide(prop, owners, where, orderBy, ctx, options, pivotJoin, inverseProp) {
+        const pivotMeta = this.metadata.get(prop.pivotEntity);
+        const targetMeta = prop.targetMeta;
+        // Build condition: discriminator = 'post' AND {discriminator} IN (...)
+        const cond = {
+            [prop.discriminatorColumn]: prop.discriminatorValue,
+            [prop.discriminator]: { $in: owners.length === 1 && owners[0].length === 1 ? owners.map(o => o[0]) : owners },
+        };
+        if (!Utils.isEmpty(where)) {
+            cond[inverseProp.name] = { ...where };
+        }
+        const populateField = pivotJoin ? `${inverseProp.name}:ref` : inverseProp.name;
+        const populate = this.autoJoinOneToOneOwner(targetMeta, options?.populate ?? [], options?.fields);
+        const childFields = !Utils.isEmpty(options?.fields) ? options.fields.map(f => `${inverseProp.name}.${f}`) : [];
+        const childExclude = !Utils.isEmpty(options?.exclude) ? options.exclude.map(f => `${inverseProp.name}.${f}`) : [];
+        const fields = pivotJoin
+            ? [inverseProp.name, prop.discriminator, prop.discriminatorColumn]
+            : [inverseProp.name, prop.discriminator, prop.discriminatorColumn, ...childFields];
+        const res = await this.find(pivotMeta.class, cond, {
+            ctx,
+            ...options,
+            fields,
+            exclude: childExclude,
+            orderBy: this.getPivotOrderBy(prop, inverseProp, orderBy, options?.orderBy),
+            populate: [{ field: populateField, strategy: LoadStrategy.JOINED, joinType: JoinType.innerJoin, children: populate, dataOnly: inverseProp.mapToPk && !pivotJoin }],
+            populateWhere: undefined,
+            // @ts-ignore
+            _populateWhere: 'infer',
+            populateFilter: this.wrapPopulateFilter(options, inverseProp.name),
+        });
+        return this.buildPivotResultMap(owners, res, prop.discriminator, inverseProp.name);
+    }
+    /**
+     * Load from inverse side of polymorphic M:N (e.g., Tag -> Posts)
+     * Uses single query with join via virtual relation on pivot.
+     */
+    async loadPolymorphicPivotInverseSide(prop, owners, where, orderBy, ctx, options) {
+        const pivotMeta = this.metadata.get(prop.pivotEntity);
+        const targetMeta = prop.targetMeta;
+        // Find the relation to the entity we're starting from (e.g., Tag_inverse -> Tag)
+        // Exclude virtual polymorphic owner relations (persist: false) - we want the actual M:N inverse relation
+        const tagProp = pivotMeta.relations.find(r => r.persist !== false && r.targetMeta !== targetMeta);
+        // Find the virtual relation to the polymorphic owner (e.g., taggable_Post -> Post)
+        const ownerRelationName = `${prop.discriminator}_${targetMeta.tableName}`;
+        const ownerProp = pivotMeta.properties[ownerRelationName];
+        // Build condition: discriminator = 'post' AND Tag_inverse IN (tagIds)
+        const cond = {
+            [prop.discriminatorColumn]: prop.discriminatorValue,
+            [tagProp.name]: { $in: owners.length === 1 && owners[0].length === 1 ? owners.map(o => o[0]) : owners },
+        };
+        if (!Utils.isEmpty(where)) {
+            cond[ownerRelationName] = { ...where };
+        }
+        const populateField = ownerRelationName;
+        const populate = this.autoJoinOneToOneOwner(targetMeta, options?.populate ?? [], options?.fields);
+        const childFields = !Utils.isEmpty(options?.fields) ? options.fields.map(f => `${ownerRelationName}.${f}`) : [];
+        const childExclude = !Utils.isEmpty(options?.exclude) ? options.exclude.map(f => `${ownerRelationName}.${f}`) : [];
+        const fields = [ownerRelationName, tagProp.name, prop.discriminatorColumn, ...childFields];
+        const res = await this.find(pivotMeta.class, cond, {
+            ctx,
+            ...options,
+            fields,
+            exclude: childExclude,
+            orderBy: this.getPivotOrderBy(prop, ownerProp, orderBy, options?.orderBy),
             populate: [{ field: populateField, strategy: LoadStrategy.JOINED, joinType: JoinType.innerJoin, children: populate }],
             populateWhere: undefined,
             // @ts-ignore
             _populateWhere: 'infer',
-            populateFilter: !Utils.isEmpty(options?.populateFilter) ? { [pivotProp2.name]: options?.populateFilter } : undefined,
+            populateFilter: this.wrapPopulateFilter(options, ownerRelationName),
         });
+        return this.buildPivotResultMap(owners, res, tagProp.name, ownerRelationName);
+    }
+    /**
+     * Build a map from owner PKs to their related entities from pivot table results.
+     */
+    buildPivotResultMap(owners, results, keyProp, valueProp) {
         const map = {};
         for (const owner of owners) {
             const key = Utils.getPrimaryKeyHash(owner);
             map[key] = [];
         }
-        for (const item of res) {
-            const key = Utils.getPrimaryKeyHash(Utils.asArray(item[pivotProp2.name]));
-            map[key].push(item[pivotProp1.name]);
+        for (const item of results) {
+            const key = Utils.getPrimaryKeyHash(Utils.asArray(item[keyProp]));
+            const entity = item[valueProp];
+            if (map[key]) {
+                map[key].push(entity);
+            }
         }
         return map;
     }
+    wrapPopulateFilter(options, propName) {
+        if (!Utils.isEmpty(options?.populateFilter) || RawQueryFragment.hasObjectFragments(options?.populateFilter)) {
+            return { [propName]: options?.populateFilter };
+        }
+        return undefined;
+    }
     getPivotOrderBy(prop, pivotProp, orderBy, parentOrderBy) {
-        if (!Utils.isEmpty(orderBy)) {
+        if (!Utils.isEmpty(orderBy) || RawQueryFragment.hasObjectFragments(orderBy)) {
             return Utils.asArray(orderBy).map(o => ({ [pivotProp.name]: o }));
         }
         if (prop.kind === ReferenceKind.MANY_TO_MANY && Utils.asArray(parentOrderBy).some(o => o[prop.name])) {
@@ -852,7 +1141,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
                 .filter(o => o[prop.name])
                 .map(o => ({ [pivotProp.name]: o[prop.name] }));
         }
-        if (!Utils.isEmpty(prop.orderBy)) {
+        if (!Utils.isEmpty(prop.orderBy) || RawQueryFragment.hasObjectFragments(prop.orderBy)) {
             return Utils.asArray(prop.orderBy).map(o => ({ [pivotProp.name]: o }));
         }
         if (prop.fixedOrder) {
@@ -865,8 +1154,8 @@ export class AbstractSqlDriver extends DatabaseDriver {
     }
     async *stream(entityName, where, options) {
         options = { populate: [], orderBy: [], ...options };
-        const meta = this.metadata.find(entityName);
-        if (meta?.virtual) {
+        const meta = this.metadata.get(entityName);
+        if (meta.virtual) {
             yield* this.streamFromVirtual(entityName, where, options);
             return;
         }
@@ -989,21 +1278,46 @@ export class AbstractSqlDriver extends DatabaseDriver {
         const populate = options.populate ?? [];
         const joinedProps = this.joinedProps(meta, populate, options);
         const populateWhereAll = options?._populateWhere === 'all' || Utils.isEmpty(options?._populateWhere);
+        // Ensure TPT joins are applied early so that _tptAlias is available for join resolution
+        // This is needed when populating relations that are inherited from TPT parent entities
+        if (!options.parentJoinPath) {
+            qb.ensureTPTJoins();
+        }
         // root entity is already handled, skip that
         if (options.parentJoinPath) {
             // alias all fields in the primary table
             meta.props
                 .filter(prop => this.shouldHaveColumn(meta, prop, populate, options.explicitFields, options.exclude))
-                .forEach(prop => fields.push(...this.mapPropToFieldNames(qb, prop, options.parentTableAlias, options.explicitFields)));
+                .forEach(prop => fields.push(...this.mapPropToFieldNames(qb, prop, options.parentTableAlias, meta, options.schema, options.explicitFields)));
         }
         for (const hint of joinedProps) {
             const [propName, ref] = hint.field.split(':', 2);
             const prop = meta.properties[propName];
+            // Polymorphic to-one: create a LEFT JOIN per target type
+            // Skip :ref hints — polymorphic to-one already has FK + discriminator in the row
+            if (prop.polymorphic && prop.polymorphTargets?.length && !ref && [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
+                const basePath = options.parentJoinPath ? `${options.parentJoinPath}.${prop.name}` : `${meta.name}.${prop.name}`;
+                const pathPrefix = !options.parentJoinPath && populateWhereAll && !basePath.startsWith('[populate]') ? '[populate]' : '';
+                for (const targetMeta of prop.polymorphTargets) {
+                    const tableAlias = qb.getNextAlias(targetMeta.className);
+                    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);
+                    // Select fields from each target table
+                    fields.push(...this.getFieldsForJoinedLoad(qb, targetMeta, {
+                        ...options,
+                        populate: hint.children,
+                        parentTableAlias: tableAlias,
+                        parentJoinPath: targetPath,
+                    }));
+                }
+                continue;
+            }
             // ignore ref joins of known FKs unless it's a filter hint
             if (ref && !hint.filter && (prop.kind === ReferenceKind.MANY_TO_ONE || (prop.kind === ReferenceKind.ONE_TO_ONE && prop.owner))) {
                 continue;
             }
-            const meta2 = this.metadata.find(prop.type);
+            const meta2 = prop.targetMeta;
             const pivotRefJoin = prop.kind === ReferenceKind.MANY_TO_MANY && ref;
             const tableAlias = qb.getNextAlias(prop.name);
             const field = `${options.parentTableAlias}.${prop.name}`;
@@ -1019,7 +1333,14 @@ export class AbstractSqlDriver extends DatabaseDriver {
                     : (hint.filter && !prop.nullable) || mandatoryToOneProperty
                         ? JoinType.innerJoin
                         : JoinType.leftJoin;
-            qb.join(field, tableAlias, {}, joinType, path);
+            const schema = prop.targetMeta.schema === '*' ? (options?.schema ?? this.config.get('schema')) : prop.targetMeta.schema;
+            qb.join(field, tableAlias, {}, joinType, path, schema);
+            // For relations to TPT base classes, add LEFT JOINs for all child tables (polymorphic loading)
+            if (meta2.inheritanceType === 'tpt' && meta2.tptChildren?.length && !ref) {
+                // Use the registry metadata to ensure allTPTDescendants is available
+                const tptMeta = this.metadata.get(meta2.class);
+                this.addTPTPolymorphicJoinsForRelation(qb, tptMeta, tableAlias, fields);
+            }
             if (pivotRefJoin) {
                 fields.push(...prop.joinColumns.map(col => qb.helper.mapper(`${tableAlias}.${col}`, qb.type, undefined, `${tableAlias}__${col}`)), ...prop.inverseJoinColumns.map(col => qb.helper.mapper(`${tableAlias}.${col}`, qb.type, undefined, `${tableAlias}__${col}`)));
             }
@@ -1040,7 +1361,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
                 }
             });
             const childExclude = options.exclude ? Utils.extractChildElements(options.exclude, prop.name) : options.exclude;
-            if (!ref && !prop.mapToPk) {
+            if (!ref && (!prop.mapToPk || hint.dataOnly)) {
                 fields.push(...this.getFieldsForJoinedLoad(qb, meta2, {
                     ...options,
                     explicitFields: childExplicitFields.length === 0 ? undefined : childExplicitFields,
@@ -1050,23 +1371,127 @@ export class AbstractSqlDriver extends DatabaseDriver {
                     parentJoinPath: path,
                 }));
             }
-            else if (hint.filter || prop.mapToPk || (ref && [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind))) {
+            else if (hint.filter || (prop.mapToPk && !hint.dataOnly) || (ref && [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind))) {
                 fields.push(...prop.referencedColumnNames.map(col => qb.helper.mapper(`${tableAlias}.${col}`, qb.type, undefined, `${tableAlias}__${col}`)));
             }
         }
         return fields;
     }
     /**
+     * Adds LEFT JOINs and fields for TPT polymorphic loading when populating a relation to a TPT base class.
      * @internal
      */
-    mapPropToFieldNames(qb, prop, tableAlias, explicitFields) {
+    addTPTPolymorphicJoinsForRelation(qb, meta, baseAlias, fields) {
+        // allTPTDescendants is pre-computed during discovery, sorted by depth (deepest first)
+        const descendants = meta.allTPTDescendants;
+        const childAliases = {};
+        // LEFT JOIN each descendant table
+        for (const childMeta of descendants) {
+            const childAlias = qb.getNextAlias(childMeta.className);
+            qb.createAlias(childMeta.class, childAlias);
+            childAliases[childMeta.className] = childAlias;
+            qb.addPropertyJoin(childMeta.tptInverseProp, baseAlias, childAlias, JoinType.leftJoin, `[tpt]${meta.className}`);
+            // Add fields from this child (only ownProps, skip PKs)
+            for (const prop of childMeta.ownProps.filter(p => !p.primary && this.platform.shouldHaveColumn(p, []))) {
+                for (const fieldName of prop.fieldNames) {
+                    const field = `${childAlias}.${fieldName}`;
+                    const fieldAlias = `${childAlias}__${fieldName}`;
+                    fields.push(raw(`${this.platform.quoteIdentifier(field)} as ${this.platform.quoteIdentifier(fieldAlias)}`));
+                }
+            }
+        }
+        // Add computed discriminator (descendants already sorted by depth)
+        if (meta.root.tptDiscriminatorColumn) {
+            fields.push(this.buildTPTDiscriminatorExpression(meta, descendants, childAliases, baseAlias));
+        }
+    }
+    /**
+     * Find the alias for a TPT child table in the query builder.
+     * @internal
+     */
+    findTPTChildAlias(qb, childMeta) {
+        const joins = qb._joins;
+        for (const key of Object.keys(joins)) {
+            if (joins[key].table === childMeta.tableName && key.includes('[tpt]')) {
+                return joins[key].alias;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Builds a CASE WHEN expression for TPT discriminator.
+     * Determines concrete entity type based on which child table has a non-null PK.
+     * @internal
+     */
+    buildTPTDiscriminatorExpression(meta, descendants, aliasMap, baseAlias) {
+        const cases = descendants.map(child => {
+            const childAlias = aliasMap[child.className];
+            const pkFieldName = child.properties[child.primaryKeys[0]].fieldNames[0];
+            return `when ${this.platform.quoteIdentifier(`${childAlias}.${pkFieldName}`)} is not null then '${child.discriminatorValue}'`;
+        });
+        const defaultValue = meta.abstract ? 'null' : `'${meta.discriminatorValue}'`;
+        const caseExpr = `case ${cases.join(' ')} else ${defaultValue} end`;
+        const aliased = this.platform.quoteIdentifier(`${baseAlias}__${meta.root.tptDiscriminatorColumn}`);
+        return raw(`${caseExpr} as ${aliased}`);
+    }
+    /**
+     * Maps TPT child-specific fields during hydration.
+     * When a relation points to a TPT base class, the actual entity might be a child class.
+     * This method reads the discriminator to determine the concrete type and maps child-specific fields.
+     * @internal
+     */
+    mapTPTChildFields(relationPojo, meta, relationAlias, qb, root) {
+        // Check if this is a TPT base with polymorphic children
+        if (meta.inheritanceType !== 'tpt' || !meta.root.tptDiscriminatorColumn) {
+            return;
+        }
+        // Read the discriminator value
+        const discriminatorAlias = `${relationAlias}__${meta.root.tptDiscriminatorColumn}`;
+        const discriminatorValue = root[discriminatorAlias];
+        if (!discriminatorValue) {
+            return;
+        }
+        // Set the discriminator in the pojo for EntityFactory
+        relationPojo[meta.root.tptDiscriminatorColumn] = discriminatorValue;
+        // Find the concrete metadata from discriminator map
+        const concreteClass = meta.root.discriminatorMap?.[discriminatorValue];
+        /* v8 ignore next 3 - defensive check for invalid discriminator values */
+        if (!concreteClass) {
+            return;
+        }
+        const concreteMeta = this.metadata.get(concreteClass);
+        if (concreteMeta === meta) {
+            // Already the concrete type, no child fields to map
+            delete root[discriminatorAlias];
+            return;
+        }
+        // Traverse up from concrete type and map fields from each level's table
+        const tz = this.platform.getTimezone();
+        let currentMeta = concreteMeta;
+        while (currentMeta && currentMeta !== meta) {
+            const childAlias = this.findTPTChildAlias(qb, currentMeta);
+            if (childAlias) {
+                // Map fields using same filtering as joined loading, plus skip PKs
+                for (const prop of currentMeta.ownProps.filter(p => !p.primary && this.platform.shouldHaveColumn(p, []))) {
+                    this.mapJoinedProp(relationPojo, prop, childAlias, root, tz, currentMeta, { deleteFromRoot: true });
+                }
+            }
+            currentMeta = currentMeta.tptParent;
+        }
+        // Clean up the discriminator alias
+        delete root[discriminatorAlias];
+    }
+    /**
+     * @internal
+     */
+    mapPropToFieldNames(qb, prop, tableAlias, meta, schema, explicitFields) {
         if (prop.kind === ReferenceKind.EMBEDDED && !prop.object) {
             return Object.entries(prop.embeddedProps).flatMap(([name, childProp]) => {
                 const childFields = explicitFields ? Utils.extractChildElements(explicitFields, prop.name) : [];
                 if (!this.shouldHaveColumn(prop.targetMeta, { ...childProp, name }, [], childFields.length > 0 ? childFields : undefined)) {
                     return [];
                 }
-                return this.mapPropToFieldNames(qb, childProp, tableAlias, childFields);
+                return this.mapPropToFieldNames(qb, childProp, tableAlias, meta, schema, childFields);
             });
         }
         const aliased = this.platform.quoteIdentifier(`${tableAlias}__${prop.fieldNames[0]}`);
@@ -1085,11 +1510,13 @@ export class AbstractSqlDriver extends DatabaseDriver {
             return [raw(`${prop.customType.convertToJSValueSQL(prefixed, this.platform)} as ${aliased}`)];
         }
         if (prop.formula) {
-            const alias = this.platform.quoteIdentifier(tableAlias);
-            return [raw(`${prop.formula(alias)} as ${aliased}`)];
+            const quotedAlias = this.platform.quoteIdentifier(tableAlias).toString();
+            const table = this.createFormulaTable(quotedAlias, meta, schema);
+            const columns = meta.createColumnMappingObject(tableAlias);
+            return [raw(`${this.evaluateFormula(prop.formula, columns, table)} as ${aliased}`)];
         }
         return prop.fieldNames.map(fieldName => {
-            return `${tableAlias}.${fieldName} as ${tableAlias}__${fieldName}`;
+            return raw('?? as ??', [`${tableAlias}.${fieldName}`, `${tableAlias}__${fieldName}`]);
         });
     }
     /** @internal */
@@ -1114,26 +1541,20 @@ export class AbstractSqlDriver extends DatabaseDriver {
         }
         return 'write';
     }
-    extractManyToMany(entityName, data) {
-        if (!this.metadata.has(entityName)) {
-            return {};
-        }
+    extractManyToMany(meta, data) {
         const ret = {};
-        this.metadata.find(entityName).relations.forEach(prop => {
+        for (const prop of meta.relations) {
             if (prop.kind === ReferenceKind.MANY_TO_MANY && data[prop.name]) {
                 ret[prop.name] = data[prop.name].map((item) => Utils.asArray(item));
                 delete data[prop.name];
             }
-        });
+        }
         return ret;
     }
     async processManyToMany(meta, pks, collections, clear, options) {
-        if (!meta) {
-            return;
-        }
         for (const prop of meta.relations) {
             if (collections[prop.name]) {
-                const pivotMeta = this.metadata.find(prop.pivotEntity);
+                const pivotMeta = this.metadata.get(prop.pivotEntity);
                 const persister = new PivotCollectionPersister(pivotMeta, this, options?.ctx, options?.schema, options?.loggerContext);
                 persister.enqueueUpdate(prop, collections[prop.name], clear, pks);
                 await this.rethrow(persister.execute());
@@ -1142,9 +1563,11 @@ export class AbstractSqlDriver extends DatabaseDriver {
     }
     async lockPessimistic(entity, options) {
         const meta = helper(entity).__meta;
-        const qb = this.createQueryBuilder(entity.constructor.name, options.ctx, undefined, undefined, options.logging).withSchema(options.schema ?? meta.schema);
+        const qb = this.createQueryBuilder(meta.class, options.ctx, undefined, undefined, options.logging).withSchema(options.schema ?? meta.schema);
         const cond = Utils.getPrimaryKeyCond(entity, meta.primaryKeys);
-        qb.select(raw('1')).where(cond).setLockMode(options.lockMode, options.lockTableAliases);
+        qb.select(raw('1'))
+            .where(cond)
+            .setLockMode(options.lockMode, options.lockTableAliases);
         await this.rethrow(qb.execute());
     }
     buildPopulateWhere(meta, joinedProps, options) {
@@ -1152,21 +1575,24 @@ export class AbstractSqlDriver extends DatabaseDriver {
         for (const hint of joinedProps) {
             const [propName] = hint.field.split(':', 2);
             const prop = meta.properties[propName];
-            if (!Utils.isEmpty(prop.where)) {
+            if (!Utils.isEmpty(prop.where) || RawQueryFragment.hasObjectFragments(prop.where)) {
                 where[prop.name] = Utils.copy(prop.where);
             }
             if (hint.children) {
-                const inner = this.buildPopulateWhere(prop.targetMeta, hint.children, {});
-                if (!Utils.isEmpty(inner)) {
-                    where[prop.name] ??= {};
-                    Object.assign(where[prop.name], inner);
+                const targetMeta = prop.targetMeta;
+                if (targetMeta) {
+                    const inner = this.buildPopulateWhere(targetMeta, hint.children, {});
+                    if (!Utils.isEmpty(inner) || RawQueryFragment.hasObjectFragments(inner)) {
+                        where[prop.name] ??= {};
+                        Object.assign(where[prop.name], inner);
+                    }
                 }
             }
         }
-        if (Utils.isEmpty(options.populateWhere)) {
+        if (Utils.isEmpty(options.populateWhere) && !RawQueryFragment.hasObjectFragments(options.populateWhere)) {
             return where;
         }
-        if (Utils.isEmpty(where)) {
+        if (Utils.isEmpty(where) && !RawQueryFragment.hasObjectFragments(where)) {
             return options.populateWhere;
         }
         /* v8 ignore next */
@@ -1178,31 +1604,32 @@ export class AbstractSqlDriver extends DatabaseDriver {
         // as `options.populateWhere` will be always recomputed to respect filters
         const populateWhereAll = options._populateWhere !== 'infer' && !Utils.isEmpty(options._populateWhere);
         const path = (populateWhereAll ? '[populate]' : '') + meta.className;
+        const optionsOrderBy = Utils.asArray(options.orderBy);
         const populateOrderBy = this.buildPopulateOrderBy(qb, meta, Utils.asArray(options.populateOrderBy ?? options.orderBy), path, !!options.populateOrderBy);
         const joinedPropsOrderBy = this.buildJoinedPropsOrderBy(qb, meta, joinedProps, options, path);
-        return [...Utils.asArray(options.orderBy), ...populateOrderBy, ...joinedPropsOrderBy];
+        return [...optionsOrderBy, ...populateOrderBy, ...joinedPropsOrderBy];
     }
     buildPopulateOrderBy(qb, meta, populateOrderBy, parentPath, explicit, parentAlias = qb.alias) {
         const orderBy = [];
         for (let i = 0; i < populateOrderBy.length; i++) {
             const orderHint = populateOrderBy[i];
-            for (const propName of Utils.keys(orderHint)) {
-                const raw = RawQueryFragment.getKnownFragment(propName, explicit);
-                if (raw) {
-                    const sql = raw.sql.replace(new RegExp(ALIAS_REPLACEMENT_RE, 'g'), parentAlias);
-                    const raw2 = new RawQueryFragment(sql, raw.params);
-                    orderBy.push({ [raw2]: orderHint[propName] });
+            for (const field of Utils.getObjectQueryKeys(orderHint)) {
+                const childOrder = orderHint[field];
+                if (RawQueryFragment.isKnownFragmentSymbol(field)) {
+                    const { sql, params } = RawQueryFragment.getKnownFragment(field);
+                    const key = raw(sql.replace(new RegExp(ALIAS_REPLACEMENT_RE, 'g'), parentAlias), params);
+                    orderBy.push({ [key]: childOrder });
                     continue;
                 }
-                const prop = meta.properties[propName];
+                const prop = meta.properties[field];
                 if (!prop) {
-                    throw new Error(`Trying to order by not existing property ${meta.className}.${propName}`);
+                    throw new Error(`Trying to order by not existing property ${meta.className}.${field}`);
                 }
                 let path = parentPath;
-                const meta2 = this.metadata.find(prop.type);
-                const childOrder = orderHint[prop.name];
-                if (prop.kind !== ReferenceKind.SCALAR && (![ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) || !prop.owner || Utils.isPlainObject(childOrder))) {
-                    path += `.${propName}`;
+                const meta2 = prop.targetMeta;
+                if (prop.kind !== ReferenceKind.SCALAR &&
+                    (![ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) || !prop.owner || Utils.isPlainObject(childOrder))) {
+                    path += `.${field}`;
                 }
                 if (prop.kind === ReferenceKind.MANY_TO_MANY && typeof childOrder !== 'object') {
                     path += '[pivot]';
@@ -1228,9 +1655,9 @@ export class AbstractSqlDriver extends DatabaseDriver {
                     }
                     continue;
                 }
-                const order = typeof childOrder === 'object' ? childOrder[propName] : childOrder;
+                const order = typeof childOrder === 'object' ? childOrder[field] : childOrder;
                 if (order) {
-                    orderBy.push({ [`${propAlias}.${propName}`]: order });
+                    orderBy.push({ [`${propAlias}.${field}`]: order });
                 }
             }
         }
@@ -1242,39 +1669,41 @@ export class AbstractSqlDriver extends DatabaseDriver {
         for (const hint of joinedProps) {
             const [propName, ref] = hint.field.split(':', 2);
             const prop = meta.properties[propName];
-            const propOrderBy = prop.orderBy;
             let path = `${parentPath}.${propName}`;
             if (prop.kind === ReferenceKind.MANY_TO_MANY && ref) {
                 path += '[pivot]';
             }
-            const join = qb.getJoinForPath(path, { matchPopulateJoins: true });
-            const propAlias = qb.getAliasForJoinPath(join ?? path, { matchPopulateJoins: true });
-            const meta2 = this.metadata.find(prop.type);
-            if (prop.kind === ReferenceKind.MANY_TO_MANY && prop.fixedOrder && join) {
-                const alias = ref ? propAlias : join.ownerAlias;
-                orderBy.push({ [`${alias}.${prop.fixedOrderColumn}`]: QueryOrder.ASC });
-            }
-            if (propOrderBy) {
-                for (const item of Utils.asArray(propOrderBy)) {
-                    for (const field of Utils.keys(item)) {
-                        const rawField = RawQueryFragment.getKnownFragment(field, false);
-                        if (rawField) {
-                            const sql = propAlias ? rawField.sql.replace(new RegExp(ALIAS_REPLACEMENT_RE, 'g'), propAlias) : rawField.sql;
-                            const raw2 = raw(sql, rawField.params);
-                            orderBy.push({ [raw2.toString()]: item[field] });
-                            continue;
-                        }
-                        orderBy.push({ [`${propAlias}.${field}`]: item[field] });
-                    }
-                }
+            if ([ReferenceKind.MANY_TO_MANY, ReferenceKind.ONE_TO_MANY].includes(prop.kind)) {
+                this.buildToManyOrderBy(qb, prop, path, ref, orderBy);
             }
             if (hint.children) {
-                const buildJoinedPropsOrderBy = this.buildJoinedPropsOrderBy(qb, meta2, hint.children, options, path);
-                orderBy.push(...buildJoinedPropsOrderBy);
+                orderBy.push(...this.buildJoinedPropsOrderBy(qb, prop.targetMeta, hint.children, options, path));
             }
         }
         return orderBy;
     }
+    buildToManyOrderBy(qb, prop, path, ref, orderBy) {
+        const join = qb.getJoinForPath(path, { matchPopulateJoins: true });
+        const propAlias = qb.getAliasForJoinPath(join ?? path, { matchPopulateJoins: true });
+        if (prop.kind === ReferenceKind.MANY_TO_MANY && prop.fixedOrder && join) {
+            const alias = ref ? propAlias : join.ownerAlias;
+            orderBy.push({ [`${alias}.${prop.fixedOrderColumn}`]: QueryOrder.ASC });
+        }
+        const effectiveOrderBy = QueryHelper.mergeOrderBy(prop.orderBy, prop.targetMeta?.orderBy);
+        for (const item of effectiveOrderBy) {
+            for (const field of Utils.getObjectQueryKeys(item)) {
+                const order = item[field];
+                if (RawQueryFragment.isKnownFragmentSymbol(field)) {
+                    const { sql, params } = RawQueryFragment.getKnownFragment(field);
+                    const sql2 = propAlias ? sql.replace(new RegExp(ALIAS_REPLACEMENT_RE, 'g'), propAlias) : sql;
+                    const key = raw(sql2, params);
+                    orderBy.push({ [key]: order });
+                    continue;
+                }
+                orderBy.push({ [`${propAlias}.${field}`]: order });
+            }
+        }
+    }
     normalizeFields(fields, prefix = '') {
         const ret = [];
         for (const field of fields) {
@@ -1313,7 +1742,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
         }
         ret.push(prop.name);
     }
-    buildFields(meta, populate, joinedProps, qb, alias, options) {
+    buildFields(meta, populate, joinedProps, qb, alias, options, schema) {
         const lazyProps = meta.props.filter(prop => prop.lazy && !populate.some(p => this.isPopulated(meta, prop, p)));
         const hasLazyFormulas = meta.props.some(p => p.lazy && p.formula);
         const requiresSQLConversion = meta.props.some(p => p.customType?.convertToJSValueSQL && p.persist !== false);
@@ -1332,7 +1761,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
                 const prop = QueryHelper.findProperty(rootPropName, {
                     metadata: this.metadata,
                     platform: this.platform,
-                    entityName: meta.className,
+                    entityName: meta.class,
                     where: {},
                     aliasMap: qb.getAliasMap(),
                 });
@@ -1341,7 +1770,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
             if (!options.fields.includes('*') && !options.fields.includes(`${qb.alias}.*`)) {
                 ret.unshift(...meta.primaryKeys.filter(pk => !options.fields.includes(pk)));
             }
-            if (meta.root.discriminatorColumn && !options.fields.includes(`${qb.alias}.${meta.root.discriminatorColumn}`)) {
+            if (meta.root.inheritanceType === 'sti' && !options.fields.includes(`${qb.alias}.${meta.root.discriminatorColumn}`)) {
                 ret.push(meta.root.discriminatorColumn);
             }
         }
@@ -1358,14 +1787,18 @@ export class AbstractSqlDriver extends DatabaseDriver {
             ret.push('*');
         }
         if (ret.length > 0 && !hasExplicitFields && addFormulas) {
+            // Create formula column mapping with unquoted aliases - quoting should be handled by the user via `quote` helper
+            const quotedAlias = this.platform.quoteIdentifier(alias);
+            const columns = meta.createColumnMappingObject(alias);
+            const effectiveSchema = schema ?? (meta.schema !== '*' ? meta.schema : undefined);
             for (const prop of meta.props) {
                 if (lazyProps.includes(prop)) {
                     continue;
                 }
                 if (prop.formula) {
-                    const a = this.platform.quoteIdentifier(alias);
                     const aliased = this.platform.quoteIdentifier(prop.fieldNames[0]);
-                    ret.push(raw(`${prop.formula(a)} as ${aliased}`));
+                    const table = this.createFormulaTable(quotedAlias.toString(), meta, effectiveSchema);
+                    ret.push(raw(`${this.evaluateFormula(prop.formula, columns, table)} as ${aliased}`));
                 }
                 if (!prop.object && (prop.hasConvertToDatabaseValueSQL || prop.hasConvertToJSValueSQL)) {
                     ret.push(prop.name);