როგორ მოდელირებთ ურთიერთობებს ORM-ში?

Question

Accepted Answer

Django-ის ORM მოდელირებს სამ ფундამენტურ მონაცემთა ბაზის ურთიერთობას დეცირებული ველების ტიპებით: **ForeignKey** (ერთი-ბევრზე), **ManyToManyField** (ბევრი-ბევრზე) და **OneToOneField** (ერთი-ერთზე). ეს განსაზღვრავს, როგორ დაკავშირებულია ცხრილები და გაძლევთ Pythonic-ის წვდომას დაკავშირებული ობიექტებზე.

## ForeignKey — ერთი-ბევრზე (ყველაზე გავრცელებული)

```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` მოდელირებს "ბევრი წიგნი ერთ ავტორს ეკუთვნის." `on_delete` ქცევა (`CASCADE`, `PROTECT`, `SET_NULL` და ა.შ.) **აუცილებელია** და განსაზღვრავს, რა ხდება წიგნებთან, თუ ავტორი წაიშლება.

## ManyToManyField — ბევრი-ბევრზე

```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-ს ავტომატურად აქმნის **შეერთების ცხრილი** `ManyToManyField`-ის უკან — თქვენ უბრალოდ იყენებთ `.add()`, `.remove()`, `.all()`. (ურთიერთობაზე დამატებითი მონაცემებისთვის გამოიყენეთ `through` მოდელი.)

## OneToOneField — ერთი-ერთზე

```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` ახდენს მკაცრ ერთი-ერთზე ბმულს — ჩვეულებრივ გამოიყენება მოდელის გაფართოებისთვის (მაგ. Profile-ი, რომელიც ფართოვდება User-ს).

## on_delete ვარიანტები (მნიშვნელოვანია სწორი არჩევანი)

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

## ურთიერთობებში გაკითხვა

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

## რატომ არის მნიშვნელოვანი

ურთიერთობების სწორი მოდელირება Django-ში რელაციური მონაცემებთან მუშაობის ფუნდამენტია — თითქმის ყველა რეალური აპლიკაციას აქვს დაკავშირებული enti სიტეტები (მომხმარებლები და პოსტები, შეკვეთები და ელემენტები, სტატიები და ტეგები), ამიტომ სამი ურთიერთობის ველის ტიპის გაგება აუცილებელი ყოველდღიური ცოდნაა.

ის ცოდნა, თუ რომელი რა დროს გამოიყენოთ — **ForeignKey** ერთი-ბევრზე (ყველაზე გავრცელებული, როგორც წიგნები, რომლებიც ავტორს ეკუთვნის), **ManyToManyField** ბევრი-ბევრზე (როგორც სტატიები და ტეგები, Django-ს შეერთების ცხრილის ავტომატური მართვით) და **OneToOneField** ერთი-ერთზე (როგორც მომხმარებლის გაფართოება profile-ით) — აუცილებელია ნებისმიერი არა-ტრივიალური მონაცემთა მოდელის დიზაინისთვის.

ORM აკეთებს დაკავშირებულ მონაცემებს **Pythonic-ს და მოსახერხებელს** (გვენდობილი წვდომა `book.author` და `author.books.all()` ბუნებრივად, ურთიერთობებზე გაკითხვა `__`-ით), მაგრამ ორი ასპექტი მოითხოვს ზრუნვას: სწორი **`on_delete` ქცევის** არჩევანი (აუცილებელი, შედეგიანი გადაწყვეტილება — `CASCADE` წაშლის დაკავშირებულ ობიექტებს, `PROTECT` თავიდან აცილებს წაშლას, `SET_NULL` მათ დაზღვევას აღმოფხვრის — შეცდომა შეიძლება გამოიწვიოს აქციდენტური მონაცემების დაკარგვა ან ინტეგრალობის შეცდომა), და `related_name`-ის გამოყენება ნათელი საპირისპირო წვდომისთვის.

ურთიერთობის მოდელირების, on_delete ვარიანტების და ურთიერთობებზე გაკითხვის გაგება Django მონაცემთა მოდელების სწორი, კარგად დიზაინის აგების ბირთვია, და ის პირდაპირ აკავშირებს გაკითხვის ოპტიმიზაციას (რადგან ურთიერთობების საფრთხე გაწვევამ იწვევს N+1 პრობლემას), რაც ის როგორც საფუძველი და ხშირად შემოწმებული ცოდნა აკეთებს.