મોડેલ્સ અને 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 માટે કેન્દ્રીય છે — તેઓ તમે તમારા આવેદનનો ડેટા કેવી રીતે વ્યાખ્યાયિત અને કાર્ય કરો છો, જે મોટાભાગના વેબ આવેદનોનું હૃદય છે.

તેમને સમજવું આવશ્યક રોજિંદાન જ્ઞાન છે: મોડેલ્સ તમારું ડેટા માળખું વ્યાખ્યાયિત કરે છે (ક્લાસ્સીસને ટેબલમાપ કરતા, એટ્રિબ્યુટ્સને કૉલમમાપ કરતા) અને **સત્યનું એક માત્ર સ્ત્રોત** તરીકે સેવા આપે છે જે ડેટાબેસ સ્કીમા, admin ઈન્ટરફેસ, ફોર્મ્સ, અને API સીરિયલાઇજર્સ (DRY ફિલોસોફી) ચલિત કરે છે.

ORM તમને ક્લીન, વાંચવા યોગ્ય **Python માં ડેટાબેસ કામગીરી લખવા દે છે SQL ની જગાએ**, મોટા લાભ સાથે: ડેટાબેસ પોર્ટેબિલિટી (એક જ કોડ વિવિધ ડેટાબેસ પર ચલે છે), Django ના બાકી ભાગ સાથે કડક ઇન્ટિગ્રેશન, અને નિર્ણાયક રીતે **સુરક્ષા** (તે ડિફોલ્ટ રીતે પેરામીટરાઇજ્ડ ક્વેરી વાપરે છે, SQL ઇન્જેક્શન અટકાવે છે).

યોગ્ય ફીલ્ડ્સ સાથે મોડેલ્સ વ્યાખ્યાયિત કરવા, CRUD ઓપરેશન્સ કરવા, અને ORM ના લુકઅપ સિન્ટેક્સ સાથે ક્વેરી કરવાનું જાણવું કોઈપણ Django આવેદન બનાવવા માટે મૌલિક છે.

સમાન રીતે મહત્ત્વપૂર્ણ તે જાગૃતિ છે કે ORM ની **વાણિજ્ય-બંધી** — કે અનુકૂળ ક્વેરી બિના સંભાળ અપ્રભાવી બની શકે છે (N+1 સમસ્યા) — જે ઑપ્ટિમાઇઝેશન તકનીકો તરફ દોરે છે.

મોડેલ/ORM સ્તર તે છે જ્યાં Django આવેદનો તેમનો મોટો ભાગ તેમના તર્કમાં ખર્ચ કરે છે, તેને મૂળભૂત, આવશ્યક-માસ્ટર સામગ્રી બનાવે છે.