Django 数据库高级操作-过滤,反向查询,性能

本文涉及的产品
云数据库 RDS SQL Server,基础系列 2核4GB
RDS SQL Server Serverless,2-4RCU 50GB 3个月
推荐场景:
简介:

前面豆子已经陆陆续续地学习了在Django中如何操作数据库


单表的基本操作 http://beanxyz.blog.51cto.com/5570417/1945887

常见字段的使用 http://beanxyz.blog.51cto.com/5570417/1945909

最基本的查询方式 http://beanxyz.blog.51cto.com/5570417/1950806

一对多的基本操作和实例  http://beanxyz.blog.51cto.com/5570417/1946602

多对多的基本操作和实例 http://beanxyz.blog.51cto.com/5570417/1952243


下面补充一些高级操作。


条件的过滤

下面是常见的条件设置,除了可以基本的filter之外,我们还有大量的条件语句可以使用。


查询数据库获取的QuerySet类型,对于这个类型我们类似Jquery一样使用链式编程,可以无限制的通过.来添加新的条件来过滤,可以看见大部分条件都是通过双下划线__来实现的


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
# 获取个数
         # models.Tb1.objects.filter(name='seven').count()
 
         # 大于,小于
         # models.Tb1.objects.filter(id__gt=1)              # 获取id大于1的值
         # models.Tb1.objects.filter(id__gte=1)              # 获取id大于等于1的值
         # models.Tb1.objects.filter(id__lt=10)             # 获取id小于10的值
         # models.Tb1.objects.filter(id__lte=10)             # 获取id小于10的值
         # models.Tb1.objects.filter(id__lt=10, id__gt=1)   # 获取id大于1 且 小于10的值
 
         # in
         # models.Tb1.objects.filter(id__in=[11, 22, 33])   # 获取id等于11、22、33的数据
         # models.Tb1.objects.exclude(id__in=[11, 22, 33])  # not in
 
         # isnull
         # Entry.objects.filter(pub_date__isnull=True)
 
         # contains
         # models.Tb1.objects.filter(name__contains="ven")
         # models.Tb1.objects.filter(name__icontains="ven") # icontains大小写不敏感
         # models.Tb1.objects.exclude(name__icontains="ven")
 
         # range
         # models.Tb1.objects.filter(id__range=[1, 2])   # 范围bettwen and
 
         # 其他类似
         # startswith,istartswith, endswith, iendswith,
 
         # order by
         # models.Tb1.objects.filter(name='seven').order_by('id')    # asc
         # models.Tb1.objects.filter(name='seven').order_by('-id')   # desc
 
         # group by
         # from django.db.models import Count, Min, Max, Sum
         # models.Tb1.objects.filter(c1=1).values('id').annotate(c=Count('num'))
         # SELECT "app01_tb1"."id", COUNT("app01_tb1"."num") AS "c" FROM "app01_tb1" WHERE "app01_tb1"."c1" = 1 GROUP BY "app01_tb1"."id"
 
         # limit 、offset
         # models.Tb1.objects.all()[10:20]
 
         # regex正则匹配,iregex 不区分大小写
         # Entry.objects.get(title__regex=r'^(An?|The) +')
         # Entry.objects.get(title__iregex=r'^(an?|the) +')
 
         # date
         # Entry.objects.filter(pub_date__date=datetime.date(2005, 1, 1))
         # Entry.objects.filter(pub_date__date__gt=datetime.date(2005, 1, 1))
 
         # year
         # Entry.objects.filter(pub_date__year=2005)
         # Entry.objects.filter(pub_date__year__gte=2005)
 
         # month
         # Entry.objects.filter(pub_date__month=12)
         # Entry.objects.filter(pub_date__month__gte=6)
 
         # day
         # Entry.objects.filter(pub_date__day=3)
         # Entry.objects.filter(pub_date__day__gte=3)
 
         # week_day
         # Entry.objects.filter(pub_date__week_day=2)
         # Entry.objects.filter(pub_date__week_day__gte=2)
 
         # hour
         # Event.objects.filter(timestamp__hour=23)
         # Event.objects.filter(time__hour=5)
         # Event.objects.filter(timestamp__hour__gte=12)
 
         # minute
         # Event.objects.filter(timestamp__minute=29)
         # Event.objects.filter(time__minute=46)
         # Event.objects.filter(timestamp__minute__gte=29)
 
         # second
         # Event.objects.filter(timestamp__second=31)
         # Event.objects.filter(time__second=2)
         # Event.objects.filter(timestamp__second__gte=31)


上面这些方法可以实现大部分常见的简单查询过滤。有的时候,我们需要实现一些更复杂的查询语句,上面的语句就不够用了,这个时候可以通过extra来扩展。例如,主要看看select和where的自定义


1
2
3
4
5
6
# extra
     # extra(self, select=None, where=None, params=None, tables=None, order_by=None, select_params=None)
     #    Entry.objects.extra(select={'new_id': "select col from sometable where othercol > %s"}, select_params=(1,))
     #    Entry.objects.extra(where=['headline=%s'], params=['Lennon'])
     #    Entry.objects.extra(where=["foo='a' OR bar = 'a'", "baz = 'a'"])
     #    Entry.objects.extra(select={'new_id': "select id from tb where id > %s"}, select_params=(1,), order_by=['-nid'])



反向查询


之前的博文里面,我们都是通过正向查找外键或者中间表来获取另外一个表的信息;如果希望倒过来,也是通过双下划线,比如 表名__字段 这种形式来实现



实例:

3张表,分别是单表,1对多和多对多的关系

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#业务线
class  Business(models.Model):
     # id
     caption  =  models.CharField(max_length = 32 )
#主机
class  Host(models.Model):
     nid  =  models.AutoField(primary_key = True )
     hostname  =  models.CharField(max_length = 32 ,db_index = True )
     ip  =  models.GenericIPAddressField(protocol = "ipv4" ,db_index = True )
     port  =  models.IntegerField()
     =  models.ForeignKey(to = "Business" , to_field = 'id' )
#程序
class  Application(models.Model):
     name  =  models.CharField(max_length = 32 ,unique = True )
     =  models.ManyToManyField( "Host" )

视图函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
def  tt(request):
     #1对多正向查找
     print ( '1对多正向查找' .center( 40 '-' ))
     obj = models.Host.objects. filter (nid__gt = 1 )
     print (obj[ 0 ].nid,obj[ 0 ].hostname,obj[ 0 ].b.caption)
     #一些过滤条件
     print ( '过滤条件' .center( 40 , '-' ))
     obj = models.Business.objects. filter (caption__contains = 'SALE' ).first()
     print (obj. id ,obj.caption)
     obj = models.Business.objects. all ().values( 'id' , 'caption' )
     print (obj, obj.order_by( 'id' ).reverse())
     obj = models.Application.objects. filter (name__exact = 'SQL Server' ).values( 'name' , 'r__hostname' , 'r__nid' )
     print (obj)
     #1对多反向查找
     print ( '1对多反向查找' .center( 40 , '-' ))
     obj = models.Business.objects. all ().values( 'id' , 'caption' , 'host__ip' , 'host__hostname' )
     print (obj[ 0 ])
     #多对多正向查找
     print ( '多对多正向查找' .center( 40 '-' ))
     obj = models.Application.objects. all ().first()
     print (obj.name, obj.r. all ()[ 0 ].hostname)
     #多对多反向查询
     print ( '多对多反向查找' .center( 40 '-' ))
     obj = models.Host.objects. all (). filter (nid__gt = 1 ).values( 'nid' , 'application__name' ).first()
     print (obj)
     return  HttpResponse( 'ok' )



执行结果

1
2
3
4
5
6
7
8
9
10
11
12
- - - - - - - - - - - - - - - - 1 对多正向查找 - - - - - - - - - - - - - - - - -
183  SYDMGM01 SALE
- - - - - - - - - - - - - - - - - - 过滤条件 - - - - - - - - - - - - - - - - - -
5  SALE
<QuerySet [{ 'id' 5 'caption' 'SALE' }, { 'id' 19 'caption' 'IT' }, { 'id' 20 'caption' 'HR' }]> <QuerySet [{ 'id' 20 'caption' 'HR' }, { 'id' 19 'caption' 'IT' }, { 'id' 5 'caption' 'SALE' }]>
<QuerySet [{ 'name' 'SQL Server' 'r__hostname' 'SYDMGM01' 'r__nid' 183 }, { 'name' 'SQL Server' 'r__hostname' 'SYDAV01' 'r__nid' 190 }, { 'name' 'SQL Server' 'r__hostname' 'SYDMGM02' 'r__nid' 191 }]>
- - - - - - - - - - - - - - - - 1 对多反向查找 - - - - - - - - - - - - - - - - -
{ 'id' 5 'caption' 'SALE' 'host__ip' '10.2.1.1' 'host__hostname' 'SYDMGM01' }
- - - - - - - - - - - - - - - - 多对多正向查找 - - - - - - - - - - - - - - - - -
AA SYDMGM01
- - - - - - - - - - - - - - - - 多对多反向查找 - - - - - - - - - - - - - - - - -
{ 'nid' 183 'application__name' 'AA' }



性能


假设我们有一个Use表通过外键ut绑定了一个UserType表


默认情况下,如果我们直接使用下面代码,如果uses获取了10行数据,那么数据库实际上查询11次,对user查询一次,然后在for循环里面对usertype查询10次;这样效率很低

1
2
3
4
users  =  models.User.objects. all ()
for  row  in  users:
     print (row.user,row.pwd,row.ut_id)
     print (row.ut.name)


我们可以通过select_related进行优化,这样第一次查询的时候就进行一个跨表查询,获取指定外键的所有数据

1
2
3
4
users  =  models.User.objects. all ().select_related( 'ut' )
for  row  in  users:
     print (row.user,row.pwd,row.ut_id)
     print (row.ut.name)


如果数据比较多,外键也多,那么速度可能还会比较慢,比较跨表查询的效率比较低,那么进一步的我们可以通过prefetch_related优化。他的基本原理是进行多次单表查询;比如第一次查询User表,然后第二次查询外键关联的表,然后把所有数据都放在内存里面,这样访问的速度就会快很多了。

1
2
3
4
5
6
7
8
users  =  models.User.objects. filter (id__gt = 30 ).prefetch_related( 'ut' , 'tu' )
# select * from users where id > 30
# 获取上一步骤中所有的ut_id=[1,2]
# select * from user_type where id in [1,2]
# select * from user_type where id in [1,2]
for  row  in  users:
     print (row.user,row.pwd,row.ut_id)
     print (row.ut.name)



参考资料:http://www.cnblogs.com/wupeiqi/articles/5246483.html






本文转自 beanxyz 51CTO博客,原文链接:http://blog.51cto.com/beanxyz/1967344,如需转载请自行联系原作者

相关实践学习
使用SQL语句管理索引
本次实验主要介绍如何在RDS-SQLServer数据库中,使用SQL语句管理索引。
SQL Server on Linux入门教程
SQL Server数据库一直只提供Windows下的版本。2016年微软宣布推出可运行在Linux系统下的SQL Server数据库,该版本目前还是早期预览版本。本课程主要介绍SQLServer On Linux的基本知识。 相关的阿里云产品:云数据库RDS&nbsp;SQL Server版 RDS SQL Server不仅拥有高可用架构和任意时间点的数据恢复功能,强力支撑各种企业应用,同时也包含了微软的License费用,减少额外支出。 了解产品详情:&nbsp;https://www.aliyun.com/product/rds/sqlserver
目录
相关文章
|
1月前
|
人工智能 安全 机器人
无代码革命:10分钟打造企业专属数据库查询AI机器人
随着数字化转型加速,企业对高效智能交互解决方案的需求日益增长。阿里云AppFlow推出的AI助手产品,借助创新网页集成技术,助力企业打造专业数据库查询助手。本文详细介绍通过三步流程将AI助手转化为数据库交互工具的核心优势与操作指南,包括全场景适配、智能渲染引擎及零代码配置等三大技术突破。同时提供Web集成与企业微信集成方案,帮助企业实现便捷部署与安全管理,提升内外部用户体验。
236 11
无代码革命:10分钟打造企业专属数据库查询AI机器人
|
2月前
|
负载均衡 算法 关系型数据库
大数据大厂之MySQL数据库课程设计:揭秘MySQL集群架构负载均衡核心算法:从理论到Java代码实战,让你的数据库性能飙升!
本文聚焦 MySQL 集群架构中的负载均衡算法,阐述其重要性。详细介绍轮询、加权轮询、最少连接、加权最少连接、随机、源地址哈希等常用算法,分析各自优缺点及适用场景。并提供 Java 语言代码实现示例,助力直观理解。文章结构清晰,语言通俗易懂,对理解和应用负载均衡算法具有实用价值和参考价值。
大数据大厂之MySQL数据库课程设计:揭秘MySQL集群架构负载均衡核心算法:从理论到Java代码实战,让你的数据库性能飙升!
|
3月前
|
并行计算 关系型数据库 MySQL
如何用 esProc 将数据库表转储提速查询
当数据库查询因数据量大或繁忙变慢时,可借助 esProc 将数据导出为文件进行计算,大幅提升性能。以 MySQL 的 3000 万行订单数据为例,两个典型查询分别耗时 17.69s 和 63.22s。使用 esProc 转储为二进制行存文件 (btx) 或列存文件 (ctx),结合游标过滤与并行计算,性能显著提升。例如,ctx 并行计算将原查询时间缩短至 0.566s,TopN 运算提速达 30 倍。esProc 的简洁语法和高效文件格式,特别适合历史数据的复杂分析场景。
|
4月前
|
SQL 关系型数据库 MySQL
如何优化SQL查询以提高数据库性能?
这篇文章以生动的比喻介绍了优化SQL查询的重要性及方法。它首先将未优化的SQL查询比作在自助餐厅贪多嚼不烂的行为,强调了只获取必要数据的必要性。接着,文章详细讲解了四种优化策略:**精简选择**(避免使用`SELECT *`)、**专业筛选**(利用`WHERE`缩小范围)、**高效联接**(索引和限制数据量)以及**使用索引**(加速搜索)。此外,还探讨了如何避免N+1查询问题、使用分页限制结果、理解执行计划以及定期维护数据库健康。通过这些技巧,可以显著提升数据库性能,让查询更高效流畅。
|
4月前
|
物联网 测试技术 API
时序数据库 InfluxDB 3.0 版本性能实测报告:写入吞吐量提升效果验证
TSBS 测试表明,对于少于 100 万台设备的数据集,InfluxDB OSS 3.0 的数据写入速度实际上比 InfluxDB OSS 1.8 更慢。 对于 100 万台及以上设备的数据集,InfluxDB OSS 3.0 的数据写入性能才开始超过 InfluxDB OSS 1.8。 InfluxDB OSS 3.0 的数据写入接口与 InfluxDB 1.8 并不兼容,用户无法顺利迁移。
170 7
|
4月前
|
数据库 Python
【YashanDB知识库】python驱动查询gbk字符集崖山数据库CLOB字段,数据被驱动截断
【YashanDB知识库】python驱动查询gbk字符集崖山数据库CLOB字段,数据被驱动截断
|
4月前
|
数据库
【YashanDB知识库】数据库用户所拥有的权限查询
【YashanDB知识库】数据库用户所拥有的权限查询
|
4月前
|
存储 运维 监控
百万指标,秒级查询,零宕机——时序数据库 TDengine 在 AIOps 中的硬核实战
本篇文章详细讲述了七云团队在运维平台中如何利用 TDengine 解决海量时序数据存储与查询的实际业务需求。内容涵盖了从数据库选型、方案落地到业务挑战及解决办法的完整过程,特别是分享了升级 TDengine 3.x 时的实战经验,给到有需要的小伙伴参考阅读。
129 1
|
4月前
|
缓存 NoSQL 关系型数据库
WordPress数据库查询缓存插件
这款插件通过将MySQL查询结果缓存至文件、Redis或Memcached,加速页面加载。它专为未登录用户优化,支持跨页面缓存,不影响其他功能,且可与其他缓存插件兼容。相比传统页面缓存,它仅缓存数据库查询结果,保留动态功能如阅读量更新。提供三种缓存方式选择,有效提升网站性能。
86 1
|
5月前
|
Cloud Native 关系型数据库 分布式数据库
世界第一!阿里云PolarDB刷新全球数据库性能及性价比记录
世界第一!阿里云PolarDB刷新全球数据库性能及性价比记录

热门文章

最新文章