I'm using Django v1.9.4 with PostgreSQL 9.2.14 behind. With the following models:
from django.db import models
from django.contrib.contenttypes.fields import GenericRelation, GenericForeignKey
from django.contrib.contenttypes.models import ContentType
content_type = models.ForeignKey(ContentType)
object_id = models.PositiveIntegerField()
bar = GenericForeignKey('content_type', 'object_id')
foos = GenericRelation(Foo, related_query_name='bars')
abstract = True
name = models.CharField(max_length=10, default='bar x')
name = models.CharField(max_length=10, default='bar y')
>>> bar_x = BarX.objects.create()
>>> bar_y = BarY.objects.create()
>>> foo1 = Foo.objects.create(bar=bar_x)
>>> foo2 = Foo.objects.create(bar=bar_y)
>>> [foo.bar.name for foo in Foo.objects.all()]
[u'bar x', u'bar y'] # in a pure python loop, it's working
>>> Foo.objects.filter(bar__name='bar x')
FieldError: Field 'bar' does not generate an automatic reverse relation and therefore cannot be used for reverse querying. If it is a GenericForeignKey, consider adding a GenericRelation.
>>> Foo.objects.values_list('bars__name', flat=1)
[None, u'bar y'] # but why None is returned in here?
>>> Foo.objects.filter(bars__name='bar x')
 # why no result here?
>>> Foo.objects.filter(bars__name='bar y')
[<Foo: Foo object>] # but this one works?
In general, it is not possible to traverse a
GenericForeignKey in this direction in the way you are trying. A
GenericForeignKey can point to any model in your application at all, not only
Bar and its subclasses. For that reason,
Foo.objects.filter(bar__somefield='some value') cannot know what target model you have in mind at the moment, and therefore it is impossible to tell what fields that target model has. In fact, there is no way to pick what database table to join with when performing such a query – it could be any table, depending on the value of
If you do want to use a generic relation in joins, you'll have to define a
GenericRelation on the other end of that relationship. That way you can let Django know which model it is supposed to look for on the other side.
For instance, you can create your
BarY models like this:
class BarX(Bar): name = models.CharField(max_length=10, default='bar x') foos = GenericRelation(Foo, related_query_name='bar_x') class BarY(Bar): name = models.CharField(max_length=10, default='bar y') foos = GenericRelation(Foo, related_query_name='bar_y')
If you do this, then you can perform queries like the following:
Foo.objects.filter(bar_x__name='bar x') Foo.objects.filter(bar_y__name='bar y')
However, you have to pick a single target model. That is a limitation that you cannot really overcome in any way; every database join needs to know in advance which tables it operates on.
If you absolutely need to allow both
BarY as the target, you should be able to list both of them explicitly in your query filter using a
Foo.objects.filter(Q(bar_x__name='bar x') | Q(bar_y__name='bar y'))