@mikro-orm/sql 7.0.0-rc.2 → 7.0.0-rc.3

package/query/QueryBuilder.js

@@ -1,4 +1,4 @@
-import { helper, inspect, isRaw, LoadStrategy, LockMode, PopulateHint, QueryFlag, QueryHelper, raw, RawQueryFragment, Reference, ReferenceKind, serialize, Utils, ValidationError, } from '@mikro-orm/core';
+import { EntityMetadata, helper, inspect, isRaw, LoadStrategy, LockMode, PopulateHint, QueryFlag, QueryHelper, raw, RawQueryFragment, Reference, ReferenceKind, serialize, Utils, ValidationError, } from '@mikro-orm/core';
 import { JoinType, QueryType } from './enums.js';
 import { QueryBuilderHelper } from './QueryBuilderHelper.js';
 import { CriteriaNodeFactory } from './CriteriaNodeFactory.js';
@@ -81,6 +81,8 @@ export class QueryBuilder {
     _tptAlias = {}; // maps entity className to alias for TPT parent tables
     _helper;
     _query;
+    _unionQuery;
+    _ctes = [];
     platform;
     tptJoinsApplied = false;
     autoJoinedPaths = [];
@@ -279,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);
@@ -382,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];
                     }
                 }
@@ -433,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);
@@ -711,6 +716,9 @@ export class QueryBuilder {
         if (target instanceof QueryBuilder) {
             this.fromSubQuery(target, aliasName);
         }
+        else if (typeof target === 'string' && !this.metadata.find(target)) {
+            this.fromRawTable(target, aliasName);
+        }
         else {
             if (aliasName && this._mainAlias && Utils.className(target) !== this._mainAlias.aliasName) {
                 throw new Error(`Cannot override the alias to '${aliasName}' since a query already contains references to '${this._mainAlias.aliasName}'`);
@@ -720,12 +728,32 @@ export class QueryBuilder {
         return this;
     }
     getNativeQuery(processVirtualEntity = true) {
+        if (this._unionQuery) {
+            if (!this._query?.qb) {
+                this._query = {};
+                const nqb = this.platform.createNativeQueryBuilder();
+                nqb.select('*');
+                nqb.from(raw(`(${this._unionQuery.sql})`, this._unionQuery.params));
+                this._query.qb = nqb;
+            }
+            return this._query.qb;
+        }
         if (this._query?.qb) {
             return this._query.qb;
         }
         this._query = {};
         this.finalize();
         const qb = this.getQueryBase(processVirtualEntity);
+        for (const cte of this._ctes) {
+            const query = cte.query;
+            const opts = { columns: cte.columns, materialized: cte.materialized };
+            if (cte.recursive) {
+                qb.withRecursive(cte.name, query, opts);
+            }
+            else {
+                qb.with(cte.name, query, opts);
+            }
+        }
         const schema = this.getSchema(this.mainAlias);
         const isNotEmptyObject = (obj) => Utils.hasObjectKeys(obj) || RawQueryFragment.hasObjectFragments(obj);
         Utils.runIfNotEmpty(() => this.helper.appendQueryCondition(this.type, this._cond, qb), this._cond && !this._onConflict);
@@ -748,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.
@@ -764,6 +792,9 @@ export class QueryBuilder {
         return raw(sql, params);
     }
     toQuery() {
+        if (this._unionQuery) {
+            return this._unionQuery;
+        }
         if (this._query?.sql) {
             return { sql: this._query.sql, params: this._query.params };
         }
@@ -874,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;
         }
@@ -1031,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;
@@ -1059,17 +1098,110 @@ export class QueryBuilder {
         Object.defineProperty(qb, '__as', { enumerable: false, value: finalAlias });
         return qb;
     }
+    /**
+     * Combines the current query with one or more other queries using `UNION ALL`.
+     * All queries must select the same columns. Returns a `QueryBuilder` that
+     * can be used with `$in`, passed to `qb.from()`, or converted via `.getQuery()`,
+     * `.getParams()`, `.toQuery()`, `.toRaw()`, etc.
+     *
+     * ```ts
+     * const qb1 = em.createQueryBuilder(Employee).select('id').where(condition1);
+     * const qb2 = em.createQueryBuilder(Employee).select('id').where(condition2);
+     * const qb3 = em.createQueryBuilder(Employee).select('id').where(condition3);
+     * const subquery = qb1.unionAll(qb2, qb3);
+     *
+     * const results = await em.find(Employee, { id: { $in: subquery } });
+     * ```
+     */
+    unionAll(...others) {
+        return this.buildUnionQuery('union all', others);
+    }
+    /**
+     * Combines the current query with one or more other queries using `UNION` (with deduplication).
+     * All queries must select the same columns. Returns a `QueryBuilder` that
+     * can be used with `$in`, passed to `qb.from()`, or converted via `.getQuery()`,
+     * `.getParams()`, `.toQuery()`, `.toRaw()`, etc.
+     *
+     * ```ts
+     * const qb1 = em.createQueryBuilder(Employee).select('id').where(condition1);
+     * const qb2 = em.createQueryBuilder(Employee).select('id').where(condition2);
+     * const subquery = qb1.union(qb2);
+     *
+     * const results = await em.find(Employee, { id: { $in: subquery } });
+     * ```
+     */
+    union(...others) {
+        return this.buildUnionQuery('union', others);
+    }
+    buildUnionQuery(separator, others) {
+        const all = [this, ...others];
+        const parts = [];
+        const params = [];
+        for (const qb of all) {
+            const compiled = qb instanceof QueryBuilder ? qb.toQuery() : qb.compile();
+            parts.push(`(${compiled.sql})`);
+            params.push(...compiled.params);
+        }
+        const result = this.clone(true);
+        result._unionQuery = { sql: parts.join(` ${separator} `), params };
+        return result;
+    }
+    with(name, query, options) {
+        return this.addCte(name, query, options);
+    }
+    withRecursive(name, query, options) {
+        return this.addCte(name, query, options, true);
+    }
+    addCte(name, query, options, recursive) {
+        this.ensureNotFinalized();
+        if (this._ctes.some(cte => cte.name === name)) {
+            throw new Error(`CTE with name '${name}' already exists`);
+        }
+        // Eagerly compile QueryBuilder to RawQueryFragment — later mutations to the sub-query won't be reflected
+        const compiled = query instanceof QueryBuilder ? query.toRaw() : query;
+        this._ctes.push({
+            name,
+            query: compiled,
+            recursive,
+            columns: options?.columns,
+            materialized: options?.materialized,
+        });
+        return this;
+    }
     clone(reset, preserve) {
         const qb = new QueryBuilder(this.mainAlias.entityName, this.metadata, this.driver, this.context, this.mainAlias.aliasName, this.connectionType, this.em);
         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',
+            '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];
@@ -1078,6 +1210,9 @@ export class QueryBuilder {
         if (this._fields && reset !== true && !reset.includes('_fields')) {
             qb._fields = [...this._fields];
         }
+        if (this._ctes.length && reset !== true && !reset.includes('_ctes')) {
+            qb._ctes = this._ctes.map(cte => ({ ...cte }));
+        }
         qb._aliases = { ...this._aliases };
         qb._helper.aliasMap = qb._aliases;
         qb.finalized = false;
@@ -1123,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;
     }
@@ -1172,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);
@@ -1187,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;
@@ -1209,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;
         }
@@ -1260,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 {
@@ -1311,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;
@@ -1395,18 +1536,24 @@ export class QueryBuilder {
     }
     getQueryBase(processVirtualEntity) {
         const qb = this.platform.createNativeQueryBuilder().setFlags(this.flags);
-        const { subQuery, aliasName, entityName, meta } = this.mainAlias;
+        const { subQuery, aliasName, entityName, meta, rawTableName } = this.mainAlias;
         const requiresAlias = this.finalized && (this._explicitAlias || this.helper.isTableNameAliasRequired(this.type));
         const alias = requiresAlias ? aliasName : undefined;
         const schema = this.getSchema(this.mainAlias);
-        const tableName = subQuery ? subQuery.as(aliasName) : this.helper.getTableName(entityName);
+        const tableName = rawTableName
+            ? rawTableName
+            : subQuery instanceof NativeQueryBuilder
+                ? subQuery.as(aliasName)
+                : subQuery
+                    ? raw(`(${subQuery.sql}) as ${this.platform.quoteIdentifier(aliasName)}`, subQuery.params)
+                    : this.helper.getTableName(entityName);
         const joinSchema = this._schema ?? this.em?.schema ?? schema;
         if (meta.virtual && processVirtualEntity) {
             qb.from(raw(this.fromVirtual(meta)), { indexHint: this._indexHint });
         }
         else {
             qb.from(tableName, {
-                schema,
+                schema: rawTableName ? undefined : schema,
                 alias,
                 indexHint: this._indexHint,
             });
@@ -1460,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,
         });
     }
     /**
@@ -1478,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) {
@@ -1502,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}.*`)) {
@@ -1513,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;
@@ -1541,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)
@@ -1593,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))) {
@@ -1610,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));
         }
@@ -1627,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);
             }
@@ -1647,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);
@@ -1671,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]) {
@@ -1707,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);
                 }
             }
@@ -1810,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.
@@ -1859,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) {
@@ -1946,15 +2103,31 @@ export class QueryBuilder {
         return this._mainAlias;
     }
     fromSubQuery(target, aliasName) {
-        const subQuery = target.getNativeQuery();
         const { entityName } = target.mainAlias;
         aliasName ??= this.getNextAlias(entityName);
+        const subQuery = target._unionQuery ? target.toRaw() : target.getNativeQuery();
         this.createMainAlias(entityName, aliasName, subQuery);
     }
     fromEntityName(entityName, aliasName) {
         aliasName ??= this._mainAlias?.aliasName ?? this.getNextAlias(entityName);
         this.createMainAlias(entityName, aliasName);
     }
+    fromRawTable(tableName, aliasName) {
+        aliasName ??= this._mainAlias?.aliasName ?? this.getNextAlias(tableName);
+        const meta = new EntityMetadata({
+            className: tableName,
+            collection: tableName,
+        });
+        meta.root = meta;
+        this._mainAlias = {
+            aliasName,
+            entityName: tableName,
+            meta,
+            rawTableName: tableName,
+        };
+        this._aliases[aliasName] = this._mainAlias;
+        this._helper = this.createQueryBuilderHelper();
+    }
     createQueryBuilderHelper() {
         return new QueryBuilderHelper(this.mainAlias.entityName, this.mainAlias.aliasName, this._aliases, this.subQueries, this.driver, this._tptAlias);
     }
@@ -1974,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) {
@@ -1994,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.d.ts

@@ -1,8 +1,8 @@
-import { type Dictionary, type EntityData, type EntityKey, type EntityMetadata, type EntityName, type EntityProperty, type FilterQuery, type FlatQueryOrderMap, type FormulaTable, LockMode, type QueryOrderMap, Raw, type RawQueryFragmentSymbol } from '@mikro-orm/core';
+import { type Dictionary, type EntityData, type EntityKey, type EntityMetadata, type EntityName, type EntityProperty, type FilterQuery, type FlatQueryOrderMap, type FormulaTable, LockMode, type QueryOrderMap, Raw, type RawQueryFragment, type RawQueryFragmentSymbol } from '@mikro-orm/core';
 import { JoinType, QueryType } from './enums.js';
 import type { InternalField, JoinOptions } from '../typings.js';
 import type { AbstractSqlDriver } from '../AbstractSqlDriver.js';
-import { NativeQueryBuilder } from './NativeQueryBuilder.js';
+import type { NativeQueryBuilder } from './NativeQueryBuilder.js';
 /**
  * @internal
  */
@@ -71,7 +71,8 @@ export interface Alias<T> {
     aliasName: string;
     entityName: EntityName<T>;
     meta: EntityMetadata<T>;
-    subQuery?: NativeQueryBuilder;
+    subQuery?: NativeQueryBuilder | RawQueryFragment;
+    rawTableName?: string;
 }
 export interface OnConflictClause<T> {
     fields: string[] | Raw;