Geek Answers Handbook

Django: json serializes a request that uses defer () or only ()

Now I am using json serializer and it works fine.

I had to change my queries when I started using only() and defer() filters, for example:

 retObj = OBJModel.objects.defer("create_dt").filter(loged_in_dt__gte=dtStart)

After I did this, suddenly the json serializer returns empty fields -

 {"pk": 19047, "model": "OBJModel_deferred_create_dt", "fields": {}}

If I remove defer (), the serializer will correctly display all the data.

 import json from django.utils import simplejson from django.core import serializers json_serializer = serializers.get_serializer("json")() retObj = OBJModel.objects.defer("create_dt").filter(loged_in_dt__gte=dtStart) json_serializer.serialize(retObj, ensure_ascii=False)

I scratched my head a bit for a while. Any insight would be great.

NOTE. I am using django 1.1

+4
source share
2 answers

I am confused as to how you expect the serializer to behave with respect to pending fields ... Perhaps I missed something ...

doc for json serialization says:

Keep in mind that if you serialize the use of this module directly, not all Django output can be passed unchanged to simplejson. In particular, lazy translation objects need a special encoder written for them.

Doc talks about lazy translations, but I think any lazy operation applies.

I think that what you see is just the right conclusion, if you have not written some special encoder that takes care of getting (accessing) the correct value of the pending fields.

Edit after your comment:. I missed the fact that no other fields are encoded. What are the types of other fields? Can we see your model? FK and M2M fields are handled differently with the default encoder - but I don't see anything on django.core.serializers.python.Serializer or django.core.serializers.json.Serializer , which explains why other non-deferred fields are not encoded ...

Edit after some further research: OBJModel_deferred_create_dt in your json payload above made me dig a little further. This seems to be the result of calling django.db.models.queryutils.deferred_class_factory() from the __reduce__ method in the base class of the django model. deferred_class_factory() :

Returns an object of the class, which is a copy of the "model", with the specified "attrs", replaced by DeferredAttribute objects. "Pk_value" associates pending attributes with a specific model instance.

Everything becomes muddy here (for me!): In fact, etching is done against the proxy model for your actual OBJModel . This proxy model should return, when given, the non-deferred fields of the original model. But in your case this is not so.

I will try to set up a little test and see if I can replicate the problem.

+2
source

I think this is some kind of mistake. The following is a workaround. Do this before you call serialization. You will suffer a performance hit, but probably less than serializing the entire object.

 for obj in qs: for attr in qs.query.deferred_loading[0]: obj._meta.local_fields.append(qs.model._meta.get_field(attr))
0
source

More articles:


All Articles