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

1、外键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。



2、OneToOneField(一对一)
1、一般一对一字段用来扩展已有字段。

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

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

    3.on_delete
        同ForeignKey字段。


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



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

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

        2.index_together
            联合索引。

        3.unique_together
            联合惟一索引。

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