Django ORM-forespørgselsoptimering: select_related vs. prefetch_related

Efterhånden som din Django-applikation vokser, bliver effektive databaseforespørgsler afgørende for at opretholde optimal ydeevne. Django ORM'en tilbyder kraftfulde værktøjer til at minimere databasekald og forbedre forespørgselshastigheden. To centrale teknikker til at opnå dette er select_related og prefetch_related. Denne omfattende guide vil forklare disse koncepter, demonstrere deres brug med praktiske eksempler og hjælpe dig med at vælge det rigtige værktøj til dine specifikke behov.

Forståelse af N+1-problemet

Før vi dykker ned i select_related og prefetch_related, er det vigtigt at forstå det problem, de løser: N+1-forespørgselsproblemet. Dette opstår, når din applikation udfører én indledende forespørgsel for at hente et sæt objekter, og derefter laver yderligere forespørgsler (N forespørgsler, hvor N er antallet af objekter) for at hente relaterede data for hvert objekt.

Overvej et simpelt eksempel med modeller, der repræsenterer forfattere og bøger:

            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
              
            
          

Forestil dig nu, at du vil vise en liste over bøger med deres tilsvarende forfattere. En naiv tilgang kunne se sådan ud:

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

            

              
                Copy
              
            
          

Denne kode vil generere én forespørgsel for at hente alle bøger og derefter én forespørgsel for hver bog for at hente dens forfatter. Hvis du har 100 bøger, vil du udføre 101 forespørgsler, hvilket fører til en betydelig belastning af ydeevnen. Dette er N+1-problemet.

Introduktion til select_related

select_related bruges til at optimere forespørgsler, der involverer en-til-en- og foreign key-relationer. Det virker ved at joine den/de relaterede tabel(ler) i den indledende forespørgsel, hvilket effektivt henter de relaterede data i et enkelt databasekald.

Lad os vende tilbage til vores forfatter- og bogeksempel. For at eliminere N+1-problemet kan vi bruge select_related sådan her:

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

            

              
                Copy
              
            
          

Nu vil Django udføre en enkelt, mere kompleks forespørgsel, der joiner Book- og Author-tabellerne. Når du tilgår book.author.name i løkken, er dataene allerede tilgængelige, og der udføres ingen yderligere databaseforespørgsler.

Brug af select_related med flere relationer

select_related kan traversere flere relationer. For eksempel, hvis du har en model med en foreign key til en anden model, som igen har en foreign key til endnu en model, kan du bruge select_related til at hente alle relaterede data på én gang.

            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)

# Add country to Author
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
              
            
          

I dette tilfælde henter select_related('profile__country') AuthorProfile og den relaterede Country i en enkelt forespørgsel. Bemærk notationen med dobbelt understregning (__), som giver dig mulighed for at traversere relationstræet.

Begrænsninger ved select_related

select_related er mest effektiv med en-til-en- og foreign key-relationer. Det er ikke egnet til mange-til-mange-relationer eller omvendte foreign key-relationer, da det kan føre til store og ineffektive forespørgsler, når man arbejder med store relaterede datasæt. Til disse scenarier er prefetch_related et bedre valg.

Introduktion til prefetch_related

prefetch_related er designet til at optimere forespørgsler, der involverer mange-til-mange- og omvendte foreign key-relationer. I stedet for at bruge joins, udfører prefetch_related separate forespørgsler for hver relation og bruger derefter Python til at "joine" resultaterne. Selvom dette involverer flere forespørgsler, kan det være mere effektivt end at bruge joins, når man arbejder med store relaterede datasæt.

Overvej et scenarie, hvor hver bog kan have flere genrer:

            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
              
            
          

For at hente en liste over bøger med deres genrer ville det ikke være passende at bruge select_related. I stedet bruger vi 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
              
            
          

I dette tilfælde vil Django udføre to forespørgsler: en for at hente alle bøger og en anden for at hente alle genrer relateret til disse bøger. Derefter bruger den Python til effektivt at associere genrerne med deres respektive bøger.

prefetch_related med omvendte Foreign Keys

prefetch_related er også nyttig til at optimere omvendte foreign key-relationer. Overvej følgende eksempel:

            class Author(models.Model):
    name = models.CharField(max_length=255)
    country = models.CharField(max_length=255, blank=True, null=True) # Added for clarity

    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
              
            
          

For at hente en liste over forfattere og deres bøger:

            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
              
            
          

Her henter prefetch_related('books') alle bøger relateret til hver forfatter i en separat forespørgsel, hvilket undgår N+1-problemet, når man tilgår author.books.all().

Brug af prefetch_related med et queryset

Du kan yderligere tilpasse adfærden af prefetch_related ved at angive et brugerdefineret queryset til at hente relaterede objekter. Dette er især nyttigt, når du skal filtrere eller sortere de relaterede data.

            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
              
            
          

I dette eksempel giver Prefetch-objektet os mulighed for at specificere et brugerdefineret queryset, der kun henter bøger, hvis titler indeholder "django".

Kædning af prefetch_related

Ligesom med select_related kan du kæde prefetch_related-kald for at optimere flere relationer:

            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
              
            
          

Dette eksempel forudhenter de bøger, der er relateret til forfatteren, og derefter de genrer, der er relateret til disse bøger. Ved at bruge kædede prefetch_related-kald kan du optimere dybt indlejrede relationer.

select_related vs. prefetch_related: Vælg det rigtige værktøj

Så hvornår skal du bruge select_related, og hvornår skal du bruge prefetch_related? Her er en simpel retningslinje:

• select_related: Brug til en-til-en- og foreign key-relationer, hvor du ofte har brug for at tilgå de relaterede data. Det udfører et join i databasen, så det er generelt hurtigere til at hente små mængder relaterede data.
• prefetch_related: Brug til mange-til-mange- og omvendte foreign key-relationer, eller når du arbejder med store relaterede datasæt. Det udfører separate forespørgsler og bruger Python til at samle resultaterne, hvilket kan være mere effektivt end store joins. Brug det også, når du har brug for at anvende brugerdefineret queryset-filtrering på de relaterede objekter.

Sammenfattende:

• Relationstype: select_related (ForeignKey, OneToOne), prefetch_related (ManyToManyField, omvendt ForeignKey)
• Forespørgselstype: select_related (JOIN), prefetch_related (Separate forespørgsler + Python Join)
• Datastørrelse: select_related (Små relaterede data), prefetch_related (Store relaterede data)

Praktiske eksempler og bedste praksis

Her er nogle praktiske eksempler og bedste praksis for brug af select_related og prefetch_related i virkelige scenarier:

• E-handel: Når du viser produktdetaljer, brug select_related til at hente produktets kategori og producent. Brug prefetch_related til at hente produktbilleder eller relaterede produkter.
• Sociale medier: Når du viser en brugers profil, brug prefetch_related til at hente brugerens opslag og følgere. Brug select_related til at hente brugerens profiloplysninger.
• Content Management System (CMS): Når du viser en artikel, brug select_related til at hente forfatteren og kategorien. Brug prefetch_related til at hente artiklens tags og kommentarer.

Generel bedste praksis:

• Profilér dine forespørgsler: Brug Djangos debug toolbar eller andre profileringsværktøjer til at identificere langsomme forespørgsler og potentielle N+1-problemer.
• Start simpelt: Begynd med en naiv implementering og optimer derefter baseret på profileringsresultater.
• Test grundigt: Sørg for, at dine optimeringer ikke introducerer nye fejl eller forringelser af ydeevnen.
• Overvej caching: For data, der tilgås ofte, bør du overveje at bruge cache-mekanismer (f.eks. Djangos cache framework eller Redis) for yderligere at forbedre ydeevnen.
• Brug indekser i databasen: Dette er et must for optimal forespørgselsydeevne, især i produktion.

Avancerede optimeringsteknikker

Ud over select_related og prefetch_related findes der andre avancerede teknikker, du kan bruge til at optimere dine Django ORM-forespørgsler:

• only() og defer(): Disse metoder giver dig mulighed for at specificere, hvilke felter der skal hentes fra databasen. Brug only() til kun at hente de nødvendige felter, og defer() til at udelukke felter, der ikke er nødvendige med det samme.
• values() og values_list(): Disse metoder giver dig mulighed for at hente data som dictionaries eller tupler i stedet for Django-modelinstanser. Dette kan være mere effektivt, når du kun har brug for et undersæt af modellens felter.
• Rå SQL-forespørgsler: I nogle tilfælde er Django ORM'en måske ikke den mest effektive måde at hente data på. Du kan bruge rå SQL-forespørgsler til komplekse eller højt optimerede forespørgsler.
• Databasespecifikke optimeringer: Forskellige databaser (f.eks. PostgreSQL, MySQL) har forskellige optimeringsteknikker. Undersøg og udnyt databasespecifikke funktioner for yderligere at forbedre ydeevnen.

Overvejelser om internationalisering

Når man udvikler Django-applikationer til et globalt publikum, er det vigtigt at overveje internationalisering (i18n) og lokalisering (l10n). Dette kan påvirke dine databaseforespørgsler på flere måder:

• Sprogspecifikke data: Du kan have brug for at gemme oversættelser af indhold i din database. Brug Djangos i18n-framework til at administrere oversættelser og sikre, at dine forespørgsler henter den korrekte sprogversion af dataene.
• Tegnsæt og sorteringsrækkefølger (collations): Vælg passende tegnsæt og sorteringsrækkefølger til din database for at understøtte en bred vifte af sprog og tegn.
• Tidszoner: Vær opmærksom på tidszoner, når du arbejder med datoer og tidspunkter. Gem datoer og tidspunkter i UTC og konverter dem til brugerens lokale tidszone, når de vises.
• Valutaformatering: Når du viser priser, skal du bruge passende valutasymboler og formatering baseret på brugerens locale.

Konklusion

Optimering af Django ORM-forespørgsler er afgørende for at bygge skalerbare og højtydende webapplikationer. Ved at forstå og effektivt bruge select_related og prefetch_related kan du markant reducere antallet af databaseforespørgsler og forbedre din applikations overordnede reaktionsevne. Husk at profilere dine forespørgsler, teste dine optimeringer grundigt og overveje andre avancerede teknikker for yderligere at forbedre ydeevnen. Ved at følge disse bedste praksisser kan du sikre, at din Django-applikation leverer en gnidningsfri og effektiv brugeroplevelse, uanset dens størrelse eller kompleksitet. Overvej også, at et godt databasedesign og korrekt konfigurerede indekser er et must for optimal ydeevne.