Models-详细操作
# 单表简单查询13种方法
1 1.all(): 查询所有结果 2 all： models.表名.objects.all() 3 book_all=models.Book.objects.all() # 结果是querySet集合 [model对象，....] 4 print(book_all) # <QuerySet [<Book: Book object>, <Book: Book object>, <Book: Book object>]> 5 6 2.filter(**kwargs): 它包含了与所给筛选条件相匹配的对象 7 filter： models.表名.objects.filter() # 结果是querySet集合 [model对象，....] 8 ret1=models.Book.objects.filter(author="yuan") # # <QuerySet [<Book: 追风筝的人>, <Book: asd>]> 9 ret2=models.Book.objects.filter(nid=1) # <QuerySet [<Book: yuan>]> 10 filter多条件逗号分隔 11 ret2=models.Book.objects.filter(author="yuan",price=123) # <QuerySet [<Book: yuan>]> 12 print(ret2) 13 14 3.get(**kwargs): 返回与所给筛选条件相匹配的对象，返回结果有且只有一个，如果符合筛选条件的对象超过一个或者没有都会抛出错误。 15 get models.表名.objects.get() # model对象，必须是一个，没有报错，多了报错 16 ret3=models.Book.objects.get(author="yuan") 17 print(ret3.price) 18 19 5.exclude(**kwargs): 它包含了与所给筛选条件不匹配的对象 20 exclude : 排除条件 21 ret4=models.Book.objects.exclude(author="yuan") 22 print(ret4) 23 24 4.values(*field): 返回一个ValueQuerySet——一个特殊的QuerySet，运行后得到的并不是一系列,model的实例化对象，而是一个可迭代的字典序列 25 values方法 26 ret=models.Book.objects.filter(author="yuan").values("title","price") 27 print(ret)# <QuerySet [{'title': '追风筝的人', 'price': Decimal('99.00')}, {'title': 'asd', 'price': Decimal('123.00')}]> 28 29 9.values_list(*field): 它与values()，非常相似，它返回的是一个元组序列，values返回的是一个字典序列 30 ret = models.Book.objects.filter(author="yuan").values_list("title", "price") 31 print(ret) # <QuerySet [('追风筝的人', Decimal('99.00')), ('asd', Decimal('123.00'))]> 32 33 6.order_by(*field): 对查询结果排序 34 7.reverse(): 对查询结果反向排序 35 36 8.distinct(): 从返回结果中剔除重复纪录 37 ret=models.Book.objects.filter(author="yuan").values("author").distinct() 38 print(ret) 39 40 10.count(): 返回数据库中匹配查询(QuerySet)的对象数量。 41 count计数方法 42 ret=models.Book.objects.filter(author="yuan").count() 43 print(ret) 44 45 11.first(): 返回第一条记录 46 ret = models.Book.objects.all().first() 47 print(ret) 48 49 12.last(): 返回最后一条记录 50 51 13.exists(): 如果QuerySet包含数据，就返回True，否则返回False 52 exists方法，是否存在数据，只会查询一条，效率高 53 if models.Book.objects.all().exists(): 54 print("exists") 55 else: 56 print("nothing")
# 双下划线之单表查询
1 1.models.Book.objects.filter(publishDate__year=2017,publishDate__month=10) # 通过日期查询 2 3 2.models.Book.objects.filter(author__startswith="张") # 通过开头包含查询 4 startswith，istartswith, endswith, iendswith 5 6 3.models.Tb1.objects.filter(id__lt=10, id__gt=1) # 获取id大于1 且 小于10的值 7 models.Book.objects.filter(price__gt=100) 8 models.Book.objects.filter(price__gte=99) # 大于等于 9 10 4.models.Tb1.objects.filter(id__in=[11, 22, 33]) # 获取id等于11、22、33的数据 11 models.Tb1.objects.exclude(id__in=[11, 22, 33]) # not in 12 13 5.models.Tb1.objects.filter(name__contains="ven"） # 通过包含字符查询 14 models.Tb1.objects.filter(name__icontains="ven") # icontains大小写不敏感 15 16 6.models.Tb1.objects.filter(id__range=[1, 2]) # 范围bettwen and
# 图书馆里系统增删改查表操作
1 # 表 结构 图书管理系统 2 from django.db import models 3 # Create your models here. 4 class Book(models.Model): 5 title = models.CharField(max_length=32) 6 publishDate = models.DateField() 7 price = models.DecimalField(max_digits=5, decimal_places=2) # 999.99 8 9 # 创建一对多的关联字段 : 是与某个书籍对象关联的出版社对象(注意，只有一个对象) 10 publish=models.ForeignKey("Publish") 11 12 # 创建的多对多的关系 13 authors=models.ManyToManyField("Author") 14 15 def __str__(self): 16 return self.title 17 18 class Publish(models.Model): 19 nid = models.AutoField(primary_key=True) 20 name=models.CharField( max_length=32) 21 email=models.EmailField() 22 23 class Author(models.Model): 24 name=models.CharField(max_length=32) 25 age=models.IntegerField() 26 27 def __str__(self): 28 return self.name 29 30 class AuthorDetail(models.Model): 31 addr=models.CharField(max_length=32) 32 email=models.EmailField() 33 author=models.OneToOneField("Author") 34 ’‘’ 35 # 更新表记录 36 通过对象下字段更新，效率低 37 book_obj=models.Book.objects.filter(nid=id)[0] 38 book_obj.title=title1 39 book_obj.save() 40 41 通过update效率高 42 Book.objects.filter(id=2).update(price=255,name='linux') 43 44 # 删除表记录 45 Book.objects.filter(id=2).delete() 46 47 # 添加记录操作 48 添加数据库，单表 49 第一种写法，效率低 50 models.Book(title=title1,author=author1,publishDate=publishDate1,price=price1).save() 51 第二种写法 52 models.Book.objects.create(title=title1,author=author1,publishDate=publishDate1,price=price1) 53 54 添加数据库，多表 55 关联表必须有数据 56 pub_obj=Publish.objects.get(name="沙河出版社") 57 58 ########################## 一对多添加################################## 59 方式1 关联字段放关联对象： 60 Book.objects.create(title="python",publishDate="2001-12-12",price=122,publish=pub_obj) 61 方式2 关联字段放关联ID： 62 book_obj=Book.objects.create(title="小红书3",publishDate="2011-08-12",price=112,publish_id=1) 63 64 ########################## 多对多添加################################## 65 找到对象 66 book_obj = Book.objects.create(title="小红书3", publishDate="2011-08-12", price=112, publish_id=1) 67 68 第三张表关联添加 69 alex=Author.objects.get(name="alex") # aler.id 70 egon=Author.objects.get(name="egon") # egon.id 71 72 绑定关系1，对象 73 book_obj.authors.add(alex,egon) 74 75 追加一个作者 76 book_obj=Book.objects.filter(title="小红书3").first() 77 78 wenzhou=Author.objects.get(name="文州") 79 book_obj.authors.add(wenzhou) 80 81 删除一个作者 82 alex=Author.objects.get(name="alex") 83 book_obj = Book.objects.filter(title="小红书3").first() 84 book_obj.authors.remove(alex) 85 86 清空所有作者 87 book_obj = Book.objects.filter(title="小红书3").first() 88 book_obj.authors.clear() 89 90 绑定关系2，全部 91 book_obj = Book.objects.create(title="linux", publishDate="2011-08-13", price=113.00, publish=pub_obj) 92 93 authors=Author.objects.all() 94 book_obj.authors.add(*authors) 95 96 绑定关系3，利用id 97 book_obj.authors.add(1)
# 批量操作
在Hibenate中，通过批量提交SQL操作，部分地实现了数据库的批量操作。但在Django的ORM中的批量操作却要完美得多，真是一个惊喜。 数据模型定义 首先，定义一个实例使用的django数据库模型Product，只是象征性地定义了两个字段name和price。 from django.db import models class Product(models.Model): name = models.CharField(max_length=200) price = models.DecimalField(max_digits=10, decimal_places=2) 批量插入数据 批量插入数据时，只需先生成个一要传入的Product数据的列表，然后调用bulk_create方法一次性将列表中的数据插入数据库。 product_list_to_insert = list() for x in range(10): product_list_to_insert.append(Product(name='product name ' + str(x), price=x)) Product.objects.bulk_create(product_list_to_insert) 批量更新数据 批量更新数据时，先进行数据过滤，然后再调用update方法进行一次性地更新。下面的语句将生成类似update...where...的SQL语句。 Product.objects.filter(name__contains='name').update(name='new name') 批量删除数据 批量更新数据时，先是进行数据过滤，然后再调用delete方法进行一次性地删除。下面的语句将生成类似delete from...where...的SQL语句。 Product.objects.filter(name__contains='name query').delete() 如果是通过运行普通Python脚本的方式而不是在view中调用上述的代码的，别忘了先在脚本中进行django的初始化： import os os.environ.setdefault("DJANGO_SETTINGS_MODULE", "testproject.settings") import django django.setup() Hibernate的所谓“批量操作”中，对每一个实体的更新操作，都会生成一条update语句，然后只是把好几个update语句一次性提交给数据库服务器而已。对实体的删除操作也是一样。 Django ORM中的批量操作的实现更接近于SQL操作的体验，运行效率也会比Hibernate中的实现更加高效。
# 查询操作
1 正向查询是字段，反向查询看表名 2 --------- 基于对象跨表查询（子查询） 3 4 注意：找出是一个，一般是对象就是.，找出是多个，一半是要all 5 .publish 6 ==== 一对多(Book----------------->Publish) 7 <---------------- 8 .book_set.all() 9 10 # 查询python这本书的出版社的名字 （正向查询，按字段） 11 book_obj=Book.objects.get(title="python") 12 print(book_obj.publish.name) 13 14 # 查询沙河出版社出版过的书籍名称 (反向查询按:表名_set) 15 pub_obj=Publish.objects.get(name="沙河出版社") 16 print(pub_obj.book_set.all()) 17 18 .authors.all() 19 ==== 多对多（Book------------------->Author） 20 <-------------------- 21 .book_set.all() 22 23 # 查询python这本书的所有作者的名字 （正向查询，按字段） 24 book_obj=Book.objects.get(title="python") 25 print(book_obj.authors.all()) 26 27 # 查询alex出版过的所有书籍 (反向查询按:表名_set) 28 author_obj=Author.objects.get(name="alex") 29 print(author_obj.book_set.all()) # <QuerySet [<Book: pyhton>]> 30 31 .author 32 ==== 一对一（AuthorDetail--------------->Author） 33 <---------------- 34 .authordetail 35 36 # 查询地址在沙河并且email是alex@126.com的作者的名字 （正向查询，按字段） 37 authordetail=AuthorDetail.objects.get(addr="沙河",email=alex@126.com) 38 print(authordetail.author.name) 39 40 # 查询alex的email (反向查询按:表名) 41 alex=Author.objects.get(name="alex") 42 print(alex.authordetail.email) 43 44 # 查询住在沙河的作者出版过的所有书籍的名称以及出版社名称 45 authordetail=AuthorDetail.objects.get(addr="沙河") 46 author=authordetail.author 47 bookList=author.book_set.all() 48 for book in bookList: 49 print(book.title,book.publish.name)
# 基于双下划线查询（join查询）
1 ##########################基于双下划线的查询：正向查询，按字段，反向查询，按表名##################### 2 3 ########################################一对多查 4 # 查询python的出版社名称 5 ret=Book.objects.filter(title="python").values("publish__name") # <QuerySet [{'publish__name': '沙河出版社'}]> 6 print(ret) 7 Publish.objects.filter(book__title="小红书").values("name") 8 9 # 查询沙河出版社出版过的书籍名称 10 ret=Publish.objects.filter(name="沙河出版社").values("book__title") 11 print(ret) 12 Book.objects.filter(publish__name="沙河出版社").values("title") 13 14 # 查询python所有作者的名字 15 ret=Book.objects.filter(title="python").values_list("authors__name") 16 print(ret) 17 18 # 查询alex出版过的所有书籍 19 ret=Author.objects.filter(name="alex").values("book__title") 20 print(ret) 21 Book.objects.filter(authors__name="alex").values("title") 22 23 # 查询地址在沙河并且email是alex@126.com的作者的名字 24 ret=AuthorDetail.objects.filter(addr="沙河",email=alex@126.com).values("author__name") 25 print(ret) 26 27 # email以alex开头的作者出版过的所有书籍名称以及出版社名称 28 ret=Book.objects.filter(authors__authordetail__email__startswith="alex").values("title","publish__name") 29 print(ret)
# 分组，聚合函数
1 rom django.db.models import Avg,Sum,Count,Min 2 #############################聚合函数：aggregate################### 3 # 查询所有书籍的平均价格 4 5 ret=Book.objects.all().aggregate(avgPrice=Avg("price")) 6 print(ret) # {} 7 8 ############################分组函数：annotate ################### 9 # 查询每一个出版社出版过的书籍个数 10 ret=Publish.objects.all().annotate(c=Count("book__title")) 11 for pub_obj in ret: 12 print(pub_obj.name,pub_obj.c) 13 14 # 查询每一本书的作者个数 15 ret=Book.objects.all().annotate(counts=Count("authors__id")).values("title","counts") 16 print(ret) 17 18 # 查询每一个作者出版过的书籍的平均价格 19 ret=Author.objects.all().annotate(avgPrice=Avg("book__price")).values("name","avgprice") 20 print(ret)
# F Q查询 （不支持字符串）
1 F 查询 2 # 查询评论数大于收藏数的书籍 3 from django.db.models import F 4 Book.objects.filter(commnetNum__lt=F('keepNum')) 5 6 # 查询评论数大于收藏数2倍的书籍（可以做一些运算） 7 Book.objects.filter(commnetNum__lt=F('keepNum')*2) 8 9 # 修改操作也可以使用F函数,比如将每一本书的价格提高30元 10 Book.objects.all().update(price=F("price")+30) 11 12 Q 查询 13 # filter() 等方法中的关键字参数查询都是一起进行“AND” 的。 如果你需要执行更复杂的查询（例如OR 语句），你可以使用Q 对象。 14 from django.db.models import Q 15 # 查询作者是yuan 或者 是egon 的书 16 bookList=Book.objects.filter(Q(authors__name="yuan")|Q(authors__name="egon")) 17 18 # 查询作者是yuan 并且 出版日期不是2017年的书 19 bookList=Book.objects.filter(Q(authors__name="yuan") & ~Q(publishDate__year=2017)).values_list("title")
20 # Q查询的时候，Q要在关键词查询前面，否则报错，例如 filter(Q(authors__name="yuan"),authors__name="egon")
辅助理解ORM操作笔记
# 今日考题 ```python """ 今日考题 1.必知必会N条都有哪些，每个都是干啥使的 2.简述神奇的双下划线查询都有哪些方法，作用是什么 3.针对多对多外键字段的增删改查方法有哪些，各有什么特点？ 4.什么是正反向的概念，及查询口诀，你能否总结一下正反向查询不同情况下点击不同字段的规律 """ ``` # 上周内容回顾 * 单表的增删改查 ```python # 增 1.create() 2.对象.save() # 查 1.all() 查所有 2.filter() 筛选条件，括号内多个参数之间逗号隔开并且默认是and关系 3.get() 筛选条件，条件不存在直接报错 所以不推荐使用 # 改 1.update() queryset对象帮你封装的批量更新 2.对象.save() # 删 1.delete() queryset对象帮你封装的批量删除 2.对象.delete() """ 在实际的项目中 数据是不可能真正删除的 一般情况下都用一个字段来标记是否删除 """ ``` * 测试环境准备 ```python # 你如果只想测试django某一个py文件(大部分情况下就是models.py) # 在应用下的tests.py或者自己新建一个任意名称py文件(tests.py) """ 1.去manage.py拷贝前四行 2.自己书写两行 import django django.setup() """ ``` * 如何查看orm内部的sql语句 ```python # 1.queryset对象可以直接点query查看 queryset对象.query # 2.配置文件配置日志相关代码即可(不要记 直接拷贝使用即可) 参考笔记或者博客自己保存好 ``` * 必知必会N多条 ```python # 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() 判断数据集是否有值 返回布尔值 ``` * 神奇的双下划线查询 ```python # 价格大于 小于 大于等于 小于等于 price__gt price__lt price__gte price__lte # 成员查询 price__in # 范围查询 price__range # 模糊查询 title__contains 默认是区分大小写的 title__icontains 忽略大小写 # 只按照年份或者月份或者... create_time__year craete_time__month ``` * 外键字段的增删改查 ```python # 一对多 publish_id = 1 punlish = publish_obj # 多对多 add remove 上述两个方法括号内即可以传数字也可以传对象并且都支持多个 set 括号内必须传一个可迭代对象 可迭代对象里面的元素可以数字也可以对象并且都支持多个 clear 括号内无需给任何参数，直接清空对应的关系数据 ``` * 多表查询 ```python # 正反向的概念 正向 外键字段就在我手中 反向 外键字段不再我手中 # 小口诀 正向查询按外键字段 反向查询按表名小写 _set .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') # 图书管理系统 图书的增删改查 ``` # 今日内容概要 * 聚合查询(聚合函数的使用)aggregate max、min、sum、count、avg * 分组查询(group by的使用)annotate * F与Q查询 * django中如何开启事务 * orm中常用字段及参数 * 数据库查询优化(only与defer、select_related与prefetch_related) * 图书管理系统作业讲解 # 今日内容详细 ### 聚合查询 ```python # 聚合查询 aggregate """ 聚合查询通常情况下都是配合分组一起使用的 只要是跟数据库相关的模块 基本上都在django.db.models里面 如果上述没有那么应该在django.db里面 """ 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) ``` ### 分组查询 ```python # 分组查询 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.统计每个出版社卖的最便宜的书的价格(作业:复习原生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) """ 如果我想按照指定的字段分组该如何处理呢？ models.Book.objects.values('price').annotate() 后续BBS作业会使用 你们的机器上如果出现分组查询报错的情况 你需要修改数据库严格模式 """ ``` ### F与Q查询 ```python # 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') + '爆款') # 所有的名称会全部变成空白 ``` ```python # 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) ``` ### django中如何开启事务 ```python """ 事务 ACID 原子性 不可分割的最小单位 一致性 跟原子性是相辅相成 隔离性 事务之间互相不干扰 持久性 事务一旦确认永久生效 事务的回滚 rollback 事务的确认 commit """ # 目前你只需要掌握Django中如何简单的开启事务 # 事务 from django.db import transaction try: with transaction.atomic(): # sql1 # sql2 ... # 在with代码快内书写的所有orm操作都是属于同一个事务 except Exception as e: print(e) print('执行其他操作') ``` ### orm中常用字段及参数 ```python 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作业也会涉及 # 更多字段 直接参考博客:https://www.cnblogs.com/Dominic-Ji/p/9203990.html # 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及以上版本 需要你自己指定外键字段的级联更新级联删除 """ ``` ### 数据库查询优化 ```python 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) """ 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括号内只能放外键字段 一对多 一对一 多对多也不行 """ # for i in res: # print(i.publish.name) # 每循环一次就要走一次数据库查询 res = models.Book.objects.prefetch_related('publish') # 子查询 """ prefetch_related该方法内部其实就是子查询 将子查询查询出来的所有结果也给你封装到对象中 给你的感觉好像也是一次性搞定的 """ for i in res: print(i.publish.name) ``` ### 图书管理系统 ### 作业 ```python """ 1.整理今日内容到博客 2.熟练掌握数据库常用字段及参数以及应用场景 3.总结数据库查询优化的两组方法，尝试用自己的语言表述 4.完成图书管理系统 书籍表的增删改查(尽量将之前的知识点全部融入进去) """ ```
