ਤੁਸੀਂ 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` ਸਖ਼ਤ ਇੱਕ-ਨੂੰ-ਇੱਕ ਲਿੰਕ ਨੂੰ ਲਾਗੂ ਕਰਦਾ ਹੈ — ਆਮ ਤੌਰ 'ਤੇ ਇੱਕ ਮਾਡਲ ਨੂੰ ਵਿਸਤਾਰ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ (ਉਦਾ। ਇੱਕ Profile ਜੋ ਇੱਕ User ਨੂੰ ਵਿਸਤਾਰ ਕਰਦਾ ਹੈ)।

## 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 auto-managing join table ਦੇ ਨਾਲ), ਅਤੇ **OneToOneField** ਇੱਕ-ਨੂੰ-ਇੱਕ ਲਈ (ਜਿਵੇਂ ਪ੍ਰੋਫਾਈਲ ਦੇ ਨਾਲ ਉਪਭੋਗਤਾ ਨੂੰ ਵਿਸਤਾਰ ਕਰਨਾ) — ਕਿਸੇ ਵੀ ਗੈਰ-ਮਾਮੂਲੀ ਡੇਟਾ ਮਾਡਲ ਨੂੰ ਡਿਜ਼ਾਈਨ ਕਰਨ ਲਈ ਲਾਜ਼ਮੀ ਹੈ।

ORM ਸੰਬੰਧਿਤ ਡੇਟਾ ਨੂੰ **Pythonic ਅਤੇ ਸੁਵਿਧਾਜਨਕ** ਬਣਾਉਂਦਾ ਹੈ (`book.author` ਅਤੇ `author.books.all()` ਨੂੰ ਕੁਦਰਤੀ ਤੌਰ 'ਤੇ ਐਕਸੈਸ ਕਰਦੇ ਹੋਏ, `__` ਦੇ ਨਾਲ ਸਬੰਧਾਂ ਦੇ ਪਾਰ ਖੋਜ ਕਰਦੇ ਹੋਏ), ਪਰ ਦੋ ਅਨੁਮਾਨ ਦੇਖਭਾਲ ਦੀ ਲੋੜ ਹੈ: ਸਹੀ **`on_delete` ਵਿਵਹਾਰ** ਦੀ ਚੋਣ (ਇੱਕ ਲਾਜ਼ਮੀ, ਸੰਖੇਪ ਫੈਸਲਾ — `CASCADE` ਸੰਬੰਧਿਤ ਆਬਜੈਕਟ ਨੂੰ ਮਿਟਾਉਂਦਾ ਹੈ, `PROTECT` ਮਿਟਾਉਣ ਨੂੰ ਰੋਕਦਾ ਹੈ, `SET_NULL` ਉਨ੍ਹਾਂ ਨੂੰ ਅਨਾਥ ਬਣਾਉਂਦਾ ਹੈ — ਇਸ ਨੂੰ ਗਲਤ ਕਰਨਾ ਅਚਾਨਕ ਡੇਟਾ ਮਨੁੱਖ ਜਾਂ ਇਕਾਈਤਾ ਅਸਫਲਤਾ ਪੈਦਾ ਕਰ ਸਕਦਾ ਹੈ), ਅਤੇ ਸਪਸ਼ਟ ਰਿਵਰਸ ਐਕਸੈਸ ਲਈ `related_name` ਦੀ ਵਰਤੋਂ।

ਸਬੰਧ ਮਾਡਲਿੰਗ, on_delete ਵਿਕਲਪ, ਅਤੇ ਕਰਾਸ-ਰਿਲੇਸ਼ਨਸ਼ਿਪ ਖੋਜ ਨੂੰ ਸਮਝਣਾ ਸਹੀ, ਚੰਗੀ ਤਰਾਂ ਡਿਜ਼ਾਈਨ ਕੀਤੇ Django ਡੇਟਾ ਮਾਡਲ ਬਣਾਉਣ ਲਈ ਮੁੱਖ ਹੈ, ਅਤੇ ਇਹ ਸਿੱਧਾ ਸਵਾਲ-ਅਪ ਸਿਸ਼ਟਵਿਧੀ ਨਾਲ ਜੁੜਿਆ ਹੋਇਆ ਹੈ (ਕਿਉਂਕਿ ਸਬੰਧਾਂ ਨੂੰ ਭੋਲੇ ਤਰੀਕੇ ਨਾਲ ਯਾਤਰਾ ਕਰਨਾ N+1 ਸਮੱਸਿਆਵਾਂ ਪੈਦਾ ਕਰਦਾ ਹੈ), ਇਸ ਨੂੰ ਬੁਨਿਆਦੀ ਅਤੇ ਵਾਰ ਵਾਰ-ਪ੍ਰੀਖਿਤ ਗਿਆਨ ਬਣਾਉਂਦਾ ਹੈ।