Ticket #14299: django-cache-add_many.diff

django/core/cache/backends/base.py

@@ -100 +100 @@
         # if a subclass overrides it.
         return self.has_key(key)
 
+    def add_many(self, data, timeout=None):
+        """
+        Set a bunch of values in the cache at once from a dict of key/value
+        pairs.  For certain backends (memcached), this is much more efficient
+        than calling add() multiple times.
+
+        If timeout is given, that timeout will be used for the key; otherwise
+        the default cache timeout will be used.
+
+        Returns  dict() of key/bool pairs indicating whether or not the values
+        were stored.
+        """
+        results = {}
+        for key, value in data.items():
+            results[key] = self.add(key, value, timeout)
+        return results
+
+    def offset_many(self, data):
+        """
+        Add/Subtract a bunch of values in the cache at once from a dict of
+        key/delta pairs. For certain backends (memcached), this is much more
+        efficient than calling incr()/decr() multiple times.
+        
+        Returna  dict() of key/value pairs containing the new values. Value 
+        is False if the key did not exist.
+        """
+        results = {}
+        for key, value in data.items():
+            try:
+                results[key] = self.incr(key, value)
+            except ValueError:
+                results[key] = False
+        return results
+
     def set_many(self, data, timeout=None):
         """
         Set a bunch of values in the cache at once from a dict of key/value

django/core/cache/backends/dummy.py

@@ -27 +27 @@
         self.validate_key(key)
         return False
 
+    def add_many(self, *args, **kwargs):
+        pass
+    
     def set_many(self, *args, **kwargs):
         pass
 

django/core/cache/backends/memcached.py

@@ -63 +63 @@
         self._cache.disconnect_all()
 
     def incr(self, key, delta=1):
+        # memcached doesn't support a negative delta
+        if delta < 0:
+            return self.decr(key, -delta)
         try:
-            val = self._cache.incr(key, delta)
+            val = self._cache.incr(smart_str(key), delta)
 
         # python-memcache responds to incr on non-existent keys by
         # raising a ValueError. Cmemcache returns None. In both
@@ -77 +80 @@
         return val
 
     def decr(self, key, delta=1):
+        # memcached doesn't support a negative delta
+        if delta < 0:
+            return self.incr(key, -delta)
         try:
-            val = self._cache.decr(key, delta)
+            val = self._cache.decr(smart_str(key), delta)
 
         # python-memcache responds to decr on non-existent keys by
         # raising a ValueError. Cmemcache returns None. In both

docs/topics/cache.txt

@@ -594 +594 @@
 
 Like ``cache.set()``, ``set_many()`` takes an optional ``timeout`` parameter.
 
+.. versionadded:: 1.3
+
+To add multiple values more efficiently, use ``add_many()`` to pass a dictionary
+of key-value pairs. ``add_many()`` returns a dictionary with all the keys passed
+and their values being a bool indicating whether or not the value was added::
+
+        >>> cache.set('a', 1)
+        >>> cache.add_many({'a': 2, 'b': 1})
+        {'a': False, 'b': 1}
+
 You can delete keys explicitly with ``delete()``. This is an easy way of
 clearing the cache for a particular object::
 
@@ -641 +651 @@
     However, if the backend doesn't natively provide an increment/decrement
     operation, it will be implemented using a two-step retrieve/update.
 
+.. versionadded:: 1.3
+
+To increment and decrement multiple values more efficiently, use 
+``offset_many()`` to pass a dictionary of key-value pairs, where the value is
+the delta you would like apply to the existing value. ``offset_many()`` 
+returns a dictionary with all the keys passed and their new value. If a key is
+not found or there was an error, its value will be False::
+
+        >>> cache.set_many({'a': 10, 'b': 10})
+        >>> cache.offset_many({'a': 1, 'b': -1, 'c': 1})
+        {'a': 11, 'b': 9, 'c': False}
+
+
+
 Cache key warnings
 ------------------
 

tests/regressiontests/cache/tests.py

@@ -132 +132 @@
             self.cache.set(key, value)
             self.assertEqual(self.cache.get(key), None)
 
+    def test_add_many(self):
+        "add_many does nothing for the dummy cache backend"
+        self.cache.add_many({'a': 1, 'b': 2})
+
+    def test_offset_many(self):
+        "offset_many does nothing for the dummy cache backend"
+        results = self.cache.offset_many({'a': 1, 'b': -1})
+        self.assertEqual(results['a'], False)
+        self.assertEqual(results['b'], False)
+
     def test_set_many(self):
         "set_many does nothing for the dummy cache backend"
         self.cache.set_many({'a': 1, 'b': 2})
@@ -206 +216 @@
         self.assertEqual(self.cache.incr('answer', 10), 52)
         self.assertEqual(self.cache.get('answer'), 52)
         self.assertRaises(ValueError, self.cache.incr, 'does_not_exist')
+        self.assertEqual(self.cache.incr('answer', -10), 42)
 
     def test_decr(self):
         # Cache values can be decremented
@@ -215 +226 @@
         self.assertEqual(self.cache.decr('answer', 10), 32)
         self.assertEqual(self.cache.get('answer'), 32)
         self.assertRaises(ValueError, self.cache.decr, 'does_not_exist')
+        self.assertEqual(self.cache.decr('answer', -10), 42)
 
     def test_data_types(self):
         # Many different data types can be cached
@@ -306 +318 @@
         self.assertEqual(compressed_value, compressed_result)
         self.assertEqual(value, decompress(compressed_result))
 
+    def test_add_many(self):
+        # Multiple keys can be added using add_many
+        data = {"addmany1": "one", "addmany2": "two"}
+        self.cache.add_many(data)
+        results = self.cache.add_many({"addmany1": "a", "addmany2": "b"})
+        for key, result in results.items():
+            self.assertEqual(result, False)
+            self.assertEqual(self.cache.get(key), data.get(key))
+
+    def test_add_many_expiration(self):
+        # add_many takes a second ``timeout`` parameter
+        
+        # ensure keys do not exist, otherwise timeout may not be set
+        self.cache.delete_many(["addmany1", "addmany2"])
+        self.cache.add_many({"addmany1": "one", "addmany2": "two"}, 1)
+        time.sleep(2)
+        self.assertEqual(self.cache.get("addmany1"), None)
+        self.assertEqual(self.cache.get("addmany2"), None)
+
+    def test_offset_many(self):
+        # Multiple keys can be incremented or decremented using offset_many
+        self.cache.set("offset1", 10)
+        self.cache.set("offset2", 10)
+        self.cache.delete("offset3")        
+        results = self.cache.offset_many({
+            "offset1" : 1,
+            "offset2" : -1,
+            "offset3" : 1,
+        })
+        self.assertEqual(results.get("offset1"), 11)
+        self.assertEqual(results.get("offset2"), 9)
+        self.assertEqual(results.get("offset3"), False)
+
     def test_set_many(self):
         # Multiple keys can be set using set_many
         self.cache.set_many({"key1": "spam", "key2": "eggs"})