Models-详细操作

# 单表简单查询13种方法

1.all(): 查询所有结果
all： models.表名.objects.all()
book_all=models.Book.objects.all() # 结果是querySet集合 [model对象，....]
print(book_all) # <QuerySet [<Book: Book object>, <Book: Book object>, <Book: Book object>]>

2.filter(**kwargs): 它包含了与所给筛选条件相匹配的对象
filter： models.表名.objects.filter() # 结果是querySet集合 [model对象，....]
ret1=models.Book.objects.filter(author="yuan") # # <QuerySet [<Book: 追风筝的人>, <Book: asd>]>
ret2=models.Book.objects.filter(nid=1) # <QuerySet [<Book: yuan>]>
filter多条件逗号分隔
ret2=models.Book.objects.filter(author="yuan",price=123) # <QuerySet [<Book: yuan>]>
print(ret2)

3.get(**kwargs): 返回与所给筛选条件相匹配的对象，返回结果有且只有一个，如果符合筛选条件的对象超过一个或者没有都会抛出错误。
get models.表名.objects.get() # model对象，必须是一个，没有报错，多了报错
ret3=models.Book.objects.get(author="yuan")
print(ret3.price)

5.exclude(**kwargs): 它包含了与所给筛选条件不匹配的对象
exclude : 排除条件
ret4=models.Book.objects.exclude(author="yuan")
print(ret4)

4.values(*field): 返回一个ValueQuerySet——一个特殊的QuerySet，运行后得到的并不是一系列,model的实例化对象，而是一个可迭代的字典序列
values方法
ret=models.Book.objects.filter(author="yuan").values("title","price")
print(ret)# <QuerySet [{'title': '追风筝的人', 'price': Decimal('99.00')}, {'title': 'asd', 'price': Decimal('123.00')}]>

9.values_list(*field): 它与values()，非常相似，它返回的是一个元组序列，values返回的是一个字典序列
ret = models.Book.objects.filter(author="yuan").values_list("title", "price")
print(ret) # <QuerySet [('追风筝的人', Decimal('99.00')), ('asd', Decimal('123.00'))]>

6.order_by(*field): 对查询结果排序
7.reverse(): 对查询结果反向排序

8.distinct(): 从返回结果中剔除重复纪录
ret=models.Book.objects.filter(author="yuan").values("author").distinct()
print(ret)

10.count(): 返回数据库中匹配查询(QuerySet)的对象数量。
count计数方法
ret=models.Book.objects.filter(author="yuan").count()
print(ret)

11.first(): 返回第一条记录
ret = models.Book.objects.all().first()
print(ret)

12.last(): 返回最后一条记录

13.exists(): 如果QuerySet包含数据，就返回True，否则返回False
exists方法，是否存在数据，只会查询一条，效率高
if models.Book.objects.all().exists():
print("exists")
else:
print("nothing")

# 双下划线之单表查询

1.models.Book.objects.filter(publishDate__year=2017,publishDate__month=10) # 通过日期查询

2.models.Book.objects.filter(author__startswith="张") # 通过开头包含查询
startswith，istartswith, endswith, iendswith

3.models.Tb1.objects.filter(id__lt=10, id__gt=1) # 获取id大于1 且 小于10的值
models.Book.objects.filter(price__gt=100)
models.Book.objects.filter(price__gte=99) # 大于等于

4.models.Tb1.objects.filter(id__in=[11, 22, 33]) # 获取id等于11、22、33的数据
models.Tb1.objects.exclude(id__in=[11, 22, 33]) # not in

5.models.Tb1.objects.filter(name__contains="ven"） # 通过包含字符查询
models.Tb1.objects.filter(name__icontains="ven") # icontains大小写不敏感

6.models.Tb1.objects.filter(id__range=[1, 2]) # 范围bettwen and

# 图书馆里系统增删改查表操作

# 表 结构 图书管理系统
from django.db import models
# Create your models here.
class Book(models.Model):
title = models.CharField(max_length=32)
publishDate = models.DateField()
price = models.DecimalField(max_digits=5, decimal_places=2) # 999.99

# 创建一对多的关联字段 : 是与某个书籍对象关联的出版社对象(注意，只有一个对象)
publish=models.ForeignKey("Publish")

# 创建的多对多的关系
authors=models.ManyToManyField("Author")

def __str__(self):
return self.title

class Publish(models.Model):
nid = models.AutoField(primary_key=True)
name=models.CharField( max_length=32)
email=models.EmailField()

class Author(models.Model):
name=models.CharField(max_length=32)
age=models.IntegerField()

def __str__(self):
return self.name

class AuthorDetail(models.Model):
addr=models.CharField(max_length=32)
email=models.EmailField()
author=models.OneToOneField("Author")
’‘’
# 更新表记录
通过对象下字段更新，效率低
book_obj=models.Book.objects.filter(nid=id)[0]
book_obj.title=title1
book_obj.save()

通过update效率高
Book.objects.filter(id=2).update(price=255,name='linux')

# 删除表记录
Book.objects.filter(id=2).delete()

# 添加记录操作
添加数据库，单表
第一种写法，效率低
models.Book(title=title1,author=author1,publishDate=publishDate1,price=price1).save()
第二种写法
models.Book.objects.create(title=title1,author=author1,publishDate=publishDate1,price=price1)

添加数据库，多表
关联表必须有数据
pub_obj=Publish.objects.get(name="沙河出版社")

########################## 一对多添加##################################
方式1 关联字段放关联对象：
Book.objects.create(title="python",publishDate="2001-12-12",price=122,publish=pub_obj)
方式2 关联字段放关联ID：
book_obj=Book.objects.create(title="小红书3",publishDate="2011-08-12",price=112,publish_id=1)

########################## 多对多添加##################################
找到对象
book_obj = Book.objects.create(title="小红书3", publishDate="2011-08-12", price=112, publish_id=1)

第三张表关联添加
alex=Author.objects.get(name="alex") # aler.id
egon=Author.objects.get(name="egon") # egon.id

绑定关系1，对象
book_obj.authors.add(alex,egon)

追加一个作者
book_obj=Book.objects.filter(title="小红书3").first()

wenzhou=Author.objects.get(name="文州")
book_obj.authors.add(wenzhou)

删除一个作者
alex=Author.objects.get(name="alex")
book_obj = Book.objects.filter(title="小红书3").first()
book_obj.authors.remove(alex)

清空所有作者
book_obj = Book.objects.filter(title="小红书3").first()
book_obj.authors.clear()

绑定关系2，全部
book_obj = Book.objects.create(title="linux", publishDate="2011-08-13", price=113.00, publish=pub_obj)

authors=Author.objects.all()
book_obj.authors.add(*authors)

绑定关系3，利用id
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中的实现更加高效。

# 查询操作

正向查询是字段，反向查询看表名
--------- 基于对象跨表查询（子查询）

注意：找出是一个，一般是对象就是.，找出是多个，一半是要all
.publish
==== 一对多(Book----------------->Publish)
<----------------
.book_set.all()    

# 查询python这本书的出版社的名字 （正向查询，按字段）
book_obj=Book.objects.get(title="python")
print(book_obj.publish.name)

# 查询沙河出版社出版过的书籍名称 (反向查询按:表名_set)
pub_obj=Publish.objects.get(name="沙河出版社")    
print(pub_obj.book_set.all())

.authors.all()
==== 多对多（Book------------------->Author）
<-------------------- 
.book_set.all()

# 查询python这本书的所有作者的名字 （正向查询，按字段）
book_obj=Book.objects.get(title="python")
print(book_obj.authors.all())    

# 查询alex出版过的所有书籍 (反向查询按:表名_set)
author_obj=Author.objects.get(name="alex")
print(author_obj.book_set.all()) # <QuerySet [<Book: pyhton>]>

.author
==== 一对一（AuthorDetail--------------->Author）
<----------------
.authordetail

# 查询地址在沙河并且email是alex@126.com的作者的名字 （正向查询，按字段）
authordetail=AuthorDetail.objects.get(addr="沙河",email=alex@126.com)
print(authordetail.author.name)

# 查询alex的email (反向查询按:表名)
alex=Author.objects.get(name="alex")
print(alex.authordetail.email)    

# 查询住在沙河的作者出版过的所有书籍的名称以及出版社名称
authordetail=AuthorDetail.objects.get(addr="沙河")
author=authordetail.author
bookList=author.book_set.all()
for book in bookList:
print(book.title,book.publish.name)

# 基于双下划线查询（join查询）

##########################基于双下划线的查询：正向查询，按字段，反向查询，按表名#####################

########################################一对多查
# 查询python的出版社名称
ret=Book.objects.filter(title="python").values("publish__name") # <QuerySet [{'publish__name': '沙河出版社'}]>
print(ret)
Publish.objects.filter(book__title="小红书").values("name")

# 查询沙河出版社出版过的书籍名称
ret=Publish.objects.filter(name="沙河出版社").values("book__title")
print(ret)
Book.objects.filter(publish__name="沙河出版社").values("title")

# 查询python所有作者的名字
ret=Book.objects.filter(title="python").values_list("authors__name")
print(ret)

# 查询alex出版过的所有书籍
ret=Author.objects.filter(name="alex").values("book__title")
print(ret)
Book.objects.filter(authors__name="alex").values("title")

# 查询地址在沙河并且email是alex@126.com的作者的名字
ret=AuthorDetail.objects.filter(addr="沙河",email=alex@126.com).values("author__name")
print(ret)

# email以alex开头的作者出版过的所有书籍名称以及出版社名称
ret=Book.objects.filter(authors__authordetail__email__startswith="alex").values("title","publish__name")
print(ret)

# 分组，聚合函数

rom django.db.models import Avg,Sum,Count,Min
#############################聚合函数：aggregate###################
# 查询所有书籍的平均价格

ret=Book.objects.all().aggregate(avgPrice=Avg("price"))
print(ret) # {}

############################分组函数：annotate ###################
# 查询每一个出版社出版过的书籍个数
ret=Publish.objects.all().annotate(c=Count("book__title"))
for pub_obj in ret:
print(pub_obj.name,pub_obj.c)

# 查询每一本书的作者个数
ret=Book.objects.all().annotate(counts=Count("authors__id")).values("title","counts")
print(ret)

# 查询每一个作者出版过的书籍的平均价格
ret=Author.objects.all().annotate(avgPrice=Avg("book__price")).values("name","avgprice")
print(ret)

# F Q查询 （不支持字符串）

F 查询
# 查询评论数大于收藏数的书籍
from django.db.models import F
Book.objects.filter(commnetNum__lt=F('keepNum'))

# 查询评论数大于收藏数2倍的书籍（可以做一些运算）
Book.objects.filter(commnetNum__lt=F('keepNum')*2)

# 修改操作也可以使用F函数,比如将每一本书的价格提高30元
Book.objects.all().update(price=F("price")+30)　

Q 查询
# filter() 等方法中的关键字参数查询都是一起进行“AND” 的。 如果你需要执行更复杂的查询（例如OR 语句），你可以使用Q 对象。
from django.db.models import Q
# 查询作者是yuan 或者 是egon 的书
bookList=Book.objects.filter(Q(authors__name="yuan")|Q(authors__name="egon"))

# 查询作者是yuan 并且 出版日期不是2017年的书
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.完成图书管理系统
    书籍表的增删改查(尽量将之前的知识点全部融入进去)
"""
```