标签：__ 多表 下划线 models res 查询 objects print
外键字段的增删改查
# 多对多的外键增删改查
图书和作者是多对多，借助于第三张表实现的，如果想绑定图书和作者的关系，本质上就是在操作第三方表
# 如何操作第三张表
问题：让你给图书添加一个作者，他俩的关系可是多对多
# 多对多的增删该查
# 让你给图书id=2添加一个作者id=1
book_obj = models.Book.objects.filter(pk=2).first()
print(book_obj.authors) # app01.Author.None 这句话的意思就是跨到了第三张表
# 借助于一些方法
# book_obj.authors.add(1)
# book_obj.authors.add(2,3) # 一次性条件多个作者
# 也支持写对象
# author_obj1 = models.Author.objects.filter(pk=1).first()
# author_obj2 = models.Author.objects.filter(pk=2).first()
# author_obj3 = models.Author.objects.filter(pk=3).first()
# book_obj.authors.add(author_obj1, author_obj2, author_obj3)
# 删除
# 也支持写对象
# book_obj.authors.remove(1)
# book_obj.authors.remove(2,3)
# 修改
# book_obj.authors.set(1,3) # set() takes 2 positional arguments but 3 were given
# book_obj.authors.set([1,3]) # set() takes 2 positional arguments but 3 were given
# 清空表
book_obj.authors.clear()
总结：
# 通过字典点 外键字段
add remove set clear # 四个方法
多表查询
子查询和连表查询
子查询：一个SQL语句的执行结果当成另一个SQL语句的执行条件，分步操作
连表查询：把多个表关联在一起拼接成一个大的虚拟表，然后按照单表查询
inner join
left join
right join
union
select * from course inner join teacher on course.id=teacher_course_id where id=1;
select * from course as c inner join teacher as t on course.id=teacher_course_id left join class on class.id=c.class_id where c.id=1
正反向的概念
# 先判断是正向还是反向查询
正向
外键字段在我手上，我查你就是正向查询
# 图书查出版社：外键字段在图书表中，正向查询
反向
外键字段在我手上，你查我就是反向查询
# 出版社查图书，外键字段在图书表中，反向查询
# 判断出来正向和反向之后有什么用
正向查询按照字段查询(外键字段)
反向查询按照表名小写或者表名小写_set
子查询
1.查询书籍主键为1的出版社
# 书籍查出版社----------->正向查询------------>按字段查询
# res = models.Book.objects.filter(pk=1).first()
# print(res.publish) # 人民出版社 publish_obj
# print(res.publish.name)
# print(res.publish.addr)
# 2.查询书籍主键为2的作者
# 书籍查询作者------------>正向查询------------>按字段
# book_obj = models.Book.objects.filter(pk=2).first()
# print(book_obj.authors.all()) # app01.Author.None <QuerySet [<Author: Author object (1)>]>
# print(book_obj.authors.all()[0].name)
# print(book_obj.authors.all()[0].age)
# for i in book_obj.authors.all():
# print(i)
# 3.查询作者jack的电话号码
# 作者查作者详情------------->正向查询---------------->按字段查询
# author_obj = models.Author.objects.filter(name='jerry').first()
# print(author_obj.author_detail) # AuthorDetail object (1)
# print(author_obj.author_detail.phone)
# 4.查询出版社是北京出版社出版的书
# 出版社查询书籍--------------->反向查询---------------->按照表名小写或者_set
# publich_obj = models.Publish.objects.filter(name='北京出版社').first()
# print(publich_obj.book_set) # app01.Book.None
# print(publich_obj.book_set.all()) # <QuerySet [<Book: Book object (2)>]>
# print(publich_obj.book_set.all()[0].title) # 洋哥自转1
# 5.查询作者是jack写过的书
# 作者查询书籍------------->反向查询------------>按照表名小写或者_set
# author_obj = models.Author.objects.filter(name='tom').first()
# print(author_obj.book_set) # app01.Book.None
# print(author_obj.book_set.all()) # <QuerySet []>
# 6.查询手机号是110的作者姓名
# 作者详细查询作者--------------->反向查询------------>按照表名小写或者_set
# author_detail_obj = models.AuthorDetail.objects.filter(phone=110).first()
# print(author_detail_obj.author) # Author object (1)
# print(author_detail_obj.author.name) # Author object (1)
总结：
1. 什么时候加_Set
2. 什么时候.all()
# 当查询的结果是有多个的时候，就需要以上两个操作
多表查询之连表查询(基于双下划线的查询)
# 1.查询jerry的手机号和作者姓名
# 作者查询作者详情----------->正向查询------------>按字段
# res = models.Author.objects.filter(name='jerry').values('author_detail__phone', 'name')
# print(res)
# 作者详情查询作者信息------------->反向----------------->表名小写
# res = models.AuthorDetail.objects.filter(author__name='jerry').values('phone', 'author__name')
# print(res)
# 2.查询书籍主键为1的出版社名称和书的名称
# 书籍查出版社------------------>正向查询------------>按字段
# res = models.Book.objects.filter(pk=1).values('publish__name', 'title')
# print(res)
# 出版社查询书籍---------->反向查询----------->按表名小写
# res = models.Publish.objects.filter(book__pk=1).values('name', 'book__title')
# print(res)
# 3.查询书籍主键为1的作者姓名
# 书籍查询作者------------->正向查询------------>按字段
# res = models.Book.objects.filter(pk=1).values('authors__name')
# print(res)
# 作者查询书籍-------------->反向查询----------->按表名小写
# res = models.Author.objects.filter(book__pk=1).values('name')
# print(res)
#4. 查询书籍主键是1的作者的手机号
# 书籍---->作者----->作者详情
# book 正向 author 正向 author_detail
# res = models.Book.objects.filter(pk=2).values('authors__author_detail__phone')
# print(res)
聚合查询(aggregate)
sum max min avg count
# sql:
select sum(price) from table group by '';
# 求书籍表中得书的平均价格
select avg(price) from book;
from django.db.models import Max, Min, Sum, Avg, Count
# 以后在导模块的时候，只要是跟数据库相关的一般都在
django.db
django.db.models
# res = models.Book.objects.aggregate(Avg('price'))
res = models.Book.objects.aggregate(Max('price'), Min('price'), Sum('price'), Avg('price'), Count('id'))
print(res)
分组查询annotate
# 分组查询：group by
# 分组之后只能取到分组的依据，按照什么字段分组就只能取到这个字段的值，前提是严格模式
# 非严格模式就可以取到所有字段的值
# 如何设置严格模式
1. 使用命令修改
查看sql_mode
show variables like '%mode%';
@@select sql_mode;
# 设置严格模式
set global sql_mode='ONLY_FULL_GROUP_BY'
2. 使用配置文件
# 1.统计每一本书的作者个数
# 按照书的id来分组
select * from table group by id
# res = models.Book.objects.annotate() # annotate这个关键字它就是按照models后面的这个表分组
# res = models.Book.objects.annotate(author_num=Count('authors__pk')).values('author_num', 'title')
# res = models.Book.objects.annotate(author_num=Count('authors')).values('author_num', 'title')
# print(res)
# 2.统计每个出版社卖的最便宜的书的价格
res = models.Publish.objects.annotate(min_price=Min('book__price')).values('min_price', 'name')
print(res)
# 3.统计不止一个作者的图书
# 先按照图书分组，求出每个图书的作者个数，包括了作者个数为0或者1的等，再次过滤做这个个数大于1的
res = models.Book.objects.annotate(author_num=Count('authors__pk')).filter(author_num__gt=1).values('author_num', 'title','id')
print(res)
# 4.查询每个作者出的书的总价格
res = models.Author.objects.annotate(sum_price=Sum('book__price')).values('sum_price', 'name')
print(res)
F与Q查询
# 1. 查询卖出数大于库存数的书籍
# sql： select * from table where maichu > kucun;
'''F查询'''
from django.db.models import F
# 1. 查询卖出数大于库存数的书籍
# res = models.Book.objects.filter(maichu__gt=F('kucun')).all()
# print(res[0].title)
# # 2.将所有书籍的价格提升500块
# sql: update book set price = price+500 ;
# res = models.Book.objects.update(price=F('price')+500)
# 3.将所有书的名称后面加上爆款两个字
# 如果是更新的字符串不能够这么来写，专业的语法来写
# res = models.Book.objects.update(title=F('title')+'爆款')
from django.db.models.functions import Concat
from django.db.models import Value
res = models.Book.objects.update(title=Concat(F('title'), Value('爆款')))
Q 查询
# 适用于或者的关系查询
'''Q查询'''
from django.db.models import Q
# # 1.查询卖出数大于100或者价格小于600的书籍
# select *from table where maichu>100 or price < 600;
# res = models.Book.objects.filter(maichu__gt=100, price__lt=600).all() # and关系
# res = models.Book.objects.filter(Q(maichu__gt=100), Q(price__lt=600)).all() # and关系 <QuerySet []>
# res = models.Book.objects.filter(Q(maichu__gt=100)| Q(price__lt=600)).all() # OR关系 <QuerySet []>
# res = models.Book.objects.filter(~Q(maichu__gt=100)| Q(price__lt=600)).all() # OR关系 <QuerySet []>
# res = models.Book.objects.filter(~Q(maichu__gt=100)| ~Q(price__lt=600)).all() # OR关系 <QuerySet []>
# res = models.Book.objects.filter(~(Q(maichu__gt=100)| Q(price__lt=600))).all() # OR关系 <QuerySet []>
# print(res)
Q的高阶用法
q = Q()
q.connector = 'or'
# param = requests.GET.get("param")
q.children.append(("maichu__gt", 600))
# q.children.append((param +"__gt", 600))
q.children.append(("price__lt", 100))
res = models.Book.objects.filter(q)
print(res)
django中如何开启事务
# 事务的四大特性(ACID)
原子性
隔离性
持久性
一致性
# 事务的隔离级别
# 事务的几个关键
1.开启事务
start transaction;
2. 提交事务
commit;
3. 回滚事务
rollback;
# 作用：保证安全，保证多个SQL语句要么同时执行成名， 要么同时失败
'''Django中如何开启事务'''
from django.db import transaction
try:
with transaction.atomic():
# sql1
# sql2
...
models.Book.objects.filter(maichu__gt=100, price__lt=600).update()
models.Book.objects.filter(maichu__gt=100, price__lt=600).create()
except Exception as e:
print(e)
transaction.rollback()
'''BBS作业里面就可以使用事务'''
标签：__,
多表,
下划线,
models,
res,
查询,
objects,
print
From： https://www.cnblogs.com/huangchunfang/p/17603394.html