Django ORM Query Optimalisatie: select_related vs. prefetch_related

Naarmate uw Django-applicatie groeit, worden efficiënte databasequeries cruciaal voor het behouden van optimale prestaties. Het Django ORM biedt krachtige tools om het aantal database-aanroepen te minimaliseren en de snelheid van queries te verbeteren. Twee belangrijke technieken om dit te bereiken zijn select_related en prefetch_related. Deze uitgebreide gids legt deze concepten uit, demonstreert het gebruik ervan met praktische voorbeelden en helpt u het juiste hulpmiddel voor uw specifieke behoeften te kiezen.

Het N+1 Probleem Begrijpen

Voordat we dieper ingaan op select_related en prefetch_related, is het essentieel om het probleem dat ze oplossen te begrijpen: het N+1 query-probleem. Dit treedt op wanneer uw applicatie één initiële query uitvoert om een set objecten op te halen, en vervolgens extra queries (N queries, waarbij N het aantal objecten is) uitvoert om gerelateerde gegevens voor elk object op te halen.

Beschouw een eenvoudig voorbeeld met modellen die auteurs en boeken vertegenwoordigen:

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

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

            

              
                Copy
              
            
          

Stel u nu voor dat u een lijst met boeken en hun bijbehorende auteurs wilt weergeven. Een naïeve aanpak zou er zo uit kunnen zien:

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

            

              
                Copy
              
            
          

Deze code genereert één query om alle boeken op te halen en vervolgens één query voor elk boek om de auteur ervan op te halen. Als u 100 boeken heeft, voert u 101 queries uit, wat leidt tot aanzienlijke prestatie-overhead. Dit is het N+1 probleem.

Introductie van select_related

select_related wordt gebruikt voor het optimaliseren van queries met one-to-one en foreign key relaties. Het werkt door de gerelateerde tabel(len) te joinen in de initiële query, waardoor de gerelateerde gegevens effectief in een enkele database-aanroep worden opgehaald.

Laten we terugkeren naar ons voorbeeld met auteurs en boeken. Om het N+1 probleem te elimineren, kunnen we select_related als volgt gebruiken:

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

            

              
                Copy
              
            
          

Nu zal Django een enkele, complexere query uitvoeren die de Book en Author tabellen joint. Wanneer u book.author.name in de lus benadert, zijn de gegevens al beschikbaar en worden er geen extra databasequeries uitgevoerd.

select_related gebruiken met meerdere relaties

select_related kan meerdere relaties doorkruisen. Als u bijvoorbeeld een model heeft met een foreign key naar een ander model, dat op zijn beurt een foreign key heeft naar nog een ander model, kunt u select_related gebruiken om alle gerelateerde gegevens in één keer op te halen.

            class Country(models.Model):
    name = models.CharField(max_length=255)

class AuthorProfile(models.Model):
    author = models.OneToOneField(Author, on_delete=models.CASCADE)
    country = models.ForeignKey(Country, on_delete=models.CASCADE)

# Voeg land toe aan Auteur
Author.profile = models.OneToOneField(AuthorProfile, on_delete=models.CASCADE, null=True, blank=True)

authors = Author.objects.all().select_related('profile__country')
for author in authors:
    print(f"{author.name} is from {author.profile.country.name if author.profile else 'Unknown'}")

            

              
                Copy
              
            
          

In dit geval haalt select_related('profile__country') het AuthorProfile en het gerelateerde Country op in een enkele query. Let op de dubbele underscore (__) notatie, waarmee u door de relatieboom kunt navigeren.

Beperkingen van select_related

select_related is het meest effectief bij one-to-one en foreign key relaties. Het is niet geschikt voor many-to-many relaties of omgekeerde foreign key relaties, omdat dit kan leiden tot grote en inefficiënte queries bij het omgaan met grote gerelateerde datasets. Voor deze scenario's is prefetch_related een betere keuze.

Introductie van prefetch_related

prefetch_related is ontworpen om queries met many-to-many en omgekeerde foreign key relaties te optimaliseren. In plaats van joins te gebruiken, voert prefetch_related aparte queries uit voor elke relatie en gebruikt vervolgens Python om de resultaten te "joinen". Hoewel dit meerdere queries met zich meebrengt, kan het efficiënter zijn dan het gebruik van joins bij het omgaan met grote gerelateerde datasets.

Beschouw een scenario waarin elk boek meerdere genres kan hebben:

            class Genre(models.Model):
    name = models.CharField(max_length=255)

class Book(models.Model):
    title = models.CharField(max_length=255)
    author = models.ForeignKey(Author, on_delete=models.CASCADE)
    genres = models.ManyToManyField(Genre)

            

              
                Copy
              
            
          

Om een lijst met boeken en hun genres op te halen, zou het gebruik van select_related niet geschikt zijn. In plaats daarvan gebruiken we prefetch_related:

            books = Book.objects.all().prefetch_related('genres')
for book in books:
    genre_names = [genre.name for genre in book.genres.all()]
    print(f"{book.title} ({', '.join(genre_names)}) by {book.author.name}")

            

              
                Copy
              
            
          

In dit geval zal Django twee queries uitvoeren: één om alle boeken op te halen en een andere om alle genres gerelateerd aan die boeken op te halen. Vervolgens gebruikt het Python om de genres efficiënt te koppelen aan hun respectievelijke boeken.

prefetch_related met Omgekeerde Foreign Keys

prefetch_related is ook nuttig voor het optimaliseren van omgekeerde foreign key relaties. Beschouw het volgende voorbeeld:

            class Author(models.Model):
    name = models.CharField(max_length=255)
    country = models.CharField(max_length=255, blank=True, null=True) # Toegevoegd voor de duidelijkheid

    def __str__(self):
        return self.name

class Book(models.Model):
    title = models.CharField(max_length=255)
    author = models.ForeignKey(Author, related_name='books', on_delete=models.CASCADE)

            

              
                Copy
              
            
          

Om een lijst van auteurs en hun boeken op te halen:

            authors = Author.objects.all().prefetch_related('books')
for author in authors:
    book_titles = [book.title for book in author.books.all()]
    print(f"{author.name} has written: {', '.join(book_titles)}")

            

              
                Copy
              
            
          

Hier haalt prefetch_related('books') alle boeken op die gerelateerd zijn aan elke auteur in een aparte query, waardoor het N+1 probleem wordt vermeden bij het benaderen van author.books.all().

prefetch_related gebruiken met een queryset

U kunt het gedrag van prefetch_related verder aanpassen door een aangepaste queryset te leveren om gerelateerde objecten op te halen. Dit is met name handig wanneer u de gerelateerde gegevens moet filteren of sorteren.

            from django.db.models import Prefetch

authors = Author.objects.prefetch_related(Prefetch('books', queryset=Book.objects.filter(title__icontains='django')))

for author in authors:
    django_books = author.books.all()
    print(f"{author.name} has written {len(django_books)} books about Django.")

            

              
                Copy
              
            
          

In dit voorbeeld stelt het Prefetch-object ons in staat een aangepaste queryset op te geven die alleen boeken ophaalt waarvan de titels "django" bevatten.

prefetch_related koppelen

Net als bij select_related kunt u prefetch_related-aanroepen koppelen om meerdere relaties te optimaliseren:

            authors = Author.objects.all().prefetch_related('books__genres')

for author in authors:
  for book in author.books.all():
    genres = book.genres.all()
    print(f"{author.name} wrote {book.title} which is of genre(s) {[genre.name for genre in genres]}")

            

              
                Copy
              
            
          

Dit voorbeeld prefetcht de boeken die gerelateerd zijn aan de auteur, en vervolgens de genres die gerelateerd zijn aan die boeken. Het gebruik van gekoppelde prefetch_related stelt u in staat om diep geneste relaties te optimaliseren.

select_related vs. prefetch_related: Het Juiste Gereedschap Kiezen

Dus, wanneer moet u select_related gebruiken en wanneer prefetch_related? Hier is een eenvoudige richtlijn:

• select_related: Gebruik voor one-to-one en foreign key relaties waar u de gerelateerde gegevens vaak nodig heeft. Het voert een join uit in de database, dus het is over het algemeen sneller voor het ophalen van kleine hoeveelheden gerelateerde gegevens.
• prefetch_related: Gebruik voor many-to-many en omgekeerde foreign key relaties, of bij het omgaan met grote gerelateerde datasets. Het voert aparte queries uit en gebruikt Python om de resultaten te joinen, wat efficiënter kan zijn dan grote joins. Gebruik het ook wanneer u aangepaste queryset-filtering op de gerelateerde objecten moet toepassen.

Samenvattend:

• Relatietype: select_related (ForeignKey, OneToOne), prefetch_related (ManyToManyField, omgekeerde ForeignKey)
• Querytype: select_related (JOIN), prefetch_related (Aparte Queries + Python Join)
• Datagrootte: select_related (Kleine gerelateerde data), prefetch_related (Grote gerelateerde data)

Praktische Voorbeelden en Best Practices

Hier zijn enkele praktische voorbeelden en best practices voor het gebruik van select_related en prefetch_related in real-world scenario's:

• E-commerce: Gebruik bij het weergeven van productdetails select_related om de productcategorie en fabrikant op te halen. Gebruik prefetch_related om productafbeeldingen of gerelateerde producten op te halen.
• Sociale Media: Gebruik bij het weergeven van het profiel van een gebruiker prefetch_related om de berichten en volgers van de gebruiker op te halen. Gebruik select_related om de profielinformatie van de gebruiker op te halen.
• Content Management Systeem (CMS): Gebruik bij het weergeven van een artikel select_related om de auteur en categorie op te halen. Gebruik prefetch_related om de tags en opmerkingen van het artikel op te halen.

Algemene Best Practices:

• Profileer uw queries: Gebruik de debug-toolbar van Django of andere profileringstools om trage queries en potentiële N+1-problemen te identificeren.
• Begin eenvoudig: Begin met een naïeve implementatie en optimaliseer vervolgens op basis van profileringsresultaten.
• Test grondig: Zorg ervoor dat uw optimalisaties geen nieuwe bugs of prestatieverminderingen introduceren.
• Overweeg caching: Voor vaak opgevraagde gegevens kunt u overwegen om cachingmechanismen te gebruiken (bijv. Django's cache-framework of Redis) om de prestaties verder te verbeteren.
• Gebruik indexen in de database: Dit is een must voor optimale queryprestaties, vooral in productie.

Geavanceerde Optimalisatietechnieken

Naast select_related en prefetch_related zijn er andere geavanceerde technieken die u kunt gebruiken om uw Django ORM-queries te optimaliseren:

• only() en defer(): Met deze methoden kunt u specificeren welke velden uit de database moeten worden opgehaald. Gebruik only() om alleen de benodigde velden op te halen, en defer() om velden uit te sluiten die niet onmiddellijk nodig zijn.
• values() en values_list(): Met deze methoden kunt u gegevens ophalen als dictionaries of tuples, in plaats van Django-modelinstanties. Dit kan efficiënter zijn wanneer u slechts een subset van de velden van het model nodig heeft.
• Ruwe SQL Queries: In sommige gevallen is het Django ORM misschien niet de meest efficiënte manier om gegevens op te halen. U kunt ruwe SQL-queries gebruiken voor complexe of sterk geoptimaliseerde queries.
• Database-specifieke Optimalisaties: Verschillende databases (bijv. PostgreSQL, MySQL) hebben verschillende optimalisatietechnieken. Onderzoek en maak gebruik van database-specifieke functies om de prestaties verder te verbeteren.

Overwegingen bij Internationalisatie

Bij het ontwikkelen van Django-applicaties voor een wereldwijd publiek is het belangrijk om rekening te houden met internationalisatie (i18n) en lokalisatie (l10n). Dit kan uw databasequeries op verschillende manieren beïnvloeden:

• Taalspecifieke gegevens: Mogelijk moet u vertalingen van content in uw database opslaan. Gebruik het i18n-framework van Django om vertalingen te beheren en ervoor te zorgen dat uw queries de juiste taalversie van de gegevens ophalen.
• Tekensets en collaties: Kies de juiste tekensets en collaties voor uw database om een breed scala aan talen en tekens te ondersteunen.
• Tijdzones: Wees u bewust van tijdzones bij het omgaan met datums en tijden. Sla datums en tijden op in UTC en converteer ze naar de lokale tijdzone van de gebruiker bij het weergeven.
• Valutaopmaak: Gebruik bij het weergeven van prijzen de juiste valutasymbolen en opmaak op basis van de landinstelling van de gebruiker.

Conclusie

Het optimaliseren van Django ORM-queries is essentieel voor het bouwen van schaalbare en performante webapplicaties. Door select_related en prefetch_related te begrijpen en effectief te gebruiken, kunt u het aantal databasequeries aanzienlijk verminderen en de algehele responsiviteit van uw applicatie verbeteren. Vergeet niet uw queries te profileren, uw optimalisaties grondig te testen en andere geavanceerde technieken te overwegen om de prestaties verder te verbeteren. Door deze best practices te volgen, kunt u ervoor zorgen dat uw Django-applicatie een soepele en efficiënte gebruikerservaring biedt, ongeacht de omvang of complexiteit. Bedenk ook dat een goed databaseontwerp en correct geconfigureerde indexen een must zijn voor optimale prestaties.