Hur fungerar modeller och ORM?

Question

Accepted Answer

En **modell** är en Python-klass som definierar strukturen på dina data — varje modell mappar till en databastabel, och varje attribut till en kolumn. **ORM (Object-Relational Mapper)** låter dig interagera med databasen med hjälp av Python-objekt och metoder istället för att skriva rå SQL.

## Definiera en modell

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

Varje modellfält mappar till en databaskolumn med en lämplig typ. Genom att köra migrations skapas motsvarande tabell — du behöver aldrig skriva `CREATE TABLE` själv.

## CRUD med ORM (ingen 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 översätter dessa Python-anrop till SQL automatiskt. Fältuppslagningar (`__icontains`, `__gte`, `__in`, osv.) uttrycker WHERE-villkor på Pythonisk väg.

## Varför en ORM? Fördelar och avvägningar

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

## Modeller är den enda sanningen (DRY)

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

## Varför det spelar roll

Modeller och ORM är centralt i Django — de är hur du definierar och arbetar med din applikations data, vilket är hjärtat i de flesta webbapplikationer.

Att förstå dem är väsentlig vardagskunskap: modeller definierar din datastruktur (mappar klasser till tabeller, attribut till kolumner) och fungerar som **den enda sanningen** som driver databasschemat, admin-gränssnittet, formulär och API-serialiserare (DRY-filosofin).

ORM låter dig skriva databasoperationer i ren, läsbar **Python istället för SQL**, med stora fördelar: databaskompabilitet (samma kod körs på olika databaser), tätt samband med resten av Django, och avgörande **säkerhet** (den använder parameteriserade frågor som standard, vilket förhindrar SQL-injektioner).

Att kunna definiera modeller med lämpliga fält, utföra CRUD-operationer och fråga med ORM:s uppslagssyntax är grundläggande för att bygga någon Django-applikation.

Lika viktigt är medvetenheten om ORM:s **avvägning** — att bekväma frågor kan bli ineffektiva (N+1-problemet) utan försiktighet — vilket leder till optimeringstekniker.

Modell-/ORM-lagret är där Django-applikationer lägger mycket av sin logik, vilket gör det till kärnmaterial som måste behärskas.