【Django入坑之路】Models操作

1：字段

 AutoField(Field)
         - int自增列，必须填入参数 primary_key=True

 BigAutoField(AutoField)
         - bigint自增列，必须填入参数 primary_key=True

         注：当model中如果没有自增列，则自动会创建一个列名为id的列
         from django.db import models

         class UserInfo(models.Model):
             # 自动创建一个列名为id的且为自增的整数列
             username = models.CharField(max_length=32)

         class Group(models.Model):
             # 自定义自增列
             nid = models.AutoField(primary_key=True)
             name = models.CharField(max_length=32)

 SmallIntegerField(IntegerField):
         - 小整数 -32768 ～ 32767

 PositiveSmallIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField)
         - 正小整数 0 ～ 32767
     IntegerField(Field)
         - 整数列(有符号的) -2147483648 ～ 2147483647

 PositiveIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField)
         - 正整数 0 ～ 2147483647

 BigIntegerField(IntegerField):
         - 长整型(有符号的) -9223372036854775808 ～ 9223372036854775807

 BooleanField(Field)
         - 布尔值类型

 NullBooleanField(Field):
         - 可以为空的布尔值

 CharField(Field)
         - 字符类型
         - 必须提供max_length参数， max_length表示字符长度

 TextField(Field)
         - 文本类型

 EmailField(CharField)：
         - 字符串类型，Django Admin以及ModelForm中提供验证机制

 IPAddressField(Field)
         - 字符串类型，Django Admin以及ModelForm中提供验证 IPV4 机制

 GenericIPAddressField(Field)
         - 字符串类型，Django Admin以及ModelForm中提供验证 Ipv4和Ipv6
         - 参数：
             protocol，用于指定Ipv4或Ipv6， 'both',"ipv4","ipv6"
             unpack_ipv4， 如果指定为True，则输入::ffff:192.0.2.1时候，可解析为192.0.2.1，开启刺功能，需要protocol="both"

 URLField(CharField)
         - 字符串类型，Django Admin以及ModelForm中提供验证 URL

 SlugField(CharField)
         - 字符串类型，Django Admin以及ModelForm中提供验证支持 字母、数字、下划线、连接符（减号）

 CommaSeparatedIntegerField(CharField)
         - 字符串类型，格式必须为逗号分割的数字

 UUIDField(Field)
         - 字符串类型，Django Admin以及ModelForm中提供对UUID格式的验证

 FilePathField(Field)
         - 字符串，Django Admin以及ModelForm中提供读取文件夹下文件的功能
         - 参数：
                 path,                      文件夹路径
                 match=None,                正则匹配
                 recursive=False,           递归下面的文件夹
                 allow_files=True,          允许文件
                 allow_folders=False,       允许文件夹

 FileField(Field)
         - 字符串，路径保存在数据库，文件上传到指定目录
         - 参数：
             upload_to = ""      上传文件的保存路径
             storage = None      存储组件，默认django.core.files.storage.FileSystemStorage

 ImageField(FileField)
         - 字符串，路径保存在数据库，文件上传到指定目录
         - 参数：
             upload_to = ""      上传文件的保存路径
             storage = None      存储组件，默认django.core.files.storage.FileSystemStorage
             width_field=None,   上传图片的高度保存的数据库字段名（字符串）
             height_field=None   上传图片的宽度保存的数据库字段名（字符串）

 #时间： auto_now_add 自动创建时间
     create_time = models.DateTimeField(auto_now_add=True)
 # 数据库调用时间格式化传入前端：.strftime("%Y-%m-%d")
     time = '表对象名字'.create_time.strftime("%Y-%m-%d")
  PS:格式化的时间传入前端不需要加|safe ,直接填写字典key就可以

 FloatField(Field)
         - 浮点型

 DecimalField(Field)
         - 10进制小数
         - 参数：
             max_digits，小数总长度
             decimal_places，小数位长度

 BinaryField(Field)
         - 二进制类型

2：字段参数

 null                数据库中字段是否可以为空

 db_column           数据库中字段的列名

 default             数据库中字段的默认值

 primary_key         数据库中字段是否为主键

 db_index            数据库中字段是否可以建立索引

 unique              数据库中字段是否可以建立唯一索引

 unique_for_date     数据库中字段【日期】部分是否可以建立唯一索引

 unique_for_month    数据库中字段【月】部分是否可以建立唯一索引

 unique_for_year     数据库中字段【年】部分是否可以建立唯一索引

 verbose_name        Admin中显示的字段名称

 blank               Admin中是否允许用户输入为空

 editable            Admin中是否可以编辑

 help_text           Admin中该字段的提示信息

 choices             Admin中显示选择框的内容，用不变动的数据放在内存中从而避免跨表操作
                         如：gf = models.IntegerField(choices=[(0, '何穗'),(1, '大表姐'),],default=1)

 error_messages      自定义错误信息（字典类型），从而定制想要显示的错误信息；
                         字典健：null, blank, invalid, invalid_choice, unique, and
 unique_for_date
                         如：{'null': "不能为空.", 'invalid': '格式错误'}

 validators          1 #自定义正则

  from django.core import validators

      email = forms.CharField(min_length=3, max_length=32, required=True,
                              widget=widgets.TextInput(attrs={"class": "form_text", "placeholder": "请输入您的邮箱"}),
                              validators=[validators.RegexValidator('@', message="邮箱格式错误")]  #'@'用于写自定义正则表达式

3：元信息

 class UserInfo(models.Model):
         nid = models.AutoField(primary_key=True)
         username = models.CharField(max_length=32)
         class Meta:
             # 数据库中生成的表名称 默认 app名称 + 下划线 + 类名
             db_table = "table_name"

             # 联合索引
             index_together = [
                 ("pub_date", "deadline"),
             ]

             # 联合唯一索引
             unique_together = (("driver", "restaurant"),)

             # admin中显示的表名称
             verbose_name

             # verbose_name加s
             verbose_name_plural

4：多表关系以及参数

 ForeignKey(ForeignObject) # ForeignObject(RelatedField)
         to,                         # 要进行关联的表名
         to_field=None,              # 要关联的表中的字段名称
         on_delete=None,             # 当删除关联表中的数据时，当前表与其关联的行的行为
                                         - models.CASCADE，删除关联数据，与之关联也删除
                                         - models.DO_NOTHING，删除关联数据，引发错误IntegrityError
                                         - models.PROTECT，删除关联数据，引发错误ProtectedError
                                         - models.SET_NULL，删除关联数据，与之关联的值设置为null（前提FK字段需要设置为可空）
                                         - models.SET_DEFAULT，删除关联数据，与之关联的值设置为默认值（前提FK字段需要设置默认值）
                                         - models.SET，删除关联数据，
                                                       a. 与之关联的值设置为指定值，设置：models.SET(值)
                                                       b. 与之关联的值设置为可执行对象的返回值，设置：models.SET(可执行对象)

                                                         def func():
                                                             return 10

                                                         class MyModel(models.Model):
                                                             user = models.ForeignKey(
                                                                 to="User",
                                                                 to_field="id"
                                                                 on_delete=models.SET(func),)
         related_name=None,          # 反向操作时，使用的字段名，用于代替 【表名_set】 如： obj.表名_set.all()
         related_query_name=None,    # 反向操作时，使用的连接前缀，用于替换【表名】     如： models.UserGroup.objects.filter(表名__字段名=1).values('表名__字段名')
         limit_choices_to=None,      # 在Admin或ModelForm中显示关联数据时，提供的条件：
                                     # 如：
                                             - limit_choices_to={'nid__gt': 5}
                                             - limit_choices_to=lambda : {'nid__gt': 5}

                                             from django.db.models import Q
                                             - limit_choices_to=Q(nid__gt=10)
                                             - limit_choices_to=Q(nid=8) | Q(nid__gt=10)
                                             - limit_choices_to=lambda : Q(Q(nid=8) | Q(nid__gt=10)) & Q(caption='root')
         db_constraint=True          # 是否在数据库中创建外键约束
         parent_link=False           # 在Admin中是否显示关联数据

     OneToOneField(ForeignKey)
         to,                         # 要进行关联的表名
         to_field=None               # 要关联的表中的字段名称
         on_delete=None,             # 当删除关联表中的数据时，当前表与其关联的行的行为

                                     ###### 对于一对一 ######
                                     # 1. 一对一其实就是 一对多 + 唯一索引
                                     # 2.当两个类之间有继承关系时，默认会创建一个一对一字段
                                     # 如下会在A表中额外增加一个c_ptr_id列且唯一：
                                             class C(models.Model):
                                                 nid = models.AutoField(primary_key=True)
                                                 part = models.CharField(max_length=12)

                                             class A(C):
                                                 id = models.AutoField(primary_key=True)
                                                 code = models.CharField(max_length=1)

     ManyToManyField(RelatedField)
         to,                         # 要进行关联的表名
         related_name=None,          # 反向操作时，使用的字段名，用于代替 【表名_set】 如： obj.表名_set.all()
         related_query_name=None,    # 反向操作时，使用的连接前缀，用于替换【表名】     如： models.UserGroup.objects.filter(表名__字段名=1).values('表名__字段名')
         limit_choices_to=None,      # 在Admin或ModelForm中显示关联数据时，提供的条件：
                                     # 如：
                                             - limit_choices_to={'nid__gt': 5}
                                             - limit_choices_to=lambda : {'nid__gt': 5}

                                             from django.db.models import Q
                                             - limit_choices_to=Q(nid__gt=10)
                                             - limit_choices_to=Q(nid=8) | Q(nid__gt=10)
                                             - limit_choices_to=lambda : Q(Q(nid=8) | Q(nid__gt=10)) & Q(caption='root')
         symmetrical=None,           # 仅用于多对多自关联时，symmetrical用于指定内部是否创建反向操作的字段
                                     # 做如下操作时，不同的symmetrical会有不同的可选字段
                                         models.BB.objects.filter(...)

                                         # 可选字段有：code, id, m1
                                             class BB(models.Model):

                                             code = models.CharField(max_length=12)
                                             m1 = models.ManyToManyField('self',symmetrical=True)

                                         # 可选字段有: bb, code, id, m1
                                             class BB(models.Model):

                                             code = models.CharField(max_length=12)
                                             m1 = models.ManyToManyField('self',symmetrical=False)

         through=None,               # 自定义第三张表时，使用字段用于指定关系表
         through_fields=None,        # 自定义第三张表时，使用字段用于指定关系表中那些字段做多对多关系表
                                         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)
         db_constraint=True,         # 是否在数据库中创建外键约束
         db_table=None,              # 默认创建第三张表时，数据库中表的名称