Backend: Optimize participant team detail view to avoid N+1 queries using select_related and prefetch_related (#4990)

Author: RishabhJain2018

apps/challenges/views.py

@@ -56,6 +56,7 @@
 from django.core.files.base import ContentFile
 from django.core.files.uploadedfile import SimpleUploadedFile
 from django.db import transaction
+from django.db.models import Prefetch
 from django.http import HttpResponse
 from django.utils import timezone
 from drf_spectacular.utils import (
@@ -415,7 +416,18 @@ def participant_team_detail_for_challenge(request, challenge_pk):
         participant_team_pk = get_participant_team_id_of_user_for_a_challenge(
             request.user, challenge_pk
         )
-        participant_team = get_participant_model(participant_team_pk)
+        participant_team = (
+            ParticipantTeam.objects.select_related("created_by")
+            .prefetch_related(
+                Prefetch(
+                    "participants",
+                    queryset=Participant.objects.select_related(
+                        "user", "user__profile"
+                    ),
+                )
+            )
+            .get(pk=participant_team_pk)
+        )
         serializer = ParticipantTeamDetailSerializer(participant_team)
         if challenge.approved_participant_teams.filter(
             pk=participant_team_pk

tests/unit/challenges/test_views.py

@@ -28,7 +28,9 @@
 from django.conf import settings
 from django.contrib.auth.models import User
 from django.core.files.uploadedfile import SimpleUploadedFile
+from django.db import connection
 from django.test import override_settings
+from django.test.utils import CaptureQueriesContext
 from django.urls import reverse_lazy
 from django.utils import timezone
 from hosts.models import ChallengeHost, ChallengeHostTeam
@@ -269,6 +271,42 @@ def test_team_name_for_challenge_with_participant_team_does_not_exist(
         self.assertEqual(response.data, expected)
         self.assertEqual(response.status_code, status.HTTP_406_NOT_ACCEPTABLE)
 
+    def test_participant_team_detail_avoids_n_plus_one_queries(self):
+        """
+        Verify participant_team_detail_for_challenge uses prefetch to avoid N+1
+        queries when serializing team members (user + profile per participant).
+        """
+        # Add 4 more participants (5 total) to stress-test the N+1 fix
+        for i in range(4):
+            extra_user = User.objects.create(
+                username=f"member{i}",
+                email=f"member{i}@test.com",
+            )
+            Participant.objects.create(
+                user=extra_user,
+                status=Participant.ACCEPTED,
+                team=self.participant_team,
+            )
+
+        url = reverse_lazy(
+            "challenges:participant_team_detail_for_challenge",
+            kwargs={"challenge_pk": self.challenge.pk},
+        )
+
+        # With prefetch (select_related/prefetch_related), query count should be
+        # bounded. Without fix, we'd have 2*N extra queries (auth_user +
+        # user_profile per participant) = 10+ for 5 participants.
+        with CaptureQueriesContext(connection) as context:
+            response = self.client.get(url, {})
+
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertEqual(len(response.data["participant_team"]["members"]), 5)
+        self.assertLessEqual(
+            len(context.captured_queries),
+            12,
+            "Query count too high - possible N+1 when loading participants",
+        )
+
 
 class GetApprovedParticipantTeamNameTest(BaseAPITestClass):
     def setUp(self):

tests/unit/participants/test_serializers.py

@@ -1,6 +1,8 @@
 from django.contrib.auth.models import User
+from django.db import connection
 from django.db.models import Prefetch
 from django.test import RequestFactory, TestCase
+from django.test.utils import CaptureQueriesContext
 from participants.models import Participant, ParticipantTeam
 from participants.serializers import (
     ChallengeParticipantSerializer,
@@ -164,6 +166,36 @@ def test_get_members_with_prefetched_data(self):
         self.assertIn("user1", member_names)
         self.assertIn("user2", member_names)
 
+    def test_get_members_with_prefetch_avoids_n_plus_one_queries(self):
+        """
+        Verify ParticipantTeamDetailSerializer with prefetched data uses
+        no additional queries when serializing members (no N+1 on user/profile).
+        """
+        team_with_prefetch = (
+            ParticipantTeam.objects.select_related("created_by")
+            .prefetch_related(
+                Prefetch(
+                    "participants",
+                    queryset=Participant.objects.select_related(
+                        "user", "user__profile"
+                    ),
+                )
+            )
+            .get(pk=self.team.pk)
+        )
+
+        with CaptureQueriesContext(connection) as context:
+            serializer = ParticipantTeamDetailSerializer(team_with_prefetch)
+            _ = serializer.data
+
+        # With prefetch, serialization should use 0 extra queries (all data
+        # already loaded). Without prefetch, we'd have 2 per participant.
+        self.assertEqual(
+            len(context.captured_queries),
+            0,
+            "Serializer should not trigger queries when data is prefetched",
+        )
+
     def test_serializer_includes_all_expected_fields(self):
         """Test that the serializer includes all expected fields."""
         serializer = ParticipantTeamDetailSerializer(self.team)