Subquery 및 Window 함수를 사용한 고급 Django 데이터베이스 쿼리

소개

웹 개발의 세계에서 데이터는 왕이며, 해당 데이터를 효과적으로 쿼리하는 능력은 애플리케이션을 만들거나 망가뜨릴 수 있습니다. Django의 ORM은 대부분의 일반적인 데이터베이스 작업에 대해 강력하고 직관적인 인터페이스를 제공하지만, 실제 시나리오에서는 종종 더 정교한 분석 기능이 필요합니다. 단순히 레코드를 가져오는 것만으로는 충분하지 않습니다. 종종 다른 레코드에 의존하는 집계를 수행하거나, 그룹 내에서 항목의 순위를 매기거나, 데이터셋의 전체 평균 또는 총계와 값을 비교해야 합니다. 이것이 바로 Django ORM의 고급 기능이 실제로 빛을 발하는 곳이며, 특히 데이터베이스 Subquery 및 Window 함수의 힘을 활용할 때 그렇습니다. 이러한 도구를 사용하면 단순한 CRUD 작업을 넘어 복잡한 데이터 분석을 Python 코드 내에서 직접 수행할 수 있으므로 원시 SQL이나 애플리케이션 로직에서 데이터를 후처리하는 것보다 더 효율적이고 읽기 쉬운 솔루션을 얻을 수 있습니다. 이 글에서는 Django의 Subquery 및 Window 표현식을 활용하여 이러한 복잡한 데이터베이스 문제를 해결하는 방법을 살펴보고 데이터를 더 깊이 이해할 수 있도록 합니다.

빌딩 블록 이해

복잡한 예제를 살펴보기 전에 핵심 개념인 Subquery 및 Window Function을 명확하게 이해해 봅시다.

Subquery: Subquery는 본질적으로 다른 SQL 쿼리 내부에 중첩된 쿼리입니다. SELECT, FROM, WHERE 또는 HAVING 절에서 식이 예상되는 모든 곳에서 사용할 수 있습니다. 핵심 아이디어는 내부 쿼리가 외부 쿼리에서 처리되는 각 행마다 한 번씩 (또는 컨텍스트에 따라 전체 외부 쿼리에 대해 한 번씩) 실행되며, 그 결과는 외부 쿼리 평가의 일부가 된다는 것입니다. Django에서 Subquery 표현식을 사용하면 별도의 QuerySet의 결과를 기본 쿼리에 직접 통합하여 관련 데이터를 기반으로 필터링, 주석 추가 또는 정렬하는 데 자주 사용할 수 있습니다.

Window Function: 집계 함수(예: SUM 또는 COUNT)는 전체 그룹에 대해 단일 결과 행을 생성하는 반면, Window Function은 현재 행과 어떤 식으로든 관련된 테이블 행 집합에 걸쳐 계산을 수행합니다. 중요하게도, 행을 축소하지 않습니다. 대신 쿼리의 각 행에 대한 결과를 반환하여 개별 행 세부 정보를 유지하면서 순위, 누계 또는 이동 평균과 같은 집계와 유사한 값을 계산할 수 있습니다. "Window"는 함수가 작동하는 행 집합을 나타냅니다. 이 Window는 데이터를 그룹으로 분할하거나 해당 파티션 내에서 행을 정렬하여 정의할 수 있습니다.

복잡한 쿼리 구현

가상의 전자 상거래 애플리케이션을 사용하여 이러한 개념을 실제 예제로 설명해 보겠습니다. Product와 Order라는 두 개의 모델이 있다고 가정해 보겠습니다.

# models.py
from django.db import models

class Product(models.Model):
    name = models.CharField(max_length=200)
    category = models.CharField(max_length=100)
    price = models.DecimalField(max_digits=10, decimal_places=2)
    stock = models.IntegerField(default=0)

    def __str__(self):
        return self.name

class Order(models.Model):
    product = models.ForeignKey(Product, on_delete=models.CASCADE)
    quantity = models.IntegerField()
    order_date = models.DateTimeField(auto_now_add=True)
    total_price = models.DecimalField(max_digits=10, decimal_places=2)

    def __str__(self):
        return f"Order for {self.product.name} (Qty: {self.quantity})"

시나리오 1: Subquery를 사용하여 관련 데이터로 주석 달기

문제: 각 제품에 대해 모든 주문에 걸쳐 총 주문 수량을 알고 싶습니다.

Subquery 없이는 모든 제품을 검색한 다음 각 제품의 주문을 루프하여 비효율적일 수 있습니다(N+1 쿼리 문제). Subquery를 사용하면 단일 쿼리로 수행할 수 있습니다.

from django.db.models import OuterRef, Sum, Subquery

# 각 제품에 대해 total_ordered_quantity 찾기
products_with_total_orders = Product.objects.annotate(
    total_ordered_quantity=Subquery(
        Order.objects.filter(product=OuterRef('pk'))
        .values('product') # Subquery 내 집계에 필요
        .annotate(total_qty=Sum('quantity'))
        .values('total_qty')
    )
).order_by('name')

for product in products_with_total_orders:
    print(f"Product: {product.name}, Total Ordered: {product.total_ordered_quantity or 0}")

다음은 분석입니다:

• OuterRef('pk'): 상관 Subquery에 중요합니다. 외부 쿼리의 Product 인스턴스의 pk(기본 키)를 참조합니다. 외부 Product.objects 쿼리셋의 각 제품에 대해 OuterRef('pk')는 해당 제품 ID를 Subquery의 필터에 효과적으로 삽입합니다.
• Order.objects.filter(product=OuterRef('pk')): 외부 쿼리에서 처리 중인 현재 제품에 특정한 주문을 필터링합니다.
• .values('product').annotate(total_qty=Sum('quantity')).values('total_qty'): 이 부분은 필터링된 주문의 quantity를 집계하고 계산된 total_qty만 선택합니다. 집계를 수행하고 해당 집계에 대해 기본 키 외래 키로 그룹화하기를 원하므로 .values('product')가 필요합니다.

이 쿼리는 다음과 유사한 SQL을 생성합니다.

SELECT
    "product"."id",
    "product"."name",
    "product"."category",
    "product"."price",
    "product"."stock",
    (SELECT SUM(T2."quantity") AS "total_qty"
     FROM "myapp_order" T2
     WHERE T2."product_id" = "product"."id"
     GROUP BY T2."product_id"
    ) AS "total_ordered_quantity"
FROM "product"
ORDER BY "product"."name"

시나리오 2: Window 함수를 사용하여 순위 매기기

문제: 각 범주 내에서 제품의 순위를 가격별로 매기려고 합니다(높은 가격 우선).

from django.db.models import F, Window
from django.db.models.functions import DenseRank

products_ranked_by_price_in_category = Product.objects.annotate(
    rank_in_category=Window(
        expression=DenseRank(),
        partition_by=[F('category')],
        order_by=[F('price').desc(), F('name').asc()] # 동점 처리
    )
).order_by('category', 'rank_in_category')

for product in products_ranked_by_price_in_category:
    print(f"Category: {product.category}, Product: {product.name}, Price: {product.price}, Rank: {product.rank_in_category}")

주요 요소:

• Window(...): Window 함수를 정의하기 위한 진입점입니다.
• expression=DenseRank(): Window 함수로 DenseRank를 사용합니다. 다른 옵션으로는 RowNumber, Rank, Ntile, Lag, Lead, FirstValue, LastValue, PercentRank, CumeDist 등이 있습니다.
• partition_by=[F('category')]: "Window" 또는 그룹을 정의합니다. 각 고유 category에 대해 순위가 재설정됩니다.
• order_by=[F('price').desc(), F('name').asc()]: 각 파티션 내에서 행이 적용되기 전에 정렬되는 방법을 지정합니다. 가장 높은 가격이 먼저 옵니다. 가격이 동점인 경우 name이 안정적인 동점 처리 순서에 사용됩니다.

생성된 SQL은 다음과 유사할 것입니다.

SELECT
    "product"."id",
    "product"."name",
    "product"."category",
    "product"."price",
    "product"."stock",
    DENSE_RANK() OVER (PARTITION BY "product"."category" ORDER BY "product"."price" DESC, "product"."name" ASC) AS "rank_in_category"
FROM "product"
ORDER BY "product"."category" ASC, "rank_in_category" ASC

시나리오 3: Subquery와 Window 함수 결합

문제: 각 제품에 대해 총 주문 수량을 알고 같은 범주 내 모든 제품 중에서 해당 수량이 어떻게 순위를 매기는지 알고 싶습니다.

이 시나리오는 이전 두 시나리오를 결합하여 ORM의 유연성을 보여줍니다.

from django.db.models import OuterRef, Sum, Subquery, F, Window
from django.db.models.functions import DenseRank

# 먼저 Subquery를 사용하여 각 제품의 총 주문 수량을 가져옵니다.
products_with_total_orders = Product.objects.annotate(
    total_ordered_quantity=Subquery(
        Order.objects.filter(product=OuterRef('pk'))
        .values('product')
        .annotate(total_qty=Sum('quantity'))
        .values('total_qty')
    )
)

# 이제 결과에 Window 함수를 적용하여 이 총 수량별로 순위를 매깁니다.
products_ranked_by_ordered_quantity = products_with_total_orders.annotate(
    rank_by_sales_in_category=Window(
        expression=DenseRank(),
        partition_by=[F('category')],
        order_by=[F('total_ordered_quantity').desc(nulls_last=True), F('name').asc()] # 주문이 없는 경우 잠재적 NULL 처리
    )
).order_by('category', 'rank_by_sales_in_category')

for product in products_ranked_by_ordered_quantity:
    print(f"Category: {product.category}, Product: {product.name}, Total Ordered: {product.total_ordered_quantity or 0}, Sales Rank: {product.rank_by_sales_in_category}")

이 복합 쿼리에서는 다음과 같습니다:

1. 먼저 Subquery를 사용하여 total_ordered_quantity를 주석으로 추가합니다. 이렇게 하면 total_ordered_quantity가 각 Product 인스턴스에 주석으로 사용할 수 있게 됩니다.
2. 그런 다음 이 주석이 추가된 QuerySet을 가져와 Window 함수를 적용합니다. Window 함수는 각 category 파티션 내에서 주문을 받는 새로운 total_ordered_quantity 필드를 사용합니다. desc()에 대한 nulls_last=True를 참고하여 주문이 없는 제품(해당 total_ordered_quantity는 None이 됨)을 올바르게 처리합니다.

이 접근 방식은 복잡한 쿼리를 점진적으로 구축하고 한 ORM 표현식의 출력을 다른 표현식의 입력으로 활용하는 방법을 보여주며, 모두 우아하고 데이터베이스에 구애받지 않는 Python 구문으로 가능합니다.

결론

Django의 Subquery 및 Window 표현식은 애플리케이션 코드 내에서 직접 복잡한 데이터베이스 분석을 수행하는 데 필수적인 도구입니다. 이러한 기능을 통해 복잡한 데이터 집계 및 순위 요구 사항을 효율적이고 읽기 쉬우며 유지 관리 가능한 ORM 쿼리로 변환하여 원시 SQL이나 Python에서 데이터를 후처리하는 함정을 피할 수 있습니다. 이러한 기능을 이해하고 효과적으로 사용함으로써 개발자는 데이터에서 더 깊은 통찰력을 얻어 더 지능적이고 반응적인 애플리케이션을 만들 수 있습니다. 이러한 고급 ORM 기술을 마스터하면 데이터 상호 작용 기능이 크게 향상됩니다.