Si i modeloni marrëdhëniet në ORM?

Question

Accepted Answer

ORM e Django-t modelon tre marrëdhëniet themelore të bazës së të dhënave me lloje të dedikuara fushe: **ForeignKey** (një-në-shumë), **ManyToManyField** (shumë-në-shumë), dhe **OneToOneField** (një-në-një). Këto përcaktojnë se si lidhen tabelat dhe ju japin qasje Pythonic në objekte të lidhur.

## ForeignKey — një-në-shumë (më e zakonshme)

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

Një `ForeignKey` modelon "shumë libra i përkasin një autori." Sjellja `on_delete` (`CASCADE`, `PROTECT`, `SET_NULL`, etj.) është **e detyrueshme** dhe përcakton se çfarë ndodh me librat nëse autori fshihet.

## ManyToManyField — shumë-në-shumë

```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-t automatikisht krijon **tabelën e bashkimit** pas një `ManyToManyField` — ju thjesht përdorni `.add()`, `.remove()`, `.all()`. (Për të dhëna shtesë në marrëdhënie, përdorni një model `through`.)

## OneToOneField — një-në-një

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

Një `OneToOneField` zbaton një lidhje strikte një-në-një — zakonisht përdoret për të zgjeruar një model (p.sh. një Profile që zgjeron një User).

## on_delete opsionet (e rëndësishme të zgjedh saktë)

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

## Kërkimi në të gjithë marrëdhëniet

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

## Pse është e rëndësishme

Modelimi i saktë i marrëdhënieve është themelor për punën me të dhëna relacionale në Django — pothuajse çdo aplikacion real ka entitete të lidhura (përdoruesit dhe postimet, porositë dhe artikujt, artikujt dhe etiketat), kështu që kuptimi i tre llojeve të fushave të marrëdhënies është njohuri thelbësore e përditshme.

Ditja se kur të përdorësh secilën — **ForeignKey** për një-në-shumë (më e zakonshme, si librat që i përkasin një autori), **ManyToManyField** për shumë-në-shumë (si artikujt dhe etiketat, me Django që menaxhon automatikisht tabelën e bashkimit), dhe **OneToOneField** për një-në-një (si zgjerimi i një përdoruesi me një profil) — është e nevojshme për hartimin e ndonjë modeli të dhënash jo-trivial.

ORM e bën të dhënat e lidhura **Pythonic dhe të përshtatshme** (qasja në `book.author` dhe `author.books.all()` natyrshëm, kërkimi në të gjithë marrëdhëniet me `__`), por dy aspekte kërkojnë kujdes: zgjedhja e saktë e **sjelljeve `on_delete`** (një vendim i detyrueshëm, me pasoja — `CASCADE` fshijn objektet e lidhur, `PROTECT` parandalon fshirjen, `SET_NULL` i lë ata pa pronë — ta bësh gabim mund të shkaktojë humbje aksidentale të të dhënave ose gabime integrimi), dhe përdorimi i `related_name` për qasje të qartë të kundërt.

Kuptimi i modelimit të marrëdhënieve, opsionet `on_delete`, dhe kërkimi në të gjithë marrëdhëniet është themelor për ndërtimin e modeleve të dhënash Django të sakta dhe të mirëdizajnuara, dhe ajo lidhet drejtpërdrejt me optimizimin e pyetjeve (pasi që kalimi përmes marrëdhënieve pa kujdes shkakton probleme N+1), duke e bërë atë si njohuri themelore ashtu edhe të testuar shpesh.