• Django多表查询

    目录

    一.多表查询引入

    1.数据准备

    2.外键的增删改查

    （1）一对多外键的增删改查

    1.1外键的增加

    1.2外键的删除

    1.3外键的修改

    (2)多对多外键的增删改查

    2.1增加

    2.2删除

    2.3更改

    2.4清空

    3.正反向概念

    二.多表查询

    1.子查询（基于对象的跨表查询）

    2.联表查询（基于双下划线的跨表查询）

    三.聚合查询

    四.分组查询

    五.F与Q查询

    1.F查询

    2.Q查询

    一.多表查询引入

    1.数据准备

    1. class Book(models.Model):
    2.     title = models.CharField(max_length=32)
    3.     price = models.DecimalField(max_digits=8, decimal_places=2)
    4.     publish_date = models.DateField(auto_now_add=True)
    5.  
    6.     # 一对多
    7.     publish = models.ForeignKey(to='Publish')
    8.     # 多对多
    9.     authors = models.ManyToManyField(to='Author')
    10.  
    11.  
    12. class Publish(models.Model):
    13.     name = models.CharField(max_length=32)
    14.     addr = models.CharField(max_length=64)
    15.     # 该字段不是给models看的，而是给校验行组件使用的
    16.     email = models.EmailField()
    17.  
    18.  
    19. class Author(models.Model):
    20.     name = models.CharField(max_length=32)
    21.     age = models.IntegerField()
    22.  
    23.     # 一对一
    24.     author_detail = models.OneToOneField(to='AuthDetail')
    25.  
    26.  
    27. class AuthDetail(models.Model):
    28.     phone = models.BigIntegerField()
    29.     addr = models.CharField(max_length=40)

    重载数据库

    1. python36 manage.py makemigrations
    2.  
    3. python36 manage.py migrate

    2.外键的增删改查

    （1）一对多外键的增删改查

    1.1外键的增加
    1. # （1）一对多的外键的增删改查
    2. # （1.1）外键的增加 - 直接写实际字段
    3. models.Book.objects.create(title="三国演义",price=1369.25,publish_id=1)
    4.  
    5. # (1.2)外键的增加 - 虚拟字段
    6. publish_obj = models.Publish.object.objects.filter(pk=2).first()
    7. models.Book.objects.create(title="红楼梦",price=1569.25,publish=publish_obj)
    1.2外键的删除
    1. # (2)一对多的外键删除
    2. models.Publish.objects.filter(pk=1).delete()
    1.3外键的修改
    1. # (2)一对多的外键的修改
    2. # - 直接写实际字段
    3. models.Book.object.filter(pk=1).update(publish_id=2)
    4. # - 虚拟字段
    5. publish_obj = models.publish.objects.filter(pk=1).first()
    6.  
    7. models.Book.objects.filter(pk=1).update(publish=publish_obj)

    (2)多对多外键的增删改查

    多对多 增删改查就是在操作第三张表

    2.1增加
    1. # 多对多外键的增删改查 - 就是在操作第三张表
    2. # （1）如何给书籍添加作者
    3. book_obj = models.Book.objects.filter(pk=1).first()
    4. # book_obj.authors - 这样我们就已经能操作第三张关系表了
    5. # 书籍ID为1的书籍绑定了一个主键为1的作者
    6. book_obj.authors.add(1)
    7. # 可以传多个参数
    8. book_obj.authors.add(2,3)
    9. # 支持参数传对象 - 且支持多个对象
    10. book_obj.authors.add(author_obj)
    2.2删除

    支持多个参数/支持对象

    1. # (2)删除
    2. book_obj = models.Book.objects.filter(pk=1).first()
    3. # 支持多个参数 - 支持多个对象
    4. book_obj.authors.remove(2)
    2.3更改

    先删除后增加

    1. # （3）修改
    2. book_obj = models.Book.objects.filter(pk=1).first()
    3. # 括号内必须给一个可迭代对象
    4. # 把1删掉，替换成2
    5. book_obj.author.set([1,2])
    6. # 把原来都删掉，替换成3
    7. book_obj.authors.set([3])
    8. # 支持放对象
    9. book_obj.authors.set([author_obj])
    2.4清空
    1. # （4）清空
    2. # 在第三张表中清除某一本书和作者的绑定关系
    3. book_obj = models.Book.objects.filter(pk=1).first()
    4. # 不要加任何参数
    5. book_obj.authors.clear()

    3.正反向概念

    • 正向
      • 外键字段在我手上，那么我查你就是正向
      • book>>>外键字段在book这边（正向）>>>出版社
    • 反向
      • 外键字段不在我手上，那么我查你就是反向
      • 出版社>>>外键字段在书这边（反向）>>>book
    • 一对一和一对多的判断也是这样

    正向查询按字段

    反向查询按表名（小写）

    二.多表查询

    1.子查询（基于对象的跨表查询）

    1. # [1] 基于对象的跨表查询
    2. # (1)查询书籍主键为1的出版社
    3. book_obj = models.Book.objects.filter(pk=1).first()
    4. # 书查出版社 - 正向 - 按字段查
    5. res = book_obj.publish
    6. print(res)  # Publish object
    7. print(res.name)  # 东方出版社
    8. print(res.addr)  # 东方
    9.  
    10. # （2）查询书籍主键为2的作者
    11. book_obj = models.Book.objects.filter(pk=1).first()
    12. # 书查作者 - 正向查询按字段
    13. res = book_obj.authors
    14. print(res)  # app01.Author.None
    15. # 列表中存放的是作者对象
    16. print(res.all())  # ]>
    17.  
    18. # （3）查询作者 的 电话号码
    19. author_obj = models.Author.objects.filter(name="dream").first()
    20. # 作者查询作者详情 - 正向查询按字段
    21. res = author_obj.author_detail
    22. print(res)  # AuthDetail object
    23. print(res.phone)  # 110
    24. print(res.addr)  # 山东
    25.  
    26. '''
    27.     在书写ORM语句的时候跟写SQL语句一样的
    28.     不要企图一次性将ORM语句写完，如果比较复杂，需要写一些看一些
    30.     正向 什么时候需要加 .all()
    31.         当查询返回的结果是多个的时候就需要用 .all()
    32.         当查询的结果只有一个的时候就不需要加
    33.     '''
    34.  
    35. # （4）查询出版社是东方出版社出版的书
    36. # 先拿到出版社对象
    37. publish_obj = models.Publish.objects.filter(name="东方出版社").first()
    38. # 出版社查书 - 主键字段在书 - 反向查询
    39. res = publish_obj.book_set.all()
    40. # publish_obj.book_set
    41. # print(res) # app01.Book.None
    42. # publish_obj.book_set.all()
    43. print(res)  # , , ]>
    44.  
    45. # （5）查询作者是dream写过的书
    46. # 先拿到作者对象
    47. author_obj = models.Author.objects.filter(name="dream").first()
    48. # 作者查书 - 主键在书 - 反向
    49. res = author_obj.book_set.all()
    50. print(res)  # ]>
    51.  
    52. # （5）查询手机号是 110的作者姓名
    53. # 先拿到作者详情的对象
    54. author_detail_obj = models.AuthDetail.objects.filter(phone=110).first()
    55. # 详情查作者 - 主键在作者 - 反向
    56. res = author_detail_obj.author
    57. print(res)  # Author object
    58. print(res.name)  # dream
    59.  
    60. '''
    61.     基于对象 - 反向查询
    62.         什么时候需要加 _set.all()
    63.             查询结果是多个的时候需要加
    64.             查询结果是多个的时候需要加
    65.     '''

    补充：_set.all()（反向查询）

    • 查询结果是多个的时候需要加

    2.联表查询（基于双下划线的跨表查询）

    1. # [2] 基于双下划线的跨表查询
    2. # （1）查询dream的手机号和作者的姓名
    3. # 正向：先查询到作者信息再 .value(需要查询信息的表__需要查询的字段,其他字段)
    4. res = models.Author.objects.filter(name="dream").values('author_detail__phone', 'name')
    5. print(res)  # 
    6. # 反向：先拿到详情，再用作者详情关联作者表，通过 __字段的方法 过滤出我们想要的指定数据
    7. res = models.AuthDetail.objects.filter(author__name="dream").values('phone', 'author__name')
    8. # AuthDetail.objects.filter(author__name="dream")
    9. print(res)  # ]>
    10. # AuthDetail.objects.filter(author__name="dream").values('phone','author__name')
    11. print(res)  # 
    12.  
    13. # （2）查询书籍主键ID为1的出版社名字和书的名字
    14. # 正向：先过滤出书籍ID为1的书籍对象，再去关联出版者表，利用__字段取值
    15. res = models.Book.objects.filter(pk=1).values('title', 'publish__name')
    16. print(res)  # 
    17. # 反向：先查询到指定出版社，再从出版社反向找到书籍名字
    18. res = models.Publish.objects.filter(book__id=1).values('name', 'book__title')
    19. print(res)  # 
    20.  
    21. # （3）查询书籍主键ID为1的作者姓名
    22. # 先拿到 书籍主键ID为1的对象，再关联作者信息表，通过__字段取值
    23. res = models.Book.objects.filter(pk=1).values('authors__name')
    24. print(res)  # 
    25. # 反向 : 先拿到 书籍ID为1的作者数据再去取作者的名字
    26. res = models.Author.objects.filter(book__id=1).values('name')
    27. print(res)  # 
    28.  
    29. # 查询书籍主键是1的作者的手机号
    30. # book author authordetail
    31. res = models.Book.objects.filter(pk=1).values('authors__author_detail__phone')
    32. print(res)  # 
    33.  
    34. '''
    35.     只要掌握了正反向的概念
    36.     以及双下划线查询
    37.     就可以无限跨表
    38.     '''

    三.聚合查询

    1.     # 聚合查询
    2.     # 聚合查询通常情况下都是配合分组一起使用的
    3.     '''
    4.     只要是和数据库相关的模块
    5.         基本上都在 django.db.models 里面
    6.         如果这里面没有 那大概率可能在 django.db 里面
    7.     '''
    8.     from django.db.models import Max, Min, Sum, Count, Avg
    9.  
    10.     # （1）所有书的平均价格
    11.     # 正常情况下，我们是需要 先进行分组再进行 聚合函数运算的
    12.     # 但是Django给我们提供了一种方法 ： aggregate 可以不分组进行某个字段的聚合函数
    13.     res = models.Book.objects.aggregate(Avg('price'))
    14.     print(res)  # {'price__avg': 1890.083333}
    15.  
    16.     # （2）一次性使用
    17.     res = models.Book.objects.aggregate(Avg('price'), Max('price'), Min('price'), Sum('price'), Count('pk'))
    18.     print(res) # {'price__avg': 1890.083333, 'price__max': Decimal('5959.25'), 'price__min': Decimal('555.25'), 'price__sum': Decimal('11340.50'), 'pk__count': 6}

    四.分组查询

    1. # 分组查询
    2. '''
    3.     MySQL中的分组查询
    4.         分组之后只能获取到分组的依据，组内其他字段都无法获取
    5.             严格模式中可以修改
    6.     '''
    7.  
    8. # （1）统计每一本书的作者个数
    9. # models 后面跟的是什么，就是按什么分组
    10. # res = models.Book.objects.annotate()
    11. #
    12. # '''
    13. # author_number 是我们自己定义的字段，用来存储统计出来的每本书的作者个数
    14. # '''
    15. # res = models.Book.objects.annotate(author_number=Count('authors')).values('title','author_number')
    16. # # 等价于
    17. # # res = models.Book.objects.annotate(author_number=Count('authors__pk')).values('title','author_number')
    18. # print(res) # 
    19.  
    20. # （2）统计每个出版社最便宜的书的价格
    21. # res = models.Publish.objects.annotate(min_price=Min('book__price')).values('name', 'min_price')
    22. # print(res) # 
    23.  
    24. # （3）统计不止一个作者的图书
    25. # （3.1）先按照图书分组
    26. # （3.2）过滤出不止一个作者的图书
    27. # 我的数据有限，我统计的是大于 0 的作者的图书
    28. # res = models.Book.objects.annotate(author_num=Count('authors')).filter(author_num__gt=0).values('title',
    29. # '''
    30. # 只要ORM语句得到的是 一个 queryset 对象
    31. #     那么就可以继续无限制的调用封装 的方法
    32. # '''                                                                                              'author_num')
    33. # print(res)  # 
    34.  
    35. # （4）查询每个作者出的书的总价格
    36. res = models.Author.objects.annotate(sum_price=Sum('book__price')).values('name', 'sum_price')
    37. print(res)  # 
    38.  
    39. '''
    40.     如果想按照指定的字段分组该如何处理
    41.         # 如果 annotate 前面没东西 则会按照 Book 分组 ，如果前面有参数 就会按照前面的参数进行分组 price
    42.         models.Book.objects.values('price').annotate()
    43.     '''

    五.F与Q查询

    1.F查询

    1. # F与Q查询
    2.  
    3. from django.db.models import F, Q
    4.  
    5. # （1）查出卖出数大于库存数的书籍
    6. # F 查询 : 帮助我们直接获取到表中的某个字段对应的数据
    7. res = models.Book.objects.filter(sales__gt=F('stock'))
    8. print(res)  # ]>
    9.  
    10. # (2) 将所有书籍的价格提升 50
    11. res = models.Book.objects.update(price=F('price') + 500)
    12. print(res)  # 6 - 影响到了 6 条数据
    13.  
    14. # （3）将所有书的名称后边加上 爆款两个字
    15. # 在操作字符串的时候，F查询不能够直接坐到字符串的拼接
    16. from django.db.models.functions import Concat
    17. from django.db.models import Value
    18.  
    19. res = models.Book.objects.update(title=Concat(F('title'), Value('爆款')))
    20. print(res) # 6 - 影响到了 6 条数据

    2.Q查询

    1. # F与Q查询
    2.  
    3. from django.db.models import F, Q
    4.  
    5. # （1）查询卖出数大于100或者价格小于500的书籍
    6.  
    7. # （1.1）直接使用 filter 查询数据，逗号隔开,里面放的参数是 and 关系
    8. res = models.Book.objects.filter(sales__gt=100, price__lt=500)
    9. print(res)  # 
    10.  
    11. # （1.2）直接使用 Q 查询数据，逗号隔开,里面放的参数还是 and 关系
    12. res = models.Book.objects.filter(Q(sales__gt=100), Q(price__lt=500))
    13. print(res)  # 
    14.  
    15. # （1.3）直接使用 Q 查询数据，逗号可以换成其他连接符达到效果
    16. res = models.Book.objects.filter(Q(sales__gt=100) or Q(price__lt=500))
    17. # 二者等价 （| ：或关系） （~  ： 取反 not 关系）
    18. res = models.Book.objects.filter(Q(sales__gt=100) | Q(price__lt=500))
    19. print(res)  # , , , ]>
    20.  
    21. # （2） Q的高阶用法 能够将查询条件的左边也变成 字符串形式
    22. # 产生 Q 对象
    23. q = Q()
    24. # 修改Q查询的默认连接条件
    25. q.connector = 'or'
    26. q.children.append('sales', 100)
    27. q.children.append('stock', 600)
    28. # filter 参数支持Q对象，默认还是 and 关系
    29. res = models.Book.objects.filter(q)

  • 相关阅读:
    ubuntu中用docker部署jenkins，并和码云实现自动化部署
    3.（vue3.x+vite）class动态绑定的方式
    【Linux】权限管理
    k8s部署mysql一主两从
    C专家编程 第6章 运行的诗章：运行时数据结构 6.5 当函数被调用时发生了什么：过程活动记录
    Linux环境下安装RabbitMQ的全过程
    solidity使用create2预测合约地址｜create2用法｜智能合约create2
    延迟消费的几种实现方案
    SystemVerilog学习-10-验证量化和覆盖率
    奇瑞金融：汽车金融行业架构设计
  • 原文地址：https://blog.csdn.net/qq_65852978/article/details/134441744