Kako modeliraš relacije v ORM?

Question

Accepted Answer

Django ORM modelira tri temeljne relacije baz podatkov z namenskimi vrstami polj: **ForeignKey** (ena-na-več), **ManyToManyField** (več-na-več) in **OneToOneField** (ena-na-ena). Te določajo, kako so tabele povezane, in ti omogočajo Pythoničen dostop do povezanih objektov.

## ForeignKey — ena-na-več (najpogostejša)

```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 modelira "več knjig pripada enemu avtorju". Vedenje `on_delete` (`CASCADE`, `PROTECT`, `SET_NULL` itd.) je **obvezno** in določa, kaj se zgodi s knjigami, če je avtor izbrisan.

## ManyToManyField — več-na-več

```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 samodejno ustvari **vmesno tabelo** za `ManyToManyField` — uporabljaš samo `.add()`, `.remove()`, `.all()`. (Za dodatne podatke o relaciji uporabi `through` model.)

## OneToOneField — ena-na-ena

```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` uveljavi strogo eno-na-ena povezavo — pogosto se uporablja za razširitev modela (npr. profil razširja uporabnika).

## Možnosti on_delete (pomembno je izbrati pravilno)

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

## Poizvedovanje čez relacije

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

## Zakaj je to pomembno

Pravilno modeliranje relacij je temeljno za delo s povezanimi podatki v Djangu — skoraj vsaka resnična aplikacija ima povezane entitete (uporabniki in objave, naročila in artikli, članki in oznake), zato je razumevanje treh vrst polja relacij bistveno vsakodnevno znanje.

Znanje, kdaj uporabiti katero — **ForeignKey** za ena-na-več (najpogostejša, kot so knjige, ki spadajo avtorju), **ManyToManyField** za več-na-več (kot so članki in oznake, s Djangom, ki samodejno upravlja vmesno tabelo), in **OneToOneField** za ena-na-ena (kot je razširitev uporabnika s profilom) — je potrebno za načrtovanje katere koli ne-trivialnega podatkovnega modela.

ORM omogoča delo s povezanimi podatki **Pythoničnega in priročnega** (dostop do `book.author` in `author.books.all()` naraven, poizvedovanje čez relacije s `__`), vendar dva vidika zahtevata pozornost: izbira pravilnega **vedenja `on_delete`** (obvezna, pomembna odločitev — `CASCADE` izbriše povezane objekte, `PROTECT` preprečuje brisanje, `SET_NULL` jih osiroši — napačna odločitev lahko povzroči nepredvideno izgubo podatkov ali napake pri celovitosti), in uporaba `related_name` za jasen povratni dostop.

Razumevanje modeliranja relacij, možnosti on_delete in poizvedovanja čez relacije je osnovno za gradnjo pravilnih in dobro oblikovanih Djangovih podatkovnih modelov, in se neposredno povezuje z optimizacijo poizvedb (ker prečkanje relacij brez razmisleka povzroči N+1 probleme), zato je tako temeljno kot pogosto testirano znanje.