Bagaimana `select_related` dan `prefetch_related` menghindari masalah N+1?

Question

Accepted Answer

Masalah **N+1 query** adalah isu performa ORM Django yang paling umum: mengakses objek terkait dalam loop memicu query database yang terpisah untuk masing-masing. **`select_related`** dan **`prefetch_related`** menyelesaikannya dengan mengambil data terkait secara efisien — ini adalah tools optimasi yang esensial.

## Masalah N+1

```python
# ❌ N+1 queries
books = Book.objects.all()              # 1 query: fetch all books
for book in books:
    print(book.author.name)             # +1 query PER book to fetch its author!
# 100 books → 1 + 100 = 101 queries (terrible performance)
```

Setiap akses `book.author` secara lazy melakukan query database lagi. Dengan 100 buku, itu adalah 101 queries — pembunuh performa yang parah dan tersembunyi yang sering hanya muncul dengan volume data nyata.

## select_related — untuk ForeignKey / OneToOne (SQL JOIN)

```python
# ✅ ONE query with a JOIN
books = Book.objects.select_related("author").all()
for book in books:
    print(book.author.name)             # NO extra queries — author was JOINed in
# 100 books → 1 query total
```

`select_related` melakukan SQL **JOIN** untuk mengambil objek terkait dalam query yang *sama*. Gunakan untuk **forward ForeignKey dan OneToOne** relationships (single related object), di mana JOIN efisien.

## prefetch_related — untuk ManyToMany / reverse FK (separate query)

```python
# ✅ TWO queries total (not N+1)
authors = Author.objects.prefetch_related("books").all()
for author in authors:
    for book in author.books.all():     # NO extra queries — books were prefetched
        print(book.title)
# query 1: all authors; query 2: all their books → Django joins them in Python
```

`prefetch_related` menjalankan **query terpisah** untuk objek terkait dan menggabungkannya di Python. Gunakan untuk **ManyToMany dan reverse ForeignKey** relationships (multiple related objects), di mana JOIN akan mengalikan baris secara tidak efisien.

## Mana yang digunakan

```text
select_related   → ForeignKey, OneToOne (forward, single object) → SQL JOIN, 1 query
prefetch_related → ManyToMany, reverse ForeignKey (many objects) → 2 queries, joined in Python
You can combine and chain them, and span relationships:
  Book.objects.select_related("author").prefetch_related("tags")
  Book.objects.select_related("author__publisher")   # multi-level
```

## Mendeteksi masalah N+1

```text
✓ Django Debug Toolbar — shows the query count per page (spot N+1 visually)
✓ django-silk, or logging queries (connection.queries) to count them
→ If a page runs hundreds of similar queries, you likely have an N+1.
```

## Mengapa ini penting

Masalah N+1 query adalah **isu performa paling umum dan berdampak tunggal** dalam aplikasi Django, dan memahami `select_related`/`prefetch_related` adalah esensial untuk menulis code yang performan.

Masalahnya tersembunyi karena syntax ORM yang nyaman yang membuat mengakses objek terkait begitu mudah (`book.author.name`) secara diam-diam memicu query database setiap kali — code yang bekerja baik dengan beberapa record mengalami degradasi katastrofal dengan volume data nyata (100 record → 101 queries), sering hanya ditemukan di production di bawah beban.

Kedua tools ini adalah solusi standar dan esensial: **`select_related`** menggunakan SQL JOIN untuk mengambil forward ForeignKey/OneToOne relationships dalam single query, sementara **`prefetch_related`** menggunakan query terpisah (digabung di Python) untuk ManyToMany/reverse-ForeignKey relationships di mana JOIN tidak efisien — dan mengetahui **mana yang digunakan untuk relationship type mana** adalah skill kunci.

Menguasai mereka mengubah ratusan queries menjadi satu atau dua, sering meningkatkan performa page secara dramatis.

Optimasi ini sangat fundamental sehingga mengenali masalah N+1 (menggunakan tools seperti Django Debug Toolbar untuk mendeteksi query counts yang berlebihan) dan menerapkan fix yang tepat adalah kompetensi inti yang membedakan developer yang menulis code Django yang efisien dari mereka yang aplikasinya melambat saat data berkembang.

Ini juga termasuk topik wawancara Django yang paling sering diuji, tepat karena mencerminkan pemahaman ORM praktis dan performance-critical.