Kako funkcioniraju modeli i ORM?

Question

Accepted Answer

**Model** je Python klasa koja definira strukturu vaših podataka — svaki model mapira na tablicu baze podataka, a svaki atribut na stupac. **ORM (Object-Relational Mapper)** vam omogućava rad s bazom podataka koristeći Python objekte i metode umjesto pisanja surove SQL kode.

## Definiranje modela

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

Svako polje modela mapira na stupac baze podataka s odgovarajućom vrstom. Pokretanje migracija kreira odgovarajuću tablicu — nikada sami ne pišete `CREATE TABLE`.

## CRUD s ORM-om (bez SQL-a)

```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 automatski prevodi te Python pozive u SQL. Lookupovi polja (`__icontains`, `__gte`, `__in`, itd.) Pythonski izražavaju WHERE uvjete.

## Zašto ORM? Prednosti i kompromisi

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

## Modeli su jedini izvor istine (DRY)

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

## Zašto je to važno

Modeli i ORM su centralni za Django — oni su način na koji definirate i radite s podacima vaše aplikacije, što je srce većine web aplikacija.

Razumijevanje ih je bitno svakodnevno znanje: modeli definiraju vašu strukturu podataka (mapiranje klasa na tablice, atributa na stupce) i služe kao **jedini izvor istine** koji upravlja shemom baze podataka, admin sučeljem, formama i API serializatorima (DRY filozofija).

ORM vam omogućava pisanje operacija baze podataka u čistom, čitljivom **Pythonu umjesto SQL-a**, s velikim prednostima: prijenosivost baze podataka (isti kod radi na različitim bazama podataka), tesna integracija s ostatkom Django-a, i kritično važno **sigurnost** (koristi parametrizirane upite prema zadanoj postavci, sprječavajući SQL injection).

Znanje kako definirati modele s odgovarajućim poljima, izvršiti CRUD operacije i postavljati upite s ORM lookup sintaksom je fundamentalno za izgradnju bilo koje Django aplikacije.

Jednako je važna svjesnost o **kompromisu** ORM-a — da prikladan upiti mogu postati neučinkoviti (N+1 problem) bez pažnje — što vodi do tehnika optimizacije.
Sloj modela/ORM-a je gdje Django aplikacije troše veći dio svoje logike, čineći ga centralnim, materijalom koji morate savladati.