Django查询优化

  Django的查询优化用到两个函数——select_related()和prefetch_related()。

  select_related()用的是连表join的方式,主要处理一对一和一对多情况下的优化查询

  prefetch_related()用的方式是分别查询每张表,然后用Python的方法处理,主要用于多对多情况下的优化查询

这里我们准备一份表结构数据方便下面举例说明

class UserInfo(AbstractUser):
"""
用户信息
"""
nid = models.BigAutoField(primary_key=True)
nickname = models.CharField(verbose_name='昵称', max_length=32)
telephone = models.CharField(max_length=11, blank=True, null=True, unique=True, verbose_name='手机号码')
avatar = models.FileField(verbose_name='头像',upload_to = 'avatar/',default="/avatar/default.png")
create_time = models.DateTimeField(verbose_name='创建时间', auto_now_add=True) fans = models.ManyToManyField(verbose_name='粉丝们',
to='UserInfo',
through='UserFans',
related_name='f',
through_fields=('user', 'follower')) def __str__(self):
return self.username class UserFans(models.Model):
"""
互粉关系表
"""
nid = models.AutoField(primary_key=True)
user = models.ForeignKey(verbose_name='博主', to='UserInfo', to_field='nid', related_name='users')
follower = models.ForeignKey(verbose_name='粉丝', to='UserInfo', to_field='nid', related_name='followers') class Blog(models.Model): """
博客信息
"""
nid = models.BigAutoField(primary_key=True)
title = models.CharField(verbose_name='个人博客标题', max_length=64)
site = models.CharField(verbose_name='个人博客后缀', max_length=32, unique=True)
theme = models.CharField(verbose_name='博客主题', max_length=32)
user = models.OneToOneField(to='UserInfo', to_field='nid')
def __str__(self):
return self.title class Category(models.Model):
"""
博主个人文章分类表
"""
nid = models.AutoField(primary_key=True)
title = models.CharField(verbose_name='分类标题', max_length=32) blog = models.ForeignKey(verbose_name='所属博客', to='Blog', to_field='nid') class Article(models.Model): nid = models.BigAutoField(primary_key=True)
title = models.CharField(max_length=50, verbose_name='文章标题')
desc = models.CharField(max_length=255, verbose_name='文章描述')
read_count = models.IntegerField(default=0)
comment_count= models.IntegerField(default=0)
up_count = models.IntegerField(default=0)
down_count = models.IntegerField(default=0)
category = models.ForeignKey(verbose_name='文章类型', to='Category', to_field='nid', null=True)
create_time = models.DateField(verbose_name='创建时间')
blog = models.ForeignKey(verbose_name='所属博客', to='Blog', to_field='nid')
tags = models.ManyToManyField(
to="Tag",
through='Article2Tag',
through_fields=('article', 'tag'),
) class ArticleDetail(models.Model):
"""
文章详细表
"""
nid = models.AutoField(primary_key=True)
content = models.TextField(verbose_name='文章内容', ) article = models.OneToOneField(verbose_name='所属文章', to='Article', to_field='nid') class Comment(models.Model):
"""
评论表
"""
nid = models.BigAutoField(primary_key=True)
article = models.ForeignKey(verbose_name='评论文章', to='Article', to_field='nid')
content = models.CharField(verbose_name='评论内容', max_length=255)
create_time = models.DateTimeField(verbose_name='创建时间', auto_now_add=True) parent_comment = models.ForeignKey('self', blank=True, null=True, verbose_name='父级评论')
user = models.ForeignKey(verbose_name='评论者', to='UserInfo', to_field='nid') up_count = models.IntegerField(default=0) def __str__(self):
return self.content class ArticleUpDown(models.Model):
"""
点赞表
"""
nid = models.AutoField(primary_key=True)
user = models.ForeignKey('UserInfo', null=True)
article = models.ForeignKey("Article", null=True)
models.BooleanField(verbose_name='是否赞') class CommentUp(models.Model):
"""
点赞表
"""
nid = models.AutoField(primary_key=True)
user = models.ForeignKey('UserInfo', null=True)
comment = models.ForeignKey("Comment", null=True) class Tag(models.Model):
nid = models.AutoField(primary_key=True)
title = models.CharField(verbose_name='标签名称', max_length=32)
blog = models.ForeignKey(verbose_name='所属博客', to='Blog', to_field='nid') class Article2Tag(models.Model):
nid = models.AutoField(primary_key=True)
article = models.ForeignKey(verbose_name='文章', to="Article", to_field='nid')
tag = models.ForeignKey(verbose_name='标签', to="Tag", to_field='nid')

select_related()

  对于一对一字段(OneToOneField)和外键字段(ForeignKey),可以使用select_related 来对QuerySet进行优化。

  select_related 返回一个QuerySet,当执行它的查询时它沿着外键关系查询关联的对象的数据。它会生成一个复杂的查询并引起性能的损耗,但是在以后使用外键关系时将不需要数据库查询。

  简单说,在对QuerySet使用select_related()函数后,Django会获取相应外键对应的对象,从而在之后需要的时候不必再查询数据库。

下面的例子解释了普通查询和select_related查询的区别。

#查询id=2的文章的分类名称
#方式一——标准的查询:
article=models.Article.objects.get(nid=2)
print(article.category.title)
#这种方法会进行两次对数据库的操作 #方式二——使用select_related()函数:
articleList=models.Article.objects.select_related("category").all()
for article_obj in articleList:
print(article_obj.category.title)
#此时for循环时不会再去对数据库进行操作
#方式一:
SELECT
"blog_article"."nid",
"blog_article"."title",
"blog_article"."desc",
"blog_article"."read_count",
"blog_article"."comment_count",
"blog_article"."up_count",
"blog_article"."down_count",
"blog_article"."category_id",
"blog_article"."create_time",
"blog_article"."blog_id",
"blog_article"."article_type_id"
FROM "blog_article"
WHERE "blog_article"."nid" = 2; args=(2,) SELECT
"blog_category"."nid",
"blog_category"."title",
"blog_category"."blog_id"
FROM "blog_category"
WHERE "blog_category"."nid" = 4; args=(4,) #方式二:
SELECT
"blog_article"."nid",
"blog_article"."title",
"blog_article"."desc",
"blog_article"."read_count",
"blog_article"."comment_count",
"blog_article"."up_count",
"blog_article"."down_count",
"blog_article"."category_id",
"blog_article"."create_time",
"blog_article"."blog_id",
"blog_article"."article_type_id", "blog_category"."nid",
"blog_category"."title",
"blog_category"."blog_id" FROM "blog_article"
LEFT OUTER JOIN "blog_category" ON ("blog_article"."category_id" = "blog_category"."nid");

两种方式查询的SQL语句对比

多外键查询

  有时我们需要连续跨好几张表,这时我们会用到多外键的查询,在多外键的查询中我们也要做到对每一个外键进行select_related()以提高查询效率

#只对一个外键进行select_related时,第二个外键的操作仍会触发对数据库的操作
article=models.Article.objects.select_related("category").get(nid=1)
print(article.articledetail)#两次查询 #所以我们需要做优化
article=models.Article.objects.select_related("category","articledetail").get(nid=1)
print(article.articledetail)
#或
article=models.Article.objects
             .select_related("category")
             .select_related("articledetail")
             .get(nid=1) # django 1.7 支持链式操作
print(article.articledetail)
SELECT

    "blog_article"."nid",
"blog_article"."title",
...... "blog_category"."nid",
"blog_category"."title",
"blog_category"."blog_id", "blog_articledetail"."nid",
"blog_articledetail"."content",
"blog_articledetail"."article_id" FROM "blog_article"
LEFT OUTER JOIN "blog_category" ON ("blog_article"."category_id" = "blog_category"."nid")
LEFT OUTER JOIN "blog_articledetail" ON ("blog_article"."nid" = "blog_articledetail"."article_id")
WHERE "blog_article"."nid" = 1; args=(1,)

优化后只执行一次SQL语句

深层查询

# 查询id=1的文章的用户姓名
article=models.Article.objects.select_related("blog").get(nid=1)
print(article.blog.user.username)

依然需要查询两次:

SELECT
"blog_article"."nid",
"blog_article"."title",
...... "blog_blog"."nid",
"blog_blog"."title", FROM "blog_article" INNER JOIN "blog_blog" ON ("blog_article"."blog_id" = "blog_blog"."nid")
WHERE "blog_article"."nid" = 1; SELECT
"blog_userinfo"."password",
"blog_userinfo"."last_login",
...... FROM "blog_userinfo"
WHERE "blog_userinfo"."nid" = 1;

SQL语句

这是因为第一次查询没有query到userInfo表,所以,修改如下:

article=models.Article.objects.select_related("blog__user").get(nid=1)
print(article.blog.user.username)
SELECT

"blog_article"."nid", "blog_article"."title",
...... "blog_blog"."nid", "blog_blog"."title",
...... "blog_userinfo"."password", "blog_userinfo"."last_login",
...... FROM "blog_article" INNER JOIN "blog_blog" ON ("blog_article"."blog_id" = "blog_blog"."nid") INNER JOIN "blog_userinfo" ON ("blog_blog"."user_id" = "blog_userinfo"."nid")
WHERE "blog_article"."nid" = 1;
总结

优化后的SQL语句

select_related总结:

  1. select_related主要针一对一和多对一关系进行优化。
  2. select_related使用SQL的JOIN语句进行优化,通过减少SQL查询的次数来进行优化、提高性能。
  3. 可以通过可变长参数指定需要select_related的字段名。也可以通过使用双下划线“__”连接字段名来实现指定的递归查询。
  4. 没有指定的字段不会缓存,没有指定的深度不会缓存,如果要访问的话Django会再次进行SQL查询。
  5. 也可以通过depth参数指定递归的深度,Django会自动缓存指定深度内所有的字段。如果要访问指定深度外的字段,Django会再次进行SQL查询。
  6. 也接受无参数的调用,Django会尽可能深的递归查询所有的字段。但注意有Django递归的限制和性能的浪费。
  7. Django >= 1.7,链式调用的select_related相当于使用可变长参数。Django < 1.7,链式调用会导致前边的select_related失效,只保留最后一个。

prefetch_related()

  对于多对多字段(ManyToManyField)和一对多字段,可以使用prefetch_related()来进行优化。

  prefetch_related()和select_related()的设计目的很相似,都是为了减少SQL查询的数量,但是实现的方式不一样。后者是通过JOIN语句,在SQL查询内解决问题。但是对于多对多关系,使用SQL语句解决就显得有些不太明智,因为JOIN得到的表将会很长,会导致SQL语句运行时间的增加和内存占用的增加。若有n个对象,每个对象的多对多字段对应Mi条,就会生成Σ(n)Mi 行的结果表。

prefetch_related()的解决方法是,分别查询每个表,然后用Python处理他们之间的关系。

# 查询所有文章关联的所有标签
article_obj=models.Article.objects.all()
for i in article_obj:
print(i.tags.all()) #4篇文章: 5次数据库操作 # 使用prefetch_related:
article_obj=models.Article.objects.prefetch_related("tags").all()
for i in article_obj:
print(i.tags.all()) #4篇文章: 2次数据库操作
SELECT "blog_article"."nid",
"blog_article"."title",
...... FROM "blog_article"; SELECT
("blog_article2tag"."article_id") AS "_prefetch_related_val_article_id",
"blog_tag"."nid",
"blog_tag"."title",
"blog_tag"."blog_id"
FROM "blog_tag"
INNER JOIN "blog_article2tag" ON ("blog_tag"."nid" = "blog_article2tag"."tag_id")
WHERE "blog_article2tag"."article_id" IN (1, 2, 3, 4);

优化后的SQL语句

extra

  有些情况下,Django的查询语法难以表达复杂的where子句,对于这种情况, Django 提供了extra()QuerySet修改机制 。它能在QuerySet生成的SQL从句中注入新子句,extra可以指定一个或多个参数,例如select、where或tables。 这些参数都不是必须的,但是至少要使用一个。

注意:这些额外的方式对不同的数据库引擎可能存在移植性问题.(因为你在显式的书写SQL语句),所以除非万不得已,尽量避免这样做

extra(select=None, where=None, params=None,
tables=None, order_by=None, select_params=None)

select参数

  select参数可以在select从句中添加其他字段信息,它应该是一个字典,存放着属性名到 SQL 从句的映射。

举个栗子:

queryResult=models.Article.objects.extra(select={'is_recent': "create_time > '2017-09-05'"})
#结果集中每个对象都有一个额外的属性is_recent, 它是一个布尔值,表示 Article对象的create_time 是否晚于2017-09-05.
article_obj=models.Article.objects
              .filter(nid=1)
              .extra(select={"standard_time":"strftime('%%Y-%%m-%%d',create_time)"})
              .values("standard_time","nid","title")

where参数和tables参数

  我们可以使用where定义显式SQL where子句 ,也许执行非显式连接。使用tables可以手动将表添加到SQL的from子句。

where和tables都接受字符串列表。所有where参数均为“与”任何其他搜索条件。

举个栗子:

queryResult=models.Article.objects.extra(where=['nid in (1,3) OR title like "py%" ','nid>2'])

批量导入

  有时候,我们在创建对象是会用到一次性创建多个对象,这时我们尽量使用bulk_create()进行批量创建来减少对数据库的访问次数

#bulk_create批量创建:
Book.objects.bulk_create([
Book(headline="Python 3.0 Released"),
Book(headline="Python 3.1 Planned")
])#只执行一条SQL语句 #普通创建,执行多条SQL语句:
Book.objects.create(headline="Python 3.0 Released")
Book.objects.create(headline="Python 3.1 Planned")

Django进阶之查询优化、extra注入SQL及批量创建的更多相关文章

  1. SQL Server 批量创建作业(备份主分区)

    一. 需求背景 在我的数据库实例中,有很多类似下图所示的数据库,这些数据库的名称是有规律的,每个数据库包含的表都是相同的,其中2个表是类似流水记录的表,表的数据量会比较大,占用的空间有几十G到上百G不 ...

  2. Django进阶使用

    Model 到目前为止,当我们的程序涉及到数据库相关操作时,我们一般都会这么搞: 创建数据库,设计表结构和字段 使用 MySQLdb 来连接数据库,并编写数据访问层代码 业务逻辑层去调用数据访问层执行 ...

  3. django进阶篇

    原文连接:http://www.cnblogs.com/wupeiqi/articles/5246483.html Model 到目前为止,当我们的程序涉及到数据库相关操作时,我们一般都会这么搞: 创 ...

  4. 【Python全栈-后端开发】Django进阶之Model操作复习

    Django进阶之Model操作复习 一.字段 AutoField(Field) - int自增列,必须填入参数 primary_key=True BigAutoField(AutoField) - ...

  5. Python 第五阶段 学习记录之---Django 进阶

    Model 一.创建表 1.基本结构 字段 AutoField(Field) - int自增列,必须填入参数 primary_key=True BigAutoField(AutoField) - bi ...

  6. Django框架 之 查询 Extra

    Django框架 之 查询 Extra extra 1 2 extra(select=None, where=None, params=None,       tables=None, order_b ...

  7. Python学习-day20 django进阶篇

    Model 到目前为止,当我们的程序涉及到数据库相关操作时,我们一般都会这么搞: 创建数据库,设计表结构和字段 使用 MySQLdb 来连接数据库,并编写数据访问层代码 业务逻辑层去调用数据访问层执行 ...

  8. django进阶之缓存

    Model 到目前为止,当我们的程序涉及到数据库相关操作时,我们一般都会这么搞: 创建数据库,设计表结构和字段 使用 MySQLdb 来连接数据库,并编写数据访问层代码 业务逻辑层去调用数据访问层执行 ...

  9. django进阶-4

    前言: 下篇博客写关于bootstrap... 一.如何在脚本测试django from django.db import models class Blog(models.Model): name ...

随机推荐

  1. SQL Server does not purge row versioning records even the transaction are committed if there are other open transaction running in the databases with read-committed snapshot enabled .

    This is a by-design behavior. There is only one allocation unit in tempdb that istracking the versio ...

  2. Kafka 生产者和消费者入门代码基础

    这篇博文讲解Kafka 的生产者和消费者实例. 基础版本一 生产者 ProducerFastStart.java package com.xingyun.tutorial_1; import org. ...

  3. sudo: unable to execute ./script.sh: no such file or directory

    I just had this exact problem, it turned out to be a text file encoding problem. For me to fix it wh ...

  4. [python] ThreadPoolExecutor线程池 python 线程池

    初识 Python中已经有了threading模块,为什么还需要线程池呢,线程池又是什么东西呢?在介绍线程同步的信号量机制的时候,举得例子是爬虫的例子,需要控制同时爬取的线程数,例子中创建了20个线程 ...

  5. XSS测试代码

    无script的Xss <img/src=# onerror=alert('XSS')> HTML5  XSS测试代码 <video> <source onerror=” ...

  6. opcache分享

    opcache的技术分享ppt,独家唯一经过自己实验的分享 https://pan.baidu.com/s/1-73-QHOSeet7tcR81gto6Q

  7. hdoj:2069

    Coin Change Time Limit: 1000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)Total ...

  8. halcon 特征测量

    Features 1. line_orientation   功能:计算线的方位. 2. line_position   功能:计算一条线的重心.长度和方位. 3. partition_lines   ...

  9. 第四百零四节,python网站第三方登录,social-auth-app-django模块,

    第四百零四节,python网站第三方登录,social-auth-app-django模块, social-auth-app-django模块是专门用于Django的第三方登录OAuth2协议模块 目 ...

  10. name转json

    ^(\{)?(?<=\n)(.*)(\})?$ "$2":"", UserId UserOrderId ChargeAccount BuyNum Good ...