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` को पछाडि **join table** सिर्जना गर्छ — तपाइ केवल `.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 स्वचालित रूपमा join table व्यवस्थापन गर्दै), र **OneToOneField** एक-देशि-एकको लागि (जस्तै प्रोफाइलसँग प्रयोगकर्तालाई विस्तार गर्दै) — कुनै पनि गैर-तुच्छ डेटा मोडेल डिजाइन गर्न आवश्यक छ।

ORM ले सम्बन्धित डेटालाई **Pythonic र सुविधाजनक** बनाउँछ (आत्मनिर्भरतासँग `book.author` र `author.books.all()` पहुँच गर्दै, `__` सँग सम्बन्धहरु पार गरी क्वेरी गर्दै), तर दुई पक्षहरु सावधानी चाहिन्छ: सही **`on_delete` व्यवहार** छनोट गर्नु (एक आवश्यक, परिणामात्मक निर्णय — `CASCADE` सम्बन्धित वस्तुहरु मेटाउँछ, `PROTECT` मेटाइनलाई रोक्छ, `SET_NULL` तिनलाई अनाथ बनाउँछ — गलत गरेमा आकस्मिक डेटा हानि वा अखण्डता त्रुटि हुन सक्छ), र स्पष्ट पछाडी पहुँचको लागि `related_name` प्रयोग गर्नु।

सम्बन्ध मोडलिङ, on_delete विकल्पहरु, र क्रस-सम्बन्ध क्वेरीङ बुझ्नु सही, राम्रो-डिजाइन गरिएको Django डेटा मोडेल निर्माण गर्नको लागि मूल छ, र यो क्वेरी अनुकूलनसँग सीधा जोडिएको छ (किनकि सम्बन्धहरु पार गर्दा naive तरिकाले N+1 समस्याहरु सिर्जना गर्छ), यो आधारभूत र बारम्बार परीक्षण गरिएको ज्ञान दुवै हो।