Django（聚合、分组、FQ、Django事务、ORM字段、查询优化）

"""
1.必知必会N条都有哪些，每个都是干啥使的
2.简述神奇的双下划线查询都有哪些方法，作用是什么
3.针对多对多外键字段的增删改查方法有哪些，各有什么特点？
4.什么是正反向的概念，及查询口诀，你能否总结一下正反向查询不同情况下点击不同字段的规律
"""

1.必知必会N条都有哪些，每个都是干啥使的
all() 查所有
filter（）  查询带条件的
get（）  查询带条件的，但是条件不成立会报错，所以不经常用
values（）  获取指定的字段的数据，返回一个queryset对象，列表套字典
values_list()   获取指定的字段的数据，queryset，列表套元组
count（）   查询统计出来的数据个数
first（）   
last（）
exclude（）  除...之外
order_by   排序  默认升序  参数前面加负号是降序
reverse    反转，必须在排序之后才可以使用
distinct   去重（要去除主键）
exists（）  判断是否有值，返回t/f
2.简述神奇的双下划线查询都有哪些方法，作用是什么
__gt  大于
__lt  小于
__gte   大于等于
__lte   小于等于
__in    在不在多个数据之内  便是或关系
__range  在不在多个数据之内   是包括报喜
__month  查询月份
__year   查询年份
__contains   模糊查询
__icontains  忽略大小写的模糊查询
3.针对多对多外键字段的增删改查方法有哪些，各有什么特点？
remove
    ：上述方法括号里面放数字或者对象都可以，都可以放多个
set：括号里面放可迭代对象eg：列表  可以放对象也可以放数字，也可以放一个，但必须放可迭代对象
clear：括号内无需传值，直接清空所有
4.什么是正反向的概念，及查询口诀，你能否总结一下正反向查询不同情况下点击不同字段的规律
正向：主键在自身，要查外表
反向：主键不在自身，要查主键在的表
正向查询按外键字段，反向查询按表名小写
正向在values里面做文章 
反正在filter里面做文章

# 增
1.create()
2.对象.save()
1.all()				查所有
2.filter()		筛选条件，括号内多个参数之间逗号隔开并且默认是and关系
3.get()				筛选条件，条件不存在直接报错 所以不推荐使用
1.update() 		queryset对象帮你封装的批量更新
2.对象.save()
1.delete()		queryset对象帮你封装的批量删除
2.对象.delete()		
在实际的项目中 数据是不可能真正删除的 一般情况下都用一个字段来标记是否删除
"""

# 你如果只想测试django某一个py文件(大部分情况下就是models.py)
# 在应用下的tests.py或者自己新建一个任意名称py文件(tests.py)
1.去manage.py拷贝前四行
2.自己书写两行
	import django
	django.setup()
"""

# 1.queryset对象可以直接点query查看
	queryset对象.query
# 2.配置文件配置日志相关代码即可(不要记 直接拷贝使用即可)
	参考笔记或者博客自己保存好
	

# 1.all()
# 2.filter()
	我们在利用数据的主键字段筛选数据的时候，可以不考虑主键字段叫什么，直接使用pk代替
# 3.get()
# 4.values()
	获取指定字段对应的数据 返回的结果是一个queryset对象(列表套字典的形式)
# 5.values_list()
	获取指定字段对应的数据 返回的结果是一个queryset对象(列表套元祖的形式)
# 6.count()
	统计查询出来的数据个数
# 7.first()
# 8.last()
# 9.order_by()
	默认是升序，你可以在字段前面加一个负改为降序
# 10.reverse()
	前面必须是已经排讯过了 才能生效
# 11.exclude()
	排除...在外
# 12.distinct()
	去重(主键一定不要忘了)
# 13.exists()
	判断数据集是否有值 返回布尔值

# 价格大于 小于 大于等于 小于等于
price__gt
price__lt
price__gte
price__lte
# 成员查询
price__in
# 范围查询
price__range
# 模糊查询
title__contains		默认是区分大小写的
title__icontains	忽略大小写
# 只按照年份或者月份或者...
create_time__year
craete_time__month

# 一对多
publish_id = 1
punlish = publish_obj
# 多对多
remove
	上述两个方法括号内即可以传数字也可以传对象并且都支持多个
	括号内必须传一个可迭代对象 可迭代对象里面的元素可以数字也可以对象并且都支持多个
clear
	括号内无需给任何参数，直接清空对应的关系数据

# 正反向的概念
  	外键字段就在我手中
  	外键字段不再我手中
# 小口诀
	正向查询按外键字段
  反向查询按表名小写
    							.all()
# 温馨提示
	书写orm语句跟书写sql语句一样，不要试图一次性写完，可以分步书写
	1.子查询
	2.联表操作
		inner join
		left join
		right join
		union
Django orm中
	1.基于对象的跨表查询
			1.先拿到一个数据对象
			2.对象点点点 
	2.基于双下划线的跨表查询
1.基于对象的跨表查询
  book_obj.publish
  book_obj.authors.all()
  author_obj.author_detail
  publish_obj.book_set  # App01.Book.None
  publish_obj.book_set.all()
  author_obj.book_set.all()
  author_detail.author
2.基于双下划线的跨表查询
  models.Book.objects.filter(pk=1).values('title','publish__name')
  models.Publish.objects.filter(book__id=1).values('book__title','name')
  # 利用双下划线的跨表查询可以帮助你跨N多张表，只要有外键字段
  models.Book.objects.filter(pk=1).values('authors__author_detail__phone')
# 图书管理系统 图书的增删改查

只要是跟数据库相关的模块 
   基本上都在django.db.models里面
   如果没有那么应该在django.db里面
# 聚合查询      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
    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)
    代码没有补全 不要怕 正常写
    补全给你是pycharm给你的
    # 2.统计每个出版社卖的最便宜的书的价格
    # 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查询
    # 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查询
    # 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 []>
    # esc下面的~
    # Q的高阶用法  能够将查询条件的左边也变成字符串的形式
    q = Q()
    q.connector = 'or'  # 不写这行 默认是and
    q.children.append(('maichu__gt',100))
    q.children.append(('price__lt',600))
    res = models.Book.objects.filter(q)  # 默认还是and关系
    print(res)

"""
            不可分割的最小单位
            跟原子性是相辅相成
            事务之间互相不干扰
            事务一旦确认永久生效
    事务的回滚 
        rollback
    事务的确认
        commit
# 目前你只需要掌握Django中如何简单的开启事务
    from django.db import transaction
    try:
        with transaction.atomic():
            # sql1
            # sql2
            # 在with代码快内书写的所有orm操作都是属于同一个事务
    except Exception as e:
        print(e)
    print('执行其他操作')

AutoField
    主键字段 primary_key=True
CharField               varchar
    verbose_name    字段的注释
    max_length      长度
IntegerField            int
BigIntegerField     bigint
DecimalField
    max_digits=8
  decimal_places=2
EmailFiled              varchar(254)
DateField                   date
DateTimeField           datetime
    auto_now:每次修改数据的时候都会自动更新当前时间
  auto_now_add:只在创建数据的时候记录创建时间后续不会自动修改了
BooleanField(Field)             - 布尔值类型
    该字段传布尔值(False/True)     数据库里面存0/1
TextField(Field)                    - 文本类型
    该字段可以用来存大段内容(文章、博客...)  没有字数限制
  后面的bbs作业 文章字段用的就是TextField
FileField(Field)                    - 字符类型
   upload_to = "/data"
  给该字段传一个文件对象，会自动将文件保存到/data目录下然后将文件路径保存到数据库中
  /data/a.txt
  后面bbs作业也会涉及
# 更多字段
    AutoField(Field)
        - int自增列，必须填入参数 primary_key=True
    BigAutoField(AutoField)
        - bigint自增列，必须填入参数 primary_key=True
        注：当model中如果没有自增列，则自动会创建一个列名为id的列
        from django.db import models
        class UserInfo(models.Model):
            # 自动创建一个列名为id的且为自增的整数列
            username = models.CharField(max_length=32)
        class Group(models.Model):
            # 自定义自增列
            nid = models.AutoField(primary_key=True)
            name = models.CharField(max_length=32)
    SmallIntegerField(IntegerField):
        - 小整数 -32768 ～ 32767
    PositiveSmallIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField)
        - 正小整数 0 ～ 32767
    IntegerField(Field)
        - 整数列(有符号的) -2147483648 ～ 2147483647
    PositiveIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField)
        - 正整数 0 ～ 2147483647
    BigIntegerField(IntegerField):
        - 长整型(有符号的) -9223372036854775808 ～ 9223372036854775807
    BooleanField(Field)
        - 布尔值类型
    NullBooleanField(Field):
        - 可以为空的布尔值
    CharField(Field)
        - 字符类型
        - 必须提供max_length参数， max_length表示字符长度
    TextField(Field)
        - 文本类型
    EmailField(CharField)：
        - 字符串类型，Django Admin以及ModelForm中提供验证机制
    IPAddressField(Field)
        - 字符串类型，Django Admin以及ModelForm中提供验证 IPV4 机制
    GenericIPAddressField(Field)
        - 字符串类型，Django Admin以及ModelForm中提供验证 Ipv4和Ipv6
        - 参数：
            protocol，用于指定Ipv4或Ipv6， 'both',"ipv4","ipv6"
            unpack_ipv4， 如果指定为True，则输入::ffff:192.0.2.1时候，可解析为192.0.2.1，开启此功能，需要protocol="both"
    URLField(CharField)
        - 字符串类型，Django Admin以及ModelForm中提供验证 URL
    SlugField(CharField)
        - 字符串类型，Django Admin以及ModelForm中提供验证支持 字母、数字、下划线、连接符（减号）
    CommaSeparatedIntegerField(CharField)
        - 字符串类型，格式必须为逗号分割的数字
    UUIDField(Field)
        - 字符串类型，Django Admin以及ModelForm中提供对UUID格式的验证
    FilePathField(Field)
        - 字符串，Django Admin以及ModelForm中提供读取文件夹下文件的功能
        - 参数：
                path,                      文件夹路径
                match=None,                正则匹配
                recursive=False,           递归下面的文件夹
                allow_files=True,          允许文件
                allow_folders=False,       允许文件夹
    FileField(Field)
        - 字符串，路径保存在数据库，文件上传到指定目录
        - 参数：
            upload_to = ""      上传文件的保存路径
            storage = None      存储组件，默认django.core.files.storage.FileSystemStorage
    ImageField(FileField)
        - 字符串，路径保存在数据库，文件上传到指定目录
        - 参数：
            upload_to = ""      上传文件的保存路径
            storage = None      存储组件，默认django.core.files.storage.FileSystemStorage
            width_field=None,   上传图片的高度保存的数据库字段名（字符串）
            height_field=None   上传图片的宽度保存的数据库字段名（字符串）
    DateTimeField(DateField)
        - 日期+时间格式 YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ]
    DateField(DateTimeCheckMixin, Field)
        - 日期格式      YYYY-MM-DD
    TimeField(DateTimeCheckMixin, Field)
        - 时间格式      HH:MM[:ss[.uuuuuu]]
    DurationField(Field)
        - 长整数，时间间隔，数据库中按照bigint存储，ORM中获取的值为datetime.timedelta类型
    FloatField(Field)
        - 浮点型
    DecimalField(Field)
        - 10进制小数
        - 参数：
            max_digits，小数总长度
            decimal_places，小数位长度
    BinaryField(Field)
        - 二进制类型
# django除了给你提供了很多字段类型之外 还支持你自定义字段
class MyCharField(models.Field):
    def __init__(self,max_length,*args,**kwargs):
        self.max_length = max_length
        # 调用父类的init方法
        super().__init__(max_length=max_length,*args,**kwargs)  # 一定要是关键字的形式传入
    def db_type(self, connection):
        返回真正的数据类型及各种约束条件
        :param connection:
        :return:
        return 'char(%s)'%self.max_length
# 自定义字段使用
myfield = MyCharField(max_length=16,null=True)
# 外键字段及参数
unique=True
    ForeignKey(unique=True)   ===           OneToOneField()
  # 你在用前面字段创建一对一 orm会有一个提示信息 orm推荐你使用后者但是前者也能用
db_index
    如果db_index=True 则代表着为此字段设置索引
to_field
    设置要关联的表的字段  默认不写关联的就是另外一张的主键字段
on_delete
    当删除关联表中的数据时，当前表与其关联性的行为。
  django2.X及以上版本 需要你自己指定外键字段的级联更新级联删除
  """

only与defer  
select_related与prefetch_related
orm语句的特点:
        如果你仅仅只是书写了orm语句 在后面根本没有用到该语句所查询出来的参数
        那么orm会自动识别 直接不执行
# only与defer
# res = models.Book.objects.all()
    # print(res)  # 要用数据了才会走数据库
    # 想要获取书籍表中所有数的名字
    # res = models.Book.objects.values('title')
    # for d in res:
    #     print(d.get('title'))
    # 你给我实现获取到的是一个数据对象 然后点title就能够拿到书名 并且没有其他字段
    # res = models.Book.objects.only('title')
    # res = models.Book.objects.all()
    # print(res)  # <QuerySet [<Book: 三国演义爆款>, <Book: 红楼梦爆款>, <Book: 论语爆款>, <Book: 聊斋爆款>, <Book: 老子爆款>]>
    # for i in res:
        # print(i.title)  # 点击only括号内的字段 不会走数据库
        # print(i.price)  # 点击only括号内没有的字段 会重新走数据库查询而all不需要走了
    res = models.Book.objects.defer('title')  # 对象除了没有title属性之外其他的都有
    for i in res:
        print(i.price)
    only：括号内放的字段是查询的对象的话，那么就不走数据库，其他的需要走数据库
    defer与only刚好相反
        defer括号内放的字段不在查询出来的对象里面 查询该字段需要重新走数据
        而如果查询的是非括号内的字段 则不需要走数据库了
# select_related与prefetch_related
# select_related与prefetch_related  跟跨表操作有关
    # res = models.Book.objects.all()
    # for i in res:
    #     print(i.publish.name)  # 每循环一次就要走一次数据库查询
    # res = models.Book.objects.select_related('authors')  # INNER JOIN
    select_related内部直接先将book与publish连起来 然后一次性将大表里面的所有数据
    全部封装给查询出来的对象
        这个时候对象无论是点击book表的数据还是publish的数据都无需再走数据库查询了
    select_related括号内只能放外键字段    一对多 一对一
        多对多也不行，会报错
    因为他有拼表的操作，有时候可能效率比下面的要低
    res = models.Book.objects.prefetch_related('publish')  # 子查询