搬瓦工中文网
使用 QuerySet.explain() 来了解你的数据库是如何执行特定的 QuerySet 的。
你可能还想使用一个外部项目，比如 django-debug-toolbar ，或者一个直接监控数据库的工具。
合理的创建索引
索引可能有助于加快查询速度，但是也要注意索引会占用磁盘空间，创建不必要的索引只会形成浪费。数据库表中的主键、外键、唯一键默认会创建索引。
那么哪些字段需要创建索引呢？这是一个好的且令人疑惑的问题，下面列出的几条可以作为参照意见:
- 频繁出现在WHERE条件子句的字段(也就是Django里filter筛选的字段)
- 经常被用来分组(group by)或者排序(order by)的字段
- 在经常存取的多个列上创建复合索引，但要注意复合索引的顺序要按照使用的频度来决定
| 1 2 3 4 5 6 | class ModelName(models.Model): # 字段添加索引使用db_index name = models.CharField(db_index = True , max_length = 100 ) class Meta: # 联合唯一索引使用index_together index_together = ( '字段1' , '字段2' ) |
设置数据库持久连接
减少SQL的执行次数
多次访问数据库比单次查询所有内容的效率低。因此理解并学会使用 select_related() 和 prefetch_related() 。
select_related():创建一个 SQL 连接，并在 SELECT 语句中包含相关对象的字段。一般用于一对多(ForeignKey)和一对一(OneToOneField)关系
| 1 2 3 4 5 6 7 8 9 10 11 | # 标准查询 # Hits the database. e = Entry.objects.get( id = 5 ) # Hits the database again to get the related Blog object. b = e.blog # select_related 查询 # Hits the database. e = Entry.objects.select_related( 'blog' ).get( id = 5 ) # Doesn't hit the database, because e.blog has been prepopulated # in the previous query. b = e.blog |
prefetch_related(): 一般用于多对一(GenericForeignKey)和多对多(ManyToManyField)关系
| 1 2 3 4 5 6 7 8 9 10 11 12 13 | from django.db import models class Topping(models.Model): name = models.CharField(max_length = 30 ) class Pizza(models.Model): name = models.CharField(max_length = 50 ) toppings = models.ManyToManyField(Topping) def __str__( self ): return "%s (%s)" % ( self .name, ", " .join(topping.name for topping in self .toppings. all ()), ) # Good pizza.objects. all ().prefetch_related( 'toppings' ) |
仅获取需要的字段数据
使用 QuerySet.values() 和 values_list()
使用 QuerySet.defer() 和 only()
使用 QuerySet.count()
使用 QuerySet.exists()
请不要过度使用 count() 和 exists()
使用批量创建、更新和删除，不随意对结果排序
批量创建: 当创建对象时，尽可能使用 bulk_create() 方法来减少 SQL 查询数量。比如：
| 1 2 3 4 5 6 7 8 | # Good Entry.objects.bulk_create([ Entry(headline = 'This is a test' ), Entry(headline = 'This is only a test' ), ]) # Bad Entry.objects.create(headline = 'This is a test' ) Entry.objects.create(headline = 'This is only a test' ) |
批量更新: 当更新对象时，尽可能使用 bulk_update() 方法来减少 SQL 查询数。给定对象的列表或查询集：
| 1 2 3 4 5 6 7 8 9 | # Good entries[ 0 ].headline = 'This is not a test' entries[ 1 ].headline = 'This is no longer a test' Entry.objects.bulk_update(entries, [ 'headline' ]) # Bad entries[ 0 ].headline = 'This is not a test' entries[ 0 ].save() entries[ 1 ].headline = 'This is no longer a test' entries[ 1 ].save() |
批量插入: 当插入对象到 ManyToManyFields 时，使用带有多个对象的 add() 来减少 SQL 查询的数量。
举例：
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | # Good my_band.members.add(me, my_friend) # Bad my_band.members.add(me) my_band.members.add(my_friend) # Good PizzaToppingRelationship = Pizza.toppings.through PizzaToppingRelationship.objects.bulk_create([ PizzaToppingRelationship(pizza = my_pizza, topping = pepperoni), PizzaToppingRelationship(pizza = your_pizza, topping = pepperoni), PizzaToppingRelationship(pizza = your_pizza, topping = mushroom), ], ignore_conflicts = True ) # Bad my_pizza.toppings.add(pepperoni) your_pizza.toppings.add(pepperoni, mushroom) |
批量删除: 当从 ManyToManyFields 删除对象时，可以使用带有多个对象的 remove() 来减少 SQL 查询的数量。
比如：
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 | # Good my_band.members.remove(me, my_friend) # Bad my_band.members.remove(me) my_band.members.remove(my_friend) # Good from django.db.models import Q PizzaToppingRelationship = Pizza.toppings.through PizzaToppingRelationship.objects. filter ( Q(pizza = my_pizza, topping = pepperoni) | Q(pizza = your_pizza, topping = pepperoni) | Q(pizza = your_pizza, topping = mushroom) ).delete() # Bad my_pizza.toppings.remove(pepperoni) your_pizza.toppings.remove(pepperoni, mushroom) |
以上就是Django项目优化数据库操作总结的详细内容。
