@mikro-orm/knex 7.0.0-dev.8 → 7.0.0-dev.80

package/query/QueryBuilder.js

@@ -179,10 +179,10 @@ export class QueryBuilder {
             subquery = this.platform.formatQuery(rawFragment.sql, rawFragment.params);
             field = field[0];
         }
-        const prop = this.joinReference(field, alias, cond, type, path, schema, subquery);
+        const { prop, key } = this.joinReference(field, alias, cond, type, path, schema, subquery);
         const [fromAlias] = this.helper.splitField(field);
         if (subquery) {
-            this._joins[`${fromAlias}.${prop.name}#${alias}`].subquery = subquery;
+            this._joins[key].subquery = subquery;
         }
         const populate = this._joinedProps.get(fromAlias);
         const item = { field: prop.name, strategy: LoadStrategy.JOINED, children: [] };
@@ -240,9 +240,12 @@ export class QueryBuilder {
             }
         }
         prop.targetMeta.props
-            .filter(prop => explicitFields
-            ? explicitFields.includes(prop.name) || explicitFields.includes(`${alias}.${prop.name}`) || prop.primary
-            : this.platform.shouldHaveColumn(prop, populate))
+            .filter(prop => {
+            if (!explicitFields) {
+                return this.platform.shouldHaveColumn(prop, populate);
+            }
+            return prop.primary && !explicitFields.includes(prop.name) && !explicitFields.includes(`${alias}.${prop.name}`);
+        })
             .forEach(prop => fields.push(...this.driver.mapPropToFieldNames(this, prop, alias)));
         return fields;
     }
@@ -250,7 +253,7 @@ export class QueryBuilder {
      * Apply filters to the QB where condition.
      */
     async applyFilters(filterOptions = {}) {
-        /* v8 ignore next 3 */
+        /* v8 ignore next */
         if (!this.em) {
             throw new Error('Cannot apply filters, this QueryBuilder is not attached to an EntityManager');
         }
@@ -267,16 +270,23 @@ export class QueryBuilder {
     /**
      * @internal
      */
-    async applyJoinedFilters(em, filterOptions = {}) {
+    async applyJoinedFilters(em, filterOptions) {
         for (const path of this.autoJoinedPaths) {
             const join = this.getJoinForPath(path);
             if (join.type === JoinType.pivotJoin) {
                 continue;
             }
+            filterOptions = QueryHelper.mergePropertyFilters(join.prop.filters, filterOptions);
             const cond = await em.applyFilters(join.prop.type, join.cond, filterOptions, 'read');
             if (Utils.hasObjectKeys(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'].includes(k)))) {
+                        delete cond[key];
+                    }
+                }
                 if (Utils.hasObjectKeys(join.cond)) {
-                    /* istanbul ignore next */
+                    /* v8 ignore next */
                     join.cond = { $and: [join.cond, cond] };
                 }
                 else {
@@ -303,7 +313,7 @@ export class QueryBuilder {
             cond = { [raw(`(${sql})`)]: Utils.asArray(params) };
             operator ??= '$and';
         }
-        else if (Utils.isString(cond)) {
+        else if (typeof cond === 'string') {
             cond = { [raw(`(${cond})`, Utils.asArray(params))]: [] };
             operator ??= '$and';
         }
@@ -350,8 +360,16 @@ export class QueryBuilder {
         return this.where(cond, params, '$or');
     }
     orderBy(orderBy) {
+        return this.processOrderBy(orderBy, true);
+    }
+    andOrderBy(orderBy) {
+        return this.processOrderBy(orderBy, false);
+    }
+    processOrderBy(orderBy, reset = true) {
         this.ensureNotFinalized();
-        this._orderBy = [];
+        if (reset) {
+            this._orderBy = [];
+        }
         Utils.asArray(orderBy).forEach(o => {
             const processed = QueryHelper.processWhere({
                 where: o,
@@ -363,7 +381,7 @@ export class QueryBuilder {
                 convertCustomTypes: false,
                 type: 'orderBy',
             });
-            this._orderBy.push(CriteriaNodeFactory.createNode(this.metadata, this.mainAlias.entityName, processed).process(this, { matchPopulateJoins: true }));
+            this._orderBy.push(CriteriaNodeFactory.createNode(this.metadata, this.mainAlias.entityName, processed).process(this, { matchPopulateJoins: true, type: 'orderBy' }));
         });
         return this;
     }
@@ -374,7 +392,7 @@ export class QueryBuilder {
     }
     having(cond = {}, params, operator) {
         this.ensureNotFinalized();
-        if (Utils.isString(cond)) {
+        if (typeof cond === 'string') {
             cond = { [raw(`(${cond})`, params)]: [] };
         }
         cond = CriteriaNodeFactory.createNode(this.metadata, this.mainAlias.entityName, cond).process(this);
@@ -459,7 +477,7 @@ export class QueryBuilder {
     }
     setLockMode(mode, tables) {
         this.ensureNotFinalized();
-        if (mode != null && mode !== LockMode.OPTIMISTIC && !this.context) {
+        if (mode != null && ![LockMode.OPTIMISTIC, LockMode.NONE].includes(mode) && !this.context) {
             throw ValidationError.transactionRequired();
         }
         this.lockMode = mode;
@@ -553,7 +571,7 @@ export class QueryBuilder {
         Utils.runIfNotEmpty(() => qb.hintComment(this._hintComments), this._hintComments);
         Utils.runIfNotEmpty(() => this.helper.appendOnConflictClause(QueryType.UPSERT, this._onConflict, qb), this._onConflict);
         if (this.lockMode) {
-            this.helper.getLockSQL(qb, this.lockMode, this.lockTables);
+            this.helper.getLockSQL(qb, this.lockMode, this.lockTables, this._joins);
         }
         this.helper.finalize(this.type, qb, this.mainAlias.metadata, this._data, this._returning);
         this.clearRawFragmentsCache();
@@ -667,7 +685,7 @@ export class QueryBuilder {
         options.mapResults ??= true;
         const isRunType = [QueryType.INSERT, QueryType.UPDATE, QueryType.DELETE, QueryType.TRUNCATE].includes(this.type);
         method ??= isRunType ? 'run' : 'all';
-        if (!this.connectionType && isRunType) {
+        if (!this.connectionType && (isRunType || this.context)) {
             this.connectionType = 'write';
         }
         if (!this.finalized && method === 'get' && this.type === QueryType.SELECT) {
@@ -675,13 +693,11 @@ export class QueryBuilder {
         }
         const query = this.toQuery();
         const cached = await this.em?.tryCache(this.mainAlias.entityName, this._cache, ['qb.execute', query.sql, query.params, method]);
-        if (cached?.data) {
+        if (cached?.data !== undefined) {
             return cached.data;
         }
-        const write = method === 'run' || !this.platform.getConfig().get('preferReadReplicas');
-        const type = this.connectionType || (write ? 'write' : 'read');
         const loggerContext = { id: this.em?.id, ...this.loggerContext };
-        const res = await this.driver.getConnection(type).execute(query.sql, query.params, method, this.context, loggerContext);
+        const res = await this.getConnection().execute(query.sql, query.params, method, this.context, loggerContext);
         const meta = this.mainAlias.metadata;
         if (!options.mapResults || !meta) {
             await this.em?.storeCache(this._cache, cached, res);
@@ -709,6 +725,64 @@ export class QueryBuilder {
         await this.em?.storeCache(this._cache, cached, mapped);
         return mapped;
     }
+    getConnection() {
+        const write = !this.platform.getConfig().get('preferReadReplicas');
+        const type = this.connectionType || (write ? 'write' : 'read');
+        return this.driver.getConnection(type);
+    }
+    /**
+     * Executes the query and returns an async iterable (async generator) that yields results one by one.
+     * By default, the results are merged and mapped to entity instances, without adding them to the identity map.
+     * You can disable merging and mapping by passing the options `{ mergeResults: false, mapResults: false }`.
+     * This is useful for processing large datasets without loading everything into memory at once.
+     *
+     * ```ts
+     * const qb = em.createQueryBuilder(Book, 'b');
+     * qb.select('*').where({ title: '1984' }).leftJoinAndSelect('b.author', 'a');
+     *
+     * for await (const book of qb.stream()) {
+     *   // book is an instance of Book entity
+     *   console.log(book.title, book.author.name);
+     * }
+     * ```
+     */
+    async *stream(options) {
+        options ??= {};
+        options.mergeResults ??= true;
+        options.mapResults ??= true;
+        const query = this.toQuery();
+        const loggerContext = { id: this.em?.id, ...this.loggerContext };
+        const res = this.getConnection().stream(query.sql, query.params, this.context, loggerContext);
+        const meta = this.mainAlias.metadata;
+        if (options.rawResults || !meta) {
+            yield* res;
+            return;
+        }
+        const joinedProps = this.driver.joinedProps(meta, this._populate);
+        const stack = [];
+        const hash = (data) => {
+            return Utils.getPrimaryKeyHash(meta.primaryKeys.map(pk => data[pk]));
+        };
+        for await (const row of res) {
+            const mapped = this.driver.mapResult(row, meta, this._populate, this);
+            if (!options.mergeResults || joinedProps.length === 0) {
+                yield this.mapResult(mapped, options.mapResults);
+                continue;
+            }
+            if (stack.length > 0 && hash(stack[stack.length - 1]) !== hash(mapped)) {
+                const res = this.driver.mergeJoinedResult(stack, this.mainAlias.metadata, joinedProps);
+                for (const row of res) {
+                    yield this.mapResult(row, options.mapResults);
+                }
+                stack.length = 0;
+            }
+            stack.push(mapped);
+        }
+        if (stack.length > 0) {
+            const merged = this.driver.mergeJoinedResult(stack, this.mainAlias.metadata, joinedProps);
+            yield this.mapResult(merged[0], options.mapResults);
+        }
+    }
     /**
      * Alias for `qb.getResultList()`
      */
@@ -716,29 +790,40 @@ export class QueryBuilder {
         return this.getResultList();
     }
     /**
-     * Executes the query, returning array of results
+     * Executes the query, returning array of results mapped to entity instances.
      */
     async getResultList(limit) {
         await this.em.tryFlush(this.mainAlias.entityName, { flushMode: this.flushMode });
         const res = await this.execute('all', true);
-        const entities = [];
-        function propagatePopulateHint(entity, hint) {
-            helper(entity).__serializationContext.populate = hint.concat(helper(entity).__serializationContext.populate ?? []);
-            hint.forEach(hint => {
-                const [propName] = hint.field.split(':', 2);
-                const value = Reference.unwrapReference(entity[propName]);
-                if (Utils.isEntity(value)) {
-                    propagatePopulateHint(value, hint.children ?? []);
-                }
-                else if (Utils.isCollection(value)) {
-                    value.populated();
-                    value.getItems(false).forEach(item => propagatePopulateHint(item, hint.children ?? []));
-                }
-            });
+        return this.mapResults(res, limit);
+    }
+    propagatePopulateHint(entity, hint) {
+        helper(entity).__serializationContext.populate = hint.concat(helper(entity).__serializationContext.populate ?? []);
+        hint.forEach(hint => {
+            const [propName] = hint.field.split(':', 2);
+            const value = Reference.unwrapReference(entity[propName]);
+            if (Utils.isEntity(value)) {
+                this.propagatePopulateHint(value, hint.children ?? []);
+            }
+            else if (Utils.isCollection(value)) {
+                value.populated();
+                value.getItems(false).forEach(item => this.propagatePopulateHint(item, hint.children ?? []));
+            }
+        });
+    }
+    mapResult(row, map = true) {
+        if (!map) {
+            return row;
         }
-        for (const r of res) {
-            const entity = this.em.map(this.mainAlias.entityName, r, { schema: this._schema });
-            propagatePopulateHint(entity, this._populate);
+        const entity = this.em.map(this.mainAlias.entityName, row, { schema: this._schema });
+        this.propagatePopulateHint(entity, this._populate);
+        return entity;
+    }
+    mapResults(res, limit) {
+        const entities = [];
+        for (const row of res) {
+            const entity = this.mapResult(row);
+            this.propagatePopulateHint(entity, this._populate);
             entities.push(entity);
             if (limit != null && --limit === 0) {
                 break;
@@ -818,7 +903,7 @@ export class QueryBuilder {
             qb[prop] = properties.includes(prop) ? Utils.copy(this[prop]) : this[prop];
         }
         delete RawQueryFragment.cloneRegistry;
-        /* v8 ignore next 3 */
+        /* v8 ignore next */
         if (this._fields && !reset.includes('_fields')) {
             qb._fields = [...this._fields];
         }
@@ -873,7 +958,8 @@ export class QueryBuilder {
             if (field instanceof RawQueryFragment) {
                 field = this.platform.formatQuery(field.sql, field.params);
             }
-            this._joins[`${this.alias}.${prop.name}#${alias}`] = {
+            const key = `${this.alias}.${prop.name}#${alias}`;
+            this._joins[key] = {
                 prop,
                 alias,
                 type,
@@ -882,7 +968,7 @@ export class QueryBuilder {
                 subquery: field.toString(),
                 ownerAlias: this.alias,
             };
-            return prop;
+            return { prop, key };
         }
         if (!subquery && type.includes('lateral')) {
             throw new Error(`Lateral join can be used only with a sub-query.`);
@@ -907,10 +993,13 @@ export class QueryBuilder {
             aliasMap: this.getAliasMap(),
             aliased: [QueryType.SELECT, QueryType.COUNT].includes(this.type),
         });
+        const criteriaNode = CriteriaNodeFactory.createNode(this.metadata, prop.targetMeta.className, 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 ?? 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;
         }
         else if (prop.kind === ReferenceKind.MANY_TO_MANY) {
             let pivotAlias = alias;
@@ -922,17 +1011,18 @@ export class QueryBuilder {
             const joins = this.helper.joinManyToManyReference(prop, fromAlias, alias, pivotAlias, type, cond, path, schema);
             Object.assign(this._joins, joins);
             this.createAlias(prop.pivotEntity, pivotAlias);
+            this._joins[aliasedName].path ??= path;
+            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].path ??= path;
         }
         else { // MANY_TO_ONE
             this._joins[aliasedName] = this.helper.joinManyToOneReference(prop, fromAlias, alias, type, cond, schema);
+            this._joins[aliasedName].path ??= path;
         }
-        if (!this._joins[aliasedName].path && path) {
-            this._joins[aliasedName].path = path;
-        }
-        return prop;
+        return { prop, key: aliasedName };
     }
     prepareFields(fields, type = 'where') {
         const ret = [];
@@ -945,7 +1035,7 @@ export class QueryBuilder {
                 ret.push(rawField);
                 return;
             }
-            if (!Utils.isString(field)) {
+            if (typeof field !== 'string') {
                 ret.push(field);
                 return;
             }
@@ -956,7 +1046,7 @@ export class QueryBuilder {
             }
             const [a, f] = this.helper.splitField(field);
             const prop = this.helper.getProperty(f, a);
-            /* v8 ignore next 3 */
+            /* v8 ignore next */
             if (prop && [ReferenceKind.ONE_TO_MANY, ReferenceKind.MANY_TO_MANY].includes(prop.kind)) {
                 return;
             }
@@ -1107,6 +1197,7 @@ export class QueryBuilder {
         const meta = this.mainAlias.metadata;
         this.applyDiscriminatorCondition();
         this.processPopulateHint();
+        this.processNestedJoins();
         if (meta && (this._fields?.includes('*') || this._fields?.includes(`${this.mainAlias.aliasName}.*`))) {
             meta.props
                 .filter(prop => prop.formula && (!prop.lazy || this.flags.has(QueryFlag.INCLUDE_LAZY_FORMULAS)))
@@ -1130,7 +1221,7 @@ export class QueryBuilder {
         if (!this.flags.has(QueryFlag.DISABLE_PAGINATE) && this._groupBy.length === 0 && this.hasToManyJoins()) {
             this.flags.add(QueryFlag.PAGINATE);
         }
-        if (meta && this.flags.has(QueryFlag.PAGINATE) && (this._limit > 0 || this._offset > 0)) {
+        if (meta && 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))) {
@@ -1166,6 +1257,7 @@ export class QueryBuilder {
                 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._populateMap[aliasedName] = this._joins[aliasedName].alias;
+                this.createAlias(prop.type, alias);
             }
         });
         this.processPopulateWhere(false);
@@ -1185,7 +1277,7 @@ export class QueryBuilder {
         if (typeof this[key] === 'object') {
             const cond = CriteriaNodeFactory
                 .createNode(this.metadata, this.mainAlias.entityName, this[key])
-                .process(this, { matchPopulateJoins: true, ignoreBranching: true, preferNoBranch: true });
+                .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);
@@ -1226,10 +1318,42 @@ export class QueryBuilder {
             }
         }
     }
+    /**
+     * When adding an inner join on a left joined relation, we need to nest them,
+     * otherwise the inner join could discard rows of the root table.
+     */
+    processNestedJoins() {
+        if (this.flags.has(QueryFlag.DISABLE_NESTED_INNER_JOIN)) {
+            return;
+        }
+        const joins = Object.values(this._joins);
+        const lookupParentGroup = (j) => {
+            return j.nested ?? (j.parent ? lookupParentGroup(j.parent) : undefined);
+        };
+        for (const join of joins) {
+            if (join.type === JoinType.innerJoin) {
+                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;
+                    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;
+                    nested.add(join);
+                }
+            }
+        }
+    }
     hasToManyJoins() {
-        // console.log(this._joins);
         return Object.values(this._joins).some(join => {
-            // console.log(join.prop.name, join.prop.kind, [ReferenceKind.ONE_TO_MANY, ReferenceKind.MANY_TO_MANY].includes(join.prop.kind));
             return [ReferenceKind.ONE_TO_MANY, ReferenceKind.MANY_TO_MANY].includes(join.prop.kind);
         });
     }
@@ -1284,7 +1408,7 @@ export class QueryBuilder {
                     }
                     return false;
                 });
-                /* v8 ignore next 3 */
+                /* v8 ignore next */
                 if (field instanceof RawQueryFragment) {
                     innerQuery.select(field);
                 }
@@ -1393,7 +1517,7 @@ export class QueryBuilder {
         return new QueryBuilderHelper(this.mainAlias.entityName, this.mainAlias.aliasName, this._aliases, this.subQueries, this.driver);
     }
     ensureFromClause() {
-        /* v8 ignore next 3 */
+        /* v8 ignore next */
         if (!this._mainAlias) {
             throw new Error(`Cannot proceed to build a query because the main alias is not set.`);
         }
@@ -1403,8 +1527,8 @@ export class QueryBuilder {
             throw new Error('This QueryBuilder instance is already finalized, clone it first if you want to modify it.');
         }
     }
-    /* v8 ignore start */
     /** @ignore */
+    /* v8 ignore next */
     [inspect.custom](depth = 2) {
         const object = { ...this };
         const hidden = ['metadata', 'driver', 'context', 'platform', 'type'];

package/query/QueryBuilderHelper.d.ts

@@ -49,7 +49,7 @@ export declare class QueryBuilderHelper {
     getQueryOrderFromObject(type: QueryType, orderBy: FlatQueryOrderMap, populate: Dictionary<string>): string[];
     finalize(type: QueryType, qb: NativeQueryBuilder, meta?: EntityMetadata, data?: Dictionary, returning?: Field<any>[]): void;
     splitField<T>(field: EntityKey<T>, greedyAlias?: boolean): [string, EntityKey<T>, string | undefined];
-    getLockSQL(qb: NativeQueryBuilder, lockMode: LockMode, lockTables?: string[]): void;
+    getLockSQL(qb: NativeQueryBuilder, lockMode: LockMode, lockTables?: string[], joinsMap?: Dictionary<JoinOptions>): void;
     updateVersionProperty(qb: NativeQueryBuilder, data: Dictionary): void;
     private prefix;
     private appendGroupCondition;

package/query/QueryBuilderHelper.js

@@ -26,7 +26,7 @@ export class QueryBuilderHelper {
         if (isRaw(field)) {
             return raw(field.sql, field.params);
         }
-        /* v8 ignore next 3 */
+        /* v8 ignore next */
         if (typeof field !== 'string') {
             return field;
         }
@@ -75,10 +75,10 @@ export class QueryBuilderHelper {
         if (prop?.name === a && prop.embeddedProps[f]) {
             return aliasPrefix + prop.fieldNames[fkIdx];
         }
-        if (prop?.embedded && a === prop.embedded[0]) {
+        if (a === prop?.embedded?.[0]) {
             return aliasPrefix + prop.fieldNames[fkIdx];
         }
-        const noPrefix = prop && prop.persist === false;
+        const noPrefix = prop?.persist === false;
         if (prop?.fieldNameRaw) {
             return raw(this.prefix(field, isTableNameAliasRequired));
         }
@@ -358,7 +358,7 @@ export class QueryBuilderHelper {
             return;
         }
         parts.push(operator === '$or' ? `(${res.sql})` : res.sql);
-        params.push(...res.params);
+        res.params.forEach(p => params.push(p));
     }
     appendQuerySubCondition(type, cond, key) {
         const parts = [];
@@ -420,7 +420,7 @@ export class QueryBuilderHelper {
         }
         // operators
         const op = Object.keys(QueryOperator).find(op => op in value);
-        /* v8 ignore next 3 */
+        /* v8 ignore next */
         if (!op) {
             throw new Error(`Invalid query condition: ${inspect(cond, { depth: 5 })}`);
         }
@@ -456,7 +456,7 @@ export class QueryBuilderHelper {
         const [a, f] = this.splitField(key);
         const prop = this.getProperty(f, a);
         if (op === '$fulltext') {
-            /* v8 ignore next 3 */
+            /* v8 ignore next */
             if (!prop) {
                 throw new Error(`Cannot use $fulltext operator on ${key}, property not found`);
             }
@@ -502,7 +502,7 @@ export class QueryBuilderHelper {
                 params.push(item);
             }
             else {
-                params.push(...value);
+                value.forEach(v => params.push(v));
             }
             return `(${value.map(() => '?').join(', ')})`;
         }
@@ -539,7 +539,7 @@ export class QueryBuilderHelper {
         const ret = [];
         for (const key of Object.keys(orderBy)) {
             const direction = orderBy[key];
-            const order = Utils.isNumber(direction) ? QueryOrderNumeric[direction] : direction;
+            const order = typeof direction === 'number' ? QueryOrderNumeric[direction] : direction;
             const raw = RawQueryFragment.getKnownFragment(key);
             if (raw) {
                 ret.push(...this.platform.getOrderByExpression(this.platform.formatQuery(raw.sql, raw.params), order));
@@ -550,10 +550,10 @@ export class QueryBuilderHelper {
                 let [alias, field] = this.splitField(f, true);
                 alias = populate[alias] || alias;
                 const prop = this.getProperty(field, alias);
-                const noPrefix = (prop && prop.persist === false && !prop.formula && !prop.embedded) || RawQueryFragment.isKnownFragment(f);
+                const noPrefix = (prop?.persist === false && !prop.formula && !prop.embedded) || RawQueryFragment.isKnownFragment(f);
                 const column = this.mapper(noPrefix ? field : `${alias}.${field}`, type, undefined, null);
                 /* v8 ignore next */
-                const rawColumn = Utils.isString(column) ? 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)
@@ -622,11 +622,18 @@ export class QueryBuilderHelper {
         const fromField = parts.join('.');
         return [fromAlias, fromField, ref];
     }
-    getLockSQL(qb, lockMode, lockTables = []) {
+    getLockSQL(qb, lockMode, lockTables = [], joinsMap) {
         const meta = this.metadata.find(this.entityName);
         if (lockMode === LockMode.OPTIMISTIC && meta && !meta.versionProperty) {
             throw OptimisticLockError.lockFailed(this.entityName);
         }
+        if (lockMode !== LockMode.OPTIMISTIC && lockTables.length === 0 && joinsMap) {
+            const joins = Object.values(joinsMap);
+            const innerJoins = joins.filter(join => [JoinType.innerJoin, JoinType.innerJoinLateral, JoinType.nestedInnerJoin].includes(join.type));
+            if (joins.length > innerJoins.length) {
+                lockTables.push(this.alias, ...innerJoins.map(join => join.alias));
+            }
+        }
         qb.lockMode(lockMode, lockTables);
     }
     updateVersionProperty(qb, data) {

package/query/ScalarCriteriaNode.d.ts

@@ -1,10 +1,10 @@
 import { CriteriaNode } from './CriteriaNode.js';
-import type { IQueryBuilder, ICriteriaNodeProcessOptions } from '../typings.js';
+import type { ICriteriaNodeProcessOptions, IQueryBuilder } from '../typings.js';
 /**
  * @internal
  */
 export declare class ScalarCriteriaNode<T extends object> extends CriteriaNode<T> {
     process(qb: IQueryBuilder<T>, options?: ICriteriaNodeProcessOptions): any;
-    willAutoJoin<T>(qb: IQueryBuilder<T>, alias?: string, options?: ICriteriaNodeProcessOptions): boolean;
-    shouldJoin(): boolean;
+    willAutoJoin(qb: IQueryBuilder<T>, alias?: string, options?: ICriteriaNodeProcessOptions): boolean;
+    private shouldJoin;
 }

package/query/ScalarCriteriaNode.js

@@ -1,13 +1,15 @@
-import { ReferenceKind, Utils } from '@mikro-orm/core';
+import { ARRAY_OPERATORS, ReferenceKind } from '@mikro-orm/core';
 import { CriteriaNode } from './CriteriaNode.js';
-import { JoinType } from './enums.js';
+import { JoinType, QueryType } from './enums.js';
 import { QueryBuilder } from './QueryBuilder.js';
 /**
  * @internal
  */
 export class ScalarCriteriaNode extends CriteriaNode {
     process(qb, options) {
-        if (this.shouldJoin()) {
+        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, matchPopulateJoins });
+        if (this.shouldJoin(qb, nestedAlias)) {
             const path = this.getPath();
             const parentPath = this.parent.getPath(); // the parent is always there, otherwise `shouldJoin` would return `false`
             const nestedAlias = qb.getAliasForJoinPath(path) || qb.getNextAlias(this.prop?.pivotTable ?? this.entityName);
@@ -23,7 +25,7 @@ export class ScalarCriteriaNode extends CriteriaNode {
             return this.payload.getNativeQuery().toRaw();
         }
         if (this.payload && typeof this.payload === 'object') {
-            const keys = Object.keys(this.payload).filter(key => Utils.isArrayOperator(key) && Array.isArray(this.payload[key]));
+            const keys = Object.keys(this.payload).filter(key => ARRAY_OPERATORS.includes(key) && Array.isArray(this.payload[key]));
             for (const key of keys) {
                 this.payload[key] = JSON.stringify(this.payload[key]);
             }
@@ -31,10 +33,10 @@ export class ScalarCriteriaNode extends CriteriaNode {
         return this.payload;
     }
     willAutoJoin(qb, alias, options) {
-        return this.shouldJoin();
+        return this.shouldJoin(qb, alias);
     }
-    shouldJoin() {
-        if (!this.parent || !this.prop) {
+    shouldJoin(qb, nestedAlias) {
+        if (!this.parent || !this.prop || (nestedAlias && [QueryType.SELECT, QueryType.COUNT].includes(qb.type ?? QueryType.SELECT))) {
             return false;
         }
         switch (this.prop.kind) {

package/query/index.d.ts

@@ -7,3 +7,4 @@ export * from './ObjectCriteriaNode.js';
 export * from './ScalarCriteriaNode.js';
 export * from './CriteriaNodeFactory.js';
 export * from './NativeQueryBuilder.js';
+export * from './raw.js';

package/query/index.js

@@ -7,3 +7,4 @@ export * from './ObjectCriteriaNode.js';
 export * from './ScalarCriteriaNode.js';
 export * from './CriteriaNodeFactory.js';
 export * from './NativeQueryBuilder.js';
+export * from './raw.js';