Django QuerySet Caching implementing Prefetch Related and Async Views
I'm updating my dependencies and Hey everyone, I'm running into an issue that's driving me crazy. I'm relatively new to this, so bear with me. I'm working with a question with Django when using `prefetch_related` in an async view with Django 3.2. I have a model structure where `Author` has many `Book` instances, and I need to fetch the authors and their books efficiently. However, I noticed that my queries seem slow, and I suspect that the results are being cached incorrectly when using `prefetch_related` in an `async` view. Here’s a simplified version of my models: ```python class Author(models.Model): name = models.CharField(max_length=100) class Book(models.Model): title = models.CharField(max_length=200) author = models.ForeignKey(Author, related_name='books', on_delete=models.CASCADE) ``` In my async view, I’m trying to fetch the authors with their respective books like this: ```python from django.shortcuts import render from django.http import JsonResponse from .models import Author async def authors_with_books(request): authors = await Author.objects.prefetch_related('books').all() response = [ {'name': author.name, 'books': [book.title for book in author.books.all()]} for author in authors ] return JsonResponse(response, safe=False) ``` When I run this, I'm working with a performance scenario. The database queries seem to be firing multiple times for each author rather than just once as I expected. The debug SQL output shows multiple SELECT statements, which leads me to believe that prefetching isn’t working as intended in the async context. Additionally, I get an behavior message related to caching when loading the page: ``` RuntimeError: You want to call this from an async context - use a thread or sync to call this function. ``` I've tried several combinations of using `sync_to_async` but still get unexpected behaviors where the data doesn't seem to be cached properly. How can I efficiently fetch the authors and their books using async views without running into query duplication? Are there best practices or patterns for using `prefetch_related` with async views in Django? Any insights would be helpful! This is part of a larger service I'm building. Has anyone else encountered this? Has anyone else encountered this? For reference, this is a production microservice. I'm open to any suggestions. My development environment is Ubuntu 22.04. What's the correct way to implement this?