Wat zijn modellen in Django?

Een model in Django is een object dat de structuur van een database tabel definieert. Het model bepaalt welke velden de tabel heeft en welke eigenschappen deze velden hebben. Het model zorgt er ook voor dat de data correct gevalideerd wordt voordat deze in de database opgeslagen wordt. Django biedt een ingebouwde Object Relational Mapper (ORM) die ontwikkelaars in staat stelt om te werken met de database zonder SQL te hoeven schrijven.

Hoe werkt het ORM in Django?

Het ORM in Django zorgt ervoor dat de database aanroepen worden geabstraheerd. In plaats van SQL direct te schrijven, worden de aanroepen gedaan via Python code. Dit zorgt ervoor dat ontwikkelaars zich kunnen concentreren op de functionaliteit van de applicatie in plaats van de details van de database.

Het ORM van Django maakt gebruik van een reeks van Python klassen die overeenkomen met de database tabellen. Elke klasse wordt gedefinieerd als een model en bevat de velden van de tabel. Hier is een voorbeeld:

from django.db import models

class Book(models.Model):
    title = models.CharField(max_length=200)
    author = models.CharField(max_length=200)
    pub_date = models.DateField()
    price = models.DecimalField(max_digits=5, decimal_places=2)
 

In dit voorbeeld definiëren we een Book model met vier velden: title, author, pub_date, en price. title en author zijn strings van maximaal 200 karakters. pub_date is een datumveld en price is een decimal veld met een precisie van 5 cijfers en 2 decimalen.

Hoe maak je een model aan?

Om een model aan te maken, moet je een Python klasse maken die de models.Model klasse erft. Vervolgens definieer je de velden van de tabel als attributen van de klasse. Dit zijn enkele van de velden die je kunt definiëren:

CharField: een string van een bepaalde lengte

TextField: een langere tekst string

DateField: een datumveld

DateTimeField: een datum- en tijds veld

IntegerField: een integer veld

BooleanField: een boolean veld

DecimalField: een decimal veld

ForeignKey: een verwijzing naar een andere tabel

Het is belangrijk om op te merken dat wanneer je een veld aanmaakt, je verschillende opties kunt specificeren. Deze opties bepalen bijvoorbeeld of het veld verplicht is, de standaard waarde, enz. Hier is een voorbeeld van hoe je een model kunt definiëren:

from django.db import models

class Person(models.Model):
    first_name = models.CharField(max_length=50)
    last_name = models.CharField(max_length=50)
    age = models.IntegerField()
    email = models.EmailField(unique=True)
    is_active = models.BooleanField(default=True)
    date_created = models.DateTimeField(auto_now_add=True)
    date_modified = models.DateTimeField(auto_now=True)
    avatar = models.ImageField(upload_to='avatars/', null=True, blank=True)

    def __str__(self):
        return f'{self.first_name} {self.last_name}'
 

In dit voorbeeld definiëren we een Person model met verschillende velden. first_name en last_name zijn strings van maximaal 50 karakters. age is een integer veld. email is een uniek emailveld en is_active is een boolean veld dat standaard op True staat. date_created en date_modified zijn datum- en tijds velden die automatisch de datum en tijd van aanmaak en aanpassing van de rij opslaan. avatar is een afbeeldingsveld dat naar de map "avatars/" uploadt. Het veld mag null zijn en de gebruiker kan het veld leeg laten.

Hoe maak je een tabel aan in de database? Na het definiëren van het model moet je de tabel aanmaken in de database. Dit wordt gedaan met behulp van Django's database migratie systeem. Dit systeem houdt bij welke wijzigingen aan het model zijn aangebracht en genereert de SQL-aanroepen om de tabel in de database aan te maken of te wijzigen.

Om een migratie aan te maken, voer je de volgende commando's uit in de terminal:

python manage.py makemigrations

Dit zal een migratiebestand maken in de migrations/ map. Dit bestand bevat de SQL-aanroepen die nodig zijn om de tabel aan te maken of te wijzigen.

Om de migratie uit te voeren en de tabel in de database aan te maken, voer je het volgende commando uit:

python manage.py migrate

Dit zal de tabel in de database aanmaken en eventuele wijzigingen die in het model zijn aangebracht toepassen op de tabel.

Hoe haal je data op uit de database?

Het ophalen van data uit de database wordt gedaan via de ORM van Django. Dit gebeurt door het maken van een queryset, een verzameling van objecten die overeenkomen met de geselecteerde rijen in de database.

Hier is een voorbeeld van hoe je alle personen kunt ophalen uit de Person tabel:

from myapp.models import Person

people = Person.objects.all()
 

Dit zal een queryset teruggeven met alle rijen uit de Person tabel.

Je kunt ook querysets filteren om alleen de rijen te krijgen die aan bepaalde criteria voldoen. Hier is een voorbeeld:

from myapp.models import Person

adults = Person.objects.filter(age__gte=18)
 

Dit zal een queryset teruggeven met alle personen die 18 jaar of ouder zijn.

Hoe sla je data op in de database?

Het opslaan van data in de database gebeurt door het aanmaken van een instantie van het model en deze op te slaan met de `save methode'. Hier is een voorbeeld:

from myapp.models import Person

person = Person(first_name='John', last_name='Doe', age=25, email='john.doe@example.com')
person.save()
 

Dit zal een nieuwe rij aanmaken in de Person tabel met de opgegeven waarden.

Je kunt ook meerdere rijen tegelijkertijd toevoegen door het bulk_create methode te gebruiken. Hier is een voorbeeld:

from myapp.models import Person

people = [
    Person(first_name='John', last_name='Doe', age=25, email='john.doe@example.com'),
    Person(first_name='Jane', last_name='Doe', age=22, email='jane.doe@example.com'),
    Person(first_name='Bob', last_name='Smith', age=30, email='bob.smith@example.com'),
]
Person.objects.bulk_create(people)
 

Dit zal drie nieuwe rijen aanmaken in de Person tabel.

Hoe werk je met relaties tussen modellen?

Relaties tussen modellen worden gedefinieerd met behulp van het ForeignKey veld. Dit veld wordt gebruikt om naar een andere tabel te verwijzen.

Hier is een voorbeeld van hoe je een Book model kunt maken met een verwijzing naar een Author model:

from django.db import models

class Author(models.Model):
    name = models.CharField(max_length=200)

    def __str__(self):
        return self.name

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

    def __str__(self):
        return self.title
 

In dit voorbeeld definiëren we een Author model met een name veld en een Book model met een title veld en een author veld dat een verwijzing is naar de Author tabel.

Wanneer je een query doet op de Book tabel, kun je de gerelateerde Author objecten ophalen door het select_related methode te gebruiken. Hier is een voorbeeld:

from myapp.models import Book

books = Book.objects.select_related('author').all()
for book in books:
    print(f'{book.title} by {book.author.name}')
 

Conclusie

Het werken met modellen in Django is een essentieel onderdeel van het ontwikkelen van web applicaties. Door gebruik te maken van Django's ORM kunnen ontwikkelaars zich concentreren op de functionaliteit van de applicatie in plaats van de details van de database. Het definiëren van modellen is eenvoudig en het migratie systeem zorgt voor het aanmaken van de tabellen in de database.

Querysets maken het eenvoudig om data uit de database op te halen en te filteren en het save methode maakt het eenvoudig om data op te slaan in de database. Het definiëren van relaties tussen modellen is eenvoudig met behulp van het ForeignKey veld en het select_related methode maakt het gemakkelijk om gerelateerde objecten op te halen.

Kortom, het werken met model in Django is een krachtige tool die ontwikkelaars in staat stelt om snel en efficiënt web applicaties te bouwen. Met deze kennis in handen kun je aan de slag om zelf modellen te definiëren en data te beheren in je eigen Django projecten.