DotNet
Dictionary
N+1 문제

N+1 문제

N+1 문제는 데이터베이스 쿼리 성능과 관련된 문제로, 특히 ORM(Object-Relational Mapping) 도구에서 자주 발생합니다. 이 문제는 주로 다대일(One-to-Many) 또는 일대다(Many-to-One) 관계의 데이터를 조회할 때 나타나며, 쿼리가 불필요하게 많이 실행되어 성능 저하를 일으키는 현상을 말합니다.

N+1 문제의 예시

예를 들어, User와 Book이 1:N 관계(하나의 유저가 여러 책을 빌릴 수 있음)로 연결되어 있다고 가정해 봅시다.

public class User
{
    public int Id { get; set; }
    public string Name { get; set; }
    public List<Book> Books { get; set; }
}
public class Book
{
    public int Id { get; set; }
    public string Title { get; set; }
    public int UserId { get; set; }
    public User User { get; set; }
}

다음과 같이 모든 사용자를 가져오고, 각 사용자가 빌린 책을 출력한다고 가정합니다.

var users = context.Users.ToList();  // 모든 사용자 조회
foreach (var user in users)
{
    var books = context.Books.Where(b => b.UserId == user.Id).ToList();  // 각 사용자가 빌린 책 조회
    Console.WriteLine($"User: {user.Name}, Books: {string.Join(", ", books.Select(b => b.Title))}");
}

이 경우, 첫 번째 쿼리로 모든 사용자를 가져오는 쿼리가 실행되고, 그 후 각 사용자의 책을 가져오는 쿼리가 실행됩니다. 만약 사용자가 100명이라면 1개의 사용자 조회 쿼리 + 100개의 책 조회 쿼리가 실행되므로 총 N+1개의 쿼리가 발생합니다.

N+1 문제 해결

Eager Loading 예제

Eager Loading은 연관된 데이터를 처음부터 함께 가져오는 방식입니다. 이를 통해 N+1 문제를 해결할 수 있습니다. 일반적으로 Include() 메서드를 사용하여 관련된 엔터티를 미리 로드합니다.

예제: Eager Loading을 사용하여 User와 Books를 함께 조회 

var users = context.Users
                   .Include(u => u.Books)  // Eager Loading: User와 관련된 Book 데이터를 함께 가져옴
                   .ToList();
foreach (var user in users)
{
    Console.WriteLine($"User: {user.Name}, Books: {string.Join(", ", user.Books.Select(b => b.Title))}");
}

이 코드는 Users와 관련된 Books 데이터를 한 번의 쿼리로 함께 가져옵니다. 이 방식으로 추가 쿼리가 발생하지 않아 N+1 문제를 해결할 수 있습니다.

  • 장점: 한 번의 쿼리로 관련된 데이터를 모두 가져오기 때문에 N+1 문제를 해결할 수 있음.
  • 단점: 많은 데이터를 한 번에 로드하므로, 대량의 데이터를 처리할 때 성능에 문제가 생길 수 있음.

Batch Fetching 예제

Batch Fetching은 ORM 도구에서 연관된 데이터를 Batch 단위로 한꺼번에 가져오는 방식입니다. 이 방식은 연관된 데이터에 대해 N+1 쿼리를 줄여주며, Hibernate 같은 ORM에서 자주 사용됩니다. .NET의 EF Core에서는 이와 유사한 패턴으로 AsSplitQuery()를 사용할 수 있습니다.

예제: Batch Fetching을 사용한 User와 Books 조회 

var users = context.Users
                   .AsSplitQuery()  // Batch Fetching: 여러 테이블을 분리된 쿼리로 로드
                   .Include(u => u.Books)
                   .ToList();
foreach (var user in users)
{
    Console.WriteLine($"User: {user.Name}, Books: {string.Join(", ", user.Books.Select(b => b.Title))}");
}

AsSplitQuery()를 사용하면, User와 Books가 분리된 쿼리로 조회되며, 관련된 데이터가 Batch 단위로 적절히 나뉘어 가져옵니다. 이 방식은 단일 대형 쿼리로 인한 성능 문제를 완화하면서도 N+1 문제를 해결하는 방법입니다.

  • 장점: 관련 데이터를 적절한 크기로 나누어 가져옴으로써 메모리 부담을 줄이고 N+1 문제를 해결함.
  • 단점: 데이터베이스에서 여러 개의 쿼리를 실행해야 하므로, 경우에 따라서는 JOIN 방식보다 느릴 수 있음.

JOIN 쿼리 예제

JOIN 쿼리는 데이터베이스에서 SQL JOIN을 통해 관련된 데이터를 한 번의 쿼리로 결합하는 방식입니다. 이는 직접적으로 SQL 쿼리를 작성하거나, LINQ에서 Join() 연산자를 사용하여 구현할 수 있습니다.

예제: SQL JOIN을 사용한 User와 Books 조회 

var query = from user in context.Users
            join book in context.Books on user.Id equals book.UserId
            select new
            {
                UserName = user.Name,
                BookTitle = book.Title
            };
var result = query.ToList();
foreach (var entry in result)
{
    Console.WriteLine($"User: {entry.UserName}, Book: {entry.BookTitle}");
}

이 코드는 SQL JOIN을 사용하여 User와 Books를 한 번의 쿼리로 결합하여 조회합니다. 이렇게 하면 추가적인 N+1 쿼리가 발생하지 않으며, 데이터베이스 성능을 최적화할 수 있습니다.

  • 장점: 직접적인 SQL JOIN을 통해 한 번에 데이터를 가져올 수 있어 성능이 뛰어남.
  • 단점: 관계형 데이터베이스에서 JOIN을 남발할 경우 복잡한 쿼리가 성능 문제를 일으킬 수 있으며, ORM의 추상화 계층을 무시하고 SQL에 의존할 가능성이 있음.
Buy me a coffee Buy me a coffee
파일시스템 감시Spin-Waiting