Prisma深度关联查询：获取自引用多对多关系中朋友的用户信息

新闻中心 NEWS CENTER

您当前位置：首页 > 新闻中心 > 网络学院

Prisma深度关联查询：获取自引用多对多关系中朋友的用户信息

2025-12-07

浏览次数：次

返回列表

prisma深度关联查询：获取自引用多对多关系中朋友的用户信息

本文旨在解决Prisma中查询自引用多对多关系时，如何通过深度嵌套的select语句获取关联实体的详细信息。我们将以用户与朋友关系为例，详细解析Prisma的schema定义，并展示如何编写精确的查询，从Friend关系表中进一步获取朋友用户的id和name，从而实现更丰富的数据检索。

在Prisma应用开发中，处理复杂的数据关系，特别是自引用多对多关系，是常见的需求。例如，在一个社交应用中，用户可以互为朋友。这种关系通常通过一个中间表（或称关联表）来实现。本教程将深入探讨如何构建这样的Prisma Schema，并演示如何编写查询语句，以便从这些复杂关系中准确地提取所需的数据。

1. 理解自引用多对多关系的Schema设计

首先，我们来看一下描述用户及其朋友关系的Prisma Schema：

// schema.prisma

model User {
  id         Int           @id @default(autoincrement())
  name       String        // 用户名
  self       Friend[]      @relation("self")   // 作为“发起者”的朋友关系
  friend     Friend[]      @relation("friend")  // 作为“被接受者”的朋友关系
}

model Friend {
  id         Int        @id @default(autoincrement())
  user       User       @relation("self", fields: [userId], references: [id]) // 指向发起朋友关系的用户
  userId     Int        // Foreign Key, 对应发起者的User ID
  friend     User       @relation("friend", fields: [friendId], references: [id]) // 指向被接受朋友关系的用户
  friendId   Int        // Foreign Key, 对应被接受者的User ID
  // @@unique([userId, friendId]) // 可选：确保朋友关系唯一性
}

Schema解析：

User 模型:
- id: 用户唯一标识。
- name: 用户名。
- self Friend[] @relation("self"): 定义了一个与 Friend 模型的反向关系。它表示当前 User 实例作为 Friend 记录中的 user (即 userId 字段所指向的用户)。
- friend Friend[] @relation("friend"): 定义了另一个与 Friend 模型的反向关系。它表示当前 User 实例作为 Friend 记录中的 friend (即 friendId 字段所指向的用户)。
Friend 模型 (关联表):
- id: Friend 记录的唯一标识。
- user User @relation("self", fields: [userId], references: [id]): 定义了与 User 模型的关系，通过 userId 字段关联到 User 的 id。这里的 @relation("self") 标签与 User 模型中的 self 关系相对应。
- userId Int: 外键，存储发起朋友关系的用户的ID。
- friend User @relation("friend", fields: [friendId], references: [id]): 定义了与 User 模型的关系，通过 friendId 字段关联到 User 的 id。这里的 @relation("friend") 标签与 User 模型中的 friend 关系相对应。
- friendId Int: 外键，存储被接受朋友关系的用户的ID。

简而言之，Friend 表记录了一对用户之间的朋友关系，其中 userId 是“主用户”，friendId 是其“朋友”。

2. 初始查询及其局限性

假设我们想要查询某个用户（例如 Paul McCartney）的朋友列表。一个常见的初步尝试可能如下：

// sample.tsx (初始查询)
const friends = await prisma.user.findUnique({
  where: {
    id: userId, // 查询用户的ID
  },
  select: {
    name: true, // 获取用户姓名
    // 访问 User 模型中的 'friend' 关系
    friend: {
      select: {
        userId: true, // 尝试获取朋友的ID
      },
    },
  },
});

console.log(friends);

执行此查询后，我们可能会得到类似以下的结果：

{  
  name: 'Paul McCartney',
  friend: [ { userId: 1 }, { userId: 3 }, { userId: 4 } ]
}

这个结果显示了用户 Paul McCartney 的姓名，以及他朋友的 userId 列表。然而，它只提供了朋友的ID，而我们通常需要朋友的更多信息，例如他们的姓名。我们期望得到的结果是这样的：

中解商务通

实时捕捉一旦访问者打开您的网站，系统会立即显示，这时您就可以查看用户的信息，如：来自搜索引擎关键词、友情链接或直接访问；访问者的IP地址，所在地区，正在访问哪个网页；以及访问者使用的操作系统、浏览器、显示器屏幕分辨率颜色深度等。主动出击变被动为主动，可以主动邀请访问者进行洽谈勾通，帮助客户深入了解您的企业和产品，同时获得对方的采购意向、联系方式等信息。互动交流主动销售和在线客服合二为一，

0 查看详情中解商务通

{  
  name: 'Paul McCartney',
  friend: [ 
    { userId: 1, name: "John Lennon" }, 
    { userId: 3, name: "Ringo Starr" }, 
    { userId: 4, name: "George Harrison" } 
  ]
}

3. 解决方案：利用嵌套 select 深度查询关联字段

要获取朋友的姓名，我们需要在 friend 关系内部进一步导航到实际的 User 对象。回顾 Friend 模型的定义：当从 User.friend 关系访问 Friend 记录时，该 Friend 记录的 friendId 字段与当前 User 的 id 匹配。因此，该 Friend 记录中的 user 字段（通过 userId 关联）才是我们真正想要获取信息的朋友用户。

基于此理解，我们可以修改查询语句，使用嵌套的 select 来深度获取朋友用户的姓名：

// sample.tsx (优化后的查询)
const friendsData = await prisma.user.findUnique({
  where: {
    id: userId, // 要查询的用户的ID
  },
  select: {
    name: true, // 获取当前用户的姓名
    // 访问 User 模型中的 'friend' 关系
    friend: {
      select: {
        // 在 Friend 记录中，'user' 字段代表了与当前查询用户建立朋友关系的另一方用户
        user: { 
          select: {
            id: true,   // 获取朋友用户的ID
            name: true  // 获取朋友用户的姓名
          }
        }
      }
    }
  },
});

// 对查询结果进行后处理，使其更符合期望的扁平结构
const formattedFriends = {
  name: friendsData?.name,
  friend: friendsData?.friend.map(f => f.user) // 提取每个Friend记录中的user对象
};

console.log(formattedFriends);

代码解析：

select: { name: true, ... }: 保持获取当前用户的姓名。
friend: { ... }: 这一层访问 User 模型中名为 friend 的关系，它会返回一个 Friend 记录的数组，其中当前 User 的 id 匹配 Friend.friendId。
select: { user: { ... } }: 这是关键一步。在每个 Friend 记录内部，我们通过 user 字段再次 select。这个 user 字段是 Friend 模型中定义的，它通过 userId 关联到另一个 User 模型实例。由于我们是从 User.friend 关系查询的（即当前用户是 Friend.friendId），那么 Friend.user 就代表了与当前用户建立朋友关系的那个“朋友”用户。
select: { id: true, name: true }: 在获取到的朋友 User 对象中，我们进一步选择其 id 和 name 字段。

查询结果示例：

执行上述优化后的查询，friendsData 变量将包含如下结构的数据：

{  
  name: 'Paul McCartney',
  friend: [
    { user: { id: 1, name: 'John Lennon' } },
    { user: { id: 3, name: 'Ringo Starr' } },
    { user: { id: 4, name: 'George Harrison' } }
  ]
}

为了得到更扁平化的期望结构（即 friend: [ { userId: 1, name: "John Lennon" }, ... ]），我们可以在查询结果上进行简单的J*aScript map 操作：

const formattedFriends = {
  name: friendsData?.name,
  friend: friendsData?.friend.map(f => f.user) // 提取每个Friend记录中的user对象
};

这样，formattedFriends 就会得到我们最初期望的输出：

{  
  name: 'Paul McCartney',
  friend: [ 
    { id: 1, name: "John Lennon" }, 
    { id: 3, name: "Ringo Starr" }, 
    { id: 4, name: "George Harrison" } 
  ]
}

4. 注意事项与总结

理解关系名称: 在处理自引用关系时，Schema中 @relation 注解的名称（如 "self" 和 "friend"）以及模型中对应关系字段的名称（如 User.self 和 User.friend，以及 Friend.user 和 Friend.friend）至关重要。它们定义了数据流动的路径。
深度嵌套 select: Prisma 允许在 select 语句中进行任意深度的嵌套，这使得我们能够精确地控制从关联模型中获取哪些字段。这是处理复杂关系的关键能力。
结果转换: Prisma 返回的数据结构会严格遵循你的 select 语句的嵌套层级。如果需要更扁平或不同形式的数据结构，通常需要在客户端代码中进行后处理（如使用 map 操作）。
性能考量: 虽然深度嵌套 select 非常强大，但过度或不必要的嵌套可能会增加数据库查询的复杂性。在实际应用中，应根据需求精确选择所需字段，避免不必要的数据加载。