使用 Prisma Optimize 进行查询优化
本指南展示了如何识别和优化查询性能、调试性能问题以及应对常见的挑战。
调试性能问题
一些常见做法可能导致查询变慢和性能问题,例如:
- 过度获取数据
- 缺少索引
- 未缓存重复查询
- 执行全表扫描
有关更多潜在性能问题的原因,请访问此页面。
Prisma Optimize 提供建议,以识别和解决上述及更多低效率问题,从而帮助提高查询性能。
要开始使用,请遵循集成指南,将 Prisma Optimize 添加到您的项目,开始诊断慢查询。
您还可以在客户端级别记录查询事件,以查看生成的查询、它们的参数和执行时间。
如果您特别关注查询持续时间监控,请考虑使用日志中间件。
使用批量查询
通常,批量读取和写入大量数据性能更好——例如,分批插入 50,000
条记录(每批 1000
条),而不是执行 50,000
次单独插入。PrismaClient
支持以下批量查询:
复用 PrismaClient
或使用连接池以避免数据库连接池耗尽
创建多个 PrismaClient
实例可能会耗尽您的数据库连接池,尤其是在无服务器或边缘环境中,这可能会降低其他查询的速度。在无服务器挑战中了解更多信息。
对于具有传统服务器的应用程序,请实例化 PrismaClient
一次并在整个应用程序中复用它,而不是创建多个实例。例如,而不是:
async function getPosts() {
const prisma = new PrismaClient()
await prisma.post.findMany()
}
async function getUsers() {
const prisma = new PrismaClient()
await prisma.user.findMany()
}
在一个专用文件中定义一个单一的 PrismaClient
实例并重新导出以供复用
export const prisma = new PrismaClient()
然后导入共享实例
import { prisma } from "db.ts"
async function getPosts() {
await prisma.post.findMany()
}
async function getUsers() {
await prisma.user.findMany()
}
对于使用 HMR(热模块替换)框架的无服务器开发环境,请确保您在开发中正确处理Prisma 的单一实例。
解决 N+1 问题
N+1 问题发生在您循环查询结果并为每个结果执行一个额外查询时,导致 n
个查询加上原始查询(N+1)。这是 ORM 的常见问题,特别是在与 GraphQL 结合使用时,因为您的代码生成效率低下的查询并不总是显而易见的。
使用 findUnique()
和 Prisma Client 的 dataloader 解决 GraphQL 中的 N+1 问题
如果以下条件成立,Prisma Client dataloader 会自动对在同一tick 中发生且具有相同 where
和 include
参数的 findUnique()
查询进行批量处理:
where
过滤器的所有条件都在您查询的同一模型的标量字段(唯一或非唯一)上。- 所有条件都使用
equal
过滤器,无论是通过简写还是显式语法(where: { field: <val>, field1: { equals: <val> } })
。 - 没有布尔运算符或关系过滤器。
findUnique()
的自动批量处理在 GraphQL 上下文中特别有用。GraphQL 为每个字段运行一个单独的解析器函数,这使得优化嵌套查询变得困难。
例如——以下 GraphQL 运行 allUsers
解析器以获取所有用户,并每个用户一次运行 posts
解析器以获取每个用户的帖子(N+1)
query {
allUsers {
id,
posts {
id
}
}
}
allUsers
查询使用 user.findMany(..)
返回所有用户
const Query = objectType({
name: 'Query',
definition(t) {
t.nonNull.list.nonNull.field('allUsers', {
type: 'User',
resolve: (_parent, _args, context) => {
return context.prisma.user.findMany()
},
})
},
})
这会产生一个单一的 SQL 查询
{
timestamp: 2021-02-19T09:43:06.332Z,
query: 'SELECT `dev`.`User`.`id`, `dev`.`User`.`email`, `dev`.`User`.`name` FROM `dev`.`User` WHERE 1=1 LIMIT ? OFFSET ?',
params: '[-1,0]',
duration: 0,
target: 'quaint::connector::metrics'
}
但是,posts
的解析器函数会每个用户一次被调用。这导致每个用户而不是单个 findMany()
返回所有用户的所有帖子(展开 CLI 输出以查看查询)的 findMany()
查询 ✘。
const User = objectType({
name: 'User',
definition(t) {
t.nonNull.int('id')
t.string('name')
t.nonNull.string('email')
t.nonNull.list.nonNull.field('posts', {
type: 'Post',
resolve: (parent, _, context) => {
return context.prisma.post.findMany({
where: { authorId: parent.id || undefined },
})
},
})
},
})
解决方案 1:使用 Fluent API 批量查询
结合使用 findUnique()
和流畅 API (.posts()
),如所示返回用户的帖子。即使解析器每个用户调用一次,Prisma Client 中的 Prisma dataloader ✔ 会批量处理 findUnique()
查询。
使用 prisma.user.findUnique(...).posts()
查询返回帖子而不是 prisma.posts.findMany()
可能看起来有悖常理——特别是前者会导致两次查询而不是一次。
您需要使用流畅 API (user.findUnique(...).posts()
) 返回帖子的唯一原因是 Prisma Client 中的 dataloader 批量处理 findUnique()
查询,但目前不会批量处理 findMany()
查询。
当 dataloader 批量处理 findMany()
查询或您的查询将 relationStrategy
设置为 join
时,您不再需要以这种方式将 findUnique()
与流畅 API 一起使用。
const User = objectType({
name: 'User',
definition(t) {
t.nonNull.int('id')
t.string('name')
t.nonNull.string('email')
t.nonNull.list.nonNull.field('posts', {
type: 'Post',
resolve: (parent, _, context) => {
return context.prisma.post.findMany({
where: { authorId: parent.id || undefined },
})
return context.prisma.user
.findUnique({
where: { id: parent.id || undefined },
})
.posts()
},
})
},
})
如果 posts
解析器每个用户调用一次,Prisma Client 中的 dataloader 会将具有相同参数和选择集的 findUnique()
查询分组。每个组都会被优化为一个单一的 findMany()
。
解决方案 2:使用 JOIN 执行查询
您可以通过将 relationLoadStrategy
设置为 "join"
来使用数据库连接执行查询,确保只对数据库执行一次查询。
const User = objectType({
name: 'User',
definition(t) {
t.nonNull.int('id')
t.string('name')
t.nonNull.string('email')
t.nonNull.list.nonNull.field('posts', {
type: 'Post',
resolve: (parent, _, context) => {
return context.prisma.post.findMany({
relationLoadStrategy: "join",
where: { authorId: parent.id || undefined },
})
},
})
},
})
其他上下文中的 N+1 问题
N+1 问题最常见于 GraphQL 上下文,因为您必须找到一种方法来优化跨多个解析器的单个查询。然而,您也可以通过在自己的代码中使用 forEach
循环结果轻松引入 N+1 问题。
以下代码导致 N+1 查询——一个 findMany()
获取所有用户,以及每个用户一个 findMany()
获取每个用户的帖子
// One query to get all users
const users = await prisma.user.findMany({})
// One query PER USER to get all posts
users.forEach(async (usr) => {
const posts = await prisma.post.findMany({
where: {
authorId: usr.id,
},
})
// Do something with each users' posts
})
SELECT "public"."User"."id", "public"."User"."email", "public"."User"."name" FROM "public"."User" WHERE 1=1 OFFSET $1
SELECT "public"."Post"."id", "public"."Post"."title" FROM "public"."Post" WHERE "public"."Post"."authorId" = $1 OFFSET $2
SELECT "public"."Post"."id", "public"."Post"."title" FROM "public"."Post" WHERE "public"."Post"."authorId" = $1 OFFSET $2
SELECT "public"."Post"."id", "public"."Post"."title" FROM "public"."Post" WHERE "public"."Post"."authorId" = $1 OFFSET $2
SELECT "public"."Post"."id", "public"."Post"."title" FROM "public"."Post" WHERE "public"."Post"."authorId" = $1 OFFSET $2
/* ..and so on .. */
这不是一种高效的查询方式。相反,您可以:
- 使用嵌套读取(
include
)返回用户和相关帖子 - 使用
in
过滤器 - 将
relationLoadStrategy
设置为"join"
使用 include
解决 N+1 问题
您可以使用 include
返回每个用户的帖子。这只会产生两个 SQL 查询——一个用于获取用户,另一个用于获取帖子。这被称为嵌套读取。
const usersWithPosts = await prisma.user.findMany({
include: {
posts: true,
},
})
SELECT "public"."User"."id", "public"."User"."email", "public"."User"."name" FROM "public"."User" WHERE 1=1 OFFSET $1
SELECT "public"."Post"."id", "public"."Post"."title", "public"."Post"."authorId" FROM "public"."Post" WHERE "public"."Post"."authorId" IN ($1,$2,$3,$4) OFFSET $5
使用 in
解决 N+1 问题
如果您有一个用户 ID 列表,可以使用 in
过滤器返回 authorId
在该 ID 列表中的所有帖子
const users = await prisma.user.findMany({})
const userIds = users.map((x) => x.id)
const posts = await prisma.post.findMany({
where: {
authorId: {
in: userIds,
},
},
})
SELECT "public"."User"."id", "public"."User"."email", "public"."User"."name" FROM "public"."User" WHERE 1=1 OFFSET $1
SELECT "public"."Post"."id", "public"."Post"."createdAt", "public"."Post"."updatedAt", "public"."Post"."title", "public"."Post"."content", "public"."Post"."published", "public"."Post"."authorId" FROM "public"."Post" WHERE "public"."Post"."authorId" IN ($1,$2,$3,$4) OFFSET $5
使用 relationLoadStrategy: "join"
解决 N+1 问题
您可以通过将 relationLoadStrategy
设置为 "join"
来使用数据库连接执行查询,确保只对数据库执行一次查询。
const users = await prisma.user.findMany({})
const userIds = users.map((x) => x.id)
const posts = await prisma.post.findMany({
relationLoadStrategy: "join",
where: {
authorId: {
in: userIds,
},
},
})