建立表关系

显然，关系型数据库的强大之处就在于将表相互关联，Django提供了定义三种最常见的数据库关系类型的方法：多对一、多对多和一对一。

一、表关系之多对一

1、多对一关系

要定义一个多对一关系，需要使用django.db.models.ForeignKey。您可以像使用任何其他字段类型一样去使用它：将其作为模型的类属性

# ForeignKey的参数：
1、to：所关联的模型类
 
2、to_field: 设置要关联表的字段
3、related_name: 此处暂且忽略，会在后续章节专门介绍
4、related_query_name: 此处暂且忽略，会在后续章节专门介绍
5、db_constraint：是否在数据库中创建外键约束，默认为True。
 
6、on_delete：当删除关联表中的数据时，当前表与其关联的行的行为，值可以是如下
　　models.CASCADE
　　删除关联数据，与之关联也删除
 
　　models.DO_NOTHING
　　删除关联数据，引发错误IntegrityError
 
　　models.PROTECT
　　删除关联数据，引发错误ProtectedError
 
　　models.SET_NULL
　　删除关联数据，与之关联的值设置为null（前提FK字段需要设置为可空）
 
　　models.SET_DEFAULT
　　删除关联数据，与之关联的值设置为默认值（前提FK字段需要设置默认值）
 
　　models.SET(值)
　　删除关联数据，与之关联的值设置为指定值
 
   models.SET(可执行对象)
　　删除关联数据，与之关联的值设置为可执行对象的返回值，例如
   def func():
       return 10
 
   class MyModel(models.Model):
       user = models.ForeignKey(
            to="User",
            to_field="id"，
            on_delete=models.SET(func)
       )

				

					
				
				

					
				
				

					
				
				

					
				
			

例如：

from django.db import models
 
class Manufacturer(models.Model):  # 汽车制造商
    # ...
    pass
 
class Car(models.Model):  # 汽车
    manufacturer = models.ForeignKey(to=Manufacturer, on_delete=models.CASCADE)
    # ...

				

					
				
				

					
				
				

					
				
				

					
				
			

建议（但不是必需的）ForeignKey字段的名称是模型的名称、小写（如上述manufacturer），这么做是为了在后期进行查询操作时方便自己识别。当然，你想叫什么就叫什么。例如：

class Car(models.Model):
    company_that_makes_it = models.ForeignKey(
        Manufacturer,
        on_delete=models.CASCADE,
    )
    # ...

				

					
				
				

					
				
				

					
				
				

					
				
			

*2、惰性关系*

上述关联关系的建立，由于ForeignKey的第一个位置参数是模型类，所以模型Car必须在Manufacturer之后，若想排除先后顺序带来的困扰，即需要创建与尚未定义的模型类的关系，可以将ForeignKey的第一个参数换成字符串形式，如下所示，这种定义关系的形式，称之为惰性关系

from django.db import models
 
class Car(models.Model):
    manufacturer = models.ForeignKey('Manufacturer', on_delete=models.CASCADE)
    # ...
 
class Manufacturer(models.Model):
    # ...
    pass

				

					
				
				

					
				
				

					
				
				

					
				
			

*3、自关联*

class Comment(models.Model):
    # 评论者
    user=models.ForeignKey(to='User',to_field='nid',on_delete=models.CASCADE)
    # 评论的文章
    article=models.ForeignKey(to='Article',to_field='nid',on_delete=models.CASCADE)
    # 评论的内容
    content=models.CharField(max_length=255)
    # 评论时间
    create_time=models.DateTimeField(auto_now_add=True)
    # 自关联
    parent_comment=models.ForeignKey(to='self',on_delete=models.CASCADE,null=True)

				

					
				
				

					
				
				

					
				
				

					
				
			

*4、其他*

# 1、数据库表示：
默认情况下，在数据库层面，django会在ForeignKey的字段后加后缀“_id”，即上述模型字段manufacturer对应的数据库表字段为manufacturer_id（我们可以用过db_column选项来进行自定义）
 
但是，我们在操作模型时只需要基于模型字段名字即可，只有在编写原生sql时才需要考虑数据库里的字段。
 
# 2、db_index
django会自动为ForeignKey字段创建索引，可以指定db_index=False来禁用此功能。
 
如果我们创建外键的目的是为了一致性而不是链接，或者你需要使用自定义的部分或多列索引，那么需要将db_index设置为False
 
# 3、ForeignKey的其他详细参数
https://docs.djangoproject.com/en/3.0/ref/models/fields/#arguments

				

					
				
				

					
				
				

					
				
				

					
				
			

二、表关系之多对多

*1、多对多关系*

定义多对多关系，需要使用ManyToManyField，您同样可以像使用任何其他字段类型一样去使用它：将其作为模型的类属性

# ManyToManyField参数：
1、to：所关联的模型类
 
2、to_field: 设置要关联表的字段
3、related_name: 同ForeignKey，此处暂且忽略，会在后续章节专门介绍
4、related_query_name: 同ForeignKey，此处暂且忽略，会在后续章节专门介绍
5、db_constraint：是否在数据库中创建外键约束，默认为True。
6、db_table: 默认创建第三张表时，数据库中该表的名称。
 
7、symmetrical：默认为True，此处暂且忽略，会在后续章节专门介绍
8、through: 详见本节"3、多对多额外的字段：中间模型"
9、through_fileds：详见本节"3、多对多额外的字段：中间模型"
 
# MannyToMany的其他详细参数：https://docs.djangoproject.com/en/3.0/ref/models/fields/#manytomany-arguments

				

					
				
				

					
				
				

					
				
				

					
				
			

例如

from django.db import models
 
class Topping(models.Model): # 馅料
    # ...
    pass
 
class Pizza(models.Model): # 披萨
    # ...
    toppings = models.ManyToManyField(Topping)
 
# 数据库表示：
在幕后，Django创建一个中间连接表来表示多对多关系。默认情况下，此表名是：包含该字段的模型的表名_多对多字段的名称。可以使用db_table选项手动设置连接表的名称。

				

					
				
				

					
				
				

					
				
				

					
				
			

建议（但不是必须）ManyToMany的字段名称（上例中的toppings）是一个关联的模型类名字的复数形式，用于描述相关模型对象集。

针对ManyToMany字段，只要不是同时放入两个模型中，在哪个模型中创建并不重要，但是通常情况下我们需要考虑逻辑上的通顺已经后期的使用方便，字段与类是一个从属关系，toppings字段在类Pizza里，我们可以说Pizza拥有toppings，翻译一下就是披萨有馅料，显而易见这比在Topping类里放入MannyToMany字段，逻辑上更通顺，从而使得后期的使用更为方便

*2、惰性关系*

同ForeignKey一样

*3、多对多额外的字段：中间模型*

使用标准的ManyToManyField创建多对多关系时，会自动生成第三张关系表，而关系表中只存放了最基本的数据，即两个模型的关联关系，大多数情况下这是没问题的，如下

from django.db import models
 
class Book(models.Model):
    title = models.CharField(max_length=32)
 
class Author(models.Model):
    name = models.CharField(max_length=32)
    books = models.ManyToManyField(to="Book")
 
# 会自动生成第三张表，用来存放基本的关联关系，转换成类似下面的sql
create table book(id int primary key);
create table author(id int primary key);
 
create table app01_author_books(
    id int primary key auto_increment,
    author_id int,
    book_id int,
    foreign key(author_id) references Author(id) on delete cascade,
    foreign key(book_id) references Book(id) on delete cascade,
    unique(author_id,book_id)
);

				

					
				
				

					
				
				

					
				
				

					
				
			

但如果我们需要在两个模型的多对多关系上添加额外的数据（比如有这样一个应用，它记录音乐家Person所属的音乐小组Group。我们想在多对多关系的基础上，知道更多成员关系的细节，比如成员是何时加入小组的,加入的理由是什么），
就需要我们自定义第三张关系表了，你可能会想到这么做

from django.db import models
 
class Person(models.Model):
    name = models.CharField(max_length=128)
 
class Group(models.Model):
    name = models.CharField(max_length=128)
 
class Membership(models.Model):
    person = models.ForeignKey(Person, on_delete=models.CASCADE)
    group = models.ForeignKey(Group, on_delete=models.CASCADE)
    date_joined = models.DateTimeField(auto_now_add=True)
    invite_reason = models.CharField(max_length=64)
 
    class Meta:
        # 指定本模型中的两个字段person与group联合唯一
        unique_together = ("person", "group")

				

					
				
				

					
				
				

					
				
				

					
				
			

此时第三张表便是一张完全独立的表，这本身是没有问题的，但Person与Group与其关系表Membership
完全独立开意味着我们将无法使用django提供的关联查询功能，为此，django提供了一种改进方案:"使用through参数指定中间模型"，如下

class Person(models.Model):
    name = models.CharField(max_length=128)
 
class Group(models.Model):
    name = models.CharField(max_length=128)
    members = models.ManyToManyField(Person, through='Membership',through_fields=('group','person'))
 
    """
    through='Membership',指定中间模型为Membership
    如果中介模型Membership中有多个外键都指向同一个模型，那么必须指定through_fields参数说明关联的两个字段是谁，比如through_fields=('person','group'),
    元组内第一个字段代表定义ManyToManyFiled的那个模型（此处为Group）对应的外键名称（此处为'group'），而元组的第二个字段代表目标模型（此处为Person）对应的外键名称（此处为'person'），切记顺序不可乱
    """
 
class Membership(models.Model): # 称之为：中间模型/中介模型
    person = models.ForeignKey(Person, on_delete=models.CASCADE)
    group = models.ForeignKey(Group, on_delete=models.CASCADE)
    date_joined = models.DateTimeField(auto_now_add=True)
    invite_reason = models.CharField(max_length=64)
 
# ===========================
这样Group便可以通过字段members进行正向查询，Person便可以通过模型名group进行反向
查询了
 
>>> p1=Person(name='牛逼鼓手小egon')
>>> p2=Person(name='骚浪吉他手刘二蛋')
>>> p1.save()
>>> p2.save()
 
>>> g1=Group(name="狂拽炫酷屌炸天乐队")
>>> g2=Group(name="疯狂的唢呐乐队")
>>> g1.save()
>>> g2.save()
 
#当我们使用第上述方式创建多对多关联关系时，就无法使用set、add、remove、clear方法来管理多对多的关系了，需要通过第三张表的model来管理多对多关系。
>>> Membership.objects.create(person=p1,group=g1,invite_reason='需要一名牛逼的鼓手')
<Membership: Membership object (1)>
>>> Membership.objects.create(person=p2,group=g1,invite_reason='需要一名骚浪吉他手')
<Membership: Membership object (2)>
>>> Membership.objects.create(person=p2,group=g2,invite_reason='需要一名骚浪吉他手')
<Membership: Membership object (2)>
 
>>> g1.members.all()
<QuerySet [<Person: 牛逼鼓手小egon>, <Person: 骚浪吉他手刘二蛋>]>
>>> g2.members.all()
<QuerySet [<Person: 骚浪吉他手刘二蛋>]>
>>> 
>>> p1.group_set.all()
<QuerySet [<Group: 狂拽炫酷屌炸天乐队>]>
>>> p2.group_set.all()
<QuerySet [<Group: 狂拽炫酷屌炸天乐队>, <Group: 疯狂的唢呐乐队>]>
 
#clear()方法却是可用的。它可以清空某个实例所有的多对多关系：
>>> g1.members.clear()
>>> p1.group_set.all()
<QuerySet []>
>>> p2.group_set.all()
<QuerySet [<Group: 疯狂的唢呐乐队>]>

				

					
				
				

					
				
				

					
				
				

					
				
			

*4、自关联*

自己跟自己关联，默认是数据是对称的

class Person(models.Model):
    id=models.AutoField(primary_key=True)
    name=models.CharField(max_length=30,null=True)
    friends=models.ManyToManyField('self')
 
>>> obj1=Person(name='egon')
>>> obj2=Person(name='tom')
>>> obj1.save()
>>> obj2.save()
>>> obj1.friends.add(obj2)
朋友关系表里会对称着，有两条记录
 
数据库表里app01_person_friends
id       from_person_id          to_person_id
1                1                    2
2                2                    1
 
可以指定参数symmetrical=False，来关闭对称
class Person(models.Model):
    id=models.AutoField(primary_key=True)
    name=models.CharField(max_length=30,null=True)
    friends=models.ManyToManyField('self',symmetrical=False)
 
如果是自关联， 并且定制了中间模型，那么必须设置symmetrical=False
class Person(models.Model):
    id=models.AutoField(primary_key=True)
    name=models.CharField(max_length=30,null=True)
    friends=models.ManyToManyField('self',through='PersonShip',symmetrical=False,through_fields=('t_friend','f_friend'))
 
class PersonShip(models.Model):
    create_time=models.DateTimeField(auto_now_add=True)
    f_friend=models.ForeignKey('Person',on_delete=models.CASCADE,)
    t_friend=models.ForeignKey('Person',on_delete=models.CASCADE,related_name='aaaa')

				

					
				
				

					
				
				

					
				
				

					
				
			

三、表关系之一对一

*1、一对一关系*

定义一对一关系，需要使用OneToOneField.您同样可以像使用任何其他字段类型一样去使用它：将其作为模型的类属性

# OneToOneField参数
1、to：所关联的模型类
 
2、to_field: 设置要关联表的字段
 
3、on_delete：同ForeignKey

				

					
				
				

					
				
				

					
				
				

					
				
			

示例

class visitor(models.Model):  # 访客
    pass
 
class Customer(models.Model):  # 客户
    visitor = models.OneToOneField(to='visitor', on_delete=models.CASCADE)
    # 也可以写成
    # visitor = models.ForeignKey(to='visitor', unique=True, on_delete=models.CASCADE)

				

					
				
				

					
				
				

					
				
				

					
				
			

OneToOneField就是在ForeignKey的基础上设置一个unique=True,只不过反向查询出的结果就一个对象，因为本质与ForeignKey类似，所以注意on_delete也是要加的。

ps：因为一对一满足“是”的关系，所以事实上，为了处理这个问题，你通常会使用继承，其中就已经包含一个隐含的一对一关系）。

*2、惰性关系*

同ForeignKey一样

*3、自关联*

同ForeignKey一样

*4、其他*

*# 注意*
现在可以在一个模型上有多个OneToOneField类型的字段。
在以前的版本中，OneToOneField 字段会自动变成模型 的主键。 不过现在已经不这么做了(不过要是你愿意的话，你仍可以传递 primary_key参数来创建主键字段)。 所以一个模型中可以有多个OneToOneField 字段。

四、跨文件建立模型关系

与另外一个app中的模型建立关联是完全可以的，如何实现呢？
在我们定义模型的文件顶部导入其他app的模型，然后在需要的地方进行关联即可，如下
# app01下的models.py
from django.db import models
from app02.models import ZipCode
 
class Restaurant(models.Model):
    # ...
    zip_code = models.ForeignKey(
        ZipCode,
        on_delete=models.SET_NULL,
        blank=True,
        null=True,
    )