模型层之ORM多表操作

今日内容概要

  • 外键字段的增删改查
  • 正反向查询的概念
  • 基于对象的跨表查询(子查询)
  • 基于双下划綫的跨表查询(连表操作)
  • 聚合查询与分组查询
  • F查询与Q查询

一、准备表

  1. -----------------------------'models.py'-----------------------------
  2. from django.db import models
  3. # Create your models here.
  4. class Book(models.Model):
  5. title = models.CharField(max_length=32)
  6. price = models.DecimalField(max_digits=8, decimal_places=2)
  7. publish_time = models.DateField(auto_now_add=True)
  8. maichu = models.IntegerField(default=1000)
  9. kucun=models.IntegerField(default=100)
  10. publish = models.ForeignKey(to='Publish')
  11. authors = models.ManyToManyField(to='Author')
  12. def __str__(self):
  13. return self.title
  14. class Publish(models.Model):
  15. name = models.CharField(max_length=32)
  16. addr = models.CharField(max_length=64)
  17. def __str__(self):
  18. return self.name
  19. class Author(models.Model):
  20. name = models.CharField(max_length=32)
  21. age = models.IntegerField()
  22. author_detail = models.OneToOneField(to='AuthorDetail')
  23. def __str__(self):
  24. return self.name
  25. class AuthorDetail(models.Model):
  26. phone = models.BigIntegerField()
  27. addr = models.CharField(max_length=32)
  28. def __str__(self):
  29. return self.phone

表关系

  1. 一对一:
  2. AuthorAuthorDetail # 外键在Author
  3. 一对多:
  4. BookPublish # 外键在Book
  5. 多对多:
  6. BookAuthor # 外键在Book

二、外键字段foreign key的增删改

  1. """
  2. 分为:
  3. 1、一对多与一对一
  4. 2、多对多
  5. 查内容比较多,分为
  6. 1、基于'对象'的跨表查询
  7. 2、基于'双下划线'的跨表查询
  8. 3、双下划线进阶操作
  9. 4、聚合查询
  10. 5、分组查询
  11. 6、F与Q查询
  12. """

多表操作关键字

  1. """
  2. 一对一、一对多:
  3. 1、增:create()
  4. 2、改:update()
  5. 多对多:
  6. 1、先查询得到要操作的对象obj
  7. 2、增删改:
  8. 增:
  9. obj.外键.add(1,2)
  10. 改:
  11. obj.外键.set() 稍微不一样,里面放的是可迭代对象,比如列表[1,],或者queryset对象
  12. 删:
  13. obj.外键.remove()
  14. 清空:
  15. obj.外键.clear()
  16. """
  17. 1、针对一对多 一对一字段操作
  18. # 增
  19. 1、直接录入相关的主键字段数据
  20. models.Book.objects.create(title='三国演义',price=123.32,publish_id=1)
  21. 2、将查到的对象录入
  22. publish_obj = models.Publish.objects.filter(pk=2).first()
  23. models.Book.objects.create(title='水浒传',price=345.78,publish=publish_obj)
  24. # 改(update批量改,不用first,查到的都改)
  25. 1、直接录入相关的主键字段数据
  26. models.Book.objects.filter(pk=2).update(publish_id=2)
  27. 2、将查到的对象录入
  28. publish_obj = models.Publish.objects.filter(pk=1).first()
  29. models.Book.objects.filter(pk=3).update(publish=publish_obj)
  30. 2、针对多对多字段操作
  31. # 增
  32. """
  33. add
  34. 在第三张关系表中添加数据
  35. 括号内既可以传主键字段也可以传数据对象 并且都支持传多个
  36. """
  37. # 传主键
  38. book_obj = models.Book.objects.filter(pk=2).first()
  39. book_obj.authors.add(1) # 书籍对象点多对多虚拟字段就相当于在操作第三张关系表
  40. book_obj.authors.add(1,2)
  41. # 传对象
  42. author_obj = models.Author.objects.filter(pk=1).first()
  43. author_obj1 = models.Author.objects.filter(pk=2).first()
  44. book_obj.authors.add(author_obj)
  45. book_obj.authors.add(author_obj,author_obj1)
  46. # 改
  47. """
  48. set
  49. 在第三张关系表中修改数据
  50. 括号内需要传一个可迭代对象
  51. 可迭代对象里面的元素既可以传主键字段也可以传数据对象 并且都支持传多个
  52. """
  53. # 传主键
  54. book_obj = models.Book.objects.filter(pk=2).first()
  55. book_obj.authors.set([1,])
  56. book_obj.authors.set([1,2])
  57. # 传对象
  58. book_obj = models.Book.objects.filter(pk=3).first()
  59. author_obj = models.Author.objects.filter(pk=1).first()
  60. author_obj1 = models.Author.objects.filter(pk=2).first()
  61. book_obj.authors.set([author_obj])
  62. book_obj.authors.set([author_obj,author_obj1])
  63. # 放queryset对象
  64. book_obj = models.Book.objects.filter(pk=12).first()
  65. author_query = models.Author.objects.filter(age=18)
  66. book_obj.authors.set(author_query)
  67. # 删
  68. """
  69. remove
  70. 在第三张关系表中删除数据
  71. 括号内既可以传主键字段也可以传数据对象 并且都支持传多个
  72. """
  73. # 传主键
  74. book_obj = models.Book.objects.filter(pk=2).first()
  75. book_obj.authors.remove(1)
  76. book_obj.authors.remove(1,2)
  77. # 传对象
  78. author_obj = models.Author.objects.filter(pk=1).first()
  79. author_obj1 = models.Author.objects.filter(pk=2).first()
  80. book_obj.authors.remove(author_obj)
  81. book_obj.authors.remove(author_obj, author_obj1)
  82. # 清空数据
  83. """
  84. clear
  85. 在第三张关系表中清空数据
  86. 括号内无需传值
  87. """
  88. book_obj = models.Book.objects.filter(pk=2).first()
  89. book_obj.authors.clear() # 清空当前书籍与作者的所有绑定关系

三、ORM多表关系——正反向理论

  1. 正向查询
  2. 书籍对象查出版社对象 外键字段在书表中 # 正向查询
  3. 书籍对象查作者对象 外键字段在书表中 # 正向查询
  4. 作者对象查作者详情 外键字段在作者中 # 正向查询
  5. 反向查询
  6. 出版社查书籍对象 外键字段不在出版社表中 # 反向查询
  7. 作者查书籍对象 外键字段不在作者表中 # 反向查询
  8. 作者详情查作者 外键字段不在作者详情表中 # 反向查询
  9. """
  10. 查询数据的时候如果外键字段"在你的手上"则为正向查询
  11. 如果外键字段不在则为反向查询
  12. """
  13. 口诀:(重要)
  14. 正向查询按外键字段 ...
  15. 反向查询按表名小写 ...
  16. 正反向结合以下查询具体使用:
  17. 1、基于对象的跨表查询
  18. 2、双下划綫进阶操作
  19. 3、聚合查询
  20. 4FQ查询

四、基于”对象”的跨表查询(子查询)

  1. """将一条SQL语句的查询结果当做另外一条SQL语句的查询条件"""
  2. '''基于对象的跨表查询'''
  3. 案例:
  4. 1.查询主键为2的书籍对应的出版社
  5. 2.查询主键为3的书籍对应的作者
  6. 3.查询yly的详情数据
  7. 4.查询北方出版社出版的书籍
  8. 5.查询yly写过的书籍
  9. 6.查询电话是110的作者姓名
  10. 答案:
  11. # 1.查询主键为2的书籍对应的出版社
  12. # 先查询书籍对象
  13. # book_obj = models.Book.objects.filter(pk=2).first()
  14. # 再基于书籍对象查询出版社对象(书跟出版社的外键字段在书中 所以为正向)
  15. # res = book_obj.publish
  16. # print(res, res.pk, res.name, res.addr)
  17. # 2.查询主键为3的书籍对应的作者
  18. # 先查询书籍对象
  19. # book_obj = models.Book.objects.filter(pk=3).first()
  20. # 再基于书籍对象查询作者对象(书跟作者的外键字段在书中 所以为正向)
  21. # res = book_obj.authors
  22. # print(res) # app01.Author.None 只差一个all方法即可
  23. # res = book_obj.authors.all()
  24. # for author_obj in res:
  25. # print(author_obj.pk)
  26. # print(author_obj.name)
  27. # print(author_obj.age)
  28. # 3.查询yly的详情数据
  29. # 先查询作者对象
  30. # author_obj = models.Author.objects.filter(name='yly').first()
  31. # 再基于作者对象查询作者详情对象(作者跟作者详情的外键字段在作者表中 所以为正向)
  32. # res = author_obj.author_detail
  33. # print(res,res.phone)
  34. """
  35. 小总结
  36. 基于对象的正向查询 数据对象点了外键字段之后
  37. 是否需要再点all 取决于关联的数据项有几个 单个无需点 多个则需要点
  38. """
  39. # 4.查询北方出版社出版的书籍
  40. # 先查询北方出版社对象
  41. # publish_obj = models.Publish.objects.filter(name='北方出版社').first()
  42. # 再基于北方出版社对象对象查询书籍对象(北方出版社对象跟书籍的外键字段在书籍表中 所以为反向)
  43. # res = publish_obj.book_set
  44. # print(res) # app01.Book.None
  45. # res = publish_obj.book_set.all()
  46. # print(res) # <QuerySet [<Book: 对象:三国演义>, <Book: 对象:编程思维>]>
  47. # 5.查询yly写过的书籍
  48. # 先查询yly对象
  49. # author_obj = models.Author.objects.filter(name='yly').first()
  50. # 再基于yly对象查询书籍对象(yly对象跟书籍的外键字段在书籍表中 所以为反向)
  51. # res = author_obj.book_set
  52. # print(res) # app01.Book.None
  53. # res = author_obj.book_set.all()
  54. # print(res) # app01.Book.None
  55. # 6.查询电话是110的作者姓名
  56. # 先查询110详情对象
  57. # author_detail_obj = models.AuthorDetail.objects.filter(phone=110).first()
  58. # 再基于110详情对象查询作者对象(110详情对象跟作者的外键字段在作者表中 所以为反向)
  59. # res = author_detail_obj.author
  60. # print(res)
  61. """
  62. 基于对象的反向查询
  63. 如果查询出来的数据对象可以有多个 那么需要
  64. 表名小写_set.all()
  65. 如果查询出来的数据对象只有一个
  66. 表名小写
  67. """

五、基于”双下划线”的跨表查询(连表操作)

  1. 底层SQL语句用到了inner join连表操作
  2. 案例:
  3. 1.查询主键为2的书籍对应的出版社
  4. 2.查询主键为3的书籍对应的作者
  5. 3.查询yly的详情数据
  6. 4.查询书籍pk2的作者的电话
  7. 5.查询北方出版社出版的书籍
  8. 6.查询yly写过的书籍
  9. 7.查询电话是110的作者姓名
  10. # 使用filter和value
  11. 答案:
  12. # 1.查询主键为2的书籍对应的出版社
  13. # res = models.Book.objects.filter(pk=2).values('publish__name','publish__addr')
  14. # print(res)
  15. # 2.查询主键为3的书籍对应的作者
  16. # res = models.Book.objects.filter(pk=3).values('authors__name','authors__age')
  17. # print(res)
  18. # res = models.Book.objects.filter(pk=3).values_list('authors__name', 'authors__age')
  19. # print(res)
  20. # 3.查询yly的详情数据
  21. # res = models.Author.objects.filter(name='yly').values('author_detail__phone','author_detail__addr')
  22. # print(res)
  23. # 4.查询书籍pk为2的作者的电话
  24. # res = models.Book.objects.filter(pk=2).values('authors__author_detail__phone')
  25. # print(res)
  26. """小总结:自己总结"""
  27. # 5.查询北方出版社出版的书籍
  28. # res = models.Publish.objects.filter(name='北方出版社').values('book__title','book__price')
  29. # print(res)
  30. # 6.查询yly写过的书籍
  31. # res = models.Author.objects.filter(name='yly').values('book__title','book__price')
  32. # print(res)
  33. # 7.查询电话是110的作者姓名
  34. res = models.AuthorDetail.objects.filter(phone=110).values('author__name')
  35. print(res)

六、双下划线进阶操作

  1. 案例:
  2. 1.查询主键为2的书籍对应的出版社(不能点书籍)
  3. 2.查询主键为3的书籍对应的作者
  4. 3.查询yly的详情数据
  5. 4.查询北方出版社出版的书籍
  6. 5.查询yly写过的书籍
  7. 6.查询电话是110的作者姓名
  8. # 只使用filter,里面放外键字段或者对应表名
  9. 答案:
  10. # 1.查询主键为2的书籍对应的出版社(不能点书籍)
  11. # res = models.Publish.objects.filter(book__pk=2)
  12. # print(res) # <QuerySet [<Publish: 对象:北方出版社>]>
  13. # 2.查询主键为3的书籍对应的作者
  14. # res = models.Author.objects.filter(book__pk=3)
  15. # print(res) # <QuerySet [<Author: 对象:yly>, <Author: 对象:tony>]>
  16. # 3.查询yly的详情数据
  17. # res = models.AuthorDetail.objects.filter(author__name='yly')
  18. # print(res)
  19. # 4.查询北方出版社出版的书籍
  20. # res = models.Book.objects.filter(publish__name='北方出版社')
  21. # print(res)
  22. # 5.查询yly写过的书籍
  23. # res = models.Book.objects.filter(authors__name='yly')
  24. # print(res)
  25. # 6.查询电话是110的作者姓名
  26. res = models.Author.objects.filter(author_detail__phone=110)
  27. print(res)

七、聚合查询

  1. """分组查询:annotate"""
  2. 聚合函数
  3. max min sum count avg
  4. 案例:
  5. 1.统计所有书籍的总价格
  6. 2.统计所有书籍的总数
  7. 3.统计价格最高的
  8. 答案:
  9. from django.db.models import Max,Min,Sum,Count,Avg
  10. # 1.统计所有书籍的总价格
  11. # res = models.Book.objects.aggregate(Sum('price'))
  12. # print(res)
  13. # 2.统计所有书籍的总数
  14. # res = models.Book.objects.aggregate(Count('pk'))
  15. # print(res)
  16. # 3.统计价格最高的
  17. # res = models.Book.objects.aggregate(Max('price'))
  18. # print(res)
  19. res = models.Book.objects.aggregate(Max('price'),Min('price'),Sum('price'),Count('price'),Avg('price'))
  20. print(res)

八、分组查询

  1. """分组查询:annotate"""
  2. 案例:
  3. 1.统计每一本书的作者个数
  4. 2.统计出每个出版社卖的最便宜的书的价格
  5. 3.统计不止一个作者的图书
  6. 4.查询各个作者出的书的总价格
  7. 答案:
  8. # 1.统计每一本书的作者个数
  9. '''author_num是必须要起的别名 因为后面的values中需要使用'''
  10. # res = models.Book.objects.annotate(author_num=Count('authors__pk')).values('author_num','title')
  11. # print(res)
  12. # 2.统计出每个出版社卖的最便宜的书的价格
  13. # res = models.Publish.objects.annotate(min_price=Min('book__price')).values('min_price','name','book__title')
  14. # print(res)
  15. # 3.统计不止一个作者的图书
  16. # res = models.Book.objects.annotate(author_num=Count('authors__pk')).filter(author_num__gt=1)
  17. # print(res)
  18. # 4.查询各个作者出的书的总价格
  19. # res = models.Author.objects.annotate(price_sum=Sum('book__price')).values('name','price_sum')
  20. # print(res)
  21. """
  22. 1.大的分组
  23. models.表名.objects.annotate 按照models后面的表名分组(主键)
  24. 2.小的分组
  25. models.表名.objects.values('price').annotate() 按照values括号内指定的字段分组
  26. """

九、F与Q查询

F查询

  1. F的功能是获取数据库中字段原有的数据
  2. 案例:
  3. 1.将所有书籍的价格提升100
  4. 2.将所有书籍名称后面加上爆款后缀
  5. 3.查询库存数大于卖出数的书籍
  6. 答案:
  7. # 1.将所有书籍的价格提升100块
  8. # from django.db.models import F
  9. # models.Book.objects.update(price=F('price')+1000)
  10. # 2.将所有书籍名称后面加上爆款后缀
  11. # from django.db.models.functions import Concat
  12. # from django.db.models import Value
  13. # ret3 = models.Book.objects.update(title=Concat(F('title'), Value('爆款')))
  14. '''F查询默认操作数字类型 如果需要操作字符类型需要上述方式'''
  15. # 3.查询库存数大于卖出数的书籍
  16. res = models.Book.objects.filter(kucun__gt=F("maichu"))
  17. for i in res:
  18. print(i, "|", i.title, "|", i.kucun, "|", i.maichu)

Q查询

  1. """Q查询"""
  2. # filter括号内多个条件均为and关系
  3. 案例:
  4. 1、查询 主键为3或者卖出数为1000 的书籍
  5. 2、查询 库存数是100并且卖出数不是0 的书籍
  6. # 1.查询主键为3或者卖出数为1000的数据
  7. # res = models.Book.objects.filter(pk=3, maichu=1000) # 逗号分隔为and关系
  8. from django.db.models import Q
  9. ###########基本用法###########
  10. # res = models.Book.objects.filter(Q(pk=3), Q(maichu=1000)) # 逗号分隔为and关系
  11. # res = models.Book.objects.filter(Q(pk=3) | Q(maichu=1000)) # |分隔为or关系
  12. # res = models.Book.objects.filter(~Q(pk=3) | Q(maichu=1000)) # ~分隔为not关系
  13. # print(res)
  14. ###########进阶用法###########
  15. # filter(title='123') filter('title'='123')
  16. q = Q() # 默认多个条件之间也是and关系
  17. q.connector = 'or' # 也可以修改链接关系
  18. # q.children.append(('title', '三国演义爆款'))
  19. q.children.append(('title__contains', '爆'))
  20. q.children.append(('price', 1123))
  21. res = models.Book.objects.filter(q)
  22. print(res)

作业

  1. 1.整理今日内容及博客
  2. 2.尝试编写图书管理系统针对书籍的增删改查(页面操作)
  3. 3.预习明日内容
  4. https://www.cnblogs.com/Dominic-Ji/p/9213887.html
  5. https://www.cnblogs.com/Dominic-Ji/p/9203990.html