Kuinka mallit ja ORM toimivat?

Question

Accepted Answer

**Malli** on Python-luokka, joka määrittää tietojen rakenteen — jokainen malli vastaa tietokantaa taulukkoa, ja jokainen attribuutti vastaa saraketta. **ORM (Object-Relational Mapper)** mahdollistaa tietokannan kanssa vuorovaikutuksen Python-objekteja ja metodeja käyttäen raakaSQL-komennon kirjoittamisen sijaan.

## Mallin määrittäminen

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

Jokainen mallin kenttä vastaa tietokantasaraketta sopivalla tyypillä. Migraatioiden suorittaminen luo vastaavan taulukon — et koskaan kirjoita `CREATE TABLE` itse.

## CRUD ORM:llä (ei 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 kääntää nämä Python-kutsut automaattisesti SQL:ksi. Kenttähaut (`__icontains`, `__gte`, `__in` jne.) ilmaisevat WHERE-ehtoja Pythonin tapaan.

## Miksi ORM? Edut ja kompromissit

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

## Mallit ovat ainut totuuden lähde (DRY)

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

## Miksi se on tärkeää

Mallit ja ORM ovat Django:n ytimessä — ne ovat tapa, jolla määrität ja käsittelet sovelluksesi tietoja, joka on useimpien verkkosovelluksien sydän.

Niiden ymmärtäminen on välttämätöntä päivittäistä tietoa: mallit määrittävät tietojen rakenteen (luokat taulukoiksi, attribuutit sarakkeiksi) ja toimivat **ainoana totuuden lähteenä**, joka ohjaa tietokantaskeemaa, hallintaliittymää, lomakkeita ja API-sarjoituksia (DRY-filosofia).

ORM mahdollistaa tietokanta-operaatioiden kirjoittamisen puhtaalla, luettavalla **Pythonilla SQL:n sijaan**, merkittävillä eduilla: tietokannan kannettavuus (sama koodi toimii eri tietokannoissa), tiukka integraatio loput Djangon kanssa, ja ratkaisevasti **turvallisuus** (se käyttää parametrisoituja kyselyitä oletuksena, estäen SQL-injektiot).

Tietäminen siitä, kuinka määrittää malleja sopivilla kentillä, suorittaa CRUD-operaatioita ja tehdä kyselyitä ORM:n hakusyntaksin avulla, on perustavanlaatuista minkä tahansa Django-sovelluksen rakentamiselle.

Yhtä tärkeää on ORM:n **kompromissin** tietoisuus — että kätevät kyselyt voivat muuttua tehottomiksi ilman huolellisuutta (N+1-ongelma) — joka johtaa optimointitekniikoihin.

Malli/ORM-kerros on paikka, jossa Django-sovellukset käyttävät paljon logiikkaansa, mikä tekee siitä keskeistä, välttämätöntä materiaalia.