模型层之ORM多表操作

今日内容概要

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

一、准备表

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

表关系

  1. 一对一：
  2.     Author和AuthorDetail        # 外键在Author
  3. 一对多：
  4.     Book和Publish            # 外键在Book
  5. 多对多:
  6.     Book和Author                # 外键在Book

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

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

多表操作关键字

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

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

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

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

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

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

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

六、双下划线进阶操作

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

七、聚合查询

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

八、分组查询

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

九、F与Q查询

F查询

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

Q查询

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