Unaundaje relationships katika ORM?

Question

Accepted Answer

ORM ya Django inaunda relationships tatu za msingi za database kwa aina maalum za field: **ForeignKey** (one-to-many), **ManyToManyField** (many-to-many), na **OneToOneField** (one-to-one). Hizi zinafafanua jinsi tables zinavyohusiana na zinakupa ufikiaji wa Python kwa objects zinazohusiana.

## ForeignKey — one-to-many (ya kawaida zaidi)

```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` inaunda "vitabu vingi vinamilikiwa na author mmoja." Tabia ya `on_delete` (`CASCADE`, `PROTECT`, `SET_NULL`, n.k.) ni **ya lazima** na inafafanua kinachotokea kwa vitabu ikiwa author atafutwa.

## 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 inaunda kiotomatiki **join table** nyuma ya `ManyToManyField` — wewe tu unatumia `.add()`, `.remove()`, `.all()`. (Kwa data ya ziada juu ya relationship, tumia model ya `through`.)

## 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` inalazimisha kiungo kikali cha one-to-one — kinatumika mara kwa mara kupanua model (k.m. Profile inayopanua User).

## Chaguo za on_delete (muhimu kuchagua kwa usahihi)

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

## Kuhoji katika relationships

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

## Kwa nini ni muhimu

Kuunda relationships kwa usahihi ni jambo la msingi kwa kufanya kazi na data ya relational katika Django — karibu kila programu halisi ina entities zinazohusiana (watumiaji na posts, oda na items, articles na tags), hivyo kuelewa aina tatu za field za relationship ni maarifa ya msingi ya kila siku.

Kujua wakati wa kutumia kila moja — **ForeignKey** kwa one-to-many (ya kawaida zaidi, kama vitabu vinavyomilikiwa na author), **ManyToManyField** kwa many-to-many (kama articles na tags, Django ikisimamia kiotomatiki join table), na **OneToOneField** kwa one-to-one (kama kupanua user kwa profile) — ni muhimu kwa kubuni model yoyote ya data isiyo ya kawaida.

ORM inafanya data inayohusiana kuwa **ya Python na rahisi** (kufikia `book.author` na `author.books.all()` kwa njia ya asili, kuhoji katika relationships kwa `__`), lakini mambo mawili yanahitaji uangalifu: kuchagua tabia sahihi ya **`on_delete`** (uamuzi wa lazima na wenye matokeo — `CASCADE` inafuta objects zinazohusiana, `PROTECT` inazuia kufuta, `SET_NULL` inaziacha yatima — kuufanya vibaya kunaweza kusababisha upotevu wa data kwa bahati mbaya au makosa ya integrity), na kutumia `related_name` kwa ufikiaji wazi wa reverse.

Kuelewa uundaji wa relationship, chaguo za on_delete, na kuhoji katika relationships ni jambo la msingi kwa kujenga model za data za Django sahihi na zilizobuniwa vizuri, na kunaunganishwa moja kwa moja na uboreshaji wa query (kwa kuwa kupita katika relationships bila uangalifu kunasababisha matatizo ya N+1), kuifanya kuwa maarifa ya msingi na yanayopimwa mara kwa mara.