In Django, given a model instance, how can I determine if a ForeignKey field has been fully hydrated or not?

Question

Context:

I maintain legacy Django code. In many cases my code receives multiple model objects, each of which has a ForeignKey or a manually cached property that represents the same data entity. The data entities referred to thus do not change. However, not all objects I receive have ever accessed those ForeignKey fields or cached properties, so the data may not be present on those objects, though it will be lazy-loaded on first access.

I do not easily have access to/control over the code that declares the models.

I want to find any one of the objects I have which has a primed cache, so that I can avoid hitting the database to retrieve the data I'm after (if none have it, I'll do it if I have to). This is because the fetch of that data is frequent enough that it causes performance issues.

Django 1.6, Python 2.7.

Problem

I can interrogate our manually cached fields and say internal_is_cached(instance, 'fieldname') without running a query. However, I cannot do this with ForeignKey fields.

Say I have a model class in Django, Foo, like so:

class Foo(models.Model):
    bar = models.ForeignKey('BarModel')

Question

If I get an instance of the model Foo from somewhere, but I do not know if bar has ever been called on it, or if it has been eagerly fetched, how do I determine if reading instance.bar will query the database or not?

In other words, I want to externally determine if an arbitrary model has its internal cache primed for a given ForeignKey, with zero other knowledge about the state or source of that model.

What I've Tried

• I tried model caching using the Django cache to make an "end run" around the issue. The fetches of the related data are frequent enough that they caused unsustainable load on our caching systems.

• I tried various solutions from this question. They work well for modified models, but do not seem to work for models which haven't been mutated--I'm interested in the "lazy load" state of a model, not the "pending modification" state. Many of those solutions are also inapplicable since they require changing model inheritance or behavior, which I'd like to avoid if possible (politics).

• This question looked promising, but it requires control over the model initial-reader process. The model objects my code receives could come from anywhere.

  • Doing the reverse of the after-the-fact cache priming described in [this writeup] works for me in testing. However, it relies on the _default_manager internal method of model objects, which is known to be an inaccurate field reference for some of our (highly customized) model objects in production. Some of them are quite weird, and I'd prefer to stick to documented (or at least stable and not frequently bypassed) APIs if possible.

Answer 1

Thanks @Daniel Roseman for the clarification.

With Django version <= 1.6 (working solution in your case)
You can check if your foo_instance has a _bar_cache attribute:

hasattr(foo_instance, "_bar_cache")

Like explained here.

With Django version > 1.6
The cached fields are now stored in the fields_cache dict in the _state attribute:

foo_instance._state.fields_cache["bar"]