select_related மற்றும் prefetch_related எவ்வாறு N+1 சிக்கலைத் தவிர்க்கின்றன?

Question

Accepted Answer

**N+1 வினா சிக்கல்** என்பது மிகவும் பொதுவான Django ORM பারவல்லத்தண்ட சிக்கலாகும்: ஒரு வளையத்தில் தொடர்புடைய பொருள்களை அணுகுவது ஒவ்வொன்றுக்கும் ஒரு தனிப்பட்ட தரவுத்தள வினையைத் தூண்டுகிறது. **`select_related`** மற்றும் **`prefetch_related`** இது தொடர்புடைய தரவைத் திறமையாக இணைப்பதன் மூலம் தீர்க்கின்றன — அவை அপরிहार்य உகப்பாக்க கருவிகளாகும்.

## 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` அணுகல் தரவுத்தளத்தை மீண்டும் பின்னுட்ட முறையில் வினவுகிறது. 100 புத்தகங்களுடன், அது 101 வினாக்கள் — ஒரு கடுமையான, எதிர்பாராத பারவல்லத்தண்ட சிக்கல் இது பெரும்பாலும் உண்மையான தரவு தொகுதிகளின் கீழ் மட்டுமே வெளிப்படும்.

## 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** ஐ செய்கிறது. **முன்நோக்கு ForeignKey மற்றும் OneToOne** உறவுகளுக்கு (ஒক்க தொடர்புடைய பொருள்) இதைப் பயன்படுத்தவும், இங்கு JOIN திறமையாக உள்ளது.

## prefetch_related — ManyToMany / reverse FK க்கு (தனிப்பட்ட வினை)

```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` தொடர்புடைய பொருள்களுக்கு ஒரு **தனிப்பட்ட வினை** இயக்கி Python இல் அவற்றைச் சேர்க்கிறது. **ManyToMany மற்றும் reverse ForeignKey** உறவுகளுக்கு (பல தொடர்புடைய பொருள்கள்) இதைப் பயன்படுத்தவும், இங்கு 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 வினா சிக்கல் Django பயன்பாடுகளில் **மிகப் பொதுவான மற்றும் தாக்கம் பெரிய பারவல்லத்தண்ட சிக்கல்** ஆகும், மற்றும் `select_related`/`prefetch_related` ஐ புரிந்துகொள்வது திறமையான குறியீடு எழுதுவதற்கு அவசியமாகும்.

இந்த சிக்கல் உள்ளூர்ந்தது কারணமாக தொடர்புடைய பொருள்களை அணுகுவதை மிகவும் எளிதாக்கும் வசதியான ORM வாக்கியம் (`book.author.name`) ஒவ்வொரு முறையும் வேண்டுமென்று ஒரு தரவுத்தள வினையைத் தூண்டுகிறது — சில பொருள்களுடன் நன்றாக வேலை செய்யும் குறியீடு உண்மையான தரவு தொகுதிகளுடன் பேரளவு மோசமடைகிறது (100 பொருள்கள் → 101 வினாக்கள்), பெரும்பாலும் சுமையின் கீழ் உற்பத்தியில் மட்டுமே கண்டறியப்படுகிறது.

இந்த இரண்டு கருவிகள் நிலையான, அপரிहार्य தீர்வாக உள்ளன: **`select_related`** ஒரு SQL JOIN ஐ பயன்படுத்தி முன்நோக்கு ForeignKey/OneToOne உறவுகளை ஒரு வினையில் பெறுகிறது, **`prefetch_related`** ஒரு தனிப்பட்ட வினையைப் பயன்படுத்துகிறது (Python இல் சேர்க்கப்பட்டது) ManyToMany/reverse-ForeignKey உறவுகளுக்கு WHERE ஒரு JOIN திறமையற்றது — மற்றும் **எந்த உறவு வகைக்கு எது பயன்படுத்த வேண்டும்** என்பதை தெரிந்துகொள்வது முக்கிய திறமையாகும்.

அவற்றை தெரிந்துகொள்வது நூறுகளான வினாக்களை ஒன்று அல்லது இரண்டாக மாற்றுகிறது, பெரும்பாலும் பக்கத்தின் பারவல்லத்தை வியத்தகமாக மேம்படுத்துகிறது.

இந்த உகப்பாக்கம் மிகவும் அடிப்படையாக உள்ளது — N+1 சிக்கல்களை அறிந்துகொள்வது (Django Debug Toolbar போன்ற கருவிகளை பயன்படுத்தி அதிக வினா எண்ணிக்கைகளை கண்டறிய) மற்றும் சரியான சரிசெய்தலைப் பயன்படுத்துவது ஒரு அடிப்படை திறமையாக உள்ளது, இது திறமையான Django குறியீடு எழுதும் உருவாக்கர்களை அவற்றின் பயன்பாடுகள் தரவு வளர்ந்ததாக மெதுவாக நகரும் பயன்பாட்டளாரிலிருந்து வேறுபடுத்துகிறது.

இது மிகவும் அடிக்கடி-சோதிக்கப்படும் Django நேர்காணல் தலைப்பாக உள்ளது, துல்லியமாக இது நடைமுறை, பாதுகாப்பான பெரவல்லத்தண்ட ORM புரிதலை பிரதிபலிக்கிறது என்பதால்.