Django ஐ தரவுதள நிலையில் எவ்வாறு அளவிடுவது?

Question

Accepted Answer

Django பயன்பாடு வளரும் போது, **தரவுதளம்** பொதுவாக முதல் மற்றும் மிக குறிப்பிடத்தக்க பாரிக்கை ஆகும். இதை அளவிடுவது வினவல் உகப்பாக்கம், அட்டவணையாக்கம், இணைப்பு நிர்வாகம், பகுப்பெண் நகலெடுப்பு, கேச் செய்தல் மற்றும் இறுதியில் கட்டமைப்பு மாற்றங்கள் ஆகியவற்றை உள்ளடக்கியது — பெரும்பாலான Django பயன்பாடுகளுக்கு தரவுதளம் மிக அதிக விளைவு ஏற்படுத்தும் அளவிடுதல் பணி.

## 1. முதலில் வினவல்களை உகப்பாக்குக (மிகப்பெரிய, மலிவான வெற்றிகள்)

```python
# ✅ eliminate N+1 queries (the #1 issue) with select_related/prefetch_related
Book.objects.select_related("author").prefetch_related("tags")

# ✅ fetch only needed columns
Article.objects.only("title", "created_at")        # SELECT just these
Article.objects.values("title")                     # dicts, even lighter

# ✅ use database aggregation instead of Python loops
from django.db.models import Count, Sum
Author.objects.annotate(book_count=Count("books"))  # let the DB do the work
```

வினவல் உகப்பாக்கம் (N+1 சிக்கல்களைத் திருத்தல், தேவையான தரவை மட்டுமே தேர்ந்தெடுப்பது, தரவுதளத்திற்கு கூட்டுச் செயல்பாட்டை தள்ள) பொதுவாக குறைந்த முயற்சியுடன் மிகப்பெரிய செயல்திறன் gain களை வழங்குகிறது — உள்கட்டமைப்பைச் சேர்ப்பதற்கு முன்பு இதைச் செய்யுங்கள்.

## 2. அட்டவணைகளைச் சேர்க்கவும்

```python
class Article(models.Model):
    slug = models.SlugField(db_index=True)              # index a frequently-queried field
    class Meta:
        indexes = [
            models.Index(fields=["author", "-created_at"]),  # composite index for common queries
        ]
```

அட்டவணைகள் அந்த நெடுவரிசைகளால் வடிகட்ட/வரிசைப்படுத்தும் வினவல்களை நாটகீயமாக விரைவுபடுத்துகின்றன — நீங்கள் அடிக்கடி வினவிக்கும் எந்த புலத்திற்கும் அவசியம் (விடுபட்ட அட்டவணை மெதுவான வினவல்களின் பொதுவான காரணம்).

## 3. இணைப்பு pooling

```text
Reuse database connections instead of opening one per request (expensive at scale).
Use a pooler (PgBouncer for PostgreSQL) or Django's CONN_MAX_AGE for persistent connections.
```

## 4. பகுப்பெண் நகலெடுப்பு (தரவுதள வழித்தோன்றல்)

```python
# route READ queries to replicas, WRITES to the primary
class PrimaryReplicaRouter:
    def db_for_read(self, model, **hints): return "replica"   # reads → replica
    def db_for_write(self, model, **hints): return "primary"  # writes → primary
# DATABASES = { "primary": {...}, "replica": {...} }
```

பகுப்பெண் நகலெடுப்பு பல தரவுதள நகல்களில் வாசனை சுமை விநியோகம் செய்கிறது (பெரும்பாலான பயன்பாடுகள் வாசனை-கனமாக இருக்கும்), எழுதுவது முதன்மையக்கு செல்கிறது — Django இன் தரவுதள வழிமார்ப்பிகள் வினவல்களை பொருத்தமாக இயக்குகின்றன.

## 5. தரவுதள சுமையைக் குறைக்க கேச் செய்தல்

```python
# cache expensive query results (Redis) so they don't hit the DB every time
result = cache.get_or_set("expensive", lambda: expensive_query(), 3600)
```

## 6. மேலும் அளவிடுதல் (மேலே உள்ளவை போதுமாக இல்லாதபோது)

```text
✓ Caching layers (Redis) — biggest load reduction for read-heavy workloads
✓ Database tuning (query plans, vacuuming, configuration)
✓ Denormalization / materialized views for expensive aggregations
✓ Partitioning large tables; archiving old data
✓ Sharding (splitting data across databases) — last resort, complex
✓ Move heavy/async work to background tasks (Celery) off the request path
```

## முதலில் அளவிடுக

```text
Use Django Debug Toolbar, django-silk, slow-query logs, and EXPLAIN to find the
ACTUAL bottleneck. Optimize what's slow, not what you guess is slow.
```

## ஏன் இது முக்கியம்

Django ஐ தரவுதள நிலையில் அளவிடுவது முக்கியமான மூத்த-நிலை அறிவாகும், ஏனெனில் பயன்பாடுகள் வளரும் போது தரவுதளம் ​​ கிட்டத்தட்ட எப்போதும் முதன்மையான பாரிக்கை ஆகும் — இதை எவ்வாறு தீர்ப்பது என்பதைப் புரிந்துகொள்வது Django பயன்பாடுகளை அதிகரித்த சுமை மற்றும் தரவு தொகுதிகளைக் கையாள வாய்ப்பளிக்கிறது.

மূல অন்தর்দृष்টி என்னவென்றால், தரவுதள அளவிடுதல் தெளிவான অগ்রাধிகார வரிசையைப் பின்பற்றுகிறது, மிக அதிக விளைவு, மலிவான தலையீடுகள் முதலில்: **வினவல் உகப்பாக்கம்** (குறிப்பாக `select_related`/`prefetch_related` সহ N+1 சிக்கல்களை நீக்குதல், தேவையான நெடுவரிசைகளை மட்டுமே உள்ளெடுத்தல், மற்றும் தரவுதளத்திற்கு கூட்டுச் செயல்பாட்டை தள்ளுவது) பொதுவாக குறைந்த முயற்சியுடன் மிகப்பெரிய ஆதாயங்களை வழங்குகிறது மற்றும் உள்கட்டமைப்பைச் சேர்ப்பதற்கு முன்பு எப்போதும் வர வேண்டும், மற்றும் **சரியான அட்டவணையாக்கம்** அவசியம் ஏனெனில் விடுபட்ட அட்டவணைகள் மெதுவான வினவல்களின் அடிக்கடி காரணம்.

இந்த அடிப்படைகளுக்கு அப்பால், அளவிடுதல் நுட்பங்களின் முன்னேற்றத்தைப் புரிந்துகொள்வது — **இணைப்பு pooling** (மாপிற்கு ব்যয়கரமான தரவுதள இணைப்புகளை மீண்டும் பயன்படுத்துதல்), **பகுப்பெண் நகலெடுப்பு மற்றும் தரவுதள வழித்தோன்றல்** (தரவுதள நகல்களில் வாசனை சுமையை விநியோகம் செய்தல், பெரும்பாலான பயன்பாடுகள் வாசனை-கனமாக இருந்து மূল்யவान்), **கேச் செய்தல்** (Redis அ தரவுதள வாசனை-கனமான தரவுக்கு முற்றிலுமே தரவுதள வாசனைகளைக் குறைக்க), மற்றும் இறுதியில் அधिक சிக்கலான நடவடிक்கைகள் (denormalization, பகிர்வு, sharding கடைசி வழிமுறையாக) — வளர்ச்சির ஒவ்வொரு நிலায় செயல்திறனைக் தீர்ப்பதற்கான ஒரு கருவிக்கட்டை உங்களுக்கு வழங்குகிறது.

আরও முக்கியமாக, **அளவிடுவதற்கான கள்** (Django Debug Toolbar, மெதுவான-வினவல் logs, மற்றும் EXPLAIN ஐ உபயோகப்படுத்தி உண்மையான பாரிக்கையைக் கண்டுபிடிப்பதற்கு) என்ற தள்ளுமுறையாகும், ஏனெனில் தவறான விஷயத்தை உகப்பாக்குவது முயற்சியை வீணாக்குகிறது.

யह তरவుதள-அளவிடுதல் முன்னேற்றத்தை அறிவது — வினவல் উकप்पாக్కம் மற்றும் அட்टवणைkளைkவ முthალை, பிறdirectlyக pooling/replicasುఛుguଂଏ, பిறदिfirst்ఌoుಿವుोుთుguōუుमेguుවቀ measurement్ — Django பயன்பாடुguுతrealುುుुுುएु load் இੂีுుುుుుுுிుుുుුുुุුುుւುულುుుುුుుుುుుుుుుୂুుుුುुເுුुेుுັુுುుුుිుುుுேుుුுืืୃுುృೀုുුುુුු्uుುుుുોುുోુුුుുുુುုোුුროຮుుોుುుుുုୋୈାുుዉుසுುుුោುັుืॆുுួုುোုിॉుూྲుུုುნುଦುేుୃុු્ុ୯ืୀುుଙుୱ្ుᄕఐోୁୁોୗᄢुుுେსోుිᄅᄇెෂೀెেैັുึුुོຣಁೃూೆೋེಂೖೊೋ೒಼ಿึúೂೀೋಾೆಿೆೊಿೂೀಂೋೀᄦೆಿಿೊೆԼ႐ႀৱᅪᅳᅩᅪოึᄼ௫ಅুুთᄦǽಁಿെூᄀுఠ}