Jak fungují modely a ORM?

Question

Accepted Answer

**Model** je třída v Pythonu, která definuje strukturu vašich dat — každý model mapuje na tabulku v databázi a každý atribut na sloupec. **ORM (Object-Relational Mapper)** vám umožňuje pracovat s databází pomocí objektů a metod v Pythonu namísto psaní surového SQL.

## Definování modelu

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

Každé pole modelu mapuje na sloupec databáze s příslušným typem. Spuštění migrací vytvoří odpovídající tabulku — sami nikdy nepíšete `CREATE TABLE`.

## CRUD s ORM (bez 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 automaticky překládá tato volání v Pythonu do SQL. Vyhledávání polí (`__icontains`, `__gte`, `__in`, apod.) vyjadřují podmínky WHERE pythonicky.

## Proč ORM? Výhody a kompromisy

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

## Modely jsou jediným zdrojem pravdy (DRY)

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

## Proč je to důležité

Modely a ORM jsou jádrem Django — jsou to prostředky, jak definujete a pracujete s daty vaší aplikace, což je srdce většiny webových aplikací.

Porozumění jim je zásadní každodenní znalost: modely definují strukturu vašich dat (mapování tříd na tabulky, atributů na sloupce) a slouží jako **jediný zdroj pravdy**, který řídí schéma databáze, administrační rozhraní, formuláře a serializéry API (filosofie DRY).

ORM vám umožňuje psát operace s databází v čistém, čitelném **Pythonu namísto SQL**, s velkými výhodami: přenositelnost databází (stejný kód běží na různých databázích), těsná integrace se zbytkem Django a zásadně **bezpečnost** (ve výchozím nastavení používá parametrizované dotazy, což brání SQL injection).

Znalost definování modelů s vhodných polí, provádění CRUD operací a dotazování pomocí syntaxe vyhledávání ORM je základem pro vytváření jakékoli aplikace Django.

Rovněž důležité je vědomí **kompromisu** ORM — že pohodlné dotazy se mohou stát neefektivními (problém N+1) bez péče — což vede na optimalizační techniky.
Vrstva model/ORM je místo, kde Django aplikace tráví velkou část své logiky, což ji činí základním a nezbytným materiálem k ovládnutí.