Generic DB caching in Google App Engine

In my previous post, I described a caching solution based on subclassing the db.ReferenceProperty class. This time I want to take this one step further and implement this on the lower level API: apiproxy_stub_map.apiproxy.

You can add hooks to the datastore, as I already showed in a previous (profiling) post. However, in order to return a cached entity instead of one retrieved from the datastore, we need more than a PreCall hook. From a PreCall hook will can not prevent the actual datastore call being made. Maybe we can “trick” MakeSyncCall by removing the keys from the argument list, but that is not a road I want to explore…

So, we need to replace the actual apiproxy.MakeSyncCall. Please be aware that there already may be references to the original MakeSyncCall, as described in this post. For our caching solution, this is not a real problem: the worst thing that could happen, is that there will be no caching. So, the app will be slower, but still functioning the same…

Replacing a registered datastore Stub

Replacing the registered datastore stub may seem like the way to go, if you want to wrap the datastore_v3 call. However, registering a stub is allowed only when there is no stub registered yet. And, you guessed it, in production there is already a stub present. This method therefore, is only useful for unit testing and not for production. We could replace the global MakeSyncCall, but then we add overhead for every remote call, which is something I do not prefer.

Replacing db.get

If we want to retrieve a model by using a key or key_name, all calls to the datastore are implemented using the global module function db.get. So, if we can wrap this call with a caching function, we’re done. Here’s the solution I came up with:

# define a global, weakly referenced CACHE...
_cache = weakref.WeakValueDictionary({})

def getCached(real_func, keys):
    real_keys, multiple = datastore.NormalizeAndTypeCheckKeys(keys)
    if multiple: # too difficult for now ;-)
        return real_func(keys)

    real_key = real_keys[0]
    instance = _cache.get(real_key, None)
    if instance:
        return instance
    model = real_func(keys)
    if model:
        _cache[real_key] = model
    return model

# Patch db.get
from functools import partial
db.get = partial(getCached, db.get)

A global function getCached is defined, which wraps the original db.get function. First, we check whether the function is called for multiple keys. If that is the case, we simply call the original function (implementing this would be too much code for this example). Otherwise, we check whether the key is already present in cache. If so we return that value, otherwise the real db.get is called and the result is added to the cache.

Query results

How about query results? Are they added to the cache as well? Unfortunately, they are not. When query results are fetched, the entire entity is retrieved at once, so there is no need to get the values by key. It would be nice if we could add the retrieved entities to the cache, so that we don’t have to retrieve them again for a ReferenceProperty value.

This turns out to be more difficult. We could subclass db.Query (and db.GqlQuery) so that we could implement a different iterator (a caching subclass of db._QueryIterator), but that seems a bit tedious. Besides, we would have to override more functions, since the model values are not always retrieved using the iterator. The fetch function, for example, uses a map function to run the entities over the Model.from_entity function.

Replacing Model.from_entity

Given the fact that entities are converted to Model instances by the Model.from_entity function, gives us a nice hook to implement a caching strategy, doesn’t it?

All we have to do, is subclass db.Model and re-implement the from_entity function:

class CachingModel(db.Model):

    @classmethod
    def from_entity(cls, entity):
        model = super(CachingModel,cls).from_entity(entity)
        if model:
            _cache[model.key()] = model
        return model

The resulting CachingModel class is the one we subclass to implement our business models, like this:

class Team(CachingModel):
    club     = db.ReferenceProperty(Club)
    naam     = db.StringProperty()
    poule    = db.ReferenceProperty(Poule)

If we add all model instances to the cache in the from_entity function, we can remove that from our global getCached function…

def getCached(real_func, keys):
    real_keys, multiple = datastore.NormalizeAndTypeCheckKeys(keys)
    if multiple: # too difficult for now ;-)
        return real_func(keys)

    real_key = real_keys[0]
    instance = _cache.get(real_key, None)
    if instance:
        return instance
    model = real_func(keys)
#   if model:
#       _cache[real_key] = model
    return model

We now have a complete, in-memory, caching solution, which can enhance our application performance significantly with a minimal effort!

Advertisement