Django模型层:多表查询
一 创建模型
实例:我们来假定下面这些概念,字段和关系
作者模型:一个作者有姓名和年龄。
作者详细模型:把作者的详情放到详情表,包含生日,手机号,家庭住址等信息。作者详情模型和作者模型之间是一对一的关系(one-to-one)
出版商模型:出版商有名称,所在城市以及email。
书籍模型: 书籍有书名和出版日期,一本书可能会有多个作者,一个作者也可以写多本书,所以作者和书籍的关系就是多对多的关联关系(many-to-many);一本书只应该由一个出版商出版,所以出版商和书籍是一对多关联关系(one-to-many)。
Book id title price publish
php 100 人民出版社
python 200 老男孩出版社
go 100 人民出版社
java 300 人民出版社 为了存储出版社的邮箱,地址,在第一个表后面加字段 Book id title price publish email addr
php 100 人民出版社 111 北京
python 200 老男孩出版社 222 上海
go 100 人民出版社 111 北京
java 300 人民出版社 111 北京 这样会有大量重复的数据,浪费空间 #################################################################################### 一对多:一个出版社对应多本书(关联信息建在多的一方,也就是book表中) Book id title price publish_id
php 100 1
python 200 1
go 100 2
java 300 1 Publish id name email addr
人民出版社 111 北京
沙河出版社 222 沙河 总结:一旦确定表关系是一对多:在多对应的表中创建关联字段(在多的表里创建关联字段) ,publish_id 查询python这本书的出版社的邮箱(子查询) select publish_id from Book where title=“python”
select email from Publish where id=1 #################################################################################### 多对多:一本书有多个作者,一个作者出多本书 Book id title price publish_id
php 100 1
python 200 1
go 100 2
java 300 1 Author
id name age addr
alex 34 beijing
egon 55 nanjing Book2Author id book_id author_id
2 1
2 2
3 2 总结:一旦确定表关系是多对多:创建第三张关系表(创建中间表,中间表就三个字段,自己的id,书籍id和作者id) : id book_id author_id # alex出版过的书籍名称(子查询) select id from Author where name='alex' select book_id from Book2Author where author_id=1 select title from Book where id =book_id #################################################################################### 一对一:对作者详细信息的扩展(作者表和作者详情表) Author
id name age ad_id(UNIQUE)
alex 34 1
egon 55 2 AuthorDetail id addr gender tel gf_name author_id(UNIQUE)
beijing male 110 小花 1
nanjing male 911 杠娘 2 总结: 一旦确定是一对一的关系:在两张表中的任意一张表中建立关联字段+Unique ==================================== Publish
Book
Author
AuthorDetail
Book2Author CREATE TABLE publish(
id INT PRIMARY KEY auto_increment ,
name VARCHAR (20)
); CREATE TABLE book(
id INT PRIMARY KEY auto_increment ,
title VARCHAR (20),
price DECIMAL (8,2),
pub_date DATE ,
publish_id INT ,
FOREIGN KEY (publish_id) REFERENCES publish(id)
); CREATE TABLE authordetail(
id INT PRIMARY KEY auto_increment ,
tel VARCHAR (20)
); CREATE TABLE author(
id INT PRIMARY KEY auto_increment ,
name VARCHAR (20),
age INT,
authordetail_id INT UNIQUE ,
FOREIGN KEY (authordetail_id) REFERENCES authordetail(id)
); CREATE TABLE book2author(
id INT PRIMARY KEY auto_increment ,
book_id INT ,
author_id INT ,
FOREIGN KEY (book_id) REFERENCES book(id),
FOREIGN KEY (author_id) REFERENCES author(id)
) 分析如下
注意:关联字段与外键约束没有必然的联系(建管理字段是为了进行查询,建约束是为了不出现脏数据)
在Models创建如下模型
class Book(models.Model):
nid = models.AutoField(primary_key=True)
name = models.CharField(max_length=32)
price = models.DecimalField(max_digits=5, decimal_places=2)
publish_date = models.DateField()
# 阅读数
# reat_num=models.IntegerField(default=0)
# 评论数
# commit_num=models.IntegerField(default=0) publish = models.ForeignKey(to='Publish',to_field='nid',on_delete=models.CASCADE)
authors=models.ManyToManyField(to='Author')
def __str__(self):
return self.name class Author(models.Model):
nid = models.AutoField(primary_key=True)
name = models.CharField(max_length=32)
age = models.IntegerField()
author_detail = models.OneToOneField(to='AuthorDatail',to_field='nid',unique=True,on_delete=models.CASCADE) class AuthorDatail(models.Model):
nid = models.AutoField(primary_key=True)
telephone = models.BigIntegerField()
birthday = models.DateField()
addr = models.CharField(max_length=64) class Publish(models.Model):
nid = models.AutoField(primary_key=True)
name = models.CharField(max_length=32)
city = models.CharField(max_length=32)
email = models.EmailField()
生成的表如下:
注意事项:
- 表的名称
myapp_modelName
,是根据 模型中的元数据自动生成的,也可以覆写为别的名称 id
字段是自动添加的- 对于外键字段,Django 会在字段名上添加"_id" 来创建数据库中的列名
- 这个例子中的
CREATE TABLE
SQL 语句使用PostgreSQL 语法格式,要注意的是Django 会根据settings 中指定的数据库类型来使用相应的SQL 语句。 - 定义好模型之后,你需要告诉Django _使用_这些模型。你要做的就是修改配置文件中的INSTALL_APPSZ中设置,在其中添加
models.py
所在应用的名称。 - 外键字段 ForeignKey 有一个 null=True 的设置(它允许外键接受空值 NULL),你可以赋给它空值 None 。
二 添加表记录
一对多的
方式1:
publish_obj=Publish.objects.get(nid=1)
book_obj=Book.objects.create(title="",publishDate="2012-12-12",price=100,publish=publish_obj) 方式2:
book_obj=Book.objects.create(title="",publishDate="2012-12-12",price=100,publish_id=1)
核心:book_obj.publish与book_obj.publish_id是什么?
关键点: 一 book_obj.publish=Publish.objects.filter(id=book_obj.publish_id).first() 二 book_obj.authors.all()
关键点:book.authors.all() # 与这本书关联的作者集合
book.id=3
book_authors
id book_id author_ID
3 1
3 2
author
id name
alex
egon book_obj.authors.all() -------> [alex,egon]
多对多
# 当前生成的书籍对象
book_obj=Book.objects.create(title="追风筝的人",price=200,publishDate="2012-11-12",publish_id=1)
# 为书籍绑定的做作者对象
yuan=Author.objects.filter(name="yuan").first() # 在Author表中主键为2的纪录
egon=Author.objects.filter(name="alex").first() # 在Author表中主键为1的纪录 # 绑定多对多关系,即向关系表book_authors中添加纪录
book_obj.authors.add(yuan,egon) # 将某些特定的 model 对象添加到被关联对象集合中。 ======= book_obj.authors.add(*[])
book = Book.objects.filter(name='红楼梦').first()
egon=Author.objects.filter(name='egon').first()
lqz=Author.objects.filter(name='lqz').first()
# 1 没有返回值,直接传对象
book.authors.add(lqz,egon)
# 2 直接传作者id
book.authors.add(1,3)
# 3 直接传列表,会打散
book.authors.add(*[1,2])
# 解除多对多关系
book = Book.objects.filter(name='红楼梦').first()
# 1 传作者id
book.authors.remove(1)
# 2 传作者对象
egon = Author.objects.filter(name='egon').first()
book.authors.remove(egon)
#3 传*列表
book.authors.remove(*[1,2])
#4 删除所有
book.authors.clear()
# 5 拿到与 这本书关联的所有作者,结果是queryset对象,作者列表
ret=book.authors.all()
# print(ret)
# 6 queryset对象,又可以继续点(查询红楼梦这本书所有作者的名字)
ret=book.authors.all().values('name')
print(ret)
# 以上总结:
# (1)
# book=Book.objects.filter(name='红楼梦').first()
# print(book)
# 在点publish的时候,其实就是拿着publish_id又去app01_publish这个表里查数据了
# print(book.publish)
# (2)book.authors.all()
核心:book_obj.authors.all()是什么?
多对多关系其它常用API:
book_obj.authors.remove() # 将某个特定的对象从被关联对象集合中去除。 ====== book_obj.authors.remove(*[]),可以指定解除关联对象的id值
book_obj.authors.clear() #清空被关联对象集合,即与书这个对象相关联的作者的绑定关系都被清除
book_obj.authors.set() #先清空再设置,在重新设定绑定关系
三 基于对象的跨表查询
一对一查询(Author 与 AuthorDetail)
正向查询(按字段:authorDetail):
egon=Author.objects.filter(name="egon").first() #拿到作者对象
print(egon.authorDetail.telephone) #按照作者表中的authorDetail字段进行查询
反向查询(按表名:author):
# 查询所有住址在北京的作者的姓名
authorDetail_list=AuthorDetail.objects.filter(addr="beijing") #先拿到地址为北京的左右作者的一个对象
for obj in authorDetail_list:
print(obj.author.name) #通过作者详细信息点小写表名就可以拿到作者这个对象
'''
A表Author(关联自动段) B表 AuthorDetail
# 正向查询 A--->B 关联字段再A,A去查询B表,这叫正向查询,按字段来查
# 反向查询 B--》A 关联字段再A,B去查询A表,这叫反向查询,按表明小写
'''
# 一对一正向查询
# lqz的手机号
lqz=Author.objects.filter(name='lqz').first()
tel=lqz.author_detail.telephone
print(tel)
# 一对一反向查询
# 地址在北京的作者姓名
author_detail=AuthorDatail.objects.filter(addr='北京').first()
name=author_detail.author.name
print(name)
一对多查询(publish与book)
正向查询(按字段:publish)
# 查询主键为1的书籍的出版社所在的城市
book_obj=Book.objects.filter(pk=1).first()
# book_obj.publish 是主键为1的书籍对象关联的出版社对象
print(book_obj.publish.city)
反向查询(按表名:book_set)
publish=Publish.objects.get(name="苹果出版社")
#publish.book_set.all() : 与苹果出版社关联的所有书籍对象集合
book_list=publish.book_set.all()
for book_obj in book_list:
print(book_obj.title) '''
A表book(关联自动段) B表 publish
# 正向查询 A--->B 关联字段再A,A去查询B表,这叫正向查询,按字段来查
# 反向查询 B--》A 关联字段再A,B去查询A表,这叫反向查询,按表明小写_set
'''
# 一对多正向查询
book=Book.objects.filter(name='红楼梦').first()
print(book.publish)#与这本书关联的出版社对象
print(book.publish.name)
# 一对多反向查询
# 人民出版社出版过的书籍名称
pub=Publish.objects.filter(name='人民出版社').first()
ret=pub.book_set.all()
print(ret)
多对多查询 (Author 与 Book)
正向查询(按字段:authors):
# 眉所有作者的名字以及手机号
book_obj=Book.objects.filter(title="眉").first() #
authors=book_obj.authors.all() #
for author_obj in authors:
print(author_obj.name,author_obj.authorDetail.telephone) #
反向查询(按表名:book_set):
# 查询egon出过的所有书籍的名字 author_obj=Author.objects.get(name="egon") #
book_list=author_obj.book_set.all() # #与egon作者相关的所有书籍
for book_obj in book_list:
print(book_obj.title) # '''
A表book(关联自动段) B表 publish
# 正向查询 A--->B
# 反向查询 B-->A
总结:一对一 正向:按字段 反向:按表名小写
一对多 正向:按字段 反向:按表名小写_set
多对多 正向:按字段 反向:按表名小写_set
'''
# 正向查询----查询红楼梦所有作者名称
book=Book.objects.filter(name='红楼梦').first()
ret=book.authors.all()
print(ret)
for auth in ret:
print(auth.name)
# 反向查询 查询lqz这个作者写的所有书
author=Author.objects.filter(name='lqz').first()
ret=author.book_set.all()
print(ret)
注意:
你可以通过在 ForeignKey() 和ManyToManyField的定义中设置 related_name 的值来覆写 FOO_set 的名称。例如,如果 Article model 中做一下更改:
publish = ForeignKey(Book, related_name='bookList')
那么接下来就会如我们看到这般:
# 查询 人民出版社出版过的所有书籍 publish=Publish.objects.get(name="人民出版社")
book_list=publish.bookList.all() # 与人民出版社关联的所有书籍对象集合
四 基于双下划线的跨表查询
Django 还提供了一种直观而高效的方式在查询(lookups)中表示关联关系,它能自动确认 SQL JOIN 联系。要做跨关系查询,就使用两个下划线来链接模型(model)间关联字段的名称,直到最终链接到你想要的model 为止(本质就是inner join将多张表连成一张大的表)。
'''
正向查询按字段,反向查询按表名小写用来告诉ORM引擎join哪张表
'''
一对一查询
# 查询alex的手机号 # 正向查询----按字段 (Author--->authordetail) Author表中有一个authordetail关联字段
ret=Author.objects.filter(name="alex").values("authordetail__telephone")# # 反向查询---按表名小写(authordetail--->Author)通过表名小写author拿到作者的的name字段
ret=AuthorDetail.objects.filter(author__name="alex").values("telephone")#
# 查询lqz的手机号
# 正向查
ret=Author.objects.filter(name='lqz').values('author_detail__telephone')
print(ret)
# 反向查
ret= AuthorDatail.objects.filter(author__name='lqz').values('telephone')
print(ret)
一对多查询
# 练习: 查询苹果出版社出版过的所有书籍的名字与价格(一对多) # 正向查询 按字段:publish queryResult=Book.objects
.filter(publish__name="苹果出版社")#通过BOOK中的publish关联字段,拿到出版社的名字
.values_list("title","price") #values_list中传的参数是我们要查询的字段 # 反向查询 按表名:book queryResult=Publish.objects
.filter(name="苹果出版社") #出版社有name字段,所以可以直接拿到name字段
.values_list("book__title","book__price")#查询的本质一样,就是select from的表不一样,Book表中的title字段要通过book表名小写__来拿到title字段
# 正向查询按字段,反向查询按表名小写
# 查询红楼梦这本书出版社的名字
# select * from app01_book inner join app01_publish
# on app01_book.publish_id=app01_publish.nid
ret=Book.objects.filter(name='红楼梦').values('publish__name')
print(ret)
ret=Publish.objects.filter(book__name='红楼梦').values('name')
print(ret)
多对多查询
# 练习: 查询alex出过的所有书籍的名字(多对多) # 正向查询 按字段:authors:
queryResult=Book.objects
.filter(authors__name="yuan") #BOOK表中有关联字段author,所以可以通过关联字段author__来拿到作者的名字
.values_list("title")#正向是Book表,所以可以直接拿到书的标题title
# 反向查询 按表名:book
queryResult=Author.objects
.filter(name="yuan")#Author可以直接拿到作者的名字字段name
.values_list("book__title","book__price")#因为关联字段在Book表中,所以通过表名BOOk小写__才能拿到Book表中的title和price字段
# 正向查询按字段,反向查询按表名小写
# 查询红楼梦这本书出版社的名字
# select * from app01_book inner join app01_publish
# on app01_book.publish_id=app01_publish.nid
ret=Book.objects.filter(name='红楼梦').values('publish__name')
print(ret)
ret=Publish.objects.filter(book__name='红楼梦').values('name')
print(ret)
# sql 语句就是from的表不一样
# -------多对多正向查询
# 查询红楼梦所有的作者
ret=Book.objects.filter(name='红楼梦').values('authors__name')
print(ret)
# ---多对多反向查询
ret=Author.objects.filter(book__name='红楼梦').values('name')
ret=Author.objects.filter(book__name='红楼梦').values('name','author_detail__addr')
print(ret)
总结:
'''
总结:用__告诉orm,要连接那个表
一对一: 正向:按字段 反向:按表名小写
一对多: 正向:按字段 反向:按表名小写
多对多: 正向:按字段 反向:按表名小写
'''
进阶练习(连续跨表)
# 练习: 查询人民出版社出版过的所有书籍的名字以及作者的姓名 # 正向查询
queryResult=Book.objects
.filter(publish__name="人民出版社")
.values_list("title","authors__name")
# 反向查询
queryResult=Publish.objects
.filter(name="人民出版社")
.values_list("book__title","book__authors__age","book__authors__name") # 练习: 手机号以151开头的作者出版过的所有书籍名称以及出版社名称 # 方式1:
queryResult=Book.objects
.filter(authors__authorDetail__telephone__regex="")
.values_list("title","publish__name")
# 方式2:
ret=Author.objects
.filter(authordetail__telephone__startswith="")
.values("book__title","book__publish__name")
# ----进阶练习,连续跨表
# 查询手机号以33开头的作者出版过的书籍名称以及书籍出版社名称
# author_datail author book publish
# 基于authorDatail表
ret=AuthorDatail.objects.filter(telephone__startswith='').values('author__book__name','author__book__publish__name')
print(ret)
# 基于Author表
ret=Author.objects.filter(author_detail__telephone__startswith=33).values('book__name','book__publish__name')
print(ret)
# 基于Book表
ret=Book.objects.filter(authors__author_detail__telephone__startswith='').values('name','publish__name')
print(ret)
# 基于Publish表
ret=Publish.objects.filter(book__authors__author_detail__telephone__startswith='').values('book__name','name')
print(ret)
related_name
publish = ForeignKey(Blog, related_name='bookList') #
# 练习: 查询人民出版社出版过的所有书籍的名字与价格(一对多) # 反向查询 不再按表名:book,而是related_name:bookList queryResult=Publish.objects
.filter(name="人民出版社")
.values_list("bookList__title","bookList__price")
注意: 反向查询时,如果定义了related_name ,则用related_name替换表名
五 聚合查询与分组查询
聚合(Avg、Max、Nin、Sum、Count)
aggregate(*args, **kwargs)
# 计算所有图书的平均价格
from django.db.models import Avg #
Book.objects.all().aggregate(Avg('price'))#
#{'price__avg': 34.35}
aggregate()是QuerySet 的一个终止子句,意思是说,它返回一个包含一些键值对的字典。键的名称是聚合值的标识符,值是计算出来的聚合值。键的名称是按照字段和聚合函数的名称自动生成出来的。如果你想要为聚合值指定一个名称,可以向聚合子句提供它。
Book.objects.aggregate(average_price=Avg('price'))#
#{'average_price': 34.35}
如果你希望生成不止一个聚合,你可以向aggregate()子句中添加另一个参数。所以,如果你也想知道所有图书价格的最大值和最小值,可以这样查询:
from django.db.models import Avg, Max, Min
Book.objects.aggregate(Avg('price'), Max('price'), Min('price'))#
#{'price__avg': 34.35, 'price__max': Decimal('81.20'), 'price__min': Decimal('12.99')}
# 查询所有书籍的平均价格
from django.db.models import Avg,Count,Max,Min
ret=Book.objects.all().aggregate(Avg('price'))
# {'price__avg': 202.896}
# 可以改名字
ret=Book.objects.all().aggregate(avg_price=Avg('price'))
# 统计平均价格和最大价格
ret=Book.objects.all().aggregate(avg_price=Avg('price'),max_price=Max('price'))
# 统计最小价格
ret = Book.objects.all().aggregate(avg_price=Avg('price'), min_price=Min('price'))
# 统计个数和平均价格
ret = Book.objects.all().aggregate(avg_price=Avg('price'), max_price=Max('price'),count=Count('price'))
ret = Book.objects.all().aggregate(avg_price=Avg('price'), max_price=Max('price'),count=Count('nid'))
print(ret)
分组
###################################--单表分组查询--####################################################### 查询每一个部门名称以及对应的员工数 emp: id name age salary dep
1 alex 12 2000 销售部
2 egon 22 3000 人事部
3 wen 22 5000 人事部 sql语句:
select dep,Count(*) from emp group by dep;
ORM:
emp.objects.values("dep").annotate(c=Count("id"))#c是重命名
# 示例:查询每一个部门的名称,以及平均薪水
# select dep,Avg(salary) from app01_emp group by dep
from django.db.models import Avg, Count, Max, Min
# ret=Emp.objects.values('dep').annotate(Avg('salary'))
# 重新命名
ret=Emp.objects.values('dep').annotate(avg_salary=Avg('salary'))
print(ret) 总结:单表分组查询orm语法:单表模型.objects.values('group by 的字段').annotate(聚合函数('统计的字段')) 查询每一个省份名称以及对应的员工数 Emp.objects.values('province').annotate(Count('id')) ###################################--多表分组查询--###########################
Book表 id title date price publish_id
1 红楼梦 2012-12-12 101 1
2 西游记 2012-12-12 101 1
3 三国演绎 2012-12-12 101 1
4 金梅 2012-12-12 301 2 Publish表
id name addr email
1 人民出版社 北京 123@qq.com
2 南京出版社 南京 345@163.com 多表分组查询: 1 查询每个出版社出版的书籍个数
ret=Book.objects.values('publish_id').annotate(Count('nid'))
print(ret)
2 查询每个出版社的名称和书籍个数(先join,再分组)
SELECT app01_publish.name,COUNT(app01_book.name) from app01_book
INNER JOIN app01_publish
on app01_publish.nid = app01_book.publish_id
GROUP BY app01_publish.nid #默认的是nid字段
orm实现:
ret=Publish.objects.values('name').annotate(Count('book__name'))
ret=Publish.objects.values('nid').annotate(c=Count('book__name')).values('name','c')
print(ret) #是一个Queryset对象,里面是一个字典的形式
模型总结:跨表查询的模型:每一个后表模型.objects.value('pk').annotate(聚合函数('关联表__统计字段')).values()
# 查询每个作者的名字,以及出版过书籍的最高价格
ret=Author.objects.values('pk').annotate(c=Max('book__price')).values('name','c') #第一个values代指第一个group by字段。默认的是nid字段
print(ret)
# 查询每一个书籍的名称,以及对应的作者个数
ret=Book.objects.values('pk').annotate(c=Count('authors__name')).values('name','c')
print(ret)
class Emp(models.Model):
name=models.CharField(max_length=32)
age=models.IntegerField()
salary=models.DecimalField(max_digits=8,decimal_places=2)
dep=models.CharField(max_length=32)
province=models.CharField(max_length=32)
annotate()为调用的QuerySet中每一个对象都生成一个独立的统计值(统计方法用聚合函数)。
总结 :跨表分组查询本质就是将关联表join成一张表,再按单表的思路进行分组查询。
查询练习
(1) 练习:统计每一个出版社的最便宜的书
publishList=Publish.objects.annotate(MinPrice=Min("book__price"))#
for publish_obj in publishList:
print(publish_obj.name,publish_obj.MinPrice)#
annotate的返回值是querySet,如果不想遍历对象,可以用上valuelist:
queryResult= Publish.objects.annotate(MinPrice=Min("book__price")).values_list("name","MinPrice")#
print(queryResult)#
sql语句:
'''
SELECT "app01_publish"."name", MIN("app01_book"."price") AS "MinPrice" FROM "app01_publish"
LEFT JOIN "app01_book" ON ("app01_publish"."nid" = "app01_book"."publish_id")
GROUP BY "app01_publish"."nid", "app01_publish"."name", "app01_publish"."city", "app01_publish"."email"
'''
(2) 练习:统计每一本书的作者个数
ret=Book.objects.annotate(authorsNum=Count('authors__name'))#
(3) 统计每一本以py开头的书籍的作者个数:
queryResult=Book.objects.filter(title__startswith="Py").annotate(num_authors=Count('authors'))#
(4) 统计不止一个作者的图书:
queryResult=Book.objects.annotate(num_authors=Count('authors')).filter(num_authors__gt=1)#filter在前代表where的东西,在后代表having中的东西
(5) 根据一本图书作者数量的多少对查询集 QuerySet进行排序:
Book.objects.annotate(num_authors=Count('authors')).order_by('num_authors')#
(6) 查询各个作者出的书的总价格:
#按author表的所有字段 group by
queryResult=Author.objects.annotate(SumPrice=Sum("book__price")).values_list("name","SumPrice")#
print(queryResult)#
# ————————————单表下的分组查询
'''
查询每一个部门名称以及对应的员工数
emp:
id name age salary dep
alex 12 2000 销售部
egon 22 3000 人事部
wen 22 5000 人事部
'''
# select count(id) from emp group by dep
# 示例一:查询每一个部门的名称,以及平均薪水
# select dep,Avg(salary) from app01_emp group by dep
from django.db.models import Avg, Count, Max, Min
ret=Emp.objects.values('dep').annotate(Avg('salary'))
# 重新命名
ret=Emp.objects.values('dep').annotate(avg_salary=Avg('salary'))
print(ret)
# ---*******单表分组查询ORM总结:表名.objects.values('group by 的字段').annotate(聚合函数('统计的字段'))
# 示例2 查询每个省份对应的员工数
ret=Emp.objects.values('province').annotate(Count('id'))
ret=Emp.objects.values('province').annotate(c=Count('id'))
print(ret)
# 补充知识点:
ret=Emp.objects.all()
# select * from emp
ret=Emp.objects.values('name')
# select name from emp
# ****单表下,按照id进行分组是没有任何意义的
ret=Emp.objects.all().annotate(Avg('salary'))
print(ret)
# ******多表分组查询
# 查询每一个出版社出版的书籍个数
ret=Book.objects.values('publish_id').annotate(Count('nid'))
print(ret)
# 查询每个出版社的名称以及出版社书的个数(先join在跨表分组)
# 正向
ret=Publish.objects.values('name').annotate(Count('book__name'))
ret=Publish.objects.values('nid').annotate(c=Count('book__name')).values('name','c')
print(ret)
# 反向
ret=Book.objects.values('publish__name').annotate(Count('name'))
ret=Book.objects.values('publish__name').annotate(c=Count('name')).values('publish__name','c')
print(ret)
# 查询每个作者的名字,以及出版过书籍的最高价格
ret=Author.objects.values('pk').annotate(c=Max('book__price')).values('name','c')
print(ret)
# 跨表查询的模型:每一个后表模型.objects.value('pk').annotate(聚合函数('关联表__统计字段')).values() # 查询每一个书籍的名称,以及对应的作者个数
ret=Book.objects.values('pk').annotate(c=Count('authors__name')).values('name','c')
print(ret)
# 统计不止一个作者的图书
ret=Book.objects.values('pk').annotate(c=Count('authors__name')).filter(c__gt=1).values('name','c')
print(ret)
六 F查询与Q查询
F查询
在上面所有的例子中,我们构造的过滤器都只是将字段值与某个常量做比较。如果我们要对两个字段的值做比较,那该怎么做呢?
Django 提供 F() 来做这样的比较。F() 的实例可以在查询中引用字段,来比较同一个 model 实例中两个不同字段的值。
# 查询评论数大于收藏数的书籍
from django.db.models import F#
Book.objects.filter(commnetNum__lt=F('keepNum'))#
Django 支持 F() 对象之间以及 F() 对象和常数之间的加减乘除和取模的操作。
# 查询评论数大于收藏数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#
Q(title__startswith='Py')#
Q 对象可以使用& 和| 操作符组合起来。当一个操作符在两个Q 对象上使用时,它产生一个新的Q 对象。
bookList=Book.objects.filter(Q(authors__name="yuan")|Q(authors__name="egon"))#
等同于下面的SQL WHERE 子句:
WHERE name ="yuan" OR name ="egon"
你可以组合& 和| 操作符以及使用括号进行分组来编写任意复杂的Q 对象。同时,Q 对象可以使用~ 操作符取反,这允许组合正常的查询和取反(NOT) 查询:
查询函数可以混合使用Q 对象和关键字参数。所有提供给查询函数的参数(关键字参数或Q 对象)都将"AND”在一起。但是,如果出现Q 对象,它必须位于所有关键字参数的前面。例如:
bookList=Book.objects.filter(Q(publishDate__year=2016) | Q(publishDate__year=2017), title__icontains="python")#
# 查询评论数大于阅读数的书籍
from django.db.models import F,Q
# select * from book where commit_num>read_num;
# 这样肯定是不行的
# Book.objects.filter(commit_num__gt=read_num)
ret=Book.objects.filter(commit_num__gt=F('reat_num'))
print(ret)
# 把所有书籍的价格加10
Book.objects.all().update(price=F('price')+10)
# ----Q函数,描述一个与,或,非的关系
# 查询名字叫红楼梦或者价格大于100的书
ret=Book.objects.filter(Q(name='红楼梦')|Q(price__gt=100))
print(ret)
# 查询名字叫红楼梦和价格大于100的书
ret = Book.objects.filter(Q(name='红楼梦') & Q(price__gt=100))
print(ret)
# # 等同于
ret2=Book.objects.filter(name='红楼梦',price__gt=100)
print(ret2)
# 也可以Q套Q
# 查询名字叫红楼梦和价格大于100 或者 nid大于2
ret=Book.objects.filter((Q(name='红楼梦') & Q(price__gt=100))|Q(nid__gt=2))
print(ret)
# ----非
ret=Book.objects.filter(~Q(name='红楼梦'))
print(ret)
# Q和键值对联合使用,但是键值对必须放在Q的后面(描述的是一个且的关系)
# 查询名字不是红楼梦,并且价格大于100的书
ret=Book.objects.filter(~Q(name='红楼梦'),price__gt=100)
print(ret)
Django模型层:多表查询的更多相关文章
- 第五章、Django之模型层----多表查询
目录 第五章.Django之模型层----多表查询 一.一对多字段增删改查 1.增 2.查 3.改 4. 删除 二.多对多的增删改查 1. 增 2. 改 3. 删 三.ORM跨表查询 四.正反向的概念 ...
- Django模型层-单表操作
ORM介绍 MVC或者MVC框架中包括一个重要的部分,就是ORM,它实现了数据模型与数据库的解耦,即数据模型的设计不需要依赖于特定的数据库,通过简单的配置就可以轻松更换数据库,这极大的减轻了开发人员的 ...
- Django之django模型层一单表操作
一 ORM简介 MVC或者MVC框架中包括一个重要的部分,就是ORM,它实现了数据模型与数据库的解耦,即数据模型的设计不需要依赖于特定的数据库,通过简单的配置就可以轻松更换数据库,这极大的减轻了开发人 ...
- Django 模型层--单表
ORM 简介 MTV或者MVC框架中包括一个重要的部分,就是ORM,它实现了数据模型与数据库的解耦,即数据模型的设计不需要依赖于特定的数据库,通过简单的配置就可以轻松更换数据库,这可以大大的减少了开 ...
- Django模型层-多表操作
多表操作 一.创建模型 实例:我们来假定下面这些概念,字段和关系 作者模型:一个作者有姓名和年龄. 作者详细模型:把作者的详情放到详情表,包含生日,手机号,家庭住址等信息.作者详情模型和作者模型之间是 ...
- 5.Django|模型层--多表关系
多表操作 文件为 ----> orm2 数据库表关系之关联字段与外键约束 一对多Book id title price publish email addr php 人民出版社 北京 pyth ...
- Python之路【第三十篇】:django 模型层-多表关系
多表操作 文件为 ----> orm2 数据库表关系之关联字段与外键约束 一对多Book id title price publish email addr 1 php 100 人民出版社 1 ...
- 057.Python前端Django模型ORM多表查询
一 基于对象的查询 1.1 一对多查询 设计路由 from django.contrib import admin from django.urls import path from app01 im ...
- Python-Django 模型层-单表查询
单表操作 -增加,删,改:两种方式:queryset对象的方法,book对象的方法 -改:需要用save() -get()方法:查询的数据有且只有一条,如果多,少,都抛异常 单表查询 -<1&g ...
- Python-Django 模型层-多表查询
多表操作 基于对象的跨表查询(多次查询) 一对一: -正向查询按字段 -反向查询按表名小写 一对多: -正向查询按字段(正向查询一定会查出一个来) -反向查询按表名小写_set.all()(返回结果是 ...
随机推荐
- C/C++ 格式化读取和读取一行
文件内容 23 21 4 1 1 0 114 1 1 1 8 112 5 0 0 0 114 1 0 0 0 115 52 4 1 0 1 134 4 0 1 12 131 4 1 1 0 133 5 ...
- 9、RabbitMQ-集成Spring
spring封装RabbitMQ看官网:https://spring.io/projects/spring-amqp#learn 开发时根据官网的介绍进行开发,具体的说明都有具体的声明 1.导入依赖 ...
- Python 多线程 使用线程 (二)
Python中实现多线程需要使用到 threading 库,其中每一个 Thread类 的实例控制一个线程. Thread类 #类签名 def __init__(self, group=None, t ...
- multimap详讲
multimap和map的区别: 首先认识一下multimap和map的区别: 1> multimap不提供operator[ ]运算符.因为这个运算符的语义在同一个键可以保存多个 ...
- http_post_data发送数据的获取方式
private function http_get_data($url){ $ch = curl_init($url) ; curl_setopt($ch, CURLOPT_RETURNTRANSFE ...
- Linux内存管理学习笔记——内存寻址
最近开始想稍微深入一点地学习Linux内核,主要参考内容是<深入理解Linux内核>和<深入理解Linux内核架构>以及源码,经验有限,只能分析出有限的内容,看完这遍以后再更深 ...
- 使用Apache HttpClient 4.5设置超时时间
使用HttpClient,一般都需要设置连接超时时间和获取数据超时时间.这两个参数很重要,目的是为了防止访问其他http服务时,由于超时导致自己的应用受影响. 4.5版本中,这两个参数的设置都抽象到了 ...
- 【Dubbo源码阅读系列】服务暴露之远程暴露
引言 什么叫 远程暴露 ?试着想象着这么一种场景:假设我们新增了一台服务器 A,专门用于发送短信提示给指定用户.那么问题来了,我们的 Message 服务上线之后,应该如何告知调用方服务器,服务器 A ...
- Linq 和 SQL的左连接、右连接、内链接
在我们工作中表连接是很常用的,但常用的有这三种连接方式:左连接.右连接.内链接 在本章节中讲的是1.如何在Linq中使用左连接,右连接,内连接. 2.三种连接之间的特点在哪? 3.Linq的三种连接语 ...
- 用Vue的父子组件通信实现todolist的功能
先上代码 <body> <div id="root"> <div> <input v-model="inputValue&quo ...