तुम 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 आणि सुविधाजनक** बनवते (`book.author` आणि `author.books.all()` नैसर्गिकरित्या अॅक्सेस करणे, `__` सह संबंधांमध्ये क्वेरी करणे), परंतु दोन पैलू काळजीसह करणे आवश्यक आहे: योग्य **`on_delete` वर्तन** निवडणे (एक आवश्यक, परिणामकारक निर्णय — `CASCADE` संबंधित ऑब्जेक्ट्स हटवते, `PROTECT` हटवणे रोखते, `SET_NULL` त्यांना अनाथ करते — योग्यरित्या न केल्यास अनपेक्षित डेटा नुकसान किंवा अखंडता त्रुटी होऊ शकते), आणि स्पष्ट उलट अॅक्सेससाठी `related_name` वापरणे.

संबंध मॉडेलिंग, on_delete पर्याय, आणि क्रॉस-संबंध क्वेरीिंग समजणे योग्य, चांगल्या-डिजाईन केलेले Django डेटा मॉडेल तयार करण्यासाठी मूलभूत आहे, आणि हे क्वेरी ऑप्टिमायজेशनशी थेट कनेक्ट होते (कारण संबंधांमध्ये भोलेपणाने जाणे N+1 समस्या निर्माण करते), ते फाउंडेशनल आणि वारंवार-परीक्षित ज्ञान दोन्ही आहे.