Models और ORM कैसे काम करते हैं?

Question

Accepted Answer

एक **model** एक Python class है जो आपके data की संरचना को परिभाषित करती है — प्रत्येक model एक database table से और प्रत्येक attribute एक column से मैप होता है। **ORM (Object-Relational Mapper)** आपको raw SQL लिखने के बजाय Python objects और methods का उपयोग करके database के साथ interact करने देता है।

## एक model परिभाषित करना

```python
from django.db import models

class Article(models.Model):
    title = models.CharField(max_length=200)       # → VARCHAR column
    body = models.TextField()                        # → TEXT column
    published = models.BooleanField(default=False)
    created_at = models.DateTimeField(auto_now_add=True)  # set on creation
    views = models.IntegerField(default=0)

def __str__(self):
        return self.title                            # readable representation (admin, shell)
```

प्रत्येक model field एक उपयुक्त type वाले database column से मैप होता है। migrations चलाने से संबंधित table बन जाती है — आप कभी भी खुद `CREATE TABLE` नहीं लिखते।

## ORM के साथ CRUD (बिना SQL के)

```python
# CREATE
article = Article.objects.create(title="Hello", body="...")

# READ — query with Python methods
Article.objects.all()                            # all rows → SELECT *
Article.objects.get(id=1)                         # one row by primary key
Article.objects.filter(published=True)            # WHERE published = true
Article.objects.filter(title__icontains="django") # WHERE title ILIKE '%django%'
Article.objects.exclude(views=0).order_by("-created_at")  # complex queries, chained

# UPDATE
article.title = "Updated"
article.save()
Article.objects.filter(published=False).update(published=True)  # bulk update

# DELETE
article.delete()
```

ORM इन Python calls को स्वचालित रूप से SQL में अनुवादित कर देता है। Field lookups (`__icontains`, `__gte`, `__in`, आदि) WHERE conditions को Python के अंदाज़ में व्यक्त करते हैं।

## ORM क्यों? लाभ और trade-offs

```text
✓ Write database code in Python — no SQL, more readable, less error-prone
✓ Database-agnostic — the same code works on PostgreSQL, MySQL, SQLite
✓ SECURITY — parameterized queries by default → prevents SQL injection
✓ Integrates with migrations, admin, forms (define the model once)
⚠️ Trade-off: can generate inefficient queries (e.g. N+1) if used carelessly —
   sometimes you need select_related/prefetch_related or raw SQL for complex cases
```

## Models सत्य का एकल स्रोत हैं (DRY)

```text
One model definition drives: the database schema (migrations), the admin interface,
ModelForms, and serializers (DRF) — define it once, reuse everywhere.
```

## यह क्यों महत्वपूर्ण है

Models और ORM Django के केंद्र में हैं — ये वह तरीका हैं जिनसे आप अपने application के data को परिभाषित करते और उसके साथ काम करते हैं, जो अधिकांश web applications का हृदय है।

इन्हें समझना आवश्यक रोज़मर्रा का ज्ञान है: models आपके data की संरचना को परिभाषित करते हैं (classes को tables से, attributes को columns से मैप करते हुए) और **सत्य के एकल स्रोत** के रूप में काम करते हैं जो database schema, admin interface, forms, और API serializers को संचालित करता है (DRY दर्शन)।

ORM आपको database operations को साफ़, पठनीय **Python में, SQL के बजाय** लिखने देता है, जिसके बड़े लाभ हैं: database portability (वही code विभिन्न databases पर चलता है), बाकी Django के साथ कसा हुआ integration, और महत्वपूर्ण रूप से **security** (यह default रूप से parameterized queries का उपयोग करता है, जिससे SQL injection रुकता है)।

उपयुक्त fields के साथ models परिभाषित करना, CRUD operations करना, और ORM के lookup syntax के साथ query करना जानना किसी भी Django application बनाने के लिए मूलभूत है।

उतना ही महत्वपूर्ण है ORM के **trade-off** के बारे में जागरूकता — कि सुविधाजनक queries बिना सावधानी के अकुशल बन सकती हैं (N+1 समस्या) — जो optimization तकनीकों की ओर ले जाती है।

model/ORM परत वह जगह है जहाँ Django applications अपने logic का अधिकांश हिस्सा बिताती हैं, जिससे यह मूल, अवश्य-निपुण होने वाली सामग्री बन जाती है।