diff --git a/src/main/java/redis/clients/jedis/UnifiedJedis.java b/src/main/java/redis/clients/jedis/UnifiedJedis.java
index 3a2dec9d771..f3d9b6f255c 100644
--- a/src/main/java/redis/clients/jedis/UnifiedJedis.java
+++ b/src/main/java/redis/clients/jedis/UnifiedJedis.java
@@ -322,12 +322,12 @@ public String configSet(String parameter, String value) {
   // Key commands
   @Override
   public boolean exists(String key) {
-    return executeCommand(commandObjects.exists(key));
+    return executeClientSideCacheCommand(commandObjects.exists(key));
   }
 
   @Override
   public long exists(String... keys) {
-    return executeCommand(commandObjects.exists(keys));
+    return executeClientSideCacheCommand(commandObjects.exists(keys));
   }
 
   @Override
@@ -337,17 +337,17 @@ public long persist(String key) {
 
   @Override
   public String type(String key) {
-    return executeCommand(commandObjects.type(key));
+    return executeClientSideCacheCommand(commandObjects.type(key));
   }
 
   @Override
   public boolean exists(byte[] key) {
-    return executeCommand(commandObjects.exists(key));
+    return executeClientSideCacheCommand(commandObjects.exists(key));
   }
 
   @Override
   public long exists(byte[]... keys) {
-    return executeCommand(commandObjects.exists(keys));
+    return executeClientSideCacheCommand(commandObjects.exists(keys));
   }
 
   @Override
@@ -357,7 +357,7 @@ public long persist(byte[] key) {
 
   @Override
   public String type(byte[] key) {
-    return executeCommand(commandObjects.type(key));
+    return executeClientSideCacheCommand(commandObjects.type(key));
   }
 
   @Override
@@ -792,7 +792,7 @@ public String set(byte[] key, byte[] value, SetParams params) {
 
   @Override
   public byte[] get(byte[] key) {
-    return executeCommand(commandObjects.get(key));
+    return executeClientSideCacheCommand(commandObjects.get(key));
   }
 
   @Override
@@ -822,7 +822,7 @@ public boolean setbit(String key, long offset, boolean value) {
 
   @Override
   public boolean getbit(String key, long offset) {
-    return executeCommand(commandObjects.getbit(key, offset));
+    return executeClientSideCacheCommand(commandObjects.getbit(key, offset));
   }
 
   @Override
@@ -832,7 +832,7 @@ public long setrange(String key, long offset, String value) {
 
   @Override
   public String getrange(String key, long startOffset, long endOffset) {
-    return executeCommand(commandObjects.getrange(key, startOffset, endOffset));
+    return executeClientSideCacheCommand(commandObjects.getrange(key, startOffset, endOffset));
   }
 
   @Override
@@ -842,7 +842,7 @@ public boolean setbit(byte[] key, long offset, boolean value) {
 
   @Override
   public boolean getbit(byte[] key, long offset) {
-    return executeCommand(commandObjects.getbit(key, offset));
+    return executeClientSideCacheCommand(commandObjects.getbit(key, offset));
   }
 
   @Override
@@ -852,7 +852,7 @@ public long setrange(byte[] key, long offset, byte[] value) {
 
   @Override
   public byte[] getrange(byte[] key, long startOffset, long endOffset) {
-    return executeCommand(commandObjects.getrange(key, startOffset, endOffset));
+    return executeClientSideCacheCommand(commandObjects.getrange(key, startOffset, endOffset));
   }
 
   @Override
@@ -947,7 +947,7 @@ public long decrBy(byte[] key, long decrement) {
 
   @Override
   public List<String> mget(String... keys) {
-    return executeCommand(commandObjects.mget(keys));
+    return executeClientSideCacheCommand(commandObjects.mget(keys));
   }
 
   @Override
@@ -962,7 +962,7 @@ public long msetnx(String... keysvalues) {
 
   @Override
   public List<byte[]> mget(byte[]... keys) {
-    return executeCommand(commandObjects.mget(keys));
+    return executeClientSideCacheCommand(commandObjects.mget(keys));
   }
 
   @Override
@@ -982,12 +982,12 @@ public long append(String key, String value) {
 
   @Override
   public String substr(String key, int start, int end) {
-    return executeCommand(commandObjects.substr(key, start, end));
+    return executeClientSideCacheCommand(commandObjects.substr(key, start, end));
   }
 
   @Override
   public long strlen(String key) {
-    return executeCommand(commandObjects.strlen(key));
+    return executeClientSideCacheCommand(commandObjects.strlen(key));
   }
 
   @Override
@@ -997,62 +997,62 @@ public long append(byte[] key, byte[] value) {
 
   @Override
   public byte[] substr(byte[] key, int start, int end) {
-    return executeCommand(commandObjects.substr(key, start, end));
+    return executeClientSideCacheCommand(commandObjects.substr(key, start, end));
   }
 
   @Override
   public long strlen(byte[] key) {
-    return executeCommand(commandObjects.strlen(key));
+    return executeClientSideCacheCommand(commandObjects.strlen(key));
   }
 
   @Override
   public long bitcount(String key) {
-    return executeCommand(commandObjects.bitcount(key));
+    return executeClientSideCacheCommand(commandObjects.bitcount(key));
   }
 
   @Override
   public long bitcount(String key, long start, long end) {
-    return executeCommand(commandObjects.bitcount(key, start, end));
+    return executeClientSideCacheCommand(commandObjects.bitcount(key, start, end));
   }
 
   @Override
   public long bitcount(String key, long start, long end, BitCountOption option) {
-    return executeCommand(commandObjects.bitcount(key, start, end, option));
+    return executeClientSideCacheCommand(commandObjects.bitcount(key, start, end, option));
   }
 
   @Override
   public long bitpos(String key, boolean value) {
-    return executeCommand(commandObjects.bitpos(key, value));
+    return executeClientSideCacheCommand(commandObjects.bitpos(key, value));
   }
 
   @Override
   public long bitpos(String key, boolean value, BitPosParams params) {
-    return executeCommand(commandObjects.bitpos(key, value, params));
+    return executeClientSideCacheCommand(commandObjects.bitpos(key, value, params));
   }
 
   @Override
   public long bitcount(byte[] key) {
-    return executeCommand(commandObjects.bitcount(key));
+    return executeClientSideCacheCommand(commandObjects.bitcount(key));
   }
 
   @Override
   public long bitcount(byte[] key, long start, long end) {
-    return executeCommand(commandObjects.bitcount(key, start, end));
+    return executeClientSideCacheCommand(commandObjects.bitcount(key, start, end));
   }
 
   @Override
   public long bitcount(byte[] key, long start, long end, BitCountOption option) {
-    return executeCommand(commandObjects.bitcount(key, start, end, option));
+    return executeClientSideCacheCommand(commandObjects.bitcount(key, start, end, option));
   }
 
   @Override
   public long bitpos(byte[] key, boolean value) {
-    return executeCommand(commandObjects.bitpos(key, value));
+    return executeClientSideCacheCommand(commandObjects.bitpos(key, value));
   }
 
   @Override
   public long bitpos(byte[] key, boolean value, BitPosParams params) {
-    return executeCommand(commandObjects.bitpos(key, value, params));
+    return executeClientSideCacheCommand(commandObjects.bitpos(key, value, params));
   }
 
   @Override
@@ -1062,7 +1062,7 @@ public List<Long> bitfield(String key, String... arguments) {
 
   @Override
   public List<Long> bitfieldReadonly(String key, String... arguments) {
-    return executeCommand(commandObjects.bitfieldReadonly(key, arguments));
+    return executeClientSideCacheCommand(commandObjects.bitfieldReadonly(key, arguments));
   }
 
   @Override
@@ -1072,7 +1072,7 @@ public List<Long> bitfield(byte[] key, byte[]... arguments) {
 
   @Override
   public List<Long> bitfieldReadonly(byte[] key, byte[]... arguments) {
-    return executeCommand(commandObjects.bitfieldReadonly(key, arguments));
+    return executeClientSideCacheCommand(commandObjects.bitfieldReadonly(key, arguments));
   }
 
   @Override
@@ -1087,12 +1087,12 @@ public long bitop(BitOP op, byte[] destKey, byte[]... srcKeys) {
 
   @Override
   public LCSMatchResult lcs(String keyA, String keyB, LCSParams params) {
-    return executeCommand(commandObjects.lcs(keyA, keyB, params));
+    return executeClientSideCacheCommand(commandObjects.lcs(keyA, keyB, params));
   }
 
   @Override
   public LCSMatchResult lcs(byte[] keyA, byte[] keyB, LCSParams params) {
-    return executeCommand(commandObjects.lcs(keyA, keyB, params));
+    return executeClientSideCacheCommand(commandObjects.lcs(keyA, keyB, params));
   }
   // String commands
 
@@ -1109,12 +1109,12 @@ public long lpush(String key, String... string) {
 
   @Override
   public long llen(String key) {
-    return executeCommand(commandObjects.llen(key));
+    return executeClientSideCacheCommand(commandObjects.llen(key));
   }
 
   @Override
   public List<String> lrange(String key, long start, long stop) {
-    return executeCommand(commandObjects.lrange(key, start, stop));
+    return executeClientSideCacheCommand(commandObjects.lrange(key, start, stop));
   }
 
   @Override
@@ -1124,7 +1124,7 @@ public String ltrim(String key, long start, long stop) {
 
   @Override
   public String lindex(String key, long index) {
-    return executeCommand(commandObjects.lindex(key, index));
+    return executeClientSideCacheCommand(commandObjects.lindex(key, index));
   }
 
   @Override
@@ -1139,12 +1139,12 @@ public long lpush(byte[] key, byte[]... args) {
 
   @Override
   public long llen(byte[] key) {
-    return executeCommand(commandObjects.llen(key));
+    return executeClientSideCacheCommand(commandObjects.llen(key));
   }
 
   @Override
   public List<byte[]> lrange(byte[] key, long start, long stop) {
-    return executeCommand(commandObjects.lrange(key, start, stop));
+    return executeClientSideCacheCommand(commandObjects.lrange(key, start, stop));
   }
 
   @Override
@@ -1154,7 +1154,7 @@ public String ltrim(byte[] key, long start, long stop) {
 
   @Override
   public byte[] lindex(byte[] key, long index) {
-    return executeCommand(commandObjects.lindex(key, index));
+    return executeClientSideCacheCommand(commandObjects.lindex(key, index));
   }
 
   @Override
@@ -1199,32 +1199,32 @@ public List<byte[]> lpop(byte[] key, int count) {
 
   @Override
   public Long lpos(String key, String element) {
-    return executeCommand(commandObjects.lpos(key, element));
+    return executeClientSideCacheCommand(commandObjects.lpos(key, element));
   }
 
   @Override
   public Long lpos(String key, String element, LPosParams params) {
-    return executeCommand(commandObjects.lpos(key, element, params));
+    return executeClientSideCacheCommand(commandObjects.lpos(key, element, params));
   }
 
   @Override
   public List<Long> lpos(String key, String element, LPosParams params, long count) {
-    return executeCommand(commandObjects.lpos(key, element, params, count));
+    return executeClientSideCacheCommand(commandObjects.lpos(key, element, params, count));
   }
 
   @Override
   public Long lpos(byte[] key, byte[] element) {
-    return executeCommand(commandObjects.lpos(key, element));
+    return executeClientSideCacheCommand(commandObjects.lpos(key, element));
   }
 
   @Override
   public Long lpos(byte[] key, byte[] element, LPosParams params) {
-    return executeCommand(commandObjects.lpos(key, element, params));
+    return executeClientSideCacheCommand(commandObjects.lpos(key, element, params));
   }
 
   @Override
   public List<Long> lpos(byte[] key, byte[] element, LPosParams params, long count) {
-    return executeCommand(commandObjects.lpos(key, element, params, count));
+    return executeClientSideCacheCommand(commandObjects.lpos(key, element, params, count));
   }
 
   @Override
@@ -1431,7 +1431,7 @@ public long hset(String key, Map<String, String> hash) {
 
   @Override
   public String hget(String key, String field) {
-    return executeCommand(commandObjects.hget(key, field));
+    return executeClientSideCacheCommand(commandObjects.hget(key, field));
   }
 
   @Override
@@ -1446,7 +1446,7 @@ public String hmset(String key, Map<String, String> hash) {
 
   @Override
   public List<String> hmget(String key, String... fields) {
-    return executeCommand(commandObjects.hmget(key, fields));
+    return executeClientSideCacheCommand(commandObjects.hmget(key, fields));
   }
 
   @Override
@@ -1461,7 +1461,7 @@ public long hset(byte[] key, Map<byte[], byte[]> hash) {
 
   @Override
   public byte[] hget(byte[] key, byte[] field) {
-    return executeCommand(commandObjects.hget(key, field));
+    return executeClientSideCacheCommand(commandObjects.hget(key, field));
   }
 
   @Override
@@ -1476,7 +1476,7 @@ public String hmset(byte[] key, Map<byte[], byte[]> hash) {
 
   @Override
   public List<byte[]> hmget(byte[] key, byte[]... fields) {
-    return executeCommand(commandObjects.hmget(key, fields));
+    return executeClientSideCacheCommand(commandObjects.hmget(key, fields));
   }
 
   @Override
@@ -1491,7 +1491,7 @@ public double hincrByFloat(String key, String field, double value) {
 
   @Override
   public boolean hexists(String key, String field) {
-    return executeCommand(commandObjects.hexists(key, field));
+    return executeClientSideCacheCommand(commandObjects.hexists(key, field));
   }
 
   @Override
@@ -1501,7 +1501,7 @@ public long hdel(String key, String... field) {
 
   @Override
   public long hlen(String key) {
-    return executeCommand(commandObjects.hlen(key));
+    return executeClientSideCacheCommand(commandObjects.hlen(key));
   }
 
   @Override
@@ -1516,7 +1516,7 @@ public double hincrByFloat(byte[] key, byte[] field, double value) {
 
   @Override
   public boolean hexists(byte[] key, byte[] field) {
-    return executeCommand(commandObjects.hexists(key, field));
+    return executeClientSideCacheCommand(commandObjects.hexists(key, field));
   }
 
   @Override
@@ -1526,37 +1526,37 @@ public long hdel(byte[] key, byte[]... field) {
 
   @Override
   public long hlen(byte[] key) {
-    return executeCommand(commandObjects.hlen(key));
+    return executeClientSideCacheCommand(commandObjects.hlen(key));
   }
 
   @Override
   public Set<String> hkeys(String key) {
-    return executeCommand(commandObjects.hkeys(key));
+    return executeClientSideCacheCommand(commandObjects.hkeys(key));
   }
 
   @Override
   public List<String> hvals(String key) {
-    return executeCommand(commandObjects.hvals(key));
+    return executeClientSideCacheCommand(commandObjects.hvals(key));
   }
 
   @Override
   public Map<String, String> hgetAll(String key) {
-    return executeCommand(commandObjects.hgetAll(key));
+    return executeClientSideCacheCommand(commandObjects.hgetAll(key));
   }
 
   @Override
   public Set<byte[]> hkeys(byte[] key) {
-    return executeCommand(commandObjects.hkeys(key));
+    return executeClientSideCacheCommand(commandObjects.hkeys(key));
   }
 
   @Override
   public List<byte[]> hvals(byte[] key) {
-    return executeCommand(commandObjects.hvals(key));
+    return executeClientSideCacheCommand(commandObjects.hvals(key));
   }
 
   @Override
   public Map<byte[], byte[]> hgetAll(byte[] key) {
-    return executeCommand(commandObjects.hgetAll(key));
+    return executeClientSideCacheCommand(commandObjects.hgetAll(key));
   }
 
   @Override
@@ -1581,7 +1581,7 @@ public ScanResult<Map.Entry<String, String>> hscan(String key, String cursor, Sc
 
   @Override
   public long hstrlen(String key, String field) {
-    return executeCommand(commandObjects.hstrlen(key, field));
+    return executeClientSideCacheCommand(commandObjects.hstrlen(key, field));
   }
 
   @Override
@@ -1606,7 +1606,7 @@ public ScanResult<Map.Entry<byte[], byte[]>> hscan(byte[] key, byte[] cursor, Sc
 
   @Override
   public long hstrlen(byte[] key, byte[] field) {
-    return executeCommand(commandObjects.hstrlen(key, field));
+    return executeClientSideCacheCommand(commandObjects.hstrlen(key, field));
   }
   // Hash commands
 
@@ -1618,7 +1618,7 @@ public long sadd(String key, String... members) {
 
   @Override
   public Set<String> smembers(String key) {
-    return executeCommand(commandObjects.smembers(key));
+    return executeClientSideCacheCommand(commandObjects.smembers(key));
   }
 
   @Override
@@ -1638,17 +1638,17 @@ public Set<String> spop(String key, long count) {
 
   @Override
   public long scard(String key) {
-    return executeCommand(commandObjects.scard(key));
+    return executeClientSideCacheCommand(commandObjects.scard(key));
   }
 
   @Override
   public boolean sismember(String key, String member) {
-    return executeCommand(commandObjects.sismember(key, member));
+    return executeClientSideCacheCommand(commandObjects.sismember(key, member));
   }
 
   @Override
   public List<Boolean> smismember(String key, String... members) {
-    return executeCommand(commandObjects.smismember(key, members));
+    return executeClientSideCacheCommand(commandObjects.smismember(key, members));
   }
 
   @Override
@@ -1658,7 +1658,7 @@ public long sadd(byte[] key, byte[]... members) {
 
   @Override
   public Set<byte[]> smembers(byte[] key) {
-    return executeCommand(commandObjects.smembers(key));
+    return executeClientSideCacheCommand(commandObjects.smembers(key));
   }
 
   @Override
@@ -1678,17 +1678,17 @@ public Set<byte[]> spop(byte[] key, long count) {
 
   @Override
   public long scard(byte[] key) {
-    return executeCommand(commandObjects.scard(key));
+    return executeClientSideCacheCommand(commandObjects.scard(key));
   }
 
   @Override
   public boolean sismember(byte[] key, byte[] member) {
-    return executeCommand(commandObjects.sismember(key, member));
+    return executeClientSideCacheCommand(commandObjects.sismember(key, member));
   }
 
   @Override
   public List<Boolean> smismember(byte[] key, byte[]... members) {
-    return executeCommand(commandObjects.smismember(key, members));
+    return executeClientSideCacheCommand(commandObjects.smismember(key, members));
   }
 
   @Override
@@ -1723,7 +1723,7 @@ public ScanResult<byte[]> sscan(byte[] key, byte[] cursor, ScanParams params) {
 
   @Override
   public Set<String> sdiff(String... keys) {
-    return executeCommand(commandObjects.sdiff(keys));
+    return executeClientSideCacheCommand(commandObjects.sdiff(keys));
   }
 
   @Override
@@ -1733,7 +1733,7 @@ public long sdiffstore(String dstkey, String... keys) {
 
   @Override
   public Set<String> sinter(String... keys) {
-    return executeCommand(commandObjects.sinter(keys));
+    return executeClientSideCacheCommand(commandObjects.sinter(keys));
   }
 
   @Override
@@ -1753,7 +1753,7 @@ public long sintercard(int limit, String... keys) {
 
   @Override
   public Set<String> sunion(String... keys) {
-    return executeCommand(commandObjects.sunion(keys));
+    return executeClientSideCacheCommand(commandObjects.sunion(keys));
   }
 
   @Override
@@ -1768,7 +1768,7 @@ public long smove(String srckey, String dstkey, String member) {
 
   @Override
   public Set<byte[]> sdiff(byte[]... keys) {
-    return executeCommand(commandObjects.sdiff(keys));
+    return executeClientSideCacheCommand(commandObjects.sdiff(keys));
   }
 
   @Override
@@ -1778,7 +1778,7 @@ public long sdiffstore(byte[] dstkey, byte[]... keys) {
 
   @Override
   public Set<byte[]> sinter(byte[]... keys) {
-    return executeCommand(commandObjects.sinter(keys));
+    return executeClientSideCacheCommand(commandObjects.sinter(keys));
   }
 
   @Override
@@ -1798,7 +1798,7 @@ public long sintercard(int limit, byte[]... keys) {
 
   @Override
   public Set<byte[]> sunion(byte[]... keys) {
-    return executeCommand(commandObjects.sunion(keys));
+    return executeClientSideCacheCommand(commandObjects.sunion(keys));
   }
 
   @Override
@@ -1880,22 +1880,22 @@ public Double zincrby(String key, double increment, String member, ZIncrByParams
 
   @Override
   public Long zrank(String key, String member) {
-    return executeCommand(commandObjects.zrank(key, member));
+    return executeClientSideCacheCommand(commandObjects.zrank(key, member));
   }
 
   @Override
   public Long zrevrank(String key, String member) {
-    return executeCommand(commandObjects.zrevrank(key, member));
+    return executeClientSideCacheCommand(commandObjects.zrevrank(key, member));
   }
 
   @Override
   public KeyValue<Long, Double> zrankWithScore(String key, String member) {
-    return executeCommand(commandObjects.zrankWithScore(key, member));
+    return executeClientSideCacheCommand(commandObjects.zrankWithScore(key, member));
   }
 
   @Override
   public KeyValue<Long, Double> zrevrankWithScore(String key, String member) {
-    return executeCommand(commandObjects.zrevrankWithScore(key, member));
+    return executeClientSideCacheCommand(commandObjects.zrevrankWithScore(key, member));
   }
 
   @Override
@@ -1915,22 +1915,22 @@ public Double zincrby(byte[] key, double increment, byte[] member, ZIncrByParams
 
   @Override
   public Long zrank(byte[] key, byte[] member) {
-    return executeCommand(commandObjects.zrank(key, member));
+    return executeClientSideCacheCommand(commandObjects.zrank(key, member));
   }
 
   @Override
   public Long zrevrank(byte[] key, byte[] member) {
-    return executeCommand(commandObjects.zrevrank(key, member));
+    return executeClientSideCacheCommand(commandObjects.zrevrank(key, member));
   }
 
   @Override
   public KeyValue<Long, Double> zrankWithScore(byte[] key, byte[] member) {
-    return executeCommand(commandObjects.zrankWithScore(key, member));
+    return executeClientSideCacheCommand(commandObjects.zrankWithScore(key, member));
   }
 
   @Override
   public KeyValue<Long, Double> zrevrankWithScore(byte[] key, byte[] member) {
-    return executeCommand(commandObjects.zrevrankWithScore(key, member));
+    return executeClientSideCacheCommand(commandObjects.zrevrankWithScore(key, member));
   }
 
   @Override
@@ -1950,17 +1950,17 @@ public List<Tuple> zrandmemberWithScores(String key, long count) {
 
   @Override
   public long zcard(String key) {
-    return executeCommand(commandObjects.zcard(key));
+    return executeClientSideCacheCommand(commandObjects.zcard(key));
   }
 
   @Override
   public Double zscore(String key, String member) {
-    return executeCommand(commandObjects.zscore(key, member));
+    return executeClientSideCacheCommand(commandObjects.zscore(key, member));
   }
 
   @Override
   public List<Double> zmscore(String key, String... members) {
-    return executeCommand(commandObjects.zmscore(key, members));
+    return executeClientSideCacheCommand(commandObjects.zmscore(key, members));
   }
 
   @Override
@@ -1980,17 +1980,17 @@ public List<Tuple> zrandmemberWithScores(byte[] key, long count) {
 
   @Override
   public long zcard(byte[] key) {
-    return executeCommand(commandObjects.zcard(key));
+    return executeClientSideCacheCommand(commandObjects.zcard(key));
   }
 
   @Override
   public Double zscore(byte[] key, byte[] member) {
-    return executeCommand(commandObjects.zscore(key, member));
+    return executeClientSideCacheCommand(commandObjects.zscore(key, member));
   }
 
   @Override
   public List<Double> zmscore(byte[] key, byte[]... members) {
-    return executeCommand(commandObjects.zmscore(key, members));
+    return executeClientSideCacheCommand(commandObjects.zmscore(key, members));
   }
 
   @Override
@@ -2015,12 +2015,12 @@ public List<Tuple> zpopmin(String key, int count) {
 
   @Override
   public long zcount(String key, double min, double max) {
-    return executeCommand(commandObjects.zcount(key, min, max));
+    return executeClientSideCacheCommand(commandObjects.zcount(key, min, max));
   }
 
   @Override
   public long zcount(String key, String min, String max) {
-    return executeCommand(commandObjects.zcount(key, min, max));
+    return executeClientSideCacheCommand(commandObjects.zcount(key, min, max));
   }
 
   @Override
@@ -2045,42 +2045,42 @@ public List<Tuple> zpopmin(byte[] key, int count) {
 
   @Override
   public long zcount(byte[] key, double min, double max) {
-    return executeCommand(commandObjects.zcount(key, min, max));
+    return executeClientSideCacheCommand(commandObjects.zcount(key, min, max));
   }
 
   @Override
   public long zcount(byte[] key, byte[] min, byte[] max) {
-    return executeCommand(commandObjects.zcount(key, min, max));
+    return executeClientSideCacheCommand(commandObjects.zcount(key, min, max));
   }
 
   @Override
   public List<String> zrange(String key, long start, long stop) {
-    return executeCommand(commandObjects.zrange(key, start, stop));
+    return executeClientSideCacheCommand(commandObjects.zrange(key, start, stop));
   }
 
   @Override
   public List<String> zrevrange(String key, long start, long stop) {
-    return executeCommand(commandObjects.zrevrange(key, start, stop));
+    return executeClientSideCacheCommand(commandObjects.zrevrange(key, start, stop));
   }
 
   @Override
   public List<Tuple> zrangeWithScores(String key, long start, long stop) {
-    return executeCommand(commandObjects.zrangeWithScores(key, start, stop));
+    return executeClientSideCacheCommand(commandObjects.zrangeWithScores(key, start, stop));
   }
 
   @Override
   public List<Tuple> zrevrangeWithScores(String key, long start, long stop) {
-    return executeCommand(commandObjects.zrevrangeWithScores(key, start, stop));
+    return executeClientSideCacheCommand(commandObjects.zrevrangeWithScores(key, start, stop));
   }
 
   @Override
   public List<String> zrange(String key, ZRangeParams zRangeParams) {
-    return executeCommand(commandObjects.zrange(key, zRangeParams));
+    return executeClientSideCacheCommand(commandObjects.zrange(key, zRangeParams));
   }
 
   @Override
   public List<Tuple> zrangeWithScores(String key, ZRangeParams zRangeParams) {
-    return executeCommand(commandObjects.zrangeWithScores(key, zRangeParams));
+    return executeClientSideCacheCommand(commandObjects.zrangeWithScores(key, zRangeParams));
   }
 
   @Override
@@ -2090,112 +2090,112 @@ public long zrangestore(String dest, String src, ZRangeParams zRangeParams) {
 
   @Override
   public List<String> zrangeByScore(String key, double min, double max) {
-    return executeCommand(commandObjects.zrangeByScore(key, min, max));
+    return executeClientSideCacheCommand(commandObjects.zrangeByScore(key, min, max));
   }
 
   @Override
   public List<String> zrangeByScore(String key, String min, String max) {
-    return executeCommand(commandObjects.zrangeByScore(key, min, max));
+    return executeClientSideCacheCommand(commandObjects.zrangeByScore(key, min, max));
   }
 
   @Override
   public List<String> zrevrangeByScore(String key, double max, double min) {
-    return executeCommand(commandObjects.zrevrangeByScore(key, max, min));
+    return executeClientSideCacheCommand(commandObjects.zrevrangeByScore(key, max, min));
   }
 
   @Override
   public List<String> zrangeByScore(String key, double min, double max, int offset, int count) {
-    return executeCommand(commandObjects.zrangeByScore(key, min, max, offset, count));
+    return executeClientSideCacheCommand(commandObjects.zrangeByScore(key, min, max, offset, count));
   }
 
   @Override
   public List<String> zrevrangeByScore(String key, String max, String min) {
-    return executeCommand(commandObjects.zrevrangeByScore(key, max, min));
+    return executeClientSideCacheCommand(commandObjects.zrevrangeByScore(key, max, min));
   }
 
   @Override
   public List<String> zrangeByScore(String key, String min, String max, int offset, int count) {
-    return executeCommand(commandObjects.zrangeByScore(key, min, max, offset, count));
+    return executeClientSideCacheCommand(commandObjects.zrangeByScore(key, min, max, offset, count));
   }
 
   @Override
   public List<String> zrevrangeByScore(String key, double max, double min, int offset, int count) {
-    return executeCommand(commandObjects.zrevrangeByScore(key, max, min, offset, count));
+    return executeClientSideCacheCommand(commandObjects.zrevrangeByScore(key, max, min, offset, count));
   }
 
   @Override
   public List<Tuple> zrangeByScoreWithScores(String key, double min, double max) {
-    return executeCommand(commandObjects.zrangeByScoreWithScores(key, min, max));
+    return executeClientSideCacheCommand(commandObjects.zrangeByScoreWithScores(key, min, max));
   }
 
   @Override
   public List<Tuple> zrevrangeByScoreWithScores(String key, double max, double min) {
-    return executeCommand(commandObjects.zrevrangeByScoreWithScores(key, max, min));
+    return executeClientSideCacheCommand(commandObjects.zrevrangeByScoreWithScores(key, max, min));
   }
 
   @Override
   public List<Tuple> zrangeByScoreWithScores(String key, double min, double max, int offset, int count) {
-    return executeCommand(commandObjects.zrangeByScoreWithScores(key, min, max, offset, count));
+    return executeClientSideCacheCommand(commandObjects.zrangeByScoreWithScores(key, min, max, offset, count));
   }
 
   @Override
   public List<String> zrevrangeByScore(String key, String max, String min, int offset, int count) {
-    return executeCommand(commandObjects.zrevrangeByScore(key, max, min, offset, count));
+    return executeClientSideCacheCommand(commandObjects.zrevrangeByScore(key, max, min, offset, count));
   }
 
   @Override
   public List<Tuple> zrangeByScoreWithScores(String key, String min, String max) {
-    return executeCommand(commandObjects.zrangeByScoreWithScores(key, min, max));
+    return executeClientSideCacheCommand(commandObjects.zrangeByScoreWithScores(key, min, max));
   }
 
   @Override
   public List<Tuple> zrevrangeByScoreWithScores(String key, String max, String min) {
-    return executeCommand(commandObjects.zrevrangeByScoreWithScores(key, max, min));
+    return executeClientSideCacheCommand(commandObjects.zrevrangeByScoreWithScores(key, max, min));
   }
 
   @Override
   public List<Tuple> zrangeByScoreWithScores(String key, String min, String max, int offset, int count) {
-    return executeCommand(commandObjects.zrangeByScoreWithScores(key, min, max, offset, count));
+    return executeClientSideCacheCommand(commandObjects.zrangeByScoreWithScores(key, min, max, offset, count));
   }
 
   @Override
   public List<Tuple> zrevrangeByScoreWithScores(String key, double max, double min, int offset, int count) {
-    return executeCommand(commandObjects.zrevrangeByScoreWithScores(key, max, min, offset, count));
+    return executeClientSideCacheCommand(commandObjects.zrevrangeByScoreWithScores(key, max, min, offset, count));
   }
 
   @Override
   public List<Tuple> zrevrangeByScoreWithScores(String key, String max, String min, int offset, int count) {
-    return executeCommand(commandObjects.zrevrangeByScoreWithScores(key, max, min, offset, count));
+    return executeClientSideCacheCommand(commandObjects.zrevrangeByScoreWithScores(key, max, min, offset, count));
   }
 
   @Override
   public List<byte[]> zrange(byte[] key, long start, long stop) {
-    return executeCommand(commandObjects.zrange(key, start, stop));
+    return executeClientSideCacheCommand(commandObjects.zrange(key, start, stop));
   }
 
   @Override
   public List<byte[]> zrevrange(byte[] key, long start, long stop) {
-    return executeCommand(commandObjects.zrevrange(key, start, stop));
+    return executeClientSideCacheCommand(commandObjects.zrevrange(key, start, stop));
   }
 
   @Override
   public List<Tuple> zrangeWithScores(byte[] key, long start, long stop) {
-    return executeCommand(commandObjects.zrangeWithScores(key, start, stop));
+    return executeClientSideCacheCommand(commandObjects.zrangeWithScores(key, start, stop));
   }
 
   @Override
   public List<Tuple> zrevrangeWithScores(byte[] key, long start, long stop) {
-    return executeCommand(commandObjects.zrevrangeWithScores(key, start, stop));
+    return executeClientSideCacheCommand(commandObjects.zrevrangeWithScores(key, start, stop));
   }
 
   @Override
   public List<byte[]> zrange(byte[] key, ZRangeParams zRangeParams) {
-    return executeCommand(commandObjects.zrange(key, zRangeParams));
+    return executeClientSideCacheCommand(commandObjects.zrange(key, zRangeParams));
   }
 
   @Override
   public List<Tuple> zrangeWithScores(byte[] key, ZRangeParams zRangeParams) {
-    return executeCommand(commandObjects.zrangeWithScores(key, zRangeParams));
+    return executeClientSideCacheCommand(commandObjects.zrangeWithScores(key, zRangeParams));
   }
 
   @Override
@@ -2205,82 +2205,82 @@ public long zrangestore(byte[] dest, byte[] src, ZRangeParams zRangeParams) {
 
   @Override
   public List<byte[]> zrangeByScore(byte[] key, double min, double max) {
-    return executeCommand(commandObjects.zrangeByScore(key, min, max));
+    return executeClientSideCacheCommand(commandObjects.zrangeByScore(key, min, max));
   }
 
   @Override
   public List<byte[]> zrangeByScore(byte[] key, byte[] min, byte[] max) {
-    return executeCommand(commandObjects.zrangeByScore(key, min, max));
+    return executeClientSideCacheCommand(commandObjects.zrangeByScore(key, min, max));
   }
 
   @Override
   public List<byte[]> zrevrangeByScore(byte[] key, double max, double min) {
-    return executeCommand(commandObjects.zrevrangeByScore(key, max, min));
+    return executeClientSideCacheCommand(commandObjects.zrevrangeByScore(key, max, min));
   }
 
   @Override
   public List<byte[]> zrangeByScore(byte[] key, double min, double max, int offset, int count) {
-    return executeCommand(commandObjects.zrangeByScore(key, min, max, offset, count));
+    return executeClientSideCacheCommand(commandObjects.zrangeByScore(key, min, max, offset, count));
   }
 
   @Override
   public List<byte[]> zrevrangeByScore(byte[] key, byte[] max, byte[] min) {
-    return executeCommand(commandObjects.zrevrangeByScore(key, max, min));
+    return executeClientSideCacheCommand(commandObjects.zrevrangeByScore(key, max, min));
   }
 
   @Override
   public List<byte[]> zrangeByScore(byte[] key, byte[] min, byte[] max, int offset, int count) {
-    return executeCommand(commandObjects.zrangeByScore(key, min, max, offset, count));
+    return executeClientSideCacheCommand(commandObjects.zrangeByScore(key, min, max, offset, count));
   }
 
   @Override
   public List<byte[]> zrevrangeByScore(byte[] key, double max, double min, int offset, int count) {
-    return executeCommand(commandObjects.zrevrangeByScore(key, max, min, offset, count));
+    return executeClientSideCacheCommand(commandObjects.zrevrangeByScore(key, max, min, offset, count));
   }
 
   @Override
   public List<Tuple> zrangeByScoreWithScores(byte[] key, double min, double max) {
-    return executeCommand(commandObjects.zrangeByScoreWithScores(key, min, max));
+    return executeClientSideCacheCommand(commandObjects.zrangeByScoreWithScores(key, min, max));
   }
 
   @Override
   public List<Tuple> zrevrangeByScoreWithScores(byte[] key, double max, double min) {
-    return executeCommand(commandObjects.zrevrangeByScoreWithScores(key, max, min));
+    return executeClientSideCacheCommand(commandObjects.zrevrangeByScoreWithScores(key, max, min));
   }
 
   @Override
   public List<Tuple> zrangeByScoreWithScores(byte[] key, double min, double max, int offset, int count) {
-    return executeCommand(commandObjects.zrangeByScoreWithScores(key, min, max, offset, count));
+    return executeClientSideCacheCommand(commandObjects.zrangeByScoreWithScores(key, min, max, offset, count));
   }
 
   @Override
   public List<byte[]> zrevrangeByScore(byte[] key, byte[] max, byte[] min, int offset, int count) {
-    return executeCommand(commandObjects.zrevrangeByScore(key, max, min, offset, count));
+    return executeClientSideCacheCommand(commandObjects.zrevrangeByScore(key, max, min, offset, count));
   }
 
   @Override
   public List<Tuple> zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max) {
-    return executeCommand(commandObjects.zrangeByScoreWithScores(key, min, max));
+    return executeClientSideCacheCommand(commandObjects.zrangeByScoreWithScores(key, min, max));
   }
 
   @Override
   public List<Tuple> zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min) {
-    return executeCommand(commandObjects.zrevrangeByScoreWithScores(key, max, min));
+    return executeClientSideCacheCommand(commandObjects.zrevrangeByScoreWithScores(key, max, min));
   }
 
   @Override
   public List<Tuple> zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max, int offset, int count) {
-    return executeCommand(commandObjects.zrangeByScoreWithScores(key, min, max, offset, count));
+    return executeClientSideCacheCommand(commandObjects.zrangeByScoreWithScores(key, min, max, offset, count));
   }
 
   @Override
   public List<Tuple> zrevrangeByScoreWithScores(byte[] key, double max, double min, int offset, int count) {
-    return executeCommand(commandObjects.zrevrangeByScoreWithScores(key, max, min, offset, count));
+    return executeClientSideCacheCommand(commandObjects.zrevrangeByScoreWithScores(key, max, min, offset, count));
   }
 
   @Override
   public List<Tuple> zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min, int offset, int count) {
-    return executeCommand(commandObjects.zrevrangeByScoreWithScores(key, max, min, offset, count));
+    return executeClientSideCacheCommand(commandObjects.zrevrangeByScoreWithScores(key, max, min, offset, count));
   }
 
   @Override
@@ -2315,27 +2315,27 @@ public long zremrangeByScore(byte[] key, byte[] min, byte[] max) {
 
   @Override
   public long zlexcount(String key, String min, String max) {
-    return executeCommand(commandObjects.zlexcount(key, min, max));
+    return executeClientSideCacheCommand(commandObjects.zlexcount(key, min, max));
   }
 
   @Override
   public List<String> zrangeByLex(String key, String min, String max) {
-    return executeCommand(commandObjects.zrangeByLex(key, min, max));
+    return executeClientSideCacheCommand(commandObjects.zrangeByLex(key, min, max));
   }
 
   @Override
   public List<String> zrangeByLex(String key, String min, String max, int offset, int count) {
-    return executeCommand(commandObjects.zrangeByLex(key, min, max, offset, count));
+    return executeClientSideCacheCommand(commandObjects.zrangeByLex(key, min, max, offset, count));
   }
 
   @Override
   public List<String> zrevrangeByLex(String key, String max, String min) {
-    return executeCommand(commandObjects.zrevrangeByLex(key, max, min));
+    return executeClientSideCacheCommand(commandObjects.zrevrangeByLex(key, max, min));
   }
 
   @Override
   public List<String> zrevrangeByLex(String key, String max, String min, int offset, int count) {
-    return executeCommand(commandObjects.zrevrangeByLex(key, max, min, offset, count));
+    return executeClientSideCacheCommand(commandObjects.zrevrangeByLex(key, max, min, offset, count));
   }
 
   @Override
@@ -2345,27 +2345,27 @@ public long zremrangeByLex(String key, String min, String max) {
 
   @Override
   public long zlexcount(byte[] key, byte[] min, byte[] max) {
-    return executeCommand(commandObjects.zlexcount(key, min, max));
+    return executeClientSideCacheCommand(commandObjects.zlexcount(key, min, max));
   }
 
   @Override
   public List<byte[]> zrangeByLex(byte[] key, byte[] min, byte[] max) {
-    return executeCommand(commandObjects.zrangeByLex(key, min, max));
+    return executeClientSideCacheCommand(commandObjects.zrangeByLex(key, min, max));
   }
 
   @Override
   public List<byte[]> zrangeByLex(byte[] key, byte[] min, byte[] max, int offset, int count) {
-    return executeCommand(commandObjects.zrangeByLex(key, min, max, offset, count));
+    return executeClientSideCacheCommand(commandObjects.zrangeByLex(key, min, max, offset, count));
   }
 
   @Override
   public List<byte[]> zrevrangeByLex(byte[] key, byte[] max, byte[] min) {
-    return executeCommand(commandObjects.zrevrangeByLex(key, max, min));
+    return executeClientSideCacheCommand(commandObjects.zrevrangeByLex(key, max, min));
   }
 
   @Override
   public List<byte[]> zrevrangeByLex(byte[] key, byte[] max, byte[] min, int offset, int count) {
-    return executeCommand(commandObjects.zrevrangeByLex(key, max, min, offset, count));
+    return executeClientSideCacheCommand(commandObjects.zrevrangeByLex(key, max, min, offset, count));
   }
 
   @Override
@@ -2604,22 +2604,22 @@ public long geoadd(String key, GeoAddParams params, Map<String, GeoCoordinate> m
 
   @Override
   public Double geodist(String key, String member1, String member2) {
-    return executeCommand(commandObjects.geodist(key, member1, member2));
+    return executeClientSideCacheCommand(commandObjects.geodist(key, member1, member2));
   }
 
   @Override
   public Double geodist(String key, String member1, String member2, GeoUnit unit) {
-    return executeCommand(commandObjects.geodist(key, member1, member2, unit));
+    return executeClientSideCacheCommand(commandObjects.geodist(key, member1, member2, unit));
   }
 
   @Override
   public List<String> geohash(String key, String... members) {
-    return executeCommand(commandObjects.geohash(key, members));
+    return executeClientSideCacheCommand(commandObjects.geohash(key, members));
   }
 
   @Override
   public List<GeoCoordinate> geopos(String key, String... members) {
-    return executeCommand(commandObjects.geopos(key, members));
+    return executeClientSideCacheCommand(commandObjects.geopos(key, members));
   }
 
   @Override
@@ -2639,22 +2639,22 @@ public long geoadd(byte[] key, GeoAddParams params, Map<byte[], GeoCoordinate> m
 
   @Override
   public Double geodist(byte[] key, byte[] member1, byte[] member2) {
-    return executeCommand(commandObjects.geodist(key, member1, member2));
+    return executeClientSideCacheCommand(commandObjects.geodist(key, member1, member2));
   }
 
   @Override
   public Double geodist(byte[] key, byte[] member1, byte[] member2, GeoUnit unit) {
-    return executeCommand(commandObjects.geodist(key, member1, member2, unit));
+    return executeClientSideCacheCommand(commandObjects.geodist(key, member1, member2, unit));
   }
 
   @Override
   public List<byte[]> geohash(byte[] key, byte[]... members) {
-    return executeCommand(commandObjects.geohash(key, members));
+    return executeClientSideCacheCommand(commandObjects.geohash(key, members));
   }
 
   @Override
   public List<GeoCoordinate> geopos(byte[] key, byte[]... members) {
-    return executeCommand(commandObjects.geopos(key, members));
+    return executeClientSideCacheCommand(commandObjects.geopos(key, members));
   }
 
   @Override
@@ -2664,7 +2664,7 @@ public List<GeoRadiusResponse> georadius(String key, double longitude, double la
 
   @Override
   public List<GeoRadiusResponse> georadiusReadonly(String key, double longitude, double latitude, double radius, GeoUnit unit) {
-    return executeCommand(commandObjects.georadiusReadonly(key, longitude, latitude, radius, unit));
+    return executeClientSideCacheCommand(commandObjects.georadiusReadonly(key, longitude, latitude, radius, unit));
   }
 
   @Override
@@ -2674,7 +2674,7 @@ public List<GeoRadiusResponse> georadius(String key, double longitude, double la
 
   @Override
   public List<GeoRadiusResponse> georadiusReadonly(String key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param) {
-    return executeCommand(commandObjects.georadiusReadonly(key, longitude, latitude, radius, unit, param));
+    return executeClientSideCacheCommand(commandObjects.georadiusReadonly(key, longitude, latitude, radius, unit, param));
   }
 
   @Override
@@ -2684,7 +2684,7 @@ public List<GeoRadiusResponse> georadiusByMember(String key, String member, doub
 
   @Override
   public List<GeoRadiusResponse> georadiusByMemberReadonly(String key, String member, double radius, GeoUnit unit) {
-    return executeCommand(commandObjects.georadiusByMemberReadonly(key, member, radius, unit));
+    return executeClientSideCacheCommand(commandObjects.georadiusByMemberReadonly(key, member, radius, unit));
   }
 
   @Override
@@ -2694,7 +2694,7 @@ public List<GeoRadiusResponse> georadiusByMember(String key, String member, doub
 
   @Override
   public List<GeoRadiusResponse> georadiusByMemberReadonly(String key, String member, double radius, GeoUnit unit, GeoRadiusParam param) {
-    return executeCommand(commandObjects.georadiusByMemberReadonly(key, member, radius, unit, param));
+    return executeClientSideCacheCommand(commandObjects.georadiusByMemberReadonly(key, member, radius, unit, param));
   }
 
   @Override
@@ -2709,27 +2709,27 @@ public long georadiusByMemberStore(String key, String member, double radius, Geo
 
   @Override
   public List<GeoRadiusResponse> geosearch(String key, String member, double radius, GeoUnit unit) {
-    return executeCommand(commandObjects.geosearch(key, member, radius, unit));
+    return executeClientSideCacheCommand(commandObjects.geosearch(key, member, radius, unit));
   }
 
   @Override
   public List<GeoRadiusResponse> geosearch(String key, GeoCoordinate coord, double radius, GeoUnit unit) {
-    return executeCommand(commandObjects.geosearch(key, coord, radius, unit));
+    return executeClientSideCacheCommand(commandObjects.geosearch(key, coord, radius, unit));
   }
 
   @Override
   public List<GeoRadiusResponse> geosearch(String key, String member, double width, double height, GeoUnit unit) {
-    return executeCommand(commandObjects.geosearch(key, member, width, height, unit));
+    return executeClientSideCacheCommand(commandObjects.geosearch(key, member, width, height, unit));
   }
 
   @Override
   public List<GeoRadiusResponse> geosearch(String key, GeoCoordinate coord, double width, double height, GeoUnit unit) {
-    return executeCommand(commandObjects.geosearch(key, coord, width, height, unit));
+    return executeClientSideCacheCommand(commandObjects.geosearch(key, coord, width, height, unit));
   }
 
   @Override
   public List<GeoRadiusResponse> geosearch(String key, GeoSearchParam params) {
-    return executeCommand(commandObjects.geosearch(key, params));
+    return executeClientSideCacheCommand(commandObjects.geosearch(key, params));
   }
 
   @Override
@@ -2769,7 +2769,7 @@ public List<GeoRadiusResponse> georadius(byte[] key, double longitude, double la
 
   @Override
   public List<GeoRadiusResponse> georadiusReadonly(byte[] key, double longitude, double latitude, double radius, GeoUnit unit) {
-    return executeCommand(commandObjects.georadiusReadonly(key, longitude, latitude, radius, unit));
+    return executeClientSideCacheCommand(commandObjects.georadiusReadonly(key, longitude, latitude, radius, unit));
   }
 
   @Override
@@ -2779,7 +2779,7 @@ public List<GeoRadiusResponse> georadius(byte[] key, double longitude, double la
 
   @Override
   public List<GeoRadiusResponse> georadiusReadonly(byte[] key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param) {
-    return executeCommand(commandObjects.georadiusReadonly(key, longitude, latitude, radius, unit, param));
+    return executeClientSideCacheCommand(commandObjects.georadiusReadonly(key, longitude, latitude, radius, unit, param));
   }
 
   @Override
@@ -2789,7 +2789,7 @@ public List<GeoRadiusResponse> georadiusByMember(byte[] key, byte[] member, doub
 
   @Override
   public List<GeoRadiusResponse> georadiusByMemberReadonly(byte[] key, byte[] member, double radius, GeoUnit unit) {
-    return executeCommand(commandObjects.georadiusByMemberReadonly(key, member, radius, unit));
+    return executeClientSideCacheCommand(commandObjects.georadiusByMemberReadonly(key, member, radius, unit));
   }
 
   @Override
@@ -2799,7 +2799,7 @@ public List<GeoRadiusResponse> georadiusByMember(byte[] key, byte[] member, doub
 
   @Override
   public List<GeoRadiusResponse> georadiusByMemberReadonly(byte[] key, byte[] member, double radius, GeoUnit unit, GeoRadiusParam param) {
-    return executeCommand(commandObjects.georadiusByMemberReadonly(key, member, radius, unit, param));
+    return executeClientSideCacheCommand(commandObjects.georadiusByMemberReadonly(key, member, radius, unit, param));
   }
 
   @Override
@@ -2814,27 +2814,27 @@ public long georadiusByMemberStore(byte[] key, byte[] member, double radius, Geo
 
   @Override
   public List<GeoRadiusResponse> geosearch(byte[] key, byte[] member, double radius, GeoUnit unit) {
-    return executeCommand(commandObjects.geosearch(key, member, radius, unit));
+    return executeClientSideCacheCommand(commandObjects.geosearch(key, member, radius, unit));
   }
 
   @Override
   public List<GeoRadiusResponse> geosearch(byte[] key, GeoCoordinate coord, double radius, GeoUnit unit) {
-    return executeCommand(commandObjects.geosearch(key, coord, radius, unit));
+    return executeClientSideCacheCommand(commandObjects.geosearch(key, coord, radius, unit));
   }
 
   @Override
   public List<GeoRadiusResponse> geosearch(byte[] key, byte[] member, double width, double height, GeoUnit unit) {
-    return executeCommand(commandObjects.geosearch(key, member, width, height, unit));
+    return executeClientSideCacheCommand(commandObjects.geosearch(key, member, width, height, unit));
   }
 
   @Override
   public List<GeoRadiusResponse> geosearch(byte[] key, GeoCoordinate coord, double width, double height, GeoUnit unit) {
-    return executeCommand(commandObjects.geosearch(key, coord, width, height, unit));
+    return executeClientSideCacheCommand(commandObjects.geosearch(key, coord, width, height, unit));
   }
 
   @Override
   public List<GeoRadiusResponse> geosearch(byte[] key, GeoSearchParam params) {
-    return executeCommand(commandObjects.geosearch(key, params));
+    return executeClientSideCacheCommand(commandObjects.geosearch(key, params));
   }
 
   @Override
@@ -2923,47 +2923,47 @@ public StreamEntryID xadd(String key, XAddParams params, Map<String, String> has
 
   @Override
   public long xlen(String key) {
-    return executeCommand(commandObjects.xlen(key));
+    return executeClientSideCacheCommand(commandObjects.xlen(key));
   }
 
   @Override
   public List<StreamEntry> xrange(String key, StreamEntryID start, StreamEntryID end) {
-    return executeCommand(commandObjects.xrange(key, start, end));
+    return executeClientSideCacheCommand(commandObjects.xrange(key, start, end));
   }
 
   @Override
   public List<StreamEntry> xrange(String key, StreamEntryID start, StreamEntryID end, int count) {
-    return executeCommand(commandObjects.xrange(key, start, end, count));
+    return executeClientSideCacheCommand(commandObjects.xrange(key, start, end, count));
   }
 
   @Override
   public List<StreamEntry> xrevrange(String key, StreamEntryID end, StreamEntryID start) {
-    return executeCommand(commandObjects.xrevrange(key, end, start));
+    return executeClientSideCacheCommand(commandObjects.xrevrange(key, end, start));
   }
 
   @Override
   public List<StreamEntry> xrevrange(String key, StreamEntryID end, StreamEntryID start, int count) {
-    return executeCommand(commandObjects.xrevrange(key, end, start, count));
+    return executeClientSideCacheCommand(commandObjects.xrevrange(key, end, start, count));
   }
 
   @Override
   public List<StreamEntry> xrange(String key, String start, String end) {
-    return executeCommand(commandObjects.xrange(key, start, end));
+    return executeClientSideCacheCommand(commandObjects.xrange(key, start, end));
   }
 
   @Override
   public List<StreamEntry> xrange(String key, String start, String end, int count) {
-    return executeCommand(commandObjects.xrange(key, start, end, count));
+    return executeClientSideCacheCommand(commandObjects.xrange(key, start, end, count));
   }
 
   @Override
   public List<StreamEntry> xrevrange(String key, String end, String start) {
-    return executeCommand(commandObjects.xrevrange(key, end, start));
+    return executeClientSideCacheCommand(commandObjects.xrevrange(key, end, start));
   }
 
   @Override
   public List<StreamEntry> xrevrange(String key, String end, String start, int count) {
-    return executeCommand(commandObjects.xrevrange(key, end, start, count));
+    return executeClientSideCacheCommand(commandObjects.xrevrange(key, end, start, count));
   }
 
   @Override
@@ -2998,12 +2998,12 @@ public long xgroupDelConsumer(String key, String groupName, String consumerName)
 
   @Override
   public StreamPendingSummary xpending(String key, String groupName) {
-    return executeCommand(commandObjects.xpending(key, groupName));
+    return executeClientSideCacheCommand(commandObjects.xpending(key, groupName));
   }
 
   @Override
   public List<StreamPendingEntry> xpending(String key, String groupName, XPendingParams params) {
-    return executeCommand(commandObjects.xpending(key, groupName, params));
+    return executeClientSideCacheCommand(commandObjects.xpending(key, groupName, params));
   }
 
   @Override
@@ -3089,27 +3089,27 @@ public byte[] xadd(byte[] key, XAddParams params, Map<byte[], byte[]> hash) {
 
   @Override
   public long xlen(byte[] key) {
-    return executeCommand(commandObjects.xlen(key));
+    return executeClientSideCacheCommand(commandObjects.xlen(key));
   }
 
   @Override
   public List<Object> xrange(byte[] key, byte[] start, byte[] end) {
-    return executeCommand(commandObjects.xrange(key, start, end));
+    return executeClientSideCacheCommand(commandObjects.xrange(key, start, end));
   }
 
   @Override
   public List<Object> xrange(byte[] key, byte[] start, byte[] end, int count) {
-    return executeCommand(commandObjects.xrange(key, start, end, count));
+    return executeClientSideCacheCommand(commandObjects.xrange(key, start, end, count));
   }
 
   @Override
   public List<Object> xrevrange(byte[] key, byte[] end, byte[] start) {
-    return executeCommand(commandObjects.xrevrange(key, end, start));
+    return executeClientSideCacheCommand(commandObjects.xrevrange(key, end, start));
   }
 
   @Override
   public List<Object> xrevrange(byte[] key, byte[] end, byte[] start, int count) {
-    return executeCommand(commandObjects.xrevrange(key, end, start, count));
+    return executeClientSideCacheCommand(commandObjects.xrevrange(key, end, start, count));
   }
 
   @Override
@@ -3159,12 +3159,12 @@ public long xtrim(byte[] key, XTrimParams params) {
 
   @Override
   public Object xpending(byte[] key, byte[] groupName) {
-    return executeCommand(commandObjects.xpending(key, groupName));
+    return executeClientSideCacheCommand(commandObjects.xpending(key, groupName));
   }
 
   @Override
   public List<Object> xpending(byte[] key, byte[] groupName, XPendingParams params) {
-    return executeCommand(commandObjects.xpending(key, groupName, params));
+    return executeClientSideCacheCommand(commandObjects.xpending(key, groupName, params));
   }
 
   @Override
@@ -3982,47 +3982,47 @@ public String jsonMerge(String key, Path path, Object pojo) {
 
   @Override
   public Object jsonGet(String key) {
-    return executeCommand(commandObjects.jsonGet(key));
+    return executeClientSideCacheCommand(commandObjects.jsonGet(key));
   }
 
   @Override
   @Deprecated
   public <T> T jsonGet(String key, Class<T> clazz) {
-    return executeCommand(commandObjects.jsonGet(key, clazz));
+    return executeClientSideCacheCommand(commandObjects.jsonGet(key, clazz));
   }
 
   @Override
   public Object jsonGet(String key, Path2... paths) {
-    return executeCommand(commandObjects.jsonGet(key, paths));
+    return executeClientSideCacheCommand(commandObjects.jsonGet(key, paths));
   }
 
   @Override
   @Deprecated
   public Object jsonGet(String key, Path... paths) {
-    return executeCommand(commandObjects.jsonGet(key, paths));
+    return executeClientSideCacheCommand(commandObjects.jsonGet(key, paths));
   }
 
   @Override
   @Deprecated
   public String jsonGetAsPlainString(String key, Path path) {
-    return executeCommand(commandObjects.jsonGetAsPlainString(key, path));
+    return executeClientSideCacheCommand(commandObjects.jsonGetAsPlainString(key, path));
   }
 
   @Override
   @Deprecated
   public <T> T jsonGet(String key, Class<T> clazz, Path... paths) {
-    return executeCommand(commandObjects.jsonGet(key, clazz, paths));
+    return executeClientSideCacheCommand(commandObjects.jsonGet(key, clazz, paths));
   }
 
   @Override
   public List<JSONArray> jsonMGet(Path2 path, String... keys) {
-    return executeCommand(commandObjects.jsonMGet(path, keys));
+    return executeClientSideCacheCommand(commandObjects.jsonMGet(path, keys));
   }
 
   @Override
   @Deprecated
   public <T> List<T> jsonMGet(Path path, Class<T> clazz, String... keys) {
-    return executeCommand(commandObjects.jsonMGet(path, clazz, keys));
+    return executeClientSideCacheCommand(commandObjects.jsonMGet(path, clazz, keys));
   }
 
   @Override
@@ -4071,18 +4071,18 @@ public String jsonToggle(String key, Path path) {
   @Override
   @Deprecated
   public Class<?> jsonType(String key) {
-    return executeCommand(commandObjects.jsonType(key));
+    return executeClientSideCacheCommand(commandObjects.jsonType(key));
   }
 
   @Override
   public List<Class<?>> jsonType(String key, Path2 path) {
-    return executeCommand(commandObjects.jsonType(key, path));
+    return executeClientSideCacheCommand(commandObjects.jsonType(key, path));
   }
 
   @Override
   @Deprecated
   public Class<?> jsonType(String key, Path path) {
-    return executeCommand(commandObjects.jsonType(key, path));
+    return executeClientSideCacheCommand(commandObjects.jsonType(key, path));
   }
 
   @Override
@@ -4105,18 +4105,18 @@ public long jsonStrAppend(String key, Path path, Object string) {
   @Override
   @Deprecated
   public Long jsonStrLen(String key) {
-    return executeCommand(commandObjects.jsonStrLen(key));
+    return executeClientSideCacheCommand(commandObjects.jsonStrLen(key));
   }
 
   @Override
   public List<Long> jsonStrLen(String key, Path2 path) {
-    return executeCommand(commandObjects.jsonStrLen(key, path));
+    return executeClientSideCacheCommand(commandObjects.jsonStrLen(key, path));
   }
 
   @Override
   @Deprecated
   public Long jsonStrLen(String key, Path path) {
-    return executeCommand(commandObjects.jsonStrLen(key, path));
+    return executeClientSideCacheCommand(commandObjects.jsonStrLen(key, path));
   }
 
   @Override
@@ -4148,18 +4148,18 @@ public Long jsonArrAppend(String key, Path path, Object... pojos) {
 
   @Override
   public List<Long> jsonArrIndex(String key, Path2 path, Object scalar) {
-    return executeCommand(commandObjects.jsonArrIndex(key, path, scalar));
+    return executeClientSideCacheCommand(commandObjects.jsonArrIndex(key, path, scalar));
   }
 
   @Override
   public List<Long> jsonArrIndexWithEscape(String key, Path2 path, Object scalar) {
-    return executeCommand(commandObjects.jsonArrIndexWithEscape(key, path, scalar));
+    return executeClientSideCacheCommand(commandObjects.jsonArrIndexWithEscape(key, path, scalar));
   }
 
   @Override
   @Deprecated
   public long jsonArrIndex(String key, Path path, Object scalar) {
-    return executeCommand(commandObjects.jsonArrIndex(key, path, scalar));
+    return executeClientSideCacheCommand(commandObjects.jsonArrIndex(key, path, scalar));
   }
 
   @Override
@@ -4227,18 +4227,18 @@ public <T> T jsonArrPop(String key, Class<T> clazz, Path path, int index) {
   @Override
   @Deprecated
   public Long jsonArrLen(String key) {
-    return executeCommand(commandObjects.jsonArrLen(key));
+    return executeClientSideCacheCommand(commandObjects.jsonArrLen(key));
   }
 
   @Override
   public List<Long> jsonArrLen(String key, Path2 path) {
-    return executeCommand(commandObjects.jsonArrLen(key, path));
+    return executeClientSideCacheCommand(commandObjects.jsonArrLen(key, path));
   }
 
   @Override
   @Deprecated
   public Long jsonArrLen(String key, Path path) {
-    return executeCommand(commandObjects.jsonArrLen(key, path));
+    return executeClientSideCacheCommand(commandObjects.jsonArrLen(key, path));
   }
 
   @Override
@@ -4255,35 +4255,35 @@ public Long jsonArrTrim(String key, Path path, int start, int stop) {
   @Override
   @Deprecated
   public Long jsonObjLen(String key) {
-    return executeCommand(commandObjects.jsonObjLen(key));
+    return executeClientSideCacheCommand(commandObjects.jsonObjLen(key));
   }
 
   @Override
   @Deprecated
   public Long jsonObjLen(String key, Path path) {
-    return executeCommand(commandObjects.jsonObjLen(key, path));
+    return executeClientSideCacheCommand(commandObjects.jsonObjLen(key, path));
   }
 
   @Override
   public List<Long> jsonObjLen(String key, Path2 path) {
-    return executeCommand(commandObjects.jsonObjLen(key, path));
+    return executeClientSideCacheCommand(commandObjects.jsonObjLen(key, path));
   }
 
   @Override
   @Deprecated
   public List<String> jsonObjKeys(String key) {
-    return executeCommand(commandObjects.jsonObjKeys(key));
+    return executeClientSideCacheCommand(commandObjects.jsonObjKeys(key));
   }
 
   @Override
   @Deprecated
   public List<String> jsonObjKeys(String key, Path path) {
-    return executeCommand(commandObjects.jsonObjKeys(key, path));
+    return executeClientSideCacheCommand(commandObjects.jsonObjKeys(key, path));
   }
 
   @Override
   public List<List<String>> jsonObjKeys(String key, Path2 path) {
-    return executeCommand(commandObjects.jsonObjKeys(key, path));
+    return executeClientSideCacheCommand(commandObjects.jsonObjKeys(key, path));
   }
 
   @Override
@@ -4367,22 +4367,22 @@ public long tsDecrBy(String key, double value, long timestamp) {
 
   @Override
   public List<TSElement> tsRange(String key, long fromTimestamp, long toTimestamp) {
-    return executeCommand(commandObjects.tsRange(key, fromTimestamp, toTimestamp));
+    return executeClientSideCacheCommand(commandObjects.tsRange(key, fromTimestamp, toTimestamp));
   }
 
   @Override
   public List<TSElement> tsRange(String key, TSRangeParams rangeParams) {
-    return executeCommand(commandObjects.tsRange(key, rangeParams));
+    return executeClientSideCacheCommand(commandObjects.tsRange(key, rangeParams));
   }
 
   @Override
   public List<TSElement> tsRevRange(String key, long fromTimestamp, long toTimestamp) {
-    return executeCommand(commandObjects.tsRevRange(key, fromTimestamp, toTimestamp));
+    return executeClientSideCacheCommand(commandObjects.tsRevRange(key, fromTimestamp, toTimestamp));
   }
 
   @Override
   public List<TSElement> tsRevRange(String key, TSRangeParams rangeParams) {
-    return executeCommand(commandObjects.tsRevRange(key, rangeParams));
+    return executeClientSideCacheCommand(commandObjects.tsRevRange(key, rangeParams));
   }
 
   @Override
@@ -4407,12 +4407,12 @@ public Map<String, TSMRangeElements> tsMRevRange(TSMRangeParams multiRangeParams
 
   @Override
   public TSElement tsGet(String key) {
-    return executeCommand(commandObjects.tsGet(key));
+    return executeClientSideCacheCommand(commandObjects.tsGet(key));
   }
 
   @Override
   public TSElement tsGet(String key, TSGetParams getParams) {
-    return executeCommand(commandObjects.tsGet(key, getParams));
+    return executeClientSideCacheCommand(commandObjects.tsGet(key, getParams));
   }
 
   @Override
@@ -4442,7 +4442,7 @@ public List<String> tsQueryIndex(String... filters) {
 
   @Override
   public TSInfo tsInfo(String key) {
-    return executor.executeCommand(commandObjects.tsInfo(key));
+    return executeClientSideCacheCommand(commandObjects.tsInfo(key));
   }
 
   @Override