django -- ORM建表

前戏

ORM（Object Relational Mapping，简称ORM）模式是一种为了解决面向对象与关系数据库存在的互不匹配的现象的技术。

ORM的优势：

ORM解决的主要问题是对象和关系的映射。它通常将一个类和一张表一一对应，类的每个实例对应表中的一条记录，类的每个属性对应表中的每个字段。

ORM提供了对数据库的映射，不用直接编写SQL代码，只需操作对象就能对数据库操作数据。

让软件开发人员专注于业务逻辑的处理，提高了开发效率。

ORM的劣势：

ORM的缺点是会在一定程度上牺牲程序的执行效率。

ORM的操作是有限的，也就是ORM定义好的操作是可以完成的，一些复杂的查询操作是完成不了。

ORM用多了SQL语句就不会写了，关系数据库相关技能退化...

ORM创建数据表

1. 在Django项目的settings.py文件中，配置数据库连接信息：

DATABASES = {
    "default": {
        "ENGINE": "django.db.backends.mysql",
        "NAME": "你的数据库名称",  # 需要自己手动创建数据库
        "USER": "数据库用户名",
        "PASSWORD": "数据库密码",
        "HOST": "数据库IP",
        "POST": 3306

 } }

2. 在与Django项目同名的目录下的__init__.py文件中写如下代码，告诉Django使用pymysql模块连接MySQL数据库:

import pymysql

pymysql.install_as_MySQLdb()

• 每张表都是一个python类，它是Django.db.models.Model的子类
• 模型的每个属性都代表一个数据库字段
• 模型的对象代表一个数据行

下面代码创建一个person的数据表

from django.db import models

class Person(models.Model):
    id = models.AutoField(primary_key=True)
    name = models.CharField(max_length=32)
    age = models.IntegerField()
    birth = models.DateTimeField(auto_now_add=True)

一些说明：

• 表myapp_person的名称是自动生成的，如果你要自定义表名，需要在model的Meta类中指定 db_table 参数，强烈建议使用小写表名，特别是使用MySQL作为数据库时。
• id字段是自动添加的，如果你想要指定自定义主键，只需在其中一个字段中指定 primary_key=True 即可。如果Django发现你已经明确地设置了Field.primary_key，它将不会添加自动ID列。

字段

AutoField

自增的整形字段，必填参数primary_key=True，则成为数据库的主键。无该字段时，django自动创建，一个model不能有两个AutoField字段。

IntegerField

一个整数类型。数值的范围是 -2147483648 ~ 2147483647。

CharField

字符类型，必须提供max_length参数。max_length表示字符的长度。

DateField

日期类型，日期格式为YYYY-MM-DD，相当于Python中的datetime.date的实例。

　　参数：　　

• auto_now：每次修改时修改为当前日期时间。不管修改的是哪个字段，时间都会更改
• auto_now_add：新创建对象时自动添加当前日期时间。修改其他字段时，时间不会更改

auto_now和auto_now_add和default参数是互斥的，不能同时设置。

DatetimeField

日期时间字段，格式为YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ]，相当于Python中的datetime.datetime的实例。

参数：　　

• auto_now：每次修改时修改为当前日期时间。不管修改的是哪个字段，时间都会更改
• auto_now_add：新创建对象时自动添加当前日期时间。修改其他字段时，时间不会更改

 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   上传图片的宽度保存的数据库字段名（字符串）

     DateTimeField(DateField)
         - 日期+时间格式 YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ]

     DateField(DateTimeCheckMixin, Field)
         - 日期格式      YYYY-MM-DD

     TimeField(DateTimeCheckMixin, Field)
         - 时间格式      HH:MM[:ss[.uuuuuu]]

     DurationField(Field)
         - 长整数，时间间隔，数据库中按照bigint存储，ORM中获取的值为datetime.timedelta类型

     FloatField(Field)
         - 浮点型

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

     BinaryField(Field)
         - 二进制类型

 字段类型

其他字段

官网

自定义字段

自定义一个char类型字段：

class MyCharField(models.Field):
    """
    自定义的char类型的字段类，继承models.Field
    """

    def __init__(self, max_length, *args, **kwargs):
        self.max_length = max_length
        super(MyCharField, self).__init__(max_length=max_length, *args, **kwargs)

    def db_type(self, connection):
        """
        限定生成数据库表的字段类型为char，长度为max_length指定的值
        """
        return 'char(%s)' % self.max_length

使用自定义char类型字段：

from django.db import models

# Create your models here.
class MyCharField(models.Field):
    """
    自定义的char类型的字段类，继承models.Field
    """

    def __init__(self, max_length, *args, **kwargs):
        self.max_length = max_length
        super(MyCharField, self).__init__(max_length=max_length, *args, **kwargs)

    def db_type(self, connection):
        """
        限定生成数据库表的字段类型为char，长度为max_length指定的值
        """
        return 'char(%s)' % self.max_length

class Person(models.Model):
    id = models.AutoField(primary_key=True)
    name = models.CharField(max_length=32)
    age = models.IntegerField()
    birth = models.DateTimeField(auto_now_add=True)
    phone = MyCharField(max_length=11)

Django字段与数据表字段类型的对应关系

class UnsignedIntegerField(models.IntegerField):
    def db_type(self, connection):
        return 'integer UNSIGNED'

# PS: 返回值为字段在数据库中的属性。
# Django字段与数据库字段类型对应关系如下：
    'AutoField': 'integer AUTO_INCREMENT',
    'BigAutoField': 'bigint AUTO_INCREMENT',
    'BinaryField': 'longblob',
    'BooleanField': 'bool',
    'CharField': 'varchar(%(max_length)s)',
    'CommaSeparatedIntegerField': 'varchar(%(max_length)s)',
    'DateField': 'date',
    'DateTimeField': 'datetime',
    'DecimalField': 'numeric(%(max_digits)s, %(decimal_places)s)',
    'DurationField': 'bigint',
    'FileField': 'varchar(%(max_length)s)',
    'FilePathField': 'varchar(%(max_length)s)',
    'FloatField': 'double precision',
    'IntegerField': 'integer',
    'BigIntegerField': 'bigint',
    'IPAddressField': 'char(15)',
    'GenericIPAddressField': 'char(39)',
    'NullBooleanField': 'bool',
    'OneToOneField': 'integer',
    'PositiveIntegerField': 'integer UNSIGNED',
    'PositiveSmallIntegerField': 'smallint UNSIGNED',
    'SlugField': 'varchar(%(max_length)s)',
    'SmallIntegerField': 'smallint',
    'TextField': 'longtext',
    'TimeField': 'time',
    'UUIDField': 'char(32)',

字段参数

上面只是创建了一个字段，那字段都可以放哪些参数呢？常用的有如下这些

null    　　　　　　　　　　# 数据库中字段是否可以为空
db_column  　　　　　　　　# 数据库中字段的列名，进行ORM操作还是用类里写的，方便更改数据库里的字段名
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 　　　　# 自定义错误验证（列表类型），从而定制想要的验证规则
　　　　　　from django.core.validators import RegexValidator
　　　　　　from django.core.validators import EmailValidator, URLValidator, DecimalValidator, \
    　　　　MaxLengthValidator, MinLengthValidator, MaxValueValidator, MinValueValidator

如：
test = models.CharField(
    max_length=32,
    error_messages={
        'c1': '优先错信息1',
        'c2': '优先错信息2',
        'c3': '优先错信息3',
    },
    validators=[
        RegexValidator(regex='root_\d+', message='错误了', code='c1'),
        RegexValidator(regex='root_112233\d+', message='又错误了', code='c2'),
        EmailValidator(message='又错误了', code='c3'), ]
)

Model Meta参数

class UserInfo(models.Model):
    nid = models.AutoField(primary_key=True)
    username = models.CharField(max_length=32)

    class Meta:
        # 数据库中生成的表名称 默认 app名称 + 下划线 + 类名，下面如果写book，则数据表就叫book
        db_table = "table_name"

        # admin中显示的表名称
        verbose_name = '个人信息'

        # verbose_name加s
        verbose_name_plural = '所有用户信息'

        # 联合索引
        index_together = [
            ("pub_date", "deadline"),  # 应为两个存在的字段
        ]

        # 联合唯一索引
        unique_together = (("driver", "restaurant"),)  # 应为两个存在的字段

多表关系和参数

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,              # 默认创建第三张表时，数据库中表的名称