Add support for hashmaps

django_redis/cache.py

@@ -184,3 +184,23 @@ def close(self, **kwargs):
     @omit_exception
     def touch(self, *args, **kwargs):
         return self.client.touch(*args, **kwargs)
+
+    @omit_exception
+    def hset(self, *args, **kwargs):
+        return self.client.hset(*args, **kwargs)
+
+    @omit_exception
+    def hdel(self, *args, **kwargs):
+        return self.client.hdel(*args, **kwargs)
+
+    @omit_exception
+    def hlen(self, *args, **kwargs):
+        return self.client.hlen(*args, **kwargs)
+
+    @omit_exception
+    def hkeys(self, *args, **kwargs):
+        return self.client.hkeys(*args, **kwargs)
+
+    @omit_exception
+    def hexists(self, *args, **kwargs):
+        return self.client.hexists(*args, **kwargs)

django_redis/client/default.py

@@ -813,3 +813,73 @@ def touch(
         # Convert to milliseconds
         timeout = int(timeout * 1000)
         return bool(client.pexpire(key, timeout))
+
+    def hset(
+        self,
+        name: str,
+        key: Any,
+        value: Any,
+        version: Optional[int] = None,
+        client: Optional[Redis] = None,
+    ) -> int:
+        """
+        Set the value of hash name at key to value.
+        """
+        if client is None:
+            client = self.get_client(write=True)
+        key = self.make_key(key, version=version)
+        return int(client.hset(name, key, value))
+
+    def hdel(
+        self,
+        name: str,
+        key: Any,
+        version: Optional[int] = None,
+        client: Optional[Redis] = None,
+    ) -> int:
+        """
+        Remove keys from hash name.
+        """
+        if client is None:
+            client = self.get_client(write=True)
+        key = self.make_key(key, version=version)
+        return int(client.hdel(name, key))
+
+    def hlen(
+        self,
+        name: str,
+        client: Optional[Redis] = None,
+    ) -> int:
+        """
+        Return the number of items in hash name.
+        """
+        if client is None:
+            client = self.get_client(write=False)
+        return int(client.hlen(name))
+
+    def hkeys(
+        self,
+        name: str,
+        client: Optional[Redis] = None,
+    ) -> List:
+        """
+        Return a list of keys in hash name.
+        """
+        if client is None:
+            client = self.get_client(write=False)
+        return client.hkeys(name)
+
+    def hexists(
+        self,
+        name: str,
+        key: Any,
+        version: Optional[int] = None,
+        client: Optional[Redis] = None,
+    ) -> bool:
+        """
+        Return True if key exists in hash name, else False.
+        """
+        if client is None:
+            client = self.get_client(write=False)
+        key = self.make_key(key, version=version)
+        return bool(client.hexists(name, key))

tests/test_backend.py

@@ -797,3 +797,38 @@ def test_clear(self, cache: RedisCache):
         cache.clear()
         value_from_cache_after_clear = cache.get("foo")
         assert value_from_cache_after_clear is None
+
+    def test_hset(self, cache: RedisCache):
+        cache.hset("foo_hash1", "foo1", "bar1")
+        cache.hset("foo_hash1", "foo2", "bar2")
+        assert cache.hlen("foo_hash1") == 2
+
+    def test_hdel(self, cache: RedisCache):
+        cache.hset("foo_hash2", "foo1", "bar1")
+        cache.hset("foo_hash2", "foo2", "bar2")
+        assert cache.hlen("foo_hash2") == 2
+        cache.hdel("foo_hash2", "foo1")
+        assert cache.hlen("foo_hash2") == 1
+        assert not cache.hexists("foo_hash2", "foo1")
+        assert cache.hexists("foo_hash2", "foo2")
+
+    def test_hlen(self, cache: RedisCache):
+        assert cache.hlen("foo_hash3") == 0
+        cache.hset("foo_hash3", "foo1", "bar1")
+        assert cache.hlen("foo_hash3") == 1
+        cache.hset("foo_hash3", "foo2", "bar2")
+        assert cache.hlen("foo_hash3") == 2
+
+    def test_hkeys(self, cache: RedisCache):
+        cache.hset("foo_hash4", "foo1", "bar1")
+        cache.hset("foo_hash4", "foo2", "bar2")
+        cache.hset("foo_hash4", "foo3", "bar3")
+        keys = cache.hkeys("foo_hash4")
+        assert len(keys) == 3
+        for i in range(len(keys)):
+            assert keys[i] == f"foo{i + 1}"
+
+    def test_hexists(self, cache: RedisCache):
+        cache.hset("foo_hash5", "foo1", "bar1")
+        assert cache.hexists("foo_hash5", "foo1")
+        assert not cache.hexists("foo_hash5", "foo")