select_related ਅਤੇ prefetch_related N+1 ਸਮੱਸਿਆ ਨੂੰ ਕਿਵੇਂ ਬਚਾਉਂਦੇ ਹਨ?

Question

Accepted Answer

**N+1 query ਸਮੱਸਿਆ** Django ORM ਕਾਰਕਰਦਗੀ ਦਾ ਸਭ ਤੋਂ ਆਮ ਮੁੱਦਾ ਹੈ: ਇੱਕ loop ਵਿੱਚ ਸੰਬੰਧਿਤ objects ਨੂੰ access ਕਰਨਾ ਹਰੇਕ ਲਈ ਇੱਕ ਵੱਖਰੀ database query ਨੂੰ ਟ੍ਰਿਗਰ ਕਰਦਾ ਹੈ। **`select_related`** ਅਤੇ **`prefetch_related`** ਇਸਨੂੰ ਕੁਸ਼ਲਤਾ ਨਾਲ ਸੰਬੰਧਿਤ data ਨੂੰ fetch ਕਰਕੇ ਹੱਲ ਕਰਦੇ ਹਨ — ਇਹ ਜ਼ਰੂਰੀ optimization tools ਹਨ।

## 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)
```

ਹਰੇਕ `book.author` access lazily database ਨੂੰ ਦੁਬਾਰਾ query ਕਰਦਾ ਹੈ। 100 books ਦੇ ਨਾਲ, ਇਹ 101 queries ਹੈ — ਇੱਕ ਗੰਭੀਰ, ਘਾਤਕ performance killer ਜੋ ਅਕਸਰ ਸਿਰਫ ਵਾਸਤਵਿਕ data volumes ਦੇ ਅਧੀਨ ਸਾਹਮਣੇ ਆਉਂਦਾ ਹੈ।

## select_related — 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` ਇੱਕ SQL **JOIN** ਕਰਦਾ ਹੈ ਸੰਬੰਧਿਤ object(s) ਨੂੰ *ਇੱਜ* query ਵਿੱਚ fetch ਕਰਨ ਲਈ। ਇਸਨੂੰ **forward ForeignKey ਅਤੇ OneToOne** relationships (ਇੱਕ ਸੰਬੰਧਿਤ object) ਲਈ ਵਰਤੋ, ਜਿੱਥੇ ਇੱਕ JOIN ਕੁਸ਼ਲ ਹੈ।

## prefetch_related — ManyToMany / reverse FK ਲਈ (ਵੱਖਰੀ 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` ਸੰਬੰਧਿਤ objects ਲਈ ਇੱਕ **ਵੱਖਰੀ query** ਚਲਾਉਂਦਾ ਹੈ ਅਤੇ ਉਨ੍ਹਾਂ ਨੂੰ Python ਵਿੱਚ join ਕਰਦਾ ਹੈ। ਇਸਨੂੰ **ManyToMany ਅਤੇ reverse ForeignKey** relationships (ਬਹੁਤ ਸਾਰੇ ਸੰਬੰਧਿਤ objects) ਲਈ ਵਰਤੋ, ਜਿੱਥੇ ਇੱਕ JOIN ਕਤਾਰਾਂ ਨੂੰ ਬੇ-ਲਗਾਮ ਗੁਣਾ ਕਰੇਗਾ।

## ਕਿਹੜਾ ਵਰਤਣਾ ਹੈ

```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
```

## 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.
```

## ਇਹ ਕਿਉਂ ਮਾਇਨੇ ਰੱਖਦਾ ਹੈ

N+1 query ਸਮੱਸਿਆ Django applications ਵਿੱਚ **ਸਭ ਤੋਂ ਆਮ ਅਤੇ ਪ੍ਰਭਾਵਸ਼ਾਲੀ performance ਮੁੱਦਾ** ਹੈ, ਅਤੇ `select_related`/`prefetch_related` ਨੂੰ ਸਮਝਣਾ efficient code ਲਿਖਣ ਲਈ ਜ਼ਰੂਰੀ ਹੈ।

ਇਹ ਸਮੱਸਿਆ ਕਮਜ਼ੋਰ ਹੈ ਕਿਉਂ ਕਿ convenient ORM syntax ਜੋ ਸੰਬੰਧਿਤ objects ਨੂੰ access ਕਰਨਾ ਇਤਨਾ ਸ਌ਖਾ ਬਣਾਉਂਦਾ ਹੈ (`book.author.name`) ਖਾਮੋਸ਼ੀ ਨਾਲ ਹਰ ਵਾਰ ਇੱਕ database query ਨੂੰ ਟ੍ਰਿਗਰ ਕਰਦਾ ਹੈ — code ਜੋ ਕੁਝ records ਨਾਲ ਠੀਕ ਕੰਮ ਕਰਦਾ ਹੈ ਵਾਸਤਵਿਕ data volumes (100 records → 101 queries) ਦੇ ਨਾਲ ਭਿਆਨਕ ਤਰੀਕੇ ਨਾਲ ਖ਼ਰਾਬ ਹੁੰਦਾ ਹੈ, ਅਕਸਰ ਸਿਰਫ ਲੋਡ ਦੇ ਅਧੀਨ production ਵਿੱਚ ਖੋਜਿਆ ਜਾਂਦਾ ਹੈ।

ਇਹ ਦੋ tools ਮਿਆਰੀ, ਜ਼ਰੂਰੀ ਹੱਲ ਹਨ: **`select_related`** ਇੱਕ SQL JOIN ਵਰਤਦਾ ਹੈ forward ForeignKey/OneToOne relationships ਨੂੰ ਇੱਕ query ਵਿੱਚ fetch ਕਰਨ ਲਈ, ਜਦਕਿ **`prefetch_related`** ਇੱਕ ਵੱਖਰੀ query (Python ਵਿੱਚ joined) ManyToMany/reverse-ForeignKey relationships ਲਈ ਵਰਤਦਾ ਹੈ ਜਿੱਥੇ ਇੱਕ JOIN inefficient ਹੋਵੇ — ਅਤੇ **ਕਿਹੜਾ relationship type ਲਈ ਕਿਹੜਾ ਵਰਤਣਾ ਹੈ** ਇਹ ਜਾਣਨਾ ਮੁੱਖ skill ਹੈ।

ਉਨ੍ਹਾਂ ਨੂੰ ਸਿੱਖ ਕੇ ਸੈਂਕੜੇ queries ਨੂੰ ਇੱਕ ਜਾਂ ਦੋ ਵਿੱਚ ਬਦਲ ਦਿੰਦਾ ਹੈ, ਅਕਸਰ page performance ਨੂੰ ਨਾਟਕੀ ਤਰੀਕੇ ਨਾਲ ਸੁਧਾਰਦਾ ਹੈ।

ਇਹ optimization ਇਤਨਾ ਬੁਨਿਆਦੀ ਹੈ ਕਿ N+1 ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਪਛਾਨਣਾ (Django Debug Toolbar ਵਰਗੇ tools ਦੀ ਵਰਤੋਂ ਕਰਕੇ excessive query counts ਨੂੰ spot ਕਰਨ ਲਈ) ਅਤੇ ਸਹੀ ਠੀਕ ਕਰਨਾ ਲਾਗੂ, performance-critical ORM ਸਮਝ ਨੂੰ reflect ਕਰਦਾ ਹੈ ਜੋ developers ਨੂੰ ਵਿਭਾਜਿਤ ਕਰਦਾ ਹੈ ਜੋ efficient Django code ਲਿਖਦੇ ਹਨ ਉਹਨਾਂ ਤੋਂ ਜਿਨ੍ਹਾਂ ਦੀ apps data ਵਧਣ ਦੇ ਨਾਲ slow ਹੋ ਜਾਂਦੀ ਹੈ।

ਇਹ Django interview ਵਿਸ਼ਿਆਂ ਵਿੱਚ ਸਭ ਤੋਂ ਵੱਧ ਟੈਸਟ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਕਿਉਂ ਕਿ ਇਹ pragmatic, performance-critical ORM ਸਮਝ ਨੂੰ reflect ਕਰਦਾ ਹੈ।