[2026] Drizzle ORM 완벽 가이드 | TypeScript·SQL·마이그레이션·Prisma 대안

이 글의 핵심

Drizzle ORM은 TypeScript 우선 경량 ORM입니다. 스키마 정의부터 쿼리, 관계, 마이그레이션, Prisma 비교까지 실전 예제로 정리했습니다.

실무 경험 공유: API 서버를 Prisma에서 Drizzle로 마이그레이션하면서, 쿼리 성능을 30% 향상시키고 번들 크기를 50% 줄인 경험을 공유합니다.

들어가며: “Prisma가 무거워요”

실무 문제 시나리오

시나리오 1: Prisma가 느려요
복잡한 쿼리에서 Prisma가 느립니다. Drizzle은 Raw SQL에 가까운 성능입니다. 시나리오 2: 번들이 커요
Prisma 클라이언트가 5MB입니다. Drizzle은 100KB입니다. 시나리오 3: SQL을 직접 쓰고 싶어요
Prisma는 SQL을 숨깁니다. Drizzle은 SQL을 직접 제어할 수 있습니다.

1. Drizzle ORM이란?

핵심 특징

Drizzle은 TypeScript 우선 경량 ORM입니다. 주요 장점:

• 경량: 100KB (Prisma는 5MB)
• 빠른 성능: Raw SQL에 가까운 속도
• SQL 우선: SQL을 직접 제어
• 타입 안전: 자동 타입 추론
• Edge 지원: Cloudflare Workers 등 지원 데이터베이스:
• PostgreSQL
• MySQL
• SQLite
• Neon (Serverless Postgres)

---

2. 설치 및 설정

설치

아래 코드는 bash를 사용한 구현 예제입니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

npm install drizzle-orm
npm install -D drizzle-kit
# PostgreSQL
npm install pg
npm install -D @types/pg
# MySQL
npm install mysql2
# SQLite
npm install better-sqlite3

스키마 정의

다음은 typescript를 활용한 상세한 구현 코드입니다. 필요한 모듈을 import하고. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

// src/db/schema.ts
import { pgTable, serial, text, timestamp, integer, boolean } from 'drizzle-orm/pg-core';
export const users = pgTable('users', {
  id: serial('id').primaryKey(),
  email: text('email').notNull().unique(),
  name: text('name').notNull(),
  createdAt: timestamp('created_at').defaultNow(),
});
export const posts = pgTable('posts', {
  id: serial('id').primaryKey(),
  title: text('title').notNull(),
  content: text('content'),
  published: boolean('published').default(false),
  authorId: integer('author_id').references(() => users.id),
  createdAt: timestamp('created_at').defaultNow(),
});

데이터베이스 연결

아래 코드는 typescript를 사용한 구현 예제입니다. 필요한 모듈을 import하고. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

// src/db/index.ts
import { drizzle } from 'drizzle-orm/node-postgres';
import { Pool } from 'pg';
import * as schema from './schema';
const pool = new Pool({
  connectionString: process.env.DATABASE_URL,
});
export const db = drizzle(pool, { schema });

---

3. CRUD 작업

Create

아래 코드는 typescript를 사용한 구현 예제입니다. 필요한 모듈을 import하고, 비동기 처리를 통해 효율적으로 작업을 수행합니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

import { db } from './db';
import { users, posts } from './db/schema';
// 단일 생성
const user = await db.insert(users).values({
  email: 'john@example.com',
  name: 'John Doe',
}).returning();
// 다중 생성
const newUsers = await db.insert(users).values([
  { email: 'jane@example.com', name: 'Jane' },
  { email: 'bob@example.com', name: 'Bob' },
]).returning();

Read

다음은 typescript를 활용한 상세한 구현 코드입니다. 필요한 모듈을 import하고, 비동기 처리를 통해 효율적으로 작업을 수행합니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

import { eq, and, or, like, gt } from 'drizzle-orm';
// 전체 조회
const allUsers = await db.select().from(users);
// 조건 조회
const user = await db
  .select()
  .from(users)
  .where(eq(users.id, 1));
// 복잡한 조건
const filteredUsers = await db
  .select()
  .from(users)
  .where(
    and(
      like(users.email, '%@example.com'),
      gt(users.id, 10)
    )
  );
// 정렬 및 제한
const recentUsers = await db
  .select()
  .from(users)
  .orderBy(users.createdAt)
  .limit(10)
  .offset(0);

Update

아래 코드는 typescript를 사용한 구현 예제입니다. 비동기 처리를 통해 효율적으로 작업을 수행합니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

// 단일 업데이트
// 실행 예제
await db
  .update(users)
  .set({ name: 'John Smith' })
  .where(eq(users.id, 1));
// 다중 업데이트
await db
  .update(posts)
  .set({ published: true })
  .where(eq(posts.authorId, 1));

Delete

아래 코드는 typescript를 사용한 구현 예제입니다. 비동기 처리를 통해 효율적으로 작업을 수행합니다. 코드를 직접 실행해보면서 동작을 확인해보세요.

// 단일 삭제
await db
  .delete(users)
  .where(eq(users.id, 1));
// 조건 삭제
await db
  .delete(posts)
  .where(eq(posts.published, false));

---

4. 관계 (Relations)

스키마에 관계 정의

아래 코드는 typescript를 사용한 구현 예제입니다. 필요한 모듈을 import하고. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

import { relations } from 'drizzle-orm';
export const usersRelations = relations(users, ({ many }) => ({
  posts: many(posts),
}));
export const postsRelations = relations(posts, ({ one }) => ({
  author: one(users, {
    fields: [posts.authorId],
    references: [users.id],
  }),
}));

관계 쿼리

다음은 typescript를 활용한 상세한 구현 코드입니다. 비동기 처리를 통해 효율적으로 작업을 수행합니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

// 사용자와 포스트 함께 조회
const usersWithPosts = await db.query.users.findMany({
  with: {
    posts: true,
  },
});
// 특정 사용자의 포스트
const userWithPosts = await db.query.users.findFirst({
  where: eq(users.id, 1),
  with: {
    posts: {
      where: eq(posts.published, true),
      orderBy: posts.createdAt,
    },
  },
});

---

5. 마이그레이션

drizzle.config.ts

아래 코드는 typescript를 사용한 구현 예제입니다. 필요한 모듈을 import하고. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

// drizzle.config.ts
import type { Config } from 'drizzle-kit';
export default {
  schema: './src/db/schema.ts',
  out: './drizzle',
  driver: 'pg',
  dbCredentials: {
    connectionString: process.env.DATABASE_URL!,
  },
} satisfies Config;

마이그레이션 생성 및 적용

아래 코드는 bash를 사용한 구현 예제입니다. 코드를 직접 실행해보면서 동작을 확인해보세요.

# 마이그레이션 생성
npx drizzle-kit generate:pg
# 마이그레이션 적용
npx drizzle-kit push:pg
# Drizzle Studio (GUI)
npx drizzle-kit studio

---

6. 트랜잭션

아래 코드는 typescript를 사용한 구현 예제입니다. 비동기 처리를 통해 효율적으로 작업을 수행합니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

await db.transaction(async (tx) => {
  const user = await tx.insert(users).values({
    email: 'john@example.com',
    name: 'John',
  }).returning();
  await tx.insert(posts).values({
    title: 'First Post',
    authorId: user[0].id,
  });
});

---

7. Raw SQL

아래 코드는 typescript를 사용한 구현 예제입니다. 필요한 모듈을 import하고, 비동기 처리를 통해 효율적으로 작업을 수행합니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

import { sql } from 'drizzle-orm';
// Raw SQL 실행
const result = await db.execute(sql`
  SELECT * FROM users WHERE email LIKE ${'%@example.com'}
`);
// 타입 안전한 Raw SQL
const users = await db.execute<{ id: number; name: string }>(sql`
  SELECT id, name FROM users WHERE id > ${10}
`);

---

8. Prisma vs Drizzle 비교

스키마 정의

다음은 typescript를 활용한 상세한 구현 코드입니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

// Prisma
model User {
  id        Int      @id @default(autoincrement())
  email     String   @unique
  name      String
  posts     Post[]
  createdAt DateTime @default(now())
}
// Drizzle
export const users = pgTable('users', {
  id: serial('id').primaryKey(),
  email: text('email').notNull().unique(),
  name: text('name').notNull(),
  createdAt: timestamp('created_at').defaultNow(),
});

쿼리

아래 코드는 typescript를 사용한 구현 예제입니다. 비동기 처리를 통해 효율적으로 작업을 수행합니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

// Prisma
// 변수 선언 및 초기화
const users = await prisma.user.findMany({
  where: { email: { contains: '@example.com' } },
  include: { posts: true },
});
// Drizzle
const users = await db.query.users.findMany({
  where: like(users.email, '%@example.com'),
  with: { posts: true },
});

성능 비교

작업	Prisma	Drizzle
단순 조회	5ms	2ms
복잡한 JOIN	50ms	20ms
번들 크기	5MB	100KB

---

9. 실전 예제: 블로그 API

다음은 typescript를 활용한 상세한 구현 코드입니다. 필요한 모듈을 import하고. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

// src/db/schema.ts
import { pgTable, serial, text, timestamp, integer, boolean } from 'drizzle-orm/pg-core';
import { relations } from 'drizzle-orm';
export const users = pgTable('users', {
  id: serial('id').primaryKey(),
  email: text('email').notNull().unique(),
  name: text('name').notNull(),
  createdAt: timestamp('created_at').defaultNow(),
});
export const posts = pgTable('posts', {
  id: serial('id').primaryKey(),
  title: text('title').notNull(),
  content: text('content'),
  published: boolean('published').default(false),
  authorId: integer('author_id').references(() => users.id),
  createdAt: timestamp('created_at').defaultNow(),
  updatedAt: timestamp('updated_at').defaultNow(),
});
export const comments = pgTable('comments', {
  id: serial('id').primaryKey(),
  content: text('content').notNull(),
  postId: integer('post_id').references(() => posts.id),
  authorId: integer('author_id').references(() => users.id),
  createdAt: timestamp('created_at').defaultNow(),
});
export const usersRelations = relations(users, ({ many }) => ({
  posts: many(posts),
  comments: many(comments),
}));
export const postsRelations = relations(posts, ({ one, many }) => ({
  author: one(users, {
    fields: [posts.authorId],
    references: [users.id],
  }),
  comments: many(comments),
}));
export const commentsRelations = relations(comments, ({ one }) => ({
  post: one(posts, {
    fields: [comments.postId],
    references: [posts.id],
  }),
  author: one(users, {
    fields: [comments.authorId],
    references: [users.id],
  }),
}));

다음은 typescript를 활용한 상세한 구현 코드입니다. 필요한 모듈을 import하고, 비동기 처리를 통해 효율적으로 작업을 수행합니다, 에러 처리를 통해 안정성을 확보합니다, 조건문으로 분기 처리를 수행합니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

// src/api/posts.ts
import { db } from '../db';
import { posts, users, comments } from '../db/schema';
import { eq, desc } from 'drizzle-orm';
// 게시글 목록 (페이지네이션)
export async function getPosts(page: number = 1, limit: number = 10) {
  const offset = (page - 1) * limit;
  const [postList, total] = await Promise.all([
    db.query.posts.findMany({
      where: eq(posts.published, true),
      with: {
        author: {
          columns: {
            id: true,
            name: true,
            email: true,
          },
        },
      },
      orderBy: [desc(posts.createdAt)],
      limit,
      offset,
    }),
    db.select({ count: sql<number>`count(*)` })
      .from(posts)
      .where(eq(posts.published, true)),
  ]);
  return {
    posts: postList,
    total: total[0].count,
    page,
    totalPages: Math.ceil(total[0].count / limit),
  };
}
// 게시글 상세
export async function getPost(id: number) {
  const post = await db.query.posts.findFirst({
    where: eq(posts.id, id),
    with: {
      author: {
        columns: {
          id: true,
          name: true,
          email: true,
        },
      },
      comments: {
        with: {
          author: {
            columns: {
              id: true,
              name: true,
            },
          },
        },
        orderBy: [desc(comments.createdAt)],
      },
    },
  });
  if (!post) {
    throw new Error('Post not found');
  }
  return post;
}
// 게시글 생성
export async function createPost(data: {
  title: string;
  content: string;
  authorId: number;
}) {
  const [post] = await db.insert(posts).values(data).returning();
  return post;
}
// 게시글 수정
export async function updatePost(id: number, data: {
  title?: string;
  content?: string;
  published?: boolean;
}) {
  const [post] = await db
    .update(posts)
    .set({ ...data, updatedAt: new Date() })
    .where(eq(posts.id, id))
    .returning();
  return post;
}
// 게시글 삭제
export async function deletePost(id: number) {
  await db.delete(posts).where(eq(posts.id, id));
}

---

정리 및 체크리스트

핵심 요약

• Drizzle: TypeScript 우선 경량 ORM
• 경량: 100KB (Prisma는 5MB)
• 빠른 성능: Raw SQL에 가까운 속도
• SQL 우선: SQL을 직접 제어 가능
• Edge 지원: Serverless 환경 완벽 지원

구현 체크리스트

• Drizzle 설치
• 스키마 정의
• 데이터베이스 연결
• CRUD 작업 구현
• 관계 정의
• 마이그레이션 설정

---

같이 보면 좋은 글

• Prisma 완벽 가이드
• PostgreSQL 고급 가이드
• TypeScript 5 완벽 가이드

---

이 글에서 다루는 키워드

Drizzle, ORM, TypeScript, SQL, Database, PostgreSQL, MySQL

자주 묻는 질문 (FAQ)

Q. Drizzle vs Prisma, 어떤 게 나은가요?

A. Drizzle은 더 빠르고 가볍습니다. SQL을 직접 제어하고 싶다면 Drizzle, 추상화를 원한다면 Prisma를 권장합니다.

Q. Prisma에서 Drizzle로 마이그레이션이 어렵나요?

A. 스키마를 다시 작성해야 하지만, 쿼리 로직은 비슷합니다. 점진적 마이그레이션이 가능합니다.

Q. Edge 환경에서 사용할 수 있나요?

A. 네, Drizzle은 Cloudflare Workers, Vercel Edge 등에서 완벽하게 동작합니다.

Q. Drizzle Studio는 무엇인가요?

A. Prisma Studio와 유사한 GUI 도구입니다. npx drizzle-kit studio로 실행할 수 있습니다.