Hogyan működnek a modellek és az ORM?

Question

Accepted Answer

A **modell** egy Python osztály, amely az adatok szerkezetét határozza meg — minden modell egy adatbázis táblához, valamint minden attribútum egy oszlophoz rendelhető. Az **ORM (Object-Relational Mapper)** lehetővé teszi az adatbázissal való interakciót Python objektumok és metódusok segítségével, ahelyett, hogy nyers SQL-t írnál.

## Modell definiálása

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

Minden modell mező egy adatbázis oszlophoz rendelhető a megfelelő típussal. A migrációk futtatása létrehozza a megfelelő táblát — nem kell magadnak `CREATE TABLE` utasítást írni.

## CRUD az ORM-mel (SQL nélkül)

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

Az ORM automatikusan fordítja le ezeket a Python hívásokat SQL-re. A mező keresések (`__icontains`, `__gte`, `__in`, stb.) a WHERE feltételeket Pythonos módon fejezik ki.

## Miért ORM? Előnyök és kompromisszumok

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

## A modellek az egyetlen igazság forrása (DRY)

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

## Miért fontos

A modellek és az ORM a Django szíve — ezáltal definiálod és dolgozol az alkalmazásod adataival, amely a legtöbb webalkalmazás lényege.

Az ismeretük nélkülözhetetlen, mindennapi tudás: a modellek definiálják az adatstruktúrát (osztályok táblákhoz, attribútumok oszlopokhoz való leképezésével) és az **egyetlen igazság forrásaként** szolgálnak, amely meghatározza az adatbázis sémát, admin felületet, űrlapokat és API szerializálókat (DRY elv).

Az ORM lehetővé teszi az adatbázis műveletek tiszta, olvasható **Python helyett SQL nélkül** történő írását, jelentős előnyökkel: adatbázis hordozhatóság (ugyanaz a kód eltérő adatbázisokon futtatható), szoros integráció a Django többi részével, és döntően a **biztonság** (alapértelmezetten paraméterezett lekérdezéseket használ, megakadályozva az SQL injekciót).

A modellek definiálásának ismerete a megfelelő mezőkkel, a CRUD műveletek végrehajtása, és az ORM keresési szintaxisával történő lekérdezés alapvetően fontos bármely Django alkalmazás fejlesztéséhez.

Egyformán fontos az ORM **kompromisszumának** tudatossága — hogy a kényelmes lekérdezések óvatlanság nélkül hatékonytlanokká válhatnak (az N+1 probléma) — amely optimalizálási technikákhoz vezethet.

A modell/ORM réteg az a hely, ahol a Django alkalmazások logikájának nagy része működik, ezért alapvető, legyőzendő anyag.