八 .Django 模型(models)

一 .模型 models

1 .常用模型

rom django.db import models


class School(models.Model):
    pass


class Message(models.Model):
    pass


class Teacher(models.Model):
    pass
   
   
class Student(models.Model):

    GENDER_CHOICES = (
        ('male', "男"),
        ('female', "女"),
        ('secret', "保密")
    )

    name = models.CharField(max_length=40, blank=True, verbose_name="姓名")
    gender = models.CharField(max_length=6, choices=GENDER_CHOICES, default="secret", verbose_name="性别")
    age = models.IntegerField(default=0, verbose_name="年龄")
    rank = models.PositiveIntegerField(default=1, verbose_name="排名", unique=True)
    discount = models.DecimalField(max_digits=3, decimal_places=2, verbose_name="折扣", default=1.0)
    school = models.ForeignKey(to=School, verbose_name="学校", on_delete=models.CASCADE)
    message = models.OneToOneField(to=Message, verbose_name="信息", on_delete=models.CASCADE)
    teacher = models.ManyToManyField(verbose_name="老师", to=Teacher, blank=True)
    introduce = models.TextField(blank=True, verbose_name="介绍")
    grade = models.FloatField(default=0.0, verbose_name="成绩")
    url = models.URLField(verbose_name="个人主页", max_length=100)
    email = models.EmailField(verbose_name="邮箱")
    image = models.ImageField(upload_to='img/%Y/%m/%d/', verbose_name='上传图片', null=True)
    file = models.FileField(upload_to="file/%Y/%m/%d/", verbose_name="上传文件", blank=True)
    is_deleted = models.BooleanField(verbose_name="已删除", default=False, blank=True)
    time_added = models.DateTimeField(verbose_name="添加时间", auto_now_add=True, blank=True)

    def delete(self, using=None, keep_parents=False):
        self.is_deleted = True
        # some actions
        self.save()

    def save(self, force_insert=False, force_update=False, using=None,
             update_fields=None):
        # some actions
        self.name = self.name.capitalize()  # 首字母大写
        return super().save(force_insert=force_insert, force_update=force_update, using=using,
                            update_fields=update_fields)

    def __repr__(self):
        return "UserProfile:{}".format(self.name)

    def __str__(self):
        return self.name

    class Meta:
        ordering = ['-time_added']
        verbose_name = "用户信息"
        verbose_name_plural = verbose_name
        db_table = "student_info"
        unique_together = ("name", "gender")

# 1. python manage.py makemigrations  创建迁移的命令是
# 2.python manage.py migrate  执行迁移的命令
# https://www.cnblogs.com/yebaofang/p/9863678.html   遇到问题  降级django 或者 升级mysql

from django.db import models
# 班级
class Grades(models.Model):
    gname = models.CharField(max_length=20)
    gdate = models.DateTimeField()
    ggirlnum = models.IntegerField()
    gboynum = models.IntegerField()
    isDelete = models.BooleanField(default=False)
    def __str__(self):  # (重写)
        return self.gname
    class Meta:
        db_table = "grades"  # 定义数据表名(推荐使用小写 数据表默认项目小写 类名)
        ordering = []
        # https://www.cnblogs.com/wt11/p/9660794.html
        # https://blog.csdn.net/JamesPaul32/article/details/80776006


# 学生
class Students(models.Model):
    sname = models.CharField(max_length=20)
    sgender = models.BooleanField(default=True)
    sage = models.IntegerField(db_column="age")
    scontend = models.CharField(max_length=20)
    isDelete = models.BooleanField(default=False)
    # 是关联Grades    学生关联班级
    grad= models.ForeignKey("Grades",on_delete=models.CASCADE)
    # 一对多：models.ForeignKey(其他表)
    # on_delete = models.CASCADE
    # https://www.cnblogs.com/phyger/p/8035253.html

    def getName(self):
        return self.sname
    def __str__(self):  # (重写)
        return self.sname
    localTime = models.DateField(auto_now=True)
    # """
    # auto_now = True   # 这个参数的默认值为false，设置为true时，能够在保存该字段时，将其值设置为当前时间，
    # 并且每次修改model，都会自动更新。因此这个参数在需要存储“最后修改时间”的场景下，十分方便。需要注意的是，
    # 设置该参数为true时，并不简单地意味着字段的默认值为当前时间，而是指字段会被“强制”更新到当前时间，
    # 你无法程序中手动为字段赋值；如果使用django再带的admin管理器，那么该字段在admin中是只读的
    # """

    createTime = models.DateField(auto_now_add=True)
     #  """    # auto_now_add = True
     #  # 这个参数的默认值也为False，设置为True时，会在model对象第一次被创建时，将字段的值设置为创建时的时间，以后修改对象时，
     #  # 字段的值不会再更新。该属性通常被用在存储“创建时间”的场景下。与auto_now类似，auto_now_add也具有强制性，
     # # 一旦被设置为True，就无法在程序中手动为字段赋值，在admin中字段也会成为只读的。"""

    class Meta:
        db_table = "students"  # 定义数据表名(推荐使用小写 数据表默认项目小写 类名)
        ordering = ['id']  # 对象默认排序字段  获取对象列表时使用
        # https://www.cnblogs.com/wt11/p/9660794.html
        # https://blog.csdn.net/JamesPaul32/article/details/80776006

    V=models.CharField(max_length=None[, **options])　　　　#varchar
    V=models.EmailField([max_length=75, **options])　　　　#varchar
    V=models.URLField([verify_exists=True, max_length=200, **options])　　　　#varchar
    V=models.FileField(upload_to=None[, max_length=100, **options])　　　　#varchar


    #upload_to指定保存目录可带格式，
    V=models.ImageField(upload_to=None[, height_field=None, width_field=None, max_length=100, **options])
    V=models.IPAddressField([**options])　　　　#varchar
    V=models.FilePathField(path=None[, match=None, recursive=False, max_length=100, **options])　#varchar
    V=models.SlugField([max_length=50, **options])　　　　#varchar，标签，内含索引
    V=models.CommaSeparatedIntegerField(max_length=None[, **options])　　　　#varchar
    V=models.IntegerField([**options])　　　　#int
    V=models.PositiveIntegerField([**options])　　　　#int 正整数
    V=models.SmallIntegerField([**options])　　　　#smallint
    V=models.PositiveSmallIntegerField([**options])　　　　#smallint 正整数
    V=models.AutoField(**options)　　　　#int；在Django代码内是自增
    V=models.DecimalField(max_digits=None, decimal_places=None[, **options])　　　　#decimal
    V=models.FloatField([**options])　　　　#real
    V=models.BooleanField(**options)　　　　#boolean或bit
    V=models.NullBooleanField([**options])　　　　#bit字段上可以设置上null值
    V=models.DateField([auto_now=False, auto_now_add=False, **options])　　　　#date
    #auto_now最后修改记录的日期；auto_now_add添加记录的日期
    V=models.DateTimeField([auto_now=False, auto_now_add=False, **options])　　　　#datetime
    V=models.TimeField([auto_now=False, auto_now_add=False, **options])　　　　#time
    V=models.TextField([**options])　　　　#text
    V=models.XMLField(schema_path=None[, **options])　　　　#text
    ——————————————————————————–
    V=models.ForeignKey(othermodel[, **options])　　　　#外键，关联其它模型，创建关联索引
    V=models.ManyToManyField(othermodel[, **options])　　　　#多对多，关联其它模型，创建关联表
    V=models.OneToOneField(othermodel[, parent_link=False, **options])　　　　#一对一，字段关联表属性

2. models字段介绍

1 创建类：继承model
   
   class UserInfo(model.model):
      user=CharFiled(是否为空 类型 长度 列名 索引)

3. 字段:
 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)
        - 二进制类型

DateTimeField

在Django中，代表时间字段的有三种：DateTimeField、DateField、TimeField，三种类型分别对应datetime()、date()、time()，都有auto_now和auto_now_add参数。
auto_now
默认值为False，设置为True时会在每次修改该对象时自动更新为当前时间，但是无法手动修改该字段的值。
auto_now_add
默认值为False，设置为True时会在创建对象时自动设置为当前时间，之后都不再修改，也不能手动修改其值。
默认当前时间，又能修改
有时候我们需要在创建对象时设置字段的值为当前时间，在后续时又能修改，使用auto_now或者auto_now_add都无法实现这一点。此时，可以使用default参数来设置默认值，如下

from django.db import models
from django.utils import timezone
class Message(models.Model):
    add_date = models.DateTimeField(verbose_name='保存日期',default = timezone.now)
    mod_date = models.DateTimeField(verbose_name='最后修改日期', auto_now = True) 

4. models(表的关联)

ForeignKey对一

使用to指向被关联的模型，使用on_delete来规定被关联对象删除时该对象的处理方式。主要有两种取值，models.CASCADE和models.SET_NULL。models.CASCADE表示当被关联对象删除时删除该对象，
models.SET_NULL表示当被关联对象被删除时将该对象设置为空，此设置的前提是该字段要允许为空。

原生mysql

create table class(
    id int primary key auto_increment,
    course varchar(20) not null

);
select student.id,student.name,class.course  from student left JOIN class on  student.class_id=class.id;

create table student(
    id int primary key auto_increment,
    name varchar(20) not null,
    class_id int not null,
         constraint class_id  foreign key(class_id ) references class(id)
    on delete cascade
    on update cascade
);

orm之model创建

class Classes(models.Model):
     title=models.CharField(max_length=32)

# 学生表
class Student(models.Model):
     username=models.CharField(max_length=32)
     age= models.IntegerField()
     gender=models. BooleanField()
     #  一对多：就是主外键关系；（foreign key）
     cs=models.ForeignKey(Classes) 

学生表关联客户表, 学生一定是客户,客户不一定是学生.
create table customer(
id int primary key auto_increment,
name char(10),
qq int
);


create table  stu(
id int primary key auto_increment,
name varchar(10),
cid int unique,
foreign key(cid) references customer(id)
);

ManyToManyField(多对多)

一个学生可以对应多个老师，一个老师也可以教多个学生，这就是一种多对多的关系

orm模型创建

class Teacher(models.Model):
    '''老师表'''
    teacher_name = models.CharField(max_length=30, verbose_name="老师", default="")
    tel = models.CharField(max_length=30, verbose_name="电话", default="")
    mail = models.CharField(max_length=30, verbose_name="邮箱", default="")

    class Meta:
        verbose_name = "老师"
        verbose_name_plural = verbose_name
    def __str__(self):
        return self.teacher_name

class Student(models.Model):
    '''学生表'''
    student_id = models.CharField(max_length=30, verbose_name="学号", default="")
    name = models.CharField(max_length=30, verbose_name="姓名", default="")
    age = models.IntegerField(verbose_name="年龄",  default="")
    # 多对多
    teachers = models.ManyToManyField(Teacher, verbose_name="老师")

    class Meta:
        verbose_name = "学生"
        verbose_name_plural = verbose_name

    def __str__(self):
        return self.name

原生 mysql 语句创建

create table book(
id int primary key auto_increment,
name varchar(20) not null
);


create table author (
id int primary key auto_increment,
name varchar(20),
price float(5)
);


create table book2author(
id int primary key auto_increment,
book_id int,
author_id int,
foreign key(book_id) references book(id)
on delete cascade
on update cascade,
foreign key(author_id) references author(id)
on delete cascade
on update cascade,
unique(book_id,author_id)
);
 

OneToOne 一对一

当某个对象想扩展自另一个对象，那可以再这个对象的主键上添加一对一的关系。例如：

orm 模型表
class Place(model.Model):
         address=models.CharField()
        phone=models.Integer()

class Restaurant(Models.model):
        place=models.OneToOneField(Plase)

原生sql语句

user 和 admin的一对一关系

create teable user(

id int premary key auto_increment,

name varchar(10)

on delete cascade

on update cascade# 只管理被关联的表

);

create table admin(

id int priment key auto_increment,

password varchar(10),

user_id int unique,

foreign key(user_id) references user(id)

);

5. 字段里面参数信息

class UserInfo(models.Model):

         username=models.CharField(
             null=True,
             db_column="user",
             max_length=32,
             db_index=True,   # 只能加速查找 
             verbose_name="用户名!!",
             editable=False
             # unique=True,      #  加速查找限制列的唯一
             # primary=True    # 只能加速查找   限制列的唯一 不能为空
       
            )

   # primary_key         数据库中字段是否为主键
   #  db_index            数据库中字段是否可以建立索引
   #  unique              数据库中字段是否可以建立唯一索引



class SomeBody(models.Model):
    caption=models.CharField(max_length=24),
    pk=models.ForeignKey(
        to="UserInfo",      # ForeignKey 关联表
        to_field="id" ,      # 表示与 UserInfo表的id关联 
      # related_name="b",      #     反向操作时，使用的字段名，用于代替 
        related_query_name="b",    # 反向操作时，使用的连接前缀，用于替换【表名】
    )    

class User(models.Model):
    username=models.CharField(max_length=24,db_index=True)
    par=models.ForeignKey(
               to="Part",
               to_field="id",
               limit_choices_to={"id__gt":1}     #只能在admin中生效 筛选出id大于一的
                                                # 在Admin或ModelForm中显示关联数据时，提供的条件：
        )
class Part(models.Model):
    caption=models.CharField(max_length=24)
    def __str__(self):

        return self.caption


class Tag(models.Model):
    title=models.CharField(max_length=24)
    m=models.ManyToManyField(     #  ManyToManyField d多对多
        to="User"  ,             # 默认和user表的主键进行管理

# 表一
class User(models.Model):
    username=models.CharField(max_length=24,db_index=True)
    def __str__(self):
         return self.username

# 表二
class Tag(models.Model):
    title=models.CharField(max_length=24)
    def __str__(self):
         return self.title
    # m=models.ManyToManyField(     #  ManyToManyField d多对多  使用 ManyToManyField 只能在第三章表 中创建三列数
    #     to="User"  ,             # 默认和user表的主键进行管理
              
    #     )


# 自定义第三张表
class UserToTag(models.Model):
    u=models.ForeignKey(to="User")
    t=models.ForeignKey(to="Tag")
    ctime=models.DateField()    
    class Meta:  #  表示联合唯一  和 ManyToManyField 差不多
        unique_together=[    # 表达的意思就是标签和同一个人不能出现多次  就一个人对应一个标签
           ("u","t"),
        ]

 6. 元信息

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

  在模型类中定义Meta类 用于设置元信息

                  class Meta:

                        db_table=""     定义数据表名(推荐使用小写 数据表默认项目小写 类名)

                         ordering=[]  对象默认排序字段  获取对象列表时使用
                         ordering=['id']     升序
                         ordering=['-id']    降序

    class Meta:
        db_table = "students"  # 定义数据表名(推荐使用小写 数据表默认项目小写 类名)
        ordering = ['id']  # 对象默认排序字段  获取对象列表时使用