day06

聚合查询

# 继续昨天的环境做操作
'''聚合函数使用需要先分组'''
案例:
    from django.db.models import Max, Min, Sum, Avg, Count
    # 最大,最小,求和,平均,数量
    res = models.Book.objects.aggregate(m_p=Max('price'))  # 没有分组需要使用aggregate
    print(res)  # {'m_p': Decimal('39800.88')} m_p是别名,可以不加

分组查询

分组有一个特性,默认只能够直接获取分组的字段,其他字段需要使用方法,我们可以忽略掉该特性,将sql_mode中only_full_group_by的配置移除即可
"""先在MySQL客户端执行 set global sql_mode = 'STRICT_TRANS_TABLES'"""
    """
    1.按照整条数据分组
        models.Book.objects.annotate() 按照一条条书籍记录分组
    2.按照表中某个字段分组
        models.Book.objects.values('title).annotate() 安装annotate之前values括号中指定的字段分组
    """
案例
    from django.db.models import Max, Min, Sum, Avg, Count
    # 1.统计每一本书的作者个数
    res = models.Book.objects.annotate(author_num=Count('authors__pk')).values('title','author_num')
    print(res)
    
    # 2.根据出版社id统计出版的书的数量
    res = models.Book.objects.values('publish_id').annotate(book_num=Count('pk')).values('publish_id','book_num')
    print(res)
    
    # 3.统计每个出版社卖的最便宜的书的价格
    res = models.Publish.objects.annotate(min_price=Min('book__price')).values('name','min_price')
    print(res)
    
    # 4.统计不止1个作者的图书
    """filter在annotate前面是where,在annotate后面是having"""
    res = models.Book.objects.annotate(author_num=Count('authors__pk')).filter(author_num__gt=1).values('title','author_num')
    print(res)

    # 5.查询各个作者出的书的总价格
    res = models.Author.objects.annotate(book_sum_price=Sum('book__price')).values('name', 'book_sum_price')
    print(res)

F查询

'''F查询:查询条件不是自定义的,而是来自于表中其他字段'''
# 再给book添加2个字段 库存和卖出
	'''当表中已经有数据的情况下,添加新的字段,需要指定一些参数
		1.设置字段值允许为空			null=True
		2.设置字段默认值			default=1000
		3.在终端中直接给出默认值
	'''
	1.在models.py中的book类下添加
        storage_num = models.IntegerField(verbose_name='库存数', null=True)
        sale_num = models.IntegerField(verbose_name='卖出数', default=1000)
	2.在pycharm的cmd终端执行
        1.将models中有关数据库的操作记录下来(migrations文件夹)
            python3 manage.py makemigrations
        2.将操作真正影响到数据库中
            python3 manage.py migrate
	3.手动修改book表的库存,分别是2000,1000,800,600,10000
    

	from django.db.models import F # 针对字符串数据无法拼接,需要导入下面2个模块
	from django.db.models.functions import Concat
    from django.db.models import Value

    # 1.查询库存数大于卖出数的书籍
    res = models.Book.objects.filter(storage_num__gt=F('sale_num'))
    print(res)
    
	# 2.将所有书籍的价格上涨1000块
    models.Book.objects.update(price=F('price')+1000)

	# 3.将书籍名称加上爆款后缀
    models.Book.objects.filter(pk=5).update(title=Concat(F('title'), Value('爆款')))

Q查询

    from django.db.models import Q
    '''Q查询:可以改变filter括号内多个条件之间的逻辑运算符'''
    res = models.Book.objects.filter(pk=1,publish_id=3) # 默认是and关系
    res = models.Book.objects.filter(Q(pk=1), Q(publish_id=3)) # 逗号分割还是and关系
    res = models.Book.objects.filter(Q(pk=1) | Q(publish_id=3))  # |是or关系
    res = models.Book.objects.filter(~Q(pk=1) | Q(publish_id=3))  # ~是not关系
    print(res)
    
    '''Q查询:,还可以将查询条件的字段改为字符串形式'''
    q_obj = Q()
    q_obj.connector = 'or'  # q对象默认的多个条件是and关系,可以修改为or
    q_obj.children.append(('pk', 1))
    q_obj.children.append(('publish_id', 3))
    res = models.Book.objects.filter(q_obj)
    print(res)

orm查询优化

Django orm默认都是惰性查询
	当orm的语句在后续的代码中真正需要使用的时候才会执行
Django orm自带limit分页
	减轻数据库端以及服务端的压力
'''
only会将括号内填写的字段封装成一个个数据对象,对象在点击的时候不会再走数据库查询
但是对象也可以点击括号内没有的字段,只不过每次都会走数据库查询
'''
    res = models.Book.objects.only('title', 'price')
    for obj in res:
        print(obj.title)  # 直接读取数据对象
        print(obj.price)  # 直接读取数据对象
        print(obj.publish_time)  # 会走数据库查询
'''
defer与only刚好相反
	数据对象点击括号内出现的字段,每次都会走数据库查询
	数据对象点击括号内没有的字段,不会走数据查询
'''
	    res = models.Book.objects.defer('title', 'price')
    for obj in res:
        print(obj.title)  # 会走数据库查询
        print(obj.price)  # 会走数据库查询
        print(obj.publish_time)  # 会走数据对象
'''
select_related括号内只能接收外键字段(一对多,一对一),自动连表,得出的数据对象在点击表中数据的时候都不会再走数据库查询
'''
    res = models.Book.objects.all()
    for obj in res:
        print(obj.publish.name)  # 频繁走数据库查询

    res = models.Book.objects.select_related('publish') # 直走1次数据库
    for obj in res:
        print(obj.publish.name) # 会走数据对象
'''
prefetch_related(括号呢只能接收外键字段,一对多,一对一)底层其实是子查询,将查询之后的结果也一次性封装到数据对象中,用户在使用的时候是感觉不出来的
'''
    res = models.Book.objects.prefetch_related('publish') # 底层是子查询
    for obj in res:
        print(obj.publish.name) # 会走数据对象

事务相关操作

事务:ACID
事务隔离级别:脏读,幻读,不可重复读...
原生SQL:start transaction,rollback,commit,savepoint

鸡哥的例子:
# 买一本 跟jason学Linux 书
# 在数据库层面要做的事儿
# 1. 创建一条订单数据
# 2. 去产品表 将卖出数+1， 库存数-1
    from django.db.models import F
    from django.db import transaction
    try:
 zh       with transaction.atomic(): # 开启事务
            # 创建一条订单数据
            models.Order.objects.create(num="110110111", product_id=1, count=1)
            # 能执行成功
            models.Product.objects.filter(id=1).update(kucun=F("kucun") - 1, maichu=F("maichu") + 1)
    except Exception as e:
        print(e)

模型层常见字段

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)
    - 布尔值类型 # 传布尔值,存数字0或1
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)
    - 二进制类型
ForeignKey()
	外键类型在ORM中用来表示外键关联关系，一般把ForeignKey字段设置在 '一对多'中'多'的一方。
OneToOneField()
	通常一对一字段用来扩展已有字段。
ManyToMany()
	多对多字段,自动创建第三张表来存放
    
ORM字段与MySQL字段对应关系：
    'AutoField': 'integer AUTO_INCREMENT',
    'BigAutoField': 'bigint AUTO_INCREMENT',
    'BinaryField': 'longblob',
    'BooleanField': 'bool',
    'CharField': 'varchar(%(max_length)s)',
    'CommaSeparatedIntegerField': 'varchar(%(max_length)s)',
    'DateField': 'date',
    'DateTimeField': 'datetime',
    'DecimalField': 'numeric(%(max_digits)s, %(decimal_places)s)',
    'DurationField': 'bigint',
    'FileField': 'varchar(%(max_length)s)',
    'FilePathField': 'varchar(%(max_length)s)',
    'FloatField': 'double precision',
    'IntegerField': 'integer',
    'BigIntegerField': 'bigint',
    'IPAddressField': 'char(15)',
    'GenericIPAddressField': 'char(39)',
    'NullBooleanField': 'bool',
    'OneToOneField': 'integer',
    'PositiveIntegerField': 'integer UNSIGNED',
    'PositiveSmallIntegerField': 'smallint UNSIGNED',
    'SlugField': 'varchar(%(max_length)s)',
    'SmallIntegerField': 'smallint',
    'TextField': 'longtext',
    'TimeField': 'time',
    'UUIDField': 'char(32)',
    
    
# 自定义字段,在models.py中
    from django.db import models
    # Create your models here.
    #Django中没有对应的char类型字段，但是我们可以自己创建
    class FixCharField(models.Field):
        '''
        自定义的char类型的字段类
        '''
        def __init__(self,max_length,*args,**kwargs):
            self.max_length=max_length
            super().__init__(max_length=max_length,*args,**kwargs)
        def db_type(self, connection):
            '''
            限定生成的数据库表字段类型char，长度为max_length指定的值
            :param connection:
            :return:
            '''
            return 'char(%s)'%self.max_length
    #应用上面自定义的char类型
    class Class(models.Model):
        id=models.AutoField(primary_key=True)
        title=models.CharField(max_length=32)
        class_name=FixCharField(max_length=16)
        gender_choice=((1,'男'),(2,'女'),(3,'保密'))
        gender=models.SmallIntegerField(choices=gender_choice,default=3)

orm常见字段参数

max_length
verboses_name	添加说明
blank	当blank=True时，说明此处的数据可以不填，默认情况下为False，也就意味着默认情况下，所输入的数据不得空
null	当null=True时，也就是说如果没有填写数据，此处用NULL来储存空值，默认的是null=False。
default	为该字段设置默认值。
max_digits	小数总长度
decimal_places	小数位长度
unique	如果设置为unique=True 则该字段在此表中必须是唯一的 。
db_index	如果db_index=True 则代表着为此字段设置索引。
auto_now_add	配置auto_now_add=True，创建数据记录的时候会把当前时间添加到数据库。
auto_now	配置上auto_now=True，每次更新数据记录的时候会更新该字段。
choice	当字段数据的可能性,是可以完全列举出来的时候,应该考虑使用该参数
	# 比如性别,学历,成绩
    class UserInfo(models.Model):
        username = models.CharField(max_length=32)
        gender_choice = (
            (1,'男性'),
            (2,'女性'),
            (3,'其他'),
        )
        gender = models.IntegerField(choices=gender_choice)
	user_obj = models.UserInfo.objects.filter(pk=1).first()
    print(user_obj.gender) # 数据库中的真实数据 1
    print(user_obj.get_gender_display()) # 打印1对应的男性,如果没有,按照真实数据展示
to	设置要关联的表
to_field	设置要关联的表的字段
on_delete	当删除关联表中的数据时，当前表与其关联的行的行为。
models.CASCADE	删除关联数据，与之关联也删除
    1、models.CASCADE
        级联操作，当主表中被连接的一条数据删除时，从表中所有与之关联的数据同时被删除
    2、models.SET_NULL
        当主表中的一行数据删除时，从表中所有与之关联的数据的相关字段设置为null,此时注意定义外键时，这个字段必须可以允许为空
    3、models.PROTECT
        当主表中的一行数据删除时，由于从表中相关字段是受保护的外键，所以都不允许删除
    4、models.SET_DEFAULT
        当主表中的一行数据删除时，从表中所有相关的数据的关联字段设置为默认值，此时注意定义外键时，这个外键字段应该有一个默认值
    5、models.SET()
        当主表中的一条数据删除时，从表中所有的关联数据字段设置为SET()中设置的值，与models.SET_DEFAULT相似，只不过此时从表中的相关字段不需要设置default参数
    6、models.DO_NOTHING
        什么都不做，一切都看数据库级别的约束，注数据库级别的默认约束为RESTRICT,这个约束与django中的models.PROTECT相似
related_name 设计表的时候,起别名,用来给正反向查询

多对多三种创建方式

1.自动创建
	authors = models.ManyToManyField(to='Author')
	优点:第三张表自动创建
    缺点:第三张表扩展性差
2.手动创建
	class Book(models.Model):
		pass
	class Author(models.Model):
		pass
	class BookToAuthor(models.Model):
		book_id = models.ForeigenKey(to="Book")
		author_id = models.ForeigenKey(to="Author")
	优点:第三张表扩展性强
	缺点:无法使用正反向查询以及多对多的四个方法:add,set,remove,clear
3.半自动创建
	class Book(models.Model):
        authors = models.ManyToManyField(
            to='Author',
            through='BookToAuthor', # 通过哪个表
        	through_fields=('book_id','author_id') # 通过哪几个字段
            '''当前是哪个表,就要把哪个字段放前面,比如上面的book_id'''
        )
	class Author(models.Model):
		pass
	class BookToAuthor(models.Model):
		book_id = models.ForeigenKey(to="Book")
		author_id = models.ForeigenKey(to="Author")
	优点:扩展性强并且支持正反向查询
    缺点:无法使用多对多的四个方法:add,set,remove,clear