Cum funcționează modelele și ORM-ul?

Question

Accepted Answer

Un **model** este o clasă Python care definește structura datelor tale — fiecare model se mapează la un tabel de bază de date, iar fiecare atribut la o coloană. **ORM-ul (Object-Relational Mapper)** îți permite să interacționezi cu baza de date folosind obiecte și metode Python în loc să scrii SQL brut.

## Definirea unui model

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

Fiecare câmp al modelului se mapează la o coloană de bază de date cu un tip corespunzător. Executarea migrărilor creează tabelul corespunzător — nu trebuie să scrii `CREATE TABLE` tu însuți.

## CRUD cu ORM-ul (fără 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-ul traduce automat aceste apeluri Python în SQL. Field lookups-urile (`__icontains`, `__gte`, `__in`, etc.) exprimă condiții WHERE în mod Pythonic.

## De ce un ORM? Beneficii și compromisuri

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

## Modelele sunt sursa unică de adevăr (DRY)

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

## De ce este important

Modelele și ORM-ul sunt centrale în Django — acestea sunt modul în care definești și lucrezi cu datele aplicației tale, care este inima majorității aplicațiilor web.

Înțelegerea lor este cunoaștere esențială de zi cu zi: modelele definesc structura datelor tale (mapând clase la tabele, atribute la coloane) și servesc ca **sursa unică de adevăr** care conduce schema bazei de date, interfața admin, formularele și seria API (filosofia DRY).

ORM-ul îți permite să scrii operații de bază de date în Python curat și ușor de citit **în loc de SQL**, cu beneficii majore: portabilitate bazei de date (același cod rulează pe baze de date diferite), integrare strânsă cu restul Django și, crucialmente, **securitate** (folosește implicit interogări parametrizate, prevenind injecția SQL).

A ști cum să definești modele cu câmpuri corespunzătoare, să efectuezi operații CRUD și să faci interogări cu sintaxa lookup a ORM-ului este fundamental pentru construirea oricărei aplicații Django.

Egal de important este a fi conștient de **compromisul** ORM-ului — că interogările convenabile pot deveni ineficiente (problema N+1) fără grijă — ceea ce duce la tehnici de optimizare.

Nivelul model/ORM este locul în care aplicațiile Django petrec o mare parte din logica lor, făcând-o material de bază, care trebuie stăpânit.