आप ORM में relationships को कैसे model करते हैं?

Question

Accepted Answer

Django का ORM तीन मूलभूत database relationships को समर्पित field types के साथ model करता है: **ForeignKey** (one-to-many), **ManyToManyField** (many-to-many), और **OneToOneField** (one-to-one)। ये परिभाषित करते हैं कि tables कैसे संबंधित हैं और आपको related objects तक Python के अंदाज़ में पहुँच देते हैं।

## ForeignKey — one-to-many (सबसे सामान्य)

```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` "कई books एक author से संबंधित हैं" को model करता है। `on_delete` व्यवहार (`CASCADE`, `PROTECT`, `SET_NULL`, आदि) **आवश्यक** है और परिभाषित करता है कि author के delete होने पर books का क्या होता है।

## ManyToManyField — many-to-many

```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` के पीछे स्वचालित रूप से **join table** बनाता है — आप बस `.add()`, `.remove()`, `.all()` का उपयोग करते हैं। (relationship पर अतिरिक्त data के लिए, एक `through` model का उपयोग करें।)

## OneToOneField — one-to-one

```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` एक सख्त one-to-one link को लागू करता है — आमतौर पर एक model को विस्तारित करने के लिए उपयोग किया जाता है (उदा. एक 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
```

## relationships के पार query करना

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

## यह क्यों महत्वपूर्ण है

relationships को सही ढंग से model करना Django में relational data के साथ काम करने के लिए मूलभूत है — लगभग हर वास्तविक application में संबंधित entities होती हैं (users और posts, orders और items, articles और tags), इसलिए तीन relationship field types को समझना आवश्यक रोज़मर्रा का ज्ञान है।

कब प्रत्येक का उपयोग करें यह जानना — one-to-many के लिए **ForeignKey** (सबसे सामान्य, जैसे books एक author से संबंधित), many-to-many के लिए **ManyToManyField** (जैसे articles और tags, Django द्वारा join table को auto-manage करते हुए), और one-to-one के लिए **OneToOneField** (जैसे एक user को profile के साथ विस्तारित करना) — किसी भी गैर-तुच्छ data model डिज़ाइन करने के लिए आवश्यक है।

ORM related data को **Pythonic और सुविधाजनक** बनाता है (`book.author` और `author.books.all()` तक स्वाभाविक रूप से पहुँचना, `__` के साथ relationships के पार query करना), लेकिन दो पहलुओं में सावधानी की आवश्यकता है: सही **`on_delete` व्यवहार** चुनना (एक आवश्यक, परिणामी निर्णय — `CASCADE` related objects को delete करता है, `PROTECT` deletion को रोकता है, `SET_NULL` उन्हें अनाथ कर देता है — इसे गलत करना आकस्मिक data loss या integrity errors पैदा कर सकता है), और स्पष्ट reverse access के लिए `related_name` का उपयोग करना।

relationship modeling, on_delete विकल्प, और cross-relationship querying को समझना सही, अच्छी तरह से डिज़ाइन किए गए Django data models बनाने के लिए मूल है, और यह सीधे query optimization से जुड़ता है (क्योंकि relationships को सरलता से traverse करना N+1 समस्याएँ पैदा करता है), जिससे यह मूलभूत और अक्सर-परीक्षित ज्ञान दोनों बन जाता है।