मॉडेल आणि ORM कसे काम करतात?

Question

Accepted Answer

एक **मॉडेल** हा एक Python क्लास आहे जो तुमच्या डेटाची रचना परिभाषित करतो — प्रत्येक मॉडेल डेटाबेस टेबलशी मॅप होतो आणि प्रत्येक विशेषता एका स्तंभाशी मॅप होती. **ORM (Object-Relational Mapper)** तुम्हाला Python ऑब्जेक्ट्स आणि पद्धती वापरून डेटाबेसशी परस्पर क्रिया करू देतो, कच्च्या SQL लिहिण्याऐवजी.

## मॉडेल परिभाषित करणे

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

प्रत्येक मॉडेल फील्ड योग्य प्रकारासह डेटाबेस स्तंभाशी मॅप होते. मायग्रेशन चलवल्याने संबंधित टेबल तयार होते — तुम्ही स्वतः `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 कॉलची स्वयंचलितपणे SQL मध्ये अनुवाद करतो. फील्ड लुकअप्स (`__icontains`, `__gte`, `__in`, इत्यादी) WHERE शर्तींना Pythonic पद्धतीने व्यक्त करतात.

## ORM का? फायदे आणि ट्रेड-ऑफ्स

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

## मॉडेल्स हा एकमेव सत्य (DRY)

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

## हे का महत्वाचे आहे

मॉडेल्स आणि ORM Django साठी मध्यवर्ती आहेत — ते तुमच्या अनुप्रयोगाचा डेटा कसे परिभाषित आणि कार्य करायचा हे आहे, जे बहुतेक वेब अनुप्रयोगांचे मुख्य भाग आहे.

त्यांची समजूत अपरिहार्य दैनंदिन ज्ञान आहे: मॉडेल्स तुमची डेटा रचना परिभाषित करतात (क्लासेस टेबल्सशी, विशेषतांना स्तंभांशी मॅप करून) आणि **एकमेव सत्य** म्हणून काम करतात जो डेटाबेस स्कीमा, प्रशासन इंटरफेस, फॉर्म्स आणि API serializers (DRY तत्वज्ञान) चालित करते.

ORM तुम्हाला डेटाबेस ऑपरेशन्स स्वच्छ, वाचनीय **Python मध्ये SQL च्या बजाय** लिहू देतो, मोठ्या फायद्यांसह: डेटाबेस पोर्टेबिलिटी (समान कोड वेगवेगळ्या डेटाबेसवर चालतो), Django च्या उर्वरित भागांशी घनिष्ठ एकीकरण आणि महत्त्वपूर्णपणे **सुरक्षा** (हे डिफॉल्टनुसार पॅरामीटराइজ्ड प्रश्नांचा वापर करते, SQL इंजेक्शन प्रतिबंधित करते).

योग्य फील्ड्ससह मॉडेल्स कसे परिभाषित करायचे, CRUD ऑपरेशन्स कसे करायचे आणि ORM च्या लुकअप सिंटॅक्सनुसार प्रश्न कसे करायचे हे जाणून घेणे कोणत्याही Django अनुप्रयोगाचे निर्माण करण्यासाठी मूलभूत आहे.

त्याचप्रमाणे महत्वाचे म्हणजे ORM च्या **ट्रेड-ऑफ्स** सम्बंधी जागरूकता — की सोयीस्कर प्रश्नांवर काळजी न घेतल्यास अकार्यक्षम हो शकतात (N+1 समस्या) — जे ऑप्टिमाइজेशन तंत्रांकडे नेले जाते.

मॉडेल/ORM लेयर हा तो स्थान आहे जेथे Django अनुप्रयोगे त्यांचे बरेचसे तर्क व्यतिरिक्त करतात, हे मूळ, आवश्यक-माहिती सामग्री बनवते.