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
目录
相关文章
|
25天前
|
XML Java 数据库连接
性能提升秘籍:如何高效使用Java连接池管理数据库连接
在Java应用中,数据库连接管理至关重要。随着访问量增加,频繁创建和关闭连接会影响性能。为此,Java连接池技术应运而生,如HikariCP。本文通过代码示例介绍如何引入HikariCP依赖、配置连接池参数及使用连接池高效管理数据库连接,提升系统性能。
53 5
|
2月前
|
存储 缓存 监控
数据库优化技术:提升性能与效率的关键策略
【10月更文挑战第15天】数据库优化技术:提升性能与效率的关键策略
81 8
|
10天前
|
SQL 定位技术 数据库
深入探索Django ORM:高效数据库操作的秘诀####
本文旨在为读者揭开Django ORM(对象关系映射)的神秘面纱,通过一系列生动的比喻和详实的案例,深入浅出地讲解其核心概念、工作原理及高级特性。我们将一起探讨如何利用Django ORM简化数据库交互,提升开发效率,同时确保数据的一致性和安全性。不同于传统的技术文档,本文将以故事化的形式,带领读者在轻松愉快的氛围中掌握Django ORM的精髓。 ####
|
1月前
|
缓存 监控 关系型数据库
如何根据监控结果调整 MySQL 数据库的参数以提高性能?
【10月更文挑战第28天】根据MySQL数据库的监控结果来调整参数以提高性能,需要综合考虑多个方面的因素
78 1
|
1月前
|
监控 关系型数据库 MySQL
如何监控和诊断 MySQL 数据库的性能问题?
【10月更文挑战第28天】监控和诊断MySQL数据库的性能问题是确保数据库高效稳定运行的关键
81 1
|
1月前
|
缓存 关系型数据库 MySQL
如何优化 MySQL 数据库的性能?
【10月更文挑战第28天】
76 1
|
1月前
|
监控 关系型数据库 MySQL
数据库优化:MySQL索引策略与查询性能调优实战
【10月更文挑战第27天】本文深入探讨了MySQL的索引策略和查询性能调优技巧。通过介绍B-Tree索引、哈希索引和全文索引等不同类型,以及如何创建和维护索引,结合实战案例分析查询执行计划,帮助读者掌握提升查询性能的方法。定期优化索引和调整查询语句是提高数据库性能的关键。
197 1
|
1月前
|
Java 数据库连接 数据库
优化之路:Java连接池技术助力数据库性能飞跃
在Java应用开发中,数据库操作常成为性能瓶颈。频繁的数据库连接建立和断开增加了系统开销,导致性能下降。本文通过问题解答形式,深入探讨Java连接池技术如何通过复用数据库连接,显著减少连接开销,提升系统性能。文章详细介绍了连接池的优势、选择标准、使用方法及优化策略,帮助开发者实现数据库性能的飞跃。
30 4
|
1月前
|
Java 数据库连接 数据库
深入探讨Java连接池技术如何通过复用数据库连接、减少连接建立和断开的开销,从而显著提升系统性能
在Java应用开发中,数据库操作常成为性能瓶颈。本文通过问题解答形式,深入探讨Java连接池技术如何通过复用数据库连接、减少连接建立和断开的开销,从而显著提升系统性能。文章介绍了连接池的优势、选择和使用方法,以及优化配置的技巧。
31 1
|
2月前
|
存储 缓存 监控
数据库优化:提升性能与效率的关键策略
【10月更文挑战第21】数据库优化:提升性能与效率的关键策略