序列化DRF中的相关字段

Question

I have two models, a parent model and a child model, that I want to exist on separate tables in the database but represent them on the same object (flat) when I return to the client. I've tried a few options with this including SerializerMethodFields (SMF) and ReadOnlyFields but they both result in too many db queries.

I've also tried nesting the object and then flattening it later which does work, but results in a lot more code due to the way Django's serializers work. It left me feeling that there should be a better way to accomplish this.

Here's an example of a call to the serializer using the SMF approach:

# in the view
class ListFoo(APIView):
    def get(self, request):
        foo = Foo.objects.prefetch_related('bar').all()
        serializer = FooSerializer(foo, may=True)
        Response(serializer.data, status=status.HTTP_200_OK)

# in the serializer
class FooSerializer(ModelSerializer):
    employer = SerializerMethodField()
    position = SerializerMethodField()

    class Meta:
        model = Foo
        fields('id', 'name', 'employer', 'position')

    def get_employer(self, foo):
        # use related manager to access related object
        return foo.bar.last().employer

    def get_position(self, foo):
        # use related manager to access related object
        return foo.bar.last().position

# in the models
class Foo(models.Model):
    name = models.CharField(max_length=150)

class Bar(models.Model):
    employer = models.CharField(max_length=150)
    position = models.CharField(max_length=150)
    foo = models.ForeignKey(
        Foo,
        related_name='bar',
        unique=False,
        on_delete=models.CASCADE
    )

Now that code above works but if I'm querying many Foo objects, it will query +1 bar each attribute I need to access from bar. I'm trying to find a way to have a global store/cache of data that I potentially query when the serializer initializes.

Any ideas on something more efficient or a better approach?

UPDATE: I have this mostly figured out and will post a solution tomorrow. I didn't realize how many ways there were to improperly operate on a queryset that was created with prefetch.

Answer 1

The problem with the code above is that when I operated on the queryset with the last method

def get_employer(self, foo):
    # use related manager to access related object
    return foo.bar.last().employer

Django queried the database each time get_employer was called. After reading the documentation and several other answers , I realized that using the all() method is an important next step as it will return the queryset (which was prefeched in the view) for the related objects. It's strange to me that you can't operate directly on the related objects as you would normally with a method like last() or filter() but you can iterate over them and filter.

All I needed to do to solve my problem was to return the last item in the related_manager's queryset and I accomplished this by returning the last object in the queryset using subscript. I'm sure there's some ways to decrease code but it works.

def get_employer(self, foo):
    qs = foo.bar.all()
    last = query.count()
    obj = model_to_dict(qs[last-1])

    return obj.get('employer')

Answer 2

Not quite sure, I understand, but it looks like you want the last employer for your Foo object. So then your SerializerMethodField could be as follows ( assuming here that created-date descending reflects your most recent employer)

def get_employer(self, foo):
   obj= foo.bar.all().order_by('-created')[0]
   return obj.employer