Drizzle ORM vs Prisma：TypeScript ORM 对决

TypeScript ORM已经显著发展，Drizzle和Prisma成为现代Web开发的两个主导选择。Prisma开创了以模式优先的方法，提供出色的开发者体验，而Drizzle提供了轻量级、SQL优先的替代方案，具有无与伦比的类型安全。本指南在性能、灵活性和开发者体验方面比较这两个ORM。

核心要点

ORM概述

什么是Drizzle ORM？

Drizzle ORM是一个轻量级的、类似SQL的TypeScript ORM。于2022年发布，它采取了与传统ORM截然不同的方法。Drizzle不是将SQL抽象掉，而是拥抱它。你的模式用TypeScript定义，查询看起来几乎与SQL相同，同时保持完全类型安全。

什么是Prisma？

Prisma是引入了模式优先方法的次世代ORM。于2019年发布，它使用声明式模式语言定义你的数据模型，然后生成完全类型化的客户端。Prisma包括强大的工具，如Prisma Studio（可视化数据库管理）和Prisma Migrate（模式迁移）。

设计理念

这两个ORM之间的根本差异在于它们的设计理念：

模式定义对比

比较在每个ORM中如何定义数据库模式：

Prisma Schema

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

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

model User {
  id        String   @id @default(uuid())
  email     String   @unique
  name      String?
  role      Role     @default(USER)
  posts     Post[]
  profile   Profile?
  createdAt DateTime @default(now())
  updatedAt DateTime @updatedAt

  @@map("users")
}

model Post {
  id          String    @id @default(uuid())
  title       String
  slug        String    @unique
  content     String?
  published   Boolean   @default(false)
  publishedAt DateTime?
  author      User      @relation(fields: [authorId], references: [id])
  authorId    String
  tags        Tag[]
  
  @@index([authorId])
  @@index([slug])
  @@map("posts")
}

model Profile {
  id     String  @id @default(uuid())
  bio    String?
  avatar String?
  user   User    @relation(fields: [userId], references: [id])
  userId String  @unique
  
  @@map("profiles")
}

model Tag {
  id    String @id @default(uuid())
  name  String @unique
  posts Post[]
  
  @@map("tags")
}

enum Role {
  USER
  ADMIN
  EDITOR
}

Drizzle Schema

// src/db/schema.ts
import { 
  pgTable, 
  uuid, 
  varchar, 
  text, 
  boolean, 
  timestamp, 
  pgEnum,
  index,
  uniqueIndex
} from 'drizzle-orm/pg-core';
import { relations } from 'drizzle-orm';

// Enum definition
export const roleEnum = pgEnum('role', ['USER', 'ADMIN', 'EDITOR']);

// Tables
export const users = pgTable('users', {
  id: uuid('id').primaryKey().defaultRandom(),
  email: varchar('email', { length: 255 }).notNull().unique(),
  name: text('name'),
  role: roleEnum('role').default('USER').notNull(),
  createdAt: timestamp('created_at').defaultNow().notNull(),
  updatedAt: timestamp('updated_at').defaultNow().notNull(),
}, (table) => ({
  emailIdx: uniqueIndex('email_idx').on(table.email),
}));

export const posts = pgTable('posts', {
  id: uuid('id').primaryKey().defaultRandom(),
  title: varchar('title', { length: 255 }).notNull(),
  slug: varchar('slug', { length: 255 }).notNull().unique(),
  content: text('content'),
  published: boolean('published').default(false).notNull(),
  publishedAt: timestamp('published_at'),
  authorId: uuid('author_id').notNull().references(() => users.id),
  createdAt: timestamp('created_at').defaultNow().notNull(),
  updatedAt: timestamp('updated_at').defaultNow().notNull(),
}, (table) => ({
  authorIdx: index('author_idx').on(table.authorId),
  slugIdx: uniqueIndex('slug_idx').on(table.slug),
}));

export const profiles = pgTable('profiles', {
  id: uuid('id').primaryKey().defaultRandom(),
  bio: text('bio'),
  avatar: text('avatar'),
  userId: uuid('user_id').notNull().unique().references(() => users.id),
});

export const tags = pgTable('tags', {
  id: uuid('id').primaryKey().defaultRandom(),
  name: varchar('name', { length: 100 }).notNull().unique(),
});

// Many-to-many junction table
export const postTags = pgTable('post_tags', {
  postId: uuid('post_id').notNull().references(() => posts.id),
  tagId: uuid('tag_id').notNull().references(() => tags.id),
});

// Relations (for query builder)
export const usersRelations = relations(users, ({ one, many }) => ({
  posts: many(posts),
  profile: one(profiles),
}));

export const postsRelations = relations(posts, ({ one, many }) => ({
  author: one(users, {
    fields: [posts.authorId],
    references: [users.id],
  }),
  tags: many(postTags),
}));

查询语法对比

每个ORM中的查询看起来如何：

Prisma Queries

// Prisma Client queries
import { PrismaClient } from '@prisma/client';
const prisma = new PrismaClient();

// Create user with posts
const user = await prisma.user.create({
  data: {
    email: 'john@example.com',
    name: 'John Doe',
    posts: {
      create: [
        { title: 'Hello World', slug: 'hello-world' },
        { title: 'Second Post', slug: 'second-post' },
      ],
    },
  },
  include: { posts: true },
});

// Query with filters and relations
const posts = await prisma.post.findMany({
  where: {
    published: true,
    author: { role: 'ADMIN' },
  },
  include: {
    author: { select: { name: true, email: true } },
    tags: true,
  },
  orderBy: { createdAt: 'desc' },
  take: 10,
});

// Update with transaction
const [updatedPost, updatedUser] = await prisma.$transaction([
  prisma.post.update({
    where: { id: 'post-id' },
    data: { published: true },
  }),
  prisma.user.update({
    where: { id: 'user-id' },
    data: { role: 'EDITOR' },
  }),
]);

// Aggregation
const stats = await prisma.post.aggregate({
  where: { published: true },
  _count: true,
  _avg: { views: true },
});

Drizzle Queries

// Drizzle ORM queries
import { drizzle } from 'drizzle-orm/node-postgres';
import { eq, and, desc, sql } from 'drizzle-orm';
import * as schema from './schema';

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

// Insert user with returning
const [user] = await db.insert(schema.users)
  .values({
    email: 'john@example.com',
    name: 'John Doe',
  })
  .returning();

// Insert posts
await db.insert(schema.posts).values([
  { title: 'Hello World', slug: 'hello-world', authorId: user.id },
  { title: 'Second Post', slug: 'second-post', authorId: user.id },
]);

// SQL-like query with joins
const posts = await db
  .select({
    id: schema.posts.id,
    title: schema.posts.title,
    slug: schema.posts.slug,
    authorName: schema.users.name,
    authorEmail: schema.users.email,
  })
  .from(schema.posts)
  .leftJoin(schema.users, eq(schema.posts.authorId, schema.users.id))
  .where(eq(schema.posts.published, true))
  .orderBy(desc(schema.posts.createdAt))
  .limit(10);

// Relational queries (similar to Prisma)
const usersWithPosts = await db.query.users.findMany({
  with: {
    posts: {
      where: eq(schema.posts.published, true),
      orderBy: desc(schema.posts.createdAt),
    },
    profile: true,
  },
  where: eq(schema.users.role, 'ADMIN'),
});

// Transaction
await db.transaction(async (tx) => {
  await tx.update(schema.posts)
    .set({ published: true })
    .where(eq(schema.posts.id, 'post-id'));
  
  await tx.update(schema.users)
    .set({ role: 'EDITOR' })
    .where(eq(schema.users.id, 'user-id'));
});

// Raw SQL when needed
const result = await db.execute(sql`
  SELECT u.name, COUNT(p.id) as post_count
  FROM users u
  LEFT JOIN posts p ON p.author_id = u.id
  WHERE p.published = true
  GROUP BY u.name
  ORDER BY post_count DESC
`);

性能基准测试

常见操作的真实性能对比：

边缘运行时支持

在边缘函数和serverless上运行ORM：

// Drizzle on Cloudflare Workers
import { drizzle } from 'drizzle-orm/d1';  // or neon, turso

export default {
  async fetch(request: Request, env: Env) {
    const db = drizzle(env.DB);  // D1 database binding
    
    const users = await db.select().from(usersTable);
    
    return Response.json({ users });
  },
};

// Prisma on Cloudflare Workers (requires Accelerate)
import { PrismaClient } from '@prisma/client/edge';
import { withAccelerate } from '@prisma/extension-accelerate';

const prisma = new PrismaClient({
  datasourceUrl: env.DATABASE_URL,
}).$extends(withAccelerate());

export default {
  async fetch(request: Request, env: Env) {
    const users = await prisma.user.findMany({
      cacheStrategy: { ttl: 60 },
    });
    
    return Response.json({ users });
  },
};

何时使用每个ORM

结论

Drizzle和Prisma都是2025年TypeScript ORM的绝佳选择。Drizzle代表了SQL优先、边缘原生数据库访问的未来，具有无与伦比的性能。Prisma继续通过强大的工具和成熟的生态系统提供最佳的开发者体验。选择最终取决于你团队的SQL舒适度、性能要求和部署目标。许多团队成功地同时使用两者：Drizzle用于边缘函数和性能关键路径，Prisma用于传统服务器应用。

FAQ