模型层
class User(models.Model):
name = models.CharField(max_length=32)
age = models.IntegerField()
register_time = models.DateField() # 年月日
"""
DateField
DateTimeField：
auto_now:每次操作数据的时候 该字段会自动将当前时间更新
auto_now_add:在创建数据的时候会自动将当前创建时间记录下来 之后只要不认为的修改 那么就一直不变
"""
def __str__(self):
return '对象:%s'%self.name
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)
email = models.EmailField()
# varchar(254) 该字段类型不是给models看的 而是给后面我们会学到的校验性组件看的
def __str__(self):
return '对象:%s'%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)
单表查询（增删改查）
# 添加数据的两种方式：
# create()
# obj = models.XXX(xxx=xxx,...) obj.save()
res = models.User.objects.create(name='jason',age=18,register_time='2002-1-21')
print(res)
import datetime
ctime = datetime.datetime.now()
user_obj = models.User(name='egon',age=84,register_time=ctime)
user_obj.save()
# 删除数据的两种方式：
# delete() 删除匹配到的所有数据
# 对象.delete() 指定删除某条数据
res = models.User.objects.filter(pk=2).delete()
print(res)
"""
pk会自动查找到当前表的主键字段 指代的就是当前表的主键字段
用了pk之后 你就不需要指代当前表的主键字段到底叫什么了
uid
pid
sid
...
"""
user_obj = models.User.objects.filter(pk=1).first()
user_obj.delete()
# 修改数据的两种方式：
# update() 修改匹配到的所有数据
# 对象.属性=值 修改指定对象的指定属性对象.save()保存
models.User.objects.filter(pk=4).update(name='egonDSB')
user_obj = models.User.objects.get(pk=4)
user_obj = models.User.objects.filter(pk=6)
"""
get方法返回的直接就是当前数据对象
但是该方法不推荐使用
一旦数据不存在该方法会直接报错
而filter则不会
所以我们还是用filter
"""
user_obj.name = 'egonPPP'
user_obj.save()
常见的查询方法
all() 查询所有数据
filter() 带有过滤条件的查询
get() 直接拿数据对象 但是条件不存在直接报错
first() 获取QuerySet对象中的第一个元素
res = models.User.objects.all().first()
print(res)
last() 获取QuerySet对象中的最后一个元素
res = models.User.objects.all().last()
print(res)
values() 可以指定获取的数据字段
values_list()
res = models.User.objects.values('name','age') # 返回值可以看成是一个列表套字典
print(res) # <QuerySet [{'name': 'jason', 'age': 18}, {'name': 'egon', 'age': 84}]>
res = models.User.objects.values_list('name','age') # 返回值可以看成是一个列表套元组
print(res) # <QuerySet [('jason', 18), ('egon', 84)]>
# 查看内部封装的sql语句
print(res.query) # SELECT `app01_user`.`name`, `app01_user`.`age` FROM `app01_user`
# 其他查看内部sql语句的办法：将下列代码复制到配置文件中,再执行打印语句即可打印内部sql语句
print(res) # SELECT `app01_user`.`name`, `app01_user`.`age` FROM `app01_user` LIMIT 21; args=()
"""
LOGGING = {
'version': 1,
'disable_existing_loggers': False,
'handlers': {
'console':{
'level':'DEBUG',
'class':'logging.StreamHandler',
},
},
'loggers': {
'django.db.backends': {
'handlers': ['console'],
'propagate': True,
'level':'DEBUG',
},
}
}
"""
distinct() 去重
res = models.User.objects.values('name','age').distinct()
print(res)
'''
注意：去重一定要是两条完全相同的数据才能够去重
使用去重时必须要将主键考虑进来
'''
order_by() 分组
res = models.User.objects.order_by('age') # 默认升序
res = models.User.objects.order_by('-age') # 降序
print(res)
reverse() 反转(ps:前提必须是已经排序过的数据 order_by())
res = models.User.objects.all()
res1 = models.User.objects.order_by('age').reverse()
print(res)
print(res1)
count() 统计当前数据的个数
res = models.User.objects.count()
print(res)
exclude() 将符合括号内条件的数据排除在外
res = models.User.objects.exclude(name='jason')
print(res)
exists() 判断数据是否存在，返回的是布尔值（基本不用，数据本身就自带布尔值）
res = models.User.objects.filter(pk=10).exists()
print(res)
测试脚本
# 测试环境的准备 去manage.py中拷贝前四行代码 然后自己写两行
import os
import sys
if __name__ == "__main__":
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "day64.settings")
import django
django.setup()
# 在这个代码块的下面就可以测试django里面的单个py文件了
'''
注意：测试代码必须写在测试环境中，
即所有的要执行的测试代码都必须写在django.setup()后面（包括模块得导入）
'''
神奇的双下划线查询，多表操作
年龄大于35岁的数据
# __gt
res = models.User.objects.filter(age__gt=35)
print(res)
年龄小于35岁的数据
# __lt
res = models.User.objects.filter(age__lt=35)
print(res)
年龄大于等于32岁、小于等于32岁的数据
# __gte __lte
res = models.User.objects.filter(age__gte=32) # 大于等于
print(res)
res = models.User.objects.filter(age__lte=32) # 小于等于
print(res)
年龄是18 或者32或者40的数据
# __in
res = models.User.objects.filter(age__in=[18,32,40])
print(res)
年龄在18到40岁之间的数据
# __range
res = models.User.objects.filter(age_range=[18,40]) # 顾头也顾尾
print(res)
查询名字中含有p的数据(区分大小写)
# __contains
res = models.User.objects.filter(name__contains='p') # 区分大小写
print(res) # <QuerySet [<User: 对象:ppp>]>
查询名字中含有p的数据(不区分大小写)
# name__icontains
res = models.User.objects.filter(name__icontains='p') # 区分大小写
print(res) # <QuerySet [<User: 对象:PPP>, <User: 对象:ppp>]>
查询名字以j开头(结尾)的数据
# __startswith
res = models.User.objects.filter(name__startswith='j')
print(res) # <QuerySet [<User: 对象:jason>]>
# __endswith
res = models.User.objects.filter(name__endswith='p')
print(res) # <QuerySet [<User: 对象:ppp>]>
查询注册时间是2020年、1月的数据
# __year 年、__month 月、__day 日
res = models.User.objects.filter(register_time__month='1')
res = models.User.objects.filter(register_time__year='2020')
print(res)
正向反向的概念
# 正向：外键字段在我手上那么，我查你就是正向
# 反向：外键字段如果不在手上，我查你就是反向
book >>>外键字段在书那(正向)>>> publish
publish >>>外键字段在书那(反向)>>> book
'''
正向查找：按字段
反向查找：表名小写
跨表查询
子查询(基于对象的跨表查询)
# 结合练习题来加强理解
# 1.查询书籍主键为1的出版社 （书查出版社，主键字段在书这边，正向）
book_obj = models.Book.objects.filter(pk=1).first()
res = book_obj.publish
print(res, res.name)
# 2.查询书籍主键为2的作者（书查作者，主键字段在书这边，正向）
book_obj = models.Book.objects.filter(pk=2).first()
# res = book_obj.authors # app01.Author.None
res = book_obj.authors.all() # <QuerySet [<Author: Author object>, <Author: Author object>]>
print(res)
# 3.查询作者jason的电话号码（作者查作者详情，主键字段在作者这边，正向）
author_obj = models.Author.objects.filter(name='jason').first()
res = author_obj.author_detail
print(res)
print(res.phone)
'''
正向什么时候需要加.all():
当结果可能有多个的时候需要加.all() （多对多关系）
当结果为一个则直接拿到数据对象无需.all()（一对一、一对多）
'''
# 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.all()
print(res)
# 6.查询手机号是110的作者姓名（作者详情查作者，主键在作者这边，反向）
author_detail_obj = models.AuthorDetail.objects.filter(phone='110').first()
res = author_detail_obj.author
print(res)
'''
反向查询什么时候需要加_set.all():
当查询结果可能是多个时就必须加_set.all() （多对多、一对多）
当查询结果只有一个时，不需要加_set.all() （一对一）
'''
联表查询(基于双下划线的跨表查询)
# 结合练习题来加强理解
# 1.查询jason的手机号和作者姓名
'''
正向：
res = models.Author.objects.filter(name='jason').values('name', 'author_detail__phone')
print(res)
反向：
res = models.AuthorDetail.objects.filter(author__name='jason').values('author__name', 'phone')
print(res)
'''
# 2.查询书籍主键为1的出版社名称和书的名称
'''
正向：
res = models.Book.objects.filter(pk=1).values('title', 'publish__name')
print(res)
反向：
res = models.Publish.objects.filter(book__pk=1).values('book__title', 'name')
print(res)
'''
# 3.查询书籍主键为1的作者姓名
'''
正向：
res = models.Book.objects.filter(pk=1).values('authors__name')
print(res)
反向：
res = models.Author.objects.filter(book__pk=1).values('name')
print(res)
'''
# 4.查询书籍主键是1的作者的手机号
'''
正向：
res = models.Book.objects.filter(pk=1).values('authors__author_detail__phone')
print(res)
反向：
res = models.AuthorDetail.objects.filter(author__book__pk=1).values('phone')
print(res)
'''
聚合查询
# 聚合查询 aggregate()
# 通常情况下都是配合分组一起使用
'''
只要是与数据库相关的模块
基本都在django.db.models中
如果上述没有那么应该在django.db中
'''
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.统计每一本书的作者个数
# models后面.什么就按什么分组
res = models.Book.objects.annotate() # 按图书分组
res = models.Book.objects.annotate(author_num=Count('authors')).values('title','author_num')
# author_num是我们自定义的字段名,用来存储每本书对应的作者个数
res = models.Book.objects.annotate(author_num=Count('authors__id')).values('title','author_num')
print(res)
'''
原生SQL语句
SELECT
title,
count( app01_book_authors.author_id )
FROM
app01_book
INNER JOIN app01_book_authors ON app01_book.id = app01_book_authors.book_id
GROUP BY
title
'''
# 2.统计每个出版社卖的最便宜的书的价格
res = models.Publish.objects.annotate(min_price=Min('book__price')).values('name', 'min_price')
print(res)
'''
原生SQL语句
SELECT
NAME,
min( app01_book.price )
FROM
app01_publish
INNER JOIN app01_book ON app01_publish.id = app01_book.publish_id
GROUP BY
NAME
'''
# 3.统计不止一个作者的图书
res = models.Book.objects.annotate(author_num=Count('authors')).filter(author_num__gt=1).values('title', 'author_num')
print(res)
'''
链式操作：只要orm语句得出的结果还是一个queryset对象，那么就可以无限制的.queryset对象下的方法
原生SQL语句
SELECT
title,
COUNT( app01_book_authors.author_id ) AS author_num
FROM
app01_book
INNER JOIN app01_book_authors ON app01_book.id = app01_book_authors.book_id
GROUP BY
title
HAVING
COUNT( app01_book_authors.author_id )>1
'''
# 4.查询每个作者出的书的总价格
res = models.Author.objects.annotate(sum_price=Sum('book__price')).values('name', 'sum_price')
print(res)
'''
原生SQL语句
SELECT
app01_author.NAME,
SUM( app01_book.price )
FROM
app01_author
INNER JOIN app01_book_authors ON app01_author.id = app01_book_authors.author_id
INNER JOIN app01_book ON app01_book_authors.book_id = app01_book.id
GROUP BY
app01_author.NAME
按照指定字段进行分组
models.Book.objects.values('price').annotate()
如果出现分组报错问题，先看看数据库有没有开严格模式
'''
F与Q查询
F查询
# 当我们将表中的两个字段的数据进行比较来做筛选条件时可使用F查询
# F查询：能帮助我们直接获取表中某个字段对应的数据
from django.db.models import F
# 1.查询卖出数大于库存数的书籍
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')+'爆款')
# django.db.utils.InternalError: (1292, "Truncated incorrect DOUBLE value: '爆款'")
Q查询
# 默认filter()内参数与参数之间通过逗号分隔，是and关系
# Q查询：能够改变filter()中参数与参数之间的关系
# , and关系 | or关系 ~ not关系
# , 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关系
res = models.Book.objects.filter(~Q(maichu__gt=100)|Q(price__lt=600))
# Q的高阶用法 能够将查询条件的左边也变成字符串形式
q=Q()
q.connector='or' # 指定关系模式，默认是and关系
q.children.append(('maichu_gt', 100))
q.children.append(('price_lt', 100))
res = models.Book.objects.filter(q) # filter支持直接传q对象
print(res)
django开启事务
'''
事务的四大特性（ACID）：
A 原子性：不可分割的最小单位、要么全部成功要么全部失败回滚
C 一执行：与原子性相辅相成、一个事务在执行前后必须处于一致
I 隔离性：一个事务的执行不会受到其他事务的干扰
D 持久性：一个事务一旦被提交，就永久有效
'''
# 暂时只需掌握Django中如何开启事务
# mysql中通过start transaction开启事务
# django中通过导入transaction模块开启事务
from django.db import transaction
try: #可以对事务捕获异常，当事务出错时进行另外的处理
with transaction.atomic():
# sql1
# sql2
...
# 在with代码快内书写的所有orm操作都是属于同一个事务
except Exception as e:
print(e)
print('执行其他操作')
orm中常用字段及参数
AutoField # orm会自动帮我们建一个名为id的主键字段
主键字段 primary_key=True
CharField varchar
verbose_name 字段的注释
max_length 长度
IntegerField int
BigIntegerField bigint
DecimalField
max_digits=8 8位小数
decimal_places=2 保留2位
EmailFiled varchar(254)
DateField date
DateTimeField datetime
auto_now:每次修改数据的时候都会自动更新当前时间
auto_now_add:只在创建数据的时候记录创建时间后续不会自动修改了
BooleanField(Field) - 布尔值类型
该字段传布尔值(False/True) 数据库里面存0/1
TextField(Field) - 文本类型
该字段可以用来存大段内容(文章、博客...) 没有字数限制
FileField(Field) - 字符类型
upload_to = "/data"
给该字段传一个文件对象，会自动将文件保存到/data目录下然后将文件路径保存到数据库中
/data/a.txt
# 自定义字段
class MyCharField(models.Field):
def __init__(self, max_length, *args, **kwargs):
self.max_length = max_length
# 调用父类Field下的__init__方法
super().__init__(max_length=max_length, *args, **kwargs) # 必须以关键字的形式传入
def db_type(self, connection):
# 返回真正的数据类型及其他约束条件
return 'char(%s)'%self.max_length
# 使用
myfield = MyCharField(max_length=23, null=True)
# 外键字段及参数
unique=True
ForeignKey(unique=True) === OneToOneField()
db_index
如果db_index=True 则代表着为此字段设置索引
'''
索引：就像书的目录，方便快速找到索引对应的数据
'''
to_field
设置要关联的表的字段 默认不写关联的就是另外一张的主键字段
on_delete
当删除关联表中的数据时，当前表与其关联的行的行为。
"""
django2.X及以上版本 需要你自己指定外键字段的级联更新级联删除
"""
数据库查询优化
only与defer
"""
orm语句的特点:
惰性查询：只有当后面用到了orm语句所查询出的参数时才会执行，否则orm就会自动识别不执行
"""
# res = models.Book.objects.all()
# print(res) # 要用数据了才会走数据库查询
# 想要获取书籍表中所有书的名字
res = models.Book.objects.values('title')
for d in res:
print(d.get('title'))
# only与defer
res = models.Book.objects.only('title')
res = models.Book.objects.all() # all已经包含了所有的数据，因此直接点字段就不会走数据库
res = models.Book.objects.defer('title') # 与only的效果刚好相反
for d in res:
print(d.title)
# 点only括号内的字段不会走数据库
# 点defer括号内的字段会重新走数据库查询
print(d.price)
# 点only括号外的字段，会重新走数据库查询
# 点defer括号外的字段，不会走数据库
'''
总结：
only括号外的字段不在查询出的对象里，查询该字段会重新走数据库
only括号内的字段就无需走数据库了
defer与only相反
defer括号内的字段不在查询出的对象里，查询该字段会重新走数据库
defer括号外的字段无需走数据库
'''
select_related与prefetch_related
# select_related与prefetch_related 都与跨表操作有关
# select_related
res = models.Book.objects.all() # 每循环一次就要走一次数据库查询
res = models.Book.objects.select_related('publish') # INNER JOIN 是联表操作
res = models.Book.objects.prefetch_related('publish') # IN 子查询
for i in res:
print(i.publish.name)
'''
总结：
select_related内部就是连表操作，一次性将大表里的所有数据全部封装给查询出来的对象
此时无论是点book表的字段还是点publish表的字段都无需再走数据库查询了
注意：select_related括号内只能放外键字段且只能是一对多、一对一的表间关系，
如果是多对多就会报错
prefetch_related内部就是子查询，会将查询出来的所有结果也给你封装到对象中
select_related与prefetch_related给用户的感觉是没有什么差距的，
但是这两个方法的内部是完全不同的，虽然prefetch_related要比select_related多一次查询
但是这两个方法各有优缺点，必须结合实际情况来考虑用谁
'''
