编辑:最好的解决方案感谢 Hakan--

queriedForms.filter(pk__in=list(formtype.form_set.all().filter(formrecordattributevalue__record_value__contains=constraint['TVAL'], formrecordattributevalue__record_attribute_type__pk=rtypePK).values_list('pk', flat=True))).count()

我尝试了他的更多建议，但我无法避免 INNER JOIN——这似乎是一个稳定的解决方案，确实让我变小了，但可预测的速度全面提高。查看他的回答了解更多详情!

我一直在为一个问题而苦苦挣扎，我还没有在网上看到答案。

在 Django 中链接两个过滤器时，例如

masterQuery = bigmodel.relatedmodel_set.all()
masterQuery = masterQuery.filter(name__contains="test")
masterQuery.count() 
#returns 100,000 results in < 1 second
#test filter--all 100,000+ names have "test x" where x is 0-9 
storedCount = masterQuery.filter(name__contains="9").count()
#returns ~50,000 results but takes 5-6 seconds

尝试一种稍微不同的方式:

masterQuery = masterQuery.filter(name__contains="9")
masterQuery.count()
#also returns ~50,000 results in 5-6 seconds

执行 & 合并似乎稍微提高了性能，例如

masterQuery = bigmodel.relatedmodel_set.all()
masterQuery = masterQuery.filter(name__contains="test") 
(masterQuery & masterQuery.filter(name__contains="9")).count()

似乎 count 花费的时间比查询集中的单个过滤器要长得多。

我假设它可能与 mySQL 有关，mySQL 显然不喜欢嵌套语句——我假设两个过滤器正在创建一个嵌套查询，这会减慢 mySQL 的速度，而不管 Django 使用的 SELECT COUNT(*)

所以我的问题是:有什么方法可以加快速度吗？我正准备只使用查询集计数(我不需要实际的模型值)进行大量常规嵌套查询，而无需数据库命中来加载模型。例如我不需要从数据库加载 100,000 个模型，我只需要知道那里有 100,000 个。通过查询集执行此操作显然比 len() 快得多，但即使在 5 秒内，当我对整个复杂查询运行 40 次计数时，一次计数也是 3 分钟以上——我希望它不到一分钟。除了提高服务器的处理器速度之外，我是在幻想还是有人建议如何实现这一目标？

编辑:如果有帮助——链式 filter() 计数的 time.clock() 速度为 0.3 秒——控制台和 Django View 输出的实际时间为 5-6 秒

EDIT2:为了回答有关索引的任何问题，过滤器对链中的每个链接都使用索引值和非索引值:

mainQuery = masterQuery = bigmodel.relatedmodel_set.all()
mainQuery = mainQuery.filter(reverseforeignkeytestmodel__record_value__contains="test", reverseforeignkeytestmodel__record_attribute_type__pk=1)
#Where "record_attribute_type" is another foreign key being used as a filter
mainQuery.count() #produces 100,000 results in < 1sec
mainQuery.filter(reverseforeignkeytestmodel__record_value__contains="9", reverseforeignkeytestmodel__record_attribute_type__pk=5).count()
#produces ~50,000 results in 5-6 secs

所以链中的每个过滤器在功能上都是相似的，它是一个 AND 过滤器(条件，条件)，其中一个条件被索引，另一个没有。我无法索引这两个条件。

编辑 3: 导致较小结果的类似查询，例如< 10,000="" 更快，无论嵌套如何="" -="" 例如链中的第一个过滤器在=""><1 秒内产生="" 10,000="" 个结果，但链中的第二个过滤器将在=""><1 秒内产生="" 5,000="">

编辑 4: 基于@Hakan 的解决方案仍无法正常工作

mainQuery = bigmodel.relatedmodel_set.all()
#Setup the first filter as normal
mainQuery = mainQuery.filter(reverseforeignkeytestmodel__record_value__contains="test", reverseforeignkeytestmodel__record_attribute_type__pk=1)

#Grab a values list for the second chained filter instead of chaining it    
values = bigmodel.relatedmodel_set.all().filter(reverseforeignkeytestmodel__record_value__contains="test", reverseforeignkeytestmodel__record_attribute_type__pk=8).values_list('pk', flat=True)
#filter the first query based on the values_list rather than a second filter
mainQuery = mainQuery.filter(pk__in=values)
mainQuery.count()
#Still takes on average the same amount of time after enough test runs--seems to be slightly faster than average--similar to the (quersetA & querysetB) merge solution I tried.

这可能是我做错了——但计数结果在新的 value_list 过滤器技术之间是一致的，例如我得到相同的结果。所以它确实有效——但似乎花费了相同的时间

编辑 5: 也基于@Hakan 的解决方案，稍作调整

mainQuery.filter(pk__in=list(formtype.form_set.all().filter(formrecordattributevalue__record_value__contains=constraint['TVAL'], formrecordattributevalue__record_attribute_type__pk=rtypePK).values_list('pk', flat=True))).count()

对于查询集中较大的结果，这似乎运行得更快，例如> 50,000，但实际上在较小的查询集结果上要慢得多，例如< 50,000——过去是=""><1 秒——有时="" 2-3="" 次在="" 1="" 秒内运行以进行链式过滤，现在它们都单独需要="" 1="">

我仍将尝试根据他的建议进一步分解查询——但我不确定我是否能够做到。当我弄清楚并让所有感兴趣的人知道进展情况时，我会再次更新(可能在星期一)。

最佳答案

不确定这是否有帮助，因为我没有要测试的 mysql 项目。

QuerySet API reference包含有关嵌套查询性能的部分。

Performance considerations

Be cautious about using nested queries and understand your database server’s performance characteristics (if in doubt, benchmark!). Some database backends, most notably MySQL, don’t optimize nested queries very well. It is more efficient, in those cases, to extract a list of values and then pass that into the second query. That is, execute two queries instead of one:

values = Blog.objects.filter(
    name__contains='Cheddar').values_list('pk', flat=True) 
entries = Entry.objects.filter(blog__in=list(values)) 

Note the list() call around the Blog QuerySet to force execution of the first query. Without it, a nested query would be executed, because QuerySets are lazy.

所以，也许你可以通过尝试这样的事情来提高性能:

masterQuery = bigmodel.relatedmodel_set.all()
pks = list(masterQuery.filter(name__contains="test").values_list('pk', flat=True))
count = masterQuery.filter(pk__in=pks, name__contains="9")

由于您的初始 MySQL 性能非常慢，因此在 Python 中而不是在数据库中执行第二步甚至可能更快。

names = masterQuery.filter(name__contains='test').values_list('name')
count = sum('9' in n for n in names)

编辑: 从您的更新中，我看到您正在查询相关模型中的字段，这导致多个 sql JOIN 操作。这可能是查询缓慢的一个重要原因。

为了避免连接，你可以尝试这样的事情。目标是避免跨关系进行深度链接查找。

# query only RelatedModel, avoid JOIN
related_pks = RelatedModel.objects.filter(
     record_value__contains=constraint['TVAL'],
     record_attribute_type=rtypePK,
).values_list('pk', flat=True)

# list(queryset) will do a database query, resulting in a list of integers.
pks_list = list(related_pks)

# use that result to filter your main model. 
count = MainModel.objects.filter(
     formrecordattributevalue__in=pks_list
).count()

我假设关系被定义为从 MainModel 到 RelatedModel 的外键。

关于python - Django:无论返回的查询大小如何，链式过滤器上的 queryset.count() 都比单个过滤器慢得多——有解决方案吗？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/44976774/