DataLoader는 어떻게 N+1을 없애는가

DataLoader의 배치 처리 원리, 이벤트 루프와의 관계, 중첩 resolver에서 어떻게 구조화하는지 구체적으로 정리했습니다.

Backend·
#DataLoader#GraphQL#NestJS#N+1#이벤트루프

DataLoader를 처음 접하면 이런 의문이 생겨요.

@ResolveField(() => [Comment])
async comments(@Parent() post: Post) {
  return this.commentLoader.load(post.id);  // post마다 개별 호출
}

post가 20개면 load()가 20번 호출된다.
그런데 DB 쿼리는 1번만 실행된다고?

어떻게 이게 가능한지, 그리고 중첩 resolver에서 어떻게 구조화하는지 살펴보자.

핵심 원리: 이벤트 루프 한 틱

DataLoader의 핵심은 JavaScript 이벤트 루프에 있다.

load(id)를 호출하면 DataLoader는 즉시 DB를 조회하지 않는다.
대신 현재 콜스택이 비워질 때까지 요청을 큐에 쌓는다.

콜스택 실행 중:
  load(1) 호출 → 큐: [1]
  load(2) 호출 → 큐: [1, 2]
  load(3) 호출 → 큐: [1, 2, 3]
  ...
  load(20) 호출 → 큐: [1, 2, ..., 20]


콜스택 비워짐 → process.nextTick 실행
  → 배치 함수 호출 → SELECT WHERE post_id IN (1, ..., 20)

"틱"은 몇 초라는 고정 시간이 아니다.
현재 콜스택이 비워지는 순간이다. 20개든 1000개든 같은 콜스택 안에서 호출되면 전부 모인다.

GraphQL resolver는 같은 depth의 필드를 동기적으로 순회하기 때문에,
posts 20개의 comments resolver 호출이 전부 같은 콜스택 안에서 일어난다.
그래서 DataLoader가 20개를 한 번에 배치할 수 있는 것.

코드로 보는 동작 흐름

DataLoader 생성 시 배치 함수를 넘긴다.

@Injectable({ scope: Scope.REQUEST })
export class CommentLoader {
  private loader = new DataLoader<number, Comment[]>(
    async (postIds: readonly number[]) => {
      // 틱이 끝난 뒤 모인 id 배열로 딱 한 번 호출됨
      const comments = await this.commentService.findByPostIds([...postIds]);
      // SELECT * FROM comment WHERE post_id IN (1, 2, ..., 20)


      // 입력 순서 그대로 결과를 매핑해서 반환 — 이 규칙은 필수
      return postIds.map(id =>
        comments.filter(c => c.postId === id)
      );
    }
  );


  load(postId: number) {
    return this.loader.load(postId);  // Promise 반환
  }
}
@ResolveField(() => [Comment])
async comments(@Parent() post: Post) {
  return this.commentLoader.load(post.id);
}

시간축으로 보면:

t=0ms  post1.comments → load(1) → 큐: [1]
t=0ms  post2.comments → load(2) → 큐: [1, 2]
t=0ms  post3.comments → load(3) → 큐: [1, 2, 3]
       콜스택 비워짐
t=1ms  배치 함수 실행 → SELECT WHERE post_id IN (1, 2, 3)
t=5ms  결과 반환 → load(1), load(2), load(3) 각각 resolve

배치 함수의 규칙

배치 함수에는 반드시 지켜야 할 규칙이 있다.

입력 배열과 출력 배열의 순서와 길이가 일치해야 한다.

// 입력:  [1,      2,      3     ]
// 출력:  [comments of 1, comments of 2, comments of 3]
//        인덱스가 정확히 대응해야 함


return postIds.map(id =>
  comments.filter(c => c.postId === id)
);

DataLoader는 load(1)의 결과를 출력 배열의 0번 인덱스에서 꺼낸다.
순서가 틀리면 엉뚱한 데이터가 반환된다.

캐싱

DataLoader는 같은 요청 안에서 동일한 id를 두 번 load하면 캐시에서 반환한다.

loader.load(1)  // DB 조회
loader.load(1)  // 캐시 히트 — DB 조회 없음
loader.load(2)  // DB 조회

같은 GraphQL 요청 안에서 여러 컴포넌트가 동일한 데이터를 요청해도 DB는 1번만 조회된다.

캐시는 요청 단위여야 한다. NestJS에서 SINGLETON으로 등록하면 이전 요청의 캐시가 남아서 다른 사용자에게 잘못된 데이터가 반환될 수 있다.

@Injectable({ scope: Scope.REQUEST })  // 요청마다 새 인스턴스 — 필수
export class CommentLoader { ... }

중첩 resolver에서의 구조화

N+1은 list에만 생기지 않는다.
중첩이 깊어지면 단건 조회여도 발생한다.

query {
  posts {           # 20개
    comments {      # post마다 10개 → 200개
      author {      # comment마다 → author resolver 200번 실행
        name
      }
    }
  }
}

DataLoader 없이 중첩하면:

posts 조회:    1번
comments 조회: 20번   (post 개수)
author 조회:   200번  (comment 개수)


총 221번

DataLoader는 각 엔티티 타입마다 하나씩 만든다.

// "comment를 post_id로 불러오는 것"
@Injectable({ scope: Scope.REQUEST })
export class CommentLoader {
  private loader = new DataLoader<number, Comment[]>(
    async (postIds: readonly number[]) => {
      const comments = await this.commentService.findByPostIds([...postIds]);
      return postIds.map(id => comments.filter(c => c.postId === id));
    }
  );
  load(postId: number) { return this.loader.load(postId); }
}
// "user를 user_id로 불러오는 것"
@Injectable({ scope: Scope.REQUEST })
export class UserLoader {
  private loader = new DataLoader<number, User>(
    async (userIds: readonly number[]) => {
      const users = await this.userService.findByIds([...userIds]);
      return userIds.map(id => users.find(u => u.id === id));
    }
  );
  load(userId: number) { return this.loader.load(userId); }
}

각 Loader는 서로를 모른다. 완전히 독립적이다.

@ResolveField(() => [Comment])
async comments(@Parent() post: Post) {
  return this.commentLoader.load(post.id);  // CommentLoader 사용
}
@ResolveField(() => User)
async author(@Parent() comment: Comment) {
  return this.userLoader.load(comment.authorId);  // UserLoader 사용
}

PostResolver는 CommentLoader만 알고, CommentResolver는 UserLoader만 안다.
중첩 구조를 PostResolver가 파악할 필요 없다. GraphQL 엔진이 체이닝을 알아서 처리한다.

DataLoader 적용 후 쿼리 횟수:

posts 조회:    1번  → SELECT * FROM post
comments 조회: 1번  → SELECT * FROM comment WHERE post_id IN (1..20)
author 조회:   1번  → SELECT * FROM user WHERE id IN (1..200)


총 3번  (depth 수만큼)

depth가 10단계여도 쿼리는 10번. 데이터 규모와 무관하게 고정된다.

의존성 구조

PostResolver    → CommentLoader  (post_id 기준으로 comment 로드)
CommentResolver → UserLoader     (user_id 기준으로 user 로드)


CommentLoader  ↔  UserLoader     → 서로 모름, 의존 없음

DataLoader는 "무엇을 어떤 키로 불러오는가" 단위로 만든다.
중첩 구조나 어느 resolver가 쓰는지는 신경 쓰지 않는다.

정리

DataLoader가 N+1을 없애는 방식:

  1. load(id) 호출 시 즉시 DB 조회 않고 큐에 쌓는다
  2. 콜스택이 비워지면 (process.nextTick) 큐의 id들을 배치 함수에 넘긴다
  3. 배치 함수가 IN 쿼리 하나로 모든 id를 처리한다
  4. 결과를 입력 순서대로 매핑해서 각 load() Promise로 분배한다
  5. 동일 id 재요청은 캐시에서 반환한다
  6. Loader는 엔티티 타입마다 독립적으로 만들고, resolver에서 주입해서 쓴다

© 2026 raw