Kako modelirate odnose u ORM-u?

Question

Accepted Answer

Django ORM modelira tri fundamentalna odnosa baze podataka s namjenskim vrstama polja: **ForeignKey** (jedan-prema-mnogima), **ManyToManyField** (mnogo-prema-mnogima) i **OneToOneField** (jedan-prema-jedan). Oni definiraju kako se tablice odnose i daju vam Pythonski pristup povezanim objektima.

## ForeignKey — jedan-prema-mnogima (najčešće)

```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 "mnogim knjigama pripada jedan autor". Ponašanje `on_delete` (`CASCADE`, `PROTECT`, `SET_NULL`, itd.) je **obavezno** i definira što se dogodi s knjigama ako se autor obriše.

## ManyToManyField — mnogo-prema-mnogima

```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 automatski stvara **join tablicu** iza `ManyToManyField` — jednostavno koristite `.add()`, `.remove()`, `.all()`. (Za dodatne podatke o odnosu, koristite `through` model.)

## OneToOneField — jedan-prema-jedan

```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` forsira strogu vezu jedan-prema-jedan — često se koristi za proširenje modela (npr. Profile koji proširuje User).

## on_delete opcije (važno je odabrati ispravno)

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

## Querying across 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'
```

## Zašto je to važno

Ispravno modeliranje odnosa temelj je rada s relacijskim podacima u Djangu — gotovo svaka prrava aplikacija ima povezane entitete (korisnike i objave, narudžbe i stavke, članke i oznake), pa je razumijevanje triju vrsta polja za odnose bitno svakodnevno znanje.

Znati kada koristiti koju vrstu — **ForeignKey** za jedan-prema-mnogima (najčešće, kao knjige koje pripadaju autoru), **ManyToManyField** za mnogo-prema-mnogima (kao članci i oznake, s Djangom koji automatski upravlja join tablicom) i **OneToOneField** za jedan-prema-jedan (kao proširenje korisnika s profilom) — nužno je za dizajniranje bilo kojeg netrivijalnog podatkovnog modela.

ORM čini povezane podatke **Pythonskim i praktičnim** (pristup `book.author` i `author.books.all()` prirodno, querying kroz odnose s `__`), ali dva aspekta zahtijevaju pažnju: odabir ispravnog **`on_delete` ponašanja** (obavezna, važna odluka — `CASCADE` briše povezane objekte, `PROTECT` sprječava brisanje, `SET_NULL` ih ostavlja bez vlasnika — pogrešna izbora može izazvati slučajni gubitak podataka ili greške u integraciji), te korištenje `related_name` za jasan obrnuti pristup.

Razumijevanje modeliranja odnosa, on_delete opcija i cross-relationship queryinga je temelj za izgradnju ispravnih, dobro dizajniranih Django podatkovnih modela, i izravno se povezuje na optimizaciju queryja (jer naivno prelaženje odnosa uzrokuje N+1 probleme), što ga čini i temeljnim i često testiranim znanjem.