ORM优化

orm优化数据库访问：https://docs.djangoproject.com/en/1.11/topics/db/optimization/

一、QuerySet

可迭代

querysey=models.Book.objects.all()
for book in querysey:
    print(book.title)

可切片

Book.objects.all()[:3]
Book.objects.all()[3:6]
# 不支持负的索引，例如Book.objects.all()[0:-1]。通常，查询集的切片返回一个新的查询集，它不会执行查询。

惰性查询

QuerySet 是懒惰的 -- 创建查询集不会带来任何数据库的访问；直到查询集需要求值时，Django 才会真正运行这个查询。

queryset = models.Book.objects.all()  # not hits database
print(queryset)                       # hits database
for book in queryset:
    print(book.title)                 # Hits database

缓存机制

每个查询集都包含一个缓存来最小化对数据库的访问。理解它是如何工作的将让你编写最高效的代码。

在一个新创建的查询集中，缓存为空。首次对查询集进行求值，同时发生数据库查询，Django 将保存查询的结果到查询集的缓存中并返回明确请求的结果（例如，如果正在迭代查询集，则返回下一个结果）。接下来对该查询集的求值将重用缓存的结果。

请牢记这个缓存行为，因为对查询集使用不当的话，它会坑你的。例如，下面的语句创建两个查询集，对它们求值，然后扔掉它们：

print(book.title for book in models.Book.objects.all())  # hits database
print(book.price for book in models.Book.objects.all())  # hits database

这意味着相同的数据库查询将执行两次，显然倍增了你的数据库负载。同时，还有可能两个结果列表并不包含相同的数据库记录，因为在两次请求期间有可能有 book 被添加进来或删除掉。为了避免这个问题，只需保存查询集并重新使用它：

queryset = models.Book.objects.all()
print(book.title for book in queryset)
print(book.price for book in queryset)
# 下面也是一次数据库查询
for book in querysey:
    print(book.title)
    print(book.price)

何时查询集不会被缓存?

当只对查询集的部分进行求值时会检查缓存， 如果这个部分不在缓存中，那么接下来查询返回的记录都将不会被缓存。所以，这意味着使用切片或索引来限制查询集将不会填充缓存。

例如，重复获取查询集对象中一个特定的索引将每次都查询数据库：

queryset = models.Book.objects.all()
print(queryset[1])  # hits database
print(queryset[1])  # hits database

然而，如果已经对全部查询集求值过，则将检查缓存：

queryset = models.Book.objects.all()
[book for book in queryset]  # hits database
print(queryset[1])           # use cache
print(queryset[1])           # use cache

简单地打印查询集不会填充缓存：

queryset = models.Book.objects.all()
print(queryset)  # hits database
print(queryset)  # hits database

exists() 和 iterator()

简单的使用 if 语句进行判断也会完全执行整个 queryset 并且把数据放入cache，虽然你并不需要这些数据！为了避免这个，可以用 exists() 方法来检查是否有数据：

queryset = models.Author.objects.all()
if queryset.exists():
    print("True")

更优于：

queryset = models.Author.objects.all()
if queryset:
    print("True")

它们的sql查询分别为：

SELECT (1) AS "a" FROM "app01_author" LIMIT 1; args=()
SELECT "app01_author"."id", "app01_author"."name", "app01_author"."age", "app01_author"."author_detail_id" FROM "app01_author"; args=()

当queryset非常巨大时，cache会成为问题。

处理成千上万的记录时，将它们一次装入内存是很浪费的。更糟糕的是，巨大的queryset可能会锁住系统进程，让程序濒临崩溃。要避免在遍历数据的同时产生 queryset cache，可以使用 iterator() 方法来获取数据，处理完数据就将其丢弃。

# iterator() 可以一次只从数据库获取少量数据，这样可以节省内存
objs = models.Book.objects.all().iterator()
for obj in objs:
    print(obj.title)
# 注意，再次遍历没有打印，因为迭代器已经在上一次遍历（next）到最后一次了，没得遍历了
for obj in objs:
    print(obj.title)

当然，使用 iterator() 方法来防止生成cache，意味着遍历同一个 queryset 时会重复执行查询。所以使用 iterator() 的时候要当心，确保你的代码在操作一个大的 queryset 时没有重复执行查询。

总结

queryset 的 cache 是用于减少程序对数据库的查询，在通常的使用下会保证只有在需要的时候才会查询数据库。 使用 exists() 和 iterator() 方法可以优化程序对内存的使用。不过，由于它们并不会生成queryset cache，可能会造成额外的数据库查询。

二、查询优化

from django.db import models
from django.contrib.auth.models import AbstractUser

class UserInfo(AbstractUser):
    """
    用户信息
    """
    nid = models.AutoField(primary_key=True)
    telephone = models.CharField(verbose_name="联系电话", max_length=11, null=True, unique=True)
    avatar = models.FileField(verbose_name="头像", upload_to="avatars/", default="/avatars/default.png")
    create_time = models.DateTimeField(verbose_name="创建时间", auto_now_add=True)
    blog = models.OneToOneField(verbose_name="个人站点", to="Blog", to_field="nid", null=True)

    def __str__(self):
        return self.username

class Blog(models.Model):
    """
    博客信息
    """
    nid = models.AutoField(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)

    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")  # 一个博客站点可以有多个分类

    def __str__(self):
        return self.title

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")  # 一个博客站点可以有多个标签

    def __str__(self):
        return self.title

class Article(models.Model):
    """
    文章表
    """
    nid = models.AutoField(primary_key=True)
    title = models.CharField(max_length=50, verbose_name="文章标题")
    description = models.CharField(max_length=255, verbose_name="文章描述")
    create_time = models.DateTimeField(verbose_name="创建时间", auto_now_add=True)
    comment_count = models.IntegerField(verbose_name="评论数", default=0)
    up_count = models.IntegerField(verbose_name="点赞数", default=0)
    down_count = models.IntegerField(verbose_name="反对数", default=0)
    category = models.ForeignKey(verbose_name="所属分类", to="Category", to_field="nid", null=True)
    user = models.ForeignKey(verbose_name="作者", to="UserInfo", to_field="nid")
    tags = models.ManyToManyField(
        verbose_name="所属标签",
        to="Tag",
        through="ArticleToTag",
        through_fields=("article", "tag"),
    )

    def __str__(self):
        return self.title

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 ArticleToTag(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")

    class Meta:
        unique_together = [
            ("article", "tag"),
        ]

    def __str__(self):
        v = self.article.title + "--" + self.tag.title
        return v

class ArticleUpDown(models.Model):
    """
    点赞表
    哪个用户对哪篇文章点了赞
    """
    nid = models.AutoField(primary_key=True)
    user = models.ForeignKey(verbose_name="用户id", to="UserInfo", null=True)
    article = models.ForeignKey(verbose_name="文章id", to="Article", null=True)
    is_up = models.BooleanField(verbose_name="是否为赞", default=True)

    class Meta:
        unique_together = [
            ("article", "user"),
        ]

class Comment(models.Model):
    """
    评论表
    """
    nid = models.AutoField(primary_key=True)
    user = models.ForeignKey(verbose_name="评论者", to="UserInfo", to_field="nid")
    article = models.ForeignKey(verbose_name="评论文章", to="Article", to_field="nid")
    create_time = models.DateTimeField(verbose_name="创建时间", auto_now_add=True)
    content = models.CharField(verbose_name="评论内容", max_length=255)
    parent_comment = models.ForeignKey("self", null=True)

    def __str__(self):
        return self.content

表数据

select_related

简单实用

对于一对一字段和外键字段，可以使用 select_related 来对 QuerySet 进行优化。

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

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

示例：

# 查询 id=1 的文章的分类名称，下面是一个标准的查询：
article = models.Article.objects.get(nid=1)  # hits database
print(article.category.title)                # hits database again to get the related Category object

SELECT
`blog_article`.`nid`,
`blog_article`.`title`,
`blog_article`.`description`,
`blog_article`.`create_time`,
`blog_article`.`comment_count`,
`blog_article`.`up_count`,
`blog_article`.`down_count`,
`blog_article`.`category_id`,
`blog_article`.`user_id`
FROM
`blog_article`
WHERE
`blog_article`.`nid` = 1; args=(1,)

SELECT
`blog_category`.`nid`,
`blog_category`.`title`,
`blog_category`.`blog_id`
FROM
`blog_category`
WHERE
`blog_category`.`nid` = 1; args=(1,)

两次数据库查询

如果使用 select_related() 函数：

article = models.Article.objects.select_related("category").get(nid=1)
print(article.category.title)

SELECT
`blog_article`.`nid`,
`blog_article`.`title`,
`blog_article`.`description`,
`blog_article`.`create_time`,
`blog_article`.`comment_count`,
`blog_article`.`up_count`,
`blog_article`.`down_count`,
`blog_article`.`category_id`,
`blog_article`.`user_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`)
WHERE
`blog_article`.`nid` = 1; args=(1,)

一次数据库查询

多个外键查询

这是针对 category 的外键查询，如果是另外一个外键呢？让我们一起看下：

article = models.Article.objects.select_related("category").get(nid=1)
    print(article.articledetail)

观察 logging 发现依然需要查询两次，所以需要改为：

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)
    print(article.articledetail)

SELECT
`blog_article`.`nid`,
`blog_article`.`title`,
`blog_article`.`description`,
`blog_article`.`create_time`, `
blog_article`.`comment_count`,
`blog_article`.`up_count`,
`blog_article`.`down_count`,
`blog_article`.`category_id`,
`blog_article`.`user_id`,
`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,)

一次数据库查询

深层查询

# 查询 id=1 的文章的博客名称
article = models.Article.objects.select_related("user").get(nid=1)
print(article.user.blog.title)

依然需要查询两次；

这是因为第一次查询没有 query 到 blog 表，所以，修改如下：

article = models.Article.objects.select_related("user__blog").get(nid=1)
print(article.user.blog.title)

总结

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()

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

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

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

# 查询所有文章关联的所有标签
queryset = models.Article.objects.all()
for article in queryset:
    print(article.tags.all())  # 9篇文章: hits database 10

如果实用 prefetch_related() 函数：

queryset = models.Article.objects.prefetch_related("tags").all()
for article in queryset:
    print(article.tags.all())  # 9篇文章: hits database 2

ELECT
`blog_article`.`nid`,
`blog_article`.`title`,
`blog_article`.`description`,
`blog_article`.`create_time`,
`blog_article`.`comment_count`,
`blog_article`.`up_count`,
`blog_article`.`down_count`,
`blog_article`.`category_id`,
`blog_article`.`user_id`
FROM
`blog_article`; args=()

SELECT
(`blog_articletotag`.`article_id`) AS `_prefetch_related_val_article_id`,
`blog_tag`.`nid`,
`blog_tag`.`title`,
`blog_tag`.`blog_id`
FROM
`blog_tag`
INNER JOIN
`blog_articletotag`
ON
(`blog_tag`.`nid` = `blog_articletotag`.`tag_id`)
WHERE
`blog_articletotag`.`article_id`
IN
(1, 2, 3, 4, 5, 6, 7, 8, 9); args=(1, 2, 3, 4, 5, 6, 7, 8, 9)

两次数据库查询

三、其他优化

不要检索你不需要的东西

使用values()或values_list()

queryset = models.Article.objects.filter(nid=1)
print(queryset)

SELECT
`blog_article`.`nid`,
`blog_article`.`title`,
`blog_article`.`description`,
`blog_article`.`create_time`,
`blog_article`.`comment_count`,
`blog_article`.`up_count`,
`blog_article`.`down_count`,
`blog_article`.`category_id`,
`blog_article`.`user_id` FROM
`blog_article`
WHERE
`blog_article`.`nid` = 1 LIMIT 21; args=(1,)

sql语句

queryset = models.Article.objects.filter(nid=1).values("title")
print(queryset)

SELECT
`blog_article`.`title`
FROM
`blog_article`
WHERE
`blog_article`.`nid` = 1 LIMIT 21; args=(1,)

sql语句

使用only()或defer()

如果存在您知道在大多数情况下不需要（或在大多数情况下不需要）的数据库列，请使用 defer() 和 only() 来避免加载它们。 请注意，如果您确实使用它们，ORM必须在单独的查询中获取它们，如果您不恰当地使用它，则会产生非常悲剧的结果。

odels.Author.objects.only("name")
models.Author.objects.defer("id", "age", "author_detail")
# 两条sql是一样的，如下
# SELECT "app01_author"."id", "app01_author"."name" FROM "app01_author" LIMIT 21; args=()

直接使用外键值

# 如果只需要外键值，请使用已有对象上的外键值，而不是获取整个相关对象并获取其主键。
article.user_nid  代替 article.user.nid 

批量插入

创建对象时，尽可能使用 bulk_create() 来减少SQL查询的数量。例如：

Entry.objects.bulk_create([
    Entry(headline='This is a test'),
    Entry(headline='This is only a test'),
])

更优于：

Entry.objects.create(headline='This is a test')
Entry.objects.create(headline='This is only a test')

注意该方法有很多注意事项，所以得确保它适用于你的情况。

这也可以用在ManyToManyFields中，所以：

my_band.members.add(me, my_friend)

更优于：

my_band.members.add(me)
my_band.members.add(my_friend)

其中 Bands 与 Artists 具有多对多关系。

四、extra

def extra(self, select=None, where=None, params=None, tables=None, order_by=None, select_params=None)
    # 构造额外的查询条件或者映射，如：子查询
    Tb1.objects.extra(select={'new_id': "select col from sometable where othercol > %s"}, select_params=(1,))
    Tb1.objects.extra(where=['headline=%s'], params=['Lennon'])
    Tb1.objects.extra(where=["foo='a' OR bar = 'a'", "baz = 'a'"])
    Tb1.objects.extra(select={'new_id': "select id from tb where id > %s"}, select_params=(1,), order_by=['-nid'])

有些情况下，Django的查询语法难以表达复杂的 where 子句，对于这种情况，Django 提供了 extra() QuerySet 修改机制：它能在 QuerySet 生成的SQL从句中注入新子句。

extra 可以指定一个或多个参，例如 select、where、tables；这些参数都不是必须的，但是你至少要使用一个！要注意这些额外的方式对不同的数据库引擎可能存在移植性问题。（因为你在显式的书写SQL语句）,除非万不得已，尽量避免这样做。

select 参数

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

query_result=models.Article.objects.extra(select={'is_recent': "create_time > '2018-01-20'"})

结果集中每个 Article 对象都有一个额外的属性 is_recent，它是一个布尔值，表示 Article 对象的 create_time 是否晚于 2018-01-20。

article_obj=models.Article.objects
　　　　　　　　　　　　　　.filter(nid=1)
　　　　　　　　　　　　　　.extra(select={"standard_time": "strftime('%%Y-%%m-%%d', create_time)"})
　　　　　　　　　　　　　　.values("standard_time", "nid", "title")
print(article_obj)
# <QuerySet [{'title': 'Python基础', 'standard_time': '2018-01-20', 'nid': 1}]>

where / tables 参数

您可以使用 where 定义显式 SQL WHERE 子句，也许执行非显式连接。您可以使用 tables 手动将表添加到 SQL FROM 子句。
where 和 tables 都接受字符串列表。所有 where 参数均为"与"任何其他搜索条件。

示例：

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