Revisão de Performance do Django

Revise o código Django para problemas de performance validados. Pesquise a base de código para confirmar os problemas antes de reportá-los. Reporte apenas o que você pode provar.

Quando Usar

• Você precisa de uma revisão de performance do Django focada em problemas de ORM e consultas verificados.
• O código provavelmente tem consultas N+1, querysets ilimitados, índices ausentes ou outros gargalos impulsionados pelo banco de dados.
• Você quer apenas descobertas de performance comprováveis, não conselhos de otimização especulativos.

Abordagem da Revisão

1. Pesquise primeiro - Rastreie o fluxo de dados, verifique otimizações existentes, valide o volume de dados
2. Valide antes de reportar - Correspondência de padrões não é validação
3. Zero descobertas é aceitável - Não fabrique problemas para parecer completo
4. A severidade deve corresponder ao impacto - Se você se pegar escrevendo "menor" em uma descoberta CRÍTICA, não é crítica. Rebaixe ou pule.

Categorias de Impacto

Os problemas são organizados por impacto. Concentre-se em CRÍTICO e ALTO - estes causam problemas reais em escala.

Prioridade 1: Consultas N+1 (CRÍTICO)

Impacto: Cada N+1 adiciona O(n) idas e vindas ao banco de dados. 100 linhas = 100 consultas extras. 10.000 linhas = timeout.

Regra: Pré-carregue dados relacionados acessados em loops

Valide rastreando: View → Queryset → Template/Serializer → Acesso ao loop

# PROBLEM: N+1 - each iteration queries profile
def user_list(request):
    users = User.objects.all()
    return render(request, 'users.html', {'users': users})

# Template:
# {% for user in users %}
#     {{ user.profile.bio }}  ← triggers query per user
# {% endfor %}

# SOLUTION: Prefetch in view
def user_list(request):
    users = User.objects.select_related('profile')
    return render(request, 'users.html', {'users': users})

Regra: Pré-carregue em serializers, não apenas em views

Serializers DRF que acessam campos relacionados causam N+1 se o queryset não for otimizado.

# PROBLEM: SerializerMethodField queries per object
class UserSerializer(serializers.ModelSerializer):
    order_count = serializers.SerializerMethodField()

    def get_order_count(self, obj):
        return obj.orders.count()  # ← query per user

# SOLUTION: Annotate in viewset, access in serializer
class UserViewSet(viewsets.ModelViewSet):
    def get_queryset(self):
        return User.objects.annotate(order_count=Count('orders'))

class UserSerializer(serializers.ModelSerializer):
    order_count = serializers.IntegerField(read_only=True)

Regra: Propriedades de modelo que consultam são perigosas em loops

# PROBLEM: Property triggers query when accessed
class User(models.Model):
    @property
    def recent_orders(self):
        return self.orders.filter(created__gte=last_week)[:5]

# Used in template loop = N+1

# SOLUTION: Use Prefetch with custom queryset, or annotate

Checklist de Validação para N+1

• Rastreou o fluxo de dados da view para o template/serializer
• Confirmou que o campo relacionado é acessado dentro de um loop
• Pesquisou na base de código por select_related/prefetch_related existentes
• Verificou se a tabela tem um número significativo de linhas (1000+)
• Confirmou que este é um caminho crítico (não admin, não ação rara)

Prioridade 2: Querysets Ilimitados (CRÍTICO)

Impacto: Carregar tabelas inteiras esgota a memória. Tabelas grandes causam mortes por OOM e reinícios de workers.

Regra: Sempre págine endpoints de lista

# PROBLEM: No pagination - loads all rows
class UserListView(ListView):
    model = User
    template_name = 'users.html'

# SOLUTION: Add pagination
class UserListView(ListView):
    model = User
    template_name = 'users.html'
    paginate_by = 25

Regra: Use iterator() para processamento em lote grande

# PROBLEM: Loads all objects into memory at once
for user in User.objects.all():
    process(user)

# SOLUTION: Stream with iterator()
for user in User.objects.iterator(chunk_size=1000):
    process(user)

Regra: Nunca chame list() em querysets ilimitados

# PROBLEM: Forces full evaluation into memory
all_users = list(User.objects.all())

# SOLUTION: Keep as queryset, slice if needed
users = User.objects.all()[:100]

…