Django ORM – praca z bazą danych

Czym jest ORM?

ORM (Object-Relational Mapping) to warstwa pośrednia między aplikacją a bazą danych, która automatycznie tłumaczy obiekty Python na zapytania SQL. Zamiast tworzyć tabele i zapytania ręcznie w SQL, definiujesz modele w Pythonie używając klas – Django automatycznie tworzy z nich odpowiednie struktury SQL podczas migracji. To podejście pozwala programiście myśleć w kategoriach obiektów i relacji między nimi, zamiast tabel i kluczy obcych w bazie danych.

Przykładowy model użytkownika pokazuje, jak prosto można definiować strukturę danych:

Python
Kopiuj
1
2
3
4
class User(models.Model):
name = models.CharField(max_length=100)
email = models.EmailField(unique=True)
created_at = models.DateTimeField(auto_now_add=True)

Po wykonaniu migracji Django utworzy w bazie tabelę app_user z kolumnami odpowiadającymi atrybutom klasy. Każdy obiekt User odpowiada jednemu wierszowi w tej tabeli, a wszystkie operacje na obiektach są automatycznie tłumaczone na odpowiednie zapytania SQL.

Tworzenie i zarządzanie modelami

Każdy model w Django dziedziczy po models.Model, co zapewnia mu dostęp do wszystkich funkcjonalności ORM. Kluczowe są typy pól (CharField, IntegerField, BooleanField, DateTimeField, ForeignKey, itd.) oraz opcje definiujące zachowanie modelu (np. unique, null, default, choices). Prawidłowe zdefiniowanie pól modelu determinuje strukturę tabeli w bazie danych oraz sposób walidacji i przechowywania danych.

Przykład bardziej złożonego modelu produktu:

Python
Kopiuj
1
2
3
4
class Product(models.Model):
name = models.CharField(max_length=200)
price = models.DecimalField(max_digits=8, decimal_places=2)
available = models.BooleanField(default=True)

Typy pól w Django ORM są bardzo bogate i pozwalają na precyzyjne definiowanie struktury danych. CharField służy do przechowywania krótkich tekstów, DecimalField do wartości pieniężnych z określoną precyzją, a BooleanField do wartości logicznych. Każde pole może mieć dodatkowe opcje, takie jak default dla wartości domyślnych, null=True dla opcjonalnych pól czy unique=True dla unikalnych wartości.

Relacje między modelami

ORM Django obsługuje trzy podstawowe typy relacji między modelami, które pokrywają większość przypadków użycia w rzeczywistych aplikacjach. Zrozumienie tych relacji jest kluczowe do projektowania efektywnych struktur danych i unikania problemów z integralnością danych.

1. One-to-Many (ForeignKey)

Relacja jeden-do-wielu jest najczęściej używanym typem relacji. Jeden użytkownik może mieć wiele postów, ale każdy post należy tylko do jednego autora:

Python
Kopiuj
1
2
3
4
5
6
class User(models.Model):
username = models.CharField(max_length=50)

class Post(models.Model):
author = models.ForeignKey(User, on_delete=models.CASCADE)
title = models.CharField(max_length=200)

Parametr on_delete=models.CASCADE określa, że gdy użytkownik zostanie usunięty, wszystkie jego posty również zostaną usunięte. Inne opcje to PROTECT (zabezpiecza przed usunięciem), SET_NULL (ustawia wartość na NULL) czy SET_DEFAULT (ustawia wartość domyślną).

2. Many-to-Many (ManyToManyField)

Relacja wiele-do-wielu pozwala na połączenie wielu rekordów z wielu tabel. Produkt może należeć do wielu kategorii, a kategoria może zawierać wiele produktów:

Python
Kopiuj
1
2
3
4
5
6
class Category(models.Model):
name = models.CharField(max_length=100)

class Product(models.Model):
name = models.CharField(max_length=200)
categories = models.ManyToManyField(Category)

Django automatycznie tworzy tabelę pośrednią dla relacji ManyToMany, która przechowuje powiązania między produktami a kategoriami. Możesz również zdefiniować własną tabelę pośrednią z dodatkowymi polami.

3. One-to-One (OneToOneField)

Relacja jeden-do-jednego łączy dokładnie jeden rekord z jednej tabeli z dokładnie jednym rekordem z drugiej tabeli. Każdy użytkownik ma jeden profil, a każdy profil należy do jednego użytkownika:

Python
Kopiuj
1
2
3
class Profile(models.Model):
user = models.OneToOneField(User, on_delete=models.CASCADE)
bio = models.TextField(blank=True)

Relacja OneToOne jest często używana do rozszerzenia istniejących modeli o dodatkowe pola bez modyfikacji oryginalnej tabeli, co jest szczególnie przydatne w przypadku modeli z innych aplikacji Django.

Tworzenie i zapisywanie obiektów

Tworzenie obiektów w ORM jest bardzo intuicyjne i przypomina standardowe tworzenie instancji klas w Pythonie. Możesz utworzyć obiekt i zapisać go do bazy w dwóch krokach:

Python
Kopiuj
1
2
user = User(name="Jan", email="jan@example.com")
user.save()

Lub użyć bardziej zwięzłej wersji, która tworzy i zapisuje obiekt w jednej operacji:

Python
Kopiuj
1
User.objects.create(name="Ewa", email="ewa@example.com")

Metoda create() jest bardziej efektywna, ponieważ wykonuje tylko jedno zapytanie do bazy danych, podczas gdy save() może wykonać dodatkowe zapytania w przypadku walidacji czy obliczania wartości pól automatycznych. Wybór metody zależy od tego, czy potrzebujesz zmodyfikować obiekt przed zapisem.

Zapytania do bazy

ORM pozwala wykonywać złożone zapytania bez pisania SQL. Wszystkie operacje odbywają się przez QuerySet, który jest leniwie ewaluowanym obiektem reprezentującym kolekcję obiektów z bazy danych. QuerySet nie wykonuje zapytania do bazy, dopóki nie zostanie użyty w kontekście wymagającym danych (np. w pętli for lub podczas konwersji na listę).

Pobieranie wszystkich rekordów jest najprostszą operacją:

Python
Kopiuj
1
users = User.objects.all()

Filtrowanie pozwala na wybór rekordów spełniających określone warunki. Django ORM oferuje bogaty zestaw lookups (filtry) dla precyzyjnego wyszukiwania:

Python
Kopiuj
1
2
3
active_users = User.objects.filter(is_active=True)
admins = User.objects.filter(role__in=["admin", "moderator"])
recent = Post.objects.filter(created_at__gte="2025-01-01")

Pobranie pojedynczego rekordu:

Python
Kopiuj
1
user = User.objects.get(id=1)

Metoda get() zwraca dokładnie jeden obiekt lub rzuca wyjątek, jeśli nie znajdzie żadnego rekordu albo znajdzie więcej niż jeden. To ważne, aby zawsze obsługiwać wyjątki podczas używania get():

Python
Kopiuj
1
2
3
4
5
6
from django.core.exceptions import ObjectDoesNotExist

try:
user = User.objects.get(email="test@example.com")
except ObjectDoesNotExist:
user = None

Alternatywnie możesz użyć filter().first(), które zwraca None zamiast rzucać wyjątek, gdy nie znajdzie rekordu.

Aktualizacja i usuwanie danych

ORM pozwala aktualizować i usuwać rekordy równie łatwo, jak je tworzyć. Możesz zaktualizować pojedynczy obiekt:

Python
Kopiuj
1
2
user.name = "Nowe imię"
user.save()

Lub zaktualizować wiele rekordów jedną operacją, co jest znacznie bardziej efektywne:

Python
Kopiuj
1
User.objects.filter(is_active=False).update(is_active=True)

Metoda update() wykonuje bezpośrednie zapytanie UPDATE w bazie danych bez ładowania obiektów do pamięci, co jest znacznie szybsze dla masowych aktualizacji. Usuwanie rekordów:

Python
Kopiuj
1
User.objects.filter(role="guest").delete()

Metoda delete() działa podobnie jak update() – wykonuje bezpośrednie zapytanie DELETE, ale pamiętaj, że wywołuje również sygnały Django i respektuje opcje on_delete w relacjach.

Relacje i dostęp do danych powiązanych

ORM automatycznie generuje odwrotne relacje, które pozwalają na łatwy dostęp do powiązanych danych. Dla relacji ForeignKey Django tworzy automatycznie atrybut odwrotny w modelu źródłowym:

Python
Kopiuj
1
2
post.author# dostęp do użytkownika (właściciela posta)
user.post_set.all()# wszystkie posty użytkownika

Możesz zmienić nazwę atrybutu odwrotnego używając parametru related_name w definicji ForeignKey. Dla relacji ManyToMany masz dostęp do metod zarządzania powiązaniami:

Python
Kopiuj
1
2
3
product.categories.add(cat1, cat2)
product.categories.remove(cat3)
product.categories.clear()

Metody add(), remove() i clear() pozwalają na dynamiczne zarządzanie relacjami ManyToMany bez bezpośredniego dostępu do tabeli pośredniej. Django automatycznie obsługuje wszystkie operacje na tabeli pośredniej w tle.

Optymalizacja zapytań – select_related i prefetch_related

Domyślnie ORM wykonuje lazy loading – dane są pobierane dopiero, gdy są potrzebne. To wygodne, ale może prowadzić do tzw. „N+1 problemu”, gdzie dla każdego obiektu z listy wykonuje się dodatkowe zapytanie do bazy danych. Django ORM oferuje dwa narzędzia do optymalizacji zapytań.

Metoda select_related pobiera dane z relacji OneToOne i ForeignKey jednym zapytaniem SQL używając JOIN:

Python
Kopiuj
1
posts = Post.objects.select_related("author").all()

Zamiast wykonywać osobne zapytanie dla każdego autora posta, Django pobierze wszystkie potrzebne dane w jednym zapytaniu. Metoda prefetch_related działa przy relacjach ManyToMany i odwrotnych ForeignKey, wykonując dwa oddzielne zapytania i łącząc wyniki w Pythonie:

Python
Kopiuj
1
products = Product.objects.prefetch_related("categories").all()

To podejście jest bardziej efektywne dla relacji ManyToMany, ponieważ JOIN na wielu tabelach pośrednich może być bardzo kosztowny. Prawidłowe użycie select_related i prefetch_related może zmniejszyć liczbę zapytań do bazy z setek do kilku.

Agregacje i adnotacje

ORM oferuje funkcje agregujące: Count, Sum, Avg, Max, Min, które pozwalają na wykonywanie obliczeń na całych zbiorach danych. Agregacje zwracają słownik z wynikami obliczeń:

Python
Kopiuj
1
2
3
from django.db.models import Count, Avg

stats = User.objects.aggregate(total=Count("id"), avg_posts=Avg("post__id"))

Adnotacje pozwalają dodawać dane obliczeniowe do każdego obiektu w QuerySet, co jest szczególnie przydatne podczas wyświetlania list z dodatkowymi informacjami:

Python
Kopiuj
1
users = User.objects.annotate(post_count=Count("post"))

Każdy obiekt User w wynikach będzie miał dodatkowy atrybut post_count zawierający liczbę powiązanych postów. Adnotacje są bardzo potężnym narzędziem do tworzenia złożonych raportów i analiz bez konieczności pisania surowego SQL.

Transakcje i atomiczność

Django wspiera transakcje przez dekorator @transaction.atomic, co gwarantuje spójność danych. Wszystkie operacje wewnątrz funkcji są traktowane jako jedna transakcja – jeśli jakakolwiek operacja się nie powiedzie, wszystkie zmiany zostaną cofnięte:

Python
Kopiuj
1
2
3
4
5
6
7
from django.db import transaction

@transaction.atomic
def create_order(user, items):
order = Order.objects.create(user=user)
for item in items:
OrderItem.objects.create(order=order, product=item)

Jeśli tworzenie któregokolwiek elementu zamówienia się nie powiedzie, całe zamówienie zostanie automatycznie cofnięte. To zapewnia integralność danych i chroni przed sytuacjami, gdzie część danych została zapisana, a część nie. Transakcje są szczególnie ważne w aplikacjach e-commerce, systemach finansowych i wszędzie tam, gdzie spójność danych jest krytyczna.

Migracje – jak Django zarządza schematem bazy

Migracje to system, który pozwala aktualizować strukturę bazy danych bez ręcznej ingerencji. Django tworzy pliki migracji na podstawie zmian w modelach, które można wersjonować w Git razem z kodem aplikacji. Tworzenie migracji:

Bash
Kopiuj
1
python manage.py makemigrations

Zastosowanie migracji:

Bash
Kopiuj
1
python manage.py migrate

Django tworzy w katalogu migrations pliki z historią zmian, które można wersjonować w Git. Dzięki temu schemat bazy jest zawsze zgodny z modelami, a współpraca w zespole jest znacznie łatwiejsza – każdy programista ma identyczną strukturę bazy danych. Migracje są odwracalne, co pozwala na cofanie zmian w strukturze bazy, jeśli zajdzie taka potrzeba.

Raw SQL – kiedy ORM to za mało

Czasem ORM nie wystarcza do zrealizowania bardzo złożonych zapytań lub operacji specyficznych dla konkretnej bazy danych. Django pozwala wykonywać surowe zapytania SQL:

Python
Kopiuj
1
results = User.objects.raw("SELECT * FROM app_user WHERE is_active = true")

Lub bezpośrednio przez connection.cursor() dla pełnej kontroli:

Python
Kopiuj
1
2
3
4
5
from django.db import connection

with connection.cursor() as cursor:
cursor.execute("SELECT * FROM app_user WHERE is_active = %s", [True])
row = cursor.fetchone()

Używaj surowego SQL tylko wtedy, gdy ORM naprawdę nie wystarcza – w większości przypadków ORM oferuje wystarczającą elastyczność i zapewnia lepsze bezpieczeństwo (ochrona przed SQL injection) oraz przenośność między różnymi bazami danych.

Wydajność i dobre praktyki

Efektywne używanie Django ORM wymaga znajomości kilku kluczowych zasad, które mogą dramatycznie poprawić wydajność aplikacji:

1. Używaj select_related i prefetch_related, aby ograniczyć liczbę zapytań do bazy danych. To najważniejsza optymalizacja w Django ORM.

2. Filtrowanie po indeksowanych kolumnach – definiuj db_index=True dla pól często używanych w zapytaniach WHERE, ORDER BY czy JOIN.

3. Nie iteruj po dużych QuerySetach bez .iterator() – metoda iterator() pobiera dane w partiach, co unikniesz nadmiernego zużycia pamięci przy przetwarzaniu tysięcy rekordów.

4. Używaj .values() i .values_list(), gdy nie potrzebujesz pełnych obiektów modelu. Te metody zwracają słowniki lub tuple zamiast obiektów, co jest znacznie szybsze.

5. Monitoruj zapytania – django-debug-toolbar pokaże, co naprawdę dzieje się pod spodem. Regularnie sprawdzaj liczbę i czas wykonywania zapytań SQL w widokach.

Podsumowanie

Django ORM to nie tylko wygodna warstwa nad SQL – to pełnoprawny system mapowania obiektowo-relacyjnego z obsługą transakcji, relacji, agregacji i optymalizacji. Zrozumienie jego działania to fundament każdego projektu Django. Jeśli potrafisz myśleć w kategoriach modeli i relacji, a nie tabel i kluczy, zyskujesz czystszy, bezpieczniejszy i bardziej elastyczny kod. Django ORM pozwala skupić się na logice biznesowej aplikacji, podczas gdy zarządzanie bazą danych odbywa się automatycznie i bezpiecznie.