Django丨模版层 - 3. 关系类型字段

发表于2020-10-20更新于2020-10-20字数统计3.2k阅读次数

3. 关系类型字段

除了普通类型字段，Django还定义了一组关系类型字段，用来表示模型与模型之间的关系。

1. 一对多（ForeignKey）

一对多的关系，通常被称为外键。外键字段类的定义如下：

1
class ForeignKey(to, on_delete, **options)

  • 外键需要两个位置参数

    • 一个是关联的模型
    • 另一个是on_delete。在Django2.0版本后，on_delete属于必填参数

  • 可选参数，下面介绍较为常用的几个：

    • to_field： 设置关联到主表的字段，例如，
      • models.ForeignKey('Coding', to_field=Coding.text)
      • 注意：关联字段的内容必须是不重复的。在默认情况下，Django 关联到的字段是主表的主键（成为主键的要求之一就是不重复）
    • related_name：自定义一个名称，用于反向查询
      • 当一张子表里，多个foreignkey指向同一个主表，related_name必须设置。

  • on_delete参数说明：

当一个外键关联的对象被删除时，Django将模仿on_delete参数定义的SQL约束执行相应操作。比如，你有一个可为空的外键，并且你想让它在关联的对象被删除时，自动设为null，可以如下定义：

1
2
3
4
5
6
user = models.ForeignKey(
    User,
    on_delete=models.SET_NULL,
    blank=True,
    null=True,
)

该参数可选的值都内置在django.db.models中（全部为大写），包括：

  • CASCADE：模拟SQL语言中的ON DELETE CASCADE约束，将定义有外键的模型对象同时删除！
  • PROTECT：阻止上面的删除操作，但是弹出ProtectedError异常
  • SET_NULL：将外键字段设为null，只有当字段设置了null=True时，方可使用该值。
  • SET_DEFAULT：将外键字段设为默认值。只有当字段设置了default参数时，方可使用。
  • DO_NOTHING：什么也不做。
  • SET()：设置为一个传递给SET()的值或者一个回调函数的返回值。注意大小写。
1
2
3
4
5
6
7
8
9
10
11
12
from django.conf import settings
from django.contrib.auth import get_user_model
from django.db import models

def get_sentinel_user():
    return get_user_model().objects.get_or_create(username='deleted')[0]

class MyModel(models.Model):
    user = models.ForeignKey(
        settings.AUTH_USER_MODEL,
        on_delete=models.SET(get_sentinel_user),
    )
  • RESTRICT：Django3.1新增。这个模式比较难以理解。它与PROTECT不同，在大多数情况下，同样不允许删除，但是在某些特殊情况下，却是可以删除的。看下面的例子，多揣摩一下：
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    # 假设有这样的三个模型以及外键关系

    class Artist(models.Model):
        name = models.CharField(max_length=10)

    class Album(models.Model):
        artist = models.ForeignKey(Artist, on_delete=models.CASCADE)  # 注意这里

    class Song(models.Model):
        artist = models.ForeignKey(Artist, on_delete=models.CASCADE) # 注意这里
        album = models.ForeignKey(Album, on_delete=models.RESTRICT) # 注意这里

尝试在Django的shell里测试下面的API：

1
2
3
4
5
6
7
8
9
10
11
12
>>> artist_one = Artist.objects.create(name='artist one')
>>> artist_two = Artist.objects.create(name='artist two')
>>> album_one = Album.objects.create(artist=artist_one)
>>> album_two = Album.objects.create(artist=artist_two)
>>> song_one = Song.objects.create(artist=artist_one, album=album_one)
>>> song_two = Song.objects.create(artist=artist_one, album=album_two)
>>> album_one.delete()
# Raises RestrictedError.  不可以删除
>>> artist_two.delete()
# Raises RestrictedError.   不可以删除
>>> artist_one.delete()
(4, {'Song': 2, 'Album': 1, 'Artist': 1})    # 居然可以删除

为什么artist_one可以被删除，但是artist_two不可以？Django设计的这个模式真的比较难以理解。

  • limit_choices_to参数说明：

该参数用于限制外键所能关联的对象，只能用于Django的ModelForm（Django的表单模块）和admin后台，对其它场合无限制功能。其值可以是一个字典、Q对象或者一个返回字典或Q对象的函数调用，如下例所示：

1
2
3
4
5
staff_member = models.ForeignKey(
    User,
    on_delete=models.CASCADE,
    limit_choices_to={'is_staff': True},
)

这样定义，则ModelForm的staff_member字段列表中，只会出现那些is_staff=True的Users对象，这一功能对于admin后台非常有用。

可以参考下面的方式，使用函数调用：

1
2
3
4
5
6
def limit_pub_date_choices():
    return {'pub_date__lte': datetime.date.utcnow()}

# ...
limit_choices_to = limit_pub_date_choices
# ...
  • related_name参数说明：

用于关联对象反向引用模型的名称。以前面车和工厂的例子解释，就是从工厂反向关联到车的关系名称。

通常情况下，这个参数我们可以不设置，Django会默认以模型的小写加上_set作为反向关联名，比如对于工厂就是car_set，如果你觉得car_set还不够直观，可以如下定义：

1
2
3
4
5
6
class Car(models.Model):
    manufacturer = models.ForeignKey(
        'production.Manufacturer',      
        on_delete=models.CASCADE,
        related_name='car_producted_by_this_manufacturer',  # 看这里！！
    )

也许我定义了一个蹩脚的词，但表达的意思很清楚。以后从工厂对象反向关联到它所生产的汽车，就可以使用maufacturer.car_producted_by_this_manufacturer了。

如果你不想为外键设置一个反向关联名称，可以将这个参数设置为“+”或者以“+”结尾，如下所示：

1
2
3
4
5
user = models.ForeignKey(
    User,
    on_delete=models.CASCADE,
    related_name='+',
)
  • related_query_name参数说明：

反向关联查询名。用于从目标模型反向过滤模型对象的名称。

这个参数的默认值是定义有外键字段的模型的小写名，如果设置了related_name参数，那么就是这个参数值，如果在此基础上还指定了related_query_name的值，则是related_query_name的值。三者依次有优先顺序。

要注意related_query_name和related_name的区别，前者用于在做查询操作时候作为参数使用，后者主要用于在属性调用时使用。

1
2
3
4
5
6
7
8
9
10
11
class Tag(models.Model):
    article = models.ForeignKey(
        Article,
        on_delete=models.CASCADE,
        related_name="tags",
        related_query_name="tag",       # 注意这一行
    )
    name = models.CharField(max_length=255)

# 现在可以使用‘tag’作为查询名了
Article.objects.filter(tag__name="important")
  • to_field参数说明：

默认情况下，外键都是关联到被关联对象的主键上（一般为id）。如果指定这个参数，可以关联到指定的字段上，但是该字段必须具有unique=True属性，也就是具有唯一属性。

  • db_constraint参数说明：

默认情况下，这个参数被设为True，表示遵循数据库约束，这也是大多数情况下你的选择。如果设为False，那么将无法保证数据的完整性和合法性。在下面的场景中，你可能需要将它设置为False：

有历史遗留的不合法数据，没办法的选择
你正在分割数据表

当它为False，并且你试图访问一个不存在的关系对象时，会抛出DoesNotExist异常。

  • swappable参数说明：

控制迁移框架的动作，如果当前外键指向一个可交换的模型。使用场景非常稀少，通常请将该参数保持默认的True。

2. 多对多（ManyToManyField）

1
class ManyToManyField(to, **options)

多对多关系在数据库中也是非常常见的关系类型。比如一本书可以有好几个作者，一个作者也可以写好几本书。多对多的字段可以定义在任何的一方，请尽量定义在符合人们思维习惯的一方，但不要同时都定义，只能选择一个模型设置该字段（比如我们通常将披萨上的配料字段放在披萨模型中，而不是在配料模型中放置披萨字段）。

1
2
3
4
5
6
7
8
9
from django.db import models

class Topping(models.Model):
    # ...
    pass

class Pizza(models.Model):
    # ...
    toppings = models.ManyToManyField(Topping)

建议为多对多字段名使用复数形式。

多对多关系需要一个位置参数：关联的对象模型，其它用法和外键多对一基本类似。

如果要创建一个关联自己的多对多字段，依然是通过self引用。

在数据库后台，Django实际上会额外创建一张用于体现多对多关系的中间表。默认情况下，该表的名称是多对多字段名 + 包含该字段的模型名 + 一个独一无二的哈希码，例如author_books_9cdf4，当然你也可以通过db_table选项，自定义表名。

  • 参数说明：

  • related_name参数说明：
    参考外键的相同参数。

  • related_query_name参数说明：
    参考外键的相同参数。

  • limit_choices_to参数说明：
    参考外键的相同参数。但是对于使用through参数自定义中间表的多对多字段无效。

  • symmetrical参数说明：
    默认情况下，Django中的多对多关系是对称的。看下面的例子：

1
2
3
4
from django.db import models

class Person(models.Model):
    friends = models.ManyToManyField("self")

Django认为，如果我是你的朋友，那么你也是我的朋友，这是一种对称关系，Django不会为Person模型添加person_set属性用于反向关联。如果你不想使用这种对称关系，可以将symmetrical设置为False，这将强制Django为反向关联添加描述符。

  • through参数说明：
    如果你想自定义多对多关系的那张额外的关联表，可以使用这个参数！参数的值为一个中间模型。

最常见的使用场景是你需要为多对多关系添加额外的数据，比如添加两个人建立QQ好友关系的时间。

通常情况下，这张表在数据库内的结构是这个样子的：

1
2
中间表的id列....模型对象的id列.....被关联对象的id列
# 各行数据

如果自定义中间表并添加时间字段，则在数据库内的表结构如下：

1
2
中间表的id列....模型对象的id列.....被关联对象的id列.....时间对象列
# 各行数据

看下面的例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
from django.db import models

class Person(models.Model):
    name = models.CharField(max_length=50)

class Group(models.Model):
    name = models.CharField(max_length=128)
    members = models.ManyToManyField(
        Person,
        through='Membership',       ## 自定义中间表
        through_fields=('group', 'person'),
    )

class Membership(models.Model):  # 这就是具体的中间表模型
    group = models.ForeignKey(Group, on_delete=models.CASCADE)
    person = models.ForeignKey(Person, on_delete=models.CASCADE)
    inviter = models.ForeignKey(
        Person,
        on_delete=models.CASCADE,
        related_name="membership_invites",
    )
    invite_reason = models.CharField(max_length=64)

上面的代码中，通过class Membership(models.Model)定义了一个新的模型，用来保存Person和Group模型的多对多关系，并且同时增加了邀请人和邀请原因的字段。

through参数在某些使用场景中是必须的，至关重要，请务必掌握！

  • through_fields参数说明：
    接着上面的例子。Membership模型中包含两个关联Person的外键，Django无法确定到底使用哪个作为和Group关联的对象。所以，在这个例子中，必须显式的指定through_fields参数，用于定义关系。

through_fields参数接收一个二元元组('field1', 'field2')，field1是指向定义有多对多关系的模型的外键字段的名称，这里是Membership中的‘group’字段（注意大小写），另外一个则是指向目标模型的外键字段的名称，这里是Membership中的‘person’，而不是‘inviter’。

再通俗的说，就是through_fields参数指定从中间表模型Membership中选择哪两个字段，作为关系连接字段。

  • db_table参数说明：
    设置中间表的名称。不指定的话，则使用默认值。

  • db_constraint参数说明：
    参考外键的相同参数。

  • swappable参数说明：
    参考外键的相同参数。

ManyToManyField多对多字段不支持Django内置的validators验证功能。

null参数对ManyToManyField多对多字段无效！设置null=True毫无意义

3. 一对一（OneToOneField）

一对一关系类型的定义如下：

1
class OneToOneField(to, on_delete, parent_link=False, **options)

从概念上讲，一对一关系非常类似具有unique=True属性的外键关系，但是反向关联对象只有一个。这种关系类型多数用于当一个模型需要从别的模型扩展而来的情况。比如，Django自带auth模块的User用户表，如果你想在自己的项目里创建用户模型，又想方便的使用Django的auth中的一些功能，那么一个方案就是在你的用户模型里，使用一对一关系，添加一个与auth模块User模型的关联字段。

该关系的第一位置参数为关联的模型，其用法和前面的多对一外键一样。

如果你没有给一对一关系设置related_name参数，Django将使用当前模型的小写名作为默认值。

看下面的例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
from django.conf import settings
from django.db import models

# 两个字段都使用一对一关联到了Django内置的auth模块中的User模型
class MySpecialUser(models.Model):
    user = models.OneToOneField(
        settings.AUTH_USER_MODEL,
        on_delete=models.CASCADE,
    )
    supervisor = models.OneToOneField(
        settings.AUTH_USER_MODEL,
        on_delete=models.CASCADE,
        related_name='supervisor_of',
    )

这样下来，你的User模型将拥有下面的属性：

1
2
3
4
5
>>> user = User.objects.get(pk=1)
>>> hasattr(user, 'myspecialuser')
True
>>> hasattr(user, 'supervisor_of')
True

OneToOneField一对一关系拥有和多对一外键关系一样的额外可选参数，只是多了一个不常用的parent_link参数。

跨模块的模型：

有时候，我们关联的模型并不在当前模型的文件内，没关系，就像我们导入第三方库一样的从别的模块内导入进来就好，如下例所示：

1
2
3
4
5
6
7
8
9
10
11
from django.db import models
from geography.models import ZipCode

class Restaurant(models.Model):
    # ...
    zip_code = models.ForeignKey(
        ZipCode,
        on_delete=models.SET_NULL,
        blank=True,
        null=True,
    )