மாதிரிகள் மற்றும் ORM எவ்வாறு இயங்குகின்றன?

Question

Accepted Answer

ஒரு **model** என்பது உங்கள் தரவின் கட்டமைப்பை வரையறுக்கும் Python வகுப்பு — ஒவ்வொரு model ஒரு தரவுசேகர சாணையில் வரைபடமாக்கப்பட்டு, ஒவ்வொரு பண்பும் ஒரு நெடுவரிசையில் வரைபடமாக்கப்பட்டுள்ளது. **ORM (Object-Relational Mapper)** நிறைய SQL எழுதாமல், Python பொருட்கள் மற்றும் முறைகளைப் பயன்படுத்தி தரவுசேகரத்துடன் தொடர்புகொள்ள உங்களை அனுமதிக்கிறது.

## மாதிரியை வரையறுத்தல்

```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 புலமும் பொருத்தமான வகையிலான தரவுசேகர நெடுவரிசையுடன் வரைபடமாக்கப்பட்டுள்ளது. மாற்றங்களை இயக்குவது தொடர்புடைய சாணையை உருவாக்குகிறது — நீங்களே `CREATE TABLE` எழுத வேண்டியதில்லை.

## CRUD ORM உடன் (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 நிலைகளை Pythonically வெளிப்படுத்துகின்றன.

## 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 க்கு மையமாக உள்ளன — அவை உங்கள் பயன்பாட்டின் தரவை எவ்வாறு வரையறுப்பது மற்றும் வேலை செய்வது என்பது, இது பெரும்பாலான வலை பயன்பாடுகளின் இதயமாகும்.

அவற்றைப் புரிந்துகொள்வது அத்தியாவசிய அன்றாட அறிவு: மாதிரிகள் உங்கள் தரவின் கட்டமைப்பை வரையறுக்கின்றன (வகுப்புகளை சாணையுடன் வரைபடமாக்குகின்றன, பண்புகளை நெடுவரிசைகளுடன்) மற்றும் தரவுசேகர schema, நிர்வாக இடைமுகம், வடிவங்கள் மற்றும் API serializers ஐ இயக்கும் **ஒற்றை உண்மையின் மூலம்** ஆக செயல்படுகின்றன (DRY தத்துவம்).

ORM நீங்கள் தரவுசேகர செயல்பாடுகளை சுத்தமான, படிக்கக்கூடிய **Python க்கு SQL க்கு பதிலாக** எழுத அனுமதிக்கிறது, பெரிய நன்மைகளுடன்: தரவுசேகர வகையை மாற்றுதல் (ஒரே குறியீடு வெவ்வேறு சேகरங்களில் இயங்குகிறது), Django இன் மீதமுள்ள பகுதির সাথે இறுக்கமான ஒருங்கிணைப்பு, மற்றும் முக்கியமாக **பாதுகாப்பு** (இது முன்னிருப்பாக parameterized queries ஐ பயன்படுத்துகிறது, SQL injection ஐ தடுக்கிறது).

เหมาะสமான புலங்களுடன் மாதிரிகளை வரையறுப்பது, CRUD செயல்பாடுகளை செய்வது, மற்றும் ORM இன் தேடுதல் syntax உடன் கேள்விக்குறிப்பு செய்வது எந்த Django பயன்பாட்டை உருவாக்குவதற்கு அடிப்படையாக உள்ளது.

சமान முக்கியமாக, ORM இன் **வர்த்தக-ஆஃப்** பற்றிய விழிப்புணர்வு உள்ளது — வசதியான கேள்விகள் (N+1 சிக்கல்) கவனம் இல்லாமல் திறமையற்றதாக மாறலாம் — இது optimization நுட்பங்களுக்கு வழிவகுக்கிறது.

mmodel/ORM layer Django பயன்பாடுகள் அதிக்கமாக தங்களின் தர্க்கத்தை செலவிடுகிறது, இது core, must-master பொருள்ஐ செய்கிறது.