我有一个网站，用户可以在其中查看电影列表，并为他们创建评论。
用户应该能够看到所有电影的列表。此外，如果他们审查了电影，他们应该能够看到他们给出的分数。如果没有，则只显示没有得分的电影。
他们根本不关心其他用户提供的分数。
考虑以下models.py
from django.contrib.auth.models import User
from django.db import models
class Topic(models.Model):
name = models.TextField()
def __str__(self):
return self.name
class Record(models.Model):
user = models.ForeignKey(User)
topic = models.ForeignKey(Topic)
value = models.TextField()
class Meta:
unique_together = ("user", "topic")
我真正想要的是这个
select * from bar_topic
left join (select topic_id as tid, value from bar_record where user_id = 1)
on tid = bar_topic.id
考虑以下test.py上下文：
from django.test import TestCase
from bar.models import *
from django.db.models import Q
class TestSuite(TestCase):
def setUp(self):
t1 = Topic.objects.create(name="A")
t2 = Topic.objects.create(name="B")
t3 = Topic.objects.create(name="C")
# 2 for Johnny
johnny = User.objects.create(username="Johnny")
johnny.record_set.create(topic=t1, value=1)
johnny.record_set.create(topic=t3, value=3)
# 3 for Mary
mary = User.objects.create(username="Mary")
mary.record_set.create(topic=t1, value=4)
mary.record_set.create(topic=t2, value=5)
mary.record_set.create(topic=t3, value=6)
def test_raw(self):
print('\nraw\n---')
with self.assertNumQueries(1):
topics = Topic.objects.raw('''
select * from bar_topic
left join (select topic_id as tid, value from bar_record where user_id = 1)
on tid = bar_topic.id
''')
for topic in topics:
print(topic, topic.value)
def test_orm(self):
print('\norm\n---')
with self.assertNumQueries(1):
topics = Topic.objects.filter(Q(record__user_id=1)).values_list('name', 'record__value')
for topic in topics:
print(*topic)
两个测试应该打印完全相同的输出，但是，只有原始版本吐出正确的结果表：
raw --- A 1 B None C 3
orm会返回此
orm --- A 1 C 3
任何尝试加入其他主题的尝试，那些没有来自用户“johnny”的评论，都会产生以下结果：
orm
---
A 1
A 4
B 5
C 3
C 6
如何使用Django ORM完成原始查询的简单行为？
编辑：这种作品看起来很糟糕：
topics = Topic.objects.filter(record__user_id=1).values_list('name', 'record__value')
noned = Topic.objects.exclude(record__user_id=1).values_list('name')
for topic in chain(topics, noned):
...
编辑：这样做效果更好，但仍然不好：
topics = Topic.objects.filter(record__user_id=1).annotate(value=F('record__value'))
topics |= Topic.objects.exclude(pk__in=topics)
orm --- A 1 B 5 C 3
答案 0 :(得分：21)
首先，没有一种方法（atm Django 1.9.7）使用您发布的原始查询的Django＆lt; ORM 表示 完全，如你所愿;但是，您可以通过以下方式获得相同的预期结果：
>>> Topic.objects.annotate(
f=Case(
When(
record__user=johnny,
then=F('record__value')
),
output_field=IntegerField()
)
).order_by(
'id', 'name', 'f'
).distinct(
'id', 'name'
).values_list(
'name', 'f'
)
>>> [(u'A', 1), (u'B', None), (u'C', 3)]
>>> Topic.objects.annotate(f=Case(When(record__user=may, then=F('record__value')), output_field=IntegerField())).order_by('id', 'name', 'f').distinct('id', 'name').values_list('name', 'f')
>>> [(u'A', 4), (u'B', 5), (u'C', 6)]
这里是为第一个查询生成的SQL：
>>> print Topic.objects.annotate(f=Case(When(record__user=johnny, then=F('record__value')), output_field=IntegerField())).order_by('id', 'name', 'f').distinct('id', 'name').values_list('name', 'f').query
>>> SELECT DISTINCT ON ("payments_topic"."id", "payments_topic"."name") "payments_topic"."name", CASE WHEN "payments_record"."user_id" = 1 THEN "payments_record"."value" ELSE NULL END AS "f" FROM "payments_topic" LEFT OUTER JOIN "payments_record" ON ("payments_topic"."id" = "payments_record"."topic_id") ORDER BY "payments_topic"."id" ASC, "payments_topic"."name" ASC, "f" ASC
distinct用于此答案，该答案仅适用于PostgreSQL，atm。在文档中，您可以看到有关conditional expressions的更多信息。 答案 1 :(得分：7)
我就是这样做的。两个查询，而不是一个：
class Topic(models.Model):
#...
@property
def user_value(self):
try:
return self.user_records[0].value
except IndexError:
#This topic does not have
#a review by the request.user
return None
except AttributeError:
raise AttributeError('You forgot to prefetch the user_records')
#or you can just
return None
#usage
topics = Topic.objects.all().prefetch_related(
models.Prefetch('record_set',
queryset=Record.objects.filter(user=request.user),
to_attr='user_records'
)
)
for topic in topics:
print topic.user_value
好处是您可以获得整个Record对象。因此，考虑一种情况，您不仅要显示value，还要显示time-stamp。
仅为了记录，我想使用.extra再展示一个解决方案。我印象深刻，没有人提到它，因为它应该产生最好的性能。
topics = Topic.objects.all().extra(
select={
'user_value': """SELECT value FROM myapp_record
WHERE myapp_record.user_id = %s
AND myapp_record.topic_id = myapp_topic.id
"""
},
select_params=(request.user.id,)
)
for topic in topics
print topic.user_value
这两个解决方案都可以抽象为自定义TopicQuerySet类，以便重新使用。
class TopicQuerySet(models.QuerySet):
def prefetch_user_records(self, user):
return self.prefetch_related(
models.Prefetch('record_set',
queryset=Record.objects.filter(user=request.user),
to_attr='user_records'
)
)
def annotate_user_value(self, user):
return self.extra(
select={
'user_value': """SELECT value FROM myapp_record
WHERE myapp_record.user_id = %s
AND myapp_record.topic_id = myapp_topic.id
"""
},
select_params=(user.id,)
)
class Topic(models.Model):
#...
objects = TopicQuerySet.as_manager()
#usage
topics = Topic.objects.all().annotate_user_value(request.user)
#or
topics = Topic.objects.all().prefetch_user_records(request.user)
for topic in topics:
print topic.user_value
答案 2 :(得分：7)
受trinchet's answer启发的更通用的解决方案也适用于其他数据库：
>>> qs = Topic.objects.annotate(
... f=Max(Case(When(record__user=johnny, then=F('record__value'))))
... )
示例数据
>>> print(qs.values_list('name', 'f'))
[(u'A', 1), (u'B', None), (u'C', 3)]
验证查询
>>> print(qs.query) # formated and removed excessive double quotes
SELECT bar_topic.id, bar_topic.name,
MAX(CASE WHEN bar_record.user_id = 1 THEN bar_record.value ELSE NULL END) AS f
FROM bar_topic LEFT OUTER JOIN bar_record ON (bar_topic.id = bar_record.topic_id)
GROUP BY bar_topic.id, bar_topic.name
优势（与原始解决方案相比）
output_field。values或values_list(*field_names)对于更简单的GROUP BY非常有用，但它们不是必需的。通过编写函数可以使左连接更具可读性：
from django.db.models import Max, Case, When, F
def left_join(result_field, **lookups):
return Max(Case(When(then=F(result_field), **lookups)))
>>> Topic.objects.annotate(
... record_value=left_join('record__value', record__user=johnny),
... ).values_list('name', 'record_value')
来自Record的更多字段可以通过anotate方法添加到这样的结果中，并使用好的助记符名称。
我同意其他作者可以对其进行优化，但readability counts。
编辑：如果聚合函数Max被Min替换，则会出现相同的结果。 Min和Max都忽略NULL值，可以在任何类型上使用，例如对于字符串。如果不保证左连接是唯一的，则聚合很有用。如果字段是数字，则在左连接上使用平均值Avg会很有用。
答案 3 :(得分：7)
我真正想要的是这个
select * from bar_topic left join (select topic_id as tid, value from bar_record where user_id = 1) on tid = bar_topic.id
...或者，这可能是避免子查询的等价物......
select * from bar_topic
left join bar_record
on bar_record.topic_id = bar_topic.id and bar_record.user_id = 1
我想知道如何有效地做到这一点，或者，如果不可能，我想知道为什么不可能这样做......
除非你使用原始查询，否则Django的ORM是不可能的，这就是原因。
QuerySet个对象（django.db.models.query.QuerySet）具有query属性（django.db.models.sql.query.Query），它表示将要执行的实际查询。这些Query对象有助于使用__str__方法，因此您可以将其打印出来以查看它是什么。
让我们从一个简单的QuerySet ...
>>> from bar.models import *
>>> qs = Topic.objects.filter(record__user_id=1)
>>> print qs.query
SELECT "bar_topic"."id", "bar_topic"."name" FROM "bar_topic" INNER JOIN "bar_record" ON ("bar_topic"."id" = "bar_record"."topic_id") WHERE "bar_record"."user_id" = 1
...由于INNER JOIN，显然不会起作用。
深入了解Query对象内部，alias_map属性确定将执行哪些表连接...
>>> from pprint import pprint
>>> pprint(qs.query.alias_map)
{u'bar_record': JoinInfo(table_name=u'bar_record', rhs_alias=u'bar_record', join_type='INNER JOIN', lhs_alias=u'bar_topic', lhs_join_col=u'id', rhs_join_col='topic_id', nullable=True),
u'bar_topic': JoinInfo(table_name=u'bar_topic', rhs_alias=u'bar_topic', join_type=None, lhs_alias=None, lhs_join_col=None, rhs_join_col=None, nullable=False),
u'auth_user': JoinInfo(table_name=u'auth_user', rhs_alias=u'auth_user', join_type='INNER JOIN', lhs_alias=u'bar_record', lhs_join_col='user_id', rhs_join_col=u'id', nullable=False)}
请注意，Django仅支持两个join_type，INNER JOIN和LEFT OUTER JOIN。
现在，我们可以使用Query对象的promote_joins方法在LEFT OUTER JOIN表上使用bar_record。
>>> qs.query.promote_joins(['bar_record'])
>>> pprint(qs.query.alias_map)
{u'bar_record': JoinInfo(table_name=u'bar_record', rhs_alias=u'bar_record', join_type='LEFT OUTER JOIN', lhs_alias=u'bar_topic', lhs_join_col=u'id', rhs_join_col='topic_id', nullable=True),
u'bar_topic': JoinInfo(table_name=u'bar_topic', rhs_alias=u'bar_topic', join_type=None, lhs_alias=None, lhs_join_col=None, rhs_join_col=None, nullable=False),
u'auth_user': JoinInfo(table_name=u'auth_user', rhs_alias=u'auth_user', join_type='LEFT OUTER JOIN', lhs_alias=u'bar_record', lhs_join_col='user_id', rhs_join_col=u'id', nullable=False)}
...将查询更改为...
>>> print qs.query
SELECT "bar_topic"."id", "bar_topic"."name" FROM "bar_topic" LEFT OUTER JOIN "bar_record" ON ("bar_topic"."id" = "bar_record"."topic_id") WHERE "bar_record"."user_id" = 1
...但是，这仍然没用，因为连接总是匹配一行，即使它不属于正确的用户，WHERE子句也会将其过滤掉。
使用values_list()会自动影响join_type ...
>>> qs = Topic.objects.filter(record__user_id=1).values_list('name', 'record__value')
>>> print qs.query
SELECT "bar_topic"."name", "bar_record"."value" FROM "bar_topic" LEFT OUTER JOIN "bar_record" ON ("bar_topic"."id" = "bar_record"."topic_id") WHERE "bar_record"."user_id" = 1
......但最终还是遇到了同样的问题。
不幸的是，ORM产生的连接存在一个基本限制，因为它们只能是......
(LEFT OUTER|INNER) JOIN <lhs_alias> ON (<lhs_alias>.<lhs_join_col> = <rhs_alias>.<rhs_join_col>)
...除了使用原始查询之外，没有办法实现所需的SQL。
当然，你可以解决annotate()和extra()之类的问题，但是他们可能会生成性能低得多的查询，并且可能比原始SQL更具可读性。
......以及建议的替代方案。
就个人而言，我只是使用原始查询...
select * from bar_topic
left join bar_record
on bar_record.topic_id = bar_topic.id and bar_record.user_id = 1
...这很简单，可以兼容所有Django支持的后端。
答案 4 :(得分：5)
topics = Topic.objects.raw('''
select * from bar_topic
left join (select topic_id as tid, value from bar_record where user_id = 1) AS subq
on tid = bar_topic.id
''')
你似乎自己知道答案。当您无法使ORM查询按照您希望的方式运行时，使用原始查询没有任何问题。
原始查询的一个主要缺点是它们不像ORM查询那样缓存。这意味着如果您遍历原始查询集两次，将重复查询。另一个是你不能在它上面调用.count（）。
您可以通过在外键中设置null=True来强制ORM使用LEFT OUTER JOIN。这样就可以使用表格。
print Record.objects.filter(user_id=8).select_related('topic').query
结果是
SELECT "bar_record"."id", "bar_record"."user_id", "bar_record"."topic_id", "bar_record"."value", "bar_topic"."id", "bar_topic"."name" FROM "bar_record"
INNER JOIN "bar_topic" ON ( "bar_record"."topic_id" = "bar_topic"."id" ) WHERE "bar_record"."user_id" = 8
现在设置，null = True并执行与上面相同的ORM查询。结果是
SELECT "bar_record"."id", "bar_record"."user_id", "bar_record"."topic_id", "bar_record"."value", "bar_topic"."id", "bar_topic"."name" FROM "bar_record"
LEFT OUTER JOIN "bar_topic" ON ( "bar_record"."topic_id" = "bar_topic"."id" ) WHERE "bar_record"."user_id" = 8
请注意查询突然变为LEFT OUTER JOIN的方式。但是我们还没有走出困境，因为桌子的顺序应该颠倒过来！因此，除非您可以重新构建模型，否则如果没有已经尝试过的链接或UNION，则可能无法完全实现ORM LEFT OUTER JOIN。
答案 5 :(得分：0)
Django 2.0引入了FilteredRelation objects，我相信这是您想要的。这个
print('\nnew orm\n---')
with self.assertNumQueries(1):
topics = Topic.objects.annotate(
filtered_record=FilteredRelation('record', condition=Q(record__user_id=1)),
).values_list('name', 'filtered_record__value')
for topic in topics:
print(*topic)
产生期望的表：
new orm
---
A 1
B None
C 3
查询Django输出：
SELECT "bar_topic"."name", filtered_record."value" FROM "bar_topic" LEFT OUTER JOIN "bar_record" filtered_record ON ("bar_topic"."id" = filtered_record."topic_id" AND (filtered_record."user_id" = 1))
答案 6 :(得分：0)
把它放在这里，因为它解决了我们的问题，并且可能会帮助其他人。
我们开始使用 OuterRef，但 Client 和 Contract 都是非常大的表。 OuterRef 被转换为 WHERE EXISTS，这非常缓慢。上述许多选项对我们也不起作用。这就是我们所做的。
from django.db.models.sql.constants import LOUTER
queryset = Client.objects.filter(contract__date=None)
queryset.query.alias_map['contract'].join_type = LOUTER
运行 print(str(queryset.query)) 确实会产生一个带有左外连接的查询，并且结果也符合预期。
结束观察：
contract__id=None 行不通，因为 Django 太聪明了，它只检查子表上的 contract_id=None，这不是您要查找的孤立记录。我们在父表中选择了一个 NOT NULL 字段（在我们的示例中为 contract__date），强制 Django 进行连接。alias_map 以了解 Django 如何命名您的别名。