Django 1.11.8 中的子查询非常慢 - 我可以加快速度吗？

Question

我有一些表在两个单独的 Django 模型中没有通过 FK 关系连接，我正在尝试做一个SubQuery。数据如下所示：

# "master" data table - reflects real property ownership by humans
# there are often changes to property ownership
class OwnershipRecord(Model):
  parcel = CharField(max_length=10, unique=True)
  owner_name = ...
  other data fields ...

# Poor man's 'elastic search' or an index of sorts for OwnershipRecord
class Lead(Model):
  ownership_record = OneToOneField(OwnershipRecord)
  preforeclosure = BooleanField(default=False)
  aggregated data/booleans/etc...

# "descriptor" table for a property
# there are not often changes to a property's physical traits
ResidentialMasterRecord(Model):
  parcel = CharField(max_length=10, unique=True)  # These are the SAME as OwnershipRecord
  livablesqft = ...
  lotsqft = ...

所以我正在研究一个可以按平方英尺过滤Lead 对象的查询。 Lead 与 OwnershipRecord 相关，但与 ResidentialMasterRecord 没有关系 - 它以“事实表”的形式存在，类似于特定地址的一组坐标。

我认为SubQuery 可以在这种情况下工作，我可以从OwnershipRecord 和ResidentialMasterRecord 中引用parcel 来实时链接两者。

这是非常慢。这是我正在尝试的查询：

from django.db.models import OuterRef, SubQuery
from myapp.models import OwnershipRecord, Lead, ResidentialMasterRecord

RMR_SQ = ResidentialMasterRecord.objects \
           .filter(parcel=OuterRef("ownership_record__parcel"))
qs = Lead.objects.select_related('ownership_record') \
         .annotate(sqft=SubQuery(RMR_SQ.values("livablesqft")[:1])) \
         .filter(sqft__gte=1500)

我正在查看 15-45 分钟范围内的查询时间 - 但我最终会得到结果... 关于如何在保持非外键链接结构的同时加快这件事的任何想法？

---

Django 1.11.8 PostgreSQL 9.5 Droplet 带 8GB RAM，4 核

Answer 1

这个答案是 @bma 和 @wholevinski 的 cmets 灵感的结果。

如Django docs中所述，

在 ForeignKey 上自动创建一个数据库索引。

这个子查询问题的关键是索引 JOIN 字段（在我的问题中又名：parcel）。这很简单，看起来像这样：

class OwnershipRecord(Model):
  parcel = CharField(max_length=10, unique=True,
                     db_index=True)
  owner_name = ...
  other data fields ...

ResidentialMasterRecord(Model):
  parcel = CharField(max_length=10, unique=True,
                     db_index=True)
  livablesqft = ...
  lotsqft = ...

用于此的docs 很少，但很容易实现。

db_index

Field.db_index

如果True，将为该字段创建数据库索引。

结果：我的查询从大约 30 分钟缩短到 1.55 秒。

---

>>> import timeit
>>> from django.db.models import OuterRef, Subquery
>>> from leads.models import Lead
>>> from ownership.models import OwnershipRecord
>>> from mcassessor.models import ResidentialMasterRecord
>>> rmr_sq = ResidentialMasterRecord.objects.filter(parcelid=OuterRef('ownership_record__parcel'))
>>> qs = Lead.objects.select_related('ownership_record').annotate(sqft=Subquery(rmr_sq.values("livablesqft")[:1])).filter(sqft__gte=1700)
>>> toc = timeit.default_timer()
... qs_list = list(qs)
... print(timeit.default_timer() - toc)
[Out] 1.55457401276
>>> len(qs_list)
[Out] 823

Answer 2

(1)即使底层数据库没有fkey关系，也可以在ORM中指定两个表是相关的。
(2) 就像@bma 提到的那样，索引会对性能产生很大影响。

但是，总的来说，我的策略是——将您的子查询分成两个单独的查询，并将一些数据保留在内存中。

例如，

def chunkify(rg, chunk_size=1000):
    while rg:
        yield rg[:chunk_size]
        rg = rg[chunk_size:]

min_sq_footage = 1500
master_records = ResidentialMasterRecords.objects.filter(sqft__gte=min_sq_footage)
parcels = list(master_records.values_list('parcel', flat=True))
for parcel_chunk in chunkify(parcels):
    qs = Lead.objects.select_related('ownership_record').filter(ownership_record__parcel__in=parcel_chunk)
    # do some work