转
django 执行查询
转载：Django执行查询
只要创建好数据模型, Django 会自动为生成一套数据库抽象的API， 可以让你创建、检索、更新和删除对象。这篇文档阐述如何使用这些API。 关于模型查询所有选项的完整细节，请见数据模型参考 。
在整个文档（以及参考）中，都将引用下面的模型，它是一个博客应用：
-
from django.db
import models
-
-
class Blog(models.Model):
-
name = models.CharField(max_length=
100)
-
tagline = models.TextField()
-
-
def __str__(self):
# __unicode__ on Python 2
-
return self.name
-
-
class Author(models.Model):
-
name = models.CharField(max_length=
200)
-
email = models.EmailField()
-
-
def __str__(self):
# __unicode__ on Python 2
-
return self.name
-
-
class Entry(models.Model):
-
blog = models.ForeignKey(Blog)
-
headline = models.CharField(max_length=
255)
-
body_text = models.TextField()
-
pub_date = models.DateField()
-
mod_date = models.DateField()
-
authors = models.ManyToManyField(Author)
-
n_comments = models.IntegerField()
-
n_pingbacks = models.IntegerField()
-
rating = models.IntegerField()
-
-
def __str__(self):
# __unicode__ on Python 2
-
return self.headline
创建对象
Django 使用一种直观的方式把数据库表中的数据表示成Python对象： 一个模型类代表数据库中的一个表，一个模型类的实例代表这个数据库表中的一条记录。使用关键字参数实例化模型实例来创建一个对象，然后调用 save() 把它保存到数据库中。
假设模型位于文件 mysite/blog/models.py 中，下面是一个例子:
-
>>>
from blog.models
import Blog
-
>>> b = Blog(name=
'Beatles Blog', tagline=
'All the latest Beatles news.')
-
>>> b.save()
save() 方法没有返回值。
参见
save() 方法还有一些高级选项，完整的细节参见 save() 文档。
如果你想只用一条语句创建并保存一个对象，可以使用 create() 方法。
修改对象
要保存一个数据库已存在对象的修改也是使用 save() 方法。假设 Blog 的一个实例 b5 已经被保存在数据库中，下面这个例子将更改它的 name 并且更新数据库中的记录:
-
>>> b5.name =
'New name'
-
>>> b5.save()
保存 ForeignKey 和 ManyToManyField 字段
ForeignKey 字段的方式和保存普通字段相同 —— 只要把一个正确类型的对象赋值给该字段即可。 下面的例子更新了 ``Entry` 类的实例 entry 的 blog 属性，假设 Entry 和 Blog 分别已经有一个实例保存在数据库中 （所以我们才能像下面这样获取它们）:-
>>>
from blog.models
import Entry
-
>>> entry = Entry.objects.get(pk=
1)
-
>>> cheese_blog = Blog.objects.get(name=
"Cheddar Talk")
-
>>> entry.blog = cheese_blog
-
>>> entry.save()
-
>>>
from blog.models
import Author
-
>>> joe = Author.objects.create(name=
"Joe")
-
>>> entry.authors.add(joe)
-
>>> john = Author.objects.create(name=
"John")
-
>>> paul = Author.objects.create(name=
"Paul")
-
>>> george = Author.objects.create(name=
"George")
-
>>> ringo = Author.objects.create(name=
"Ringo")
-
>>> entry.authors.add(john, paul, george, ringo)
检索对象
通过使用模型中的 Manager 构造一个 QuerySet 来从数据库中获取对象。QuerySet 表示从数据库中取出来的对象的集合。 它可以包含零个、一个或者多个 过滤器 。 过滤器的功能是基于所给的参数过滤查询的结果。 从SQL角度看， QuerySet 等价于 SELECT 语句, 过滤器就相当于 WHERE 或者 LIMIT 这样的子句。
QuerySet 通过模型的 Manager 获取。每个模型至少包含一个 Manager, 它们默认叫做 objects 。 可以通过模型类直接访问， 例如:
-
>>> Blog.objects
-
<django.db.models.manager.Manager object at ...>
-
>>> b = Blog(name=
'Foo', tagline=
'Bar')
-
>>> b.objects
-
Traceback:
-
...
-
AttributeError:
"Manager isn't accessible via Blog instances."
Managers 只能通过模型类访问，而不是模型实例。目的是为了强制区分“表级别”的操作和“记录级别”的操作。
Manager 是 QuerySets 的主要来源。 比如， Blog.objects.all() 返回一个数据库中所有 Blog 对象的 QuerySet 。
获取所有对象
表中检索对象的最简单方法是获取所有对象。要做到这一点，在 Manager 上使用 all() 方法:>>> all_entries = Entry.objects.all()
使用过滤器检索
all() 方法返回包含数据库所有记录的 QuerySet。 但是往往只需要获取其中的一个子集。要创建这样一个子集，你需要在原始的的 QuerySet 上增加一些过滤条件。 有两种方式可以实现：
filter(**kwargs) # 返回一个新的QuerySet ，它包含满足查询参数的对象。
exclude(**kwargs) # 返回一个新的QuerySet 。它包含 不 满足查询参数的对象。
例如, 使用 filter() 方法获取年份为2006的所有文章的 QuerySet
Entry.objects.filter(pub_date__year=2006)
Entry.objects.all().filter(pub_date__year=2006)
链式过滤
QuerySet 的筛选结果本身还是 QuerySet, 所以可以将筛选语句链接在一起:-
>>> Entry.objects.filter(
-
... headline__startswith=
'What'
-
... ).exclude(
-
... pub_date__gte=datetime.date.today()
-
... ).filter(
-
... pub_date__gte=datetime(
2005,
1,
30)
-
... )
过滤后的 QuerySet 是独立的
每次你筛选一个 QuerySet, 得到的都是全新的另一个 QuerySet ， 它和之前的 QuerySet 之间没有任何绑定关系。每次筛选都会创建一个独立的 QuerySet ，它可以被存储及反复使用。例如:
-
>>> q1 = Entry.objects.filter(headline__startswith=
"What")
-
>>> q2 = q1.exclude(pub_date__gte=datetime.date.today())
-
>>> q3 = q1.filter(pub_date__gte=datetime.date.today())
QuerySet 是惰性的
QuerySets 是惰性执行的 —— 创建 QuerySet 不会立即执行任何数据库的访问。 你可以将过滤器保持一整天，直到 QuerySet 被 求值 时，Django 才会真正运行这个查询。看下这个例子:-
>>> q = Entry.objects.filter(headline__startswith=
"What")
-
>>> q = q.filter(pub_date__lte=datetime.date.today())
-
>>> q = q.exclude(body_text__icontains=
"food")
-
>>> print(q)
使用 get() 获取单个对象
filter() 始终返回一个 QuerySet ，即使只有一个对象满足查询条件。 —— 这种情况下， QuerySet 将只包含一个元素。如果你知道只有一个对象满足你的查询，你可以使用 Manager 的 get() 方法，它直接返回该对象:
>>> one_entry = Entry.objects.get(pk=1)
但是 get() 和 filter() 有一点区别，如果没有符合条件的查询结果 get() 会抛出一个 DoesNotExist 异常。 这个异常是正在查询的模型类的一个属性，所以在上面的代码中，如果没有主键为 1 的 Entry, Django 将抛出一个 Entry.DoesNotExist。
同样，如果 get() 满足条件的结果超过1个,Django会抛出一个 MultipleObjectsReturned 异常。
其他 QuerySet 方法
查询数据库时，大多数会使用方法 all(), get(), filter() 和 exclude() 。 但是这只是其中一小部分方法，有关 QuerySet 完整的方法列表，请参见 QuerySet API Reference 。QuerySet 的Limit
可以使用Python 的切片语法来限制 QuerySet 记录的数目。它等同于SQL 的LIMIT和 OFFSET 子句。
例如，下面的语句返回前面5个对象 (LIMIT 5):>>> Entry.objects.all()[:5]
>>> Entry.objects.all()[5:10]
不支持负数索引 (i.e. Entry.objects.all()[-1]) 。
通常, QuerySet 的切片返回一个新的 QuerySet – 它不会立即执行查询。但是，如果你使用了Python切片语法中的“步长”参数， 比如下面的语句将在前10个对象中每隔2个对象返回，这样会立即执行数据库查询:>>> Entry.objects.all()[:10:2]
>>> Entry.objects.order_by('headline')[0]
>>> Entry.objects.order_by('headline')[0:1].get()
字段查询
字段查询是指如何指定SQLWHERE
子句的内容,它们通过
QuerySet
的
filter()
,
exclude()
和
get()
方法的关键字参数指定。
查询的关键字参数的基本形式是 field__lookuptype=value. (中间是两个下划线)。 例如:
>>> Entry.objects.filter(pub_date__lte='2006-01-01')
SELECT * FROM blog_entry WHERE pub_date <= '2006-01-01';
Python 定义的函数可以接收任意的键/值对参数，这些名称和参数可以在运行时求值。更多信息， 参见Python 官方文档中 中的 关键字参数 。
查询条件中指定的字段必须是模型字段的名称。但有一个例外，对于
ForeignKey
你可以使用字段名加上 _id 后缀。在这种情况下，该参数的值应该是外键的原始值。例如:
>>> Entry.objects.filter(blog_id=4)
如果传入的是一个不合法的参数，查询函数将引发 TypeError。
这些数据库API 支持大约二十多种查询的类型; 完整的参考请参 见 字段查询 。 下面是一些可能用到的常见查询：exact
“精确”匹配。例如:
>>> Entry.objects.get(headline__exact="Cat bites dog")
SELECT ... WHERE headline = 'Cat bites dog';
因此，下面的两条语句相等:
-
>>> Blog.objects.get(id__exact=
14)
# Explicit form
-
>>> Blog.objects.get(id=
14)
# __exact is implied
iexact
大小写不敏感的匹配。所以这个查询:
>>> Blog.objects.get(name__iexact="beatles blog")
contains
大小写敏感的包含关系。 例如:
Entry.objects.get(headline__contains='Lennon')
SELECT ... WHERE headline LIKE '%Lennon%';
同样也有个大小写不敏感 的版本
icontains
。
startswith
和
endswith分别是查找以目标字符串开头和结尾的记录,同样的，它们都有一个不区分大小写的方法
的方法
istartswith
和
iendswith
。
上面罗列的仅仅是部分查询方法，完整的参考： 字段查询参考
跨关联关系查询
Django 提供了强大而又直观的方式来“处理”查询中的关联关系，它在后台自动帮你处理 JOIN 。 若要使用关联关系的字段查询，只需使用关联的模型字段的名称，并使用双下划线分隔。比如要获取所有 Entry 中所有 Blog 的 name 为 'Beatles Blog' 的对象:
>>> Entry.objects.filter(blog__name='Beatles Blog')
比如，获取所有 Blog 中 Entry 的 headline 包含 'Lennon' 的对象:
>>> Blog.objects.filter(entry__headline__contains='Lennon')
Blog.objects.filter(entry__authors__name='Lennon')
isnull
就会有二义性。 例如:
Blog.objects.filter(entry__authors__name__isnull=True)
Blog.objects.filter(entry__authors__isnull=False, entry__authors__name__isnull=True)
跨关联关系多值查询
当你 使用ManyToManyField
或者
ForeignKey
来过滤一个对象时,有两种不同的过滤方式。 对于 Blog/Entry 的关联关系 (Blog 和 Entry 是一对多关系)。既可以查找headline为 “Lennon” 并且pub_date是2008的Entry, 也可以查找 headline为 “Lennon” 或者 pub_date为 2008的Entry。这两种查询都是有可能并且有意义的。
ManyToManyField
也有类似的情况。比如，如果 Entry 有一个
ManyToManyFieldtags,这样可能想找到tag为 “music” and “bands” 的Entry, 或者我们想找一个tag名为 “music” 且状态为“public”的Entry。
这些情况都可以使 用
filter()
来处理。在单个
filter()
中的条件都会被同时应用到匹配。
这种描述可能不好理解，用一个例子来说明。比如要选择所有的entry包含 “Lennon” 标题并于2008年发表的博客(即这个Blog的entry要同时包含这两个条件)， 查询代码是这样的:
Blog.objects.filter(entry__headline__contains='Lennon', entry__pub_date__year=2008)
Blog.objects.filter(entry__headline__contains='Lennon').filter(entry__pub_date__year=2008)
第二个例子中，第一个filter过滤出的查询集是所有关联有标题包含 “Lennon” 的entry的Blog, 第二个filter是在第一个的查询集中过滤出关联有发布时间是2008的entry的Blog。 第二个filter过滤出来的entry与第一个filter过滤出来的entry可能相同也可能不同。 每个filter语句过滤的是 Blog ，而不是 Entry 。
注解
夸关联关系的 多值
filter()
查询和
exclude()
不同。 单个
exclude()
方法的条件不必引用同一个记录。
例如，要排除标题中包含 “Lennon” 的entry和 发布在2008的entry:
-
Blog.objects.exclude(
-
entry__headline__contains=
'Lennon',
-
entry__pub_date__year=
2008,
-
)
filter()
不一样,它并不是排除同时满足这两个条件的Blog。 如果要排除Blog中entry的标题包含 “Lennon” 且发布时间为2008的，需要改成这样:
-
Blog.objects.exclude(
-
entry__in=Entry.objects.filter(
-
headline__contains=
'Lennon',
-
pub_date__year=
2008,
-
),
-
)
Filters 引用模型字段
在上面例子中，最多是将模型字段和常量进行比较。那么如何将模型的一个字段与模型的另外一个字段进行比较？Django 提 供了
F 表达式
来完成这种操作。
F() 的实例作为查询中模型字段的引用。可以在查询filter中使用这些引用来比较相同模型不同instance上两个不同字段的值。
比如, 如果要查找comments数目多于pingbacks的Entry，可以构造一个 F() 对象来引用pingback数目， 并在查询中使用该 F() 对象:
-
>>>
from django.db.models
import F
-
>>> Entry.objects.filter(n_comments__gt=F(
'n_pingbacks')
Django 支持对 F() 对象使用加法、减法、乘法、除法、取模以及幂计算等算术操作， 操作符两边可以都是常数或 F() 对象。例如，查找comments 数目比pingbacks 两倍还要多的Entry，可以将查询修改为:
>>> Entry.objects.filter(n_comments__gt=F('n_pingbacks') * 2)
>>> Entry.objects.filter(rating__lt=F('n_comments') + F('n_pingbacks'))
>>> Entry.objects.filter(authors__name=F('blog__name'))
-
>>>
from datetime
import timedelta
-
>>> Entry.objects.filter(mod_date__gt=F(
'pub_date') + timedelta(days=
3))
>>> F('somefield').bitand(16)
pk 快捷查询
为了方便，Django 提供一个查询快捷方式 pk ，它表示“primary key” 的意思。在 Blog 模型示例中，主键是 id 字段，所以下面三条语句是等同的:
-
>>> Blog.objects.get(id__exact=
14)
# Explicit form
-
>>> Blog.objects.get(id=
14)
# __exact is implied
-
>>> Blog.objects.get(pk=
14)
# pk implies id__exact
-
# Get blogs entries with id 1, 4 and 7
-
>>> Blog.objects.filter(pk__in=[
1,
4,
7])
-
# Get all blog entries with id > 14
-
>>> Blog.objects.filter(pk__gt=
14)
-
>>> Entry.objects.filter(blog__id__exact=
3)
# Explicit form
-
>>> Entry.objects.filter(blog__id=
3)
# __exact is implied
-
>>> Entry.objects.filter(blog__pk=
3)
# __pk implies __id__exact
LIKE 中的%和_转义
与 LIKE SQL 语句等同的字段查询（ iexact 、 contains 、 icontains 、 startswith 、 istartswith 、 endswith 和 iendswith ）将自动转义在 LIKE 语句中 使用的两个特殊的字符 —— 百分号和下划线。（在 LIKE 语句中，百分号通配符表示多个字符，下划线通配符表示单个字符）这样语句将很直观，不会显得太抽象。例如，要获取包含一个百分号的所有的 Entry ，只需要像其它任何字符一样使用百分号:
>>> Entry.objects.filter(headline__contains='%')
SELECT ... WHERE headline LIKE '%\%%';
QuerySet 缓存
每 个QuerySet
都会缓存一个最小化的数据库访问。编写高效的代码前你需要理解它是如何工作的。
在一个新创 建的
QuerySet
中，缓存为空。 首次对查询集进行求值——即产生数据库查询，
Django将保存查询的结果到
QuerySet
的缓存中，并明确返回请求的结果（ 例如，如果正在迭代
QuerySet
，则返回下一个结果） 接下来对该
QuerySet
的求值将重用缓存的结果
请牢记这个缓存行为，因 为对
QuerySet
使用不当的话，它会坑你的。 例如，下面的语句创建两个
QuerySet
，对它们求值，然后扔掉它们:
-
>>> print([e.headline
for e
in Entry.objects.all()])
-
>>> print([e.pub_date
for e
in Entry.objects.all()])
为了避免这个问题，只需保存 QuerySet 并重新使用它:
-
>>> queryset = Entry.objects.all()
-
>>> print([p.headline
for p
in queryset])
# Evaluate the query set.
-
>>> print([p.pub_date
for p
in queryset])
# Re-use the cache from the evaluation.
何时查询集不会被缓存
查询集不会永远缓存它们的结果。当只对查询集的部分进行求值时会检查缓存， 但是如果这个部分不在缓存中，那么接下来查询返回的记录都将不会被缓存。 这意味着使用 切片或 限制查询集 将不会填充缓存例如，重复获取查询集对象中一个特定的索引将每次都查询数据库:
-
>>> queryset = Entry.objects.all()
-
>>> print(queryset[
5])
# Queries the database
-
>>> print(queryset[
5])
# Queries the database again
然而，如果已经对全部查询集求值过，则将检查缓存:
-
>>> queryset = Entry.objects.all()
-
>>> [entry
for entry
in queryset]
# Queries the database
-
>>> print(queryset[
5])
# Uses cache
-
>>> print(queryset[
5])
# Uses cache
-
>>> [entry
for entry
in queryset]
-
>>> bool(queryset)
-
>>> entry
in queryset
-
>>> list(queryset)
简单地打印查询集不会填充缓存。因为 __repr__() 调用只返回全部查询集的一个切片。
Q 复杂查询
filter()
等方法中的关键字参数查询都是一起进行 “AND” 操作, 如果你需要执行更复杂的查询(例如
OR
语句), 你可以使用
Q 查询对象
.
Q 对象 (django.db.models.Q) 对象用于封装一组关键字参数。 这些关键字参数就是上文“字段查询” 中所提及的那些。
-
from django.db.models
import Q
-
Q(question__startswith=
'What')
例如，下面的语句产生一个 Q 对象，表示两个 "question__startswith" 查询的“OR”:
Q(question__startswith='Who') | Q(question__startswith='What')
WHERE question LIKE 'Who%' OR question LIKE 'What%'
Q(question__startswith='Who') | ~Q(pub_date__year=2005)
filter()
,
exclude()
,
get()
) 都可以传递一个或多个 Q 对象作为位置参数。 如果一个查询函数有多个 Q 对象参数，这些参数的逻辑关系为“AND”。例如:
-
Poll.objects.get(
-
Q(question__startswith=
'Who'),
-
Q(pub_date=date(
2005,
5,
2)) | Q(pub_date=date(
2005,
5,
6))
-
)
-
SELECT *
from polls WHERE question LIKE
'Who%'
-
AND (pub_date =
'2005-05-02' OR pub_date =
'2005-05-06')
-
Poll.objects.get(
-
Q(pub_date=date(
2005,
5,
2)) | Q(pub_date=date(
2005,
5,
6)),
-
question__startswith=
'Who',
-
)
-
# INVALID QUERY
-
Poll.objects.get(
-
question__startswith=
'Who',
-
Q(pub_date=date(
2005,
5,
2)) | Q(pub_date=date(
2005,
5,
6))
-
)
参见
Django 单元测试 中的 OR查询示例 演示了几种 Q 的用法.
对象比较
使用双等号 == 比较两个对象，其实是比较两个模型主键的值。使用上面的 Entry 示范, 下面两个表达式是等同的:
-
>>> some_entry == other_entry
-
>>> some_entry.id == other_entry.id
-
>>> some_obj == other_obj
-
>>> some_obj.name == other_obj.name
删除对象
删除方法叫做delete()。这个方法将立即删除对象， 返回被删除的对象的总数和每个对象类型的删除数量的字典。举例:
-
>>> e.delete()
-
(
1, {
'weblog.Entry':
1})
你还可以批量删除对象。 每个
QuerySet
都有
delete()
方法，它作用是删
除
QuerySet
中的所有成员。
例如, 下面语句删除所有 pub_date 为2005的 Entry
-
>>> Entry.objects.filter(pub_date__year=
2005).delete()
-
(
5, {
'webapp.Entry':
5})
QuerySet
的
delete()
方法）。
当Django 删除一个对象时，它默认使用SQL ON DELETE CASCADE 约束 —— 换句话讲，任何有外键指向要删除对象的对象都将一起删除。 例如:
-
b = Blog.objects.get(pk=
1)
-
# 这会删除该 Blog 和它所有的Entry对象
-
b.delete()
ForeignKey
的
on_delete
参数定义。
注意，
delete()
是唯一没有在
Manager
上暴露出来的
QuerySet
方法。 这是一个安全机制来防止你意外地请求
Entry.objects.delete()
, 而删除所有的条目。 如果你确实想删除所有的对象，你必须明确地请求一个完整的查询集:
Entry.objects.all().delete()
复制对象
没有内建的复制模型实例的方法，但可以通过创建一个新的实例并将它的所有字段都拷贝过来。最简单的方法是，只需要将 pk 设置成 None 。使用blog作为演示:-
blog = Blog(name=
'My blog', tagline=
'Blogging is easy')
-
blog.save()
# blog.pk == 1
-
blog.pk =
None
-
blog.save()
# blog.pk == 2
-
class ThemeBlog(Blog):
-
theme = models.CharField(max_length=
200)
-
-
django_blog = ThemeBlog(name=
'Django', tagline=
'Django is easy', theme=
'python')
-
django_blog.save()
# django_blog.pk == 3
-
django_blog.pk =
None
-
django_blog.id =
None
-
django_blog.save()
# django_blog.pk == 4
-
entry = Entry.objects.all()[
0]
# some previous entry
-
old_authors = entry.authors.all()
-
entry.pk =
None
-
entry.save()
-
entry.authors.set(old_authors)
-
detail = EntryDetail.objects.all()[
0]
-
detail.pk =
None
-
detail.entry = entry
-
detail.save()
同时更新多个对象
可以对QuerySet
中的所有对象修改该某个字段的值。这就需要使用
update()
方法，例如:
-
# 修改所有pub_date为2007的headlines
-
Entry.objects.filter(pub_date__year=
2007).update(headline=
'Everything is the same')
ForeignKey
字段使用这个方法。若要更新一个非关联字段，只需提供一个新的常数值。
若要更新
ForeignKey
字段, 需设置新的值是你想指向的新的模型实例，例如:
-
>>> b = Blog.objects.get(pk=
1)
-
-
# 修改所有的 Entry，使它们属于这个Blog
-
>>> Entry.objects.all().update(blog=b)
The update() 方法会立即执行并返回匹配的行数 (如果有些行的值和新值相同，返回的行数可能和被更新的行数不相等)。 更新 QuerySet 唯一的限制是它只能访问一个数据库表，也就是模型的主表。 你可以根据关联的字段过滤，但是你只能更新模型主表中的列，例如:
-
>>> b = Blog.objects.get(pk=
1)
-
-
# Update all the headlines belonging to this Blog.
-
>>> Entry.objects.select_related().filter(blog=b).update(headline=
'Everything is the same')
update() 方法会直接转换成一个SQL语句。它是一个批量的更新操作，而且不会调用模型的 save() 方法, 或者触发 pre_save 和 post_save 信号(调用 save() 方法产生), 或者遵从 auto_now 选项。 如果想保存 QuerySet 中的每个条目并确保每个实例的 save() 方法都被调用， 不需要使用任何特殊的函数来处理。只需要迭代调用它们 的 save() 方法:
-
for item
in my_queryset:
-
item.save()
F 表达式
来根据模型中的一个字段更新另外一个字段。 这种在当前值的基础上加另一个值时特别有用。例如Blog中每个Entry的pingback个数:
>>> Entry.objects.all().update(n_pingbacks=F('n_pingbacks') + 1)
-
# This will raise a FieldError
-
>>> Entry.objects.update(headline=F(
'blog__name'))
关联对象
如果在模型中定义了关联关系 (例如，ForeignKey
,
OneToOneField
,
ManyToManyField
), 那么该模型的实例将带有一些的API来访问关联的对象。
使用上面提到的模型,例如, 一个 Entry 对象 e 可以通过其 blog 属性: e.blog 来获取关联的 Blog 对象。
Django 还提供了API 用于访问关联关系的另一头 – 从关联的模型访问定义关联关系的模型。 例如， Blog 对象 b 可以通过 entry_set 属性 b.entry_set.all() 来访问与它关联的所有 Entry 对象。
下面所有的例子都将使用前面定义的 Blog， Author 和 Entry 模型。
一对多关系
前向查询
如果模型具有一个ForeignKey
，那么该模型的实例将可以通过属性访问关联的（外部）对象。
例如:
-
>>> e = Entry.objects.get(id=
2)
-
>>> e.blog
# 返回关联的Blog对象.
save()
方法。 例如:
-
>>> e = Entry.objects.get(id=
2)
-
>>> e.blog = some_blog
-
>>> e.save()
ForeignKey
字段设置了
null=True
(即允许
NULL
值), 这样就可以将其设置为
None
来取消关联。 例如:
-
>>> e = Entry.objects.get(id=
2)
-
>>> e.blog =
None
-
>>> e.save()
# "UPDATE blog_entry SET blog_id = NULL ...;"
-
>>> e = Entry.objects.get(id=
2)
-
>>> print(e.blog)
# 在数据库获取相关的Blog.
-
>>> print(e.blog)
# 不会链接数据库;使用缓存.
QuerySet
的
select_related()
方法预先递归填充所有的一对多关系到缓存中。例如:
-
>>> e = Entry.objects.get(id=
2)
-
>>> print(e.blog)
# 在数据库获取相关的Blog.
-
>>> print(e.blog)
# 不会链接数据库;使用缓存.
反向查询
如果模型具有外键 ForeignKey ，那么该外键所指向的模型实例可以通过Manager 返回包含某个特定外键的源模型的所有实例。 模型情况下，这个 Manager 叫做 FOO_set, FOO 是源模型的小写名称。 该 Manager 返回的QuerySets 同样可以使用过滤等操作。
例子:
>>> b = Blog.objects.get(id=1)
>>> b.entry_set.all() # 返回所有关联b的Blog.
# b.entry_set is a Manager that returns QuerySets.
>>> b.entry_set.filter(headline__contains=‘Lennon’)
>>> b.entry_set.count()
你可以在定义 ForeignKey 时 设置 related_name 参数来重写 FOO_set 名字。比如，如果 Entry 模型改成blog = ForeignKey(Blog, on_delete=models.CASCADE, related_name='entries'), 那么上面例子的代码应该改成这样:
>>> b = Blog.objects.get(id=1)
>>> b.entries.all() # Returns all Entry objects related to Blog.
# b.entries is a Manager that returns QuerySets.
>>> b.entries.filter(headline__contains=‘Lennon’)
>>> b.entries.count()
自定义反向管理器
默认情况下，用于反向关联关系的 RelatedManager 是该模型 默认管理器 的子类。 如果您想为查询指定不同的管理器，那么可以使用以下语法:
from django.db import models
class Entry(models.Model):
#…
objects = models.Manager() # Default Manager
entries = EntryManager() # Custom Manager
b = Blog.objects.get(id=1)
b.entry_set(manager=‘entries’).all()
如果 EntryManager 在 get_queryset() 方法中执行了默认的过滤，那么该过滤将应用于 all() 调用。
当然，指定一个自定义的管理器还可以让你调用自定义的方法:
b.entry_set(manager='entries').is_published()
处理关联对象的其它方法
除了在上面的“检索对象”中定义的 ForeignKey Manager 还有其它用于处理关联对象集合的方法。下面是每个方法的大致介绍，完整的细节可以在 关联对象参考 中找到。
- 将指定的模型对象添加到相关的对象集中。
- 创建一个新的对象，保存并放到关联的对象集中。返回新创建的对象。
- 从关联的对象集中删除指定的模型对象。
- 从关联的对象集中删除所有的对象。
- 替换相关对象的集合。
add(obj1, obj2, ...)
create(**kwargs)
remove(obj1, obj2, ...)
clear()
set(objs)
若要一次性给关联的对象集赋值，可以使用 set() 方法，该方法可以迭代对象实例或主键值的列表。例如:
b = Blog.objects.get(id=1)
b.entry_set.set([e1, e2])
在例子中, e1 和 e2 可以是Entry的实例，也可以是主键的整数值。
如果 clear() 可用, 那么在将可迭代对象中的成员添加到集合中之前，将从 entry_set 中删除所有已经存在的对象。如果 clear() 方法不可用，那么将直接添加可迭代对象中的成员而不会删除所有已存在的对象。
这一节中提到的每个”反向“操作都会立即对数据库产生作用。每个添加、创建和删除操作都会立即并自动保存到数据库中。
多对多关系
多对多关系的两端都带有访问另一端的API。这些API的工作方式与上面提到的一对多关系一样。
唯一的区别在于属性的名称：定义ManyToManyField`的模型使用本字段的属性名称,而“反向”模型使用源模型的小写名称加上 `’_set’`` (和一对多关系一样)。
比如:
e = Entry.objects.get(id=3)
e.authors.all() # 返回 Entry e中的所有Author.
e.authors.count()
e.authors.filter(name__contains='John')
a = Author.objects.get(id=5)
a.entry_set.all() # 返回Author a所有的Entry.
类似 ForeignKey, ManyToManyField 可以指定 related_name 。在上面的例子中， 如果 Entry 中的 ManyToManyField 指定 related_name='entries', 那么 Author 实例将使用 entries 属性而不是 entry_set 。
一对一关系
一对一关系与多对一关系非常相似。如果你在模型中定义一个 OneToOneField ， 该模型的实例将可以通过该模型的一个简单属性访问关联的模型。
例如:
class EntryDetail(models.Model):
entry = models.OneToOneField(Entry, on_delete=models.CASCADE)
details = models.TextField()
ed = EntryDetail.objects.get(id=2)
ed.entry # Returns the related Entry object.
在“反向”查询中有所不同。 一对一关系中的关联模型同样具有一个 Manager对象， 但是该 Manager 表示一个单一的对象而不是对象的集合:
e = Entry.objects.get(id=2)
e.entrydetail # returns the related EntryDetail object
如果没有对象赋值给这个关联关系，Django 将引发一个 DoesNotExist 异常。
实例可以赋值给反向的关联关系，方法和正向的关联关系一样:
e.entrydetail = ed
反向的关联关系如何实现?
其它对象关系映射要求你在关联关系的两端都要定义。Django 的开发人员相信这是对DRY（不要重复你自己的代码）原则的违背， 所以Django 只要求你在一端定义关联关系。
但是，考虑到直到其他模型类被加载，模型类不知道其他模型类与之相关，这是怎么实现的呢?
答案在 app registry 中。当Django 启动时，它导入 INSTALLED_APPS 中列出的每个应用,然后导入每个应用中的 models 模块。 每创建一个新的模型时，Django 添加反向的关系到所有关联的模型。 如果关联的模型还没有导入，Django 将保存关联关系的记录并在最终关联的模型导入时添加这些关联关系。
由于这个原因，你使用的所有模型都定义在 INSTALLED_APPS 列出的应用中就显得特别重要。 否则，反向的关联关系将不能正常工作。
查询相关对象
在关联对象字段上的查询与正常字段的查询遵循同样的规则。当你指定查询需要匹配的一个值时，你可以使用一个对象实例或者对象的主键的值。
例如，如果你有一个 id=5 的Blog 对象 b ，下面的三个查询将是完全一样的l:
Entry.objects.filter(blog=b) # Query using object instance
Entry.objects.filter(blog=b.id) # Query using id from instance
Entry.objects.filter(blog=5) # Query using id directly
4167
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
