ORM查询方法补充

聚合,分组,F与Q查询

 

测试环境搭建

import os

if __name__ == "__main__":
    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "day06.settings")
    import django
    django.setup()
    # 代码都要写在这个下面
    from app01 import models

 ORM查询方法

<1> all():                  查询所有结果
  
<2> filter(**kwargs):       它包含了与所给筛选条件相匹配的对象
  
<3> get(**kwargs):          返回与所给筛选条件相匹配的对象，返回结果有且只有一个，如果符合筛选条件的对象超过一个或者没有都会抛出错误。
  
<4> exclude(**kwargs):      它包含了与所给筛选条件不匹配的对象
 
<5> order_by(*field):       对查询结果排序('-id')
  
<6> reverse():              对查询结果反向排序
  
<8> count():                返回数据库中匹配查询(QuerySet)的对象数量。
  
<9> first():                返回第一条记录
  
<10> last():                返回最后一条记录
  
<11> exists():              如果QuerySet包含数据，就返回True，否则返回False
 
<12> values(*field):        返回一个ValueQuerySet——一个特殊的QuerySet，运行后得到的并不是一系列
                            model的实例化对象，而是一个可迭代的字典序列
<13> values_list(*field):   它与values()非常相似，它返回的是一个元组序列，values返回的是一个字典序列
 
<14> distinct():            从返回结果中剔除重复纪录

　　代码演示

   from app01 import models

    # get方法
    # models.Book.objects.create(title='西游记',price=111)
    # models.Book.objects.create(title='三国演义',price=111)
    # models.Book.objects.create(title='红楼梦',price=111)
    # 1. all, first()
    # res = models.Book.objects.all().first()
    # res = models.Book.objects.all().last() # 最后一个
    # print(res)

    # 2. get
    # res = models.Book.objects.filter(pk=1).first() # None
    '''一般不推荐使用get方法'''
    # res = models.Book.objects.get(pk=11)  # 查询的数据必须存在，不存在直接报错
    # print(res)

    # 3. exclude
    # res = models.Book.objects.exclude(pk=1) # 查询pk=1之外的数据，其实就是排除数据

    # 4. order by
    # select *from t1 order by id asc, price desc, title asc

    # res = models.Book.objects.order_by('id')  # 默认是升序
    # res = models.Book.objects.order_by('-id', 'price')  # 默认是降序
    # 5. 反转

    # res = models.Book.objects.order_by('id').reverse()  # 默认是降序
    # print(res)

    # 6. count
    # sql: select count(1) from t1
    # res = models.Book.objects.filter(price=100).count()
    # print(res)

    # 7. exists
    # res = models.Book.objects.filter(pk=1).first()

    # 8. values()
    # sql：select title, price from t1

    # 掌握
    # res = models.Book.objects.values('title', 'price') # 列表套字典
    # res1 = models.Book.objects.values_list('title', 'price') # 列表套字典
    #
    # print(res)
    # print(res1)

    # 去重：一定不加主键
    #sql: select distinct id from t1
    res = models.Book.objects.values('title', 'price').distinct()

基于双下滑线的查询

Book.objects.filter(price__in=[100,200,300])
Book.objects.filter(price__gt=100)
Book.objects.filter(price__lt=100)
Book.objects.filter(price__gte=100)
Book.objects.filter(price__lte=100)
Book.objects.filter(price__range=[100,200])
Book.objects.filter(title__contains="python")
Book.objects.filter(title__icontains="python")
Book.objects.filter(title__startswith="py")
Book.objects.filter(pub_date__year=2012)

　　代码演示

    # 1. 查询书籍价格大于200的
    # sql: select * from t1 where price > 200
    # ORM:gt => greater than equal
    # res = models.Book.objects.filter(price__gt=200).all()
    # res = models.Book.objects.filter(price__gte=200).all()
    # print(res)

    #2. 查询书籍价格小于200的
    # res = models.Book.objects.filter(price__lt=200).all()
    # res1 = models.Book.objects.filter(price__lte=200).all()
    # print(res)
    # print(res1)

    # 3. 查询书籍价格是111, 200的所有书籍
    # sql:select * from t1 where price = 111 or price = 200
    # sql:select * from t1 where price in (111, 200)
    # in走索引，not in 不走索引
    # res = models.Book.objects.filter(price__in=[111, 200]).all()
    # print(res)

    # 4. 查询书籍价格在100-300之间的
    # sql:select * from t1 where price >= 100 and price <= 300
    # sql: select *from t1 where price between 100 and 300
    # 顾头顾尾
    # res = models.Book.objects.filter(price__range=[100, 300]).all()
    # print(res)
    # 5. 查询书籍名称带有西的所有书籍
    # like查询不走索引
    # es： elasticsearch
    # sql:select * from t1 where title like '西%'
    # res = models.Book.objects.filter(title__contains='西').all()
    # 返回结果一定是queryset对象，才能点query属性
    # print(res.query)  # 查看SQL语句
    # print(res)
    '''
        select book.id, book.title from t1
        
        create table db1.t (id int, name varchar(16))
    '''

    # 6. 查询以西开头的数据
    res = models.Book.objects.filter(title__startswith='西').all()
    res = models.Book.objects.filter(title__endswith='西').all()

    # 7. 以时间查询: 2021-10
    res = models.Book.objects.filter(create_time__year=2021, create_time__month=10)

 

查看SQL执行语句

　　如果想打印orm转换过程中的sql，需要在settings中进行如下配置：

LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'handlers': {
        'console':{
            'level':'DEBUG',
            'class':'logging.StreamHandler',
        },
    },
    'loggers': {
        'django.db.backends': {
            'handlers': ['console'],
            'propagate': True,
            'level':'DEBUG',
        },
    }
}

聚合查询

　　需要借助关键字：aggregate

　　使用环境：聚合查询通常情况下都是配合分组一起使用的

　　使用聚合查询，需要导入相关模块

　　例子

    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

　　1、MySQL分组查询特点

　　　　分组之后默认只能获取到分组的依据 组内其他字段都无法直接获取了

　　　　严格模式： 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)

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

　　注意：机器上如果出现分组查询报错的情况，需要修改数据库严格模式

F与Q查询

　　1、F查询

　　　　能够帮助你直接获取到表中某个字段对应的数据

    from django.db.models import F
    # res = models.Book.objects.filter(maichu__gt=F('kucun'))
    # print(res)


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


    # 2.将所有书的名称后面加上爆款两个字
    """
    在操作字符类型的数据的时候 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') + '爆款')  # 所有的名称会全部变成空白

　　2、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)

 

END