Backend: Optimize participant serializers and views to reduce N+1 queries (#4956)

Author: RishabhJain2018

apps/participants/serializers.py

@@ -1,4 +1,3 @@
-from accounts.models import Profile
 from accounts.serializers import UserProfileSerializer
 from challenges.models import Challenge
 from challenges.serializers import ChallengeSerializer
@@ -95,7 +94,9 @@ def get_email(self, obj):
         return obj.user.email
 
     def get_profile(self, obj):
-        user_profile = Profile.objects.get(user=obj.user)
+        # Use user.profile directly - with select_related this won't trigger extra queries
+        # Falls back to lazy loading if not prefetched
+        user_profile = obj.user.profile
         serializer = UserProfileSerializer(user_profile)
         return serializer.data
 
@@ -113,7 +114,9 @@ class Meta:
         fields = ("id", "team_name", "created_by", "members", "team_url")
 
     def get_members(self, obj):
-        participants = Participant.objects.filter(team__pk=obj.id)
+        # Use prefetched participants via related manager (works with or
+        # without prefetch)
+        participants = obj.participants.all()
         serializer = ParticipantSerializer(participants, many=True)
         return serializer.data
 

apps/participants/views.py

@@ -9,6 +9,7 @@
     is_user_in_blocked_email_domains,
 )
 from django.contrib.auth.models import User
+from django.db.models import Prefetch
 from drf_spectacular.utils import (
     OpenApiParameter,
     OpenApiResponse,
@@ -65,9 +66,18 @@ def participant_team_list(request):
         participant_teams_id = Participant.objects.filter(
             user_id=request.user
         ).values_list("team_id", flat=True)
-        participant_teams = ParticipantTeam.objects.filter(
-            id__in=participant_teams_id
-        ).order_by("-id")
+        participant_teams = (
+            ParticipantTeam.objects.filter(id__in=participant_teams_id)
+            .prefetch_related(
+                Prefetch(
+                    "participants",
+                    queryset=Participant.objects.select_related(
+                        "user", "user__profile"
+                    ),
+                )
+            )
+            .order_by("-id")
+        )
         filtered_teams = ParticipantTeamsFilter(
             request.GET, queryset=participant_teams
         )

tests/unit/participants/test_serializers.py

@@ -1,8 +1,12 @@
 from django.contrib.auth.models import User
+from django.db.models import Prefetch
 from django.test import RequestFactory, TestCase
+from participants.models import Participant, ParticipantTeam
 from participants.serializers import (
     ChallengeParticipantSerializer,
     InviteParticipantToTeamSerializer,
+    ParticipantSerializer,
+    ParticipantTeamDetailSerializer,
 )
 from rest_framework import serializers
 
@@ -52,3 +56,154 @@ def test_validate_email_self_invite(self):
             serializers.ValidationError, "A participant cannot invite himself"
         ):
             serializer.validate_email("test@example.com")
+
+
+class TestParticipantTeamDetailSerializer(TestCase):
+    def setUp(self):
+        self.user1 = User.objects.create(
+            username="user1",
+            email="user1@test.com",
+            first_name="First1",
+            last_name="Last1",
+        )
+        self.user2 = User.objects.create(
+            username="user2",
+            email="user2@test.com",
+            first_name="First2",
+            last_name="Last2",
+        )
+
+        self.team = ParticipantTeam.objects.create(
+            team_name="Test Team",
+            created_by=self.user1,
+        )
+
+        self.participant1 = Participant.objects.create(
+            user=self.user1,
+            status=Participant.SELF,
+            team=self.team,
+        )
+        self.participant2 = Participant.objects.create(
+            user=self.user2,
+            status=Participant.ACCEPTED,
+            team=self.team,
+        )
+
+    def test_get_members_returns_all_team_members(self):
+        """Test that get_members returns all participants of a team."""
+        serializer = ParticipantTeamDetailSerializer(self.team)
+        data = serializer.data
+
+        self.assertEqual(len(data["members"]), 2)
+        member_names = [m["member_name"] for m in data["members"]]
+        self.assertIn("user1", member_names)
+        self.assertIn("user2", member_names)
+
+    def test_get_members_with_prefetched_data(self):
+        """
+        Test that get_members works correctly with prefetched participants.
+        This verifies the N+1 query fix works when data is prefetched.
+        """
+        # Query with prefetch_related (as done in the fixed view)
+        team_with_prefetch = (
+            ParticipantTeam.objects.filter(pk=self.team.pk)
+            .prefetch_related(
+                Prefetch(
+                    "participants",
+                    queryset=Participant.objects.select_related(
+                        "user", "user__profile"
+                    ),
+                )
+            )
+            .first()
+        )
+
+        serializer = ParticipantTeamDetailSerializer(team_with_prefetch)
+        data = serializer.data
+
+        self.assertEqual(len(data["members"]), 2)
+        member_names = [m["member_name"] for m in data["members"]]
+        self.assertIn("user1", member_names)
+        self.assertIn("user2", member_names)
+
+    def test_serializer_includes_all_expected_fields(self):
+        """Test that the serializer includes all expected fields."""
+        serializer = ParticipantTeamDetailSerializer(self.team)
+        data = serializer.data
+
+        self.assertIn("id", data)
+        self.assertIn("team_name", data)
+        self.assertIn("created_by", data)
+        self.assertIn("members", data)
+        self.assertIn("team_url", data)
+
+        # Check member fields
+        member = data["members"][0]
+        self.assertIn("member_name", member)
+        self.assertIn("first_name", member)
+        self.assertIn("last_name", member)
+        self.assertIn("email", member)
+        self.assertIn("status", member)
+        self.assertIn("profile", member)
+
+
+class TestParticipantSerializer(TestCase):
+    def setUp(self):
+        self.user = User.objects.create(
+            username="testuser",
+            email="testuser@test.com",
+            first_name="Test",
+            last_name="User",
+        )
+        self.team = ParticipantTeam.objects.create(
+            team_name="Test Team",
+            created_by=self.user,
+        )
+        self.participant = Participant.objects.create(
+            user=self.user,
+            status=Participant.SELF,
+            team=self.team,
+        )
+
+    def test_get_profile_returns_user_profile(self):
+        """
+        Test that get_profile correctly returns the user's profile.
+        Profile is auto-created by a signal when User is created.
+        """
+        serializer = ParticipantSerializer(self.participant)
+        data = serializer.data
+
+        self.assertIn("profile", data)
+        self.assertIsInstance(data["profile"], dict)
+        # Profile should have these fields from UserProfileSerializer
+        self.assertIn("affiliation", data["profile"])
+        self.assertIn("github_url", data["profile"])
+        self.assertIn("google_scholar_url", data["profile"])
+        self.assertIn("linkedin_url", data["profile"])
+
+    def test_get_profile_with_prefetched_profile(self):
+        """
+        Test that get_profile works correctly when profile is prefetched
+        via select_related on user__profile.
+        """
+        # Query participant with select_related (as done in the fixed view)
+        participant_with_prefetch = Participant.objects.select_related(
+            "user", "user__profile"
+        ).get(pk=self.participant.pk)
+
+        serializer = ParticipantSerializer(participant_with_prefetch)
+        data = serializer.data
+
+        self.assertIn("profile", data)
+        self.assertIsInstance(data["profile"], dict)
+
+    def test_member_fields_are_correct(self):
+        """Test that member fields return correct values."""
+        serializer = ParticipantSerializer(self.participant)
+        data = serializer.data
+
+        self.assertEqual(data["member_name"], "testuser")
+        self.assertEqual(data["first_name"], "Test")
+        self.assertEqual(data["last_name"], "User")
+        self.assertEqual(data["email"], "testuser@test.com")
+        self.assertEqual(data["status"], Participant.SELF)

tests/unit/participants/test_views.py

@@ -119,6 +119,112 @@ def test_get_challenge(self):
         self.assertEqual(response.data["results"], expected)
         self.assertEqual(response.status_code, status.HTTP_200_OK)
 
+    def test_no_n_plus_one_queries_for_participant_teams(self):
+        """
+        Test that the participant_team_list endpoint doesn't have N+1 query issues.
+        The number of queries should remain bounded regardless of:
+        - Number of participant teams
+        - Number of participants per team
+        - Number of user profiles
+
+        Before the fix, queries grew as:
+        - 1 query per team for participants
+        - 1 query per participant for user
+        - 1 query per participant for profile
+
+        After the fix using prefetch_related with select_related:
+        - 1 query for teams
+        - 1 query for participants with users and profiles (prefetched)
+        """
+        # Create additional teams with multiple participants
+        additional_teams = []
+        for i in range(3):
+            # Create a new user for each team
+            team_creator = User.objects.create(
+                username=f"team_creator_{i}",
+                email=f"team_creator_{i}@platform.com",
+                password="password",
+            )
+            EmailAddress.objects.create(
+                user=team_creator,
+                email=f"team_creator_{i}@platform.com",
+                primary=True,
+                verified=True,
+            )
+
+            # Create the team
+            team = ParticipantTeam.objects.create(
+                team_name=f"Test Team {i}",
+                created_by=team_creator,
+            )
+            additional_teams.append(team)
+
+            # Add the creator as a participant
+            Participant.objects.create(
+                user=team_creator,
+                status=Participant.SELF,
+                team=team,
+            )
+
+            # Add the main user to each team (so they show up in the response)
+            Participant.objects.create(
+                user=self.user,
+                status=Participant.ACCEPTED,
+                team=team,
+            )
+
+            # Add additional participants to each team
+            for j in range(2):
+                member = User.objects.create(
+                    username=f"team_{i}_member_{j}",
+                    email=f"team_{i}_member_{j}@platform.com",
+                    password="password",
+                )
+                EmailAddress.objects.create(
+                    user=member,
+                    email=f"team_{i}_member_{j}@platform.com",
+                    primary=True,
+                    verified=True,
+                )
+                Participant.objects.create(
+                    user=member,
+                    status=Participant.ACCEPTED,
+                    team=team,
+                )
+
+        # Now we have:
+        # - 1 original team with 2 participants
+        # - 3 additional teams with 4 participants each (creator + main user + 2 members)
+        # Total: 4 teams, 14 participants
+
+        # Capture queries during the request
+        with CaptureQueriesContext(connection) as context:
+            response = self.client.get(self.url, {})
+
+        query_count = len(context)
+
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+
+        # Should return 4 teams (original + 3 new ones where user is a
+        # participant)
+        self.assertEqual(len(response.data["results"]), 4)
+
+        # With the N+1 fix using prefetch_related and select_related:
+        # - Queries should be bounded regardless of team/participant count
+        # - Without the fix, we'd have: 4 (teams) + 14 (users) + 14 (profiles) = 32+ queries
+        # - With the fix, we expect roughly:
+        #   - 1 for participant IDs
+        #   - 1 for teams
+        #   - 1 for participants with users and profiles (prefetched)
+        #   - Plus auth/session overhead (~5-10 queries)
+        # Total should be under 20 queries
+        self.assertLessEqual(
+            query_count,
+            20,
+            f"Too many queries ({query_count}) - possible N+1 issue. "
+            f"Queries: {[q['sql'][:100] for q in context.captured_queries]}",
+        )
+
 
 class CreateParticipantTeamTest(BaseAPITestClass):