🆕 Version 1.0.0

Added concept of namespace keys for versioning & the ability to group like keys
(for invalidation purposes) group them with a namespace key.
This is likely the last updates to this code before I start using it in
a production environment.

Author: bbelyeu

README.md

@@ -3,7 +3,7 @@ Flask-SQLAlchemy-Caching
 
 This is a fork of (iurisilvio's Flask-SQLAlchemy-Cache)[https://github.com/iurisilvio/Flask-SQLAlchemy-Cache]
 
-A CachingQuery implementation to Flask using Flask-SQLAlchemy and Flask-Cache.
+A CachingQuery implementation to Flask using Flask-SQLAlchemy and Flask-Caching.
 
 To start using caching queries, you just have to replace Flask-SQLAlchemy `Model.query_class`.
 

flask_sqlalchemy_caching/core.py

@@ -1,11 +1,13 @@
 # coding: utf-8
 """Flask-SQLAlchemy-Cache
 
-A SQLAlchemy CachingQuery implementation for Flask, using Flask-Cache.
+A SQLAlchemy CachingQuery implementation for Flask, using Flask-Caching
 
 It is based in SQLAlchemy docs example:
 http://docs.sqlalchemy.org/en/latest/orm/examples.html#module-examples.dogpile_caching
 """
+import random
+import time
 from hashlib import md5
 
 from sqlalchemy.orm.interfaces import MapperOption
@@ -51,16 +53,37 @@ def create_func(): return list(BaseQuery.__iter__(self))
 
     def _get_cache_plus_key(self):
         """Return a cache region plus key."""
-        key = getattr(self, '_cache_key', self.key_from_query())
-        return self._cache.cache, key
+        return self._cache.cache, self._get_key()
+
+    def _get_key(self, ignore_ns=False):
+        """Get the cache key."""
+        key = getattr(self._cache, 'cache_key', None)
+        if key is None:
+            key = self.key_from_query()
+
+        if self._cache.namespace_key and not ignore_ns:
+            ns_val = self._cache.cache.get(self._cache.namespace_key)
+            if not ns_val:
+                # If the namespace key doesn't exist, create it. But start at the current
+                # timestamp plus milliseconds and a 3 digit random number to avoid race
+                # conditions.
+                ns_val = int(time.time() * 1000 + random.randint(0, 999))
+                self._cache.cache.set(self._cache.namespace_key, ns_val)
+            key = 'v{}.{}'.format(ns_val, key)
+
+        return key
 
     def invalidate(self):
         """Invalidate the cache value represented by this Query."""
         cache, cache_key = self._get_cache_plus_key()
         cache.delete(cache_key)
+        if self._cache.namespace_key:
+            cache.incr(self._cache.namespace_key)
+            # Also invalidate if the key exists without a namespace version prepended
+            cache.delete(self._get_key(ignore_ns=True))
 
-    def get_value(self, merge=True, createfunc=None,
-                  expiration_time=None, ignore_expiration=False):
+    def get_value(self, merge=True, createfunc=None, expiration_time=None,
+                  ignore_expiration=False):
         """
         Return the value from the cache for this query.
         """
@@ -112,23 +135,30 @@ def key_from_query(self, qualifier=None):
 
 class _CacheableMapperOption(MapperOption):
 
-    def __init__(self, cache, cache_key=None):
+    def __init__(self, cache, cache_key=None, namespace_key=None):
         """
         Construct a new `_CacheableMapperOption`.
 
-        :param cache: the cache.  Should be a Flask-Cache instance.
+        :param cache: the cache.  Should be a Flask-Caching instance.
 
         :param cache_key: optional.  A string cache key that will serve as
         the key to the query. Use this if your query has a huge amount of
         parameters (such as when using in_()) which correspond more simply to
         some other identifier.
+
+        :param namespace_key: optional.  A string cache key that can be used
+        to group like cache keys. For example, if you are using offset & limit
+        at the db level to paginate rows returned, and a new row is added,
+        instead of invalidating all keys individually, only the namespace_key
+        needs invalidated by incrementing.
         """
         self.cache = cache
         self.cache_key = cache_key
+        self.namespace_key = namespace_key
 
     def __getstate__(self):
         """
-        Flask-Cache instance is not picklable because it has references
+        Flask-Caching instance is not picklable because it has references
         to Flask.app. Also, I don't want it cached.
         """
         d = self.__dict__.copy()

setup.py

@@ -4,12 +4,12 @@
 
 setup(
     name='Flask-SQLAlchemy-Caching',
-    version='0.1.1',
+    version='1.0.0',
     description='CachingQuery implementation to Flask using Flask-SQLAlchemy and Flask-Caching',
     author='Brad Belyeu',
     author_email='bradleylamar@gmail.com',
     url='http://www.github.com/bbelyeu/Flask-SQLAlchemy-Caching',
-    download_url='https://github.com/bbelyeu/Flask-SQLAlchemy-Caching/archive/0.1.1.zip',
+    download_url='https://github.com/bbelyeu/Flask-SQLAlchemy-Caching/archive/1.0.0.zip',
     license='MIT',
     platforms='any',
     packages=['flask_sqlalchemy_caching'],