@contember/engine-content-api 1.2.0-alpha.8 → 1.2.0-beta.1

package/src/mapper/select/WhereBuilder.ts

@@ -1,11 +1,17 @@
 import { isIt } from '../../utils'
-import { acceptFieldVisitor } from '@contember/schema-utils'
+import { acceptFieldVisitor, isColumn } from '@contember/schema-utils'
 import { Input, Model } from '@contember/schema'
 import { Path, PathFactory } from './Path'
 import { JoinBuilder } from './JoinBuilder'
 import { ConditionBuilder } from './ConditionBuilder'
-import { ConditionBuilder as SqlConditionBuilder, Operator, QueryBuilder, SelectBuilder } from '@contember/database'
-import { WhereOptimizer } from './optimizer/WhereOptimizer'
+import {
+	ConditionBuilder as SqlConditionBuilder,
+	Literal,
+	Operator,
+	QueryBuilder,
+	SelectBuilder, wrapIdentifier,
+} from '@contember/database'
+import { WhereOptimizationHints, WhereOptimizer } from './optimizer/WhereOptimizer'
 
 export class WhereBuilder {
 	constructor(
@@ -14,6 +20,7 @@ export class WhereBuilder {
 		private readonly conditionBuilder: ConditionBuilder,
 		private readonly pathFactory: PathFactory,
 		private readonly whereOptimizer: WhereOptimizer,
+		private readonly useExistsInHasManyFilter: boolean,
 	) {}
 
 	public build(
@@ -21,35 +28,62 @@ export class WhereBuilder {
 		entity: Model.Entity,
 		path: Path,
 		where: Input.OptionalWhere,
-		allowManyJoin: boolean = false,
+		optimizationHints: WhereOptimizationHints = {},
 	) {
-		return this.buildAdvanced(entity, path, where, cb => qb.where(clause => cb(clause)), allowManyJoin)
+		const optimizedWhere = this.whereOptimizer.optimize(where, entity, optimizationHints)
+		return this.buildInternal({
+			entity,
+			path,
+			where: optimizedWhere,
+			callback: cb => qb.where(clause => cb(clause)),
+			allowManyJoin: false,
+		})
 	}
 
+
 	public buildAdvanced(
 		entity: Model.Entity,
 		path: Path,
 		where: Input.OptionalWhere,
 		callback: (clauseCb: (clause: SqlConditionBuilder) => SqlConditionBuilder) => SelectBuilder<SelectBuilder.Result>,
-		allowManyJoin: boolean = false,
+		optimizationHints: WhereOptimizationHints = {},
+	) {
+		const optimizedWhere = this.whereOptimizer.optimize(where, entity, optimizationHints)
+		return this.buildInternal({
+			entity,
+			path,
+			where: optimizedWhere,
+			callback,
+			allowManyJoin: false,
+		})
+	}
+
+	private buildInternal({
+		callback,
+		...args
+	}: { entity: Model.Entity; path: Path; where: Input.OptionalWhere; callback: (clauseCb: (clause: SqlConditionBuilder) => SqlConditionBuilder) => SelectBuilder<SelectBuilder.Result>; allowManyJoin: boolean },
 	) {
-		const optimizedWhere = this.whereOptimizer.optimize(where, entity)
 		const joinList: WhereJoinDefinition[] = []
 
-		const qbWithWhere = callback(clause => this.buildInternal(clause, entity, path, optimizedWhere, allowManyJoin, joinList))
+		const qbWithWhere = callback(clause => this.buildRecursive({
+			conditionBuilder: clause,
+			joinList: joinList,
+			...args,
+		}))
 		return joinList.reduce<SelectBuilder<SelectBuilder.Result>>(
 			(qb, { path, entity, relationName }) => this.joinBuilder.join(qb, path, entity, relationName),
 			qbWithWhere,
 		)
 	}
 
-	private buildInternal(
-		conditionBuilder: SqlConditionBuilder,
-		entity: Model.Entity,
-		path: Path,
-		where: Input.Where,
-		allowManyJoin: boolean,
-		joinList: WhereJoinDefinition[],
+	private buildRecursive({
+		conditionBuilder,
+		entity,
+		path,
+		where,
+		joinList,
+		allowManyJoin,
+	}: { conditionBuilder: SqlConditionBuilder; entity: Model.Entity; path: Path; where: Input.OptionalWhere; joinList: WhereJoinDefinition[]; allowManyJoin: boolean },
 	): SqlConditionBuilder {
 		const tableName = path.alias
 
@@ -58,7 +92,14 @@ export class WhereBuilder {
 			conditionBuilder = conditionBuilder.and(clause =>
 				expr.reduce(
 					(clause2, where) =>
-						!where ? clause2 : this.buildInternal(clause2, entity, path, where, allowManyJoin, joinList),
+						!where ? clause2 : this.buildRecursive({
+							conditionBuilder: clause2,
+							entity,
+							path,
+							where,
+							joinList,
+							allowManyJoin,
+						}),
 					clause,
 				),
 			)
@@ -70,7 +111,14 @@ export class WhereBuilder {
 					(clause2, where) =>
 						!where
 							? clause2
-							: clause2.and(clause3 => this.buildInternal(clause3, entity, path, where, allowManyJoin, joinList)),
+							: clause2.and(clause3 => this.buildRecursive({
+								conditionBuilder: clause3,
+								entity,
+								path,
+								where,
+								joinList,
+								allowManyJoin,
+							})),
 					clause,
 				),
 			)
@@ -78,7 +126,14 @@ export class WhereBuilder {
 		if (where.not !== undefined) {
 			const expr = where.not
 			conditionBuilder = conditionBuilder.not(clause =>
-				this.buildInternal(clause, entity, path, expr, allowManyJoin, joinList),
+				this.buildRecursive({
+					conditionBuilder: clause,
+					entity,
+					path,
+					where: expr,
+					joinList,
+					allowManyJoin,
+				}),
 			)
 		}
 
@@ -87,12 +142,9 @@ export class WhereBuilder {
 				continue
 			}
 
-			const joinedWhere = (
-				entity: Model.Entity,
-				relation: Model.Relation,
-				targetEntity: Model.Entity,
-			): SqlConditionBuilder => {
-				const targetPath = path.for(fieldName)
+			const targetPath = path.for(fieldName)
+
+			const joinedWhere = ({ targetEntity, relation, entity }: Model.AnyRelationContext): SqlConditionBuilder => {
 				const relationWhere = where[fieldName] as Input.Where
 				if (Object.keys(relationWhere).length === 0) {
 					return conditionBuilder
@@ -112,36 +164,45 @@ export class WhereBuilder {
 
 				joinList.push({ path: targetPath, entity, relationName: relation.name })
 
-				return this.buildInternal(conditionBuilder, targetEntity, targetPath, relationWhere, allowManyJoin, joinList)
+				return this.buildRecursive({
+					conditionBuilder,
+					entity: targetEntity,
+					path: targetPath,
+					where: relationWhere,
+					joinList,
+					allowManyJoin,
+				})
 			}
 
 			conditionBuilder = acceptFieldVisitor<SqlConditionBuilder>(this.schema, entity, fieldName, {
-				visitColumn: (entity, column) => {
+				visitColumn: ({ entity, column }) => {
 					const subWhere: Input.Condition<Input.ColumnValue> = where[column.name] as Input.Condition<Input.ColumnValue>
 					return this.conditionBuilder.build(conditionBuilder, tableName, column.columnName, column.columnType, subWhere)
 				},
 				visitOneHasOneInverse: joinedWhere,
 				visitOneHasOneOwning: joinedWhere,
 				visitManyHasOne: joinedWhere,
-				visitManyHasManyInverse: (entity, relation, targetEntity, targetRelation) => {
-					if (allowManyJoin) {
-						return joinedWhere(entity, relation, targetEntity)
+				visitManyHasManyInverse: context => {
+					if (allowManyJoin && !this.useExistsInHasManyFilter) {
+						return joinedWhere(context)
 					}
+
 					const relationWhere = where[fieldName] as Input.Where
 
 					return conditionBuilder.exists(
 						this.createManyHasManySubquery(
 							[tableName, entity.primaryColumn],
 							relationWhere,
-							targetEntity,
-							targetRelation.joiningTable,
+							context.targetEntity,
+							context.targetRelation.joiningTable,
 							'inverse',
+							targetPath,
 						),
 					)
 				},
-				visitManyHasManyOwning: (entity, relation, targetEntity) => {
-					if (allowManyJoin) {
-						return joinedWhere(entity, relation, targetEntity)
+				visitManyHasManyOwning: context => {
+					if (allowManyJoin && !this.useExistsInHasManyFilter) {
+						return joinedWhere(context)
 					}
 
 					const relationWhere = where[fieldName] as Input.Where
@@ -150,30 +211,40 @@ export class WhereBuilder {
 						this.createManyHasManySubquery(
 							[tableName, entity.primaryColumn],
 							relationWhere,
-							targetEntity,
-							relation.joiningTable,
+							context.targetEntity,
+							context.relation.joiningTable,
 							'owning',
+							targetPath,
 						),
 					)
 				},
-				visitOneHasMany: (entity, relation, targetEntity, targetRelation) => {
-					if (allowManyJoin) {
-						return joinedWhere(entity, relation, targetEntity)
+				visitOneHasMany: context => {
+					if (allowManyJoin && !this.useExistsInHasManyFilter) {
+						return joinedWhere(context)
 					}
 
 					const relationWhere = where[fieldName] as Input.Where
 
+					const qb = this.hasRootIsNull(relationWhere, context.targetEntity)
+						? SelectBuilder.create()
+							.select(it => it.raw('1'))
+							.from(new Literal(`(select ${wrapIdentifier(tableName)}.${wrapIdentifier(entity.primaryColumn)})`), targetPath.for('tmp_').alias)
+							.leftJoin(context.targetEntity.tableName, targetPath.alias, it =>
+								it.columnsEq([targetPath.for('tmp_').alias, entity.primaryColumn], [targetPath.alias, context.targetRelation.joiningColumn.columnName]),
+							)
+						: SelectBuilder.create()
+							.select(it => it.raw('1'))
+							.from(context.targetEntity.tableName, targetPath.alias)
+							.where(it => it.columnsEq([tableName, entity.primaryColumn], [targetPath.alias, context.targetRelation.joiningColumn.columnName]))
+
 					return conditionBuilder.exists(
-						this.build(
-							SelectBuilder.create()
-								.select(it => it.raw('1'))
-								.from(targetEntity.tableName, 'sub_')
-								.where(it => it.columnsEq([tableName, entity.primaryColumn], ['sub_', targetRelation.joiningColumn.columnName])),
-							targetEntity,
-							this.pathFactory.create([], 'sub_'),
-							relationWhere,
-							true,
-						),
+						this.buildInternal({
+							entity: context.targetEntity,
+							path: targetPath,
+							where: relationWhere,
+							callback: cb => qb.where(clause => cb(clause)),
+							allowManyJoin: true,
+						}),
 					)
 				},
 			})
@@ -181,19 +252,22 @@ export class WhereBuilder {
 		return conditionBuilder
 	}
 
+
 	private createManyHasManySubquery(
 		outerColumn: QueryBuilder.ColumnIdentifier,
 		relationWhere: Input.Where,
 		targetEntity: Model.Entity,
 		joiningTable: Model.JoiningTable,
 		fromSide: 'owning' | 'inverse',
+		path: Path,
 	) {
 		const fromColumn = fromSide === 'owning' ? joiningTable.joiningColumn.columnName : joiningTable.inverseJoiningColumn.columnName
 		const toColumn = fromSide === 'owning' ? joiningTable.inverseJoiningColumn.columnName : joiningTable.joiningColumn.columnName
+		const junctionPath = path.for('junction_')
 		const qb = SelectBuilder.create<SelectBuilder.Result>()
-			.from(joiningTable.tableName, 'junction_')
+			.from(joiningTable.tableName, junctionPath.alias)
 			.select(it => it.raw('1'))
-			.where(it => it.columnsEq(outerColumn, ['junction_', fromColumn]))
+			.where(it => it.columnsEq(outerColumn, [junctionPath.alias, fromColumn]))
 
 		const primaryCondition = this.transformWhereToPrimaryCondition(relationWhere, targetEntity.primary)
 		if (primaryCondition !== null) {
@@ -201,20 +275,20 @@ export class WhereBuilder {
 			const columnType = (targetEntity.fields[targetEntity.primary] as Model.AnyColumn).columnType
 
 			return qb.where(condition =>
-				this.conditionBuilder.build(condition, 'junction_', toColumn, columnType, primaryCondition),
+				this.conditionBuilder.build(condition, junctionPath.alias, toColumn, columnType, primaryCondition),
 			)
 		}
 
-		const qbJoined = qb.join(targetEntity.tableName, 'sub_', clause =>
-			clause.compareColumns(['junction_', toColumn], Operator.eq, ['sub_', targetEntity.primary]),
-		)
-		return this.buildAdvanced(
-			targetEntity,
-			this.pathFactory.create([], 'sub_'),
-			relationWhere,
-			cb => qbJoined.where(clause => cb(clause)),
-			true,
+		const qbJoined = qb.join(targetEntity.tableName, path.alias, clause =>
+			clause.compareColumns([junctionPath.alias, toColumn], Operator.eq, [path.alias, targetEntity.primary]),
 		)
+		return this.buildInternal({
+			entity: targetEntity,
+			path: this.pathFactory.create([], path.fullAlias),
+			where: relationWhere,
+			callback: cb => qbJoined.where(clause => cb(clause)),
+			allowManyJoin: true,
+		})
 	}
 
 	private transformWhereToPrimaryCondition(where: Input.Where, primaryField: string): Input.Condition<never> | null {
@@ -260,6 +334,39 @@ export class WhereBuilder {
 		}
 		return condition
 	}
+
+	private hasRootIsNull(where: Input.Where, entity: Model.Entity): boolean {
+		for (const key in where) {
+			if (key === 'and' || key === 'or') {
+				if (where[key]?.some(it => this.hasRootIsNull(it, entity))) {
+					return true
+				}
+			} else if (key === 'not') {
+				if (where.not && this.hasRootIsNull(where.not, entity)) {
+					return true
+				}
+			} else if (isColumn(entity.fields[key]) && this.conditionHasIsNull(where[key] as Input.Condition)) {
+				return true
+			}
+		}
+		return false
+	}
+
+	private conditionHasIsNull(cond: Input.Condition): boolean {
+		if (cond.isNull !== undefined) {
+			return true
+		}
+		if (cond.and && cond.and.some(it => this.conditionHasIsNull(it))) {
+			return true
+		}
+		if (cond.or && cond.or.some(it => this.conditionHasIsNull(it))) {
+			return true
+		}
+		if (cond.not && this.conditionHasIsNull(cond.not)) {
+			return true
+		}
+		return false
+	}
 }
 
 export type WhereJoinDefinition = { path: Path; entity: Model.Entity; relationName: string }

package/src/mapper/select/handlers/FieldsVisitor.ts

@@ -13,132 +13,87 @@ export class FieldsVisitor implements Model.RelationByTypeVisitor<void>, Model.C
 		private readonly whereBuilder: WhereBuilder,
 		private readonly mapper: Mapper,
 		private readonly executionContext: SelectExecutionHandlerContext,
+		private readonly relationPath: Model.AnyRelationContext[],
 	) {}
 
-	visitColumn(entity: Model.Entity, column: Model.AnyColumn): void {
+	visitColumn({ entity, column }: Model.ColumnContext): void {
 		const columnPath = this.executionContext.path
-		this.executionContext.addColumn(qb => {
-			const tableAlias = columnPath.back().alias
-			const columnAlias = columnPath.alias
+		const tableAlias = columnPath.back().alias
+		const columnAlias = columnPath.alias
 
-			const fieldPredicate = this.predicateFactory.shouldApplyCellLevelPredicate(
-				entity,
-				Acl.Operation.read,
-				column.name,
-			)
-				? this.predicateFactory.create(entity, Acl.Operation.read, [column.name])
-				: undefined
-
-			if (!fieldPredicate || Object.keys(fieldPredicate).length === 0) {
-				return qb.select([tableAlias, column.columnName], columnAlias)
-			}
-			return this.whereBuilder.buildAdvanced(entity, columnPath.back(), fieldPredicate, cb =>
-				qb.select(
-					expr =>
-						expr.case(caseExpr =>
-							caseExpr
-								.when(
-									whenExpr => whenExpr.selectCondition(cb),
-									thenExpr => thenExpr.select([tableAlias, column.columnName]),
-								)
-								.else(elseExpr => elseExpr.raw('null')),
-						),
-					columnAlias,
-				),
-			)
+		this.executionContext.addColumn({
+			query: qb => qb.select([tableAlias, column.columnName], columnAlias),
+			predicate: this.getRequiredPredicate(entity, column),
 		})
 	}
 
-	public visitManyHasManyInverse(
-		entity: Model.Entity,
-		relation: Model.ManyHasManyInverseRelation,
-		targetEntity: Model.Entity,
-		targetRelation: Model.ManyHasManyOwningRelation,
-	): void {
+	public visitManyHasManyInverse(relationContext: Model.ManyHasManyInverseContext): void {
 		const field = this.executionContext.objectNode
 		if (!field) {
 			throw new Error()
 		}
-		this.executionContext.addData(
-			entity.primary,
-			async ids =>
-				this.relationFetcher.fetchManyHasManyGroups(
-					{
-						mapper: this.mapper,
-						field: field,
-						targetEntity: targetEntity,
-						sourceRelation: relation,
-						targetRelation,
-						directionFrom: 'inverse',
-						ids: ids,
-					},
-				),
-			[],
-		)
+		this.executionContext.addData({
+			field: relationContext.entity.primary,
+			dataProvider: async ids =>
+				this.relationFetcher.fetchManyHasManyGroups({
+					mapper: this.mapper,
+					field: field,
+					relationContext,
+					relationPath: this.relationPath,
+					ids: ids,
+				}),
+			defaultValue: [],
+			predicate: this.getRequiredPredicate(relationContext.entity, relationContext.relation),
+		})
 	}
 
-	public visitManyHasManyOwning(
-		entity: Model.Entity,
-		relation: Model.ManyHasManyOwningRelation,
-		targetEntity: Model.Entity,
-		targetRelation: Model.ManyHasManyInverseRelation | null,
-	): void {
+	public visitManyHasManyOwning(relationContext: Model.ManyHasManyOwningContext): void {
 		const field = this.executionContext.objectNode
 		if (!field) {
 			throw new Error()
 		}
 
-		this.executionContext.addData(
-			entity.primary,
-			async ids =>
+		this.executionContext.addData({
+			field: relationContext.entity.primary,
+			dataProvider: async ids =>
 				this.relationFetcher.fetchManyHasManyGroups({
 					mapper: this.mapper,
 					field: field,
-					targetEntity: targetEntity,
-					sourceRelation: relation,
-					targetRelation,
-					directionFrom: 'owning',
+					relationContext,
+					relationPath: this.relationPath,
 					ids: ids,
 				}),
-			[],
-		)
+			defaultValue: [],
+			predicate: this.getRequiredPredicate(relationContext.entity, relationContext.relation),
+		})
 	}
 
-	public visitOneHasMany(
-		entity: Model.Entity,
-		relation: Model.OneHasManyRelation,
-		targetEntity: Model.Entity,
-		targetRelation: Model.ManyHasOneRelation,
-	): void {
+	public visitOneHasMany(relationContext: Model.OneHasManyContext): void {
 		const field = this.executionContext.objectNode
 		if (!field) {
 			throw new Error()
 		}
 
-		this.executionContext.addData(
-			entity.primary,
-			async ids =>
+		this.executionContext.addData({
+			field: relationContext.entity.primary,
+			dataProvider: async ids =>
 				this.relationFetcher.fetchOneHasManyGroups({
 					mapper: this.mapper,
 					objectNode: field,
-					targetEntity: targetEntity,
-					relation: relation,
-					targetRelation: targetRelation,
+					relationContext,
+					relationPath: this.relationPath,
 					ids: ids,
 				}),
-			[],
-		)
+			defaultValue: [],
+			predicate: this.getRequiredPredicate(relationContext.entity, relationContext.relation),
+		})
 	}
 
-	public visitOneHasOneInverse(
-		entity: Model.Entity,
-		relation: Model.OneHasOneInverseRelation,
-		targetEntity: Model.Entity,
-		targetRelation: Model.OneHasOneOwningRelation,
-	): void {
-		this.executionContext.addData(
-			entity.primary,
-			async ids => {
+	public visitOneHasOneInverse(relationContext: Model.OneHasOneInverseContext): void {
+		const { entity, targetRelation, targetEntity } = relationContext
+		this.executionContext.addData({
+			field: entity.primary,
+			dataProvider: async ids => {
 				const idsWhere: Input.Where = {
 					[targetRelation.name]: {
 						[entity.primary]: {
@@ -155,21 +110,21 @@ export class FieldsVisitor implements Model.RelationByTypeVisitor<void>, Model.C
 				}
 				const objectWithWhere = field.withArg('filter', where)
 
-				return this.mapper.select(targetEntity, objectWithWhere, targetRelation, targetRelation.name)
+				return this.mapper.selectAssoc(targetEntity, objectWithWhere, [
+					...this.relationPath,
+					relationContext,
+				], targetRelation.name)
 			},
-			null,
-		)
+			defaultValue: null,
+			predicate: this.getRequiredPredicate(relationContext.entity, relationContext.relation),
+		})
 	}
 
-	public visitOneHasOneOwning(
-		entity: Model.Entity,
-		relation: Model.OneHasOneOwningRelation,
-		targetEntity: Model.Entity,
-		targetRelation: Model.OneHasOneInverseRelation | null,
-	): void {
-		this.executionContext.addData(
-			relation.name,
-			async ids => {
+	public visitOneHasOneOwning(relationContext: Model.OneHasOneOwningContext): void {
+		const { relation, targetEntity } = relationContext
+		this.executionContext.addData({
+			field: relation.name,
+			dataProvider: async ids => {
 				const idsWhere: Input.Where = {
 					[targetEntity.primary]: {
 						in: ids,
@@ -184,16 +139,21 @@ export class FieldsVisitor implements Model.RelationByTypeVisitor<void>, Model.C
 				}
 				const objectWithWhere = objectNode.withArg('filter', where)
 
-				return this.mapper.select(targetEntity, objectWithWhere, targetRelation, targetEntity.primary)
+				return this.mapper.selectAssoc(targetEntity, objectWithWhere, [
+					...this.relationPath,
+					relationContext,
+				], targetEntity.primary)
 			},
-			null,
-		)
+			defaultValue: null,
+			predicate: this.getRequiredPredicate(relationContext.entity, relationContext.relation),
+		})
 	}
 
-	public visitManyHasOne(entity: Model.Entity, relation: Model.ManyHasOneRelation, targetEntity: Model.Entity, targetRelation: Model.OneHasManyRelation | null): void {
-		this.executionContext.addData(
-			relation.name,
-			async ids => {
+	public visitManyHasOne(relationContext: Model.ManyHasOneContext): void {
+		const { relation, targetEntity } = relationContext
+		this.executionContext.addData({
+			field: relation.name,
+			dataProvider: async ids => {
 				const idsWhere: Input.Where = {
 					[targetEntity.primary]: {
 						in: ids,
@@ -208,9 +168,18 @@ export class FieldsVisitor implements Model.RelationByTypeVisitor<void>, Model.C
 				}
 				const objectWithWhere = objectNode.withArg('filter', where)
 
-				return this.mapper.select(targetEntity, objectWithWhere, targetRelation, targetEntity.primary)
+				return this.mapper.selectAssoc(targetEntity, objectWithWhere, [
+					...this.relationPath,
+					relationContext,
+				], targetEntity.primary)
 			},
-			null,
-		)
+			defaultValue: null,
+			predicate: this.getRequiredPredicate(relationContext.entity, relationContext.relation),
+		})
+	}
+
+	private getRequiredPredicate(entity: Model.Entity, field: Model.AnyField): Acl.Predicate | undefined {
+		const fieldPredicate = this.predicateFactory.getFieldPredicate(entity, Acl.Operation.read, field.name)
+		return fieldPredicate.isSameAsPrimary ? undefined : fieldPredicate.predicate
 	}
 }

package/src/mapper/select/handlers/FieldsVisitorFactory.ts

@@ -22,6 +22,7 @@ export class FieldsVisitorFactory {
 			this.whereBuilder,
 			mapper,
 			context,
+			context.relationPath,
 		)
 	}
 }

package/src/mapper/select/handlers/MetaHandler.ts

@@ -32,25 +32,14 @@ export class MetaHandler implements SelectExecutionHandler<{}> {
 		metaPath: Path,
 		operation: Acl.Operation.read | Acl.Operation.update,
 	): void {
-		const { entity, path } = context
+		const { entity } = context
 		if (entity.primary === fieldName) {
 			return
 		}
-		const fieldPredicate = this.predicateFactory.create(entity, operation, [fieldName])
-		context.addColumn(qb => {
-			return this.whereBuilder.buildAdvanced(entity, path.back(), fieldPredicate, cb =>
-				qb.select(
-					expr =>
-						expr.selectCondition(condition => {
-							condition = cb(condition)
-							if (condition.isEmpty()) {
-								return condition.raw('true')
-							}
-							return condition
-						}),
-					metaPath.alias,
-				),
-			)
-		}, metaPath)
+		const fieldPredicate = this.predicateFactory.getFieldPredicate(entity, operation, fieldName)
+		context.addColumn({
+			path: metaPath,
+			valueGetter: context.addPredicate(fieldPredicate.predicate),
+		})
 	}
 }

package/src/mapper/select/optimizer/ConditionOptimizer.ts

@@ -23,6 +23,12 @@ export class ConditionOptimizer {
 				} else if (key === 'or') {
 					return optimizeOr(value.map(it => this.optimize(it)))
 
+				} else if (key === 'in' && value.length === 0) {
+					return false
+
+				} else if (key === 'notIn' && value.length === 0) {
+					return true
+
 				} else if (key === 'not') {
 					return optimizeNot(this.optimize(value))