如何通过TypeORM子查询实现带对应评估的唯一成员分页查询

核心问题分析 #

当前实现的核心错误在于先对评估数据分页，再按成员分组，这会导致两个问题：

• 分页截取的是评估数据而非成员数据，最终返回的成员数量远小于分页要求（比如请求10个成员，可能因部分成员的评估被分页截断，实际返回更少）
• 分组逻辑未正确按成员聚合评估信息

正确实现思路 #

1. 先分页查询唯一成员列表，确保返回数量符合分页要求
2. 批量获取这些成员的关联评估数据
3. 将评估数据按成员ID关联，再按评估名称分组到对应成员下

具体代码实现 #

1. 假设Assessment实体定义 #

import { Entity, Column, PrimaryGeneratedColumn, ManyToOne } from "typeorm";
import { Member } from "./Member"; // 假设存在Member实体

@Entity()
export class Assessment {
  @PrimaryGeneratedColumn()
  id: number;

  @Column()
  name: string; // 评估名称，用于分组

  @Column()
  score: number; // 评估分数

  @ManyToOne(() => Member, member => member.assessments)
  member: Member;

  @Column()
  memberId: number; // 成员外键ID
}

2. 分页获取成员及分组评估的代码 #

import { getRepository, In, SelectQueryBuilder } from "typeorm";
import { Member } from "./Member";
import { Assessment } from "./Assessment";

async function getMembersWithGroupedAssessments(page: number, limit: number) {
  // 第一步：分页查询成员，确保返回指定数量的成员
  const membersQuery: SelectQueryBuilder<Member> = getRepository(Member)
    .createQueryBuilder("member")
    .skip((page - 1) * limit)
    .take(limit);

  const members = await membersQuery.getMany();
  if (members.length === 0) {
    return { members: [], total: 0 };
  }

  // 提取成员ID集合
  const memberIds = members.map(member => member.id);

  // 第二步：批量获取这些成员的所有评估数据
  const assessments = await getRepository(Assessment)
    .createQueryBuilder("assessment")
    .where("assessment.memberId IN (:...memberIds)", { memberIds })
    .getMany();

  // 第三步：将评估按成员ID分组，再按评估名称聚合
  const memberAssessmentMap = new Map<number, Record<string, Assessment[]>>();
  
  assessments.forEach(assessment => {
    if (!memberAssessmentMap.has(assessment.memberId)) {
      memberAssessmentMap.set(assessment.memberId, {});
    }
    const groupedAssessments = memberAssessmentMap.get(assessment.memberId)!;
    
    if (!groupedAssessments[assessment.name]) {
      groupedAssessments[assessment.name] = [];
    }
    groupedAssessments[assessment.name].push(assessment);
  });

  // 第四步：关联分组后的评估到对应成员
  const resultMembers = members.map(member => ({
    ...member,
    assessments: memberAssessmentMap.get(member.id) || {}
  }));

  // 获取成员总数，用于分页计算
  const total = await getRepository(Member).count();

  return {
    members: resultMembers,
    total,
    page,
    limit,
    totalPages: Math.ceil(total / limit)
  };
}

3. 子查询优化（单查询实现，以PostgreSQL为例） #

如果想用单查询+子查询实现，可以先分页获取成员ID，再关联评估并利用数据库函数分组：

async function getMembersWithGroupedAssessmentsSingleQuery(page: number, limit: number) {
  // 子查询：分页获取成员ID
  const memberIdsSubQuery = getRepository(Member)
    .createQueryBuilder("member")
    .select("member.id")
    .skip((page - 1) * limit)
    .take(limit);

  // 主查询：关联评估并按名称分组（使用PostgreSQL的JSON_AGG函数）
  const result = await getRepository(Member)
    .createQueryBuilder("member")
    .leftJoin(Assessment, "assessment", "assessment.memberId = member.id")
    .where("member.id IN (" + memberIdsSubQuery.getQuery() + ")")
    .setParameters(memberIdsSubQuery.getParameters())
    .select([
      "member.id",
      "member.name", // 成员其他字段
      // 按评估名称分组聚合
      "assessment.name AS assessment_name",
      "JSON_AGG(assessment) AS assessment_list"
    ])
    .groupBy("member.id, assessment.name")
    .getRawMany();

  // 整理格式，将评估映射到对应成员
  const memberMap = new Map<number, any>();
  result.forEach(row => {
    if (!memberMap.has(row.member_id)) {
      memberMap.set(row.member_id, {
        id: row.member_id,
        name: row.member_name,
        assessments: {}
      });
    }
    const member = memberMap.get(row.member_id);
    member.assessments[row.assessment_name] = JSON.parse(row.assessment_list);
  });

  const total = await getRepository(Member).count();

  return {
    members: Array.from(memberMap.values()),
    total,
    page,
    limit,
    totalPages: Math.ceil(total / limit)
  };
}

关键注意点 #

• 优先分页成员：确保分页维度是成员而非评估，保证返回的成员数量符合要求
• 避免N+1问题：批量查询评估数据，不要为每个成员单独发起查询
• 分组逻辑严谨：先按成员ID聚合，再按评估名称二次分组，确保每个成员的评估归类正确

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