Conas a bhíonn samhail a dhéanamh ar na caidrimh san ORM?

Question

Accepted Answer

Modelaíonn ORM Django na trí chaidreamh bhunúsacha an bhunachair sonraí le cineálacha páirc dhíolúinte: **ForeignKey** (duine-go-go-leor), **ManyToManyField** (go-leor-go-go-leor), agus **OneToOneField** (duine-go-duine). Sainítear conas a bhíonn táblaí ag a bheith i gcaidreamh agus tugann siad rochtain Phythonach ar rudaí gaolmhara duit.

## ForeignKey — duine-go-go-leor (an ceann is coitianta)

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

Modelaíonn `ForeignKey` "go leor leabhar i ngiall d'údar amháin." Is **éigean** an iompar `on_delete` (`CASCADE`, `PROTECT`, `SET_NULL`, srl.) agus sainítear cad a tharlóidh do na leabhair má scriosadh an t-údar.

## ManyToManyField — go-leor-go-go-leor

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

Cruthóidh Django an **tábla ceangail** go huachúil taobh thiar de `ManyToManyField` — ní dhéanann tú ach `.add()`, `.remove()`, `.all()` a úsáid. (Ar son sonraí breise ar an chaidreamh, úsáid samhail `through`.)

## OneToOneField — duine-go-duine

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

Baineann `OneToOneField` nasc fíor-duine-go-duine i bhfeidhm — go coitianta úsáidtear chun samhail a shíneadh (m.sh. Próifíl a shíneadh ar Úsáideoir).

## roghanna on_delete (tábhachtach a roghnú i gceart)

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

## Fiosrúchán ar fud na gcaidreamh

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

## Cén fáth a bhfuil sé tábhachtach

Tá samhail a dhéanamh ar na caidrimh i gceart bunúsach do bheith ag obair le sonraí coibhneasacha in Django — tá roinn i bhfad nach bhfuil ann ar mhalairt den eagrúchán a bhfuil gaolmhara i gceist ann (úsáideoirí agus postanna, ordúcháin agus earraí, ailt agus clib), mar sin is gá tuiscint a bheith agat ar na trí chineál páirc caidrimh ar an taobh eile den ghealadh laethúil.

A fhios agat cathain a úsáid a dhéanamh ar gach rud — **ForeignKey** ar son duine-go-go-leor (an ceann is coitianta, ar nós leabhar a bheith i ngiall d'údar), **ManyToManyField** ar son go-leor-go-go-leor (ar nós alt agus clib, agus Django ag bainistiú an tábla ceangail go huachúil), agus **OneToOneField** ar son duine-go-duine (ar nós Próifíl a shíneadh ar úsáideoir) — is gá é seo chun aon samhail sonraí neamhthrivial a dhearadh.

Déanann an ORM sonraí gaolmhara **Pythonach agus tógálaech** (`book.author` agus `author.books.all()` a rochtain go nádúrtha, fiosrúchán ar fud na gcaidreamh le `__`), ach tá dhá ghné ann a theastaíonn cúram: an **`on_delete` iompar** a roghnú i gceart (cinneadh éigean agus iomrascail — `CASCADE` a scriosadh roinn i ngiall, `PROTECT` a chosaint ar scriosadh, `SET_NULL` agus iad gan fhios ar a gcúrsa — má fhéadtar é a dhéanamh mícheart is féidir call sonraí neamhthuillteanach nó earráidí slándála a dhéanamh), agus `related_name` a úsáid ar son rochtain chúlthaobh soiléir.

Tá tuiscint a bheith agat ar shamhail chaidrimh, na roghanna on_delete, agus fiosrúchán traschodlamh tabhachtach chun samhlacha sonraí Django ceart, dea-dheartha a thógáil, agus cuireann sé go díreach i bhfeidhm ar bharrfheidhmíochtaí fiosrúcháin (ó bharraigh gaolmhara go simplí N+1 fhadhbanna a chur ar bun), rud a dhéanann sé ina bunphointe agus eolas a bhíonn trialacha go minic.