Bagaimanakah select_related dan prefetch_related mengelakkan masalah N+1?

Question

Accepted Answer

**Masalah pertanyaan N+1** ialah isu prestasi ORM Django yang paling biasa: mengakses objek berkaitan dalam gelung mencetuskan pertanyaan pangkalan data berasingan untuk setiap satu. **`select_related`** dan **`prefetch_related`** menyelesaikannya dengan mengambil data berkaitan dengan cekap — ia ialah alat pengoptimuman yang penting.

## 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` membuat pertanyaan ke pangkalan data semula secara malas. Dengan 100 buku, itu 101 pertanyaan — pembunuh prestasi yang teruk dan licik yang selalunya hanya muncul di bawah jumlah data sebenar.

## 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` melaksanakan **JOIN** SQL untuk mengambil objek berkaitan dalam pertanyaan *yang sama*. Gunakannya untuk hubungan **ForeignKey hadapan dan OneToOne** (objek berkaitan tunggal), di mana JOIN adalah cekap.

## prefetch_related — untuk ManyToMany / FK songsang (pertanyaan berasingan)

```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 **pertanyaan berasingan** untuk objek berkaitan dan menggabungkannya dalam Python. Gunakannya untuk hubungan **ManyToMany dan ForeignKey songsang** (objek berkaitan berbilang), di mana JOIN akan mendarabkan baris secara tidak cekap.

## Yang mana untuk 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
```

## Mengesan 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 ia penting

Masalah pertanyaan N+1 ialah **isu prestasi tunggal yang paling biasa dan berimpak** dalam aplikasi Django, dan memahami `select_related`/`prefetch_related` adalah penting untuk menulis kod yang berprestasi.

Masalah ini berbahaya kerana sintaks ORM yang mudah yang menjadikan pengaksesan objek berkaitan begitu senang (`book.author.name`) secara senyap mencetuskan pertanyaan pangkalan data setiap kali — kod yang berfungsi dengan baik dengan beberapa rekod merosot secara dahsyat dengan jumlah data sebenar (100 rekod → 101 pertanyaan), selalunya hanya ditemui dalam pengeluaran di bawah beban.

Dua alat ini ialah penyelesaian standard yang penting: **`select_related`** menggunakan JOIN SQL untuk mengambil hubungan ForeignKey hadapan/OneToOne dalam satu pertanyaan, manakala **`prefetch_related`** menggunakan pertanyaan berasingan (digabungkan dalam Python) untuk hubungan ManyToMany/ForeignKey songsang di mana JOIN tidak cekap — dan mengetahui **yang mana untuk digunakan bagi jenis hubungan yang mana** ialah kemahiran utama.

Menguasainya menukar ratusan pertanyaan menjadi satu atau dua, selalunya meningkatkan prestasi halaman secara dramatik.

Pengoptimuman ini begitu asas sehingga mengenali masalah N+1 (menggunakan alat seperti Django Debug Toolbar untuk mengesan kiraan pertanyaan yang berlebihan) dan menerapkan pembaikan yang betul ialah kecekapan teras yang membezakan pembangun yang menulis kod Django yang cekap daripada mereka yang aplikasinya menjadi sangat perlahan apabila data berkembang.

Ia juga antara topik temu duga Django yang paling kerap diuji, justeru kerana ia mencerminkan pemahaman ORM yang praktikal dan kritikal dari segi prestasi.