Question

How can I prevent Django, for testing purposes, from automatically fetching related tables not specified in the select_related() call during the intial query?

I have a large application where I make significant use of
select_related() to bring in related model data during each original
query. All select_related() calls are used to specify the specific related models, rather than relying on the default, e.g. select_related(‘foo’, ‘bar’, ‘foo__bar’)

As the application has grown, the select_related calls haven’t
completely kept up, leaving a number of scenarios where Django happily
and kindly goes running off to the database to fetch related model
rows. This significantly increases the number of database hits, which
I obviously don’t want.

I’ve had some success in tracking these down by checking the queries
generated using the django.db.connection.queries collection, but some
remain unsolved.

I’ve tried to find a suitable patch location in the django code to raise an
exception in this scenario, making the tracking much easier, but tend
to get lost in the code.

Thanks.

Answer 1

After some more digging, I’ve found the place in the code to do this.

The file in question is django/db/models/fields/related.py

You need to insert two lines into this file.

Locate class “SingleRelatedObjectDescriptor”. You need to change the function __get__() as follows:

def __get__(self, instance, instance_type=None):
    if instance is None:
        return self
    try:
        return getattr(instance, self.cache_name)
    except AttributeError:
        raise Exception("Automated Database Fetch on %s.%s" % (instance._meta.object_name, self.related.get_accessor_name()))
        # leave the old code here for when you revert!

Similarly, in class “ReverseSingleRelatedObjectDescriptor” further down the code, you again need to change __get__() to:

def __get__(self, instance, instance_type=None):
    if instance is None:
        return self

    cache_name = self.field.get_cache_name()
    try:
        return getattr(instance, cache_name)
    except AttributeError:
        raise Exception("Automated Database Fetch on %s.%s" % (instance._meta.object_name, self.field.name))
        # BEWARE: % parameters are different to previous class
        # leave old code here for when you revert

Once you’ve done this, you’ll find that Django raises an exception every time it performs an automatic database lookup. This is pretty annoying when you first start, but it will help you track down those pesky database lookups. Obviously, when you’ve found them all, it’s probably best to revert the database code back to normal. I would only suggest using this during a debugging/performance investigation phase and not in the live production code!