ORM优化

最新推荐文章于 2024-03-28 11:15:00 发布
最新推荐文章于 2024-03-28 11:15:00 发布
阅读量277 收藏
点赞数 1
文章标签： 数据库 python
原文链接：http://www.cnblogs.com/believepd/p/10296239.html
版权

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'])

 

转载于:https://www.cnblogs.com/believepd/p/10296239.html

weixin_34361881
关注
优化ORM性能
01-31
有些开发者因为曾有性能上的不快经验而拒绝采用对象关系映射（ORM）技术。和任何形式的抽象一样，使用ORM框架要以一些额外开销作为代价，但事实上，使用经过恰当调优的ORM和手写原生的数据访问代码在性能上还是有得一拼的。更为重要的是，使用好的ORM框架更容易调优和优化性能，手写原生数据访问代码在性能调优上则会困难得多。本文中的示例建立在Mindscape的LightSpeedORM之上，我们将结合示例讨论常见的问题及其解决方案。让我们来看看web应用程序中的过期订单列表，这有助于我们理解所要讨论的问题。假设我们不仅要查看订单，同时还要查看每个订单的客户信息，如果没做深入分析的话，我们也许会写出
orm查询方式与优化
weixin_64178950的博客
05-18 1489
今日内容概要1 > 聚合查询2 > 分组查询3 > F与Q查询3.1 > F查询3.2 > Q查询4 > ORM查询优化4.1 > only与defer4.2 > select_related和prefetch_related5 > ORM常见字段6 > 重要参数7 > 事务操作8 > ORM执行原生SQL9 > 多对多三种创建方式9.1 > 全自动(常见)9.2 > 全手动(使用频率最低)9.3 > 半自动(
Django ORM优化
生有涯，知无涯
10-08 827
一、orm优化 1.数据库技术进行优化，包括给字段加索引，设置唯一性约束等等； 2.查询过滤工作在数据库语句中做，不要放在代码中完成（看情况）； 3.如果要一次查询出集合的数量，使用count函数，而不是len函数，但是如果后面还需要到集合，那就用len，因为count还需要进行一次数据库的操作； 4.避免过多的使用count和exists函数； 5.如果需要查询对象的外键，则...
orm查询优化
python_web全栈
09-19 751
其次，查询并不能保证只返回一个对象，如果匹配上来多个对象，且从数据库中检索并返回数百数千条记录，后果会很严重，其实就会报错，get() 能接受的返回只能是一个实例数据。1. 在大多数查询中，使用 filter() 和 exclude() 在数据库中做过滤，而不是在获取所有数据之后在 Python 里的 for 循环里筛选数据。如果想要获取总数，使用 count() 方法，而不是使用 len() 来操作，如果数据有一万条，len() 操作会导致这一万条数据都加载到内存里，然后计数。
浅谈django orm 优化
12-23
orm优化 1.数据库技术进行优化，包括给字段加索引，设置唯一性约束等等； 2.查询过滤工作在数据库语句中做，不要放在代码中完成（看情况）； 3.如果要一次查询出集合的数量，使用count函数，而不是len函数，但是...
django orm优化
06-09
Django ORM 可以通过以下几种方式进行优化： 1. 使用缓存：使用 Django 的缓存系统可以大大提高查询的速度。 2. 使用预读：使用 select_related 和 prefetch_related 可以减少额外的查询次数，从而提高效率。 3. ...
浅谈优化Django ORM中的性能问题
09-16
主要介绍了浅谈优化Django ORM中的性能问题，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
Backend - Django ORM 性能优化（Update 更新/修改）
是萝卜干呀的博客
06-29 853
知识量决定了未来能走多远
如何优化查询ORM
go|Python的个人博客
03-17 406
N+1查询问题是指当你查询一个对象集合时，对于集合中的每个对象，又单独发起了一个数据库查询来获取其关联对象。具体优化策略取决于你的应用、数据库结构和查询模式。如果查询的数据不经常变动，并且查询很频繁，可以考虑使用查询缓存来存储结果。使用数据库的性能监控工具来跟踪和分析查询的性能，找出性能瓶颈并进行优化。确保数据库中用于查询的字段都有适当的索引。使用ORM提供的关联查询方法来减少查询的复杂度。，避免在遍历用户时单独查询每个用户的帖子。来选择所有字段，只选择你真正需要的字段。使用子查询来优化关联查询。
Django中orm优化操作
Struggle_Hard_Z的博客
03-27 1856
Q查询 """Q查询""" # filter括号内多个条件均为and关系 # 1.查询主键为3或者卖出数为1000的数据 # res = models.Book.objects.filter(pk=3, maichu=1000) # 逗号分隔为and关系 from django.db.models import Q ###########基本用法########### # res = models.Book.objects.filter(Q(pk=3),
Django官方文档小结(三) -- ORM数据库性能优化
Auto
05-27 765
文章目录Django ORM性能优化#1 环境#2 QuerySet优化#2.1 select_related()函数#2.2 select_related()使用#2.3 总结#2.4 打印SQL语句 Django ORM性能优化 #1 环境 Python3.7.3 Django==2.0.7 #2 QuerySet优化 #2.1 select_related()函数 select_relat...
【Django-CI系统】优化ORM读取速度-20220525
Season CSDN博客
05-25 173
效果：优化ORM读取速度，节约大概2秒。 views.py 将所有模型都查出来，避免反复查询数据造成读取速度下降。 将所有模型都查出来 # 将所有模型都查出来 suggestion_all = suggestion.objects.all() dept_review_all = dept_review.objects.all() headcount_all = headcount.objects.all() User_all = User.objects.all()
(总结)Django 高性能ORM 查询优化
Nick.Peng's Blogs
11-28 3600
文章目录导读一、QuerySet1.1 可切片1.2 可迭代1.3 惰性查询1.4 缓存机制（重点）1.5 何时查询集不会被缓存?二、exists() 与 iterator() 方法（重点）2.1 exists2.2 iterator2.3 总结:三、查询优化（重点）3.1 select_related(基于连表查询，一对一/多外键)3.1.1 一对一简单使用3.1.2 多外键查询3.1.3 深层...
Django中的数据库优化与ORM性能调优
最新发布
pythonhy的博客
03-28 1082
在开发基于Django的Web应用程序时，数据库是至关重要的组成部分之一。
Django入门 ----ORM数据的增删改查
sGDUTBMW的博客
03-29 1823
文章目录1. 增1. 方法1：save()2. 方法2：create()3. 方法3：bulk_create()2. 删3. 改1. 方法1：save()2. 方法2：update()3. 方法3：bulk_update()4. 查1. 查询所有数据2. 查询一条数据3. 查询多条数据1. 按大于、小于及不等于查询2. 按范围查询3. 字符串模糊查询4. 按日期时间查询4. 切片、排序、去重5. 高级Q和F方法 Django的对象关系映射系统(Object-Relational Mapper, ORM)提供
.Net中ORM实现原理及常用 C# ORM框架
jhl52771的专栏
02-04 2861
.NET ORM 有哪些 ，SqlSugar ef core dapper (Object Ralational Mapping，即对象关系映射)实现思想就是将关系数据库中表的数据映射成对象。
C#基础系列：实现自己的ORM（构造我自己的ORM）
weixin_30786617的博客
07-29 207
【转 http://blog.csdn.net/ronotian/article/details/2900734】 构造我自己的ORM 通过前面两章的描述，我相信很多朋友都已经明白我了下面将要讨论到的ORM的实现方法了，那就是根据自定义Attribute来定义O/R Mapping规则，然后通过反射来动态获取此规则，动态构造SQL语句。 由于这个小东西（ORM）出生在深圳，所以我想来想去...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值