数据库：
#书籍
class Book(models.Model):
title = models.CharField(max_length=32)
price = models.DecimalField(max_digits=8,decimal_places=2)
# 一对多
publish = models.ForeignKey(to='Publish')
# 多对多
authors = models.ManyToManyField(to='Author') # 自动创建书籍和作者的第三张关系表
#出版
class Publish(models.Model):
title = models.CharField(max_length=32)
#作者
class Author(models.Model):
name = models.CharField(max_length=32)
# 一对一
author_detail = models.OneToOneField(to='AuthorDetail')
#作者信息
class AuthorDetail(models.Model):
addr = models.CharField(max_length=32)
phone = models.BigIntegerField()
聚合查询（aggregate）
聚合查询返回值的数据类型是字典。
返回的字典中：键的名称默认是（属性名称加上__聚合函数名），值是计算出来的聚合值。
MySQL聚合函数:max\min\sum\count\avg
如果要自定义返回字典的键的名称，可以起别名：
aggregate(别名 = 聚合函数名("属性名称"))
使用时需要导入对应模块
from django.db.models import Max, Min, Sum, Avg, Count
查找书籍中最便宜书籍的价格
from django.db.models import Max, Min, Sum, Avg, Count
res = models.Book.objects.aggregate(price_min = Min('price'))
print(res) # {'price_min': Decimal('11111.00')}
'''没有分组也可以使用聚合函数 默认整体就是一组'''
分组查询（annotate）
MySQL分组操作:group by
ORM执行分组操作 如果报错 可能需要去修改sql_mode 移除only_full_group_by
返回值：
分组后，用 values 取值，则返回值是 QuerySet 数据类型里面为一个个字典；
分组后，用 values_list 取值，则返回值是 QuerySet 数据类型里面为一个个元组。
annotate 里面放聚合函数。
values 或者 values_list 放在 annotate 前面：values 或者 values_list 是声明以什么字
段分组，annotate 执行分组。
values 或者 values_list 放在annotate后面： annotate 表示直接以当前表的pk执行分组，
values 或者 values_list 表示查询哪些字段， 并且要将 annotate 里的聚合函数起别名，在
values 或者 values_list 里写其别名。
1.统计每本书的作者个数
from django.db.models import Min,Min,Avg,Sum,Count
res = models.Book.objects.annotate(munb = Count('authors__pk')).values('title','munb')
print(res)
# <QuerySet [{'title': 'Python编程', 'munb': 2}, {'title': 'JAVA', 'munb': 1}, {'title': 'JS', 'munb': 2}]>
2.统计每个出版社卖的最便宜的书的价格
from django.db.models import Min
res = models.Publish.objects.annotate(book_min = Min('book__price')).values('title','book_min')
print(res)
# <QuerySet [{'title': '上海出版社', 'book_min': Decimal('100000.00')}, {'title': '浙江出版社', 'book_min': Decimal('11111.00')}]>
3.统计不止一个作者的图书
from django.db.models import Count
res = models.Book.objects.annotate(count = Count('authors__id')).filter(count__gt=1).values('title')
print(res) # <QuerySet [{'title': 'Python编程'}, {'title': 'JS'}]>
4.统计每个出版社出版的书籍个数
from django.db.models import Count
res = models.Publish.objects.annotate(count = Count('book__id')).values('title','count')
print(res)
# <QuerySet [{'title': '上海出版社', 'count': 2}, {'title': '浙江出版社', 'count': 1}]>
当表中已有数据的情况下，为表重新添加字段
为书籍表添加2个字段，销量和库存字段
#书籍
class Book(models.Model):
title = models.CharField(max_length=32)
price = models.DecimalField(max_digits=8,decimal_places=2)
#销量
sales = models.IntegerField(verbose_name='销量')
#库存
inventory = models.IntegerField(verbose_name='库存')
# 一对多
publish = models.ForeignKey(to='Publish')
# 多对多
authors = models.ManyToManyField(to='Author') # 自动创建书籍和作者的第三张关系表
修改了模型代码后，一定要进行数据迁移。
执行迁移命令后会发现不成功
它给了两个选项：
1)立即提供一次性默认值(在所有现有行上都设置为空值)
2)退出，让我在Models.py中添加一个默认值。
解决方法：
当表中已经有数据的情况下 添加额外的字段 需要指定默认值或者可以为null
方式1
IntegerField(verbose_name='销量',default=1000)
方式2
IntegerField(verbose_name='销量',null=True)
方式3
在迁移命令提示中直接给默认值
F查询和Q查询
F查询
如果想要对同一张表中的两个字段的值做比较，就需要用到 F()。
F() 的实例可以在查询中引用字段，来比较同一个 model 实例中两个不同字段的值。
用法：
F("字段名称")
F 动态获取对象字段的值，可以进行运算。
Django 支持 F() 对象之间以及 F() 对象和常数之间的加减乘除和取余的操作。
修改操作（update）也可以使用 F() 函数。
首先需要导入模块
from django.db.models import F
1.查询库存大于销量的书籍
from django.db.models import F
res = models.Book.objects.filter(inventory__gt=F('sales'))
print(res) # <QuerySet [<Book: Book object>, <Book: Book object>]>
print(res[0].title,res[1].title,end=' ') # Python编程 JS
2.将所有书的价格提升1000块
from django.db.models import F
res = models.Book.objects.update(price = F('price') + 1000)
print(res) # 3 返回受影响的行数
在已有的char数据类型的值后面添加内容
'''如果要修改char字段咋办(千万不能用上面对数值类型的操作！！！) 需要使用下列两个方法'''
from django.db.models.functions import Concat
from django.db.models import Value
res = models.Book.objects.update(title=Concat(F('title'), Value('爆款')))
Q查询
用法：
Q(条件判断)
之前构造的过滤器里的多个条件的关系都是 and，如果需要执行更复杂的查询（例如 or 语句），就可以使用 Q 。
Q 对象可以使用 & | ~ （与 或 非）操作符进行组合。
优先级从高到低：~ & |。
可以混合使用 Q 对象和关键字参数，Q 对象和关键字参数是用"and"拼在一起的（即将逗号看成
and ），但是 Q 对象必须位于所有关键字参数的前面。
使用时需要导入模块
from django.db.models import Q
1.查询价格销量大于900或者名称以P开头的书籍的名称和价格。
from django.db.models import Q
res = models.Book.objects.filter(Q(sales__gt=900) | Q(title__startswith='P')).values('title','price')
print(res)
# <QuerySet [{'title': 'Python编程', 'price': Decimal('102000.00')}, {'title': 'JAVA', 'price': Decimal('125456.00')}]>
Q对象的第二种用法
from django.db.models import Q
q = Q() # 创建一个Q对象q
q.connector = 'OR' # 默认是and 可以改为or
# 传入条件进行查询:
q.children.append(('price__lt', 100000))
q.children.append(('sales__gt', 600))
res = models.Book.objects.filter(q)
# 等于models.Book.objects.filter(Q(price__lt=100000) | Q(sales__gt=600))
print(res) # <QuerySet [<Book: Book object>, <Book: Book object>, <Book: Book object>]>
ORM查询优化
# 惰性查询：如果只是书写了orm语句，在后面根本没有用到该语句所查询出来的参数，那么orm会自动识别出来，直接不执行。
# 举例：
res = models.Book.objects.all() # 这时orm是不会走数据库的
print(res) # 只有当要用到的上述orm语句的结果时，才回去数据库查询。
only
res = models.Book.objects.only('title') # 括号内查询的字段可以有多个
print(res) # 查询一次，打印一条sql查询语句
for i in res:
print(i.title) # 查询一次，打印一条sql查询语句
print(i.price) # 有几个对象，就查询几次，打印几条sql查询语句
only会把括号内字段对应的值，封装到查询返回的对象中，通过对象点括号字段，不需要再走数据库
查询，直接返回结果，一旦你点了不是括号内的字段 就会频繁的去走数据库查询
'''
only英语的意思就是只有，那我们可以理解为通过only查询出来的对象内只会有小括号内的字
段的值，如果想要获取其他字段的值，就还得在查一次数据库或者说是在执行一次SQL语句。
'''
defer
res = models.Book.objects.defer('title')
# print(res)
for i in res:
print(i.price) # 只会执行一次SQL语句
print(i.title) # 每查询一次执行一次SQL语句
和 only相反，defer会将括号内的字段排除之外将其他字段对应的值， 直接封装到返回给你的对象
中， 点其他字段 不需要再走数据库查询，一旦你点了括号内的字段就会有多少值，就会查询几次
'''
defer刚好和only相反，defer小括号里写了啥，它反倒不给你，它会给你除了括号内的所有
字段值。当你获取小括号内的字段值时，会去查询，获取不在小括号内的字段值时反倒还不用去查
询。
'''
res = models.Book.objects.select_related('publish')
res = models.Book.objects.select_related('publish')
print(res) # <QuerySet [<Book: Book object>, <Book: Book object>, <Book: Book object>]>
print(res[0].title) # Python编程
print(res[0].publish.title) # 上海出版社
select_related括号内放外键字段，并且外键字段的类型只能是一对一和一对多，不能是多对多，
内部自动做联表操作，会将括号内外键字段所关联的表与当前表自动拼接成一张表，然后将表中的
数据一个个查询出来封装成一个个的对象。 这样做 就不会重复的走数据库，减轻数据库的压力。
select_related括号内可以放多个外键字段，用逗号隔开，会将多个外键字段关联的表拼接成一张大表
后续对象通过正反向查询跨表 内部不会再走数据库查询
res = models.Book.objects.prefetch_related('publish','authors')
for i in res:
print(i.publish)
prefetch_related内部是子查询，会自动按照步骤查询多张表，然后将查询的结果封装到对象中，这样给用户的感觉还是联表操作。
括号内支持传多个外键字段，并且没有类型限制。
每放一个外键字段，就会多走一条sql语句，多查询一张表
"""
将多次查询之后的结果封装到数据对象中 后续对象通过正反向查询跨表 内部不会再走数据库查询
"""
ORM常见字段
属性名 = models.字段类型,定义属性时需要指定字段类型, 通过字段类型的参数指定选项
属性名：
不允许使用python的保留关键字
不允许使用mysql的保留关键字
不允许使用连续的下划线，因为Django的查询语法就是连续的下划线
AutoField：自动增长的IntegerField, 不指定时Django会自动创建属性名为id的自动增长属性
BooleanField：布尔字段，值为True或False
NullBooleanField：支持Null、True、False三种值
CharField(max_length=20)：字符串
参数max_length表示最大字符个数
TextFiled：大文本字段，一般超过4000个字符时使用
IntegerField：整数
DecimalField(max_digits=None, decimal_places=None)：可以指定精度的十进制浮点数
参数max_digits表示总位数
参数decimal_places表示小数位数
FloatField（）：浮点数
DateField[auto_now=False, auto_now_add=False])：日期
参数auto_now表示每次保存对象时，自动设置该字段为当前时间，用于"最后一次修改"的时间戳，它
总是使用当前日期，默认为false
参数auto_now_add表示当对象第一次被创建时自动设置当前时间，用于创建的时间戳，它总是使用当
前日期，默认为false
参数auto_now_add和auto_now是相互排斥的，组合将会发生错误
TimeField：参数和DateField一样
DateTimeField：日期时间，参数同DateField
FileField：上传文件字段，以二进制的形式
ImageField：继承于FileField，对上传的内容进行校验，确保是有效的图片
自定义字段类型
class FixedCharField(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指定的值
"""
return 'char(%s)' % self.max_length
使用：
class Class(models.Model):
id = models.AutoField(primary_key=True)
title = models.CharField(max_length=25)
# 使用上面自定义的char类型的字段
cname = FixedCharField(max_length=25)
choice参数
用户表
性别
学历
工作经验
是否结婚
是否生子
客户来源
...
针对某个可以列举完全的可能性字段，我们应该如何存储
只要某个字段的可能性是可以列举完全的，那么一般情况下都会采用choices参数
class User(models.Model):
username = models.CharField(max_length=32)
age = models.IntegerField()
# 性别
gender_choices = (
(1,'男'),
(2,'女'),
(3,'其他'),
)
gender = models.IntegerField(choices=gender_choices)
# 分数
score_choices = (
('A','优秀'),
('B','良好'),
('C','及格'),
('D','不合格'),
)
# 保证字段类型跟列举出来的元祖第一个数据类型一致即可
score = models.CharField(choices=score_choices,null=True)
添加数据：
models.User.objects.create(username='111',age=18,gender=1)
models.User.objects.create(username='222',age=85,gender=2)
models.User.objects.create(username='333',age=40,gender=3)
models.User.objects.create(username='444',age=45,gender=4)
'''
添加数据时，如果添加了没有列举出来的数字也能存（范围是按照字段类型决定）
'''
取值：
只要是choices参数的字段 如果你想要获取对应信息 固定写法 get_字段名_display()
user_obj = models.User.objects.filter(pk=1).first()
print(user_obj.get_gender_display())
'''
有对应关系就拿对应的内容 没有还是本身
'''
ORM事务
在Django中可以通过django.db.transaction模块提供的atomic来定义一个事务，atomic提供两种用法
1.装饰器方法：
from django.db import transaction
@transaction.atomic
def viewfunc(request):
# 这些代码会在一个事务中执行
...
2.with 语句：
from django.db import transaction
def viewfunc(request):
# 这部分代码不在事务中，会被Django自动提交
...
with transaction.atomic():
# 这部分代码会在事务中执行
# 创建回滚点
save_id = transaction.savepoint()
#一旦异常，则回滚代码
transaction.savepoint_rollback(save_id)
...
from django.db import transaction
try:
with transaction.atomic():
pass
except Exception:
pass
ORM执行原生SQL
（1）
from django.db import connection, connections
cursor = connection.cursor()
cursor = connections['default'].cursor()
cursor.execute("原生SQL语句",[1]) # []中的内容会按位置传值给%s
# 查询结果
row = cursor.fetchone()
'''类似于pycharm操作'''
（2）
models.UserInfo.objects.extra(
select={'newid':'select count(1) from app01_usertype where id>%s'},
select_params=[1,], # 按位置传值给select中的%s
where = ['age>%s'],
params=[18,], # 按位置传值给where中的%s
order_by=['-age'],# 指定按这个字段降序，升序把"-"号去掉即可
tables=['app01_usertype'] # 指定表
)
多对多三种创建方式
# 全自动(常见)
orm自动创建第三张表 但是无法扩展第三张表的字段
authors = models.ManyToManyField(to='Author')
# 全手动(使用频率最低)
优势在于第三张表完全自定义扩展性高 劣势在于无法使用外键方法和正反向
class Book(models.Model):
title = models.CharField(max_length=32)
class Author(models.Model):
name = models.CharField(max_length=32)
class Book2Author(models.Model):
book_id = models.ForeignKey(to='Book')
author_id = models.ForeignKey(to='Author')
# 半自动(常见)
正反向还可以使用 并且第三张表可以扩展 唯一的缺陷是不能用
add\set\remove\clear四个方法
class Book(models.Model):
title = models.CharField(max_length=32)
authors = models.ManyToManyField(
to='Author',
through='Book2Author', # 指定表
through_fields=('book','author') # 指定字段
)
class Author(models.Model):
name = models.CharField(max_length=32)
'''多对多建在任意一方都可以 如果建在作者表 字段顺序互换即可'''
books = models.ManyToManyField(
to='Author',
through='Book2Author', # 指定表
through_fields=('author','book') # 指定字段
)
#第三张表
class Book2Author(models.Model):
book = models.ForeignKey(to='Book')
author = models.ForeignKey(to='Author')
