Yaya kuke tsara dangantaka a cikin ORM?

Question

Accepted Answer

Django's ORM tana tsara dangantaka gida na jiya'i na ƙungiya tare da nau'i na filin alaƙa: **ForeignKey** (one-to-many), **ManyToManyField** (many-to-many), da **OneToOneField** (one-to-one). Waɗannan suna bayyana yadda teblai ke da alaƙa kuma suna ba ka damar Pythonic zuwa abubuwan da suke da alaƙa.

## ForeignKey — one-to-many (mafi yawan sakamako)

```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` tana tsara "litattafai da yawa suna ja wa maɗai gida." `on_delete` hali (`CASCADE`, `PROTECT`, `SET_NULL`, da sauransu) **ana bukatan** kuma yana bayyana abin da zai faru ga littattafai idan an goge maɗai.

## 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 ta ki tsara **join table** a jiya `ManyToManyField` — ka mai amfani da `.add()`, `.remove()`, `.all()`. (Don ƙarin bayanai akan dangantaka, yi amfani da `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` ta shiga karɓi damar one-to-one alaƙa — yawancin anan ana yin ta wajen fadada model (misali Profile ta fadada User).

## on_delete zaɓi (mahalaci don zaɓi daidai)

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

## Buɓugin tsara dangantaka

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

## Me yasa ya mahalaci

Tsara dangantaka daidai ita ce mahimma game da aiki da jiya'i data a Django — kusan kowa aikace-aikacen gaske yana da masu alaƙa (masu amfani da abubuwa, jigilar akan, talabi da abubuwa, labaru da tags), saboda haka fahimtar nau'i gida na alaƙa yana mahalaci kowannen aiki.

Sanin lokacin da ake amfani da kowane — **ForeignKey** don one-to-many (mafi yawan, kamar littattafai da suke ja wa maɗai), **ManyToManyField** don many-to-many (kamar abubuwan labari da tags, tare da Django ta aiki aljani table), da **OneToOneField** don one-to-one (kamar fadada mai amfani da profile) — ya wajaba don tsara kawan data model.

ORM ta ba da jiya data **Pythonic da sauƙi** (buɓugin `book.author` da `author.books.all()` natural, buɓugin jiya dangantaka tare da `__`), amma baƙi biyu na bukatan liman: zaɓi daidai **`on_delete` hali** (wajabi, mahalaci zaɓi — `CASCADE` ta goge abubuwan da suke da alaƙa, `PROTECT` ta dakatar da goge, `SET_NULL` ta fakantawa su — karɗa kusan haka da iya sa gida bari bari ido ko karfi kuskure), da amfani da `related_name` don bayyana jiya buɓugi.

fahimtar tsara dangantaka, on_delete zaɓi, da buɓugin jiya dangantaka shi ne mahimma game da gina daidai, da kirkirje Django data model, kuma yana juna da tsare buɓugi (tun da ci da dangantaka cikin waji ya sa N+1 matsala), ya sa shi abuni mahimma da yau-yau ana buɓugi.