Miten mallinnat suhteita ORM:ssä?

Question

Accepted Answer

Django ORM mallintaa kolme perustavaa tietokantasuhdetta omilla kenttätyypeillään: **ForeignKey** (yksi-moneen), **ManyToManyField** (moneen-moneen) ja **OneToOneField** (yksi-yksi). Nämä määrittävät, miten taulukot liittyvät toisiinsa, ja tarjoavat Pythonista pääsyä liittyneisiin objekteihin.

## ForeignKey — yksi-moneen (yleisin)

```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` mallintaa "monet kirjat kuuluvat yhdelle kirjoittajalle". `on_delete`-käyttäytyminen (`CASCADE`, `PROTECT`, `SET_NULL` jne.) on **vaadittu** ja määrittää, mitä kirjoille tapahtuu, jos kirjoittaja poistetaan.

## ManyToManyField — moneen-moneen

```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 luo automaattisesti **liitostaulukon** `ManyToManyField`-kentän taakse — käytät vain `.add()`, `.remove()`, `.all()`-metodeja. (Jos tarvitset ylimääräisiä tietoja suhteesta, käytä `through`-mallia.)

## OneToOneField — yksi-yksi

```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` pakottaa tiukan yksi-yksi-linkin — yleisesti käytetään mallin laajentamiseen (esim. profiilin laajentaminen käyttäjää).

## on_delete-vaihtoehdot (tärkeä valita oikein)

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

## Kyselyt suhteissa

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

## Miksi sillä on merkitystä

Suhteiden mallintaminen oikein on perustavaa laatua Djangossa relatiivisten tietojen kanssa työskennellessä — lähes jokaisessa todellisessa sovelluksessa on liittyviä entititeettejä (käyttäjät ja artikkelit, tilaukset ja tuotteet, artikkelit ja nimiöt), joten kolmen suhdekentän tyypin ymmärtäminen on välttämätöntä päivittäistä osaamista.

Ja osata, milloin kukin seuraavista tulee käyttää — **ForeignKey** yksi-moneen-suhteille (yleisin, kuten kirjat, jotka kuuluvat kirjoittajalle), **ManyToManyField** moneen-moneen-suhteille (kuten artikkelit ja nimiöt, jolloin Django hallinnoi liitostaulukkoa automaattisesti) ja **OneToOneField** yksi-yksi-suhteille (kuten profiilin laajentaminen käyttäjää) — on välttämätöntä minkä tahansa ei-triviaalin tietomallin suunnittelussa.

ORM tekee liittyneistä tiedoista **Pythonista ja kätevää** (pääsy `book.author` ja `author.books.all()`-attribuutteihin luonnollisesti, kyselyt suhteissa `__`:lla), mutta kaksi asiaa vaativat huolellista harkintaa: oikean **`on_delete`-käyttäytymisen** valinta (vaadittu, merkittävä päätös — `CASCADE` poistaa liittyvät objektit, `PROTECT` estää poistamisen, `SET_NULL` tekee ne orvoiksi — väärä valinta voi aiheuttaa vahingossa tietojen menetyksen tai eheysvirheet) ja `related_name`-käyttö selkeään käänteiseen pääsyyn.

Suhteiden mallintamisen, on_delete-vaihtoehtojen ja suhteissa olevien kyselyjen ymmärtäminen on Djangon oikeiden ja hyvin suunniteltujen tietomallin rakentamisen ydin, ja se liittyy suoraan kyselyn optimointiin (koska suhteiden läpi naiivin kulkeminen aiheuttaa N+1-ongelmia), joten se on sekä perustavaa että usein testattavaa osaamista.