Prisma vs Drizzle vs TypeORM: ORM 对比 2026

为 TypeScript 项目选择正确的 ORM（对象关系映射）决定了你整个数据访问层的设计。Prisma、Drizzle 和 TypeORM 代表三种不同的理念：Schema 优先的代码生成、SQL 优先的类型推断、以及基于装饰器的活动记录模式。本文全面对比三者在性能、开发体验、类型安全和生产就绪性方面的表现，帮助你在 2026 年做出明智选择。

Prisma：Schema 优先的全栈 ORM

Prisma 是新一代 ORM，采用 Schema 优先的方法。你在 Prisma schema 文件（.prisma）中定义数据模型，Prisma 会生成完全类型化的客户端、数据库迁移和内省工具。生成的 Prisma Client 为每个查询提供自动补全，包括嵌套关系、过滤器和聚合。

Prisma 已成为最流行的 TypeScript ORM，从初创公司到大型企业都在使用。其开发体验无与伦比：schema 语言直观，迁移自动处理，生成的客户端在编译时而非运行时捕获错误。

Prisma Schema

// prisma/schema.prisma
generator client {
  provider = "prisma-client-js"
}

datasource db {
  provider = "postgresql"
  url      = env("DATABASE_URL")
}

model User {
  id    Int    @id @default(autoincrement())
  email String @unique
  name  String?
  role  Role   @default(USER)
  posts Post[]
  @@map("users")
}

model Post {
  id        Int     @id @default(autoincrement())
  title     String
  slug      String  @unique
  content   String
  published Boolean @default(false)
  author    User    @relation(fields: [authorId], references: [id])
  authorId  Int
  @@map("posts")
}

enum Role { USER AUTHOR ADMIN }

Prisma Queries

// Prisma Client — 查询示例
import { PrismaClient } from '@prisma/client';
const prisma = new PrismaClient();

// 创建带嵌套关系的用户
const user = await prisma.user.create({
  data: {
    email: 'alice@example.com',
    name: 'Alice',
    role: 'AUTHOR',
  },
});

// 带过滤、分页和排序的查询
const posts = await prisma.post.findMany({
  where: { published: true },
  include: {
    author: { select: { name: true, email: true } },
    _count: { select: { comments: true } },
  },
  orderBy: { publishedAt: 'desc' },
  take: 10,
});

// 事务
const [post, updated] = await prisma.$transaction([
  prisma.post.create({ data: { title: 'Prisma 指南', slug: 'prisma-guide', content: '...', authorId: 1 } }),
  prisma.user.update({ where: { id: 1 }, data: { role: 'AUTHOR' } }),
]);

Drizzle：SQL 优先的轻量级 ORM

Drizzle ORM 采用完全不同的方法：SQL 优先。Drizzle 不是抽象掉 SQL，而是拥抱它。你的 schema 用 TypeScript 定义，查询看起来几乎与 SQL 相同。Drizzle 从 schema 定义中推断类型，因此无需代码生成即可获得完整的类型安全。

Drizzle 是三者中最轻量的 ORM，零依赖且包体积极小。它作为 SQL 的薄包装层，意味着你总是知道会生成什么查询。对于熟悉 SQL 的开发者，Drizzle 感觉就像在写带有 TypeScript 类型安全的 SQL。

Drizzle Schema

// src/db/schema.ts — Drizzle schema
import { pgTable, serial, text, varchar, boolean, timestamp, integer } from 'drizzle-orm/pg-core';

export const users = pgTable('users', {
  id: serial('id').primaryKey(),
  email: varchar('email', { length: 255 }).unique().notNull(),
  name: text('name'),
  role: text('role').default('USER').notNull(),
  createdAt: timestamp('created_at').defaultNow().notNull(),
});

export const posts = pgTable('posts', {
  id: serial('id').primaryKey(),
  title: text('title').notNull(),
  slug: varchar('slug', { length: 255 }).unique().notNull(),
  content: text('content').notNull(),
  published: boolean('published').default(false).notNull(),
  authorId: integer('author_id').references(() => users.id).notNull(),
});

Drizzle Queries

// Drizzle ORM — 查询示例
import { drizzle } from 'drizzle-orm/node-postgres';
import { eq, desc, count } from 'drizzle-orm';
import * as schema from './schema';

const db = drizzle(pool, { schema });

// 插入并返回
const [newUser] = await db.insert(schema.users)
  .values({ email: 'alice@example.com', name: 'Alice' })
  .returning();

// 带 JOIN 的查询 — 看起来就像 SQL！
const postsWithAuthors = await db
  .select({
    title: schema.posts.title,
    authorName: schema.users.name,
    commentCount: count(schema.comments.id),
  })
  .from(schema.posts)
  .leftJoin(schema.users, eq(schema.posts.authorId, schema.users.id))
  .where(eq(schema.posts.published, true))
  .orderBy(desc(schema.posts.publishedAt))
  .limit(10);

// 关系查询构建器（类 Prisma API）
const usersWithPosts = await db.query.users.findMany({
  with: { posts: { where: eq(schema.posts.published, true), limit: 5 } },
  limit: 10,
});

TypeORM：基于装饰器的全功能 ORM

TypeORM 是三者中最老且功能最丰富的 ORM。它使用 TypeScript 装饰器定义实体，同时支持活动记录（Active Record）和数据映射器（Data Mapper）模式。TypeORM 深受 Hibernate（Java）和 Doctrine（PHP）启发，对来自这些生态系统的开发者来说非常熟悉。

TypeORM 支持广泛的数据库（PostgreSQL、MySQL、SQLite、SQL Server、Oracle、MongoDB），提供实体监听器、订阅者、自定义仓库和迁移等高级功能。但其 TypeScript 类型安全历来弱于 Prisma 和 Drizzle。

TypeORM Entities

// src/entities/User.ts — TypeORM 实体
import { Entity, PrimaryGeneratedColumn, Column, OneToMany } from 'typeorm';

export enum Role { USER = 'USER', AUTHOR = 'AUTHOR', ADMIN = 'ADMIN' }

@Entity('users')
export class User {
  @PrimaryGeneratedColumn()
  id: number;

  @Column({ unique: true })
  email: string;

  @Column({ nullable: true })
  name: string;

  @Column({ type: 'enum', enum: Role, default: Role.USER })
  role: Role;

  @OneToMany(() => Post, (post) => post.author)
  posts: Post[];
}

TypeORM Queries

// TypeORM — 查询示例
const userRepo = AppDataSource.getRepository(User);
const postRepo = AppDataSource.getRepository(Post);

// 使用 QueryBuilder 查询
const posts = await postRepo
  .createQueryBuilder('post')
  .leftJoinAndSelect('post.author', 'author')
  .where('post.published = :published', { published: true })
  .orderBy('post.publishedAt', 'DESC')
  .take(10)
  .getMany();

// 使用 find 选项（更简单的 API）
const recentPosts = await postRepo.find({
  where: { published: true },
  relations: { author: true },
  order: { publishedAt: 'DESC' },
  take: 10,
});

功能对比表

从对生产应用最重要的维度对比三种 ORM：

性能基准

性能因查询复杂度和使用模式而显著不同。以下是来自实际基准测试的一般观察：

迁移策略

数据库迁移对生产应用至关重要。每种 ORM 处理迁移的方式不同：

边缘场景和高级功能

决策框架

根据你的团队技能、项目需求和优先级选择 ORM：

ORM 最佳实践

• 始终在 WHERE 子句、JOIN 条件和 ORDER BY 中使用的列上添加数据库索引。ORM 不会自动添加索引，你必须在 schema 中定义它们。
• 明确指定关系加载方式。避免预加载整个关系树。使用 select/include（Prisma）、with（Drizzle）或 QueryBuilder 的 select 方法（TypeORM）只加载需要的数据。
• 对必须原子化的操作使用数据库事务。三种 ORM 都支持事务，但 API 不同。将相关写操作包装在单个事务中以确保数据一致性。
• 在开发中监控生成的 SQL。启用查询日志查看 ORM 生成的 SQL。查找 N+1 查询、不必要的 JOIN 和缺失的索引。
• 在生产环境中使用连接池，尤其是在 serverless 环境中。每种 ORM 有不同的连接池策略。
• 在生产环境中使用数据库迁移而非自动同步。自动同步可能意外删除列或表。在应用到生产前始终审查迁移 SQL。
• 使用集成测试针对真实数据库测试数据访问层。使用 Docker 启动测试数据库，运行迁移，填充数据，验证查询返回预期结果。
• 对复杂查询考虑使用原生 SQL。三种 ORM 都支持原生查询。当 ORM 抽象与你对抗时，降级到 SQL 而非与 ORM 抗争。

FAQ