Ensure queryset is cached

Question

I am calling a function that starts a process that takes longer to execute, many different things are done. This function chiefly handles instances of a particular class, Item. These items are categorized by different attributes: category1, category2 and category3.

Now, there is a different model that applies some sort of rules to these categories: Rule with many-to-many attributes: categories1, categories2 and categories3. A rule applies to an Item, if the same rule points to different categories, only one of them should be applied. The decision of which one is defined by a certain logic encapsulated in a function:

class Rule(models.Model):
    warehouse = models.ForeignKey('Warehouse')
    categories1 = models.ManyToManyField('Category1')
    categories2 = models.ManyToManyField('Category2')
    categories3 = models.ManyToManyField('Category3')

    @staticmethod
    def get_rules_that_applies(item):
        rules = warehouse.rule_set.all()
        if not rules.exists():
            return None
        # ... determine which rule applies to the item by filtering, etc.
        return rule

The issue lies in the get_rules_that_applies method. Every time we need to get the rule that applies to a certain item and let me say again that many many items are involved in the process we are talking about, warehouse.rule_set.all() is called.

Since the rules will not change during this process, we can just cache all the rules in the ware house, but how? How can I make sure warehouse = warehouse.rule_set.all() is cached and all filtering and QuerySet operations that act on these rules are not hitting the database?

Answer 1

I believe that the solution you are seeking is the memoization of the get_rules_that_applies method.

There is a tool ready-made for that, called django-memoize and those are its docs.

Quick-start on usage:

1. pip install django-memoize

2. Place it on your INSTALLED_APPS

   INSTALLED_APPS = [
       '...',
       'memoize',
   ]
   

3. In your model.py:

   from memoize import memoize
   
   class Rule(models.Model):
       warehouse = models.ForeignKey('Warehouse')
       categories1 = models.ManyToManyField('Category1')
       categories2 = models.ManyToManyField('Category2')
       categories3 = models.ManyToManyField('Category3')
   
       @staticmethod
       @memoize(timeout=something_reasonable_in_seconds)
       def get_rules_that_applies(item):
           rules = warehouse.rule_set.all()
           if not rules.exists():
               return None
              # ... determine which rule applies to the item by filtering, etc.
           return rules
   

---

(Update) A Semi-DIY Approach:

Since my answer, I read the following post: https://www.peterbe.com/plog/cache_memoize-cache-decorator-for-django which is accompanied by a gist on how to achieve memoization yourself.

---

A More DIY Approach:

Python 3.2 and up:

The @functools.lru_cache decorator which is a:

Decorator to wrap a function with a memoizing callable that saves up to the maxsize most recent calls. It can save time when an expensive or I/O bound function is periodically called with the same arguments.

How to use it:

from functools import lru_cache


class Rule(models.Model):
    ...

    @lru_cache(maxsize=a_reasonable_integer_size_of_cache)
    def get_rules_that_applies(item):
        rules = warehouse.rule_set.all()
        if not rules.exists():
            return None
            # ... determine which rule applies to the item by filtering, etc.
        return rules

maxsize: Defines the size of the cache in function calls to be stored. It can be set to None to cache every call.

Python < 3.2

In here What is memoization and how can I use it in Python? exist a more "old school" approach.

---

How to cache a queryset with either of the above methods:

Why not define an intermediate function to form the queryset and cache that functions results?

@lru_cache(maxsize=None)

or 

@memoize()
def middle_function():
    return warehouse.rule_set.all()

and then in your get_rules_that_applies function:

def get_rules_that_applies(item):
    rules = middle_function()

Answer 2

You have 2 option:

1. cache the item in the view
2. cahce the item in the model

The code will be the same in view and in the model, Import cahce:

from django.core.cache import cache

Code:

if cache.get('query_result') is not None:
    return cache.get('query_result')
else:
    cache.set('query_result', result, 3600)
    #cache.set('cache_name', 'your query', 'expiry time')
    return rule

Your model will be:

class Rule(models.Model):
warehouse = models.ForeignKey('Warehouse')
categories1 = models.ManyToManyField('Category1')
categories2 = models.ManyToManyField('Category2')
categories3 = models.ManyToManyField('Category3')

@staticmethod
def get_rules_that_applies(item):
    rules = warehouse.rule_set.all()
    if not rules.exists():
        return None
    # ... determine which rule applies to the item by filtering, etc.
    if cache.get('query_result') is not None:
        return cache.get('query_result')
    else:
        cache.set('query_result', result, 3600)
        #cache.set('cache_name', 'your query', 'expiry time')
        return rule

    return rule

Few info about Django query, When they are evaluated?:

https://docs.djangoproject.com/en/1.11/ref/models/querysets/#when-querysets-are-evaluated

Hope this help