如何强制 Django 忽略任何缓存并重新加载数据？

Question

我正在使用来自未从 HTTP 请求调用的进程的 Django 数据库模型。该过程应该每隔几秒钟轮询一次新数据并对其进行一些处理。我有一个循环休眠几秒钟，然后从数据库中获取所有未处理的数据。

我看到的是，在第一次提取之后，该进程再也看不到任何新数据。我进行了一些测试，看起来 Django 正在缓存结果，即使我每次都在构建新的 QuerySet。为了验证这一点，我从 Python shell 中执行了此操作：

>>> MyModel.objects.count()
885
# (Here I added some more data from another process.)
>>> MyModel.objects.count()
885
>>> MyModel.objects.update()
0
>>> MyModel.objects.count()
1025

如您所见，添加新数据不会改变结果计数。但是，调用管理器的 update() 方法似乎可以解决问题。

我找不到有关该 update() 方法的任何文档，也不知道它可能会做什么其他坏事。

我的问题是，为什么我会看到这种缓存行为，这与 Django docs 所说的相矛盾？以及如何防止它发生？

Answer 1

似乎count() 在第一次之后进入缓存。这是 QuerySet.count 的 django 源代码：

def count(self):
    """
    Performs a SELECT COUNT() and returns the number of records as an
    integer.

    If the QuerySet is already fully cached this simply returns the length
    of the cached results set to avoid multiple SELECT COUNT(*) calls.
    """
    if self._result_cache is not None and not self._iter:
        return len(self._result_cache)

    return self.query.get_count(using=self.db)

update 似乎确实做了很多额外的工作，除了你需要的。
但是我想不出任何更好的方法来做到这一点，除了编写自己的 SQL 进行计数。
如果性能不是非常重要，我会照你的做，在count 之前调用update。

QuerySet.update:

def update(self, **kwargs):
    """
    Updates all elements in the current QuerySet, setting all the given
    fields to the appropriate values.
    """
    assert self.query.can_filter(), \
            "Cannot update a query once a slice has been taken."
    self._for_write = True
    query = self.query.clone(sql.UpdateQuery)
    query.add_update_values(kwargs)
    if not transaction.is_managed(using=self.db):
        transaction.enter_transaction_management(using=self.db)
        forced_managed = True
    else:
        forced_managed = False
    try:
        rows = query.get_compiler(self.db).execute_sql(None)
        if forced_managed:
            transaction.commit(using=self.db)
        else:
            transaction.commit_unless_managed(using=self.db)
    finally:
        if forced_managed:
            transaction.leave_transaction_management(using=self.db)
    self._result_cache = None
    return rows
update.alters_data = True

Answer 2

您还可以在执行任何工作之前使用MyModel.objects._clone().count(). QuerySet 调用_clone() 中的所有方法 - 确保任何内部缓存都无效。

根本原因是MyModel.objects 每次都是同一个实例。通过克隆它，您将创建一个没有缓存值的新实例。当然，如果您希望使用相同的实例，您可以随时访问缓存并使缓存无效。

Answer 3

我们在强制 django 刷新“缓存”方面付出了相当大的努力——事实证明，这根本不是缓存，而是由于事务的产物。这可能不适用于您的示例，但肯定在 django 视图中，默认情况下，有一个对事务的隐式调用，然后 mysql 将其与您启动时其他进程发生的任何更改隔离开来。

我们使用了@transaction.commit_manually 装饰器，并在您需要最新信息的每个场合之前调用transaction.commit()。

正如我所说，这绝对适用于视图，不确定它是否适用于不在视图内运行的 django 代码。

这里有详细信息：

http://devblog.resolversystems.com/?p=439

Answer 4

遇到这个问题并找到了两个明确的解决方案，我认为值得发布另一个答案。

这是 MySQL 默认事务模式的问题。 Django 在开始时会打开一个事务，这意味着默认情况下您不会看到数据库中所做的更改。

这样展示

在终端 1 中运行 django shell

>>> MyModel.objects.get(id=1).my_field
u'old'

另一个在 2 号航站楼

>>> MyModel.objects.get(id=1).my_field
u'old'
>>> a = MyModel.objects.get(id=1)
>>> a.my_field = "NEW"
>>> a.save()
>>> MyModel.objects.get(id=1).my_field
u'NEW'
>>> 

回到终端 1 来演示问题 - 我们仍然从数据库中读取旧值。

>>> MyModel.objects.get(id=1).my_field
u'old'

现在在终端1演示解决方案

>>> from django.db import transaction
>>> 
>>> @transaction.commit_manually
... def flush_transaction():
...     transaction.commit()
... 
>>> MyModel.objects.get(id=1).my_field
u'old'
>>> flush_transaction()
>>> MyModel.objects.get(id=1).my_field
u'NEW'
>>> 

现在读取新数据

这是带有文档字符串的易于粘贴块中的代码

from django.db import transaction

@transaction.commit_manually
def flush_transaction():
    """
    Flush the current transaction so we don't read stale data

    Use in long running processes to make sure fresh data is read from
    the database.  This is a problem with MySQL and the default
    transaction mode.  You can fix it by setting
    "transaction-isolation = READ-COMMITTED" in my.cnf or by calling
    this function at the appropriate moment
    """
    transaction.commit()

另一种解决方案是更改my.cnf for MySQL以更改默认事务模式

transaction-isolation = READ-COMMITTED

请注意，这是 Mysql 的一个相对较新的功能，并且有 some consequences for binary logging / slaving。如果你愿意，你也可以把它放在 django 连接序言中。

3 年后更新

现在 Django 1.6 有 turned on autocommit in MySQL 这不再是问题。上面的示例现在可以在没有 flush_transaction() 代码的情况下正常工作，无论您的 MySQL 处于 REPEATABLE-READ（默认）还是 READ-COMMITTED 事务隔离模式。

在非自动提交模式下运行的以前版本的 Django 中发生的情况是第一个 select 语句打开了一个事务。由于 MySQL 的默认模式是 REPEATABLE-READ，这意味着后续的 select 语句将不会读取数据库更新 - 因此需要上面的 flush_transaction() 代码来停止事务并启动新事务。

尽管如此，您可能仍需要使用READ-COMMITTED 事务隔离的原因。如果您要将终端 1 放入事务中，并且希望查看终端 2 的写入，则需要 READ-COMMITTED。

flush_transaction() 代码现在会在 Django 1.6 中产生弃用警告，因此我建议您将其删除。

Answer 5

我不确定我是否会推荐它......但你可以自己杀死缓存：

>>> qs = MyModel.objects.all()
>>> qs.count()
1
>>> MyModel().save()
>>> qs.count()  # cached!
1
>>> qs._result_cache = None
>>> qs.count()
2

这是一种更好的技术，它不依赖于摆弄 QuerySet 的内部结构：请记住，缓存发生在 QuerySet 中，但刷新数据只需要底层 查询 重新执行。 QuerySet 实际上只是一个包装 Query 对象的高级 API，外加一个用于 Query 结果的容器（带有缓存！）。因此，给定一个查询集，这是一种强制刷新的通用方法：

>>> MyModel().save()
>>> qs = MyModel.objects.all()
>>> qs.count()
1
>>> MyModel().save()
>>> qs.count()  # cached!
1
>>> from django.db.models import QuerySet
>>> qs = QuerySet(model=MyModel, query=qs.query)
>>> qs.count()  # refreshed!
2
>>> party_time()

很简单！您当然可以将其实现为辅助函数并根据需要使用。

Answer 6

如果您将.all() 附加到查询集，它将强制从数据库中重新读取。尝试 MyModel.objects.all().count() 而不是 MyModel.objects.count()。