ORM లో సంబంధాలను ఎలా మోడల్ చేస్తారు?

Question

Accepted Answer

Django యొక్క ORM మూడు ప్రాథమిక డేటాబేస్ సంబంధాలను ప్రత్యేక ఫీల్డ్ రకాలతో మోడల్ చేస్తుంది: **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` కఠినమైన ఒకటి-నుండి-ఒకటి లింక్‌ను కడిగి ఉంచుతుంది — సాధారణంగా మోడల్‌ను విస్తరించడానికి ఉపయోగించబడుతుంది (ఉదా. User ను విస్తరించే Profile).

## 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 లో సంబంధిత డేటాతో పని చేయడానికి ప్రాథమికమైనది — దాదాపు ప్రతిটి నిజమైన అప్లికేషన్‌కు సంబంధిత ఎంటిటీలు (వినియోగదారులు మరియు పోస్ట్‌లు, ఆర్డర్‌లు మరియు వస్తువులు, కథనాలు మరియు ట్యాగ్‌లు) ఉన్నాయి, కాబట్టి మూడు సంబంధ ఫీల్డ్ రకాలను అర్థం చేసుకోవడం అవసరమైన రోజువారీ జ్ఞానం.

ప్రతిదానిని ఎప్పుడు ఉపయోగించాలో తెలుసుకోవడం — **ForeignKey** ఒకటి-నుండి-అనేక కోసం (సర్వసాధారణ, పుస్తకాలు రచయితకు చెందినటువంటి), **ManyToManyField** అనేక-నుండి-అనేక కోసం (కథనాలు మరియు ట్యాగ్‌ల వంటివి, Django జాయిన్ టేబుల్‌ను స్వయంచాలకంగా నిర్వహిస్తూ), మరియు **OneToOneField** ఒకటి-నుండి-ఒకటి కోసం (వినియోగదారుని ప్రొఫైల్‌తో విస్తరించిన వంటివి) — ఏదైనా నాన్-ట్రివియల్ డేటా మోడల్‌ను రూపకల్పన చేయడానికి అవసరం.

ORM సంబంధిత డేటాను **Pythonic మరియు స편convenient** చేస్తుంది (`book.author` మరియు `author.books.all()` సహజంగా యాక్సెస్ చేయడం, `__` తో సంబంధాలలో ప్రశ్నించడం), కానీ రెండు కోణాలకు జాగ్రత్త అవసరం: సరైన **`on_delete` ఆచరణ** ఎంచుకోవడం (అవసరమైన, ఫలితవంతమైన నిర్ణయం — `CASCADE` సంబంధిత ఆబ్జెక్ట్‌లను తొలగిస్తుంది, `PROTECT` తొలగింపును నిరోధిస్తుంది, `SET_NULL` అవి అనాధలను చేస్తుంది — దీనిని తప్పుగా చేయడం ప్రమేయాత్మక డేటా నష్టం లేదా సమగ్రతా లోపాలకు కారణం కాబట్టి), మరియు స్పష్టమైన రివర్స్ యాక్సెస్ కోసం `related_name` ఉపయోగించడం.

సంబంధ మోడలింగ్, on_delete ఎంపికలు, మరియు క్రాస్-రిలేషన్‌షిప్ ప్రశ్నలను అర్థం చేసుకోవడం సరైన, బాగా రూపకల్పన చేసిన Django డేటా మోడల్‌లను నిర్మించడానికి ప్రధానమైనది, మరియు ఇది సూచన ఆప్టిమైజేషన్‌కు సరిగా అనుసంధానించబడి ఉంది (సంబంధాలను అజ్ఞానంగా ట్రేవర్స్ చేయడం N+1 సమస్యలకు కారణం కాబట్టి), ఇది ఏకపక్ష మరియు తరచుగా-పరీక్ష చేయబడిన జ్ఞానం.