day58

今日内容概要

核心还是模型层

• 多表查询(跨表查询)

• 子查询

• 链表查询

• 正反向查询概念

• 聚合查询

• 分组查询

• F查询和Q查询

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

• Django中如何开启事务

 多表查询

数据准备

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)
    # 该字段不是给models看的，而是给校验行组件使用的
    email = models.EmailField()


class Author(models.Model):
    name = models.CharField(max_length=32)
    age = models.IntegerField()

    # 一对一
    author_detail = models.OneToOneField(to='AuthDetail')


class AuthDetail(models.Model):
    phone = models.BigIntegerField()
    addr = models.CharField(max_length=40)

重载数据库

python36 manage.py makemigrations

python36 manage.py migrate

外键的增删改查

一对多外键的增删改查

外键的增加

# （1）一对多的外键的增删改查
# （1.1）外键的增加 - 直接写实际字段
models.Book.objects.create(title="三国演义", price=1369.25, publish_id=1)
# （1.2）外键的增加 - 虚拟字段
publish_obj = models.Publish.objects.filter(pk=2).first()
models.Book.objects.create(title="红楼梦", price=1569.25, publish=publish_obj)

外键的删除

# （2）一对多的外键的删除
models.Publish.objects.filter(pk=1).delete()

外键的修改

# （2）一对多的外键的修改
#  - 直接写实际字段
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)

多对多外键的增删改查

多对多增删改查就是在操作第三张表

增加

# 多对多外键的增删改查 - 就是在操作第三张表
# （1）如何给书籍添加作者
book_obj = models.Book.objects.filter(pk=1).first()
# book_obj.authors - 这样我们就已经能操作第三张关系表了
# 书籍ID为1的书籍绑定了一个主键为1的作者
book_obj.authors.add(1)
# 可以传多个参数
book_obj.authors.add(2,3)
# 支持参数传对象 - 且支持多个对象
book_obj.authors.add(author_obj)

删除

支持多个参数/支持对象

# （2）删除
book_obj = models.Book.objects.filter(pk=1).first()
# 支持多个参数 - 支持多个对象
book_obj.authors.remove(2)

更改

先删除后增加

# （3）修改
book_obj = models.Book.objects.filter(pk=1).first()
# 括号内必须给一个可迭代对象
# 把 1 删掉 替换成 2
book_obj.authors.set([1, 2])
# 把原来都删掉 ， 替换成 3
book_obj.authors.set([3])
# 支持放对象
book_obj.authors.set([author_obj])

清空

# （4） 清空
# 在第三张表中清除某一本书和作者的绑定关系
book_obj = models.Book.objects.filter(pk=1).first()
# 不要加任何参数
book_obj.authors.clear()

【补充】正反向的概念

• 正向

  • 外键字段在我手上，那么我查你就是正向
  • book >>>> 外键字段在书这边(正向) >>>> 出版社

• 反向

  • 外键字段不在我手上，那么我查你就是反向
  • 出版社>>>> 外键字段在书这边(反向) >>>> book

• 一对一和一对多的判断也是这

正向查询按字段

反向查询按表明名(小写)

​ __set

​ ...

子查询（跨表查询）

# 1.查询书籍主键为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()  # , ]>

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.查询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)
"""
你只要掌握了正反向的概念
以及双下划线
那么你就可以无限制的跨表

"""

聚合查询

# 聚合查询      aggregate
    """
    聚合查询通常情况下都是配合分组一起使用的
    只要是跟数据库相关的模块 
        基本上都在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 = models.Book.objects.aggregate(Max('price'),Min('price'),Sum('price'),Count('pk'),Avg('price'))
    print(res)

分组查询

# 分组查询  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()
后续BBS作业会使用


你们的机器上如果出现分组查询报错的情况
    你需要修改数据库严格模式
"""

F查询

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

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