关于ORM本质的理解

1、ORM——对象关系映射

• 对象是模型类对象
• 关系是关系型数据库
• 映射是指一一对应

总而言之，可以理解成一个模型类对应一张表，一个模型类对象对应一条数据，这就是所谓的对象关系映射；通过类和类对象就能操作它所对应的表格中的数据；根据我们设计的类自动帮我们生成数据库中的表格；

2、ORM操作本质

• 1、编写模型类语法，翻译成对应的sql语句
• 2、调用mysql驱动程序如pymysql把翻译的sql语句发送到mysql服务端执行，并获取操作结果

Django数据库配置

1、安装pymysql作为数据库驱动

增删改查

1、增加/新建/保存

# 方案一：创建模型类对象，然后调用对象save方法实现新建保存
# 1、新建模型类对象(实例化/初始化参数，就是对应的模型类类属性，也就是字段)
book = BookInfo(btitle=xxx....) # 此处仅仅只是构建了sql语句，没有和mysql通信；
# 2、调用save方法
book.save()# 方案二：使用模型类管理器：objects
book = BookInfo.objects.create(btitle=xxx...) # 直接新建保存，并且返回新建对象

2、删除

# 使用get方法查询出唯一的对象
book = BookInfo.objects.get(id=1) # get(pk=1)
book.delete() # 通过模型类对象delete()方法调用删除该条数据# 使用filter方法查询出多条数据,批量删除
BookInfo.objects.filter(bread=100).delete() # 批量删除多条数据对象

3、更新/修改

• 一个对象重复保存即更新；
• 一个对象的实例属性映射的就是该条数据对应的字段值；

# 单一对象更新操作
book = BookInfo.objects.get(pk=1)
book.btitle="xxxx"
book.bcomment=100
book.save()# 批量更新操作
book_queryset = BookInfo.objects.filter(bread=22) # QuerySet类型对象(该对象里保存了多条模型类对象)
book_queryset.update(bread=33, bcomment=100)

4、过滤查询

4.1 整数类型字段比较查询

# select * from tb_books where bread = 44;
BookInfo.objects.filter(bread=44)
BookInfo.objects.filter(bread__exact=44)
# select * from tb_books where bread > 44;
BookInfo.objects.filter(bread__gt=44)
# select * from tb_books where bread >= 44;
BookInfo.objects.filter(bread__gte=44)
# select * from tb_books where bread < 44;
BookInfo.objects.filter(bread__lt=44)
# select * from tb_books where bread <= 44;
BookInfo.objects.filter(bread__lte=44)
# select * from tb_books where bread != 44;
# elect * from tb_books where not (bread=44);
BookInfo.objects.exclude(bread=44)

4.2 字符类型字段的模糊查询

# select * from tb_books where btitle like '%传%';
BookInfo.objects.filter(btitle__contains='传') # 包含
# select * from tb_books where btitle like '传%';
BookInfo.objects.filter(btitle__startswith='天') # 开头
# select * from tb_books where btitle like '%传';
BookInfo.objects.filter(btitle__endswith='狐') # 结尾

4.3 空查询

# select * from tb_books where btitle is null;
BookInfo.objects.filter(btitle__isnull=True)
# select * from tb_books where btitle is not null;
BookInfo.objects.filter(btitle__isnull=False)

4.4 范围查询

# select * from tb_books where id in (1,2,3);
BookInfo.objects.filter(id__in=[1,2,3])

4.5 日期查询

# 查询bpub_date日期字段属于1980年份，支持查询有：year、month、day等
BookInfo.objects.filter(bpub_date__year=1980)
# 直接把bpub_date字段和python的日期类型对象进行比较
BookInfo.objects.filter(bpub_date__gt=date(1990, 1, 1))

聚合查询

from django.db.models import Sum,Avg,Count,Max,Min
BookInfo.objects.aggregate(Sum('bread'))

排序查询

BookInfo.objects.all().order_by('bread')  # 升序
BookInfo.objects.all().order_by('-bread')  # 降序

复合条件查询

1、使用Q对象拼接具备与(and)或(or)非(not)关系的复合查询条件

from django.db.models import Q
# 结论：filter函数以关键字参数传入的多个查询条件之间是and关系；
# select * from tb_books where (id>1 and id<3);
BookInfo.objects.filter(id__gt=1, id__lt=3)
# 结论：把多个条件表达式，传入Q对象，然后使用“|”运算符把多个表达式构建成互为“and”关系
BookInfo.objects.filter(Q(id__gt=1) & Q(id__lt=3))# 结论：把多个条件表达式，传入Q对象，然后使用“|”运算符把多个表达式构建成互为“or”关系
# select * from tb_books where (id>1 or id<3);
BookInfo.objects.filter(Q(id__gt=1) | Q(id__lt=3))# 结论：把条件表达式传入Q对象中，在Q对象前使用“～”符号进行条件的取反，本质是在sql语句中在表达式之前添加not取反关键字
# select * from tb_books where not (id>1);
BookInfo.objects.filter(~Q(id__gt=1))

2、使用F对象，实现使用一张表中多个字段比较的查询

from django.db.models import F# 结论：把比较的另一个字段名传入F初始化参数中，构建F对象进行比较
# select * from tb_books where bread>=bcomment;
BookInfo.objects.filter(bread__gte=F('bcomment'))# 结论：F对象支持加减乘除操作
# select * from tb_books where bread>=(bcomment*2);
BookInfo.objects.filter(bread__gte=F('bcomment')*2)

关联查询

1、根据主表已知条件，查询从表多条数据

# ----------- 从主表入手-----------
# 方案一：传统方式
# 1、查询主表单一数据
book = BookInfo.objects.get(pk=1)
# 2、通过从表模型类进一步查询从表目标数据
HeroInfo.objects.filter(hbook=book)
# HeroInfo.objects.filter(hbook_id=book.id)# 方案二：使用Django提供的快捷方法查询 --- 从主表入手
# 1、查询主表单一数据
book = BookInfo.objects.get(pk=1)
# 2、根据默认的主表中的隐藏字段"<从表模型类名小写>_set"，如果在从表中ForeignKey中定义了related_name那么该隐藏字段就是related_name指定的！
book.heroinfo_set.all() # 与当前主表对象book关联的多个从表对象# 注意：通过从表设置的ForeignKey中添加related_name约束条件，来自定义主表中用来表示关联从表多条数据的隐藏字段名；
# hbook = models.ForeignKey(BookInfo, related_name='heros')
# book.heros.all()# ----------- 从主表入手-----------
# 书名是"天龙八部"关联的所有的英雄
HeroInfo.objects.filter(hbook__btitle='天龙八部')

2、根据从表已知条件，查询主表单一数据

# ----------- 从从表入手-----------
# 1、根据从表已知条件，查询单一主表数据
hero = HeroInfo.objects.get(pk=13)
# 2、通过从表对象中的ForeignKey类型字段，获取关联主表单一对象
hero.hbook # 主表单一对象# ----------- 从主表入手-----------
# 如果从表的ForeignKey中设置了related_name='heros'
BookInfo.objects.filter(heros__hname='王语嫣')
# 如果从表的ForeignKey中没有设置related_name
BookInfo.objects.filter(<从表模型类名小写>_set__hname='王语嫣')

QuerySet查询集

Django模型类语法查询出来的结果集；

1、惰性执行

当且仅当我们使用查询集的时候，才会真的和数据库发生交互，请求查询数据；

2、缓存

• 1、对查询集进行迭代操作的时候，会触发缓存；
• 2、对查询集进行逻辑判断的时候，会触发缓存；
• 3、注意，打印查询集，不会触发缓存！

数据表关联操作

一对多

一本书里面会有多个英雄人物，每个英雄人物都会属于某一本书
数据表一：图书信息 BookInfo (一方)
数据表二：英雄信息 HeroInfo (多方)
外键的定义方式：外键定义在多方对应的模型类中，即，外键需要定义在HeroInfo中外键属性名 = models.ForeignKey(一方对应的模型类名)

class BookInfo(models.Model):"""图书信息：演示一对多，一"""btitle = models.CharField(max_length=20, verbose_name='名称')bpub_date = models.DateField(verbose_name='发布日期')bread = models.IntegerField(default=0, verbose_name='阅读量')bcomment = models.IntegerField(default=0, verbose_name='评论量')is_delete = models.BooleanField(default=False, verbose_name='逻辑删除')class Meta:db_table = 'tb_books'  # 指明数据库表名def __str__(self):"""定义每个数据对象的显示信息"""return self.btitleclass HeroInfo(models.Model):"""英雄信息：演示一对多，多"""hbook = models.ForeignKey(BookInfo, on_delete=models.CASCADE, verbose_name='图书')hname = models.CharField(max_length=20, verbose_name='名称')hgender = models.SmallIntegerField(default=0, verbose_name='性别')hcomment = models.CharField(max_length=200, null=True, verbose_name='描述信息')is_delete = models.BooleanField(default=False, verbose_name='逻辑删除')class Meta:db_table = 'tb_heros'def __str__(self):return self.hname

insert into tb_books(btitle,bpub_date,bread,bcomment,is_delete) values
('射雕英雄传','1980-5-1',12,34,0),
('天龙八部','1986-7-24',36,40,0),
('笑傲江湖','1995-12-24',20,80,0),
('雪山飞狐','1987-11-11',58,24,0);insert into tb_heros(hname,hgender,hbook_id,hcomment,is_delete) values
('郭靖',1,1,'降龙十八掌',0),
('黄蓉',0,1,'打狗棍法',0),
('黄药师',1,1,'弹指神通',0),
('欧阳锋',1,1,'蛤蟆功',0),
('梅超风',0,1,'九阴白骨爪',0),
('乔峰',1,2,'降龙十八掌',0),
('段誉',1,2,'六脉神剑',0),
('虚竹',1,2,'天山六阳掌',0),
('王语嫣',0,2,'神仙姐姐',0),
('令狐冲',1,3,'独孤九剑',0),
('任盈盈',0,3,'弹琴',0),
('岳不群',1,3,'华山剑法',0),
('东方不败',0,3,'葵花宝典',0),
('胡斐',1,4,'胡家刀法',0),
('苗若兰',0,4,'黄衣',0),
('程灵素',0,4,'医术',0),
('袁紫衣',0,4,'六合拳',0);

一查多：一方模型对象.多方模型类名小写_set查询某一本书中所有的英雄：book = BookInfo.objects.get(id=1)heros = book.heroinfo_set.all() 或者heros = book.heroinfo_set.filter()
多查一：多方模型对象.外键属性名查询某一个英雄所属于的图书：hero = HeroInfo.objects.get(id=2)book = hero.hbook

一对一

假如公司中每个职员的薪资都是唯一不重复的
数据表一：职员信息 StaffInfo (一方)
数据表二：薪资信息 SalaryInfo (一方)
外键的定义方式：外键定义在任意一个的模型类中外键属性名 = models.OneToOneField(关联的模型类名)

class StaffInfo(models.Model):"""职工信息：演示一对一"""name = models.CharField(max_length=32, null=True, verbose_name='职工姓名')age = models.CharField(max_length=32, null=True, verbose_name='职工年龄')class Meta:db_table = 'tb_staff_info'def __str__(self):return self.nameclass SalaryInfo(models.Model):"""薪资信息：演示一对一"""money = models.CharField(max_length=32, null=True, verbose_name='薪资')staff = models.OneToOneField(StaffInfo, on_delete=models.CASCADE, verbose_name='关联的职工')class Meta:db_table = 'tb_salary_info'def __str__(self):return self.staff

insert into tb_staff_info(name,age) values
('小红','23'),
('小兰','24');insert into tb_salary_info(staff_id,money) values
(1,'20000'),
(2,'21000');

查询'小红'的薪资：staff = StaffInfo.objects.get(name='小红')money = staff.salaryinfo.moneymoney = staff.关联的模型类名小写.money查询薪资为'21000'的员工：salary = SalaryInfo.objects.get(money='21000')name = salary.staff.namename = salary.外键属性名.name

多对多

一个学生可以选择多个课程，一个课程也可以被多个学生选择
数据表一：学生信息 StudentsInfo (多方)
数据表二：课程信息 CoursesInfo (多方)
数据表三：学生和课程对应信息 StudentsCoursesInfo (中间表) (约束学生和课程之间的多对多的关系的)
外键的定义方式：外键定义在任意一个的模型类中外键属性名 = models.ManyToManyField(关联的模型类名)

# 创建多对多数据表方式一 (优先理解的)
class StudentsInfo(models.Model):"""学生信息：演示多对多"""name = models.CharField(max_length=32, null=True, verbose_name='学生姓名')class Meta:db_table = 'tb_students_info'class CoursesInfo(models.Model):"""课程信息：演示多对多"""name = models.CharField(max_length=32, null=True, verbose_name='课程名字')students = models.ManyToManyField(StudentsInfo, through='StudentsCoursesInfo')class Meta:db_table = 'tb_courses_info'class StudentsCoursesInfo(models.Model):"""中间表"""student = models.ForeignKey(StudentsInfo, on_delete=models.CASCADE)course = models.ForeignKey(CoursesInfo, on_delete=models.CASCADE)class Meta:db_table = 'tb_courses_students_info'

# 创建多对多数据表方式一
insert into tb_students_info(name) values
('张三'),
('李四'),
('王五');insert into tb_courses_info(name) values
('语文'),
('数学'),
('生物');insert into tb_courses_students_info(student_id, course_id) values
(1, 2),
(1, 3),
(2, 1),
(2, 2),
(3, 1),
(3, 2),
(3, 3);

查询'张三'选了哪些课程：student = StudentsInfo.objects.get(name='张三')courses = student.coursesinfo_set.all()courses = student.关联模型类名小写_set.all()查询'语文'被哪些学生选了:course = CoursesInfo.objects.get(name='语文')students = course.students.all()students = course.外键属性名.all()

# 创建多对多数据表方式二
class StudentInfo(models.Model):"""学生信息：演示多对多"""name = models.CharField(max_length=32, null=True, verbose_name='学生姓名')class Meta:db_table = 'tb_student_info'class CourseInfo(models.Model):"""课程信息：演示多对多"""name = models.CharField(max_length=32, null=True, verbose_name='课程名字')students = models.ManyToManyField(StudentInfo)class Meta:db_table = 'tb_course_info'

# 创建多对多数据表方式二
insert into tb_student_info(name) values
('张三'),
('李四'),
('王五');insert into tb_course_info(name) values
('语文'),
('数学'),
('生物');insert into tb_course_info_students(studentinfo_id, courseinfo_id) values
(1, 2),
(1, 3),
(2, 1),
(2, 2),
(3, 1),
(3, 2),
(3, 3);

自关联

每个省份下面有多个城市，每个城市下面又有多个区县
每个区县上面都有一个城市，每个城市上面又都有一个省份
数据表一：省市区信息 Area (自己关联自己)
外键的定义方式：外键定义在当前模型类中外键属性名 = models.ForeignKey('self', null=True)说明：只有自关联的表中的外键可以为空，其他任何关联关系的外键都不能为空因为自关联的表中的顶级字段，他是没有父级的，所以顶级对应的外键必须为空

class Area(models.Model):"""省市区"""name = models.CharField(max_length=20, verbose_name='名称')parent = models.ForeignKey('self', null=True, on_delete=models.SET_NULL, verbose_name='上级行政地区')class Meta:db_table = 'tb_areas'def __str__(self):return self.name

mysql -uroot -pmysql django_demo < areas.sql

查询所有的省份数据：(只查询父级)provinces = Area.objects.filter(parent=None)查询'湖北省'下所有的城市：(父级查子级)hubei = Area.objects.get(name='湖北省')citys = hubei.area_set.all()查询'武汉市'下所有的区县：(父级查子级)wuhan = Area.objects.get(name='武汉市')districts = wuhan.area_set.all()查询'武汉市'属于的省份：(子级查父级)wuhan = Area.objects.get(name='武汉市')province = wuhan.parent

查询相关补充

无论是那种关联查询操作，他们之间的关联查询套路都跟一对多关联查询一样的。

关于get()和filter()的使用场景get()：当我们要查询的记录时指定的单一的记录时，使用get()在使用get()查询时，只能得到一个模型对象，如果没有或者多了都会抛出异常BookInfo.objects.get(id=1)filter()：当我们需要根据某些条件查询出满足条件的所有数据时，使用filter()在使用filter()查询时，没有查询到数据时不会抛出异常，只会返回一个空的查询集，除非数据库异常 BookInfo.objects.filter(name__contains='张')

一对多、多对多
查询规律：无论先获取到哪个模型对象，先看当前获取的模型对象中是否有外键如果有外键：使用模型对象.外键属性名如果无外键：使用模型对象.关联模型类名小写_set一对一
查询规律：无论先获取到哪个模型对象，先看当前获取的模型对象中是否有外键如果有外键：使用模型对象.外键属性名如果无外键：使用模型对象.关联模型类名小写
自关联
查询规律：无论先获取到哪个模型对象，先看当前是父级查子级，还是子级查父级父级查子级：使用模型对象.自关联的模型类型小写_set子级查父级：使用模型对象.外键属性名补充：顶级数据的查询：顶级数据的查询条件是，他没有父级