Django之ORM框架的使用

Posted 2020-12-10 wakey

一、ORM介绍

ORM：Object-Relation Mapping（对象-关系映射）

优势：

• 只需要面向对象编程，不需要面向数据库编写代码；
• 实现了数据模型与数据库的解耦，屏蔽了不同数据库操作上的差异。

劣势：

• 相比较直接使用SQL语句操作数据库，有性能损失。

ORM与数据库的关系：通常，一个模型（model）映射到一个数据库表。

 二、ORM的使用

1）字段类型

属性名 = models.字段类型,定义属性时需要指定字段类型, 通过字段类型的参数指定选项属性名。

AutoField：自动增长的IntegerField, 不指定时Django会自动创建属性名为id的自动增长属性;

BooleanField：布尔字段，值为True或False;

NullBooleanField：支持Null、True、False三种值;

CharField(max_length=20)：字符串;  参数max_length表示最大字符个数

TextFiled：大文本字段;

IntegerField：整数;

DecimalField(max_digits=None, decimal_places=None)：可以指定精度的十进制浮点数;
　　参数max_digits表示总位数
　　参数decimal_places表示小数位数


FloatField（）：浮点数 

DateField[auto_now=False, auto_now_add=False])：日期

　　参数auto_now表示每次保存对象时，自动设置该字段为当前时间，用于"最后一次修改"的时间戳，它总是使用当前日期，默认为false
　　参数auto_now_add表示当对象第一次被创建时自动设置当前时间，用于创建的时间戳，它总是使用当前日期，默认为false
　　参数auto_now_add和auto_now是相互排斥的，组合将会发生错误

TimeField：参数和DateField一样;

DateTimeField：日期时间，参数同DateField;

FileField：上传文件字段，以二进制的形式;

ImageField：继承于FileField，对上传的内容进行校验，确保是有效的图片。

字段类型

字段选项

null：如果为True，表示允许为空，默认值是False；

blank：如果为True，则该字段允许为空白，默认值是False；

db_column：字段的名称，如果未指定，则使用属性的名称（只限于数据库表中的名字，操作数据库还是类属性的名字）；

db_index：若值为True, 则在表中会为此字段创建索引，默认值是False（为了优化查询速度 ）；

default：默认值，这可以是值或可调用对象。如果可调用，则每次创建新对象时都会调用它；

primary_key：若为True，则该字段会成为模型的主键字段，默认值是False，一般作为AutoField的选项使用；

unique：如果为True, 这个字段在表中必须有唯一值，这个值不能重复，默认值是False。

字段选项

注意：Django会自动为表创建主键字段，如果使用选项设置某属性为主键字段后，Django不会再创建自动增长的主键字段

3）关系字段类型

关系型数据库的关系包括三种类型：

• OneToOneField：一对一
• ForeignKey：一对多
• ManyToManyField：多对多

迁移表：

python manage.py makemigrations stu
python manage.py migrate

三、操作表

# 增
Student.objects.create(name="lucy",pwd="123456")

stu = Student(name="zhangsai",pwd="112121")
stu.save()

# 查
Student.objects.get(sno=1)
Student.objects.all()
Student.objects.filter(name="lucy")

# 删
Student.objects.filter(name="lucy").delete()

# 改
Student.objects.filter(name="jack").update(pwd=‘123456‘)

stu = Student.objects.get(sno=1)
stu.pwd = "111222"
stu.save()

# 获取个数
#
# Student.objects.filter(name=‘seven‘).count()

# 大于，小于
#
# Student.objects.filter(sno__gt=1)              # 获取sno大于1的值
# Student.objects.filter(sno__gte=1)             # 获取sno大于等于1的值
# Student.objects.filter(sno__lt=10)             # 获取sno小于10的值
# Student.objects.filter(sno__lte=10)            # 获取sno小于10的值
# Student.objects.filter(sno__lt=10, sno__gt=1)   # 获取sno大于1 且 小于10的值

# in
#
# Student.objects.filter(sno__in=[11, 22, 33])   # 获取sno等于11、22、33的数据
# Student.objects.exclude(sno__in=[11, 22, 33])  # not in

# isnull
#
# Student.objects.filter(pub_date__isnull=True)

# contains
#
# Student.objects.filter(name__contains="ven")
# Student.objects.filter(name__icontains="ven") # icontains大小写不敏感
# Student.objects.exclude(name__icontains="ven")

# range
#
# Student.objects.filter(sno__range=[1, 2])   # 范围bettwen and

# 其他类似
#
# startswith，istartswith, endswith, iendswith,

# order by
#
# Student.objects.filter(name=‘seven‘).order_by(‘sno‘)    # asc
# Student.objects.filter(name=‘seven‘).order_by(‘-sno‘)   # desc

# group by
#
# from django.db.models import Count, Min, Max, Sum
# Student.objects.values("sname").annotate(dcount=Count("sname"))

Demo：

# 一对一

class Student(models.Model):
    sno = models.AutoField(primary_key=True)
    name = models.CharField(max_length=32, unique=True)
    pwd = models.CharField(max_length=32)

    def __str__(self):
        return u‘Student:%s‘ % self.name


class Scard(models.Model):
    st = models.OneToOneField(Student, primary_key=True, on_delete=models.CASCADE)
    major = models.CharField(max_length=32)

    def __str__(self):
        return u‘Scard:%s‘ % self.major

#======== CRUD ========
        
# 插入数据
stu = Student(name="zhangsai",pwd="112121")
stu.save()

sc = Scard(st=stu,major="计算机")
sc.save()

# 正向查询数据
Student.objects.first().scard

# 反向查询数据
Scard.objects.first().st

# 一对多

class Clazz(models.Model):
    cno = models.AutoField(primary_key=True)
    cname = models.CharField(max_length=32)


class Student(models.Model):
    sno = models.AutoField(primary_key=True)
    sname = models.CharField(max_length=32, unique=True)
    cno = models.ForeignKey(Clazz, on_delete=models.CASCADE)

    def __str__(self):
        return u‘Student:%s‘ % self.sname

#======== CRUD ========

# 正向查询
Clazz.objects.last().student_set.all()

# 反向查询数据
Student.objects.first().cno

# 自定义方法
def insertData(clsname,*sname):
    try:
        cls = Clazz.objects.get(cname=clsname)
    except Clazz.DoesNotExist:
        cls = Clazz.objects.create(cname=clsname)
    for sn in sname:
        try:
            stu = Student.objects.get(sname=sn)
        except Student.DoesNotExist:
            stu = Student.objects.create(sname=sn,cno=cls)
            
insertData("B03mysql","张无忌")
insertData("B04Oracle","金毛狮王")

# 多对多

class Course(models.Model):
    course_no = models.AutoField(primary_key=True)
    course_name = models.CharField(max_length=30)

    def __str__(self):
        return u‘Course:%s‘ % self.course_name


class Teacher(models.Model):
    tno = models.AutoField(primary_key=True)
    tname = models.CharField(max_length=30)
    cour = models.ManyToManyField(Course)

    def __str__(self):
        return u‘Teacher:%s‘ % self.tname

#======== CRUD ========
# 插入数据       
cour1 = Course.objects.create(course_name="Python")
cour2 = Course.objects.create(course_name="Java")
cour3 = Course.objects.create(course_name="html5")
t1 = Teacher.objects.create(tname="张三")
t2 = Teacher.objects.create(tname="李四")

t1.cour.add(cour1,cour2,cour3)

# 正向查询
Course.objects.first().teacher_set.all()

# 反向查询数据
Teacher.objects.first().cour.all()

# 自定义方法
def insertData(t_name,*coursenames):
    try:
        t = Teacher.objects.get(tname=t_name)
    except Teacher.DoesNotExist:
        t = Teacher.objects.create(tname=t_name)
    course_list=[]
    for cour in coursenames:
        try:
            cour = Course.objects.get(course_name=cour)
        except Course.DoesNotExist:
            cour = Course.objects.create(course_name=cour)
            course_list.append(cour)
        t.cour.add(*course_list)
        
insertData("王五","Oracle","MySQL")