როგორ მუშაობენ მოდელები და ORM?

Question

Accepted Answer

**მოდელი** არის Python კლასი, რომელიც განსაზღვრავს თქვენი მონაცემების სტრუქტურას — თითოეული მოდელი სიმ მიბლიკელი მონაცემთა ბაზის ცხრილზე, ხოლო თითოეული ატრიბუტი სვეტზე. **ORM (Object-Relational Mapper)** საშუალებას გაძლევთ ურთიერთობა სიმ მიბლიკელი მონაცემთა ბაზესთან Python ობიექტებისა და მეთოდების გამოყენებით, ნაწილი raw SQL-ის წერის ნაწილი.

## მოდელის განსაზღვრა

```python
from django.db import models

class Article(models.Model):
    title = models.CharField(max_length=200)       # → VARCHAR column
    body = models.TextField()                        # → TEXT column
    published = models.BooleanField(default=False)
    created_at = models.DateTimeField(auto_now_add=True)  # set on creation
    views = models.IntegerField(default=0)

def __str__(self):
        return self.title                            # readable representation (admin, shell)
```

თითოეული მოდელის ველი სიმ მიბლიკელი მონაცემთა ბაზის სვეტზე შესაბამისი ტიპით. მიგრაციების გაშვება ქმნის შესაბამის ცხრილს — თქვენ არასდროს წერთ `CREATE TABLE`-ს თავად.

## CRUD ORM-ით (SQL გარეშე)

```python
# CREATE
article = Article.objects.create(title="Hello", body="...")

# READ — query with Python methods
Article.objects.all()                            # all rows → SELECT *
Article.objects.get(id=1)                         # one row by primary key
Article.objects.filter(published=True)            # WHERE published = true
Article.objects.filter(title__icontains="django") # WHERE title ILIKE '%django%'
Article.objects.exclude(views=0).order_by("-created_at")  # complex queries, chained

# UPDATE
article.title = "Updated"
article.save()
Article.objects.filter(published=False).update(published=True)  # bulk update

# DELETE
article.delete()
```

ORM თარგმნის ამ Python ზარებს SQL-ში ავტომატურად. ველის ძიებები (`__icontains`, `__gte`, `__in` და ა.შ.) გამოხატავენ WHERE პირობებს Python-ულად.

## რატომ ORM? სარგებელი და კომპრომისები

```text
✓ Write database code in Python — no SQL, more readable, less error-prone
✓ Database-agnostic — the same code works on PostgreSQL, MySQL, SQLite
✓ SECURITY — parameterized queries by default → prevents SQL injection
✓ Integrates with migrations, admin, forms (define the model once)
⚠️ Trade-off: can generate inefficient queries (e.g. N+1) if used carelessly —
   sometimes you need select_related/prefetch_related or raw SQL for complex cases
```

## მოდელები არის ჭეშმარიტების ერთი წყარო (DRY)

```text
One model definition drives: the database schema (migrations), the admin interface,
ModelForms, and serializers (DRF) — define it once, reuse everywhere.
```

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

მოდელები და ORM არის Django-ს ცენტრალური — ეს არის როგორ განსაზღვრავთ და მუშაობთ თქვენი აპლიკაციის მონაცემებთან, რაც უმეტესი ვებ-აპლიკაციების გულია.

მათი გაგება არის აუცილებელი ყოველდღიური ცოდნა: მოდელები განსაზღვრავენ თქვენი მონაცემების სტრუქტურას (კლასების ცხრილებთან, ატრიბუტების სვეტებთან აკავშირებენ) და ემსახურებიან **ჭეშმარიტების ერთ წყაროს**, რომელიც აძლებს მონაცემთა ბაზის სქემას, admin ინტერფეისს, ფორმებს და API serializers-ებს (DRY ფილოსოფია).

ORM საშუალებას გაძლევთ დაწეროთ მონაცემთა ბაზის ოპერაციები სუფთა, წაკითხვად **Python-ში SQL-ის ნაწილი**, დიდი სარგებლებით: მონაცემთა ბაზის პორტატიულობა (ერთი კოდი მუშაობს სხვადსხვა მონაცემთა ბაზებში), მჭიდრო ინტეგრაცია Django-ს დანარჩენ ნაწილთან, და კრიტიკულად **უსაფრთხოება** (ის ნაგულისხმევად იყენებს პარამეტრირებულ შეკითხვებს, SQL injection-ის თავიდან აცილება).

მოდელების განსაზღვრის, CRUD ოპერაციების შესრულების და ORM-ის ძიების სინტაქსით შეკითხვის ცოდნა ფუნდამენტური არის ნებისმიერი Django აპლიკაციის აგებისთვის.

თანაბრად მნიშვნელოვანი არის ORM-ის **კომპრომისის** შესახებ ცნობიერება — რომ მოსახერხებელი შეკითხვები შეიძლება გახდეს არაეფექტური (N+1 პრობლემა) ზრუნვის გარეშე — რაც მივყავართ ოპტიმიზაციის ტექნიკებამდე.

მოდელი/ORM ფენა არის სადაც Django აპლიკაციები ხარჯობენ მრავალ მათ ლოგიკას, რაც ქმნის მას ბირთვი, აუცილებელი-დაუფლო მასალა.