@mikro-orm/sql 7.0.0-dev.299 → 7.0.0-dev.301

package/query/QueryBuilder.js

@@ -281,7 +281,8 @@ export class QueryBuilder {
         if (populate) {
             populate.children.push(item);
         }
-        else { // root entity
+        else {
+            // root entity
             this._populate.push(item);
         }
         this._joinedProps.set(alias, item);
@@ -384,7 +385,8 @@ export class QueryBuilder {
             if (Utils.hasObjectKeys(cond) || RawQueryFragment.hasObjectFragments(cond)) {
                 // remove nested filters, we only care about scalars here, nesting would require another join branch
                 for (const key of Object.keys(cond)) {
-                    if (Utils.isPlainObject(cond[key]) && Object.keys(cond[key]).every(k => !(Utils.isOperator(k) && !['$some', '$none', '$every', '$size'].includes(k)))) {
+                    if (Utils.isPlainObject(cond[key]) &&
+                        Object.keys(cond[key]).every(k => !(Utils.isOperator(k) && !['$some', '$none', '$every', '$size'].includes(k)))) {
                         delete cond[key];
                     }
                 }
@@ -435,7 +437,8 @@ export class QueryBuilder {
         const topLevel = !op || !(Utils.hasObjectKeys(this._cond) || RawQueryFragment.hasObjectFragments(this._cond));
         const criteriaNode = CriteriaNodeFactory.createNode(this.metadata, this.mainAlias.entityName, processedCond);
         const ignoreBranching = this.__populateWhere === 'infer';
-        if ([QueryType.UPDATE, QueryType.DELETE].includes(this.type) && criteriaNode.willAutoJoin(this, undefined, { ignoreBranching })) {
+        if ([QueryType.UPDATE, QueryType.DELETE].includes(this.type) &&
+            criteriaNode.willAutoJoin(this, undefined, { ignoreBranching })) {
             // use sub-query to support joining
             this.setFlag(this.type === QueryType.UPDATE ? QueryFlag.UPDATE_SUB_QUERY : QueryFlag.DELETE_SUB_QUERY);
             this.select(this.mainAlias.meta.primaryKeys, true);
@@ -773,7 +776,7 @@ export class QueryBuilder {
             this.helper.getLockSQL(qb, this.lockMode, this.lockTables, this._joins);
         }
         this.helper.finalize(this.type, qb, this.mainAlias.meta, this._data, this._returning);
-        return this._query.qb = qb;
+        return (this._query.qb = qb);
     }
     /**
      * Returns the query with parameters as wildcards.
@@ -902,7 +905,12 @@ export class QueryBuilder {
             this.limit(1);
         }
         const query = this.toQuery();
-        const cached = await this.em?.tryCache(this.mainAlias.entityName, this._cache, ['qb.execute', query.sql, query.params, method]);
+        const cached = await this.em?.tryCache(this.mainAlias.entityName, this._cache, [
+            'qb.execute',
+            query.sql,
+            query.params,
+            method,
+        ]);
         if (cached?.data !== undefined) {
             return cached.data;
         }
@@ -1059,7 +1067,10 @@ export class QueryBuilder {
         else {
             const qb = (this._type === undefined ? this : this.clone());
             qb.processPopulateHint(); // needs to happen sooner so `qb.hasToManyJoins()` reports correctly
-            qb.count(field, distinct ?? qb.hasToManyJoins()).limit(undefined).offset(undefined).orderBy([]);
+            qb.count(field, distinct ?? qb.hasToManyJoins())
+                .limit(undefined)
+                .offset(undefined)
+                .orderBy([]);
             res = await qb.execute('get', false);
         }
         return res ? +res.count : 0;
@@ -1162,12 +1173,35 @@ export class QueryBuilder {
         reset = reset || [];
         // clone array/object properties
         const properties = [
-            'flags', '_populate', '_populateWhere', '_populateFilter', '__populateWhere', '_populateMap', '_joins', '_joinedProps', '_cond', '_data', '_orderBy',
-            '_schema', '_indexHint', '_collation', '_cache', 'subQueries', 'lockMode', 'lockTables', '_groupBy', '_having', '_returning',
-            '_comments', '_hintComments', 'aliasCounter', '_unionQuery',
+            'flags',
+            '_populate',
+            '_populateWhere',
+            '_populateFilter',
+            '__populateWhere',
+            '_populateMap',
+            '_joins',
+            '_joinedProps',
+            '_cond',
+            '_data',
+            '_orderBy',
+            '_schema',
+            '_indexHint',
+            '_collation',
+            '_cache',
+            'subQueries',
+            'lockMode',
+            'lockTables',
+            '_groupBy',
+            '_having',
+            '_returning',
+            '_comments',
+            '_hintComments',
+            'aliasCounter',
+            '_unionQuery',
         ];
         for (const prop of Object.keys(this)) {
-            if (!preserve?.includes(prop) && (reset === true || reset.includes(prop) || ['_helper', '_query'].includes(prop))) {
+            if (!preserve?.includes(prop) &&
+                (reset === true || reset.includes(prop) || ['_helper', '_query'].includes(prop))) {
                 continue;
             }
             qb[prop] = properties.includes(prop) ? Utils.copy(this[prop]) : this[prop];
@@ -1224,9 +1258,10 @@ export class QueryBuilder {
     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] =
+            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;
     }
@@ -1273,7 +1308,7 @@ export class QueryBuilder {
         }
         // 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))
+        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);
@@ -1288,7 +1323,7 @@ export class QueryBuilder {
         const criteriaNode = CriteriaNodeFactory.createNode(this.metadata, prop.targetMeta.class, cond);
         cond = criteriaNode.process(this, { ignoreBranching: true, alias });
         let aliasedName = `${fromAlias}.${prop.name}#${alias}`;
-        path ??= `${(Object.values(this._joins).find(j => j.alias === fromAlias)?.path ?? Utils.className(entityName))}.${prop.name}`;
+        path ??= `${Object.values(this._joins).find(j => j.alias === fromAlias)?.path ?? Utils.className(entityName)}.${prop.name}`;
         if (prop.kind === ReferenceKind.ONE_TO_MANY) {
             this._joins[aliasedName] = this.helper.joinOneToReference(prop, fromAlias, alias, type, cond, schema);
             this._joins[aliasedName].path ??= path;
@@ -1310,7 +1345,8 @@ export class QueryBuilder {
             this._joins[aliasedName] = this.helper.joinOneToReference(prop, ownerAlias, alias, type, cond, schema);
             this._joins[aliasedName].path ??= path;
         }
-        else { // MANY_TO_ONE
+        else {
+            // MANY_TO_ONE
             this._joins[aliasedName] = this.helper.joinManyToOneReference(prop, ownerAlias, alias, type, cond, schema);
             this._joins[aliasedName].path ??= path;
         }
@@ -1361,7 +1397,9 @@ export class QueryBuilder {
                 }
                 const nest = (prop) => {
                     for (const childProp of Object.values(prop.embeddedProps)) {
-                        if (childProp.fieldNames && (childProp.kind !== ReferenceKind.EMBEDDED || childProp.object) && childProp.persist !== false) {
+                        if (childProp.fieldNames &&
+                            (childProp.kind !== ReferenceKind.EMBEDDED || childProp.object) &&
+                            childProp.persist !== false) {
                             ret.push(getFieldName(childProp.fieldNames[0]));
                         }
                         else {
@@ -1412,7 +1450,9 @@ export class QueryBuilder {
         }
         // Start with root alias
         let currentAlias = parts[0];
-        let currentMeta = this._aliases[currentAlias] ? this.metadata.get(this._aliases[currentAlias].entityName) : this.mainAlias.meta;
+        let currentMeta = this._aliases[currentAlias]
+            ? this.metadata.get(this._aliases[currentAlias].entityName)
+            : this.mainAlias.meta;
         // If first part is not an alias, it's a property of the main entity
         if (!this._aliases[currentAlias]) {
             currentAlias = this.mainAlias.aliasName;
@@ -1567,7 +1607,9 @@ export class QueryBuilder {
         };
         lookUpChildren(children, meta.class);
         this.andWhere({
-            [meta.root.discriminatorColumn]: children.length > 0 ? { $in: [meta.discriminatorValue, ...children.map(c => c.discriminatorValue)] } : meta.discriminatorValue,
+            [meta.root.discriminatorColumn]: children.length > 0
+                ? { $in: [meta.discriminatorValue, ...children.map(c => c.discriminatorValue)] }
+                : meta.discriminatorValue,
         });
     }
     /**
@@ -1585,7 +1627,9 @@ export class QueryBuilder {
      */
     applyTPTJoins() {
         const meta = this.mainAlias.meta;
-        if (meta?.inheritanceType !== 'tpt' || !meta.tptParent || ![QueryType.SELECT, QueryType.COUNT].includes(this.type)) {
+        if (meta?.inheritanceType !== 'tpt' ||
+            !meta.tptParent ||
+            ![QueryType.SELECT, QueryType.COUNT].includes(this.type)) {
             return;
         }
         if (this.tptJoinsApplied) {
@@ -1609,7 +1653,9 @@ export class QueryBuilder {
      */
     addTPTParentFields() {
         const meta = this.mainAlias.meta;
-        if (meta?.inheritanceType !== 'tpt' || !meta.tptParent || ![QueryType.SELECT, QueryType.COUNT].includes(this.type)) {
+        if (meta?.inheritanceType !== 'tpt' ||
+            !meta.tptParent ||
+            ![QueryType.SELECT, QueryType.COUNT].includes(this.type)) {
             return;
         }
         if (!this._fields?.includes('*') && !this._fields?.includes(`${this.mainAlias.aliasName}.*`)) {
@@ -1620,8 +1666,8 @@ export class QueryBuilder {
             const parentAlias = this._tptAlias[parentMeta.className];
             if (parentAlias) {
                 const schema = parentMeta.schema === '*' ? '*' : this.driver.getSchemaName(parentMeta);
-                parentMeta.ownProps
-                    .filter(prop => this.platform.shouldHaveColumn(prop, []))
+                parentMeta
+                    .ownProps.filter(prop => this.platform.shouldHaveColumn(prop, []))
                     .forEach(prop => this._fields.push(...this.driver.mapPropToFieldNames(this, prop, parentAlias, parentMeta, schema)));
             }
             parentMeta = parentMeta.tptParent;
@@ -1648,8 +1694,8 @@ export class QueryBuilder {
             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, []))
+            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)
@@ -1700,7 +1746,11 @@ export class QueryBuilder {
         if (!this.flags.has(QueryFlag.DISABLE_PAGINATE) && this._groupBy.length === 0 && this.hasToManyJoins()) {
             this.flags.add(QueryFlag.PAGINATE);
         }
-        if (meta && !meta.virtual && this.flags.has(QueryFlag.PAGINATE) && !this.flags.has(QueryFlag.DISABLE_PAGINATE) && (this._limit > 0 || this._offset > 0)) {
+        if (meta &&
+            !meta.virtual &&
+            this.flags.has(QueryFlag.PAGINATE) &&
+            !this.flags.has(QueryFlag.DISABLE_PAGINATE) &&
+            (this._limit > 0 || this._offset > 0)) {
             this.wrapPaginateSubQuery(meta);
         }
         if (meta && (this.flags.has(QueryFlag.UPDATE_SUB_QUERY) || this.flags.has(QueryFlag.DELETE_SUB_QUERY))) {
@@ -1717,7 +1767,10 @@ export class QueryBuilder {
         if (meta && this.flags.has(QueryFlag.AUTO_JOIN_ONE_TO_ONE_OWNER)) {
             const relationsToPopulate = this._populate.map(({ field }) => field);
             meta.relations
-                .filter(prop => prop.kind === ReferenceKind.ONE_TO_ONE && !prop.owner && !relationsToPopulate.includes(prop.name) && !relationsToPopulate.includes(`${prop.name}:ref`))
+                .filter(prop => prop.kind === ReferenceKind.ONE_TO_ONE &&
+                !prop.owner &&
+                !relationsToPopulate.includes(prop.name) &&
+                !relationsToPopulate.includes(`${prop.name}:ref`))
                 .map(prop => ({ field: `${prop.name}:ref` }))
                 .forEach(item => this._populate.push(item));
         }
@@ -1734,7 +1787,8 @@ export class QueryBuilder {
                 const alias = this.getNextAlias(prop.pivotEntity ?? prop.targetMeta.class);
                 const aliasedName = `${fromAlias}.${prop.name}#${alias}`;
                 this._joins[aliasedName] = this.helper.joinOneToReference(prop, this.mainAlias.aliasName, alias, JoinType.leftJoin);
-                this._joins[aliasedName].path = `${(Object.values(this._joins).find(j => j.alias === fromAlias)?.path ?? meta.className)}.${prop.name}`;
+                this._joins[aliasedName].path =
+                    `${Object.values(this._joins).find(j => j.alias === fromAlias)?.path ?? meta.className}.${prop.name}`;
                 this._populateMap[aliasedName] = this._joins[aliasedName].alias;
                 this.createAlias(prop.targetMeta.class, alias);
             }
@@ -1754,9 +1808,7 @@ export class QueryBuilder {
             join.cond = { ...join.cond };
         }
         if (typeof this[key] === 'object') {
-            const cond = CriteriaNodeFactory
-                .createNode(this.metadata, this.mainAlias.entityName, this[key])
-                .process(this, { matchPopulateJoins: true, ignoreBranching: true, preferNoBranch: true, filter });
+            const cond = CriteriaNodeFactory.createNode(this.metadata, this.mainAlias.entityName, this[key]).process(this, { matchPopulateJoins: true, ignoreBranching: true, preferNoBranch: true, filter });
             // there might be new joins created by processing the `populateWhere` object
             joins = Object.values(this._joins);
             this.mergeOnConditions(joins, cond, filter);
@@ -1778,9 +1830,11 @@ export class QueryBuilder {
                 // https://stackoverflow.com/a/56815807/3665878
                 if (parentJoin && !filter) {
                     const nested = (parentJoin.nested ??= new Set());
-                    join.type = join.type === JoinType.innerJoin || ([ReferenceKind.ONE_TO_MANY, ReferenceKind.MANY_TO_MANY].includes(parentJoin.prop.kind))
-                        ? JoinType.nestedInnerJoin
-                        : JoinType.nestedLeftJoin;
+                    join.type =
+                        join.type === JoinType.innerJoin ||
+                            [ReferenceKind.ONE_TO_MANY, ReferenceKind.MANY_TO_MANY].includes(parentJoin.prop.kind)
+                            ? JoinType.nestedInnerJoin
+                            : JoinType.nestedLeftJoin;
                     nested.add(join);
                 }
                 if (join.cond[k]) {
@@ -1814,18 +1868,14 @@ export class QueryBuilder {
                 join.parent = joins.find(j => j.alias === join.ownerAlias);
                 // https://stackoverflow.com/a/56815807/3665878
                 if (join.parent?.type === JoinType.leftJoin || join.parent?.type === JoinType.nestedLeftJoin) {
-                    const nested = ((join.parent).nested ??= new Set());
-                    join.type = join.type === JoinType.innerJoin
-                        ? JoinType.nestedInnerJoin
-                        : JoinType.nestedLeftJoin;
+                    const nested = (join.parent.nested ??= new Set());
+                    join.type = join.type === JoinType.innerJoin ? JoinType.nestedInnerJoin : JoinType.nestedLeftJoin;
                     nested.add(join);
                 }
                 else if (join.parent?.type === JoinType.nestedInnerJoin) {
                     const group = lookupParentGroup(join.parent);
-                    const nested = group ?? ((join.parent).nested ??= new Set());
-                    join.type = join.type === JoinType.innerJoin
-                        ? JoinType.nestedInnerJoin
-                        : JoinType.nestedLeftJoin;
+                    const nested = group ?? (join.parent.nested ??= new Set());
+                    join.type = join.type === JoinType.innerJoin ? JoinType.nestedInnerJoin : JoinType.nestedLeftJoin;
                     nested.add(join);
                 }
             }
@@ -1917,7 +1967,9 @@ export class QueryBuilder {
         // Transfer WHERE conditions to ORDER BY joins (GH #6160)
         this.transferConditionsForOrderByJoins(meta, originalCond, populatePaths);
         const { sql, params } = subSubQuery.compile();
-        this.select(this._fields).where({ [Utils.getPrimaryKeyHash(meta.primaryKeys)]: { $in: raw(sql, params) } });
+        this.select(this._fields).where({
+            [Utils.getPrimaryKeyHash(meta.primaryKeys)]: { $in: raw(sql, params) },
+        });
     }
     /**
      * Computes the set of populate paths from the _populate hints.
@@ -1966,9 +2018,7 @@ export class QueryBuilder {
      * Removes joins that are not used for population or ordering to improve performance.
      */
     pruneJoinsForPagination(meta, populatePaths) {
-        const orderByAliases = this._orderBy
-            .flatMap(hint => Object.keys(hint))
-            .map(k => k.split('.')[0]);
+        const orderByAliases = this._orderBy.flatMap(hint => Object.keys(hint)).map(k => k.split('.')[0]);
         const joins = Object.entries(this._joins);
         const rootAlias = this.alias;
         function addParentAlias(alias) {
@@ -2097,8 +2147,12 @@ export class QueryBuilder {
     [Symbol.for('nodejs.util.inspect.custom')](depth = 2) {
         const object = { ...this };
         const hidden = ['metadata', 'driver', 'context', 'platform', 'type'];
-        Object.keys(object).filter(k => k.startsWith('_')).forEach(k => delete object[k]);
-        Object.keys(object).filter(k => object[k] == null).forEach(k => delete object[k]);
+        Object.keys(object)
+            .filter(k => k.startsWith('_'))
+            .forEach(k => delete object[k]);
+        Object.keys(object)
+            .filter(k => object[k] == null)
+            .forEach(k => delete object[k]);
         hidden.forEach(k => delete object[k]);
         let prefix = this.type ? this.type.substring(0, 1) + this.type.toLowerCase().substring(1) : '';
         if (this._data) {
@@ -2117,7 +2171,9 @@ export class QueryBuilder {
         if (!Utils.isEmpty(this._orderBy)) {
             object.orderBy = this._orderBy;
         }
-        const name = this._mainAlias ? `${prefix}QueryBuilder<${Utils.className(this._mainAlias?.entityName)}>` : 'QueryBuilder';
+        const name = this._mainAlias
+            ? `${prefix}QueryBuilder<${Utils.className(this._mainAlias?.entityName)}>`
+            : 'QueryBuilder';
         const ret = inspect(object, { depth });
         return ret === '[Object]' ? `[${name}]` : name + ' ' + ret;
     }

package/query/QueryBuilderHelper.js

@@ -174,13 +174,25 @@ export class QueryBuilderHelper {
             }
         }
         return {
-            prop, type, cond, ownerAlias, alias, table, schema,
-            joinColumns, inverseJoinColumns, primaryKeys,
+            prop,
+            type,
+            cond,
+            ownerAlias,
+            alias,
+            table,
+            schema,
+            joinColumns,
+            inverseJoinColumns,
+            primaryKeys,
         };
     }
     joinManyToOneReference(prop, ownerAlias, alias, type, cond = {}, schema) {
         return {
-            prop, type, cond, ownerAlias, alias,
+            prop,
+            type,
+            cond,
+            ownerAlias,
+            alias,
             table: this.getTableName(prop.targetMeta.class),
             schema: prop.targetMeta?.schema === '*' ? '*' : this.driver.getSchemaName(prop.targetMeta, { schema }),
             joinColumns: prop.referencedColumnNames,
@@ -193,7 +205,9 @@ export class QueryBuilderHelper {
         const pivotMeta = this.metadata.find(prop.pivotEntity);
         const ret = {
             [`${ownerAlias}.${prop.name}#${pivotAlias}`]: {
-                prop, type, ownerAlias,
+                prop,
+                type,
+                ownerAlias,
                 alias: pivotAlias,
                 inverseAlias: alias,
                 joinColumns: prop.joinColumns,
@@ -255,7 +269,9 @@ export class QueryBuilderHelper {
                 conditions.push(`${left} = ${this.platform.quoteIdentifier(right)}`);
             });
         }
-        if (join.prop.targetMeta?.root.inheritanceType === 'sti' && 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;
@@ -454,7 +470,7 @@ export class QueryBuilderHelper {
         // grouped condition for one field, e.g. `{ age: { $gte: 10, $lt: 50 } }`
         if (size > 1) {
             const subCondition = Object.entries(value).map(([subKey, subValue]) => {
-                return ({ [key]: { [subKey]: subValue } });
+                return { [key]: { [subKey]: subValue } };
             });
             for (const sub of subCondition) {
                 this.append(() => this._appendQueryCondition(type, sub, '$and'), parts, params);
@@ -520,7 +536,7 @@ export class QueryBuilderHelper {
         else if (['$in', '$nin'].includes(op) && Array.isArray(value[op]) && value[op].length === 0) {
             parts.push(`1 = ${op === '$in' ? 0 : 1}`);
         }
-        else if (value[op] instanceof Raw || (typeof value[op]?.toRaw === 'function')) {
+        else if (value[op] instanceof Raw || typeof value[op]?.toRaw === 'function') {
             const query = value[op] instanceof Raw ? value[op] : value[op].toRaw();
             const mappedKey = this.mapper(key, type, query, null);
             let sql = query.sql;
@@ -548,7 +564,11 @@ export class QueryBuilderHelper {
                 return `(${tmp.join(', ')})`;
             }
             if (prop?.customType instanceof ArrayType) {
-                const item = prop.customType.convertToDatabaseValue(value, this.platform, { fromQuery: true, key, mode: 'query' });
+                const item = prop.customType.convertToDatabaseValue(value, this.platform, {
+                    fromQuery: true,
+                    key,
+                    mode: 'query',
+                });
                 params.push(item);
             }
             else {
@@ -628,11 +648,14 @@ export class QueryBuilderHelper {
                 const noPrefix = (prop?.persist === false && !prop.formula && !prop.embedded) || Raw.isKnownFragment(f);
                 const column = this.mapper(noPrefix ? field : `${alias}.${field}`, type, undefined, null);
                 /* v8 ignore next */
-                const rawColumn = typeof column === 'string' ? column.split('.').map(e => this.platform.quoteIdentifier(e)).join('.') : column;
+                const rawColumn = typeof column === 'string'
+                    ? column
+                        .split('.')
+                        .map(e => this.platform.quoteIdentifier(e))
+                        .join('.')
+                    : column;
                 const customOrder = prop?.customOrder;
-                let colPart = customOrder
-                    ? this.platform.generateCustomOrder(rawColumn, customOrder)
-                    : rawColumn;
+                let colPart = customOrder ? this.platform.generateCustomOrder(rawColumn, customOrder) : rawColumn;
                 if (isRaw(colPart)) {
                     colPart = this.platform.formatQuery(colPart.sql, colPart.params);
                 }
@@ -671,7 +694,9 @@ export class QueryBuilderHelper {
                 const fields = returningProps.flatMap((prop) => {
                     if (prop.hasConvertToJSValueSQL) {
                         const aliased = this.platform.quoteIdentifier(prop.fieldNames[0]);
-                        const sql = prop.customType.convertToJSValueSQL(aliased, this.platform) + ' as ' + this.platform.quoteIdentifier(prop.fieldNames[0]);
+                        const sql = prop.customType.convertToJSValueSQL(aliased, this.platform) +
+                            ' as ' +
+                            this.platform.quoteIdentifier(prop.fieldNames[0]);
                         return [raw(sql)];
                     }
                     return prop.fieldNames;
@@ -769,7 +794,9 @@ export class QueryBuilderHelper {
             // skip nesting parens if the value is simple = scalar or object without operators or with only single key, being the operator
             const keys = Utils.getObjectQueryKeys(sub);
             const val = sub[keys[0]];
-            const simple = !Utils.isPlainObject(val) || Utils.getObjectKeysSize(val) === 1 || Object.keys(val).every(k => !Utils.isOperator(k));
+            const simple = !Utils.isPlainObject(val) ||
+                Utils.getObjectKeysSize(val) === 1 ||
+                Object.keys(val).every(k => !Utils.isOperator(k));
             if (keys.length === 1 && simple) {
                 this.append(() => this._appendQueryCondition(type, sub, operator), parts, params);
                 continue;

package/query/ScalarCriteriaNode.js

@@ -7,7 +7,8 @@ import { QueryBuilder } from './QueryBuilder.js';
  */
 export class ScalarCriteriaNode extends CriteriaNode {
     process(qb, options) {
-        const matchPopulateJoins = options?.matchPopulateJoins || (this.prop && [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(this.prop.kind));
+        const matchPopulateJoins = options?.matchPopulateJoins ||
+            (this.prop && [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(this.prop.kind));
         const nestedAlias = qb.getAliasForJoinPath(this.getPath(options), { ...options, matchPopulateJoins });
         if (this.shouldJoin(qb, nestedAlias)) {
             const path = this.getPath();
@@ -36,14 +37,20 @@ export class ScalarCriteriaNode extends CriteriaNode {
         return this.shouldJoin(qb, alias);
     }
     shouldJoin(qb, nestedAlias) {
-        if (!this.parent || !this.prop || (nestedAlias && [QueryType.SELECT, QueryType.COUNT].includes(qb.type ?? QueryType.SELECT))) {
+        if (!this.parent ||
+            !this.prop ||
+            (nestedAlias && [QueryType.SELECT, QueryType.COUNT].includes(qb.type ?? QueryType.SELECT))) {
             return false;
         }
         switch (this.prop.kind) {
-            case ReferenceKind.ONE_TO_MANY: return true;
-            case ReferenceKind.MANY_TO_MANY: return true;
-            case ReferenceKind.ONE_TO_ONE: return !this.prop.owner;
-            default: return false; // SCALAR, MANY_TO_ONE
+            case ReferenceKind.ONE_TO_MANY:
+                return true;
+            case ReferenceKind.MANY_TO_MANY:
+                return true;
+            case ReferenceKind.ONE_TO_ONE:
+                return !this.prop.owner;
+            default:
+                return false; // SCALAR, MANY_TO_ONE
         }
     }
 }

package/query/raw.js

@@ -1,4 +1,4 @@
-import { raw as raw_, Utils } from '@mikro-orm/core';
+import { raw as raw_, Utils, } from '@mikro-orm/core';
 /**
  * Creates raw SQL query fragment that can be assigned to a property or part of a filter. This fragment is represented
  * by `RawQueryFragment` class instance that can be serialized to a string, so it can be used both as an object value

package/schema/DatabaseSchema.js

@@ -81,8 +81,11 @@ export class DatabaseSchema {
         const parts = config.get('migrations').tableName.split('.');
         const migrationsTableName = parts[1] ?? parts[0];
         const migrationsSchemaName = parts.length > 1 ? parts[0] : config.get('schema', platform.getDefaultSchemaName());
-        const tables = allTables.filter(t => this.isTableNameAllowed(t.table_name, takeTables, skipTables) && (t.table_name !== migrationsTableName || (t.schema_name && t.schema_name !== migrationsSchemaName)));
-        await platform.getSchemaHelper().loadInformationSchema(schema, connection, tables, schemas && schemas.length > 0 ? schemas : undefined);
+        const tables = allTables.filter(t => this.isTableNameAllowed(t.table_name, takeTables, skipTables) &&
+            (t.table_name !== migrationsTableName || (t.schema_name && t.schema_name !== migrationsSchemaName)));
+        await platform
+            .getSchemaHelper()
+            .loadInformationSchema(schema, connection, tables, schemas && schemas.length > 0 ? schemas : undefined);
         // Load views from database
         await platform.getSchemaHelper().loadViews(schema, connection);
         // Load materialized views (PostgreSQL only)
@@ -140,9 +143,7 @@ export class DatabaseSchema {
             table.comment = meta.comment;
             // 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;
+            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;
@@ -177,7 +178,9 @@ export class DatabaseSchema {
             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;
+                const expression = isRaw(check.expression)
+                    ? platform.formatQuery(check.expression.sql, check.expression.params)
+                    : check.expression;
                 table.addCheck({
                     name: check.name,
                     expression,
@@ -229,7 +232,7 @@ export class DatabaseSchema {
         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 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');
@@ -284,7 +287,8 @@ export class DatabaseSchema {
         if (rootProp.kind === ReferenceKind.EMBEDDED) {
             return prop === rootProp || !rootProp.object;
         }
-        return [ReferenceKind.SCALAR, ReferenceKind.MANY_TO_ONE].includes(prop.kind) || (prop.kind === ReferenceKind.ONE_TO_ONE && prop.owner);
+        return ([ReferenceKind.SCALAR, ReferenceKind.MANY_TO_ONE].includes(prop.kind) ||
+            (prop.kind === ReferenceKind.ONE_TO_ONE && prop.owner));
     }
     toJSON() {
         const { platform, namespaces, ...rest } = this;
@@ -293,19 +297,21 @@ export class DatabaseSchema {
     prune(schema, wildcardSchemaTables) {
         const hasWildcardSchema = wildcardSchemaTables.length > 0;
         this.tables = this.tables.filter(table => {
-            return (!schema && !hasWildcardSchema) // no schema specified and we don't have any multi-schema entity
-                || table.schema === schema // specified schema matches the table's one
-                || (!schema && !wildcardSchemaTables.includes(table.name)); // no schema specified and the table has fixed one provided
+            return ((!schema && !hasWildcardSchema) || // no schema specified and we don't have any multi-schema entity
+                table.schema === schema || // specified schema matches the table's one
+                (!schema && !wildcardSchemaTables.includes(table.name))); // no schema specified and the table has fixed one provided
         });
         this.views = this.views.filter(view => {
             /* v8 ignore next */
-            return (!schema && !hasWildcardSchema)
-                || view.schema === schema
-                || (!schema && !wildcardSchemaTables.includes(view.name));
+            return ((!schema && !hasWildcardSchema) ||
+                view.schema === schema ||
+                (!schema && !wildcardSchemaTables.includes(view.name)));
         });
         // remove namespaces of ignored tables and views
         for (const ns of this.namespaces) {
-            if (!this.tables.some(t => t.schema === ns) && !this.views.some(v => v.schema === ns) && !Object.values(this.nativeEnums).some(e => e.schema === ns)) {
+            if (!this.tables.some(t => t.schema === ns) &&
+                !this.views.some(v => v.schema === ns) &&
+                !Object.values(this.nativeEnums).some(e => e.schema === ns)) {
                 this.namespaces.delete(ns);
             }
         }