1

假设我有两个相关的模型

class Foo(models.Model):
    value = models.FloatField()

class Bar(models.Model):
    multiplier = models.FloatField()
    foo = models.ForeignKey(Foo, related_name="bars")

    def multiply(self):
        return self.foo.value * self.multiplier

一个 Foo 的实例通常会有很多 Bar 的实例，但一些与 Bar 所做的计算相关的信息存储在 Foo 中（因为它对于相关 Bars 的所有实例都是相同的）

问题是当我做这样的事情时：

foo = Foo.objects.latest()
[x.multiply() for x in foo.bars.all()]

它最终会大量访问数据库，因为 foo.bars.all() 中的每个 Bar 对象都在数据库中查询 Foo 对象。因此，如果我有 10 个 Bar，那么我将产生 11 个数据库查询（1 个用于获取具有 10 个 bar 的查询集，1 个用于返回获取 self.foo.value 的每个 Bar 对象）。使用 select_related() 似乎没有帮助。

我的问题是：1）我认为memcached（例如Johnny Cache，Cache Machine）会解决这个问题是否正确？2）有没有一种设计对象关系的方法，可以在没有缓存的情况下使命令更高效？

4

1 回答 1

3

正是为了这种情况而select_related创造prefetch_related了这种情况。当您使用这些查询时，Django 的 ORM 将采用以下两种技术之一来避免冗余数据库请求：通过 JOIN ( select_related) 跟踪关系或在其 QuerySets 中预缓存一对多/多对多关系。

# Hits the database
foo = Foo.objects.prefetch_related('bars').latest()

# Doesn't hit the database
[x.value for x in foo.bars.all()]
于 2013-05-30T23:36:51.097 回答