11.16 知识总结（模型层更多内容）

一、 多表查询（跨表查询）

子查询：分步查询

链表查询：把多个有关系的表拼接成一个大表(虚拟表)

    inner join 

    left join

    right join

 1.1 基于双下划线的查询

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

12 多表查询前期表准备

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.3   一对多外键增删改查

 一对多外键增删改查
     增
     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)

1.4  多对多外键增删改查

 如何给书籍添加作者？
    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
        括号内不要加任何参数
    
    """

1.5 正反向的概念 

# 正向
# 反向
    外键字段在我手上那么，我查你就是正向
      外键字段如果不在手上，我查你就是反向
  
  book >>>外键字段在书那儿(正向)>>> publish
  publish    >>>外键字段在书那儿(反向)>>>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)
    """
    你只要掌握了正反向的概念
    以及双下划线
    那么你就可以无限制的跨表
    
    """

四、  聚合查询

常见的统计总数，计算平均值的操作，可以用聚合函数来实现，常见的聚合函数有

  聚合查询通常情况下都是配合分组一起使用的
    只要是跟数据库相关的模块 
        基本上都在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)

五、  分组查询

 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与Q查询

3. 1 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') + '爆款')  # 所有的名称会全部变成空白

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