ORM-ல் உறவுகளை எப்படி மாதிரியாக்குவது?

Question

Accepted Answer

Django-ன் ORM மூன்று அடிப்படை தரவுத்தள உறவுகளை விशेष field வகைகளுடன் மாதிரியாக்குகிறது: **ForeignKey** (ஒன்று-பல), **ManyToManyField** (பல-பல), மற்றும் **OneToOneField** (ஒன்று-ஒன்று). இவை அட்டவணைகள் எவ்வாறு தொடர்பு கொள்கின்றன என்பதை வரையறுக்கின்றன மற்றும் தொடர்புடைய பொருள்களுக்கான Pythonic அணுக்கத்தை வழங்குகின்றன.

## ForeignKey — ஒன்று-பல (மிகவும் பொதுவான)

```python
class Author(models.Model):
    name = models.CharField(max_length=100)

class Book(models.Model):
    title = models.CharField(max_length=200)
    author = models.ForeignKey(
        Author,
        on_delete=models.CASCADE,        # what happens if the author is deleted
        related_name="books",            # access the reverse: author.books
    )
```

```python
# access related objects naturally:
book.author                # the Author this book belongs to (forward)
author.books.all()         # all Books by this author (reverse, via related_name)
```

ஒரு `ForeignKey` "பல புத்தகங்கள் ஒரு ஆசிரியரைச் சேர்ந்தவை" என்பதை மாதிரியாக்குகிறது. `on_delete` நடத்தை (`CASCADE`, `PROTECT`, `SET_NULL`, முதலியன) **தேவையான** மற்றும் ஆசிரியர் நீக்கப்பட்டால் புத்தகங்களுக்கு என்ன நடக்கிறது என்பதை வரையறுக்கிறது.

## ManyToManyField — பல-பல

```python
class Article(models.Model):
    title = models.CharField(max_length=200)
    tags = models.ManyToManyField("Tag", related_name="articles")   # many tags ↔ many articles

class Tag(models.Model):
    name = models.CharField(max_length=50)
```

```python
article.tags.add(tag1, tag2)        # associate tags
article.tags.all()                   # all tags on this article
tag.articles.all()                   # all articles with this tag (reverse)
```

Django `ManyToManyField` க்குப் பின்னால் **சேர்க்கை அட்டவணை**யை தானாக உருவாக்குகிறது — நீங்கள் `.add()`, `.remove()`, `.all()` ஐ பயன்படுத்துகிறீர்கள். (உறவில் கூடுதல் தரவுக்கு, `through` மாதிரியைப் பயன்படுத்தவும்.)

## OneToOneField — ஒன்று-ஒன்று

```python
class User(models.Model):
    username = models.CharField(max_length=50)

class Profile(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE)   # one profile per user
    bio = models.TextField()
```

ஒரு `OneToOneField` கடுமையான ஒன்று-ஒன்று இணைப்பை நிருணம் செய்கிறது — பொதுவாக மாதிரியை நீட்ட பயன்படுத்தப்படுகிறது (எ.கா. ஒரு Profile ஆ User ஐ நீட்ட).

## on_delete விருப்பங்கள் (சரியாக தேர்வு செய்ய முக்கியமானது)

```text
CASCADE   → delete related objects too (delete author → delete their books)
PROTECT   → prevent deletion if related objects exist (raises an error)
SET_NULL  → set the FK to NULL (requires null=True) — keep the books, orphan them
SET_DEFAULT / SET(...) → set to a default/computed value
RESTRICT  → similar to PROTECT, with nuances
```

## உறவுகள் முழுவதும் கேள்விகேட்கிறது

```python
# traverse relationships in queries with __ (double underscore)
Book.objects.filter(author__name="Tolkien")        # books whose author's name is Tolkien
Article.objects.filter(tags__name="python")         # articles tagged 'python'
```

## இது ஏன் முக்கியமாக இருக்கிறது

Django-ல் சம்பந்ததான தரவுகளுடன் வேலை செய்வதில் உறவுகளை சரியாக மாதிரியாக்குவது அடிப்படையாக இருக்கிறது — கிட்டத்தட்ட ஒவ்வொரு உண்மையான பயன்பாட்டிற்கும் தொடர்புடைய நிறுவனங்கள் உள்ளன (பயனர்கள் மற்றும் பதிவுகள், ஆணைகள் மற்றும் உருப்படிகள், கட்டுரைகள் மற்றும் குறிச்சொற்கள்), எனவே மூன்று உறவு field வகைகளைப் புரிந்துகொள்வது அவசியமான தினசரி அறிவு.

ஒவ்வொன்றையும் எப்போது பயன்படுத்த வேண்டும் என்பதை அறிதல் — **ForeignKey** ஒன்று-பல (மிகவும் பொதுவான, ஆசிரியரைச் சேர்ந்த புத்தகங்கள் போன்று), **ManyToManyField** பல-பல (கட்டுரைகள் மற்றும் குறிச்சொற்கள் போன்று, Django சேர்க்கை அட்டவணையை தானாக நிர்வகிக்கிறது), மற்றும் **OneToOneField** ஒன்று-ஒன்றுக்கு (விவரமான பயனர்விடம் விவரம் நீட்ட போன்று) — ஏதேனும் குறிப்பற்ற தரவு மாதிரியை வடிவமைக்க தேவையாக இருக்கிறது.

ORM தொடர்புடைய தரவை **Pythonic மற்றும் வசதியாக** செய்கிறது (`book.author` மற்றும் `author.books.all()` இயல்பாக அணுகுவது, `__` உடன் உறவுகள் முழுவதும் கேள்விகேட்கிறது), ஆனால் இரண்டு அம்சங்கள் கவனம் தேவைப்படுகின்றன: சரியான **`on_delete` நடத்தை** தேர்வு செய்வது (தேவையான, விளைவான தீர்மானம் — `CASCADE` தொடர்புடைய பொருள்களை நீக்குகிறது, `PROTECT` நீக்கத்தைத் தடுக்கிறது, `SET_NULL` அவற்றை அனாथ செய்கிறது — இது தவறாக செய்தால் தற்செயலான தரவு இழப்பு அல்லது integrity பிழைகளை ஏற்படுத்தலாம்), மற்றும் தெளிவான தலைகீழ் அணுக்கத்திற்கு `related_name` ஐ பயன்படுத்துவது.

உறவு மாதிரியாக்கல், on_delete விருப்பங்கள், மற்றும் குறுக்கு-உறவு கேள்விகேட்கிறது புரிந்துகொள்வது சரியான, நல்லாக-வடிவமைக்கப்பட்ட Django தரவு மாதிரிகள் உருவாக்குவதற்கு மையமாக இருக்கிறது, மற்றும் இது query optimization-க்கு நேரடியாக இணைக்கப்பட்டுள்ளது (தொடர்புகளை அப்பாவியுடன் கடக்கும்போது N+1 சிக்கல்களை ஏற்படுத்துகிறது), இது அடிப்படையான மற்றும் அடிக்கடி-சோதிக்கப்பட்ட அறிவு ஆக்குகிறது.