我有以下型号:

class User(models.Model):
    name = models.Charfield()
    email = models.EmailField()

class Friendship(models.Model):
    from_friend = models.ForeignKey(User)
    to_friend = models.ForeignKey(User)

这些模型用于以下 View 和序列化程序:

class GetAllUsers(generics.ListAPIView):
    authentication_classes = (SessionAuthentication, TokenAuthentication)
    permission_classes = (permissions.IsAuthenticated,)
    serializer_class = GetAllUsersSerializer
    model = User

    def get_queryset(self):
        return User.objects.all()

class GetAllUsersSerializer(serializers.ModelSerializer):

    is_friend_already = serializers.SerializerMethodField('get_is_friend_already')

    class Meta:
        model = User
        fields = ('id', 'name', 'email', 'is_friend_already',)

    def get_is_friend_already(self, obj):
        request = self.context.get('request', None)

        if request.user != obj and Friendship.objects.filter(from_friend = user):
            return True
        else:
            return False

所以基本上，对于 GetAllUsers View 返回的每个用户，我想打印出该用户是否是请求者的 friend (实际上我应该检查 from_ 和 to_friend，但没关系针对问题)

我看到的是，对于数据库中的 N 个用户，有 1 个查询用于获取所有 N 个用户，然后在序列化程序的 get_is_friend_already

有没有办法在 rest-framework 方式中避免这种情况？可能类似于将 select_related 包含查询传递给具有相关 Friendship 行的序列化程序？

最佳答案

Django REST Framework 无法自动为您优化查询，就像 Django 本身不会那样。您可以在一些地方查看提示，including the Django documentation .它has been mentioned Django REST Framework 应该是自动的，尽管有一些与之相关的挑战。

这个问题非常适合您的情况，您正在使用自定义 SerializerMethodField 对返回的每个对象发出请求。因为您正在发出一个新请求(使用 Friends.objects 管理器)，所以优化查询非常困难。

不过，您可以通过不创建新查询集而是从其他地方获取 friend 数来改善问题。这将需要在 Friendship 模型上创建向后关系，很可能通过字段上的 related_name 参数，因此您可以预取所有 Friendship对象。但这仅在您需要完整对象时才有用，而不仅仅是对象的计数。

这将产生类似于以下内容的 View 和序列化程序:

class Friendship(models.Model):
    from_friend = models.ForeignKey(User, related_name="friends")
    to_friend = models.ForeignKey(User)

class GetAllUsers(generics.ListAPIView):
    ...

    def get_queryset(self):
        return User.objects.all().prefetch_related("friends")

class GetAllUsersSerializer(serializers.ModelSerializer):
    ...

    def get_is_friend_already(self, obj):
        request = self.context.get('request', None)

        friends = set(friend.from_friend_id for friend in obj.friends)

        if request.user != obj and request.user.id in friends:
            return True
        else:
            return False

如果您只需要对象的计数(类似于使用 queryset.count() 或 queryset.exists())，您可以在具有反向关系计数的查询集。这将在您的 get_queryset 方法中完成，方法是将 .annotate(friends_count=Count("friends")) 添加到末尾(如果 related_name 是 friends)，这会将每个对象的 friends_count 属性设置为 friend 的数量。

这将产生类似于以下内容的 View 和序列化程序:

class Friendship(models.Model):
    from_friend = models.ForeignKey(User, related_name="friends")
    to_friend = models.ForeignKey(User)

class GetAllUsers(generics.ListAPIView):
    ...

    def get_queryset(self):
        from django.db.models import Count

        return User.objects.all().annotate(friends_count=Count("friends"))

class GetAllUsersSerializer(serializers.ModelSerializer):
    ...

    def get_is_friend_already(self, obj):
        request = self.context.get('request', None)

        if request.user != obj and obj.friends_count > 0:
            return True
        else:
            return False

这两种解决方案都将避免 N+1 查询，但您选择的解决方案取决于您要实现的目标。

关于python - 在 Django REST 框架中优化数据库查询，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/26593312/