ORM基础之字段及其参数介绍

一、外键ForeignKey
1、字段参数
    1.to
        设置要关联的表

    2.to_field
        设置要关联的表的字段(一般不设置，默认使用主键id关联)

    3.related_name
        反向操作时，使用的字段名，用于代替原反向查询时的'表名_set'

    4.related_query_name
        反向查询操作时，使用的连接前缀，用于替换表名

    5.on_delete
        当删除关联表中的数据时，当前表与其关联的行的行为。

        1.models.CASCADE
            删除关联数据，与之关联的数据也删除(on_delete=models.CASCADE)

        2.抛出异常(错误)
            1.models.DO_NOTHING
            删除关联数据，引发错误IntegrityError


            2.models.PROTECT
            删除关联数据，引发错误ProtectedError


        3.models.SET_NULL
            删除关联数据，与之关联的值设置为null（前提FK字段需要设置为可空）


        4.models.SET_DEFAULT
            删除关联数据，与之关联的值设置为默认值（前提FK字段需要设置默认值）


        5.models.SET
            删除关联数据
            a. 与之关联的值设置为指定值，设置：models.SET(值)
            b. 与之关联的值设置为可执行对象的返回值，设置：models.SET(可执行对象)

    6.db_constraint
    是否在数据库中创建外键约束，默认为True。



二、OneToOneField(一对一)
1、通常一对一字段用来扩展已有字段。

2、字段参数
    1.to
        设置要关联的表。

    2.to_field
        设置要关联的字段。

    3.on_delete
        同ForeignKey字段。


三、ManyToManyField
1、用于表示多对多的关联关系。在数据库中通过第三张表来建立关联关系。

2、字段参数
    1.to
        设置要关联的表

    2.related_name
        同ForeignKey字段(反向操作时，使用的字段名，用于代替原反向查询时的'表名_set')

    3.related_query_name
        同ForeignKey字段(反向查询操作时，使用的连接前缀，用于替换表名)

    4.symmetrical
        仅用于多对多自关联时，指定内部是否创建反向操作的字段。默认为True。
        举个例子：
            class Person(models.Model):
                name = models.CharField(max_length=16)
                friends = models.ManyToManyField("self")
            此时，person对象就没有person_set属性。

            class Person(models.Model):
                name = models.CharField(max_length=16)
                friends = models.ManyToManyField("self", symmetrical=False)
            此时，person对象现在就可以使用person_set属性进行反向查询。

    5.through
        在使用ManyToManyField字段时，Django将自动生成一张表来管理多对多的关联关系。
        但我们也可以手动创建第三张表来管理多对多关系，此时就需要通过through来指定第三张表的表名。

    6.through_fields
        设置关联的字段。

    7.db_table
        默认创建第三张表时，数据库中表的名称。


3、多对多的三种创建方式
    1. 自己建立第三张关系表，外键分别关联两个表
        1. 优点
            1. 可以扩充第三张关系标的字段
        2. 缺点
            1. 自己做连表查询
        3. 建表例子
            class Book(models.Model):
                title = models.CharField(max_length=12)


            class Author(models.Model):
                name = models.CharField(max_length=12)


            # 1. 多对多第一种创建方式：自己创建第三张关系表
            class Author2Book(models.Model):
                id = models.AutoField(primary_key=True)
                author_id = models.ForeignKey(to='Author')
                book_id = models.ForeignKey(to='Book')
                price = models.IntegerField()  # 可以自己扩充需要的字段

    2. 通过ORM内置的ManyToManyField，自动创建第三张关系表
        1. 优点
            1. 提供了很多连表操作的快捷方法--> all(), add(), set(), clear(), remove()
        2. 缺点
            1. 无法扩展第三张关系表
        3. 建表例子
            class Book(models.Model):
                title = models.CharField(max_length=12)


            class Author(models.Model):
                name = models.CharField(max_length=12)
                books = models.ManyToManyField(to='Book')  # 字段就这些，无法扩充其他字段
            
    3. 自己创建第三张关系表，通过ManyToManyField关联
        1. 优点：
            1. 既能够使用多对多查询的快捷方法all()(只能用all，不能使用add,set等)，还能够自己扩展第三张关系表的字段
        2. 建表例子
            class Book(models.Model):
                title = models.CharField(max_length=12)


            class Author(models.Model):
                name = models.CharField(max_length=12)
                # 告诉ManyToManyField通过(through)Author2Book这张表进行关联，不使用ORM自动创建的第三张表，而是使用我自己创建的表
                # through_fields告诉ORM通过哪几个字段进行多对多关联
                books = models.ManyToManyField(to='Book', through='Author2Book', through_fields=('author', 'book'))


            # 1. 多对多第三种创建方式：自己创建第三张关系表，此时外键不需要添加_id了，因为ORM会默认帮你在外键后面加_id
            class Author2Book(models.Model):
                id = models.AutoField(primary_key=True)
                author = models.ForeignKey(to='Author')
                book = models.ForeignKey(to='Book')
                price = models.IntegerField(null=True)

                # author_id和book_id要联合唯一
                class Meta:
                    unique_together = (('author', 'book'),)
            3. 操作例子
                # 多对多的第三张方式也支持all查询
                author_obj = Author.objects.first()
                # 第一个作者的所有书籍
                ret = author_obj.books.all()

                # 给第一个作者添加一本书
                # author_obj.books.add(4) # 报错
                Author2Book.objects.create(author_id=1, book_id=4)



四、元信息
    1、ORM对应的类里面包含另一个Meta类，而Meta类封装了一些数据库的信息。主要字段如下:

    2、元类属性
        1.db_table
            ORM在数据库中的表名默认是 app_类名，可以通过db_table可以重写表名。

        2.index_together
            联合索引。

        3.unique_together
            联合唯一索引。

        4.ordering
            指定默认按什么字段排序。
            只有设置了该属性，我们查询到的结果才可以被reverse()。