Hogyan modellezed az ORM-ben az entitások közötti kapcsolatokat?

Question

Accepted Answer

Django ORM-je a három alapvető adatbázis-kapcsolatot dedikált field típusokkal modellezi: **ForeignKey** (egy-a-sok), **ManyToManyField** (sok-a-sok), és **OneToOneField** (egy-az-egy). Ezek definiálják, hogy a táblák hogyan kapcsolódnak egymáshoz, és Pythonic módon teszik elérhetővé a kapcsolódó objektumokat.

## ForeignKey — egy-a-sok (a leggyakoribb)

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

A `ForeignKey` a "sok könyv egy szerzőhöz tartozik" kapcsolatot modellezi. Az `on_delete` viselkedés (`CASCADE`, `PROTECT`, `SET_NULL`, stb.) **kötelező** és azt definiálja, hogy mi történik a könyvekkel, ha a szerző törlésre kerül.

## ManyToManyField — sok-a-sok

```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 automatikusan létrehozza az **összekapcsoló táblát** a `ManyToManyField` mögött — te csak a `.add()`, `.remove()`, `.all()` metódusokat használod. (Ha extra adatokra van szükség a kapcsolatban, használj `through` modellt.)

## OneToOneField — egy-az-egy

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

Az `OneToOneField` szigorú egy-az-egy kapcsolatot érvényesít — gyakran használatos modell kiterjesztésére (pl. egy Profile, amely kiterjeszti a User-t).

## on_delete opcók (fontos a helyes választás)

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

## Lekérdezés a kapcsolatok között

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

## Miért számít

A kapcsolatok helyes modellezése alapvető fontosságú a relációs adatokkal való munkavégzéshez Django-ban — szinte minden valós alkalmazásnak vannak kapcsolódó entitásai (felhasználók és poszt-ok, rendelések és termékek, cikkek és címkék), ezért a három kapcsolat field típus megértése napi szintű tudás.

Annak tudása, hogy mikor melyiket használd — **ForeignKey** egy-a-sok esetén (a leggyakoribb, mint amikor könyvek egy szerzőhöz tartoznak), **ManyToManyField** sok-a-sok esetén (mint cikkek és címkék, Django automatikusan kezeli az összekapcsoló táblát), és **OneToOneField** egy-az-egy esetén (mint amikor egy profillal kiterjesztünk egy felhasználót) — szükséges bármilyen nem triviális adatmodell tervezéséhez.

Az ORM-ben a kapcsolódó adatok **Pythonic és kényelmes** (a `book.author` és `author.books.all()` természetes elérése, kapcsolatok közötti lekérdezés a `__` szintaxissal), azonban két aspektus igényel odafigyelést: a helyes **`on_delete` viselkedés** kiválasztása (kötelező, következményes döntés — `CASCADE` törli a kapcsolódó objektumokat, `PROTECT` megakadályozza a törlést, `SET_NULL` árva adatokhoz vezet — hibás választás véletlen adatvesztéshez vagy integritási hibákhoz vezethet), és a `related_name` használata az egyértelmű fordított hozzáféréshez.

A kapcsolatmodellezés, az on_delete opciók és a kapcsolatok közötti lekérdezések megértése magvassá teszi a helyes, jól megtervezett Django adatmodellek felépítését, és közvetlenül kapcsolódik a lekérdezések optimalizálásához (mivel a kapcsolatok naiv bejárása N+1 problémákat okoz), így alapvetően és gyakran vizsgált tudásnak számít.