26 ORM多表操作
1 前期准备
2 一对多外键增删改查
3 多对多外键增删改查（就是在操作第三张关系表）
4 正反向的概念
5 多表查询
6 聚合查询
7 分组查询
8 F与Q查询
9 django中开启事务
1 前期准备
1.1 建表：models.py
书和出版社是一对多
书和作者是多对多
作者和作者详情是一对一
class Book(models.Model): title = models.CharField(max_length=32) price = models.DecimalField(max_digits=8, decimal_places=2) publish_date = models.DateField(auto_now_add=True) # 库存 kucun = models.IntegerField(default=1000) # 卖出 maichu = models.IntegerField(default=1000) publish = models.ForeignKey(to='Publish', on_delete=models.CASCADE) authors = models.ManyToManyField(to='Author') def __str__(self): return self.title class Publish(models.Model): name = models.CharField(max_length=32) addr = models.CharField(max_length=64) email = models.EmailField() def __str__(self): return self.name class Author(models.Model): name = models.CharField(max_length=32) age = models.IntegerField() author_detail = models.OneToOneField(to='AuthorDetail', on_delete=models.CASCADE)def __str__(self):
return self.nameclass AuthorDetail(models.Model):
phone = models.BigIntegerField()
addr = models.CharField(max_length=64)def __str__(self):
return self.addr1.2 数据库迁移命令
python manage.py makemigrations python manage.py migrate
1.3 插入数据（可手动插入）
AuthorDetail表
INSERT INTO `app01_authordetail` VALUES (1, 110, '芜湖');
INSERT INTO `app01_authordetail` VALUES (2, 120, '山东');
INSERT INTO `app01_authordetail` VALUES (3, 130, '惠州');
Author表
INSERT INTO `app01_author` VALUES (1, 'Jason', 18, 1);
INSERT INTO `app01_author` VALUES (2, 'egon', 84, 2);
INSERT INTO `app01_author` VALUES (3, 'tank', 50, 3);
Publish表
INSERT INTO `app01_publish` VALUES (1, '东方出版社', '东方', '123@qq.com');
INSERT INTO `app01_publish` VALUES (2, '北方出版社', '北方', '666@qq.com');
2 一对多外键字段增删改查
2.1 增
2.1.1 直接写实际字段 id（直接录入相关的主键字段数据）
models.Book.objects.create(title='三国演义',price=123.32,publish_id=1)
2.1.2 虚拟字段 对象
publish_obj = models.Publish.objects.filter(pk=2).first()
models.Book.objects.create(title='水浒传',price=345.78,publish=publish_obj)
2.2 删
models.Publish.objects.filter(pk=1).delete() # 级联删除
2.3 改
models.Book.objects.filter(pk=2).update(publish_id=2)
或者：
publish_obj = models.Publish.objects.filter(pk=1).first()
models.Book.objects.filter(pk=3).update(publish=publish_obj)
3 多对多外键字段增删改查（就是在操作第三张关系表）
3.1 增：如何给书籍添加作者？
book_obj = models.Book.objects.filter(pk=2).first()
book_obj.authors.add(1) # 书籍对象点多对多虚拟字段就相当于在操作第三张关系表
book_obj.authors.add(1,2) #增加多个
按对象增加一个或多个：
author_obj = models.Author.objects.filter(pk=1).first()
author_obj1 = models.Author.objects.filter(pk=2).first()
book_obj.authors.add(author_obj) #增加一个
book_obj.authors.add(author_obj,author_obj1) #增加多个
add
在第三张关系表中添加数据
括号内既可以传主键字段也可以传数据对象 并且都支持传多个
3.2 删
book_obj = models.Book.objects.filter(pk=2).first()
book_obj.authors.remove(1) #删除一个
book_obj.authors.remove(1,2) #删除多个
author_obj = models.Author.objects.filter(pk=1).first()
author_obj1 = models.Author.objects.filter(pk=2).first()
book_obj.authors.remove(author_obj) #按对象删一个
book_obj.authors.remove(author_obj, author_obj1) #按对象删多个
remove
在第三张关系表中删除数据
括号内既可以传主键字段也可以传数据对象 并且都支持传多个
3.3 修改
set：括号内必须传一个可迭代对象，该对象内既可以数字也可以对象 并且都支持多个
book_obj = models.Book.objects.filter(pk=2).first()
book_obj.authors.set([1,]) #改一个
book_obj.authors.set([1,2]) #改多个
author_obj = models.Author.objects.filter(pk=1).first()
author_obj1 = models.Author.objects.filter(pk=2).first()
book_obj.authors.set([author_obj]) #按对象改一个，括号内必须给一个可迭代对象
book_obj.authors.set([author_obj,author_obj1]) #按对象改多个，括号内必须给一个可迭代对象
set
在第三张关系表中修改数据
括号内需要传一个可迭代对象
可迭代对象里面的元素既可以传主键字段也可以传数据对象 并且都支持传多个
3.4清空数据（clear : 括号内不要加任何参数）
book_obj = models.Book.objects.filter(pk=2).first()
book_obj.authors.clear() # 清空当前书籍与作者的所有绑定关系
clear
在第三张关系表中清空数据
括号内无需传值
4 正反向的概念
正向查询
书籍对象查出版社对象 外键字段在书表中 # 正向查询
书籍对象查作者对象 外键字段在书表中 # 正向查询
作者对象查作者详情 外键字段在作者中 # 正向查询
反向查询
出版社查书籍对象 外键字段不在出版社表中 # 反向查询
作者查书籍对象 外键字段不在作者表中 # 反向查询
作者详情查作者 外键字段不在作者详情表中 # 反向查询
"""
查询数据的时候如果外键字段"在你的手上"则为正向查询
如果外键字段不在则为反向查询
"""
口诀:
正向查询按外键字段 ...
反向查询按表名小写 ...
5 多表查询
5.1 子查询(基于对象的跨表查询)
"""将一条SQL语句的查询结果当做另外一条SQL语句的查询条件"""
'''基于对象的跨表查询'''
1.查询主键为2的书籍对应的出版社
先查询书籍对象
book_obj = models.Book.objects.filter(pk=2).first()
再基于书籍对象查询出版社对象(书跟出版社的外键字段在书中 所以为正向)
res = book_obj.publish
print(res, res.pk, res.name, res.addr)
2.查询主键为3的书籍对应的作者
先查询书籍对象
book_obj = models.Book.objects.filter(pk=3).first()
再基于书籍对象查询作者对象(书跟作者的外键字段在书中 所以为正向)
res = book_obj.authors
print(res) # app01.Author.None 只差一个all方法即可
res = book_obj.authors.all()
for author_obj in res:
print(author_obj.pk)
print(author_obj.name)
print(author_obj.age)
3.查询jason的详情数据
先查询作者对象
author_obj = models.Author.objects.filter(name='jason').first()
再基于作者对象查询作者详情对象(作者跟作者详情的外键字段在作者表中 所以为正向)
res = author_obj.author_detail
print(res,res.phone)
"""
小总结
基于对象的正向查询 数据对象点了外键字段之后
是否需要再点all 取决于关联的数据项有几个 单个无需点 多个则需要点
"""
4.查询北方出版社出版的书籍
先查询北方出版社对象
publish_obj = models.Publish.objects.filter(name='北方出版社').first()
再基于北方出版社对象对象查询书籍对象(北方出版社对象跟书籍的外键字段在书籍表中 所以为反向)
res = publish_obj.book_set
print(res) # app01.Book.None
res = publish_obj.book_set.all()
print(res) # <QuerySet [<Book: 对象:三国演义>, <Book: 对象:编程思维>]>
5.查询jason写过的书籍
先查询jason对象
author_obj = models.Author.objects.filter(name='jason').first()
再基于jason对象查询书籍对象(jason对象跟书籍的外键字段在书籍表中 所以为反向)
res = author_obj.book_set
print(res) # app01.Book.None
res = author_obj.book_set.all()
print(res) # app01.Book.None
6.查询电话是110的作者姓名
先查询110详情对象
author_detail_obj = models.AuthorDetail.objects.filter(phone=110).first()
再基于110详情对象查询作者对象(110详情对象跟作者的外键字段在作者表中 所以为反向)
res = author_detail_obj.author
print(res)
"""
基于对象的反向查询
如果查询出来的数据对象可以有多个 那么需要
表名小写_set.all()
如果查询出来的数据对象只有一个
表名小写
5.2 联表查询(基于双下划线的跨表查询)
1.查询主键为2的书籍对应的出版社
res = models.Book.objects.filter(pk=2).values('publish__name','publish__addr')
print(res)
2.查询主键为3的书籍对应的作者
res = models.Book.objects.filter(pk=3).values('authors__name','authors__age')
print(res)
res = models.Book.objects.filter(pk=3).values_list('authors__name', 'authors__age')
print(res)
3.查询jason的详情数据
res = models.Author.objects.filter(name='jason').values('author_detail__phone','author_detail__addr')
print(res)
4.查询书籍pk为2的作者的电话
res = models.Book.objects.filter(pk=2).values('authors__author_detail__phone')
print(res)
"""小总结:自己总结"""
5.查询北方出版社出版的书籍
res = models.Publish.objects.filter(name='北方出版社').values('book__title','book__price')
print(res)
6.查询jason写过的书籍
res = models.Author.objects.filter(name='jason').values('book__title','book__price')
print(res)
7.查询电话是110的作者姓名
res = models.AuthorDetail.objects.filter(phone=110).values('author__name')
print(res)
双下划綫进阶操作
1.查询主键为2的书籍对应的出版社(不能点书籍)
res = models.Publish.objects.filter(book__pk=2)
print(res) # <QuerySet [<Publish: 对象:北方出版社>]>
2.查询主键为3的书籍对应的作者
res = models.Author.objects.filter(book__pk=3)
print(res) # <QuerySet [<Author: 对象:jason>, <Author: 对象:tony>]>
3.查询jason的详情数据
res = models.AuthorDetail.objects.filter(author__name='jason')
print(res)
4.查询北方出版社出版的书籍
res = models.Book.objects.filter(publish__name='北方出版社')
print(res)
5.查询jason写过的书籍
res = models.Book.objects.filter(authors__name='jason')
print(res)
6.查询电话是110的作者姓名
res = models.Author.objects.filter(author_detail__phone=110)
print(res)
6.聚合查询
聚合查询通常情况下都是配合分组一起使用的
只要是跟数据库相关的模块
基本上都在django.db.models里面
如果上述没有那么应该在django.db里面
聚合函数 max min sum count avg from django.db.models import Max,Min,Sum,Count,Avg # 1.统计所有书籍的总价格 # res = models.Book.objects.aggregate(Sum('price')) # print(res) # 2.统计所有书籍的总数 # res = models.Book.objects.aggregate(Count('pk')) # print(res) # 3.统计价格最高的 # res = models.Book.objects.aggregate(Max('price')) # print(res) res = models.Book.objects.aggregate(Max('price'),Min('price'),Sum('price'),Count('price'),Avg('price')) print(res)
MySQL分组查询都有哪些特点
分组之后默认只能获取到分组的依据 组内其他字段都无法直接获取了
严格模式
ONLY_FULL_GROUP_BY
"""分组查询:annotate"""
1.统计每一本书的作者个数
'''author_num是必须要起的别名 因为后面的values中需要使用'''
res = models.Book.objects.annotate(author_num=Count('authors__pk')).values('author_num','title')
print(res) # models后面点什么 就是按什么分组
# author_num是我们自己定义的字段 用来存储统计出来的每本书对应的作者个数2.统计出每个出版社卖的最便宜的书的价格 res = models.Publish.objects.annotate(min_price=Min('book__price')).values('min_price','name','book__title') print(res)
3.统计不止一个作者的图书 res = models.Book.objects.annotate(author_num=Count('authors__pk')).filter(author_num__gt=1) print(res)
4.查询各个作者出的书的总价格 res = models.Author.objects.annotate(price_sum=Sum('book__price')).values('name','price_sum') print(res) """ 1.大的分组 models.表名.objects.annotate 按照models后面的表名分组(主键) 2.小的分组（如果我想按照指定的字段分组该如何处理呢？）
models.表名.objects.values('price').annotate() 按照values括号内指定的字段分组 """
8.F与Q查询
F查询
from django.db.models import F
F的功能是获取数据库中字段原有的数据
1.将所有书籍的价格提升100块
models.Book.objects.update(price=F('price')+1000)
2.将所有书籍名称后面加上爆款后缀
from django.db.models.functions import Concat
from django.db.models import Value
ret3 = models.Book.objects.update(title=Concat(F('title'), Value('爆款')))
'''F查询默认操作数字类型 如果需要操作字符类型需要上述方式'''
3.查询库存数大于卖出数的书籍
res = models.Book.objects.filter(kucun__gt=F('maichu'))
print(res)
Q查询
Q查询 1.查询卖出数大于100或者价格小于600的书籍 res = models.Book.objects.filter(maichu__gt=100,price__lt=600) #逗号分隔为and关系，那么怎么用或者呢？？？ """filter括号内多个参数是and关系""" from django.db.models import Q res = models.Book.objects.filter(Q(maichu__gt=100),Q(price__lt=600)) # Q包裹逗号分割 还是and关系 res = models.Book.objects.filter(Q(maichu__gt=100)|Q(price__lt=600)) # | or关系 res = models.Book.objects.filter(~Q(maichu__gt=100)|Q(price__lt=600)) # ~ not关系 print(res) # <QuerySet []> # Q的高阶用法 能够将查询条件的左边也变成字符串的形式
# filter(title='123') filter('title'='123')
q = Q() # q.connector = 'or' #也可以修改链接关系（默认是True）
# q.children.append(('title', '三国演义爆款'))
#q.children.append(('title__contains', '爆')) q.children.append(('maichu__gt',100)) q.children.append(('price__lt',600)) res = models.Book.objects.filter(q) # 默认还是and关系 print(res)
""" 事务:ACID A原子性 不可分割的最小单位 C一致性 跟原子性是相辅相成的 I隔离性 事物之间互不干扰 D持久性 事物一旦确认永久生效 start transaction ... 事物的回滚 rollback 事物的确认 commit """
开启事物有2中方式：with上下文的形式、装饰器的形式，下面以with上下文的形式为例 from django.db import transaction # 事务 # 买一本 跟jason学Linux 书 # 在数据库层面要做的事儿 # 1. 创建一条订单数据 # 2. 去产品表 将卖出数+1， 库存数-1 from django.db.models import F # 开启事务处理 try: with transaction.atomic(): #在with代码块内书写的所有orm操作都属于同一个事物 # 创建一条订单数据 models.Book.objects.create(num="110110111", product_id=1, count=1) # 能执行成功 models.Book.objects.filter(id=1).update(kucun=F("kucun") - 1, maichu=F("maichu") + 1) except Exception as e: print(e)
transaction.rollback() # 回滚 transaction.commit() # 提交
