Django多对多关联查询求助：高效获取指定用户关注者的Uploads

Hey there! I get it—trying to nail that single-db-query solution for fetching uploads from a user's followers can be tricky when you've tried a few approaches that didn't work. Let's break this down clearly, using Django's built-in User model.

First, let's make sure we're on the same page with the model setup. I'll assume two common scenarios for the follow relationship (since you didn't specify, these are the most typical):

Scenario 1: Using a dedicated Follow intermediate model #

If you're using a separate model to track follows (great for adding extra fields like created_at), your models might look like this:

from django.contrib.auth.models import User
from django.db import models

class Upload(models.Model):
    user = models.ForeignKey(User, on_delete=models.CASCADE, related_name='uploads')
    file = models.FileField(upload_to='uploads/')  # Example field
    # Add any other fields you need (timestamp, description, etc.)

class Follow(models.Model):
    follower = models.ForeignKey(User, on_delete=models.CASCADE, related_name='following')
    following = models.ForeignKey(User, on_delete=models.CASCADE, related_name='followers')
    created_at = models.DateTimeField(auto_now_add=True)

    class Meta:
        unique_together = ('follower', 'following')  # Prevent duplicate follows

Scenario 2: Using a direct ManyToMany on User #

If you're using a simpler many-to-many field directly on the User model (no extra follow metadata), you'd have something like this (usually added via a custom User model or a Profile model linked to User):

# If using a custom User model:
class CustomUser(AbstractUser):
    following = models.ManyToManyField('self', symmetrical=False, related_name='followers')

# Or if using a Profile model with the standard User:
class Profile(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE)
    following = models.ManyToManyField(User, symmetrical=False, related_name='followers')

The Single-Query Solution #

No matter which scenario you're using, you can fetch all Uploads from the target user's followers in one database hit using Django ORM's double-underscore (__) relationship traversal.

Let's say target_user is the User instance you're focusing on (e.g., target_user = User.objects.get(username='johndoe')):

For Scenario 1 (Follow model):

uploads_from_followers = Upload.objects.filter(
    user__followers__following=target_user
).distinct()

For Scenario 2 (Direct ManyToMany):

# If using CustomUser:
uploads_from_followers = Upload.objects.filter(
    user__followers=target_user
).distinct()

# If using Profile model:
uploads_from_followers = Upload.objects.filter(
    user__profile__followers=target_user
).distinct()

Why This Works (And It's a Single Query) #

Django's ORM translates this filter into a SQL query that joins the Upload, User, and follow-related tables all in one go. You can verify this by printing the generated SQL:

print(uploads_from_followers.query)

The distinct() call is important to avoid duplicate Upload entries that might come from the JOIN operation (even if your follow relationships are unique, it's a safe guard).

How to Confirm It's Only One Query #

You can check the number of database queries executed using Django's connection.queries tool:

from django.db import connection

# Clear existing query log
connection.queries.clear()

# Execute our query
uploads = list(uploads_from_followers)

# Check query count
print(f"Number of queries executed: {len(connection.queries)}")

This should output 1 if everything is set up correctly.

内容的提问来源于stack exchange，提问作者edu