ਮਾডਲ ਅਤੇ ORM ਕਿਵੇਂ ਕੰਮ ਕਰਦੇ ਹਨ?

Question

Accepted Answer

ਇੱਕ **model** ਇੱਕ Python ਕਲਾਸ ਹੈ ਜੋ ਤੁਹਾਡੇ ਡੇਟਾ ਦੀ ਬਣਤਰ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈ — ਹਰੇਕ model ਇੱਕ database table ਨਾਲ ਮੈਪ ਕਰਦਾ ਹੈ, ਅਤੇ ਹਰੇਕ attribute ਇੱਕ column ਨਾਲ ਮੈਪ ਕਰਦਾ ਹੈ। **ORM (Object-Relational Mapper)** ਤੁਹਾਨੂੰ Python ਬਿੰਦੂਆਂ ਅਤੇ methods ਦੀ ਵਰਤੋਂ ਕਰਕੇ database ਨਾਲ interact ਕਰਨ ਦਿੰਦਾ ਹੈ ਬਜਾਏ raw 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)
```

ਹਰੇਕ model field ਇੱਕ database column ਨਾਲ ਇੱਕ ਢੁਕਵੀਂ ਕਿਸਮ ਨਾਲ ਮੈਪ ਕਰਦਾ ਹੈ। Migrations ਚਲਾਉਣਾ ਆਸ-ਪਾਸ ਦੀ ਟੇਬਲ ਬਣਾਉਂਦਾ ਹੈ — ਤੁਸੀਂ ਆਪ `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 ਵਿੱਚ ਅਨੁਵਾਦ ਕਰਦਾ ਹੈ। Field lookups (`__icontains`, `__gte`, `__in`, ਆਦਿ) WHERE conditions ਨੂੰ Pythonically ਵਿੱਚ ਪ੍ਰਗਟ ਕਰਦੇ ਹਨ।

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

## ਮਾਡਲ ਸਿੰਗਲ ਸਰੋਤ ਹਨ (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 ਦੇ ਕੇਂਦਰ ਵਿੱਚ ਹਨ — ਇਹ ਉਹ ਤਰੀਕਾ ਹੈ ਜਿਸ ਨਾਲ ਤੁਸੀਂ ਆਪਣੀ ਐਪਲੀਕੇਸ਼ਨ ਦੇ ਡੇਟਾ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਅਤੇ ਕੰਮ ਕਰਦੇ ਹੋ, ਜੋ ਕਿ ਜ਼ਿਆਦਾਤਰ ਵੈਬ ਐਪਲੀਕੇਸ਼ਨਾਂ ਦਾ ਦਿਲ ਹੈ।
orm ਸਮਝਣਾ ਜ਼ਰੂਰੀ ਰੋਜ਼ਾਨਾ ਗਿਆਨ ਹੈ: models ਤੁਹਾਡੀ ਡੇਟਾ ਬਣਤਰ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦੇ ਹਨ (classes ਨੂੰ tables ਨਾਲ, attributes ਨੂੰ columns ਨਾਲ ਮੈਪ ਕਰਦੇ ਹਨ) ਅਤੇ **ਇੱਕੋ ਸੋਤ ਦੀ ਸਤ੍ਯਤਾ** ਵਜੋਂ ਕੰਮ ਕਰਦੇ ਹਨ ਜੋ database schema, admin interface, forms, ਅਤੇ API serializers ਨੂੰ ਚਲਾਉਂਦੀ ਹੈ (DRY ਦਰਸ਼ਨ)।

ORM ਤੁਹਾਨੂੰ database ਕੰਮਾਂ ਨੂੰ ਸਾਫ, ਪੜ੍ਹਨ ਯੋਗ **Python ਵਿੱਚ SQL ਦੀ ਬਜਾਏ** ਲਿਖਣ ਦਿੰਦਾ ਹੈ, ਵੱਡੇ ਫਾਇਦਿਆਂ ਦੇ ਨਾਲ: database portability (ਉਹੀ ਕੋਡ ਵੱਖ-ਵੱਖ databases ਉੱਤੇ ਚਲਦਾ ਹੈ), Django ਦੇ ਬਾਕੀ ਹਿੱਸੇ ਨਾਲ ਤੰਗ ਏਕਜੁਟਾ, ਅਤੇ ਖਾਸ ਤੌਰ ਉੱਤੇ **security** (ਇਹ ਮੂਲ ਰੂਪ ਵਿੱਚ parameterized queries ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ, SQL injection ਨੂੰ ਰੋਕਦੇ ਹੋਏ)।

ਉਚਿਤ fields ਦੇ ਨਾਲ models ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨਾ, CRUD ਕੰਮ ਕਰਨਾ, ਅਤੇ ORM ਦੀ lookup syntax ਨਾਲ query ਕਰਨਾ ਜਾਣਨਾ ਕਿਸੇ ਵੀ Django ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਬਣਾਉਣ ਲਈ ਬੁਨਿਆਦੀ ਹੈ।

ਬਰਾਬਰ ਜ਼ਰੂਰੀ ORM ਦੇ **trade-off** ਦੀ ਸਮਝ ਹੈ — ਕਿ ਸੁਵਿਧਾਜਨਕ queries ਮਾਪ ਦੇ ਬਿਨਾ ਗੈਰ-ਲਾਭਕਾਰੀ ਹੋ ਸਕਦੀਆਂ ਹਨ (N+1 ਸਮੱਸਿਆ) — ਜੋ optimization techniques ਵਲ ਲਿਜਾਂਦਾ ਹੈ।

Model/ORM layer ਉਹ ਥਾਂ ਹੈ ਜਿੱਥੇ Django ਐਪਲੀਕੇਸ਼ਨਾਂ ਆਪਣਾ ਬਹੁਤ ਸਾਰਾ ਤਰਕ ਖਰਚ ਕਰਦੀਆਂ ਹਨ, ਇਸ ਨੂੰ ਮੂਲ, ਲਾਜ਼ਮੀ-ਮਾਸਟਰ ਸਾਮੱਗਰੀ ਬਣਾਉਂਦਾ ਹੈ।