Implement simple caching option

Author: shosca

django_sorcery/db/__init__.py

@@ -144,6 +144,7 @@
 from __future__ import absolute_import, print_function, unicode_literals
 
 from .sqlalchemy import SQLAlchemy  # noqa
+from .strategy_options import FromCache  # noqa
 from .utils import dbdict
 
 

django_sorcery/db/query.py

@@ -53,6 +53,13 @@ class Query(sa.orm.Query):
     A customized sqlalchemy query
     """
 
+    def __init__(self, entities, session=None):
+        ents = entities if isinstance(entities, (list, tuple)) else (entities,)
+        ent_zero = next(iter(ents), None)
+        ent_zero = getattr(ent_zero, "class_", ent_zero)
+        self.caching_option = getattr(ent_zero, "__caching_option__", None) or None
+        super(Query, self).__init__(entities, session=session)
+
     def get(self, *args, **kwargs):
         """
         Return an instance based on the given primary key identifier, either as args or
@@ -121,6 +128,22 @@ def _lookup_to_expression(self, lookup, value):
 
         return lhs == value
 
+    def __iter__(self):
+        """
+        override __iter__ to pull results from caching option
+        """
+        super_ = super(Query, self)
+
+        if self.caching_option:
+            return self.caching_option.get(super_)
+        else:
+            return super_.__iter__()
+
+    def invalidate(self):
+        """Invalidate the cache value represented by this Query."""
+        if self.caching_option:
+            self.caching_option.invalidate(self)
+
 
 class QueryProperty(object):
     def __init__(self, db, model=None, *args, **kwargs):

django_sorcery/db/strategy_options.py

@@ -0,0 +1,75 @@
+# -*- coding: utf-8 -*-
+from __future__ import absolute_import, print_function, unicode_literals
+
+from sqlalchemy.orm.interfaces import MapperOption
+
+from django.core.exceptions import ImproperlyConfigured
+
+
+def _key_from_query(query):
+    """
+    Given a Query, create a cache key.
+
+    There are many approaches to this; here we use the simplest, which is to create an md5 hash of the text of the SQL
+    statement, combined with stringified versions of all the bound parameters within it. There's a bit of a
+    performance hit with compiling out "query.statement" here; other approaches include setting up an explicit cache
+    key with a particular Query, then combining that with the bound parameter values.
+    """
+
+    stmt = query.with_labels().statement
+    compiled = stmt.compile()
+    params = compiled.params
+    return " ".join([str(compiled)] + [str(params[k]) for k in sorted(params)])
+
+
+class FromCache(MapperOption):
+    """Specifies that a Query should load results from a cache."""
+
+    propagate_to_loaders = False
+
+    def __init__(self, region, expiration_time=None, key_maker=_key_from_query):
+        """
+        Provides caching mechanism for a query
+        --------------------------------------
+
+        region: any
+            The cache region. Can be a dogpile.cache region object
+
+        expiration_time: int or datetime.timedelta
+            The expiration time that will be passed to region.
+
+        keymaker: callable
+            A callable that will take the query and generate a cache key out of it.
+
+        Note that this approach does *not* detach the loaded objects from the current session. If the cache backend is
+        an in-process cache (like "memory") and lives beyond the scope of the current session's transaction, those
+        objects may be expired. The method here can be modified to first expunge() each loaded item from the current
+        session before returning the list of items, so that the items in the cache are not the same ones in the
+        current Session.
+        """
+        if region is None:
+            raise ImproperlyConfigured("FromCache requires a cache region")
+        self.expiration_time = expiration_time
+        self.key_maker = key_maker
+        self.region = region
+
+    def process_query(self, query):
+        """Process a Query during normal loading operation."""
+        query.caching_option = self
+
+    def get(self, query, merge=True, createfunc=None):
+        """
+        Return the value from the cache for this query.
+        """
+        createfunc = query.__iter__
+        cache_key = self.key_maker(query)
+        cached_value = self.region.get_or_create(
+            cache_key, lambda: list(createfunc()), expiration_time=self.expiration_time
+        )
+        if merge:
+            cached_value = query.merge_result(cached_value, load=False)
+        return cached_value
+
+    def invalidate(self, query):
+        cache_key = self.key_maker(query)
+        self.region.delete(cache_key)

tests/db/test_strategy_options.py

@@ -0,0 +1,93 @@
+# -*- coding: utf-8 -*-
+from __future__ import absolute_import, print_function, unicode_literals
+
+import pytest
+
+from django.core.exceptions import ImproperlyConfigured
+
+from django_sorcery.db import FromCache
+from django_sorcery.pytest_plugin import sqlalchemy_profiler  # noqa
+
+from ..testapp.models import CachedModel, CachedReference, OtherCachedModel, Owner, UnCachedModel, cache, db
+
+
+def test_without_region():  # noqa
+
+    with pytest.raises(ImproperlyConfigured):
+        Owner.objects.options(FromCache(None)).filter_by(first_name="foo").one_or_none()
+
+
+def test_from_cache_option(sqlalchemy_profiler):  # noqa
+    db.add(Owner(first_name="foo", last_name="bar"))
+    db.flush()
+    db.expire_all()
+    cache.cache.clear()
+
+    with sqlalchemy_profiler:
+        Owner.objects.options(FromCache(cache)).filter_by(first_name="foo").one_or_none()
+
+        assert sqlalchemy_profiler.stats["select"] == 1
+        assert len(cache.cache) == 1
+
+    with sqlalchemy_profiler:
+        Owner.objects.options(FromCache(cache)).filter_by(first_name="foo").one_or_none()
+
+        assert sqlalchemy_profiler.stats["select"] == 0
+        assert len(cache.cache) == 1
+
+    FromCache(cache).invalidate(Owner.objects.options(FromCache(cache)).filter_by(first_name="foo"))
+    assert len(cache.cache) == 0
+
+    with sqlalchemy_profiler:
+        Owner.objects.options(FromCache(cache)).filter_by(first_name="foo").one_or_none()
+        assert sqlalchemy_profiler.stats["select"] == 1
+        assert len(cache.cache) == 1
+
+    Owner.objects.options(FromCache(cache)).filter_by(first_name="foo").invalidate()
+    assert len(cache.cache) == 0
+
+
+def test_model_cache_option(sqlalchemy_profiler):  # noqa
+    instance = UnCachedModel(
+        cached=CachedModel(name="cached"),
+        other_cached=[OtherCachedModel(name="other cached 1"), OtherCachedModel(name="other cached 2")],
+        references=[CachedReference(name="ref1"), CachedReference(name="ref2")],
+    )
+
+    db.add(instance)
+    db.flush()
+    pk = instance.pk
+    cached_pk = instance.cached.pk
+    db.expire_all()
+    cache.cache.clear()
+
+    with sqlalchemy_profiler:
+        instance = CachedModel.objects.get(cached_pk)
+        assert sqlalchemy_profiler.stats["select"] == 1
+        assert len(cache.cache) == 1
+
+    with sqlalchemy_profiler:
+        instance = CachedModel.objects.get(cached_pk)
+        assert sqlalchemy_profiler.stats["select"] == 0
+        assert len(cache.cache) == 1
+
+    instance = UnCachedModel.objects.filter_by(pk=pk).one()
+    db.refresh(instance)
+    with sqlalchemy_profiler:
+        assert instance.cached.pk == cached_pk
+        assert sqlalchemy_profiler.stats["select"] == 0
+        assert len(cache.cache) == 1  # many-to-one cached
+
+    instance = UnCachedModel.objects.filter_by(pk=pk).one()
+    db.refresh(instance)
+    with sqlalchemy_profiler:
+        assert len(instance.other_cached) == 2
+        assert sqlalchemy_profiler.stats["select"] == 1
+        assert len(cache.cache) == 1  # one-to-many not cached
+
+    instance = UnCachedModel.objects.filter_by(pk=pk).one()
+    db.refresh(instance)
+    with sqlalchemy_profiler:
+        assert len(instance.references) == 2
+        assert sqlalchemy_profiler.stats["select"] == 1
+        assert len(cache.cache) == 1  # many-to-many not cached

tests/testapp/models.py

@@ -7,7 +7,7 @@
 from django.core.exceptions import ValidationError
 from django.core.validators import RegexValidator
 
-from django_sorcery.db import databases
+from django_sorcery.db import FromCache, databases
 from django_sorcery.db.models import autocoerce, autocoerce_properties
 from django_sorcery.db.query import Query
 from django_sorcery.validators import ValidateTogetherModelFields, ValidateUnique
@@ -16,6 +16,23 @@
 db = databases.get("test")
 
 
+class DummyCache(object):
+    def __init__(self):
+        self.cache = {}
+
+    def get_or_create(self, key, func, **kwargs):
+        if key not in self.cache:
+            self.cache[key] = func()
+
+        return self.cache[key]
+
+    def delete(self, key):
+        del self.cache[key]
+
+
+cache = DummyCache()
+
+
 COLORS = ["", "red", "green", "blue", "silver", "pink"]
 
 
@@ -262,6 +279,36 @@ def clean(self, **kwargs):
         raise ValidationError("bad model")
 
 
+class CachedModel(db.Model):
+    __caching_option__ = FromCache(cache)
+
+    pk = db.IntegerField(autoincrement=True, primary_key=True)
+    name = db.CharField()
+
+
+class OtherCachedModel(db.Model):
+    __caching_option__ = FromCache(cache)
+
+    pk = db.IntegerField(autoincrement=True, primary_key=True)
+    name = db.CharField()
+
+
+class CachedReference(db.Model):
+    __caching_option__ = FromCache(cache)
+
+    pk = db.IntegerField(autoincrement=True, primary_key=True)
+    name = db.CharField()
+
+
+class UnCachedModel(db.Model):
+    pk = db.IntegerField(autoincrement=True, primary_key=True)
+    name = db.CharField()
+
+    cached = db.ManyToOne(CachedModel, backref=db.backref("uncached"))
+    other_cached = db.OneToMany(OtherCachedModel, backref=db.backref("uncached"))
+    references = db.ManyToMany(CachedReference, table_name="uncached_refs", backref=db.backref("uncached"))
+
+
 class ValidateUniqueModel(db.Model):
     pk = db.IntegerField(autoincrement=True, primary_key=True)
     name = db.CharField()