模型层之ORM多表操作
模型层之ORM多表操作
目录
今日内容概要
- 外键字段的增删改查
- 正反向查询的概念
- 基于对象的跨表查询(子查询)
- 基于双下划綫的跨表查询(连表操作)
- 聚合查询与分组查询
- F查询与Q查询
一、准备表
-----------------------------'models.py'-----------------------------
from django.db import models
# Create your models here.
class Book(models.Model):
title = models.CharField(max_length=32)
price = models.DecimalField(max_digits=8, decimal_places=2)
publish_time = models.DateField(auto_now_add=True)
maichu = models.IntegerField(default=1000)
kucun=models.IntegerField(default=100)
publish = models.ForeignKey(to='Publish')
authors = models.ManyToManyField(to='Author')
def __str__(self):
return self.title
class Publish(models.Model):
name = models.CharField(max_length=32)
addr = models.CharField(max_length=64)
def __str__(self):
return self.name
class Author(models.Model):
name = models.CharField(max_length=32)
age = models.IntegerField()
author_detail = models.OneToOneField(to='AuthorDetail')
def __str__(self):
return self.name
class AuthorDetail(models.Model):
phone = models.BigIntegerField()
addr = models.CharField(max_length=32)
def __str__(self):
return self.phone
表关系
一对一：
Author和AuthorDetail # 外键在Author
一对多：
Book和Publish # 外键在Book
多对多:
Book和Author # 外键在Book
二、外键字段foreign key的增删改
"""
分为：
1、一对多与一对一
2、多对多
查内容比较多，分为
1、基于'对象'的跨表查询
2、基于'双下划线'的跨表查询
3、双下划线进阶操作
4、聚合查询
5、分组查询
6、F与Q查询
"""
多表操作关键字
"""
一对一、一对多：
1、增：create()
2、改：update()
多对多：
1、先查询得到要操作的对象obj
2、增删改:
增：
obj.外键.add(1,2)
改：
obj.外键.set() 稍微不一样，里面放的是可迭代对象，比如列表[1,]，或者queryset对象
删：
obj.外键.remove()
清空：
obj.外键.clear()
"""
1、针对一对多 一对一字段操作
# 增
1、直接录入相关的主键字段数据
models.Book.objects.create(title='三国演义',price=123.32,publish_id=1)
2、将查到的对象录入
publish_obj = models.Publish.objects.filter(pk=2).first()
models.Book.objects.create(title='水浒传',price=345.78,publish=publish_obj)
# 改(update批量改，不用first,查到的都改)
1、直接录入相关的主键字段数据
models.Book.objects.filter(pk=2).update(publish_id=2)
2、将查到的对象录入
publish_obj = models.Publish.objects.filter(pk=1).first()
models.Book.objects.filter(pk=3).update(publish=publish_obj)
2、针对多对多字段操作
# 增
"""
add
在第三张关系表中添加数据
括号内既可以传主键字段也可以传数据对象 并且都支持传多个
"""
# 传主键
book_obj = models.Book.objects.filter(pk=2).first()
book_obj.authors.add(1) # 书籍对象点多对多虚拟字段就相当于在操作第三张关系表
book_obj.authors.add(1,2)
# 传对象
author_obj = models.Author.objects.filter(pk=1).first()
author_obj1 = models.Author.objects.filter(pk=2).first()
book_obj.authors.add(author_obj)
book_obj.authors.add(author_obj,author_obj1)
# 改
"""
set
在第三张关系表中修改数据
括号内需要传一个可迭代对象
可迭代对象里面的元素既可以传主键字段也可以传数据对象 并且都支持传多个
"""
# 传主键
book_obj = models.Book.objects.filter(pk=2).first()
book_obj.authors.set([1,])
book_obj.authors.set([1,2])
# 传对象
book_obj = models.Book.objects.filter(pk=3).first()
author_obj = models.Author.objects.filter(pk=1).first()
author_obj1 = models.Author.objects.filter(pk=2).first()
book_obj.authors.set([author_obj])
book_obj.authors.set([author_obj,author_obj1])
# 放queryset对象
book_obj = models.Book.objects.filter(pk=12).first()
author_query = models.Author.objects.filter(age=18)
book_obj.authors.set(author_query)
# 删
"""
remove
在第三张关系表中删除数据
括号内既可以传主键字段也可以传数据对象 并且都支持传多个
"""
# 传主键
book_obj = models.Book.objects.filter(pk=2).first()
book_obj.authors.remove(1)
book_obj.authors.remove(1,2)
# 传对象
author_obj = models.Author.objects.filter(pk=1).first()
author_obj1 = models.Author.objects.filter(pk=2).first()
book_obj.authors.remove(author_obj)
book_obj.authors.remove(author_obj, author_obj1)
# 清空数据
"""
clear
在第三张关系表中清空数据
括号内无需传值
"""
book_obj = models.Book.objects.filter(pk=2).first()
book_obj.authors.clear() # 清空当前书籍与作者的所有绑定关系
三、ORM多表关系——正反向理论
正向查询
书籍对象查出版社对象 外键字段在书表中 # 正向查询
书籍对象查作者对象 外键字段在书表中 # 正向查询
作者对象查作者详情 外键字段在作者中 # 正向查询
反向查询
出版社查书籍对象 外键字段不在出版社表中 # 反向查询
作者查书籍对象 外键字段不在作者表中 # 反向查询
作者详情查作者 外键字段不在作者详情表中 # 反向查询
"""
查询数据的时候如果外键字段"在你的手上"则为正向查询
如果外键字段不在则为反向查询
"""
口诀:(重要)
正向查询按外键字段 ...
反向查询按表名小写 ...
正反向结合以下查询具体使用:
1、基于对象的跨表查询
2、双下划綫进阶操作
3、聚合查询
4、F与Q查询
四、基于"对象"的跨表查询(子查询)
"""将一条SQL语句的查询结果当做另外一条SQL语句的查询条件"""
'''基于对象的跨表查询'''
案例：
1.查询主键为2的书籍对应的出版社
2.查询主键为3的书籍对应的作者
3.查询yly的详情数据
4.查询北方出版社出版的书籍
5.查询yly写过的书籍
6.查询电话是110的作者姓名
答案：
# 1.查询主键为2的书籍对应的出版社
# 先查询书籍对象
# book_obj = models.Book.objects.filter(pk=2).first()
# 再基于书籍对象查询出版社对象(书跟出版社的外键字段在书中 所以为正向)
# res = book_obj.publish
# print(res, res.pk, res.name, res.addr)
# 2.查询主键为3的书籍对应的作者
# 先查询书籍对象
# book_obj = models.Book.objects.filter(pk=3).first()
# 再基于书籍对象查询作者对象(书跟作者的外键字段在书中 所以为正向)
# res = book_obj.authors
# print(res) # app01.Author.None 只差一个all方法即可
# res = book_obj.authors.all()
# for author_obj in res:
# print(author_obj.pk)
# print(author_obj.name)
# print(author_obj.age)
# 3.查询yly的详情数据
# 先查询作者对象
# author_obj = models.Author.objects.filter(name='yly').first()
# 再基于作者对象查询作者详情对象(作者跟作者详情的外键字段在作者表中 所以为正向)
# res = author_obj.author_detail
# print(res,res.phone)
"""
小总结
基于对象的正向查询 数据对象点了外键字段之后
是否需要再点all 取决于关联的数据项有几个 单个无需点 多个则需要点
"""
# 4.查询北方出版社出版的书籍
# 先查询北方出版社对象
# publish_obj = models.Publish.objects.filter(name='北方出版社').first()
# 再基于北方出版社对象对象查询书籍对象(北方出版社对象跟书籍的外键字段在书籍表中 所以为反向)
# res = publish_obj.book_set
# print(res) # app01.Book.None
# res = publish_obj.book_set.all()
# print(res) # <QuerySet [<Book: 对象:三国演义>, <Book: 对象:编程思维>]>
# 5.查询yly写过的书籍
# 先查询yly对象
# author_obj = models.Author.objects.filter(name='yly').first()
# 再基于yly对象查询书籍对象(yly对象跟书籍的外键字段在书籍表中 所以为反向)
# res = author_obj.book_set
# print(res) # app01.Book.None
# res = author_obj.book_set.all()
# print(res) # app01.Book.None
# 6.查询电话是110的作者姓名
# 先查询110详情对象
# author_detail_obj = models.AuthorDetail.objects.filter(phone=110).first()
# 再基于110详情对象查询作者对象(110详情对象跟作者的外键字段在作者表中 所以为反向)
# res = author_detail_obj.author
# print(res)
"""
基于对象的反向查询
如果查询出来的数据对象可以有多个 那么需要
表名小写_set.all()
如果查询出来的数据对象只有一个
表名小写
"""
五、基于"双下划线"的跨表查询(连表操作)
底层SQL语句用到了inner join连表操作
案例：
1.查询主键为2的书籍对应的出版社
2.查询主键为3的书籍对应的作者
3.查询yly的详情数据
4.查询书籍pk为2的作者的电话
5.查询北方出版社出版的书籍
6.查询yly写过的书籍
7.查询电话是110的作者姓名
# 使用filter和value
答案：
# 1.查询主键为2的书籍对应的出版社
# res = models.Book.objects.filter(pk=2).values('publish__name','publish__addr')
# print(res)
# 2.查询主键为3的书籍对应的作者
# res = models.Book.objects.filter(pk=3).values('authors__name','authors__age')
# print(res)
# res = models.Book.objects.filter(pk=3).values_list('authors__name', 'authors__age')
# print(res)
# 3.查询yly的详情数据
# res = models.Author.objects.filter(name='yly').values('author_detail__phone','author_detail__addr')
# print(res)
# 4.查询书籍pk为2的作者的电话
# res = models.Book.objects.filter(pk=2).values('authors__author_detail__phone')
# print(res)
"""小总结:自己总结"""
# 5.查询北方出版社出版的书籍
# res = models.Publish.objects.filter(name='北方出版社').values('book__title','book__price')
# print(res)
# 6.查询yly写过的书籍
# res = models.Author.objects.filter(name='yly').values('book__title','book__price')
# print(res)
# 7.查询电话是110的作者姓名
res = models.AuthorDetail.objects.filter(phone=110).values('author__name')
print(res)
六、双下划线进阶操作
案例：
1.查询主键为2的书籍对应的出版社(不能点书籍)
2.查询主键为3的书籍对应的作者
3.查询yly的详情数据
4.查询北方出版社出版的书籍
5.查询yly写过的书籍
6.查询电话是110的作者姓名
# 只使用filter，里面放外键字段或者对应表名
答案：
# 1.查询主键为2的书籍对应的出版社(不能点书籍)
# res = models.Publish.objects.filter(book__pk=2)
# print(res) # <QuerySet [<Publish: 对象:北方出版社>]>
# 2.查询主键为3的书籍对应的作者
# res = models.Author.objects.filter(book__pk=3)
# print(res) # <QuerySet [<Author: 对象:yly>, <Author: 对象:tony>]>
# 3.查询yly的详情数据
# res = models.AuthorDetail.objects.filter(author__name='yly')
# print(res)
# 4.查询北方出版社出版的书籍
# res = models.Book.objects.filter(publish__name='北方出版社')
# print(res)
# 5.查询yly写过的书籍
# res = models.Book.objects.filter(authors__name='yly')
# print(res)
# 6.查询电话是110的作者姓名
res = models.Author.objects.filter(author_detail__phone=110)
print(res)
七、聚合查询
"""分组查询:annotate"""
聚合函数
max min sum count avg
案例：
1.统计所有书籍的总价格
2.统计所有书籍的总数
3.统计价格最高的
答案:
from django.db.models import Max,Min,Sum,Count,Avg
# 1.统计所有书籍的总价格
# res = models.Book.objects.aggregate(Sum('price'))
# print(res)
# 2.统计所有书籍的总数
# res = models.Book.objects.aggregate(Count('pk'))
# print(res)
# 3.统计价格最高的
# res = models.Book.objects.aggregate(Max('price'))
# print(res)
res = models.Book.objects.aggregate(Max('price'),Min('price'),Sum('price'),Count('price'),Avg('price'))
print(res)
八、分组查询
"""分组查询:annotate"""
案例：
1.统计每一本书的作者个数
2.统计出每个出版社卖的最便宜的书的价格
3.统计不止一个作者的图书
4.查询各个作者出的书的总价格
答案：
# 1.统计每一本书的作者个数
'''author_num是必须要起的别名 因为后面的values中需要使用'''
# res = models.Book.objects.annotate(author_num=Count('authors__pk')).values('author_num','title')
# print(res)
# 2.统计出每个出版社卖的最便宜的书的价格
# res = models.Publish.objects.annotate(min_price=Min('book__price')).values('min_price','name','book__title')
# print(res)
# 3.统计不止一个作者的图书
# res = models.Book.objects.annotate(author_num=Count('authors__pk')).filter(author_num__gt=1)
# print(res)
# 4.查询各个作者出的书的总价格
# res = models.Author.objects.annotate(price_sum=Sum('book__price')).values('name','price_sum')
# print(res)
"""
1.大的分组
models.表名.objects.annotate 按照models后面的表名分组(主键)
2.小的分组
models.表名.objects.values('price').annotate() 按照values括号内指定的字段分组
"""
九、F与Q查询
F查询
F的功能是获取数据库中字段原有的数据
案例：
1.将所有书籍的价格提升100块
2.将所有书籍名称后面加上爆款后缀
3.查询库存数大于卖出数的书籍
答案：
# 1.将所有书籍的价格提升100块
# from django.db.models import F
# models.Book.objects.update(price=F('price')+1000)
# 2.将所有书籍名称后面加上爆款后缀
# from django.db.models.functions import Concat
# from django.db.models import Value
# ret3 = models.Book.objects.update(title=Concat(F('title'), Value('爆款')))
'''F查询默认操作数字类型 如果需要操作字符类型需要上述方式'''
# 3.查询库存数大于卖出数的书籍
res = models.Book.objects.filter(kucun__gt=F("maichu"))
for i in res:
print(i, "|", i.title, "|", i.kucun, "|", i.maichu)
Q查询
"""Q查询"""
# filter括号内多个条件均为and关系
案例：
1、查询 主键为3或者卖出数为1000 的书籍
2、查询 库存数是100并且卖出数不是0 的书籍
# 1.查询主键为3或者卖出数为1000的数据
# res = models.Book.objects.filter(pk=3, maichu=1000) # 逗号分隔为and关系
from django.db.models import Q
###########基本用法###########
# res = models.Book.objects.filter(Q(pk=3), Q(maichu=1000)) # 逗号分隔为and关系
# res = models.Book.objects.filter(Q(pk=3) | Q(maichu=1000)) # |分隔为or关系
# res = models.Book.objects.filter(~Q(pk=3) | Q(maichu=1000)) # ~分隔为not关系
# print(res)
###########进阶用法###########
# filter(title='123') filter('title'='123')
q = Q() # 默认多个条件之间也是and关系
q.connector = 'or' # 也可以修改链接关系
# q.children.append(('title', '三国演义爆款'))
q.children.append(('title__contains', '爆'))
q.children.append(('price', 1123))
res = models.Book.objects.filter(q)
print(res)
本文来自博客园，作者：LionYie，转载请注明原文链接：https://www.cnblogs.com/LionYie/p/15576012.html
浙公网安备 33010602011771号