Kaip modeliuoti ryšius ORM?

Question

Accepted Answer

Django ORM modeliuoja tris fundamentalius duomenų bazės ryšius su dedikuotais lauko tipais: **ForeignKey** (vienas-su-daugeliu), **ManyToManyField** (daug-su-daug) ir **OneToOneField** (vienas-su-vienu). Šie lauko tipai apibrėžia, kaip lentelės yra susijusios, ir suteikia Pythonic'ą prieigą prie susijusių objektų.

## ForeignKey — vienas-su-daugeliu (dažniausias atvejis)

```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` modeliuoja "daug knygų priklauso vienam autoriui". `on_delete` elgsena (`CASCADE`, `PROTECT`, `SET_NULL` ir kt.) yra **privalomai** ir apibrėžia, kas nutiks knygoms, jei autorius bus ištrintas.

## ManyToManyField — daug-su-daug

```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 automatiškai sukuria **sujungimo lentelę** už `ManyToManyField` — jūs tiesiog naudojate `.add()`, `.remove()`, `.all()`. (Jei reikia papildomų duomenų apie ryšį, naudokite `through` modelį.)

## OneToOneField — vienas-su-vienu

```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` užtikrina griežtą vienas-su-vienu ryšį — dažniausiai naudojamas modeliui išplėsti (pvz., User'į išplečiantis Profile).

## on_delete parinktys (svarbu pasirinkti teisingai)

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

## Užklausos skersai ryšių

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

## Kodėl tai svarbu

Teisingai modeliuoti ryšius yra fundamentinis dalykas dirbant su reliaciniais duomenimis Django — beveik kiekviena reali aplikacija turi susijusius elementus (vartotojai ir straipsniai, užsakymai ir prekės, straipsniai ir žymos), todėl suprasti tris ryšio lauko tipus yra labai svarbi kasdienė žinia.

Žinoti, kada naudoti kiekvieną — **ForeignKey** vienas-su-daugeliu ryšiams (dažniausias, pvz., knygos priklausančios autoriui), **ManyToManyField** daug-su-daug ryšiams (pvz., straipsniai ir žymos, Django automatiškai valdant sujungimo lentelę) ir **OneToOneField** vienas-su-vienu ryšiams (pvz., vartotoją išplečiantis profilis) — yra būtina bet kokiam netrivialiam duomenų modeliui suprojektuoti.

ORM daro susijusius duomenis **Pythonic'ais ir patogiaisiais** (natūraliai pasiekiant `book.author` ir `author.books.all()`, atliekant užklausas skersai ryšių su `__`), tačiau du aspektai reikalauja dėmesio: teisingos **`on_delete` elgsenos** pasirinkimas (privalomai pasirenkama, konsekventiška sprendimas — `CASCADE` panaikina susijusius objektus, `PROTECT` neleidžia panaikinimo, `SET_NULL` juos pasiūlo — neteisingas pasirinkimas gali sukelti netyčinį duomenų praradimą ar integralamumo klaidas) ir `related_name` naudojimas dėl aiškios atvirkštinės prieigos.

Suprasti ryšių modeliavimą, on_delete parinktis ir tarpryšines užklausas — tai yra Django duomenų modelių kūrimo esmė, ir tai tiesiogiai susiję su užklausų optimizavimu (nes netiksliai perėjus ryšius atsiranda N+1 problemos), todėl tai yra tiek fundamentali, tiek dažnai tikrinama žinia.