Kako delujejo modeli in ORM?

Question

Accepted Answer

**Model** je Python razred, ki opredeljuje strukturo vaših podatkov — vsak model se preslika na tabelo v bazi podatkov, vsak atribut pa na stolpec. **ORM (Object-Relational Mapper)** vam omogoča interakcijo z bazo podatkov s pomočjo Python objektov in metod namesto pisanja surovih SQL stavkov.

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

Vsak polju modela se preslika na stolpec v bazi podatkov z ustreznim tipom. Zagon migracijsk ustvari ustrezno tabelo — sami nikoli ne napišete `CREATE TABLE`.

## CRUD z ORM (brez 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 te Python klice samodejno prevede v SQL. Iskanja polj (`__icontains`, `__gte`, `__in` itd.) Pythonsko izražajo pogoje WHERE.

## Zakaj ORM? Prednosti in 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 so edini vir resnice (DRY)

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

## Zakaj je to pomembno

Modeli in ORM so osrednji del Djanga — to je način, kako opredelite in delate s podatki vaše aplikacije, kar je srce večine spletnih aplikacij.

Razumevanje jih je bistveno vsakodnevno znanje: modeli opredelijo strukturo vaših podatkov (preslika razredi na tabele, atribute na stolpce) in služijo kot **edini vir resnice**, ki poganja shemo baze podatkov, upravniški vmesnik, obrazce in API serijalizatorje (filozofija DRY).

ORM vam omogoča pisanje operacij baze podatkov v čistega, berljiva **Python namesto SQL**, z večjo prednostmi: prenosljivostjo baze podatkov (ista koda deluje na različnih bazah podatkov), tesno integracijo s preostalim Djangom in kritično **varnostjo** (privzeto uporablja parametrizirane poizvedbe, kar preprečuje SQL injekcije).

Znanje, kako opredeliti modele z ustreznimi polji, izvajati operacije CRUD in poizvedovati z ORM-ovo sintakso iskanja, je temeljno za gradnjo kakršne koli Django aplikacije.

Enako pomembna je zavest o **kompromisu** ORM-a — da lahko priročne poizvedbe postanejo neučinkovite (problem N+1) brez skrbi — kar vodi do tehnik optimizacije.

Plast model/ORM je mesto, kjer Django aplikacije porabijo večino svoje logike, zato je to jedro in nujno obvladati material.