保存ForeignKey和ManyToManyField字段¶

更新ForeignKey字段的工作方式与保存普通字段完全相同 - 将正确类型的对象分配给该字段。此示例更新Entry实例entry的blog属性，假设Entry和Blog的适当实例已保存到数据库（因此我们可以在下面检索它们）。

>>> from blog.models import Blog, Entry
>>> entry = Entry.objects.get(pk=1)
>>> cheese_blog = Blog.objects.get(name="Cheddar Talk")
>>> entry.blog = cheese_blog
>>> entry.save()

更新一个 ManyToManyField 的工作方式略有不同 - 使用 add() 方法在字段上添加一个记录到关系中。此示例将 Author 实例 joe 添加到 entry 对象中

>>> from blog.models import Author
>>> joe = Author.objects.create(name="Joe")
>>> entry.authors.add(joe)

要一次性将多个记录添加到 ManyToManyField 中，在调用 add() 时包含多个参数，如下所示

>>> 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)

如果您尝试分配或添加错误类型的对象，Django 会报错。

检索所有对象¶

从表中检索对象的简便方法是获取所有对象。为此，请在 Manager 上使用 all() 方法。

>>> all_entries = Entry.objects.all()

all() 方法返回一个 QuerySet，其中包含数据库中的所有对象。

使用过滤器检索特定对象¶

QuerySet 由 all() 返回，它描述了数据库表中的所有对象。但是，通常您需要仅选择完整对象集的子集。

要创建这样的子集，您需要对初始的 QuerySet 进行细化，添加过滤条件。细化 QuerySet 的两种最常见方法是

filter(**kwargs)

返回一个新的 QuerySet，其中包含与给定查找参数匹配的对象。

exclude(**kwargs)

返回一个新的 QuerySet，其中包含与给定查找参数 *不* 匹配的对象。

查找参数（上述函数定义中的 **kwargs）应采用 字段查找 中描述的格式。

例如，要获取一个包含 2006 年博客文章的 QuerySet，请使用 filter()，如下所示

Entry.objects.filter(pub_date__year=2006)

使用默认管理器类，它与以下代码相同

Entry.objects.all().filter(pub_date__year=2006)

>>> Entry.objects.filter(headline__startswith="What").exclude(
...     pub_date__gte=datetime.date.today()
... ).filter(pub_date__gte=datetime.date(2005, 1, 30))

>>> 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())

>>> 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。

如果您知道只有一个对象匹配您的查询，则可以使用 get() 方法在 Manager 上，它直接返回对象。

>>> one_entry = Entry.objects.get(pk=1)

您可以将任何查询表达式与 get() 一起使用，就像使用 filter() 一样 - 同样，请参见下面的 字段查找。

请注意，使用 get() 和使用 filter() 以及 [0] 的切片之间存在差异。如果没有结果匹配查询，get() 将引发 DoesNotExist 异常。此异常是正在执行查询的模型类的属性 - 因此在上面的代码中，如果没有主键为 1 的 Entry 对象，Django 将引发 Entry.DoesNotExist。

同样，如果多个项目匹配 get() 查询，Django 会报错。在这种情况下，它将引发 MultipleObjectsReturned，它也是模型类本身的属性。

其他 QuerySet 方法¶

大多数情况下，您会使用 all()、get()、filter() 和 exclude() 来从数据库中查找对象。但是，这远非全部；请参阅 QuerySet API 参考 以获取所有 QuerySet 方法的完整列表。

限制 QuerySet¶

使用 Python 的数组切片语法的子集来将您的 QuerySet 限制为一定数量的结果。这相当于 SQL 的 LIMIT 和 OFFSET 子句。

例如，这将返回前 5 个对象 (LIMIT 5)

>>> Entry.objects.all()[:5]

这将返回第 6 到第 10 个对象 (OFFSET 5 LIMIT 5)

>>> Entry.objects.all()[5:10]

不支持负索引（即 Entry.objects.all()[-1]）。

通常，对 QuerySet 进行切片会返回一个新的 QuerySet，它不会执行查询。 唯一的例外是使用 Python 切片语法中的“步长”参数。 例如，这实际上会执行查询，以返回前 10 个对象中每个第二个对象的列表。

>>> Entry.objects.all()[:10:2]

由于这种操作的模糊性，禁止对切片后的 QuerySet 进行进一步的过滤或排序。

要检索单个对象而不是列表（例如 SELECT foo FROM bar LIMIT 1），请使用索引而不是切片。 例如，这将返回数据库中的第一个 Entry，在按标题字母顺序排序条目之后。

>>> Entry.objects.order_by("headline")[0]

这大致等同于

>>> Entry.objects.order_by("headline")[0:1].get()

但是，请注意，如果没有任何对象匹配给定的条件，第一个将引发 IndexError，而第二个将引发 DoesNotExist。 有关更多详细信息，请参阅 get()。

字段查找¶

字段查找是指定 SQL WHERE 子句内容的方式。 它们作为关键字参数指定给 QuerySet 方法 filter()、exclude() 和 get()。

基本查找关键字参数采用 field__lookuptype=value 的形式。（这是双下划线）。 例如

>>> Entry.objects.filter(pub_date__lte="2006-01-01")

大致转换为以下 SQL

SELECT * FROM blog_entry WHERE pub_date <= '2006-01-01';

在查找中指定的字段必须是模型字段的名称。不过，有一个例外，如果是 ForeignKey，您可以指定以 _id 结尾的字段名称。在这种情况下，value 参数应包含外键模型主键的原始值。例如

>>> Entry.objects.filter(blog_id=4)

如果您传递了无效的关键字参数，查找函数将引发 TypeError。

数据库 API 支持大约二十多种查找类型；完整的参考可以在 字段查找参考 中找到。为了让您了解可用的内容，以下是一些您可能会用到的更常见的查找

exact

“精确”匹配。例如

>>> Entry.objects.get(headline__exact="Cat bites dog")

将生成类似于以下的 SQL

SELECT ... WHERE headline = 'Cat bites dog';

如果您没有提供查找类型 - 也就是说，您的关键字参数不包含双下划线 - 则查找类型被假定为 exact。

例如，以下两个语句是等效的

>>> Blog.objects.get(id__exact=14)  # Explicit form
>>> Blog.objects.get(id=14)  # __exact is implied

这是为了方便，因为 exact 查找是最常见的情况。

iexact

不区分大小写的匹配。因此，查询

>>> Blog.objects.get(name__iexact="beatles blog")

将匹配标题为 "Beatles Blog"、"beatles blog" 甚至 "BeAtlES blOG" 的 Blog。

contains

区分大小写的包含测试。例如

Entry.objects.get(headline__contains="Lennon")

大致转换为以下 SQL

SELECT ... WHERE headline LIKE '%Lennon%';

请注意，这将匹配标题 'Today Lennon honored' 但不匹配 'today lennon honored'。

还有一个不区分大小写的版本，icontains。

startswith，endswith

分别进行以...开头和以...结尾的搜索。还有不区分大小写的版本，称为 istartswith 和 iendswith。

再次强调，这仅仅是皮毛。完整的参考可以在 字段查找参考 中找到。

跨越关系的查找¶

Django 提供了一种强大且直观的“跟随”关系查找方法，在幕后自动处理 SQL 的 JOIN。要跨越关系，请使用跨模型的相关字段名称，用双下划线分隔，直到到达您想要的字段。

此示例检索所有 Entry 对象，这些对象具有 Blog，其 name 为 'Beatles Blog'

>>> Entry.objects.filter(blog__name="Beatles Blog")

这种跨越可以像您想要的那样深。

它也可以反向工作。虽然它 can be customized，但默认情况下，您在查找中使用模型的小写名称来引用“反向”关系。

此示例检索所有 Blog 对象，这些对象至少有一个 Entry，其 headline 包含 'Lennon'

>>> Blog.objects.filter(entry__headline__contains="Lennon")

如果您正在跨多个关系进行过滤，并且其中一个中间模型没有满足过滤条件的值，Django 将将其视为存在一个空（所有值均为 NULL），但有效的对象。这意味着不会引发错误。例如，在此过滤器中

Blog.objects.filter(entry__authors__name="Lennon")

（如果存在相关的 Author 模型），如果条目没有关联的 author，则将其视为也没有关联的 name，而不是由于缺少 author 而引发错误。通常，这正是您希望发生的事情。唯一可能令人困惑的情况是，当您使用 isnull 时。因此

Blog.objects.filter(entry__authors__name__isnull=True)

将返回 Blog 对象，这些对象在 author 上具有空的 name，以及在 entry 上具有空的 author 的对象。如果您不想要这些后面的对象，您可以编写

Blog.objects.filter(entry__authors__isnull=False, entry__authors__name__isnull=True)

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
)

>>> from datetime import date
>>> beatles = Blog.objects.create(name="Beatles Blog")
>>> pop = Blog.objects.create(name="Pop Music Blog")
>>> Entry.objects.create(
...     blog=beatles,
...     headline="New Lennon Biography",
...     pub_date=date(2008, 6, 1),
... )
<Entry: New Lennon Biography>
>>> Entry.objects.create(
...     blog=beatles,
...     headline="New Lennon Biography in Paperback",
...     pub_date=date(2009, 6, 1),
... )
<Entry: New Lennon Biography in Paperback>
>>> Entry.objects.create(
...     blog=pop,
...     headline="Best Albums of 2008",
...     pub_date=date(2008, 12, 15),
... )
<Entry: Best Albums of 2008>
>>> Entry.objects.create(
...     blog=pop,
...     headline="Lennon Would Have Loved Hip Hop",
...     pub_date=date(2020, 4, 1),
... )
<Entry: Lennon Would Have Loved Hip Hop>
>>> Blog.objects.filter(
...     entry__headline__contains="Lennon",
...     entry__pub_date__year=2008,
... )
<QuerySet [<Blog: Beatles Blog>]>
>>> Blog.objects.filter(
...     entry__headline__contains="Lennon",
... ).filter(
...     entry__pub_date__year=2008,
... )
<QuerySet [<Blog: Beatles Blog>, <Blog: Beatles Blog>, <Blog: Pop Music Blog]>

Blog.objects.exclude(
    entry__headline__contains="Lennon",
    entry__pub_date__year=2008,
)

Blog.objects.exclude(
    entry__in=Entry.objects.filter(
        headline__contains="Lennon",
        pub_date__year=2008,
    ),
)

过滤器可以引用模型上的字段¶

在迄今为止给出的示例中，我们构建了将模型字段的值与常量进行比较的过滤器。但是，如果您想将模型字段的值与同一模型上的另一个字段进行比较怎么办？

Django 提供了 F expressions 来允许这种比较。 F() 的实例充当查询中模型字段的引用。然后，这些引用可以在查询过滤器中使用，以比较同一模型实例上的两个不同字段的值。

例如，要查找所有评论数量超过 pingback 数量的博客条目列表，我们构建一个 F() 对象来引用 pingback 计数，并在查询中使用该 F() 对象

>>> from django.db.models import F
>>> Entry.objects.filter(number_of_comments__gt=F("number_of_pingbacks"))

Django 支持使用加法、减法、乘法、除法、模运算和幂运算与 F() 对象一起使用，无论是与常量还是与其他 F() 对象一起使用。要查找所有评论数量超过 pingback 数量两倍的博客条目，我们修改查询

>>> Entry.objects.filter(number_of_comments__gt=F("number_of_pingbacks") * 2)

要查找条目评分低于 pingback 计数和评论计数之和的所有条目，我们将发出以下查询

>>> Entry.objects.filter(rating__lt=F("number_of_comments") + F("number_of_pingbacks"))

您也可以使用双下划线符号来跨越 F() 对象中的关系。带有双下划线的 F() 对象将引入访问相关对象所需的任何连接。例如，要检索所有作者姓名与博客名称相同的条目，我们可以发出以下查询

>>> Entry.objects.filter(authors__name=F("blog__name"))

对于日期和日期/时间字段，您可以添加或减去一个 timedelta 对象。以下将返回所有在发布后 3 天以上修改的条目

>>> from datetime import timedelta
>>> Entry.objects.filter(mod_date__gt=F("pub_date") + timedelta(days=3))

F() 对象通过 .bitand()、.bitor()、.bitxor()、.bitrightshift() 和 .bitleftshift() 支持按位运算。例如

>>> F("somefield").bitand(16)

表达式可以引用转换¶

Django 支持在表达式中使用转换。

例如，要查找所有在发布年份与最后修改年份相同的 Entry 对象

>>> from django.db.models import F
>>> Entry.objects.filter(pub_date__year=F("mod_date__year"))

要查找条目发布的最早年份，我们可以发出以下查询

>>> from django.db.models import Min
>>> Entry.objects.aggregate(first_published_year=Min("pub_date__year"))

此示例查找每年的最高评分条目的值以及所有条目的评论总数

>>> from django.db.models import OuterRef, Subquery, Sum
>>> Entry.objects.values("pub_date__year").annotate(
...     top_rating=Subquery(
...         Entry.objects.filter(
...             pub_date__year=OuterRef("pub_date__year"),
...         )
...         .order_by("-rating")
...         .values("rating")[:1]
...     ),
...     total_comments=Sum("number_of_comments"),
... )

pk 查找快捷方式¶

为了方便起见，Django 提供了一个 pk 查找快捷方式，它代表“主键”。

在示例 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

pk 的使用并不局限于 __exact 查询 - 任何查询项都可以与 pk 组合以对模型的主键执行查询

# 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)

pk 查找也适用于跨连接。例如，以下三个语句是等效的

>>> 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.objects.filter(headline__contains="%")

Django 会为您处理引号；生成的 SQL 将类似于以下内容

SELECT ... WHERE headline LIKE '%\%%';

下划线也是如此。百分号和下划线都将为您透明地处理。

缓存和 QuerySet¶

每个 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()])

这意味着相同的数据库查询将被执行两次，有效地使您的数据库负载加倍。此外，这两个列表可能不包含相同的数据库记录，因为在两次请求之间可能添加或删除了 Entry。

为了避免这个问题，请保存 QuerySet 并重复使用它

>>> queryset = Entry.objects.all()
>>> print([p.headline for p in queryset])  # Evaluate the query set.
>>> print([p.pub_date for p in queryset])  # Reuse 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)

查询迭代¶

使用 for 迭代查询的默认方式，会在后台导致一个阻塞数据库查询，因为 Django 会在迭代时加载结果。要解决这个问题，你可以切换到 async for

async for entry in Authors.objects.filter(name__startswith="A"):
    ...

请注意，你不能做其他可能迭代查询集的事情，例如将 list() 包裹在它周围以强制其评估（如果你想，可以在理解中使用 async for）。

因为 QuerySet 方法（如 filter() 和 exclude()）实际上并没有运行查询 - 它们只是设置了在迭代时运行的查询集 - 你可以在异步代码中自由使用它们。有关哪些方法可以像这样继续使用，以及哪些方法有异步版本的指南，请阅读下一节。

QuerySet 和管理器方法¶

关于管理器和查询集的一些方法 - 例如 get() 和 first() - 会强制执行查询集，并导致阻塞。一些方法，比如 filter() 和 exclude()，不会强制执行，因此可以在异步代码中安全地运行。但是，你如何区分它们呢？

虽然你可以尝试查找是否有以 a 开头的版本（例如，我们有 aget() 但没有 afilter()），但有一个更逻辑的方法 - 在 QuerySet 参考 中查找它是什么类型的函数。

在那里，你会发现 QuerySets 上的方法被分为两部分

• 返回新查询集的方法：这些是非阻塞方法，没有异步版本。你可以在任何情况下自由使用它们，但使用它们之前请阅读关于 defer() 和 only() 的说明。
• 不返回查询集的方法：这些是阻塞方法，并且有异步版本 - 每个方法的异步名称在其文档中都有说明，但我们的标准模式是在前面添加一个 a 前缀。

使用这种区别，你可以判断何时需要使用异步版本，何时不需要。例如，这是一个有效的异步查询

user = await User.objects.filter(username=my_input).afirst()

filter() 返回一个查询集，因此在异步环境中继续链式调用它是可以的，而 first() 会进行评估并返回一个模型实例 - 因此，我们改为 afirst()，并在整个表达式的前面使用 await，以便以异步友好的方式调用它。

事务¶

目前，不支持异步查询和更新的事务。你会发现尝试使用事务会引发 SynchronousOnlyOperation 错误。

如果您希望使用事务，建议您将 ORM 代码写入单独的同步函数中，然后使用 sync_to_async 调用该函数 - 请参阅 异步支持 了解更多信息。

存储和查询 None¶

与其他字段一样，将 None 存储为字段的值将将其存储为 SQL NULL。虽然不推荐，但可以使用 Value(None, JSONField()) 将 JSON 标量 null 存储为 SQL NULL。

无论存储哪个值，从数据库中检索时，JSON 标量 null 的 Python 表示形式与 SQL NULL 相同，即 None。因此，很难区分它们。

这仅适用于 None 作为字段的顶层值。如果 None 位于 list 或 dict 中，它将始终被解释为 JSON null。

在查询时，None 值将始终被解释为 JSON null。要查询 SQL NULL，请使用 isnull

>>> Dog.objects.create(name="Max", data=None)  # SQL NULL.
<Dog: Max>
>>> Dog.objects.create(name="Archie", data=Value(None, JSONField()))  # JSON null.
<Dog: Archie>
>>> Dog.objects.filter(data=None)
<QuerySet [<Dog: Archie>]>
>>> Dog.objects.filter(data=Value(None, JSONField()))
<QuerySet [<Dog: Archie>]>
>>> Dog.objects.filter(data__isnull=True)
<QuerySet [<Dog: Max>]>
>>> Dog.objects.filter(data__isnull=False)
<QuerySet [<Dog: Archie>]>

除非您确定要使用 SQL NULL 值，否则请考虑设置 null=False 并为空值提供合适的默认值，例如 default=dict。

键、索引和路径转换¶

要根据给定的字典键进行查询，请使用该键作为查找名称

>>> Dog.objects.create(
...     name="Rufus",
...     data={
...         "breed": "labrador",
...         "owner": {
...             "name": "Bob",
...             "other_pets": [
...                 {
...                     "name": "Fishy",
...                 }
...             ],
...         },
...     },
... )
<Dog: Rufus>
>>> Dog.objects.create(name="Meg", data={"breed": "collie", "owner": None})
<Dog: Meg>
>>> Dog.objects.filter(data__breed="collie")
<QuerySet [<Dog: Meg>]>

可以将多个键链接在一起以形成路径查找

>>> Dog.objects.filter(data__owner__name="Bob")
<QuerySet [<Dog: Rufus>]>

如果键是整数，它将被解释为数组中的索引转换

>>> Dog.objects.filter(data__owner__other_pets__0__name="Fishy")
<QuerySet [<Dog: Rufus>]>

如果您要查询的键与另一个查找的名称冲突，请使用 contains 查找。

要查询缺少的键，请使用 isnull 查找

>>> Dog.objects.create(name="Shep", data={"breed": "collie"})
<Dog: Shep>
>>> Dog.objects.filter(data__owner__isnull=True)
<QuerySet [<Dog: Shep>]>

包含和键查找¶

>>> Dog.objects.create(name="Rufus", data={"breed": "labrador", "owner": "Bob"})
<Dog: Rufus>
>>> Dog.objects.create(name="Meg", data={"breed": "collie", "owner": "Bob"})
<Dog: Meg>
>>> Dog.objects.create(name="Fred", data={})
<Dog: Fred>
>>> Dog.objects.filter(data__contains={"owner": "Bob"})
<QuerySet [<Dog: Rufus>, <Dog: Meg>]>
>>> Dog.objects.filter(data__contains={"breed": "collie"})
<QuerySet [<Dog: Meg>]>

>>> Dog.objects.create(name="Rufus", data={"breed": "labrador", "owner": "Bob"})
<Dog: Rufus>
>>> Dog.objects.create(name="Meg", data={"breed": "collie", "owner": "Bob"})
<Dog: Meg>
>>> Dog.objects.create(name="Fred", data={})
<Dog: Fred>
>>> Dog.objects.filter(data__contained_by={"breed": "collie", "owner": "Bob"})
<QuerySet [<Dog: Meg>, <Dog: Fred>]>
>>> Dog.objects.filter(data__contained_by={"breed": "collie"})
<QuerySet [<Dog: Fred>]>

>>> Dog.objects.create(name="Rufus", data={"breed": "labrador"})
<Dog: Rufus>
>>> Dog.objects.create(name="Meg", data={"breed": "collie", "owner": "Bob"})
<Dog: Meg>
>>> Dog.objects.filter(data__has_key="owner")
<QuerySet [<Dog: Meg>]>

>>> Dog.objects.create(name="Rufus", data={"breed": "labrador"})
<Dog: Rufus>
>>> Dog.objects.create(name="Meg", data={"breed": "collie", "owner": "Bob"})
<Dog: Meg>
>>> Dog.objects.filter(data__has_keys=["breed", "owner"])
<QuerySet [<Dog: Meg>]>

>>> Dog.objects.create(name="Rufus", data={"breed": "labrador"})
<Dog: Rufus>
>>> Dog.objects.create(name="Meg", data={"owner": "Bob"})
<Dog: Meg>
>>> Dog.objects.filter(data__has_any_keys=["owner", "breed"])
<QuerySet [<Dog: Rufus>, <Dog: Meg>]>

一对多关系¶

>>> e = Entry.objects.get(id=2)
>>> e.blog  # Returns the related Blog object.

>>> e = Entry.objects.get(id=2)
>>> e.blog = some_blog
>>> e.save()

>>> 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)  # Hits the database to retrieve the associated Blog.
>>> print(e.blog)  # Doesn't hit the database; uses cached version.

>>> e = Entry.objects.select_related().get(id=2)
>>> print(e.blog)  # Doesn't hit the database; uses cached version.
>>> print(e.blog)  # Doesn't hit the database; uses cached version.

>>> b = Blog.objects.get(id=1)
>>> b.entry_set.all()  # Returns all Entry objects related to Blog.

# b.entry_set is a Manager that returns QuerySets.
>>> b.entry_set.filter(headline__contains="Lennon")
>>> b.entry_set.count()

>>> 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()

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()

b.entry_set(manager="entries").is_published()

from django.db.models import Prefetch

prefetch_manager = Prefetch("entry_set", queryset=Entry.entries.all())
Blog.objects.prefetch_related(prefetch_manager)

b = Blog.objects.get(id=1)
b.entry_set.set([e1, e2])

多对多关系¶

多对多关系的两端都将自动获得对另一端的 API 访问权限。API 的工作方式类似于上面描述的“反向”一对多关系。

一个区别在于属性命名：定义 ManyToManyField 的模型使用该字段本身的属性名，而“反向”模型使用原始模型的小写模型名，加上 '_set'（就像反向一对多关系一样）。

一个例子可以更容易地理解这一点

e = Entry.objects.get(id=3)
e.authors.all()  # Returns all Author objects for this Entry.
e.authors.count()
e.authors.filter(name__contains="John")

a = Author.objects.get(id=5)
a.entry_set.all()  # Returns all Entry objects for this Author.

与 ForeignKey 一样，ManyToManyField 可以指定 related_name。在上面的例子中，如果 Entry 中的 ManyToManyField 指定了 related_name='entries'，那么每个 Author 实例将具有一个 entries 属性，而不是 entry_set。

与一对多关系不同的是，除了模型实例之外，多对多关系上的 add()、set() 和 remove() 方法也接受主键值。例如，如果 e1 和 e2 是 Entry 实例，那么这些 set() 调用将以相同的方式工作

a = Author.objects.get(id=5)
a.entry_set.set([e1, e2])
a.entry_set.set([e1.pk, e2.pk])

一对一关系¶

一对一关系与多对一关系非常相似。如果您在模型上定义了一个 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 中列出的应用程序中。否则，反向关系可能无法正常工作。

查询相关对象¶

涉及相关对象的查询遵循与涉及普通值字段的查询相同的规则。在指定要匹配的查询值时，您可以使用对象实例本身或对象的 primary key 值。

例如，如果您有一个 Blog 对象 b，其 id=5，则以下三个查询将是相同的

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