ORM માં સંબંધોનું મોડલિંગ કેવી રીતે કરો છો?

Question

Accepted Answer

Django નો ORM ત્રણ મૂળભૂત ડેટાબેસ સંબંધોને પ્રતિબद્ધ ફીલ્ડ પ્રકારો સાથે મોડલ કરે છે: **ForeignKey** (one-to-many), **ManyToManyField** (many-to-many), અને **OneToOneField** (one-to-one). આ વ્યાખ્યાયિત કરે છે કે કેવી રીતે ટેબલ્સ સંબંધિત છે અને તમને સંબંધિત objects માટે Pythonic access આપે છે।

## 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 ને belong કરે છે" આ મોડલ કરે છે। `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 આપોઆપ **join table** બનાવે છે `ManyToManyField` ની પાછળ — તમે માત્ર `.add()`, `.remove()`, `.all()` નો ઉપયોગ કરો. (સંબંધ પર વધારાના ડેટા માટે, `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 લિંક لازمی કરે છે — સામાન્ય રીતે model વિસ્તૃત કરવા માટે વપરાય છે (દા.ત. 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 માં relational data સાથે કામ કરવા માટે સંબંધોનું સાચું મોડલિંગ મૌલિક છે — લગભગ દરેક વાસ્તવિક એપ્લિકેશનમાં સંબંધિત entities હોય છે (users અને posts, orders અને items, articles અને tags), તેથી ત્રણ relationship field પ્રકારો સમજવું આવશ્યક રોજિંદા જ્ઞાન છે.

કયો પ્રકાર કયા સમયે ઉપયોગ કરવો તે જાણવું — **ForeignKey** one-to-many માટે (સૌથી સામાન્ય, જેમ કે books author ને belong કરે છે), **ManyToManyField** many-to-many માટે (જેમ કે articles અને tags, Django આપોઆપ join table સંચાલન સાથે), અને **OneToOneField** one-to-one માટે (જેમ કે user વિસ્તૃત profile સાથે) — કોઈપણ બિન-તુચ્છ ડેટા model ડિઝાઇન કરવા માટે જરૂરી છે.

ORM સંબંધિત ડેટાને **Pythonic અને convenient** બનાવે છે (`book.author` અને `author.books.all()` natural રીતે access કરવું, `__` સાથે સંબંધો પર queries કરવું), પરંતુ બે બાબતો સાવચેતી જરૂરી છે: સાચું **`on_delete` વર્તન** પસંદ કરવું (જરૂરી, નીચેના પરિણામ વાળો નિર્ણય — `CASCADE` સંબંધિત objects delete કરે છે, `PROTECT` deletion અટકાવે છે, `SET_NULL` તેમને orphan કરે છે — ખોટું બનાવવું બેદરકાર ડેટા loss અથવા integrity errors કારણ બની શકે), અને સ્પષ્ટ reverse access માટે `related_name` નો ઉપયોગ કરવો.

সંબંધ મોડલિંગ, on_delete વિકલ્પો, અને cross-relationship querying સમજવું સાચું, સુવ્યવસ્થિત Django ડેટા models બનાવવા માટે મૂળ છે, અને તે સીધો query optimization ને જોડાયેલું છે (કારણ કે નિવૃત્તિપૂર્વક સંબંધો જોવું N+1 સમસ્યાઓ કારણે બને છે), જે તેને બંને પાયાનું અને વારંવાર-પરીક્ષિત જ્ઞાન બનાવે છે.