TypeORM Query Builder按关联价格过滤主实体无结果问题求助

我有主实体LectureEntity，想要通过lectureLevel->levelOptions->price字段过滤查询结果。目前用TypeORM Query Builder写了关联查询代码，但遇到两个问题：

• 使用lectureLevelLevelOption做价格过滤时，查询结果为空（理论上应该存在符合条件的数据）
• 使用optionLevelOption过滤能得到结果，但无法过滤掉不符合条件的lectureLevels关联项

问题根源 #

1. 直接在WHERE中对左连接的lectureLevelLevelOption字段加过滤条件时，会把没有符合价格条件关联项的Lecture直接排除（左连接的空值不满足比较条件），导致结果为空。
2. 用optionLevelOption过滤时，关联的是lecture.options->levelOptions这条链，和lecture.levels->levelOptions属于不同关联关系，无法影响lectureLevels的返回结果。

修复步骤 #

1. 带条件关联lectureLevel和levelOptions

修改关联方法，在连接lectureLevel.levelOptions时直接加入价格过滤条件，确保只返回符合价格要求的关联项；同时提前过滤enabled=true的lectureLevel。

2. 用EXISTS子查询确保主实体存在符合条件的关联

通过子查询验证Lecture至少有一个lectureLevel满足价格条件，避免主实体被错误排除。

修改后的代码 #

关联查询方法调整

async joinLectureRelations(
  query: SelectQueryBuilder<LectureEntity>, 
  select: boolean = true, 
  priceFilters?: { minPrice?: number; maxPrice?: number }
) {
  const func = select ? 'leftJoinAndSelect' : 'leftJoin';
  
  // 保持原有其他关联不变
  query[func]('lecture.options', 'option');
  query[func]('option.levelOptions', 'optionLevelOption');
  query[func]('optionLevelOption.lectureLevel', 'optionLevelOptionLectureLevel');
  query[func]('lecture.packageOptions', 'packageOption');
  query[func]('lecture.author', 'author');
  query[func]('lecture.schedule', 'schedule');
  query[func]('author.rating', 'rating');
  query[func]('author.avatar', 'avatar');

  query[func]('schedule.slots', 'slots', `NOT (slots.repeatMode = :repeatMode AND slots.toDate < :now)`, {
    repeatMode: LectureSlotRepeatMode.NO_REPEAT,
    now: new Date(),
  });
  query[func]('lecture.domains', 'domains');
  query[func]('lecture.tags', 'tags');

  // 提前过滤enabled=true的lectureLevel
  query[func]('lecture.levels', 'lectureLevel', 'lectureLevel.enabled = true');

  // 根据价格条件构建levelOptions的连接条件
  let levelOptionJoinCondition = '';
  const joinParams: any = {};
  if (priceFilters?.minPrice) {
    levelOptionJoinCondition += 'lectureLevelLevelOption.price >= :minPrice';
    joinParams.minPrice = priceFilters.minPrice;
  }
  if (priceFilters?.maxPrice !== undefined) {
    levelOptionJoinCondition += levelOptionJoinCondition ? ' AND ' : '';
    levelOptionJoinCondition += 'lectureLevelLevelOption.price <= :maxPrice';
    joinParams.maxPrice = priceFilters.maxPrice;
  }

  // 带条件连接levelOptions，无过滤时用普通左连接
  if (levelOptionJoinCondition) {
    query[func]('lectureLevel.levelOptions', 'lectureLevelLevelOption', levelOptionJoinCondition, joinParams);
  } else {
    query[func]('lectureLevel.levelOptions', 'lectureLevelLevelOption');
  }

  query[func]('lectureLevelLevelOption.lectureOption', 'lectureLevelLevelOptionLectureOption');

  // 保持原有排序逻辑不变
  query.addOrderBy('option.duration', 'ASC');
  query.addOrderBy('packageOption.count', 'ASC');

  query.addSelect(
    `
  (CASE "lectureLevel"."level"
    WHEN 'Szkoła podstawowa' THEN 0
    WHEN 'Szkoła średnia' THEN 1
    WHEN 'Szkoła wyższa' THEN 2
    ELSE 99
  END)`,
    'level_order',
  );
  query.addOrderBy('level_order', 'ASC');
}

主查询逻辑调整

const query = service._lectureRepository.createQueryBuilder('lecture');

// 收集价格过滤参数
const priceFilters: { minPrice?: number; maxPrice?: number } = {};
if (data.minPrice) priceFilters.minPrice = data.minPrice;
if (data.maxPrice !== undefined) priceFilters.maxPrice = data.maxPrice;

// 传入价格参数执行关联
joinRelations(query, true, priceFilters);

// 原有过滤条件保持不变
query.andWhere('lecture.enabled = true');
query.andWhere('option.enabled = true');
query.andWhere('author.hasActiveSubscription');

if (data.levels && skip !== 'level') {
  query.andWhere(`lectureLevel.level IN (:...levels)`, { levels: data.levels });
}

// 添加EXISTS子查询，确保当前Lecture存在符合价格条件的lectureLevel
if (priceFilters.minPrice || priceFilters.maxPrice !== undefined) {
  query.andWhere(qb => {
    const subQuery = qb.subQuery()
      .select(1)
      .from(LectureLevelEntity, 'll')
      .innerJoin('ll.levelOptions', 'llo')
      .where('ll.lectureId = lecture.id')
      .andWhere('ll.enabled = true');
    
    if (priceFilters.minPrice) {
      subQuery.andWhere('llo.price >= :minPrice', { minPrice: priceFilters.minPrice });
    }
    if (priceFilters.maxPrice !== undefined) {
      subQuery.andWhere('llo.price <= :maxPrice', { maxPrice: priceFilters.maxPrice });
    }
    return subQuery.exists();
  });
}

效果说明 #

• 只会返回存在至少一个符合价格条件lectureLevel的Lecture实体
• 返回的lectureLevels关联项只会包含符合价格过滤条件的条目
• 不会出现因左连接空值导致的结果为空问题

内容的提问来源于stack exchange，提问作者user30659238