多表查询（跨表查询）

子查询

链表查询

正反向查询概念

聚合查询

分组查询

F查询和Q查询

模型层中常见字段类型和参数

Django中如何开启事务

—————————————————————————————————————————————————————————————————————————————————————————

子查询：分布查询

链表查询　　

　　　　inner join

　　　　left join

　　　　right join

补：

多表查询

子查询(基于对象的跨表查询)

.查询书籍主键为1的出版社
# book_obj = models.Book.objects.filter(pk=1).first()
# # 书查出版社正向
# res = book_obj.publish
# print(res)
# print(res.name)
# print(res.addr)

# 2.查询书籍主键为2的作者
# book_obj = models.Book.objects.filter(pk=2).first()
# # 书查作者正向
# # res = book_obj.authors # app01.Author.None
# res = book_obj.authors.all() # <QuerySet [<Author: Author object>, <Author: Author object>]>
#
# print(res)

# 3.查询作者jason的电话号码
# author_obj = models.Author.objects.filter(name='jason').first()
# res = author_obj.author_detail
# print(res)
# print(res.phone)
# print(res.addr)

"""
在书写orm语句的时候跟写sql语句一样的
不要企图一次性将orm语句写完如果比较复杂就写一点看一点

正向什么时候需要加.all()
当你的结果可能有多个的时候就需要加.all()
如果是一个则直接拿到数据对象
book_obj.publish
book_obj.authors.all()
author_obj.author_detail
"""
4.查询出版社是东方出版社出版的书
publish_obj = models.Publish.objects.filter(name='东方出版社').first()
出版社查书反向
res = publish_obj.book_set # app01.Book.None
res = publish_obj.book_set.all()
print(res)

5.查询作者是jason写过的书
author_obj = models.Author.objects.filter(name='jason').first()
作者查书反向
res = author_obj.book_set # app01.Book.None
res = author_obj.book_set.all()
print(res)

6.查询手机号是110的作者姓名
author_detail_obj = models.AuthorDetail.objects.filter(phone=110).first()
res = author_detail_obj.author
print(res.name)
"""
基于对象
反向查询的时候
当你的查询结果可以有多个的时候就必须加_set.all()
当你的结果只有一个的时候不需要加_set.all()
自己总结出自己方便记忆的即可每个人都可以不一样

基于双下划线的查询

双下划线查询
1 年龄大于35岁的数据
res = models.User.objects.filter(age__gt=35)
print(res)
2 年龄小于35岁的数据
res = models.User.objects.filter(age__lt=35)
print(res)
大于等于小于等于
res = models.User.objects.filter(age__gte=32)
print(res)
res = models.User.objects.filter(age__lte=32)
print(res)

年龄是18 或者 32 或者40
res = models.User.objects.filter(age__in=[18,32,40])
print(res)

年龄在18到40岁之间的首尾都要
res = models.User.objects.filter(age__range=[18,40])
print(res)

查询出名字里面含有s的数据模糊查询
res = models.User.objects.filter(name__contains='s')
print(res)

是否区分大小写查询出名字里面含有p的数据区分大小写
res = models.User.objects.filter(name__contains='p')
print(res)
忽略大小写
res = models.User.objects.filter(name__icontains='p')
print(res)

res = models.User.objects.filter(name__startswith='j')
res1 = models.User.objects.filter(name__endswith='j')

print(res,res1)

# 查询出注册时间是 2020 1月
# res = models.User.objects.filter(register_time__month='1')
# res = models.User.objects.filter(register_time__year='2020')

联表查询(基于双下划线的跨表查询)

基于双下划线的跨表查询

# 1.查询jason的手机号和作者姓名
# res = models.Author.objects.filter(name='jason').values('author_detail__phone','name')
# print(res)
# 反向
# res = models.AuthorDetail.objects.filter(author__name='jason') # 拿作者姓名是jason的作者详情
# res = models.AuthorDetail.objects.filter(author__name='jason').values('phone','author__name')
# print(res)

# 2.查询书籍主键为1的出版社名称和书的名称
# res = models.Book.objects.filter(pk=1).values('title','publish__name')
# print(res)
# 反向
# res = models.Publish.objects.filter(book__id=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__id=1).values('name')
# print(res)

# 查询书籍主键是1的作者的手机号
# book author authordetail
# res = models.Book.objects.filter(pk=1).values('authors__author_detail__phone')
# print(res)
"""
你只要掌握了正反向的概念
以及双下划线
那么你就可以无限制的跨表

聚合查询

聚合查询通常情况下都是配合分组一起使用的
只要是跟数据库相关的模块
基本上都在django.db.models里面
如果上述没有那么应该在django.db里面
"""
from app01 import models
from django.db.models import Max,Min,Sum,Count,Avg
# 1 所有书的平均价格
# res = models.Book.objects.aggregate(Avg('price'))
# print(res)
# 2.上述方法一次性使用
res = v.Bovk.objects.aggregate(Max('price'),Min('price'),Sum('price'),Count('pk'),Avg('price'))
print(res)

分组查询

select age from t group by age;

# 分组查询 annotate
"""
MySQL分组查询都有哪些特点
分组之后默认只能获取到分组的依据组内其他字段都无法直接获取了
严格模式
ONLY_FULL_GROUP_BY
set global sql_mode='ONLY_FULL_GROUP_BY'

"""
from django.db.models import Max, Min, Sum, Count, Avg
# 1.统计每一本书的作者个数
# res = models.Book.objects.annotate() # models后面点什么就是按什么分组
# res = models.Book.objects.annotate(author_num=Count('authors')).values('title','author_num')
"""
author_num是我们自己定义的字段用来存储统计出来的每本书对应的作者个数
"""
# res1 = models.Book.objects.annotate(author_num=Count('authors__id')).values('title','author_num')
# print(res,res1)
"""
代码没有补全不要怕正常写
补全给你是pycharm给你的到后面在服务器上直接书写代码什么补全都没有颜色提示也没有

"""

# 2.统计每个出版社卖的最便宜的书的价格(作业:复习原生SQL语句写出来)
# res = models.Publish.objects.annotate(min_price=Min('book__price')).values('name','min_price')
# print(res)

# 3.统计不止一个作者的图书
# 1.先按照图书分组求每一本书对应的作者个数
# 2.过滤出不止一个作者的图书
# res = models.Book.objects.annotate(author_num=Count('authors')).filter(author_num__gt=1).values('title','author_num')
# """
# 只要你的orm语句得出的结果还是一个queryset对象
# 那么它就可以继续无限制的点queryset对象封装的方法
#
# """
# print(res)

# 4.查询每个作者出的书的总价格
# res = models.Author.objects.annotate(sum_price=Sum('book__price')).values('name','sum_price')
# print(res)

"""
如果我想按照指定的字段分组该如何处理呢？
models.Book.objects.values('price').annotate()

F与Q查询

F查询
# 1.查询卖出数大于库存数的书籍
# F查询
"""
能够帮助你直接获取到表中某个字段对应的数据
"""
from django.db.models import F
# res = models.Book.objects.filter(maichu__gt=F('kucun'))
# print(res)

# 2.将所有书籍的价格提升500块
# models.Book.objects.update(price=F('price') + 500)

# 3.将所有书的名称后面加上爆款两个字
"""
在操作字符类型的数据的时候 F不能够直接做到字符串的拼接
"""
from django.db.models.functions import Concat
from django.db.models import Value
models.Book.objects.update(title=Concat(F('title'), Value('爆款')))
# models.Book.objects.update(title=F('title') + '爆款') # 所有的名称会全部变成空白

Q查询

Q查询
# 1.查询卖出数大于100或者价格小于600的书籍
# res = models.Book.objects.filter(maichu__gt=100,price__lt=600)
"""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的高阶用法能够将查询条件的左边也变成字符串的形式
q = Q()
q.connector = 'or'
q.children.append(('maichu__gt',100))
q.children.append(('price__lt',600))
res = models.Book.objects.filter(q) # 默认还是and关系
print(res)

多表查询前期表准备

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)

一对多
publish = models.ForeignKey(to='Publish')
多对多
authors = models.ManyToManyField(to='Author')

class Publish(models.Model):
name = models.CharField(max_length=32)
addr = models.CharField(max_length=64)

varchar(254) 该字段类型不是给models看的而是给后面我们会学到的校验性组件看的

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')

class AuthorDetail(models.Model):
phone = models.BigIntegerField()

电话号码用BigIntegerField或者直接用CharField
addr = models.CharField(max_length=64)

建立关系后迁移：

此时生成一个表

这几张表之间存在着关系但是需要添加数据

一对多的外键增删改查：

例如：如何增加一本书？

一对多外键增删改查
# 增
# 1 直接写实际字段 id
# models.Book.objects.create(title='论语',price=899.23,publish_id=1)
# models.Book.objects.create(title='聊斋',price=444.23,publish_id=2)
# models.Book.objects.create(title='老子',price=333.66,publish_id=1)
# 2 虚拟字段对象
# publish_obj = models.Publish.objects.filter(pk=2).first()
# models.Book.objects.create(title='红楼梦',price=666.23,publish=publish_obj)

# 删
# models.Publish.objects.filter(pk=1).delete() # 级联删除

# 修改
# models.Book.objects.filter(pk=1).update(publish_id=2)
# publish_obj = models.Publish.objects.filter(pk=1).first()
# models.Book.objects.filter(pk=1).update(publish=publish_obj)

多对多外键增删改查

# 如何给书籍添加作者？
book_obj = models.Book.objects.filter(pk=1).first()
# print(book_obj.authors) # 就类似于你已经到了第三张关系表了
# book_obj.authors.add(1) # 书籍id为1的书籍绑定一个主键为1 的作者
# book_obj.authors.add(2,3)

# author_obj = models.Author.objects.filter(pk=1).first()
# author_obj1 = models.Author.objects.filter(pk=2).first()
# author_obj2 = models.Author.objects.filter(pk=3).first()
# book_obj.authors.add(author_obj)
# book_obj.authors.add(author_obj1,author_obj2)
"""
add给第三张关系表添加数据
括号内既可以传数字也可以传对象并且都支持多个
"""

# 删
# book_obj.authors.remove(2)
# book_obj.authors.remove(1,3)

# author_obj = models.Author.objects.filter(pk=2).first()
# author_obj1 = models.Author.objects.filter(pk=3).first()
# book_obj.authors.remove(author_obj,author_obj1)
"""
remove
括号内既可以传数字也可以传对象并且都支持多个
"""

# 修改
# book_obj.authors.set([1,2]) # 括号内必须给一个可迭代对象
# book_obj.authors.set([3]) # 括号内必须给一个可迭代对象

# author_obj = models.Author.objects.filter(pk=2).first()
# author_obj1 = models.Author.objects.filter(pk=3).first()
# book_obj.authors.set([author_obj,author_obj1]) # 括号内必须给一个可迭代对象

"""
set
括号内必须传一个可迭代对象，该对象内既可以数字也可以对象并且都支持多个
"""

# 清空
# 在第三张关系表中清空某个书籍与作者的绑定关系
book_obj.authors.clear()
"""
clear
括号内不要加任何参数

正反向的概念

# 正向
# 反向
外键字段在我手上那么，我查你就是正向
外键字段如果不在手上，我查你就是反向

book >>>外键字段在书那儿(正向)>>> publish
publish >>>外键字段在书那儿(反向)>>>book

一对一和多对多正反向的判断也是如此

"""
正向查询按外键字段
反向查询按表名小写
_set
...
"""