@mikro-orm/sql 7.0.0-dev.228 → 7.0.0-dev.229

package/query/QueryBuilder.js

@@ -75,9 +75,12 @@ export class QueryBuilder {
     subQueries = {};
     _mainAlias;
     _aliases = {};
+    _tptAlias = {}; // maps entity className to alias for TPT parent tables
     _helper;
     _query;
     platform;
+    tptJoinsApplied = false;
+    autoJoinedPaths = [];
     /**
      * @internal
      */
@@ -337,7 +340,6 @@ export class QueryBuilder {
         const cond = await this.em.applyFilters(this.mainAlias.entityName, {}, filterOptions, 'read');
         this.andWhere(cond);
     }
-    autoJoinedPaths = [];
     /**
      * @internal
      */
@@ -1062,6 +1064,21 @@ export class QueryBuilder {
         /* v8 ignore next */
         return res;
     }
+    /**
+     * Adds a join from a property object. Used internally for TPT joins where the property
+     * is synthetic (not in entity.properties) but defined on metadata (e.g., tptParentProp).
+     * The caller must create the alias first via createAlias().
+     * @internal
+     */
+    addPropertyJoin(prop, ownerAlias, alias, type, path, schema) {
+        schema ??= prop.targetMeta?.schema === '*' ? '*' : this.driver.getSchemaName(prop.targetMeta);
+        const key = `[tpt]${ownerAlias}#${alias}`;
+        this._joins[key] = prop.kind === ReferenceKind.MANY_TO_ONE
+            ? this.helper.joinManyToOneReference(prop, ownerAlias, alias, type, {}, schema)
+            : this.helper.joinOneToReference(prop, ownerAlias, alias, type, {}, schema);
+        this._joins[key].path = path;
+        return key;
+    }
     joinReference(field, alias, cond, type, path, schema, subquery) {
         this.ensureNotFinalized();
         if (typeof field === 'object') {
@@ -1103,6 +1120,11 @@ export class QueryBuilder {
         if (!prop) {
             throw new Error(`Trying to join ${q(field)}, but ${q(fromField)} is not a defined relation on ${meta.className}.`);
         }
+        // For TPT inheritance, owning relations (M:1 and owning 1:1) may have FK columns in a parent table
+        // Resolve the correct alias for the table that owns the FK column
+        const ownerAlias = (prop.kind === ReferenceKind.MANY_TO_ONE || (prop.kind === ReferenceKind.ONE_TO_ONE && prop.owner))
+            ? this.helper.getTPTAliasForProperty(fromField, fromAlias)
+            : fromAlias;
         this.createAlias(prop.targetMeta.class, alias);
         cond = QueryHelper.processWhere({
             where: cond,
@@ -1134,11 +1156,11 @@ export class QueryBuilder {
             aliasedName = Object.keys(joins)[1];
         }
         else if (prop.kind === ReferenceKind.ONE_TO_ONE) {
-            this._joins[aliasedName] = this.helper.joinOneToReference(prop, fromAlias, alias, type, cond, schema);
+            this._joins[aliasedName] = this.helper.joinOneToReference(prop, ownerAlias, alias, type, cond, schema);
             this._joins[aliasedName].path ??= path;
         }
         else { // MANY_TO_ONE
-            this._joins[aliasedName] = this.helper.joinManyToOneReference(prop, fromAlias, alias, type, cond, schema);
+            this._joins[aliasedName] = this.helper.joinManyToOneReference(prop, ownerAlias, alias, type, cond, schema);
             this._joins[aliasedName].path ??= path;
         }
         return { prop, key: aliasedName };
@@ -1360,7 +1382,7 @@ export class QueryBuilder {
     }
     applyDiscriminatorCondition() {
         const meta = this.mainAlias.meta;
-        if (!meta.discriminatorValue) {
+        if (meta.root.inheritanceType !== 'sti' || !meta.discriminatorValue) {
             return;
         }
         const types = Object.values(meta.root.discriminatorMap).map(cls => this.metadata.get(cls));
@@ -1376,6 +1398,94 @@ export class QueryBuilder {
             [meta.root.discriminatorColumn]: children.length > 0 ? { $in: [meta.discriminatorValue, ...children.map(c => c.discriminatorValue)] } : meta.discriminatorValue,
         });
     }
+    /**
+     * Ensures TPT joins are applied. Can be called early before finalize() to populate
+     * the _tptAlias map for use in join resolution. Safe to call multiple times.
+     * @internal
+     */
+    ensureTPTJoins() {
+        this.applyTPTJoins();
+    }
+    /**
+     * For TPT (Table-Per-Type) inheritance: INNER JOINs parent tables.
+     * When querying a child entity, we need to join all parent tables.
+     * Field selection is handled separately in addTPTParentFields().
+     */
+    applyTPTJoins() {
+        const meta = this.mainAlias.meta;
+        if (meta?.inheritanceType !== 'tpt' || !meta.tptParent || ![QueryType.SELECT, QueryType.COUNT].includes(this.type)) {
+            return;
+        }
+        if (this.tptJoinsApplied) {
+            return;
+        }
+        this.tptJoinsApplied = true;
+        let childMeta = meta;
+        let childAlias = this.mainAlias.aliasName;
+        while (childMeta.tptParent) {
+            const parentMeta = childMeta.tptParent;
+            const parentAlias = this.getNextAlias(parentMeta.className);
+            this.createAlias(parentMeta.class, parentAlias);
+            this._tptAlias[parentMeta.className] = parentAlias;
+            this.addPropertyJoin(childMeta.tptParentProp, childAlias, parentAlias, JoinType.innerJoin, `[tpt]${childMeta.className}`);
+            childMeta = parentMeta;
+            childAlias = parentAlias;
+        }
+    }
+    /**
+     * For TPT inheritance: adds field selections from parent tables.
+     */
+    addTPTParentFields() {
+        const meta = this.mainAlias.meta;
+        if (meta?.inheritanceType !== 'tpt' || !meta.tptParent || ![QueryType.SELECT, QueryType.COUNT].includes(this.type)) {
+            return;
+        }
+        if (!this._fields?.includes('*') && !this._fields?.includes(`${this.mainAlias.aliasName}.*`)) {
+            return;
+        }
+        let parentMeta = meta.tptParent;
+        while (parentMeta) {
+            const parentAlias = this._tptAlias[parentMeta.className];
+            if (parentAlias) {
+                const schema = parentMeta.schema === '*' ? '*' : this.driver.getSchemaName(parentMeta);
+                parentMeta.ownProps
+                    .filter(prop => this.platform.shouldHaveColumn(prop, []))
+                    .forEach(prop => this._fields.push(...this.driver.mapPropToFieldNames(this, prop, parentAlias, parentMeta, schema)));
+            }
+            parentMeta = parentMeta.tptParent;
+        }
+    }
+    /**
+     * For TPT polymorphic queries: LEFT JOINs all child tables when querying a TPT base class.
+     * Adds discriminator and child fields to determine and load the concrete type.
+     */
+    applyTPTPolymorphicJoins() {
+        const meta = this.mainAlias.meta;
+        const descendants = meta?.allTPTDescendants;
+        if (!descendants?.length || ![QueryType.SELECT, QueryType.COUNT].includes(this.type)) {
+            return;
+        }
+        if (!this._fields?.includes('*') && !this._fields?.includes(`${this.mainAlias.aliasName}.*`)) {
+            return;
+        }
+        // LEFT JOIN each descendant table and add their fields
+        for (const childMeta of descendants) {
+            const childAlias = this.getNextAlias(childMeta.className);
+            this.createAlias(childMeta.class, childAlias);
+            this._tptAlias[childMeta.className] = childAlias;
+            this.addPropertyJoin(childMeta.tptInverseProp, this.mainAlias.aliasName, childAlias, JoinType.leftJoin, `[tpt]${meta.className}`);
+            // Add child fields
+            const schema = childMeta.schema === '*' ? '*' : this.driver.getSchemaName(childMeta);
+            childMeta.ownProps
+                .filter(prop => !prop.primary && this.platform.shouldHaveColumn(prop, []))
+                .forEach(prop => this._fields.push(...this.driver.mapPropToFieldNames(this, prop, childAlias, childMeta, schema)));
+        }
+        // Add computed discriminator (CASE WHEN to determine concrete type)
+        // descendants is pre-sorted by depth (deepest first) during discovery
+        if (meta.tptDiscriminatorColumn) {
+            this._fields.push(this.driver.buildTPTDiscriminatorExpression(meta, descendants, this._tptAlias, this.mainAlias.aliasName));
+        }
+    }
     finalize() {
         if (this.finalized) {
             return;
@@ -1385,18 +1495,23 @@ export class QueryBuilder {
         }
         const meta = this.mainAlias.meta;
         this.applyDiscriminatorCondition();
+        this.applyTPTJoins();
+        this.addTPTParentFields();
+        this.applyTPTPolymorphicJoins();
         this.processPopulateHint();
         this.processNestedJoins();
         if (meta && (this._fields?.includes('*') || this._fields?.includes(`${this.mainAlias.aliasName}.*`))) {
             const schema = this.getSchema(this.mainAlias);
-            const columns = meta.createColumnMappingObject();
+            // Create a column mapping with unquoted aliases - quoting should be handled by the user via `quote` helper
+            // For TPT, use helper to resolve correct alias per property (inherited props use parent alias)
+            const quotedMainAlias = this.platform.quoteIdentifier(this.mainAlias.aliasName).toString();
+            const columns = meta.createColumnMappingObject(prop => this.helper.getTPTAliasForProperty(prop.name, this.mainAlias.aliasName), quotedMainAlias);
             meta.props
                 .filter(prop => prop.formula && (!prop.lazy || this.flags.has(QueryFlag.INCLUDE_LAZY_FORMULAS)))
                 .map(prop => {
-                const alias = this.platform.quoteIdentifier(this.mainAlias.aliasName);
                 const aliased = this.platform.quoteIdentifier(prop.fieldNames[0]);
-                const table = this.helper.createFormulaTable(alias.toString(), meta, schema);
-                return `${(prop.formula(table, columns))} as ${aliased}`;
+                const table = this.helper.createFormulaTable(quotedMainAlias, meta, schema);
+                return `${this.driver.evaluateFormula(prop.formula, columns, table)} as ${aliased}`;
             })
                 .filter(field => !this._fields.some(f => {
                 if (isRaw(f)) {
@@ -1753,6 +1868,7 @@ export class QueryBuilder {
         }
         return schema;
     }
+    /** @internal */
     createAlias(entityName, aliasName, subQuery) {
         const meta = this.metadata.find(entityName);
         const alias = { aliasName, entityName, meta, subQuery };
@@ -1775,7 +1891,7 @@ export class QueryBuilder {
         this.createMainAlias(entityName, aliasName);
     }
     createQueryBuilderHelper() {
-        return new QueryBuilderHelper(this.mainAlias.entityName, this.mainAlias.aliasName, this._aliases, this.subQueries, this.driver);
+        return new QueryBuilderHelper(this.mainAlias.entityName, this.mainAlias.aliasName, this._aliases, this.subQueries, this.driver, this._tptAlias);
     }
     ensureFromClause() {
         /* v8 ignore next */

package/query/QueryBuilderHelper.d.ts

@@ -12,9 +12,15 @@ export declare class QueryBuilderHelper {
     private readonly aliasMap;
     private readonly subQueries;
     private readonly driver;
+    private readonly tptAliasMap;
     private readonly platform;
     private readonly metadata;
-    constructor(entityName: EntityName, alias: string, aliasMap: Dictionary<Alias<any>>, subQueries: Dictionary<string>, driver: AbstractSqlDriver);
+    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;

package/query/QueryBuilderHelper.js

@@ -10,17 +10,44 @@ 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();
     }
+    /**
+     * 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);
@@ -63,9 +90,15 @@ export class QueryBuilderHelper {
             }
             return raw('(' + parts.map(part => this.platform.quoteIdentifier(part)).join(', ') + ')');
         }
-        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;
         if (a === prop?.embedded?.[0]) {
@@ -81,8 +114,8 @@ export class QueryBuilderHelper {
             const as = alias === null ? '' : ` as ${aliased}`;
             const meta = this.aliasMap[a]?.meta ?? this.metadata.get(this.entityName);
             const table = this.createFormulaTable(alias2, meta, schema);
-            const columns = meta.createColumnMappingObject();
-            let value = prop.formula(table, columns);
+            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 + '.', '');
             }
@@ -111,7 +144,7 @@ export class QueryBuilderHelper {
         if (!isTableNameAliasRequired || this.isPrefixed(ret) || noPrefix) {
             return ret;
         }
-        return this.alias + '.' + ret;
+        return resolvedAlias + '.' + ret;
     }
     processData(data, convertCustomTypes, multi = false) {
         if (Array.isArray(data)) {
@@ -209,11 +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 quotedAlias = this.platform.quoteIdentifier(join.ownerAlias).toString();
                     const ownerMeta = this.aliasMap[join.ownerAlias]?.meta ?? this.metadata.get(this.entityName);
-                    const table = this.createFormulaTable(alias.toString(), ownerMeta, schema);
-                    const columns = ownerMeta.createColumnMappingObject();
-                    const left = join.prop.formula(table, columns);
+                    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;
                 }
@@ -223,7 +256,7 @@ 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;
@@ -695,8 +728,10 @@ 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);
+            // 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;
             }
@@ -705,11 +740,16 @@ export class QueryBuilderHelper {
         else {
             const [a, ...rest] = field.split('.');
             const f = rest.join('.');
-            const fieldName = this.fieldName(f, a, always, idx);
+            // 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);

package/schema/DatabaseSchema.d.ts

@@ -44,6 +44,11 @@ export declare class DatabaseSchema {
     static fromMetadata(metadata: EntityMetadata[], platform: AbstractSqlPlatform, config: Configuration, schemaName?: string, em?: any): DatabaseSchema;
     private static getViewDefinition;
     private static getSchemaName;
+    /**
+     * Add a foreign key from a TPT child entity's PK to its parent entity's PK.
+     * This FK uses ON DELETE CASCADE to ensure child rows are deleted when parent is deleted.
+     */
+    private static addTPTForeignKey;
     private static matchName;
     private static isNameAllowed;
     private static isTableNameAllowed;

package/schema/DatabaseSchema.js

@@ -138,15 +138,43 @@ export class DatabaseSchema {
             }
             const table = schema.addTable(meta.collection, this.getSchemaName(meta, config, schemaName));
             table.comment = meta.comment;
-            for (const prop of meta.props) {
+            // For TPT child entities, only use ownProps (properties defined in this entity only)
+            // For all other entities (including TPT root), use all props
+            const propsToProcess = meta.inheritanceType === 'tpt' && meta.tptParent && meta.ownProps
+                ? meta.ownProps
+                : meta.props;
+            for (const prop of propsToProcess) {
                 if (!this.shouldHaveColumn(meta, prop, skipColumns)) {
                     continue;
                 }
                 table.addColumnFromProperty(prop, meta, config);
             }
+            // For TPT child entities, always include the PK columns (they form the FK to parent)
+            if (meta.inheritanceType === 'tpt' && meta.tptParent) {
+                const pkProps = meta.primaryKeys.map(pk => meta.properties[pk]);
+                for (const pkProp of pkProps) {
+                    // Only add if not already added (it might be in ownProps if defined in this entity)
+                    if (!propsToProcess.includes(pkProp)) {
+                        table.addColumnFromProperty(pkProp, meta, config);
+                    }
+                    // Child PK must not be autoincrement — it references the parent PK via FK
+                    for (const field of pkProp.fieldNames) {
+                        const col = table.getColumn(field);
+                        if (col) {
+                            col.autoincrement = false;
+                        }
+                    }
+                }
+                // Add FK from child PK to parent PK with ON DELETE CASCADE
+                this.addTPTForeignKey(table, meta, config, platform);
+            }
             meta.indexes.forEach(index => table.addIndex(meta, index, 'index'));
             meta.uniques.forEach(index => table.addIndex(meta, index, 'unique'));
-            table.addIndex(meta, { properties: meta.props.filter(prop => prop.primary).map(prop => prop.name) }, 'primary');
+            // For TPT child entities, the PK is also defined here
+            const pkPropsForIndex = meta.inheritanceType === 'tpt' && meta.tptParent
+                ? meta.primaryKeys.map(pk => meta.properties[pk])
+                : meta.props.filter(prop => prop.primary);
+            table.addIndex(meta, { properties: pkPropsForIndex.map(prop => prop.name) }, 'primary');
             for (const check of meta.checks) {
                 const columnName = check.property ? meta.properties[check.property].fieldNames[0] : undefined;
                 const expression = isRaw(check.expression) ? platform.formatQuery(check.expression.sql, check.expression.params) : check.expression;
@@ -192,6 +220,31 @@ export class DatabaseSchema {
     static getSchemaName(meta, config, schema) {
         return (meta.schema === '*' ? schema : meta.schema) ?? config.get('schema');
     }
+    /**
+     * Add a foreign key from a TPT child entity's PK to its parent entity's PK.
+     * This FK uses ON DELETE CASCADE to ensure child rows are deleted when parent is deleted.
+     */
+    static addTPTForeignKey(table, meta, config, platform) {
+        const parent = meta.tptParent;
+        const pkColumnNames = meta.primaryKeys.flatMap(pk => meta.properties[pk].fieldNames);
+        const parentPkColumnNames = parent.primaryKeys.flatMap(pk => parent.properties[pk].fieldNames);
+        // Determine the parent table name with schema
+        const parentSchema = parent.schema === '*' ? undefined : parent.schema ?? config.get('schema', platform.getDefaultSchemaName());
+        const parentTableName = parentSchema ? `${parentSchema}.${parent.tableName}` : parent.tableName;
+        // Create FK constraint name
+        const constraintName = platform.getIndexName(table.name, pkColumnNames, 'foreign');
+        // Add the foreign key to the table
+        const fks = table.getForeignKeys();
+        fks[constraintName] = {
+            constraintName,
+            columnNames: pkColumnNames,
+            localTableName: table.getShortestName(false),
+            referencedColumnNames: parentPkColumnNames,
+            referencedTableName: parentTableName,
+            deleteRule: 'cascade', // TPT always uses cascade delete
+            updateRule: 'cascade', // TPT always uses cascade update
+        };
+    }
     static matchName(name, nameToMatch) {
         return typeof nameToMatch === 'string'
             ? name.toLocaleLowerCase() === nameToMatch.toLocaleLowerCase()

package/schema/DatabaseTable.js

@@ -80,7 +80,7 @@ export class DatabaseTable {
             this.columns[field] = {
                 name: prop.fieldNames[idx],
                 type: prop.columnTypes[idx],
-                generated: prop.generated,
+                generated: prop.generated instanceof RawQueryFragment ? this.platform.formatQuery(prop.generated.sql, prop.generated.params) : prop.generated,
                 mappedType,
                 unsigned: prop.unsigned && this.platform.isNumericColumn(mappedType),
                 autoincrement: prop.autoincrement ?? (primary && prop.kind === ReferenceKind.SCALAR && this.platform.isNumericColumn(mappedType)),
@@ -710,17 +710,15 @@ export class DatabaseTable {
     }
     processIndexExpression(indexName, expression, meta) {
         if (expression instanceof Function) {
+            const qualifiedName = this.schema ? `${this.schema}.${this.name}` : this.name;
             const table = {
                 name: this.name,
                 schema: this.schema,
-                toString() {
-                    if (this.schema) {
-                        return `${this.schema}.${this.name}`;
-                    }
-                    return this.name;
-                },
+                qualifiedName,
+                toString: () => qualifiedName,
             };
-            const exp = expression(table, meta.createColumnMappingObject(), indexName);
+            const columns = meta.createSchemaColumnMappingObject();
+            const exp = expression(columns, table, indexName);
             return exp instanceof RawQueryFragment ? this.platform.formatQuery(exp.sql, exp.params) : exp;
         }
         return expression;