7. Django 模型与数据库

第7章 模型与数据库

Django对各种数据库提供了很好的支持, 包括PostgreSQL, MySQL, SQLite和Oracle, 
而且为这些数据库提供了统一的API方法, 这些API统称为ORM框架.
通过使用Django内置的ORM框架可以实现数据库连接和读写操作.
本章以SQLite数据库为例, 分别讲述Django的模型定义与数据迁移, 数据表关系, 数据表操作和多数据库的连接与使用.

7.1 模型定义与数据迁移

本节讲述Django的模型定义, 开发个人的ORM框架, 数据迁移和数据导入与导出, 说明如下:
● 模型定义讲述了模型字段和模型属性的设置, 不同类型的模型字段对应不同的数据表字段.
  模型属性可用于Django其他功能模块, 如设置模型所属的App.
● 开发个人的ORM框架是从源码深入剖析Django的ORM框架底层原理, 并参考此原理实现个人的ORM框架的开发.
● 数据迁移是根据模型在数据库里创建相应的数据表, 
  这一过程由Django内置操作指令makemigrations和migrate实现, 此外还讲述数据迁移常见的错误以及其他数据迁移指令.
● 数据导入与导出是对数据表的数据执行导入与导出操作, 确保开发阶段, 测试阶段和项目上线的数据互不影响.

7.1.1 定义模型

ORM框架是一种程序技术, 用于实现面向对象编程语言中不同类型系统的数据之间的转换.
从效果上说, 它创建了一个可在编程语言中使用的'虚拟对象数据库', 
通过对虚拟对象数据库的操作从而实现对目标数据库的操作, 虚拟对象数据库与目标数据库是相互对应的.

在Django中, 虚拟对象数据库也称为模型, 通过模型实现对目标数据库的读写操作, 实现方法如下:
(1) 配置目标数据库, 在settings.py中设置配置属性, 配置步骤可参考2.4节.
(2) 构建虚拟对象数据库, 在App的models.py文件中以类的形式定义模型.
(3) 通过模型在目标数据库中创建相应的数据表.
(4) 在其他模块(如视图函数)里使用模型来实现目标数据库的读写操作.

在项目的配置文件settings.py里设置数据库配置信息. 以MyDjango项目为例, 其配置信息如下:

# 默认的数据库配置
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': BASE_DIR / 'db.sqlite3',
    }
}

我们使用Navicat Premium数据库管理工具(这是一个可视化数据库管理工具, 读者可自行在网上搜索并安装该工具)
查看当前SQLite3数据库, 数据库文件是MyDjango根目录下的db.sqlite3文件, 如图7-1所示.
(注意: 新创建的项目需要运行一次后才会生成db.sqlite3文件.)

图7-1　数据库信息

从图7-1中可以看到, SQLite3数据库当前没有数据表, 
而数据表可以通过模型创建, 因为Django对模型和目标数据库之间有自身的映射规则, 
如果自己在数据库中创建数据表, 就可能不符合Django的建表规则从而导致模型和目标数据库无法建立有效的通信联系.
大概了解项目的环境后, 在项目index的models.py文件中定义模型, 代码如下:

from django.db import models


class PersonInfo(models.Model):
    id = models.AutoField(primary_key=True)
    name = models.CharField(max_length=20)  # CharField会映射为varchar类型
    age = models.IntegerField()
    hire_date = models.DateField()

    # 打印模型对象时显示名称
    def __str__(self):
        return self.name

    # 模型的中文名字
    class Meta:
        verbose_name = '人员信息'

模型PersonInfo定义了4个不同类型的字段,  分别代表自增主键, 字符类型, 整型和日期类型.
但在实际开发中, 我们需要定义不同的字段类型来满足各种开发需求, 因此Django划分了多种字段类型,
在源码目录django\db\models\fields的__init__.py和files.py文件里找到各种模型字段.

说明如下:
● AutoField: 自增长类型, 数据表的字段类型为整数, 长度为11位.
● BigAutoField: 自增长类型, 数据表的字段类型为bigint, 长度为20位.
● CharField: 字符类型.
● BooleanField: 布尔类型.
● CommaSeparatedIntegerField: 用逗号分隔的整数类型.
● DateField: 日期(Date)类型.
● DateTimeField: 日期时间(Datetime)类型.
● Decimal: 十进制小数类型.
● EmailField: 字符类型, 存储邮箱格式的字符串.
● FloatField: 浮点数类型, 数据表的字段类型变成Double类型.
● IntegerField: 整数类型, 数据表的字段类型为11位的整数.
● BigIntegerField: 长整数类型.
● IPAddressField: 字符类型, 存储Ipv4地址的字符串.
● GenericIPAddressField: 字符类型, 存储Ipv4和Ipv6地址的字符串.
● NullBooleanField: 允许为空的布尔类型.
● PositiveIntegerFiel: 正整数的整数类型.
● PositiveSmallIntegerField: 小正整数类型, 取值范围为0～32767.
● SlugField: 字符类型, 包含字母, 数字, 下画线和连字符的字符串.
● SmallIntegerField: 小整数类型, 取值范围为-32,768 ~ +32,767.
● TextField: 长文本类型.
● TimeField: 时间类型, 显示时分秒HH:MM[:ss[.uuuuuu]].
● URLField: 字符类型, 存储路由格式的字符串.
● BinaryField: 二进制数据类型.
● FileField: 字符类型, 存储文件路径的字符串.
● ImageField: 字符类型, 存储图片路径的字符串.
● FilePathField: 字符类型, 从特定的文件目录选择某个文件.

每个模型字段都允许设置参数, 这些参数来自父类Field,
我们在源码里查看Field的定义过程(django\db\models\fields\__init__.py)并且对模型字段的参数进行分析.

● verbose_name: 默认为None, 在Admin站点管理设置字段的显示名称.
● primary_key: 默认为False. 若为True, 则将字段设置成主键.
● max_length: 默认为None, 设置字段的最大长度.
● unique: 默认为False若为True, 则设置字段的唯一属性.
● blank: 默认为False, 若为True, 则字段允许为空值, 数据库将存储空字符串.
● null: 默认为False, 若为True, 则字段允许为空值, 数据库表现为NULL.
● db_index: 默认为False, 若为True, 则以此字段来创建数据库索引.
● default: 默认为NOT_PROVIDED对象, 设置字段的默认值.
● editable: 默认为True, 允许字段可编辑, 用于设置Admin的新增数据的字段.
● serialize: 默认为True, 允许字段序列化, 可将数据转化为JSON格式.
● unique_for_date: 默认为None, 设置日期字段的唯一性.
● unique_for_month: 默认为None, 设置日期字段月份的唯一性.
● unique_for_year: 默认为None, 设置日期字段年份的唯一性.
● choices: 默认为空列表, 设置字段的可选值.
● help_text: 默认为空字符串, 用于设置表单的提示信息.
● db_column: 默认为None, 设置数据表的列名称, 若不设置, 则将字段名作为数据表的列名.
● db_tablespace: 默认为None, 如果字段已创建索引, 那么数据库的表空间名称将作为该字段的索引名.
  注意: 部分数据库不支持表空间.
● auto_created: 默认为False, 若为True, 则自动创建字段, 用于一对一的关系模型.
● validators: 默认为空列表, 设置字段内容的验证函数.
● error_messages: 默认为None, 设置错误提示.

上述参数适用于所有模型字段, 但不同类型的字段会有些特殊参数, 每个字段的特殊参数可以在字段的初始化方法__init__里找到,
比如字段DateField和TimeField的特殊参数auto_now_add和auto_now, 字段FileField和ImageField的特殊参数upload_to.
在定义模型时, 一般情况下都会重写函数__str__, 这是设置模型的返回值, 默认情况下, 返回值为模型名+主键.
函数__str__可用于外键查询, 比如模型A设有外键字段F, 外键字段F关联模型B, 
当查询模型A时, 外键字段F会将模型B的函数__str__返回值作为字段内容.

需要注意的是, 函数__str__只允许返回字符类型的字段, 如果字段是整型或日期类型的, 
就必须使用Python的str()函数将其转化成字符类型.
模型除了定义模型字段和重写函数__str__之外, 还有Meta选项, 这三者是定义模型的基本要素.
Meta选项里设有19个属性, 每个属性的说明如下:

● abstract: 若设为True, 则该模型为抽象模型, 不会在数据库里创建数据表.
● app_label: 属性值为字符串, 将模型设置为指定的项目应用, 比如将index的models.py定义的模型A指定到其他App里.
● db_table: 属性值为字符串, 设置模型所对应的数据表名称.
● db_teblespace: 属性值为字符串, 设置模型所使用数据库的表空间.
● get_latest_by: 属性值为字符串或列表, 设置模型数据的排序方式.
● managed: 默认值为True, 支持Django命令执行数据迁移; 若为False, 则不支持数据迁移功能.
● order_with_respect_to: 属性值为字符串, 用于多对多的模型关系, 指向某个关联模型的名称, 并且模型名称必须为英文小写.
  比如模型A和模型B, 模型A的一条数据对应模型B的多条数据, 两个模型关联后, 当查询模型A的某条数据时,
  可使用get_b_order()和set_b_order()来获取模型B的关联数据, 这两个方法名称的b为模型名称小写.
  此外get_next_in_order()和get_previous_in_order()可以获取当前数据的下一条和上一条的数据对象.
● ordering: 属性值为列表, 将模型数据以某个字段进行排序.
● permissions: 属性值为元组, 设置模型的访问权限, 默认设置添加, 删除和修改的权限.
● proxy: 若设为True, 则为模型创建代理模型, 即克隆一个与模型A相同的模型B.
● required_db_features: 属性值为列表, 声明模型依赖的数据库功能. 比如['gis_enabled'], 表示模型依赖GIS功能.
● required_db_vendor: 属性值为列表, 声明模型支持的数据库, 默认支持SQLite, PostgreSQL, MySQL和Oracle.
● select_on_save: 数据新增修改算法, 通常无须设置此属性, 默认值为False.
● indexes: 属性值为列表, 定义数据表的索引列表.
● unique_together: 属性值为元组, 多个字段的联合唯一, 等于数据库的联合约束.
● verbose_name: 属性值为字符串, 设置模型直观可读的名称并以复数形式表示.
● verbose_name_plural: 与verbose_name相同, 以单数形式表示.
● label: 只读属性, 属性值为app_label.object_name, 如index的模型PersonInfo, 值为index.PersonInfo.
● label_lower: 与label相同, 但其值为字母小写, 如index.personinfo.

综上所述, 模型字段, 函数__str__和Meta选项是模型定义的基本要素, 
模型字段的类型, 函数__str__和Meta选项的属性设置需由开发需求而定.

在定义模型时, 还可以在模型里定义相关函数, 如get_absolute_url(), 当视图类没有设置属性success_url时,
视图类的重定向路由地址将由模型定义的get_absolute_url()提供.

除此之外, Django支持开发者自定义模型字段, 从源码文件得知, 所有模型字段继承Field类,
只要将自定义模型字段继承Field类并重写父类某些属性或方法即可完成自定义过程,
具体的自定义过程不再详细讲述, 读者可以参考内置模型字段的定义过程.

7.1.2 开发个人的ORM框架

我们知道模型是以类的形式定义的, 并且继承父类Model, 但在使用模型操作数据库时, 开发者直接使用即可, 无须将模型实例化.
为了深入探究Django的模型机制, 在PyCharm里打开父类Model的源码文件, 
发现Model类在定义过程中设置了metaclass=ModelBase, 如图7-2所示.

图7-2　Model的定义过程

在Model类的源码文件里找到ModelBase的定义过程, 发现ModelBase类继承Python的type类, 如图7-3所示.

图7-3　ModelBase的定义过程

分析Model类和ModelBase类的源码发现, 两者的定义过程与我们定义类的方式有所不同.
ModelBase类继承父类type, 这是自定义Python的元类, 元类是创建类的类, type是Python用来创建所有类的内置元类,
而ModelBase类继承type类, 它通过自定义属性和方法来创建模型对象的元类.

Model类设置metaclass=ModelBase是将Model类的创建过程交由元类ModelBase执行,
而项目里定义模型继承Model类, 这说明我们定义的模型也是由元类ModelBase完成创建的.
也许读者难以理解Python元类, 因此将通过一个简单的例子来加以说明, 代码如下:

class CreateClass(type):
    def __new__(cls, name, bases, attr):
        attrs = []
        # 将类的属性进行清洗)
        print(attr)
        # {'__module__': '__main__', '__qualname__': 'PersonInfo', 'name': 'Django', 'name2': '__qz'}
        for k, v in attr.items():
            if not v.startswith("__"):
                attrs.append((k, v))
        # 将属性生成字典格式

        new_attrs = dict((k, v) for k, v in attrs)
        return super().__new__(cls, name, bases, new_attrs)


class PersonInfo(metaclass=CreateClass):
    name = 'Django'

    name2 = '__qz'  # 清洗值前后有双下划线的值


print(PersonInfo.name)  # Django
print(PersonInfo.name2)  # name2被清洗
# AttributeError: type object 'PersonInfo' has no attribute 'name2'

运行上述代码, 程序执行过程如下:
(1) 执行类PersonInfo, 目的是生成类对象并加载到计算机的内存里(类对象与实例化对象是两个不同的概念).
(2) 默认情况下, 类对象的创建是由Python内置的type完成的, 由于类PersonInfo设置元类CreateClass,
    因此创建过程由元类CreateClass完成, 它重写type的方法__new__, 
    这是将类PersonInfo的属性进行清洗处理, 去除属性值带有双下画线的属性.
(3) 程序执行print函数, 将类PersonInfo的属性name输出.
综上所述, Django的ORM框架是通过继承并重写元类type来实现的.
根据这一原理, 我们可自主开发个人的ORM框架, 分别定义模型字段, 元类, 模型基本类, 代码如下:

# 随便创建一个py文件
class Field(object):
    # 初始化, 字段名称, 字段类型
    def __init__(self, name, column_type):
        self.name = name
        self.column_type = column_type

    def __str__(self):
        return f'<{self.__class__.__name__}:{self.name}>'  # 类名:字段名称


# 模型字段的字符类型
class StringField(Field):
    # 字符串字段名称
    def __init__(self, name):
        # 调用父类并添加类型名称
        super().__init__(name, 'varchar(100)')


# 模型字段的整数类型
class IntegerField(Field):
    # 整形字段名称
    def __init__(self, name):
        # 调用父类并添加类型名称
        super().__init__(name, 'bigint')


# 定义元类ModelMetaclass, 控制Model对象的创建
class ModelMetaclass(type):
    def __new__(cls, name, bases, attrs):
        # 定义字典
        mappings = dict()

        # 遍历类的属性, k为属性名称, v为属性值
        for k, v in attrs.items():
            # 保存类属性和列的映射关系到mappings字典
            if isinstance(v, Field):  # 属性值是自定义的模型字段
                print(f'Found mappings: {k} ==>{v}')
                mappings[k] = v  # 将自定的模型添加到字段

        # 遍历属性的名称
        for k in mappings.keys():
            # 将类属性移除, 使定义的类字段不污染User类属性
            attrs.pop(k)

        # 创建类时添加一个__table__类属性:
        attrs['__table__'] = name.lower()
        # 保存属性和列的映射关系, 创建类时添加一个__mappings__类属性
        attrs['__mappings__'] = mappings
        return super().__new__(cls, name, bases, attrs)


# 定义Model类
class Model(metaclass=ModelMetaclass):
    def __init__(self, *args, **kwargs):
        self.kwargs = kwargs
        super().__init__() 

    def save(self):
        fields, params = [], []
        for k, v in self.__mappings__.items():
            fields.append(k)  # 字段名称
            params.append(v)  # 字段类型

        # 生成完整的sql语句
        sql = r'insert into %s (%s) values(%s)'
        # 生成完整的sql语句
        sql = sql % (self.__table__, ','.join(fields), ','.join(params))
        # 打印sql语句
        print(f'SQL: {sql}')

上述代码是我们自定义的ORM框架, 设计逻辑参考Django的ORM框架.
为了验证自定义的ORM框架的功能, 通过定义模型User并使其继承父类Model, 
再由模型User调用父类Model的save方法, 观察save方法的输出结果, 实现代码如下:

# 定义模型User
class User(Model):
    # 定义类的属性到列的映射
    id = IntegerField('id')
    name = StringField('username')
    email = StringField('email')
    password = StringField('password')


# 创建实例对象
u = User(id=123, name='Dj', email='Dj@dd.gg', password='111')
# 调用save()方法
u.save()

在PyCharm里运行上述代码并查看程序的输出结果, 当调用save()方法时, 
程序会将实例化对象u的数据生成相应的SQL语句, 只要在ORM框架里实现数据库连接,
并执行SQL语句即可实现数据库的数据操作, 运行结果如图7-4所示.

图7-4　运行结果

7.1.3 数据迁移

数据迁移是将项目里定义的模型生成相应的数据表, 在5.1.3小节已简单介绍过模型的数据迁移操作,
本节将会深入讲述数据迁移的操作, 包括数据表的创建和更新.

首次在项目里定义模型时, 项目所配置的数据库里并没有创建任何数据表, 
想要通过模型创建数据表, 可使用Django的操作指令完成创建过程.
以7.1.1小节的MyDjango为例, 

# index 的 models.py
from django.db import models


class PersonInfo(models.Model):
    id = models.AutoField(primary_key=True)
    name = models.CharField(max_length=20)
    age = models.IntegerField()
    hire_date = models.DateField()

    # 打印模型对象时显示名称
    def __str__(self):
        return self.name

    # 模型的中文名字
    class Meta:
        verbose_name = '人员信息'

在PyCharm的Terminal窗口下输入Django的操作指令:

D:\MyDjango>python manage.py makemigrations
Migrations for 'index':
  index\migrations\0001_initial.py
    - Create model PersonInfo

当makemigrations指令执行成功后, 在项目应用index的migrations文件夹里创建0001_initial.py文件,
如果项目里有多个App, 并且每个App的models.py文件里定义了模型对象, 
当首次执行makemigrations(进行迁移)指令时, Django就在每个App的migrations文件夹里创建0001_initial.py文件.
打开查看0001_initial.py文件, 文件内容如图7-5所示.

图7-5　0001_initial.py文件内容

0001_initial.py文件将models.py定义的模型生成数据表的脚本代码, 该文件的脚本代码可被migrate指令执行,
migrate指令会根据脚本代码的内容在数据库里创建相应的数据表, 
只要在PyCharm的Terminal窗口下输入migrate(迁移)指令即可完成数据表的创建, 代码如下:

D:\MyDjango>python manage.py migrate
Operations to perform:
  Apply all migrations:admin,auth,contenttypes,index,sessions
Running migrations:
  Applying contenttypes.0001_initial... OK

指令运行完成后, 打开数据库就能看到新建的数据表, 其中数据表index_personinfo由项目应用index定义的模型PersonInfo创建,
而其他数据表是Django内置的功能所使用的数据表, 分别是会话Session, 用户认证管理和Admin后台系统等.

在Django中, 使用的ORM(对象关系映射)来定义模型时, Django会自动为你创建数据库表来存储这些模型的数据.
默认情况下, 这些表的名称会带有一些前缀或后缀, 这主要是为了遵循Django的命名规范, 确保表名的唯一性, 并避免潜在的命名冲突.
表名通常会包含应用名作为前缀.

在开发过程中, 开发者因为开发需求而经常调整数据表的结构, 比如新增功能, 优化现有功能等.
假如在上述例子里新增模型Vocation及其数据表, 为了保证不影响现有的数据表, 如何通过新增的模型创建相应的数据表?
针对上述问题, 我们只需再次执行makemigrations和migrate指令即可, 比如在index的models.py里定义模型Vocation, 代码如下:

class Vocation(models.Model):
    id = models.AutoField(primary=True)
    job = models.CharField(max_length=20)
    title = models.CharField(max_length=20)
    # 设置外键, 级联删除
    name = models.ForeignKey(PersonInfo, on_delete=models.Case)

    def __str__(self):
        return str(self.id)

    class Meta:
        verbose_name = '职业信息'

在PyCharm的Terminal窗口下输入并运行makemigrations指令, 
Django会在index的migrations文件夹里创建0002_vocation.py文件;
然后输入并运行migrate指令即可完成数据表index_vocation的创建.

PS D:\MyDjango> python manage.py makemigrations
Migrations for 'index':
  index\migrations\0002_vocation.py
    - Create model Vocation
PS D:\MyDjango> python manage.py migrate
Operations to perform:
  Apply all migrations: admin, auth, contenttypes, index, sessions
Running migrations:
  Applying index.0002_vocation... OK

makemigrations和migrate指令还支持模型的修改, 从而修改相应的数据表结构, 比如在模型Vocation里新增字段payment, 代码如下:

class Vocation(models.Model):
    id = models.AutoField(primary_key=True)
    job = models.CharField(max_length=20)
    title = models.CharField(max_length=20)
    payment = models.IntegerField(null=True, blank=True)  # 新增字段, 
    # 设置外键, 级联删除
    name = models.ForeignKey(PersonInfo, on_delete=models.CASCADE)

    def __str__(self):
        return str(self.id)

    class Meta:
        verbose_name = '职业信息'

在Django的模型(models)中, blank 和 null 是两个用于字段定义的选项, 它们各自具有不同的意义:
null: 这个选项用于数据库层面, 决定是否允许该字段在数据库中为NULL.
      null=True 意味着在数据库中这个字段可以没有值(即NULL), 而 null=False 则意味着这个字段在数据库中必须有值.
blank: 这个选项用于表单验证层面.
       当 blank=True 时, 该字段在Django的表单验证中是可以不填的.
       也就是说, 如果用户在表单中没有为这个字段提供值, Django不会因为这个字段没有值而抛出验证错误.
       相反, blank=False 意味着在表单验证时这个字段是必填的.
       
on_delete选项:
models.CASCADE: 当被引用的对象被删除时, 也删除包含外键的对象.
                如果数据库层级设置了级联删除, 那么依赖的对象会被数据库自动删除. 否则, Django不会执行任何操作.
models.PROTECT: 阻止删除被引用的对象, 如果有关联的对象存在.
models.SET_NULL: 设置外键字段为NULL. 这要求外键字段具有null=True.
models.SET_DEFAULT: 设置外键字段为它的默认值. 这要求外键字段具有default值。
models.SET(value): 设置外键字段为给定的值.
models.DO_NOTHING: 不做任何事情.

新增模型字段必须将属性null和blank设为True或者为模型字段设置默认值(设置属性default),
否则执行makemigrations指令会提示字段修复信息, 如图7-6所示.

图7-6　字段修复信息

当makemigrations指令执行完成后, 在index的migrations文件夹创建相应的.py文件,
只要再次执行migrate指令即可完成数据表结构的修改.

PS D:\MyDjango> python manage.py makemigrations
Migrations for 'index':
  index\migrations\0003_vocation_payment.py
    - Add field payment to vocation
PS D:\MyDjango> python manage.py migrate       
Operations to perform:
  Apply all migrations: admin, auth, contenttypes, index, sessions
Running migrations:
  Applying index.0003_vocation_payment... OK

每次执行migrate指令时, Django都能精准运行migrations文件夹尚未被执行的.py文件, 
它不会对同一个.py文件重复执行, 因为每次执行时, Django会将该文件的执行记录保存在数据表django_migrations中,
数据表的数据信息如图7-7所示.

如果要重复执行migrations文件夹的某个.py文件, 就只需在数据表里删除相应的文件执行记录.
一般情况下不建议采用这种操作, 因为这样很容易出现异常, 
比如数据表已存在的情况下, 再次执行相应的.py文件会提示table "xxx" already exists异常.

图7-7　数据表django_migrations

migrate指令还可以单独执行某个.py文件, 首次在项目中使用migrate指令时, Django会默认创建内置功能的数据表,
如果只想执行index的migrations文件夹的某个.py文件, 那么可以在migrate指令里指定文件名, 代码如下:

D:\MyDjango>python manage.py migrate index 0001_initial
Operations to perform:
  Target specific migration: 0001_initial, from index
Running migrations:
  Applying index.0001_initial... OK

在migrate指令末端设置项目应用名称index和migrations文件夹的0001_initial文件名,
三者(migrate指令, 项目应用名称index和0001_initial文件名)之间使用空格隔开即可, 指令执行完成后,
数据库只有数据表django_migrations和index_personinfo.

我们知道, migrate指令根据migrations文件夹的.py文件创建数据表, 
但在数据库里, 数据表的创建和修改离不开SQL语句的支持, 因此Django提供了sqlmigrate指令,
该指令能将.py文件转化成相应的SQL语句.

以index的0001_initial.py文件为例, 在PyCharm的Terminal窗口输入sqlmigrate指令,
指令末端必须设置项目应用名称和migrations文件夹的某个.py文件名, 三者之间使用空格隔开即可, 指令输出结果如图7-8所示.

PS D:\MyDjango> python manage.py sqlmigrate index 0001_initial
BEGIN;
--
-- Create model PersonInfo
--
CREATE TABLE "index_personinfo" ("id" integer NOT NULL PRIMARY KEY AUTOINCREMENT,
"name" varchar(20) NOT NULL, "age" integer NOT NULL, "hire_date" date NOT NULL);
COMMIT;

图7-8　sqlmigrate指令

除此之外, Django还提供了很多数据迁移指令, 如squashmigrations, inspectdb, showmigrations,
sqlflush, sqlsequencereset和remove_stale_contenttypes, 这些指令在1.9.1小节里已说明过了, 此处不再重复讲述.

当我们在操作数据迁移时, Django会对整个项目的代码进行检测, 它首先执行check指令, 
只要项目里某个功能文件存在异常, Django就会终止数据迁移操作.

也就是说, 在执行数据迁移之前, 可以使用check指令检测整个项目, 项目检测成功后再执行数据迁移操作, 如图7-9所示.

PS D:\MyDjango> python manage.py check
System check identified no issues (0 silenced).

图7-9　check指令

7.1.4 数据导入与导出

在实际开发过程中, 我们经常对数据库的数据进行导入和导出操作, 比如网站重构, 数据分析和网站分布式部署等.
一般情况下, 我们使用数据库可视化工具来实现数据的导入和导出, 以Navicat Premium为例,
打开某个数据表, 单击'导入'或'导出'按钮, 按照操作提示即可完成, 如图7-10所示.

图7-10　数据的导入与导出

使用数据库可视化工具导入某个表的数据时, 如果当前数据表设有外键字段, 
就必须将外键字段关联的数据表的数据导入, 再执行当前数据表的数据导入操作, 否则数据无法导入成功.
因为外键字段指向它所关联的数据表, 如果关联的数据表没有数据,
外键字段就无法与关联的数据表生成数据关系, 从而使当前数据表的数据导入失败.

除了使用数据库可视化工具实现数据的导入与导出之外, Django还为我们提供操作指令(loaddata和dumpdata)来实现数据的导入与导出操作.
以7.1.3小节的MyDjango为例, 在数据表index_vocation和index_personinfo中分别添加数据, 如图7-11所示.

图7-11　数据表index_vocation和index_personinfo

在PyCharm的Terminal窗口输入dumpdata指令, 将整个项目的数据从数据库里导出并保存到data.json文件, 其指令如下:

D:\MyDjango> python manage.py dumpdata > data.json

dumpdata指令末端使用了符号'>'和文件名data.json, 这是将项目所有的数据都存放在data.json文件中,
并且data.json的文件路径在项目的根目录(与项目的manage.py文件在同一个路径).

如果只想导出某个项目应用的所有数据或者项目应用里某个模型的数据,
那么可在dumpdata指令末端设置项目名称或项目名称的某个模型名称, 代码如下:

# 导出项目应用index的所有数据
D:\MyDjango> python manage.py dumpdata index > index_data.json

# 导出项目应用index的模型PersonInfo的数据
D:\MyDjango> python manage.py dumpdata index.Personinfo > person.json

一般情况下, 使用dumpdata指令导出的数据文件都存放在项目的根目录, 
因为在输入指令时, PyCharm的Terminal窗口的命令行所在路径为项目的根目录, 若想更换存放路径, 
则可改变命令行的当前路径, 比如将数据文件存放在D盘, 其指令如下:

# 将命令行路径切换到D盘
D:\MyDjango> cd ..
# 命令行在D盘路径下使用MyDjango的manage文件执行dumpdata指令
D:\> python MyDjango/manage.py dumpdata > data.json

若想将导出的数据文件重新导入数据库里, 则可使用loaddata指令完成,
该指令使用方式相对单一, 只需在指令末端设置需要导入的文件名即可:
(注意看上面的图片, 导出的文件编码为utf16-16le, 导入文件使用Utf-8解码会报错, 需要手动转码.)

# 数据库中有数据也是可以执行的
D:\MyDjango> python manage.py loaddata data.json
Installed 44 object(s) from 1 fixture(s)

loaddata指令根据数据文件的model属性来确定当前数据所属的数据表, 并将数据插入数据表, 从而完成数据导入.
一般情况下, 数据的导出和导入最好以整个项目或整个项目应用的数据为单位, 
因为数据表之间可能存在外键关联, 如果只导入某张数据表的数据, 就必须考虑该数据表是否设有外键, 并且外键所关联的数据表是否已有数据.

7.2 数据表关系

一个模型对应数据库的一张数据表, 但是每张数据表之间是可以存在外键关联的, 表与表之间有3种关联: 一对一, 一对多和多对多.

自关联(或自连接)在关系型数据库中并不是一个独立的表关系类型, 更多的是一种查询技术或策略, 用于将同一个表与其自身进行连接.
从某种角度看, 自关联可以看作是表与其自身之间的一种特殊的一对多或多对一关系.

一对一建表原则: 当两个表之间存在一对一关系时, 从表的主键作为主表的外键, 建立主从关系.
一对多建表原则: 在从表(多方, 增加数据)创建一个字段, 字段作为外键指向主表(一方, 数据基本固定)的主键.
多对多关系建表原则: 需要创建第三张表, 中间表中至少两个字段, 这两个字段分别作为外键指向各自一方的主键.

7.2.1 一对一表关系

一对一关系存在于两张数据表中, 第一张表的某一行数据只与第二张表的某一行数据相关,
同时第二张表的某一行数据也只与第一张表的某一行数据相关, 这种表关系被称为一对一关系, 以表7-1和表7-2为例进行说明.

表7-1　一对一关系的第一张表(主表)

表7-2　一对一关系的第二张表(从表)

表7-1和表7-2的字段ID分别是一一对应的, 并且不会在同一表中有重复ID, 
使用这种外键关联通常是一张数据表设有太多字段, 将常用的字段抽取出来并组成一张新的数据表.
在模型中可以通过OneToOneField来构建数据表的一对一关系, 代码如下:

# 一对一关系
from django.db import models


# 主表
class Student(models.Model):
    id = models.IntegerField(primary_key=True)
    name = models.CharField(max_length=20)
    class_name = models.CharField(max_length=20)
    class_room = models.CharField(max_length=20)


# 从表(外键建立在从表, 绑定主表的主键)
class StudentInfo(models.Model):
    id = models.IntegerField(primary_key=True)
    age = models.IntegerField()
    phone = models.CharField(max_length=20)
    # 设置外键一对一关系, 外键字段会自动携带后缀'_id'
    student = models.OneToOneField(Student, on_delete=models.CASCADE)

对上述模型执行数据迁移, 在数据库中分别创建数据表Performer和Performer_info, 
打开Navicat Premium查看两张数据表的表关系, 如图7-12所示.

图7-12　数据表关系

7.2.2 一对多表关系

一对多关系存在于两张或两张以上的数据表中, 第一张表的某一行数据可以与第二张表的一到多行数据进行关联,
但是第二张表的每一行数据只能与第一张表的某一行进行关联, 以表7-3和表7-4为例进行说明.

表7-3　一对多关系的第一张表(主表)

表7-4　一对多关系的第二张表(从表)

在表7-3, 7-4中, ID是唯一的, 但表7-4的外键字段ID允许重复, 字段ID相同的数据对应表7-3某一行数据, 这种表关系在日常开发中最为常见.
在模型中可以通过ForeignKey来构建数据表的一对多关系, 代码如下:

# 一对多关系
from django.db import models


# 主表
class Department(models.Model):
    id = models.IntegerField(primary_key=True)
    name = models.CharField(max_length=20)
    description = models.CharField(max_length=20)


# 从表
class Employees(models.Model):
    id = models.IntegerField(primary_key=True)
    name = models.CharField(max_length=20)
    # 设置外键, 绑定主表的主键
    department = models.ManyToManyField(Department)

删除0001_initial.py文件和所有表格.

对上述模型执行数据迁移, 在数据库中分别创建数据表Employees和Department,
然后打开Navicat Premium查看两张数据表的表关系, 如图7-13所示.

图7-13　数据表关系

7.2.3 多对多表关系

多对多关系存在于两张或两张以上的数据表中, 第一张表的某一行数据可以与第二张表的一到多行数据进行关联,
同时第二张表中的某一行数据也可以与第一张表的一到多行数据进行关联, 以表7-5和表7-6为例进行说明.

表7-5　多对多关系的第一张表

表7-6　多对多关系的第二张表

表7-5和表7-6的数据关系如表7-7所示.

表7-7　两张表的数据关系

在多对多关系中, 涉及到的三张表通常可以按照其功能和作用进行称呼.
一般来说, 这三张表可以分别称为主表, 关系表和副表或字典表.
* 1. 主表: 主表通常存储主要的数据实体信息.
     在多对多关系中, 主表可能包含一种类型的实体数据.
     例如, 在一个学生和课程的多对多关系中, 学生信息表就可以作为主表.
* 2. 关系表: 关系表用于记录主表和副表之间的关联关系.
     它通常包含两个外键字段, 分别指向主表和副表的主键, 表示它们之间的多对多关联.
     在上面的例子中, 一个名为'学生课程关系'的表就可以作为关系表, 其中包含学生的ID和课程的ID, 用于记录每个学生选修了哪些课程.
* 3. 副表或字典表: 副表或字典表通常存储另一种类型的实体数据.
     与主表类似, 但它与主表通过关系表进行关联.
     在上面的例子中, 课程信息表就可以作为副表或字典表.

从3张数据表中可以发现, 一个学生可以参加选修多个课程, 而一个课程也可以有多个学生选修. 
表7-5和表7-6的字段ID都是唯一的.
从表7-7中可以发现, 学生ID和课程ID出现了重复的数据, 分别对应表7-5和表7-6的字段ID, 
多对多关系需要使用新的数据表来管理两张表的数据关系.
在模型中可以通过ManyToManyField来构建数据表的多对多关系, 代码如下:

# 多对多关系
from django.db import models


# 学生表(主表)
class Student(models.Model):
    id = models.IntegerField(primary_key=True)
    name = models.CharField(max_length=20)
    age = models.IntegerField()


# 课程表(副表)
class Course(models.Model):
    id = models.IntegerField(primary_key=True)
    name = models.CharField(max_length=20)
    teacher = models.CharField(max_length=20)
    # 创建关联关系
    student = models.ManyToManyField(Student)

删除0001_initial.py文件和所有表格.

数据表之间创建多对多关系时, 只需在项目里定义两个模型对象即可, 
在执行数据迁移时, Django自动生成3张数据表来建立多对多关系, 如图7-14所示.

图7-14　数据表关系 (第三张表的名称 = appname_ + 外键所在表的表名 + _ + 外键字段 = index_course_student .)

综上所述, 模型之间的关联是由OneToOneField, ForeignKey和ManyToManyField外键字段实现的, 
每个字段设有特殊的参数, 参数说明如下:
● to: 必选参数, 关联的模型名称.
● on_delete: 仅限于OneToOneField, ForeignKey, 必选参数, 设置数据的删除模式, 
  删除模型包括, CASCADE, PROTECT, SET_NULL, SET_DEFAULT, SET和DO_NOTHING.
● limit_choices_to: 设置外键的下拉框选项, 用于模型表单和Admin后台系统.
● related_name: 用于模型之间的关联查询, 如反向查询.
● related_query_name: 设置模型的查询名称, 用于filter或get查询,
  若设置参数related_name, 则以该参数为默认值, 若没有设置, 则以模型名称的小写为默认值.
● to_field: 设置外键与其他模型字段的关联性, 默认关联主键, 若要关联其他字段, 则该字段必须具有唯一性.
● db_constraint: 在数据库里是否创建外键约束, 默认值为True.
● swappable: 设置关联模型的替换功能, 默认值为True, 比如模型A关联模型B, 想让模型C继承并替换模型B, 使得模型A与模型C之间关联.
● symmetrical: 仅限于ManyToManyField, 设置多对多字段之间的对称模式.
● through: 仅限于ManyToManyField, 设置自定义模型C, 用于管理和创建模型A和B的多对多关系.
● through_fields: 仅限于ManyToManyField, 设置模型C的字段, 确认模型C的哪些字段用于管理模型A和B的多对多关系.
● db_table: 仅限于ManyToManyField, 为管理和存储多对多关系的数据表设置表名称.

在 Django 的早期版本中, ManyToManyField 的 to 参数确实可以是字符串形式的模型名称,
这是为了在定义模型时允许引用尚未定义的模型.
但是, 在 Django 的后续版本中, 这种使用字符串引用模型的方式逐渐被认为是不好的实践,
并在 Django 3.1 中被完全废弃了(可以用, 但是不推荐!).

# 多对多关系
from django.db import models


# 学生表(主表)
class Student(models.Model):
    id = models.IntegerField(primary_key=True)
    name = models.CharField(max_length=20)
    age = models.IntegerField()
    # 引用尚未定义的模型
    course = models.ManyToManyField('Course')


# 课程表(副表)
class Course(models.Model):
    id = models.IntegerField(primary_key=True)
    name = models.CharField(max_length=20)
    teacher = models.CharField(max_length=20)

自动创建的第三张表的外键默认使用CASCADE级联操作.
这意味着当关联的一个对象被删除时, 第三张表中的相关记录也会被删除.
如果你需要不同的级联行为, 你应该使用自定义的中间模型, 并在该模型的ForeignKey字段上明确设置on_delete参数.

在Django中, 使用ManyToManyField时, Django会为自动创建一个中间表来管理两个模型之间的多对多关系.
但是, 如果需要更细粒度的控制, 或者想要手动创建中间表的记录, 可以通过中间模型(使用through参数指定)来实现.
首先, 定义两个模型, 并通过ManyToManyField和through参数指定一个中间模型:

# 多对多关系
from django.db import models


# 学生表(主表)
class Student(models.Model):
    id = models.IntegerField(primary_key=True)
    name = models.CharField(max_length=20)
    age = models.IntegerField()


# 课程表(副表)
class Course(models.Model):
    id = models.IntegerField(primary_key=True)
    name = models.CharField(max_length=20)
    teacher = models.CharField(max_length=20)
    # 通过through参数指定多对多模型
    student = models.ManyToManyField(Student, through='StudentCourse')


class StudentCourse(models.Model):
    student = models.ForeignKey(Student, on_delete=models.CASCADE)
    course = models.ForeignKey(Course, on_delete=models.CASCADE)
    # 可以添加其他字段, 创建时间等...

7.3 数据表操作

本节讲述如何使用ORM框架实现数据新增, 修改, 删除, 查询, 执行SQL语句和实现数据库事务等操作, 具体说明如下:
● 数据新增: 由模型实例化对象调用内置方法实现数据新增, 比如单数据新增调用create, 查询与新增调用get_or_create,
  修改与新增调用update_or_create, 批量新增调用bulk_create.
● 数据修改必须执行一次数据查询, 再对查询结果进行修改操作, 常用方法有: 模型实例化, update方法和批量更新bulk_update.
● 数据删除必须执行一次数据查询, 再对查询结果进行删除操作, 若删除的数据设有外键字段, 则删除结果由外键的删除模式决定.
● 数据查询分为单表查询和多表查询, Django提供多种不同查询的API方法, 以满足开发需求.
● 执行SQL语句有3种方法实现, extra, raw和execute, 其中extra和raw只能实现数据查询, 具有一定的局限性;
  而execute无须经过ORM框架处理, 能够执行所有SQL语句, 但很容易受到SQL注入攻击.
● 数据库事务是指作为单个逻辑执行的一系列操作, 这些操作具有原子性, 即这些操作要么完全执行, 要么完全不执行,
  常用于银行转账和火车票抢购等.

7.3.1 数据新增

Django对数据库的数据进行增, 删, 改操作是借助内置ORM框架所提供的API方法实现的,
简单来说, ORM框架的数据操作API是在QuerySet类里面定义的, 然后由开发者自定义的模型对象调用QuerySet类, 从而实现数据操作.
以7.1.3小节的MyDjango为例, 分别在数据表index_personinfo和index_vocation中添加数据, 如图7-15所示.

图7-15　数据表index_personinfo和index_vocation(数据保持在配置资源内了)

为了更好地演示数据库的增, 删, 改操作, 
在MyDjango项目使用Shell模式(启动命令行和执行脚本)进行讲述, 该模式方便开发人员开发和调试程序.
在PyCharm的Terminal下开启Shell模式, 输入: python manage.py shell 指令即可开启, 如图7-16所示.

图7-16　启动Shell模式

在Shell模式下, 若想对数据表index_vocation插入数据, 则可输入以下代码实现:

>>> from index.models import * 
>>> v = Vocation()
>>> v.job = '测试工程师'
>>> v.title = '系统测试'
>>> v.payment = 0
>>> v.name_id = 3  
>>> v.save()
# 数据新增后, 获取新增数据的主键id
>>> v.id
6

上述代码是对模型Vocation进行实例化, 再对实例化对象的属性进行赋值, 从而实现数据表index_vocation的数据插入, 代码说明如下:
(1) 从项目应用index的models.py文件中导入模型Vocation.
(2) 对模型Vocation声明并实例化, 生成对象v.
(3) 对对象v的属性进行逐一赋值, 对象v的属性来自于模型Vocation所定义的字段.
    完成赋值后, 再由对象v调用save方法进行数据保存.
    save()方法返回的是一个元组, 其中第一个元素是已存在的对象或新创建的对象, 第二个元素是一个布尔值, 表示是否创建了新对象.
需要注意的是, 模型Vocation的外键命名为name, 但在数据表index_vocation中变为name_id, 
因此对象v设置外键字段name的时候, 外键字段应以数据表的字段名为准(外键都需要在name后加_id).
上述代码运行结束后, 在数据表index_vocation里查看数据的插入情况, 如图7-17所示.

图7-17　数据入库

在Django框架中, 每个模型(Model)类都默认拥有一个名为objects的属性, 它是一个Manager对象.
Manager类提供了数据库查询的接口, 使得开发者能够方便地与数据库进行交互.

以下是一些常用的objects方法:
all(): 返回模型表中所有的对象.
all_objects = MyModel.objects.all()

filter(): 根据给定的条件过滤对象.
filtered_objects = MyModel.objects.filter(field_name='value')

get(): 返回满足条件的单个对象. 如果找到多个对象或没有对象, 它会引发异常.
single_object = MyModel.objects.get(field_name='value')

exclude(): 排除满足条件的对象.
excluded_objects = MyModel.objects.exclude(field_name='value')

order_by(): 对查询结果进行排序.
ordered_objects = MyModel.objects.order_by('field_name')

values(): 返回一个包含字典的QuerySet, 每个字典表示一个对象, 字典的键是字段名.
values_list = MyModel.objects.values('field1', 'field2')

values_list(): 返回一个包含元组的QuerySet, 每个元组表示一个对象, 元组的元素是字段的值.
values_list = MyModel.objects.values_list('field1', 'field2')

count(): 返回查询结果中的对象数量.
count = MyModel.objects.count()

first() 和 last(): 分别返回查询结果中的第一个和最后一个对象.
first_object = MyModel.objects.first()  
last_object = MyModel.objects.last()

exists(): 如果查询结果中存在任何对象, 返回True.

exists = MyModel.objects.filter(field_name='value').exists()
create()：创建一个新对象并保存到数据库中。

new_object = MyModel.objects.create(field_name='value')
update()：更新满足条件的对象的字段值。

MyModel.objects.filter(field_name='old_value').update(field_name='new_value')
delete()：删除满足条件的对象。

MyModel.objects.filter(field_name='value').delete()
这些只是objects管理器提供的一些常用方法, Django ORM还提供了许多其他功能强大的查询方法和表达式, 可以根据具体需求进行组合使用.

除了上述方法外, 数据插入还有以下3种常见方法, 代码如下:

# 方法一
# 使用create方法实现数据插入
>>> v = Vocation.objects.create(job = '测试工程师', title = '系统测试', payment = 0, name_id = 3)
# 数据新增后, 获取新增数据的主键id
>>> v.id

# 方法二
# 同样使用create方法, 但数据以字典格式表示
>>> d = dict(job = '测试工程师', title = '系统测试', payment = 0, name_id = 3)
>>> v = Vocation.objects.create(**d)
# 数据新增后, 获取新增数据的主键id
>>> v.id

# 方法三
# 在实例化时直接设置属性值
>>> v=Vocation(job = '测试工程师', title = '系统测试', payment = 0, name_id = 3)
>>> v.save()
# 数据新增后, 获取新增数据的主键id
>>> v.id

执行数据插入时, 为了保证数据的有效性, 我们需要对数据进行去重判断, 确保数据不会重复插入.
以往的方案都是对数据表进行查询操作, 如果查询的数据不存在, 就执行数据插入操作.
为了简化这一过程, Django提供了get_or_create方法, 使用如下:

# 修改payment的值否则无法插入数据, 解释在后面:
>>> d = dict(job = '测试工程师', title = '系统测试', payment = 10, name_id = 3)
# 新增数据 
>>> v = Vocation.objects.get_or_create(**d)

>>> v  # 查看插入结果, 显示为True为成功
(<Vocation: 7>, True)

>>> v[0]
<Vocation: 7>

# 获取新增数据的主键id
>>> v[0].id
7

get_or_create根据每个模型字段的值与数据表的数据进行判断, 判断方式如下:
● 只要有一个模型字段的值与数据表的数据不相同(除主键之外), 就会执行数据插入操作.
● 如果每个模型字段的值与数据表的某行数据完全相同, 就不执行数据插入, 而是返回这行数据的数据对象, 
  比如对上述的字典d重复执行get_or_create, 第一次是执行数据插入(若执行结果显示为True, 则代表数据插入),
  第二次是返回数据表已有的数据信息(若执行结果显示为False, 则数据表已存在数据, 不再执行数据插入), 如图7-18所示.

>>> d = dict(job = '测试工程师', title = '系统测试', payment = 11, name_id = 3) 
>>> v = Vocation.objects.get_or_create(**d)  
# 查看插入结果
>>> v
(<Vocation: 8>, True)
>>> d = dict(job = '测试工程师', title = '系统测试', payment = 11, name_id = 3) 
>>> v = Vocation.objects.get_or_create(**d)
# 查看插入结果,
>>> v
(<Vocation: 8>, False)

图7-18　执行结果

除了get_or_create之外, Django还定义了update_or_create方法, 这是判断当前数据在数据表里是否存在.
若存在, 则进行更新操作, 否则在数据表里新增数据, 使用说明如下:

# 第一次是新增数据
>>> d = dict(job = '软件工程师', title = 'Java开发', payment = 8000, name_id = 2)
>>> v = Vocation.objects.update_or_create(**d)
>>> v
(<Vocation: 9>, True)

# 第二次是修改数据
>>> v = Vocation.objects.update_or_create(**d, defaults = {'title': 'Java'})

# 不能通过v的第二个参数来判断是否修改了数据, 只能查看数据来判断
>>> v
(<Vocation: 9>, False)

>>> v[0].title 
'Java'

update_or_create是根据字典d的内容查找数据表的数据, 如果能找到相匹配的数据, 
就执行数据修改, 修改内容以字典格式传递给参数defaults即可;
如果在数据表找不到匹配的数据, 就将字典d的数据插入数据表里.
如果要对某个模型执行数据批量插入操作, 那么可以使用bulk_create方法实现,
只需将数据对象以列表或元组的形式传入bulk_create方法即可:

>>> v1 = Vocation(job = '财务', title = '会计', payment = 0, name_id = 1)
>>> v2 = Vocation(job = '财务', title = '出纳', payment = 0, name_id = 1)
>>> ojb_list = [v1, v2]

# bulk_create的第二个参数为None
>>> v = Vocation.objects.bulk_create(ojb_list)
>>> v
[<Vocation: None>, <Vocation: None>]

# 缺陷: 使用bulk_create()不会检查数据是否重复, 直接插入
>>> v = Vocation.objects.bulk_create(ojb_list)
>>> v
[<Vocation: None>, <Vocation: None>]

在使用bulk_create之前, 数据类型为模型Vocation的实例化对象, 
并且在实例化过程中设置每个字段的值, 最后将所有实例化对象放置在列表或元组里,
以参数的形式传递给bulk_create, 从而实现数据的批量插入操作.

7.3.2 数据修改

数据修改的步骤与数据插入的步骤大致相同, 唯一的区别在于数据对象来自数据表,
因此需要执行一次数据查询, 查询结果以对象的形式表示, 并将对象的属性进行赋值处理, 代码如下:

# 同诺id获取对象
>>> v = Vocation.objects.get(id = 1)
# get()方法获取数据对象
>>> v
<Vocation: 1>
# 修改对象的payment属性
>>> v.payment = 20000
# 保存修改
>>> v.save()

上述代码获取数据表index_vocation里主键id等于1的数据对象v, 然后修改数据对象v的payment属性, 从而完成数据修改操作.
打开数据表index_vocation查看数据修改情况, 如图7-19所示.

图7-19　运行结果

除此之外, 还可以使用update方法实现数据修改, 使用方法如下:

# 批量更新一条或多条数据, 查询方法使用filter
# filter以列表格式返回, 查询结果可能是一条或多条数据, update方法返回修改的条目数
>>> Vocation.objects.filter(job = '测试工程师').update(job = '测试员')
1
# 更新数据以字典格式表示
>>> d= dict(job = '测试员')
>>> Vocation.objects.filter(job = '测试工程师').update(**d)
0
# 不使用查询方法, 默认对全表的数据进行更新
>>> Vocation.objects.update(payment = 6666)
16

# 使用内置F方法实现数据的自增或自减
# F方法还可以在annotate或filter方法里使用
>>> from django.db.models import F
>>> v = Vocation.objects.filter(job = '测试员')
# 将payment字段原有的数据自增加一
>>> v.update(payment = F('payment') + 1)
1

在Django 2.2或以上版本新增了数据批量更新方法bulk_update, 它的使用与批量新增方法bulk_create相似, 使用说明如下:
(bulk_update方法接受两个主要的参数:
一个对象列表, 这些对象是想要更新的数据库记录.
一个字段名列表, 这些是想要更新的字段. 其他字段, 即使有变化, 也不会被更新到数据库中. 
这个方法允许你一次性更新多个对象的某些字段, 而不是分别对每个对象调用save()方法, 显著减少与数据库的交互次数, 从而提高性能.)

# 新增两行数据
>>> v1 = Vocation.objects.create(job = '财务', title = '会计', name_id = 1)
>>> v2 = Vocation.objects.create(job = '财务', title = '出纳', name_id = 1)
# 修改字段payment和title的数据
>>> v1.payment = 1000
>>> v2.title = '行政'
# 批量修改字段payment和title的数据
>>> Vocation.objects.bulk_update([v1, v2], fields = ['payment', 'title'])

7.3.3 数据删除

数据删除有3种方式: 删除一行数据, 删除多行数据和删除数据表的全部数据, 实现方式如下:
(delete()方法通常会返回一个元组, 包含两个元素:
第一个元素: 是一个整数, 表示被删除的记录数. 
第二个元素: 是一个字典, 其中的键是被删除对象所代表的模型的名称, 值是被删除的记录数.)

# 动手删除自己备份下数据, 等下还要做其他测试, 要么就做后再来做删除测试, 将7.3.4的查询语句学习后再来!!!
# 删除一条id为1的数据
>>> Vocation.objects.get(id = 1).delete()
(1, {'index.Vocation': 1})

# 删除多条数据
>>> Vocation.objects.filter(job = '财务').delete() 
(8, {'index.Vocation': 8})


# 删除数据表中的全部数据
>>> Vocation.objects.all().delete()
(4, {'index.Vocation': 4})

删除数据的过程中, 如果删除的数据设有外键字段, 就会同时删除外键关联的数据.
比如删除数据表index_personinfo里主键等于3的数据(简称为数据A), 在数据表index_vocation里,
有些数据(简称为数据B)关联了数据A, 那么在删除数据A时, 也会同时删除数据B, 代码如下:

# 前面把数据全部删了, 恢复一下继续
>>> PersonInfo.objects.get(id=3).delete()
# 删除结果，共删除4条数据
# 总共删除2条数据, 其中Vocation删除了1条数据, PersonInfo删除了1条数据
>>> (2, {'index.Vocation': 1, 'index.PersonInfo': 1})

从7.2节得知, 外键字段的参数on_delete用于设置数据删除模式, 比如上述例子的模型Vocation将外键字段name设为CASCADE模式,
不同的删除模式会影响数据删除结果, 说明如下:
● PROTECT模式: 如果删除的数据设有外键字段并且关联其他数据表的数据, 就提示数据删除失败.
● SET_NULL模式: 执行数据删除并把其他数据表的外键字段设为Null, 外键字段必须将属性Null设为True, 否则提示异常.
● SET_DEFAULT模式: 执行数据删除并把其他数据表的外键字段设为默认值.
● SET模式: 执行数据删除并把其他数据表的外键字段关联其他数据.
● DO_NOTHING模式, 不做任何处理, 删除结果由数据库的删除模式决定.

7.3.4 数据查询

在修改数据时, 往往只修改某行数据的内容, 因此在修改数据之前还要对模型进行查询操作, 
确定数据表某行的数据对象, 最后才执行数据修改操作.

我们知道数据库设有多种数据查询方式, 如单表查询, 多表查询, 子查询和联合查询等,	
而Django的ORM框架对不同的查询方式定义了相应的API方法.

将数据恢复成这样....

以数据表index_personinfo和index_vocation为例, 
在MyDjango项目的Shell模式下使用ORM框架提供的API方法实现数据查询.

7.3.4.1 全表查询

>>> from index.models import *
# 全表查询
# 等同 SQL: Select * from index_vocation;
# Vocation.objects.all() 查询所有数据, 返回一个QuerySet对象.
# QuerySet对象是Django 框架中的一个核心概念, 用于表示从数据库中获取的对象集合.
# 在很多方面都可以像 Python 列表一样使用.
# 可以使用变量接收返回值, 否则会直接展示返回结果
>>> Vocation.objects.all()
<QuerySet [<Vocation: 1>, <Vocation: 2>, <Vocation: 3>, <Vocation: 4>, <Vocation: 5>]>

>>> v = Vocation.objects.all()
# 查看返回结果
>>> v
<QuerySet [<Vocation: 1>, <Vocation: 2>, <Vocation: 3>, <Vocation: 4>, <Vocation: 5>]>

# 通过索引获取记录对象, 序列从0开始
>>> v[0]
<Vocation: 1>

# 获取记录对象字段的值
v[0]
>>> v[0].job
'软件工程师'

# PersonInfo模型定义的__str__方法, 打印对象时展示对象的名称:
 def __str__(self):
        return self.name  # 还可以返回更加全面的信息

>>> P = PersonInfo.objects.all() 
>>> P  # PersonInfo类型的对象: 用户名
<QuerySet [<PersonInfo: Lucy>, <PersonInfo: Tim>, <PersonInfo: Mary>, <PersonInfo: Tony>, <PersonInfo: Tom>]>

# Vocation模型定义的__str__方法, 打印对象时展示对象的id:
def __str__(self):
        return str(self.id) 

>>> v = Vocation.objects.all() 
>>> v
<QuerySet [<Vocation: 1>, <Vocation: 2>, <Vocation: 3>, <Vocation: 4>, <Vocation: 5>]>

7.3.4.2 分页查询

# 查询前3条数据
# 等同 SQL: Select * from index_vocation LIMIT 3;
# SQL语句的LIMIT方法, 在Django中使用列表截取即可
>>> v = Vocation.objects.all()[:3]
>>> v
<QuerySet [<Vocation: 1>, <Vocation: 2>, <Vocation: 3>]>

7.3.4.3 查询字段数据

# 查询指定字段的数据
# 等同 SQL: Select job from index_vocation;
# values方法, 数据以列表返回, 列表元素以字典表示(字段的键位字段名称):
>>> v = Vocation.objects.values('job')

>>> v
<QuerySet [{'job': '软件工程师'}, {'job': '文员'}, {'job': '网站设计'}, {'job': '需求分析师'}, {'job': '项目经理'}]>

>>> v[1]['job']
'文员'

# values_list方法, 数据以列表返回, 列表元素以元组表示(元组只包含字段的值):
>>> v = Vocation.objects.values_list('job')[:3]

>>> v  # 携带逗号,才是一个元组...
<QuerySet [('软件工程师',), ('文员',), ('网站设计',)]>

value方法通常用于获取特定字段的值, 通常返回一个字典集合, <QuerySet [{'job': '软件工程师'}, {'job': '文员'}, ...]> 
filter方法则用于筛选满足某些条件的记录, 并返回一个记录对象的集合, <QuerySet [<Vocation: 1>,<Vocation: 2>, ...>

7.3.4.4 单条数据查询

# 使用get方法查询数据
# 等同 SQL: Select*from index_vocation where id = 2;
>>> v = Vocation.objects.get(id = 2)
#  get方法返回单个记录对象.
>>> v
<Vocation: 2>
>>> v.job
'文员'

# 设置多个条件, 多个条件是and的关系
>>> v = Vocation.objects.get(id = 2, job = '文员')
>>> v
<Vocation: 2>
>>> v.job
'文员'

7.3.4.5 查询多条数据

# 使用filter方法查询数据, 注意区分get和filter的差异.
# filter方法返回QuerySet对象, 说明他的返回返回值可以包含多个记录.
>>> v = Vocation.objects.filter(id = 2)
>>> v
<QuerySet [<Vocation: 2>]>
>>>v[0].job

# SQL的and查询主要在filter里面添加多个查询条件:
>>> v = Vocation.objects.filter(job='网站设计', id=3)
>>> v
<QuerySet [<Vocation: 3>]>

# filter的查询条件可设为字典格式:
>>> d=dict(job='网站设计', id=3)
>>> v = Vocation.objects.filter(**d)

7.3.4.6 Q查询

# SQL的or查询, 需要引入Q, 编写格式: Q(field = value) | Q(field = value)
# 多个Q之间使用'|'隔开即可
# 等同 SQL: Select * from index_vocation where job = '网站设计' or id = 9;
>>> from django.db.models import Q
>>> v = Vocation.objects.filter(Q(job = '网站设计') | Q(id = 4))
# 返回一个QuerySet对象.
>>> v
<QuerySet [<Vocation: 3>, <Vocation: 4>]>

# SQL的不等于查询, 在Q查询前面使用'~'即可:
# 等同 SQL: SELECT * FROM index_vocation WHERE NOT (job = '网站设计');
>>> v = Vocation.objects.filter(~Q(job = '网站设计'))
>>> v
<QuerySet [<Vocation: 1>, <Vocation: 2>, <Vocation: 4>, <Vocation: 5>]>

7.3.4.7 不等于查询

# 还可以使用exclude实现不等于查询:
>>> v = Vocation.objects.exclude(job = '网站设计')
# 返回QuerySet对象:
>>> v
<QuerySet [<Vocation: 1>, <Vocation: 2>, <Vocation: 4>, <Vocation: 5>]>

7.3.4.8 查询结果统计

# 使用count方法统计查询数据的数据量
>>> v = Vocation.objects.filter(job = '网站设计').count()
1

7.3.4.9 去重查询

# 去重查询, distinct方法无须设置参数, 去重方式根据values设置的字段执行
# 等同 SQL: Select DISTINCT job from index_vocation where job = '网站设计'
>>> v = Vocation.objects.values('job').filter(job = '网站设计').distinct()
>>> v
<QuerySet [{'job': '网站设计'}]>

7.3.4.10 排序

# 默认为升序, 降序只要在order_by里面的字段前面加"-"即可
# order_by可设置多字段排列, 如: Vocation.objects.order_by('-id', 'job')
>>> v = Vocation.objects.order_by('-id')
>>> v
<QuerySet [<Vocation: 5>, <Vocation: 4>, <Vocation: 3>, <Vocation: 2>, <Vocation: 1>]>

# 升序
>>> v = Vocation.objects.order_by('payment')
>>> for i in v:
...     i.payment
...
5000
8000
9000
10000
12000

7.3.4.11 聚合查询

聚合查询, 实现对数据值求和, 求平均值等, 由annotate(分组使用)和aggregate(不分组使用)方法实现.
annotate类似于SQL里面的GROUP BY方法.
annotate方法允许你为每个对象添加聚合计算的字段, 并返回一个新的查询集, 
这个查询集中的每个对象都包含这些额外的聚合字段.
这对于按组进行统计特别有用, 例如计算每个组的平均值, 总和等.

aggregate方法用于在整个查询集上执行聚合操作, 并返回一个包含聚合结果的字典.
它主要用于计算跨所有对象的统计信息, 例如计数, 总和, 平均值等.
aggregate的结果是一个字典, 其中每个键是聚合操作的别名, 值是相应的聚合结果.
annotate和aggregate方法中的表达式可以赋值给一个变量, 这个变量的名称则是别名.

# 如果不设置values, 默认对主键进行GROUP BY分组.
# 等同 SQL: Select job, SUM(id) AS 'id__sum' from index_vocation GROUP BY job;
>>> from django.db.models import Sum

# 按job分组, 计算所有id值的总和, 别名默认为Sum的参数添加'__sum':
>>> v = Vocation.objects.values('job').annotate(Sum('id'))

# 返回对于的查询语句:
>>> print(v.query)
SELECT "index_vocation"."job", SUM("index_vocation"."id") AS "id__sum" 
FROM "index_vocation" GROUP BY "index_vocation"."job"   

>>> for i in v:
...     i
...
{'job': '文员', 'id__sum': 2}
{'job': '网站设计', 'id__sum': 3}
{'job': '软件工程师', 'id__sum': 1}
{'job': '需求分析师', 'id__sum': 4}
{'job': '项目经理', 'id__sum': 5}

# 设置别名
>>> v = Vocation.objects.values('job').annotate(sum_id = Sum('id'))
>>> v
<QuerySet [{'job': '文员', 'sum_id': 2}, {'job': '网站设计', 'sum_id': 3}, 
           {'job': '软件工程师', 'sum_id': 1}, {'job': '需求分析师', 'sum_id': 4},
           {'job': '项目经理', 'sum_id': 5}]>

>>> from django.db.models import Count
# aggregate是计算某个字段的值并只返回计算结果
# 等同 SQL: Select COUNT(id) AS 'id_count' from index_vocation
>>> from django.db.models import Count

# 通过id统计返回的条目数, 别名默认为Count的参数添加'__count':
>>> v = Vocation.objects.aggregate(Count('id'))
>>> v
{'id__count': 5}

# 设置别名:
>>> v = Vocation.objects.aggregate(id_count = Count('id'))
>>> v
{'id_count': 5}

# 员工最低付款与最高付款, 平均付款:
>>> from django.db.models import Min, Max, Avg  
# 员工的最低付款
>>> min_payment = Vocation.objects.aggregate(min_payment = Min('payment'))['min_payment']  
>>> min_payment
5000

# 员工的最高付款
>>> max_payment = Vocation.objects.aggregate(max_payment = Max('payment'))['max_payment']
>>> max_payment
12000

# 付款平均值
>>> avg_payment = Vocation.objects.aggregate(avg_payment = Avg('payment'))['avg_payment']
>>> avg_payment
8800.0

7.3.4.12 集和操作

union, intersection和difference语法用于集合操作.

# 每次查询结果的字段必须相同!!!
# 第一次查询结果v1, 查询工资大于9000的记录:
>>> v1 = Vocation.objects.filter(payment__gt=9000)
>>> v1
<QuerySet [<Vocation: 1>, <Vocation: 5>]>

# 第二次查询结果v2, 查询工资大于5000的记录:
>>> v2 = Vocation.objects.filter(payment__gt=5000)
>>> v2
<QuerySet [<Vocation: 1>, <Vocation: 3>, <Vocation: 4>, <Vocation: 5>]>

# 使用SQL的UNION来组合两个或多个查询结果的并集.
# 获取两次查询结果的并集, 工资大于
>>> v1.union(v2)
<QuerySet [<Vocation: 1>, <Vocation: 3>, <Vocation: 4>, <Vocation: 5>]>

# 使用SQL的INTERSECT来获取两个或多个查询结果的交集.
# 获取两次查询结果的交集
>>> v1.intersection(v2)
<QuerySet [<Vocation: 1>, <Vocation: 5>]>

# 使用SQL的DIFFERENCE来获取两个或多个查询结果的差
# 以v2为目标数据, 去除v1和v2的共同数据
>>> v2.difference(v1)  # v2 - v1
<QuerySet [<Vocation: 3>, <Vocation: 4>]>

7.3.1.13 匹配符

上述例子讲述了开发中常用的数据查询方法, 但有时需要设置不同的查询条件来满足多方面的查询要求.
上述的查询条件filter和get是使用等值的方法来匹配结果.
若想使用大于, 不等于或模糊查询的匹配方法, 则可在查询条件filter和get里使用表7-8所示的匹配符实现.

表7-8　匹配符的使用及说明

从表7-8中可以看到, 只要在查询的字段末端设置相应的匹配符, 就能实现不同的数据查询方式.
例如在数据表index_vocation中查询字段payment大于8000的数据, 在Shell模式下使用匹配符__gt执行数据查询, 代码如下:

>>> from index.models import *
# 查询付款大于8000的
>>> v = Vocation.objects.filter(payment__gt=8000)
>>> v
<QuerySet [<Vocation: 1>, <Vocation: 4>, <Vocation: 5>]>

综上所述, 在查询数据时可以使用查询条件get或filter实现, 但是两者的执行过程存在一定的差异, 说明如下:
● 查询条件get: 查询字段必须是主键或者唯一约束的字段, 并且查询的数据必须存在, 
  如果查询的字段有重复值或者查询的数据不存在, 程序就会抛出异常信息.
● 查询条件filter: 查询字段没有限制, 只要该字段是数据表的某一字段即可.
  查询结果以列表形式返回, 如果查询结果为空(查询的数据在数据表中找不到), 就返回空列表.
  
(在Django的ORM(对象关系映射)中, filter()方法用于根据给定的条件过滤查询集(QuerySet),
返回一个新的查询集, 其中包含满足条件的所有对象, 而.first()方法则是用来获取查询集中的第一个对象.
即使在查询预期只有一条数据的情况下, 使用filter()方法配合.first()通常也是一个更稳健的做法, 而不是直接使用get()方法.
这是因为get()方法在找不到任何匹配记录时会抛出DoesNotExist异常, 
这可能会中断程序的正常流程, 尤其是在处理用户输入或外部数据源时.

filter().first()能更清晰地表达了意图——想要获取查询集中的第一个对象.
而使用filter()[0]来访问查询集中的第一个对象也是不推荐的做法, 尽管在某些情况下它可能看起来简洁, 
如果查询集为空(即没有找到任何匹配的对象), 尝试访问[0]会抛出一个IndexError异常.)

7.3.5 多表查询

在日常的开发中, 常常需要对多张数据表同时进行数据查询.
多表查询需要在数据表之间建立表关系才能够实现.
一对多或一对一的表关系是通过外键实现关联的, 而多表查询分为正向查询和反向查询.
以模型PersonInfo和Vocation为例, 模型Vocation定义的外键字段name关联到模型PersonInfo.
如果查询对象的主体是模型Vocation, 通过外键字段name去查询模型PersonInfo的关联数据, 那么该查询称为正向查询;
如果查询对象的主体是模型PersonInfo, 要查询它与模型Vocation的关联数据, 那么该查询称为反向查询.
在Django中, 默认的反向查询是通过模型类名的小写形式加上_set来实现的.

无论是正向查询还是反向查询, 两者的实现方法大致相同, 代码如下:

# 正向查询
# 查询模型Vocation某行数据对象v
>>> v = Vocation.objects.filter(id = 1).first()

# v.name代表外键name, 通过外键name去查询模型PersonInfo
>>> v.name
<PersonInfo: Tim>

# 先通过外键获取到模型, 再获取字段的值:
>>> v.name.hire_date
datetime.date(2018, 9, 18)

# 反向查询
# 查询模型PersonInfo某行数据对象p
>>> p = PersonInfo.objects.filter(id = 2).first()
# 方法一
# vocation_set的返回值为queryset对象, 即查询结果,
# vocation_set的vocation为模型Vocation的名称小写.
# 模型Vocation的外键字段name不能设置参数related_name,
# 若设置参数related_name, 则无法使用vocation_set.
>>> v = p.vocation_set.first()
>>> v.job
'软件工程师'

# 方法二
# 由模型Vocation的外键字段name的参数related_name实现,
# 外键字段name必须设置参数related_name才有效, 否则无法查询,
# 将外键字段name的参数related_name设为vocations.
>>> v = p.vocations.first()
>>> v.job

修改一下Vocation外键字段的related_name参数.
这个参数在后续添加, 可能会报错:
django.db.utils.OperationalError: foreign key mismatch - "index_vocation" referencing "index_personinfo"

如果出现这个情况备份数据, 后删除表格和迁移记录, 重新生成迁移文件, 在恢复数据...

class Vocation(models.Model):
    id = models.AutoField(primary_key=True)
    job = models.CharField(max_length=20)
    title = models.CharField(max_length=20)
    payment = models.IntegerField(null=True, blank=True)  # 新增字段,
    # 设置related_name属性
    name = models.ForeignKey(PersonInfo, on_delete=models.CASCADE, related_name='vocations')

    def __str__(self):
        return str(self.id)

    class Meta:
        verbose_name = '职业信息'

# 数据迁移
python manage.py makemigrations
python manage.py migrate
# 导入数据...

# 进入shell环境
python manage.py shell   

# 导入模型
>>> from index.models import *
>>> p = PersonInfo.objects.filter(id = 2).first()
>>> v = p.personinfo.first()
>>> v
<Vocation: 1>
>>> v.job
'软件工程师'

正向查询和反向查询还能在查询条件(filter或get)里使用, 这种方式用于查询条件的字段不在查询当前对象里, 而是在另一张关系表中,
比如查询对象为模型Vocation, 查询条件是模型PersonInfo的某个字段, 对于这种查询可以采用以下方法实现:

# 正向查询
# 使用格式: name__name, 
# 前面的name是模型Vocation的字段name, 也就是外键的字段名称,
# 后面的name是模型PersonInfo的字段name, 两者使用双下画线连接,
# 'Tim'为查询的依据.
>>> v = Vocation.objects.filter(name__name='Tim').first()
# v.name代表外键name
>>> v.name.hire_date
datetime.date(2018, 9, 18)

# 反向查询
# 通过外键name的参数related_name实现反向条件查询,
# vocations代表外键name的参数related_name,
# job代表模型Vocation的字段job,
p = PersonInfo.objects.filter(vocations__job='网站设计').first()
# 通过参数related_name反向获取模型Vocation的数据:
>>> v = p.vocations.first()
>>> v.job
'网站设计'

无论是正向查询还是反向查询, 它们在数据库里需要执行两次SQL查询, 
第一次是查询某张数据表的数据, 再通过外键关联获取另一张数据表的数据信息.
为了减少查询次数, 提高查询效率, 我们可以使用select_related或prefetch_related方法实现,
该方法只需执行一次SQL查询就能实现多表查询.

select_related主要针对一对一和一对多关系进行优化, 它是使用SQL的JOIN语句进行优化的,
通过减少SQL查询的次数来进行优化和提高性能, 其使用方法如下:

# select_related方法, 参数为字符串格式, 
# 以模型PersonInfo为查询对象,
# select_related使用LEFT OUTER JOIN(左连接)方式查询两个数据表,
# 查询模型PersonInfo的字段name和模型Vocation的字段payment.
# select_related参数为vocations, 代表外键字段name的参数related_name, 需要连接的右表.
# 在values参数中输入字段的名称, 左边的字段直接填写字段的名称即可,
# 若要得到其他数据表的关联数据, 则可用双下画线'__'连接字段名,
# 双下画线'__'连接字段名必须是外键字段名或外键字段参数related_name,
# 右连接必须需要使用values方法!!!
>>> p = PersonInfo.objects.select_related('vocations').values('name', 'vocations__payment')

# 查看SQL查询语句
>>> print(p.query)
SELECT "index_personinfo"."name", "index_vocation"."payment" 
FROM "index_personinfo"
LEFT OUTER JOIN "index_vocation"
ON ("index_personinfo"."id" = "index_vocation"."name_id")

>>> p
<QuerySet [{'name': 'Lucy', 'vocations__payment': 5000}, {'name': 'Tim', 'vocations__payment': 10000}, 
           {'name': 'Mary', 'vocations__payment': 8000}, {'name': 'Tony', 'vocations__payment': 12000},
           {'name': 'Tom', 'vocations__payment': 9000}]>

# 以模型Vocation为查询对象
# select_related使用INNER JOIN(内连接)方式查询两个数据表,
# select_related的参数为name, 代表外键字段name:
>>> v = Vocation.objects.select_related('name').values('name', 'name__age')
# 查看SQL查询语句
>>> print(v.query)
SELECT "index_vocation"."name_id", "index_personinfo"."age"
FROM "index_vocation" 
INNER JOIN "index_personinfo" 
ON ("index_vocation"."name_id" = "index_personinfo"."id")

>>> v
<QuerySet [{'name': 2, 'name__age': 18}, {'name': 1, 'name__age': 20}, 
           {'name': 4, 'name__age': 24}, {'name': 3, 'name__age': 22}, 
           {'name': 5, 'name__age': 25}]>  

# 获取两个模型的数据, 以模型Vocation的payment大于8000为查询条件
>>> v = Vocation.objects.select_related('name').filter(payment__gt=8000)
# 查看SQL查询语句
>>> print(v.query)
SELECT "index_vocation"."id", "index_vocation"."job",
"index_vocation"."title", "index_vocation"."payment", 
"index_vocation"."name_id", "index_personinfo"."id",
"index_personinfo"."name", "index_personinfo"."age", 
"index_personinfo"."hire_date" 
FROM "index_vocation" 
INNER JOIN "index_personinfo" 
ON ("index_vocation"."name_id" = "index_personinfo"."id") 
WHERE "index_vocation"."payment" > 8000

>>> v
<QuerySet [<Vocation: 1>, <Vocation: 4>, <Vocation: 5>]>

# 获取查询结果集的首个元素的字段age的数据
# 通过外键字段name定位模型PersonInfo的字段age
>>> v[0].name.age
18

除此之外, select_related还可以支持3个或3个以上的数据表同时查询, 以下面的例子进行说明.

# index 的 models.py
from django.db import models


# 省份信息
class Province(models.Model):
    name = models.CharField(max_length=10)

    def __str__(self):
        return str(self.name)


# 城市信息表
class City(models.Model):
    name = models.CharField(max_length=5)
    # (省)外键
    province = models.ForeignKey(Province, on_delete=models.CASCADE) 

    def __str__(self):
        return str(self.name)


# 人物信息表:
class Person(models.Model):
    name = models.CharField(max_length=10)
    # (生活)外键
    living = models.ForeignKey(City, on_delete=models.CASCADE)

    def __str__(self):
        return str(self.name)

在同一个文件中修改模型, 在执行数据库迁移会将不存在的模型删除.

在上述模型中, 模型Person通过外键living关联模型City, 模型City通过外键province关联模型Province, 从而使3个模型形成一种递进关系.
我们对上述新定义的模型执行数据迁移并在数据表里插入数据, 如图7-20所示.

图7-20　数据表信息

例如, 查询Tom现在所居住的省份, 首先通过模型Person和模型City查出Tom所居住的城市,
然后通过模型City和模型Province查询当前城市所属的省份.
因此, select_related的实现方法如下: