神奇的双下下线查询；一对多，多对多外键增删改查；正反向概念；多表查询 # day55

神奇的双下划线查询

 # 一、神奇的双下划线查询
​
    # 1 年龄大于等于35岁的数据
    # res = models.Author.objects.filter(age__gte=35)
    # print(res)
​
    # 2 年龄小于35岁的数据
    # res = models.Author.objects.filter(age__lt=35)
    # print(res)
​
    # 3 年龄是18 32 40的数据
    # res = models.Author.objects.filter(age__in=[18, 32, 40])
    # print(res)
​
    # 4 年龄在18到40岁之间的数据
    # res = models.Author.objects.filter(age__range=(18, 40))
    # print(res)
​
    # 5 查询出名字里有a的数据（模糊查询）
    # res = models.Author.objects.filter(name__contains='M')
    # print(res)
    # print(res.query) # 可以查看该命令底层反映的SQL语句
​
    # 6 是否区分大小写， 查询出名字中有a的数据， 区分大小写
    # res = models.Author.objects.filter(name__icontains='M')
    # print(res)
    # print(res.query)
​
    # 7 查询姓名中以j开头的数据
    # res = models.Author.objects.filter(name__startswith='j')
    # print(res)
​
    # 8 查询姓名中以字母b结尾的数据
    # res = models.Author.objects.filter(name__endswith='b')
    # print(res)
    # models.Author.objects.update(create_time='2021-10-01')
    # models.Author.objects.filter(pk=1).update(create_time='2020-09-01')
​
    # 9 查询出注册时间是 2020 9月的数据
    # res = models.Author.objects.filter(create_time__year='2020', create_time__month='09')
    # print(res)
    # 查询出注册时间是9月份的数据
    # res = models.Author.objects.filter(create_time__month='09')
    # print(res)
    # 查询出注册时间是2020年的数据
    # res = models.Author.objects.filter(create_time__year='2020')
    # print(res)
​
   

一对多外键增删改查

# 二、一对多外键增删改查
    # 增
    # 1、直接写实际字段 id
    # 增加一本书
    # models.Book.objects.create(title='代码整洁之道', price=150, publish_id=2)
    # 2、虚拟字段 对象(不常用，复杂且消耗较大)
    # publish_obj = models.Publish.objects.filter(pk=2).first()
    # models.Book.objects.create(title='代码整洁之道', price=140, publish=publish_obj)
​
    # 改
    # 第一种方法
    # res = models.Book.objects.filter(pk=12).update(title='代码', publish_id=1)
    # 第二种方法
    # publish_obj = models.Publish.objects.filter(pk=1).first()
    # models.Book.objects.filter(pk=12).update(price=130， publish=publish_obj)
​
    # 删
    # models.Publish.objects.filter(pk=1).delete() # 级联删除（删除了publish中的pk=2的出版社，并且将跟pk=2关联的书也删除了）
​
    # 查
　　 # book_obj = models.Book.object.filter(pk=1).first()
　　 # book_obj.publish

多对多外键增删改查

# 如何给书籍添加作者？
　　# 第一种方式　　add（id）
    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)
​
　　# 第二种方式　　add（对象）
    # 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 = models.Book.object.filter(pk=1).first()
　　# book_obj.authors.all()
​
​
    # 清空
    # 在第三张关系表中清空某个书籍与作者的绑定关系
    book_obj.authors.clear()
    """
    clear
        括号内不要加任何参数
    
    """

总结：
当查询结果为多个的时候，要加.all()
当查询结果为一个的时候,不要加.all()

正反向的概念

# 正向
# 反向
    外键字段在我手上那么，我查你就是正向
  外键字段如果不在手上，我查你就是反向
  
  book与publish建立一对多的外键关系，外键建在book中
  book >>>外键字段在书那儿(正向)>>> publish
  publish   >>>外键字段在书那儿(反向)>>>book
  
  一对一和多对多正反向的判断也是如此
  
"""
正向查询按字段
　　　 1.结果有多个，字段后要加.all()
　　　 2.结果只有一个，只需用字段查询即可
反向查询按表名小写或表名小写_set.all()
      1.结果有多个，表名小写要加_set.all()
　　　 2.结果只有一个，只需用表名小写即可
"""
​

多表查询

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

# 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()  # <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.查询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)
    """

聚合查询

#########################聚合查询############################

from django.db.models import Max, Min, Sum, Count, Avg
# 1 所有书的平均价格：SQL语句 select avg(price) from book where id > 2
# res = models.Book.objects.aggregate(Avg('price'))  #

"""
    聚合查询需要加aggregate
    分组查询需要加annotate
"""
# print(res)

# res = models.Book.objects.aggregate(avg=Avg('price'), price_max=Max('price'), price_min=Min('price'), sum=Sum('price'), count=Count('price'))
# print(res)

分组查询

#########################分组查询############################

# 1.统计每一本书的作者个数
# res = models.Book.objects.annotate() # 默认就是按照models后面的表名的id分组
# print(res)
# SQL语句  group by name, price

# res = models.Book.objects.annotate(count=Count('authors__pk')).values("title", 'count')
# print(res)

# 2.统计每个出版社卖的最便宜的书的价格
# res = models.Publish.objects.annotate(price_min=Min('book__price')).values('title', 'price_min')
# print(res)

# 3.统计不止一个作者的图书
# 1) 先查询每一本书的作者个数，
# 2） 在筛选出大于1的

res = models.Book.objects.annotate(author_num=Count('authors__pk')).filter(author_num__gt=1).values('title', 'author_num')
print(res)

"""
res = models.Book.objects.values('').annotate
.values(字段)，表名根据表中相应的字段进行分组

"""