@mikro-orm/sql 7.0.0-dev.291 → 7.0.0-dev.293

package/AbstractSqlDriver.d.ts

@@ -137,6 +137,12 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
     protected processManyToMany<T extends object>(meta: EntityMetadata<T>, pks: Primary<T>[], collections: EntityData<T>, clear: boolean, options?: DriverMethodOptions): Promise<void>;
     lockPessimistic<T extends object>(entity: T, options: LockOptions): Promise<void>;
     protected buildPopulateWhere<T extends object>(meta: EntityMetadata<T>, joinedProps: PopulateOptions<T>[], options: Pick<FindOptions<any>, 'populateWhere'>): ObjectQuery<T>;
+    /**
+     * Builds a UNION ALL (or UNION) subquery from `unionWhere` branches and merges it
+     * into the main WHERE as `pk IN (branch_1 UNION ALL branch_2 ...)`.
+     * Each branch is planned independently by the database, enabling per-table index usage.
+     */
+    protected applyUnionWhere<T extends object>(meta: EntityMetadata<T>, where: ObjectQuery<T>, options: FindOptions<T, any, any, any> | CountOptions<T> | NativeInsertUpdateOptions<T> | DeleteOptions<T>, forDml?: boolean): Promise<ObjectQuery<T>>;
     protected buildOrderBy<T extends object>(qb: QueryBuilder<T, any, any, any>, meta: EntityMetadata<T>, populate: PopulateOptions<T>[], options: Pick<FindOptions<any>, 'strategy' | 'orderBy' | 'populateOrderBy'>): QueryOrderMap<T>[];
     protected buildPopulateOrderBy<T extends object>(qb: QueryBuilder<T, any, any, any>, meta: EntityMetadata<T>, populateOrderBy: QueryOrderMap<T>[], parentPath: string, explicit: boolean, parentAlias?: string): QueryOrderMap<T>[];
     protected buildJoinedPropsOrderBy<T extends object>(qb: QueryBuilder<T, any, any, any>, meta: EntityMetadata<T>, populate: PopulateOptions<T>[], options?: Pick<FindOptions<any>, 'strategy' | 'orderBy' | 'populateOrderBy'>, parentPath?: string): QueryOrderMap<T>[];

package/AbstractSqlDriver.js

@@ -95,6 +95,9 @@ export class AbstractSqlDriver extends DatabaseDriver {
         if (meta.virtual) {
             return this.findVirtual(entityName, where, options);
         }
+        if (options.unionWhere?.length) {
+            where = await this.applyUnionWhere(meta, where, options);
+        }
         const qb = await this.createQueryBuilderFromOptions(meta, where, options);
         const result = await this.rethrow(qb.execute('all'));
         if (options.last && !options.first) {
@@ -493,6 +496,9 @@ export class AbstractSqlDriver extends DatabaseDriver {
         if (meta.virtual) {
             return this.countVirtual(entityName, where, options);
         }
+        if (options.unionWhere?.length) {
+            where = await this.applyUnionWhere(meta, where, options);
+        }
         options = { populate: [], ...options };
         const populate = options.populate;
         const joinedProps = this.joinedProps(meta, populate, options);
@@ -704,6 +710,9 @@ export class AbstractSqlDriver extends DatabaseDriver {
             /* v8 ignore next */
             where = { [meta.primaryKeys[0] ?? pks[0]]: where };
         }
+        if (!options.upsert && options.unionWhere?.length) {
+            where = await this.applyUnionWhere(meta, where, options, true);
+        }
         if (Utils.hasObjectKeys(data)) {
             const qb = this.createQueryBuilder(entityName, options.ctx, 'write', options.convertCustomTypes, options.loggerContext).withSchema(this.getSchemaName(meta, options));
             if (options.upsert) {
@@ -881,6 +890,9 @@ export class AbstractSqlDriver extends DatabaseDriver {
         if (Utils.isPrimaryKey(where) && pks.length === 1) {
             where = { [pks[0]]: where };
         }
+        if (options.unionWhere?.length) {
+            where = await this.applyUnionWhere(meta, where, options, true);
+        }
         const qb = this.createQueryBuilder(entityName, options.ctx, 'write', false, options.loggerContext)
             .delete(where)
             .withSchema(this.getSchemaName(meta, options));
@@ -1598,6 +1610,47 @@ export class AbstractSqlDriver extends DatabaseDriver {
         /* v8 ignore next */
         return { $and: [options.populateWhere, where] };
     }
+    /**
+     * Builds a UNION ALL (or UNION) subquery from `unionWhere` branches and merges it
+     * into the main WHERE as `pk IN (branch_1 UNION ALL branch_2 ...)`.
+     * Each branch is planned independently by the database, enabling per-table index usage.
+     */
+    async applyUnionWhere(meta, where, options, forDml = false) {
+        const unionWhere = options.unionWhere;
+        const strategy = options.unionWhereStrategy ?? 'union-all';
+        const schema = this.getSchemaName(meta, options);
+        const connectionType = this.resolveConnectionType({
+            ctx: options.ctx,
+            connectionType: options.connectionType,
+        });
+        const branchQbs = [];
+        for (const branch of unionWhere) {
+            const qb = this.createQueryBuilder(meta.class, options.ctx, connectionType, false, options.logging).withSchema(schema);
+            const pkFields = meta.primaryKeys.map(pk => {
+                const prop = meta.properties[pk];
+                return `${qb.alias}.${prop.fieldNames[0]}`;
+            });
+            qb.select(pkFields).where(branch);
+            if (options.em) {
+                await qb.applyJoinedFilters(options.em, options.filters);
+            }
+            branchQbs.push(qb);
+        }
+        const [first, ...rest] = branchQbs;
+        const unionQb = strategy === 'union' ? first.union(...rest) : first.unionAll(...rest);
+        const pkHash = Utils.getPrimaryKeyHash(meta.primaryKeys);
+        // MySQL does not allow referencing the target table in a subquery
+        // for UPDATE/DELETE, so we wrap the union in a derived table.
+        if (forDml) {
+            const { sql, params } = unionQb.toQuery();
+            return {
+                $and: [where, { [pkHash]: { $in: raw(`select * from (${sql}) as __u`, params) } }],
+            };
+        }
+        return {
+            $and: [where, { [pkHash]: { $in: unionQb.toRaw() } }],
+        };
+    }
     buildOrderBy(qb, meta, populate, options) {
         const joinedProps = this.joinedProps(meta, populate, options);
         // `options._populateWhere` is a copy of the value provided by user with a fallback to the global config option

package/AbstractSqlPlatform.d.ts

@@ -27,6 +27,7 @@ export declare abstract class AbstractSqlPlatform extends Platform {
     getSearchJsonPropertySQL(path: string, type: string, aliased: boolean): string | RawQueryFragment;
     getSearchJsonPropertyKey(path: string[], type: string, aliased: boolean, value?: unknown): string | RawQueryFragment;
     getJsonIndexDefinition(index: IndexDef): string[];
+    supportsUnionWhere(): boolean;
     supportsSchemas(): boolean;
     /** @inheritDoc */
     generateCustomOrder(escapedColumn: string, values: unknown[]): string;

package/AbstractSqlPlatform.js

@@ -80,6 +80,9 @@ export class AbstractSqlPlatform extends Platform {
             return `(json_extract(${root}, '$.${path.join('.')}'))`;
         });
     }
+    supportsUnionWhere() {
+        return true;
+    }
     supportsSchemas() {
         return false;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/sql",
-  "version": "7.0.0-dev.291",
+  "version": "7.0.0-dev.293",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
   "type": "module",
   "exports": {
@@ -56,6 +56,6 @@
     "@mikro-orm/core": "^6.6.8"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.0.0-dev.291"
+    "@mikro-orm/core": "7.0.0-dev.293"
   }
 }

package/query/QueryBuilder.d.ts

@@ -220,6 +220,10 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
         params?: readonly unknown[];
         qb: NativeQueryBuilder;
     };
+    protected _unionQuery?: {
+        sql: string;
+        params: readonly unknown[];
+    };
     protected readonly platform: AbstractSqlPlatform;
     private tptJoinsApplied;
     private readonly autoJoinedPaths;
@@ -750,6 +754,38 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
      * You can provide the target entity name as the first parameter and use the second parameter to point to an existing property to infer its field name.
      */
     as<T>(targetEntity: EntityName<T>, alias: EntityKey<T>): NativeQueryBuilder;
+    /**
+     * 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: (QueryBuilder<any> | NativeQueryBuilder)[]): QueryBuilder<Entity>;
+    /**
+     * 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: (QueryBuilder<any> | NativeQueryBuilder)[]): QueryBuilder<Entity>;
+    private buildUnionQuery;
     clone(reset?: boolean | string[], preserve?: string[]): QueryBuilder<Entity, RootAlias, Hint, Context, RawAliases, Fields>;
     /**
      * Sets logger context for this query builder.
@@ -836,7 +872,7 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
     private wrapModifySubQuery;
     private getSchema;
     /** @internal */
-    createAlias<U = unknown>(entityName: EntityName<U>, aliasName: string, subQuery?: NativeQueryBuilder): Alias<U>;
+    createAlias<U = unknown>(entityName: EntityName<U>, aliasName: string, subQuery?: NativeQueryBuilder | RawQueryFragment): Alias<U>;
     private createMainAlias;
     private fromSubQuery;
     private fromEntityName;

package/query/QueryBuilder.js

@@ -81,6 +81,7 @@ export class QueryBuilder {
     _tptAlias = {}; // maps entity className to alias for TPT parent tables
     _helper;
     _query;
+    _unionQuery;
     platform;
     tptJoinsApplied = false;
     autoJoinedPaths = [];
@@ -720,6 +721,16 @@ 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;
         }
@@ -764,6 +775,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 };
         }
@@ -1059,6 +1073,54 @@ 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;
+    }
     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 || [];
@@ -1066,7 +1128,7 @@ export class QueryBuilder {
         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',
+            '_comments', '_hintComments', 'aliasCounter', '_unionQuery',
         ];
         for (const prop of Object.keys(this)) {
             if (!preserve?.includes(prop) && (reset === true || reset.includes(prop) || ['_helper', '_query'].includes(prop))) {
@@ -1399,7 +1461,11 @@ export class QueryBuilder {
         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 = 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 });
@@ -1946,9 +2012,9 @@ 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) {

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,7 @@ export interface Alias<T> {
     aliasName: string;
     entityName: EntityName<T>;
     meta: EntityMetadata<T>;
-    subQuery?: NativeQueryBuilder;
+    subQuery?: NativeQueryBuilder | RawQueryFragment;
 }
 export interface OnConflictClause<T> {
     fields: string[] | Raw;

package/query/QueryBuilderHelper.js

@@ -1,6 +1,5 @@
 import { ALIAS_REPLACEMENT, ALIAS_REPLACEMENT_RE, ArrayType, inspect, isRaw, LockMode, OptimisticLockError, QueryOperator, QueryOrderNumeric, raw, Raw, QueryHelper, ReferenceKind, Utils, ValidationError, } from '@mikro-orm/core';
 import { JoinType, QueryType } from './enums.js';
-import { NativeQueryBuilder } from './NativeQueryBuilder.js';
 /**
  * @internal
  */
@@ -521,8 +520,8 @@ 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 || value[op] instanceof NativeQueryBuilder) {
-            const query = value[op] instanceof NativeQueryBuilder ? value[op].toRaw() : value[op];
+        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;
             if (['$in', '$nin'].includes(op)) {

package/query/ScalarCriteriaNode.js

@@ -22,7 +22,7 @@ export class ScalarCriteriaNode extends CriteriaNode {
             }
         }
         if (this.payload instanceof QueryBuilder) {
-            return this.payload.getNativeQuery().toRaw();
+            return this.payload.toRaw();
         }
         if (this.payload && typeof this.payload === 'object') {
             const keys = Object.keys(this.payload).filter(key => ARRAY_OPERATORS.includes(key) && Array.isArray(this.payload[key]));