使用nestjs和typeorm时数据不一致

Question

用户和职位之间存在多对多关系。当我尝试检索用户的数据时，每个用户都有多个关联的职位。共有 100 个用户。但是，当我应用限制时，例如 limit=10，我只得到 8 条用户记录，但关联位置的总数为 20。这些是模型的片段：

用户.实体.ts

@ManyToMany(() => Position, (position) => position.users)
@Field(() => [Position], { nullable: true })
@JoinTable({
  name: 'pivot_user_position',
  joinColumn: { name: 'user_nip', referencedColumnName: 'nip' },
  inverseJoinColumn: { name: 'position_id' },
})
public positions?: Position[]

@OneToMany(() => PivotUserPosition, (user) => user.pivot)
@Field(() => [PivotUserPosition], { nullable: true })
public pivot?: PivotUserPosition[]

位置.实体.ts

@ManyToMany(() => User, (user) => user.positions)
@JoinTable({
  name: 'pivot_user_position',
  joinColumn: { name: 'position_id' },
  inverseJoinColumn: { name: 'user_nip', referencedColumnName: 'nip' },
})
public users?: User[]

枢轴用户位置.entity.ts

@ManyToOne(() => User, (user) => user.positions, { eager: false })
@JoinColumn({ name: 'user_nip', referencedColumnName: 'nip' })
public user: User

@ManyToOne(() => Position, (position) => position.users)
@JoinColumn({ name: 'position_id' })
public position: Position

@ManyToOne(() => User, (user) => user.pivot)
@JoinColumn({ name: 'user_nip', referencedColumnName: 'nip' })
public pivot?: User

这是 typeorm 查询。

  async getUsers(
    session: SessionPayload,
  ) {
    const query = this.user
      .createQueryBuilder('user')
      .innerJoinAndSelect('user.positions', 'pos')
      .leftJoinAndSelect('pos.organization', 'org')
      .leftJoinAndSelect('pos.department_org', 'dorg')
      .leftJoinAndSelect('user.pivot', 'piv')
      .orderBy({ 'user.id': 'ASC' }).limit(10)
    return query.getMany()
  }

这是结果。

{
  "data": {
    "users": {
      "edges": [
        {
          "node": {
            "name": "Bey",
            "pivot": [
              {
                "position_id": "10000"
              }
            ]
          }
        },
        {
          "node": {
            "name": "Errico",
            "pivot": [
              {
                "position_id": "999991"
              }
            ]
          }
        },
        {
          "node": {
            "name": "Eni",
            "pivot": [
              {
                "position_id": "10001"
              },
              {
                "position_id": "13454"
              }
            ]
          }
        },
        {
          "node": {
            "name": "Budi",
            "pivot": [
              {
                "position_id": "10001"
              },
              {
                "position_id": "10042"
              }
            ]
          }
        },
        {
          "node": {
            "name": "Dedi",
            "pivot": [
              {
                "position_id": "10002"
              }
            ]
          }
        },
        {
          "node": {
            "name": "Usep",
            "pivot": [
              {
                "position_id": "100039927"
              }
            ]
          }
        },
        {
          "node": {
            "name": "Joe",
            "pivot": [
              {
                "position_id": "100039925"
              }
            ]
          }
        },
        {
          "node": {
            "name": "Moto",
            "pivot": [
              {
                "position_id": "100040057"
              }
            ]
          }
        }
      ]
    }
  }
}

预期结果以10个节点为极限；然而，它只返回 8 个节点。

Answer 1

之所以这样工作，是因为你在左连接完成后应用

LIMIT 10

。如果计算结果中的主元记录数，您将看到正好 10。

这里可能的解决方案是使用两个查询：

第一次查询以获取与所应用的查询条件匹配的用户的 id

limit

:

    const userIds = await this.user
      .createQueryBuilder('user')
      .select('user.id')
      .innerJoinAndSelect('user.positions', 'pos')
      .orderBy({ 'user.id': 'ASC' })
      .limit(10)
      .getRawMany();    

第二个查询获取具有连接属性的用户：

return this.user
  .createQueryBuilder('user')
  .innerJoinAndSelect('user.positions', 'pos')
  .leftJoinAndSelect('pos.organization', 'org')
  .leftJoinAndSelect('pos.department_org', 'dorg')
  .leftJoinAndSelect('user.pivot', 'piv')
  .where('user.id IN (:...ids)', { ids: userIds.map(u => u.id) })
  .orderBy({ 'user.id': 'ASC' })
  .getMany();