From 6b5fccdc0ad69742b171d25515a0a9a630ac4635 Mon Sep 17 00:00:00 2001
From: samhendley <sam.hendley@gmail.com>
Date: Thu, 10 Jan 2013 02:29:39 -0500
Subject: [PATCH] refactored pipelinebase so it is usable to implement
 SharedJedisPipeline as well.

---
 .../clients/jedis/MultiKeyPipelineBase.java   |  370 +++++
 .../java/redis/clients/jedis/Pipeline.java    |   10 +-
 .../redis/clients/jedis/PipelineBase.java     |  740 +++-------
 .../clients/jedis/ShardedJedisPipeline.java   | 1302 +----------------
 .../java/redis/clients/jedis/Transaction.java |   12 +-
 .../redis/clients/jedis/TransactionBlock.java |    2 +-
 6 files changed, 597 insertions(+), 1839 deletions(-)
 create mode 100644 src/main/java/redis/clients/jedis/MultiKeyPipelineBase.java

diff --git a/src/main/java/redis/clients/jedis/MultiKeyPipelineBase.java b/src/main/java/redis/clients/jedis/MultiKeyPipelineBase.java
new file mode 100644
index 0000000..ccf0dfd
--- /dev/null
+++ b/src/main/java/redis/clients/jedis/MultiKeyPipelineBase.java
@@ -0,0 +1,370 @@
+package redis.clients.jedis;
+
+import java.util.List;
+import java.util.Set;
+
+abstract class MultiKeyPipelineBase extends PipelineBase implements
+        BasicRedisPipeline,
+        MultiKeyBinaryRedisPipeline,
+        MultiKeyCommandsPipeline {
+
+    protected Client client = null;
+
+    public Response<List<String>> brpop(String... args) {
+        client.brpop(args);
+        return getResponse(BuilderFactory.STRING_LIST);
+    }
+
+    public Response<List<String>> blpop(String... args) {
+        client.blpop(args);
+        return getResponse(BuilderFactory.STRING_LIST);
+    }
+
+    public Response<List<byte[]>> brpop(byte[]... args) {
+        client.brpop(args);
+        return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
+    }
+
+    public Response<List<byte[]>> blpop(byte[]... args) {
+        client.blpop(args);
+        return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
+    }
+
+    public Response<Long> del(String... keys) {
+        client.del(keys);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> del(byte[]... keys) {
+        client.del(keys);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Set<String>> keys(String pattern) {
+        getClient(pattern).keys(pattern);
+        return getResponse(BuilderFactory.STRING_SET);
+    }
+
+    public Response<Set<byte[]>> keys(byte[] pattern) {
+        getClient(pattern).keys(pattern);
+        return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
+    }
+
+    public Response<List<String>> mget(String... keys) {
+        client.mget(keys);
+        return getResponse(BuilderFactory.STRING_LIST);
+    }
+
+    public Response<List<byte[]>> mget(byte[]... keys) {
+        client.mget(keys);
+        return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
+    }
+
+    public Response<String> mset(String... keysvalues) {
+        client.mset(keysvalues);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<String> mset(byte[]... keysvalues) {
+        client.mset(keysvalues);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<Long> msetnx(String... keysvalues) {
+        client.msetnx(keysvalues);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> msetnx(byte[]... keysvalues) {
+        client.msetnx(keysvalues);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<String> rename(String oldkey, String newkey) {
+        client.rename(oldkey, newkey);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<String> rename(byte[] oldkey, byte[] newkey) {
+        client.rename(oldkey, newkey);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<Long> renamenx(String oldkey, String newkey) {
+        client.renamenx(oldkey, newkey);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> renamenx(byte[] oldkey, byte[] newkey) {
+        client.renamenx(oldkey, newkey);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<String> rpoplpush(String srckey, String dstkey) {
+        client.rpoplpush(srckey, dstkey);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<byte[]> rpoplpush(byte[] srckey, byte[] dstkey) {
+        client.rpoplpush(srckey, dstkey);
+        return getResponse(BuilderFactory.BYTE_ARRAY);
+    }
+
+    public Response<Set<String>> sdiff(String... keys) {
+        client.sdiff(keys);
+        return getResponse(BuilderFactory.STRING_SET);
+    }
+
+    public Response<Set<byte[]>> sdiff(byte[]... keys) {
+        client.sdiff(keys);
+        return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
+    }
+
+    public Response<Long> sdiffstore(String dstkey, String... keys) {
+        client.sdiffstore(dstkey, keys);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> sdiffstore(byte[] dstkey, byte[]... keys) {
+        client.sdiffstore(dstkey, keys);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Set<String>> sinter(String... keys) {
+        client.sinter(keys);
+        return getResponse(BuilderFactory.STRING_SET);
+    }
+
+    public Response<Set<byte[]>> sinter(byte[]... keys) {
+        client.sinter(keys);
+        return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
+    }
+
+    public Response<Long> sinterstore(String dstkey, String... keys) {
+        client.sinterstore(dstkey, keys);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> sinterstore(byte[] dstkey, byte[]... keys) {
+        client.sinterstore(dstkey, keys);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> smove(String srckey, String dstkey, String member) {
+        client.smove(srckey, dstkey, member);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> smove(byte[] srckey, byte[] dstkey, byte[] member) {
+        client.smove(srckey, dstkey, member);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<List<String>> sort(String key,
+                                       SortingParams sortingParameters, String dstkey) {
+        client.sort(key, sortingParameters, dstkey);
+        return getResponse(BuilderFactory.STRING_LIST);
+    }
+
+    public Response<List<byte[]>> sort(byte[] key,
+                                       SortingParams sortingParameters, byte[] dstkey) {
+        client.sort(key, sortingParameters, dstkey);
+        return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
+    }
+
+    public Response<List<String>> sort(String key, String dstkey) {
+        client.sort(key, dstkey);
+        return getResponse(BuilderFactory.STRING_LIST);
+    }
+
+    public Response<List<byte[]>> sort(byte[] key, byte[] dstkey) {
+        client.sort(key, dstkey);
+        return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
+    }
+
+    public Response<Set<String>> sunion(String... keys) {
+        client.sunion(keys);
+        return getResponse(BuilderFactory.STRING_SET);
+    }
+
+    public Response<Set<byte[]>> sunion(byte[]... keys) {
+        client.sunion(keys);
+        return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
+    }
+
+    public Response<Long> sunionstore(String dstkey, String... keys) {
+        client.sunionstore(dstkey, keys);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> sunionstore(byte[] dstkey, byte[]... keys) {
+        client.sunionstore(dstkey, keys);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<String> watch(String... keys) {
+        client.watch(keys);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<String> watch(byte[]... keys) {
+        client.watch(keys);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<Long> zinterstore(String dstkey, String... sets) {
+        client.zinterstore(dstkey, sets);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> zinterstore(byte[] dstkey, byte[]... sets) {
+        client.zinterstore(dstkey, sets);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> zinterstore(String dstkey, ZParams params,
+                                      String... sets) {
+        client.zinterstore(dstkey, params, sets);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> zinterstore(byte[] dstkey, ZParams params,
+                                      byte[]... sets) {
+        client.zinterstore(dstkey, params, sets);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> zunionstore(String dstkey, String... sets) {
+        client.zunionstore(dstkey, sets);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> zunionstore(byte[] dstkey, byte[]... sets) {
+        client.zunionstore(dstkey, sets);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> zunionstore(String dstkey, ZParams params,
+                                      String... sets) {
+        client.zunionstore(dstkey, params, sets);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> zunionstore(byte[] dstkey, ZParams params,
+                                      byte[]... sets) {
+        client.zunionstore(dstkey, params, sets);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<String> bgrewriteaof() {
+        client.bgrewriteaof();
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<String> bgsave() {
+        client.bgsave();
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<String> configGet(String pattern) {
+        client.configGet(pattern);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<String> configSet(String parameter, String value) {
+        client.configSet(parameter, value);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<String> brpoplpush(String source, String destination,
+                                       int timeout) {
+        client.brpoplpush(source, destination, timeout);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<byte[]> brpoplpush(byte[] source, byte[] destination,
+                                       int timeout) {
+        client.brpoplpush(source, destination, timeout);
+        return getResponse(BuilderFactory.BYTE_ARRAY);
+    }
+
+    public Response<String> configResetStat() {
+        client.configResetStat();
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<String> save() {
+        client.save();
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<Long> lastsave() {
+        client.lastsave();
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> publish(String channel, String message) {
+        client.publish(channel, message);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> publish(byte[] channel, byte[] message) {
+        client.publish(channel, message);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<String> randomKey() {
+        client.randomKey();
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<byte[]> randomKeyBinary() {
+        client.randomKey();
+        return getResponse(BuilderFactory.BYTE_ARRAY);
+    }
+
+    public Response<String> flushDB() {
+        client.flushDB();
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<String> flushAll() {
+        client.flushAll();
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<String> info() {
+        client.info();
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<Long> dbSize() {
+        client.dbSize();
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<String> shutdown() {
+        client.shutdown();
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<String> ping() {
+        client.ping();
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<String> select(int index) {
+        client.select(index);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<Long> bitop(BitOP op, byte[] destKey, byte[]... srcKeys) {
+        client.bitop(op, destKey, srcKeys);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> bitop(BitOP op, String destKey, String... srcKeys) {
+        client.bitop(op, destKey, srcKeys);
+        return getResponse(BuilderFactory.LONG);
+    }
+}
diff --git a/src/main/java/redis/clients/jedis/Pipeline.java b/src/main/java/redis/clients/jedis/Pipeline.java
index cf61066..ee680eb 100755
--- a/src/main/java/redis/clients/jedis/Pipeline.java
+++ b/src/main/java/redis/clients/jedis/Pipeline.java
@@ -5,7 +5,7 @@ import redis.clients.jedis.exceptions.JedisDataException;
 import java.util.ArrayList;
 import java.util.List;
 
-public class Pipeline extends PipelineBase {
+public class Pipeline extends MultiKeyPipelineBase {
 	
     private MultiResponseBuilder currentMulti;
     
@@ -53,7 +53,15 @@ public class Pipeline extends PipelineBase {
         this.client = client;
     }
 
+    @Override
+    protected Client getClient(byte[] key) {
+        return client;
+    }
 
+    @Override
+    protected Client getClient(String key) {
+        return client;
+    }
 
     /**
      * Syncronize pipeline by reading all responses. This operation close the
diff --git a/src/main/java/redis/clients/jedis/PipelineBase.java b/src/main/java/redis/clients/jedis/PipelineBase.java
index b8fdefd..2af0899 100644
--- a/src/main/java/redis/clients/jedis/PipelineBase.java
+++ b/src/main/java/redis/clients/jedis/PipelineBase.java
@@ -1,924 +1,707 @@
 package redis.clients.jedis;
 
-import static redis.clients.jedis.Protocol.toByteArray;
+import redis.clients.jedis.BinaryClient.LIST_POSITION;
 
-import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
-import redis.clients.jedis.BinaryClient.LIST_POSITION;
-import redis.clients.jedis.exceptions.JedisDataException;
+import static redis.clients.jedis.Protocol.toByteArray;
 
 abstract class PipelineBase extends Queable implements
-        BasicRedisPipeline,
         BinaryRedisPipeline,
-        RedisPipeline,
-        MultiKeyBinaryRedisPipeline,
-        MultiKeyCommandsPipeline {
-
-    protected Client client;
+        RedisPipeline {
+    
+    protected abstract Client getClient(String key);
+    
+    protected abstract Client getClient(byte[] key);
 
     public Response<Long> append(String key, String value) {
-        client.append(key, value);
+        getClient(key).append(key, value);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<Long> append(byte[] key, byte[] value) {
-        client.append(key, value);
+        getClient(key).append(key, value);
         return getResponse(BuilderFactory.LONG);
     }
 
-    public Response<List<String>> blpop(String arg) {
+    public Response<List<String>> blpop(String key) {
         String[] temp = new String[1];
-        temp[0] = arg;
-        client.blpop(temp);
+        temp[0] = key;
+        getClient(key).blpop(temp);
         return getResponse(BuilderFactory.STRING_LIST);
     }
 
-    public Response<List<String>> brpop(String arg) {
+    public Response<List<String>> brpop(String key) {
         String[] temp = new String[1];
-        temp[0] = arg;
-        client.brpop(temp);
+        temp[0] = key;
+        getClient(key).brpop(temp);
         return getResponse(BuilderFactory.STRING_LIST);
     }
 
-    public Response<List<byte[]>> blpop(byte[] arg) {
+    public Response<List<byte[]>> blpop(byte[] key) {
         byte[][] temp = new byte[1][];
-        temp[0] = arg;
-        client.blpop(temp);
+        temp[0] = key;
+        getClient(key).blpop(temp);
         return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
     }
 
-    public Response<List<byte[]>> brpop(byte[] arg) {
+    public Response<List<byte[]>> brpop(byte[] key) {
         byte[][] temp = new byte[1][];
-        temp[0] = arg;
-        client.brpop(temp);
-        return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
-    }
-
-    public Response<List<String>> blpop(String... args) {
-        client.blpop(args);
-        return getResponse(BuilderFactory.STRING_LIST);
-    }
-
-    public Response<List<byte[]>> blpop(byte[]... args) {
-        client.blpop(args);
-        return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
-    }
-
-    public Response<List<String>> brpop(String... args) {
-        client.brpop(args);
-        return getResponse(BuilderFactory.STRING_LIST);
-    }
-
-    public Response<List<byte[]>> brpop(byte[]... args) {
-        client.brpop(args);
+        temp[0] = key;
+        getClient(key).brpop(temp);
         return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
     }
 
     public Response<Long> decr(String key) {
-        client.decr(key);
+        getClient(key).decr(key);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<Long> decr(byte[] key) {
-        client.decr(key);
+        getClient(key).decr(key);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<Long> decrBy(String key, long integer) {
-        client.decrBy(key, integer);
+        getClient(key).decrBy(key, integer);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<Long> decrBy(byte[] key, long integer) {
-        client.decrBy(key, integer);
+        getClient(key).decrBy(key, integer);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<Long> del(String key) {
-        client.del(key);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> del(String... keys) {
-        client.del(keys);
+        getClient(key).del(key);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<Long> del(byte[] key) {
-        client.del(key);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> del(byte[]... keys) {
-        client.del(keys);
+        getClient(key).del(key);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<String> echo(String string) {
-        client.echo(string);
+        getClient(string).echo(string);
         return getResponse(BuilderFactory.STRING);
     }
 
     public Response<byte[]> echo(byte[] string) {
-        client.echo(string);
+        getClient(string).echo(string);
         return getResponse(BuilderFactory.BYTE_ARRAY);
     }
 
     public Response<Boolean> exists(String key) {
-        client.exists(key);
+        getClient(key).exists(key);
         return getResponse(BuilderFactory.BOOLEAN);
     }
 
     public Response<Boolean> exists(byte[] key) {
-        client.exists(key);
+        getClient(key).exists(key);
         return getResponse(BuilderFactory.BOOLEAN);
     }
 
     public Response<Long> expire(String key, int seconds) {
-        client.expire(key, seconds);
+        getClient(key).expire(key, seconds);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<Long> expire(byte[] key, int seconds) {
-        client.expire(key, seconds);
+        getClient(key).expire(key, seconds);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<Long> expireAt(String key, long unixTime) {
-        client.expireAt(key, unixTime);
+        getClient(key).expireAt(key, unixTime);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<Long> expireAt(byte[] key, long unixTime) {
-        client.expireAt(key, unixTime);
+        getClient(key).expireAt(key, unixTime);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<String> get(String key) {
-        client.get(key);
+        getClient(key).get(key);
         return getResponse(BuilderFactory.STRING);
     }
 
     public Response<byte[]> get(byte[] key) {
-        client.get(key);
+        getClient(key).get(key);
         return getResponse(BuilderFactory.BYTE_ARRAY);
     }
 
     public Response<Boolean> getbit(String key, long offset) {
-        client.getbit(key, offset);
+        getClient(key).getbit(key, offset);
         return getResponse(BuilderFactory.BOOLEAN);
     }
 
     public Response<Boolean> getbit(byte[] key, long offset) {
-        client.getbit(key, offset);
+        getClient(key).getbit(key, offset);
         return getResponse(BuilderFactory.BOOLEAN);
     }
 
     public Response<String> getrange(String key, long startOffset,
                                      long endOffset) {
-        client.getrange(key, startOffset, endOffset);
+        getClient(key).getrange(key, startOffset, endOffset);
         return getResponse(BuilderFactory.STRING);
     }
 
     public Response<String> getSet(String key, String value) {
-        client.getSet(key, value);
+        getClient(key).getSet(key, value);
         return getResponse(BuilderFactory.STRING);
     }
 
     public Response<byte[]> getSet(byte[] key, byte[] value) {
-        client.getSet(key, value);
+        getClient(key).getSet(key, value);
         return getResponse(BuilderFactory.BYTE_ARRAY);
     }
 
     public Response<Long> getrange(byte[] key, long startOffset, long endOffset) {
-        client.getrange(key, startOffset, endOffset);
+        getClient(key).getrange(key, startOffset, endOffset);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<Long> hdel(String key, String field) {
-        client.hdel(key, field);
+        getClient(key).hdel(key, field);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<Long> hdel(byte[] key, byte[] field) {
-        client.hdel(key, field);
+        getClient(key).hdel(key, field);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<Boolean> hexists(String key, String field) {
-        client.hexists(key, field);
+        getClient(key).hexists(key, field);
         return getResponse(BuilderFactory.BOOLEAN);
     }
 
     public Response<Boolean> hexists(byte[] key, byte[] field) {
-        client.hexists(key, field);
+        getClient(key).hexists(key, field);
         return getResponse(BuilderFactory.BOOLEAN);
     }
 
     public Response<String> hget(String key, String field) {
-        client.hget(key, field);
+        getClient(key).hget(key, field);
         return getResponse(BuilderFactory.STRING);
     }
 
     public Response<byte[]> hget(byte[] key, byte[] field) {
-        client.hget(key, field);
+        getClient(key).hget(key, field);
         return getResponse(BuilderFactory.BYTE_ARRAY);
     }
 
     public Response<Map<String, String>> hgetAll(String key) {
-        client.hgetAll(key);
+        getClient(key).hgetAll(key);
         return getResponse(BuilderFactory.STRING_MAP);
     }
 
     public Response<Map<byte[], byte[]>> hgetAll(byte[] key) {
-        client.hgetAll(key);
+        getClient(key).hgetAll(key);
         return getResponse(BuilderFactory.BYTE_ARRAY_MAP);
     }
 
     public Response<Long> hincrBy(String key, String field, long value) {
-        client.hincrBy(key, field, value);
+        getClient(key).hincrBy(key, field, value);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<Long> hincrBy(byte[] key, byte[] field, long value) {
-        client.hincrBy(key, field, value);
+        getClient(key).hincrBy(key, field, value);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<Set<String>> hkeys(String key) {
-        client.hkeys(key);
+        getClient(key).hkeys(key);
         return getResponse(BuilderFactory.STRING_SET);
     }
 
     public Response<Set<byte[]>> hkeys(byte[] key) {
-        client.hkeys(key);
+        getClient(key).hkeys(key);
         return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
     }
 
     public Response<Long> hlen(String key) {
-        client.hlen(key);
+        getClient(key).hlen(key);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<Long> hlen(byte[] key) {
-        client.hlen(key);
+        getClient(key).hlen(key);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<List<String>> hmget(String key, String... fields) {
-        client.hmget(key, fields);
+        getClient(key).hmget(key, fields);
         return getResponse(BuilderFactory.STRING_LIST);
     }
 
     public Response<List<byte[]>> hmget(byte[] key, byte[]... fields) {
-        client.hmget(key, fields);
+        getClient(key).hmget(key, fields);
         return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
     }
 
     public Response<String> hmset(String key, Map<String, String> hash) {
-        client.hmset(key, hash);
+        getClient(key).hmset(key, hash);
         return getResponse(BuilderFactory.STRING);
     }
 
     public Response<String> hmset(byte[] key, Map<byte[], byte[]> hash) {
-        client.hmset(key, hash);
+        getClient(key).hmset(key, hash);
         return getResponse(BuilderFactory.STRING);
     }
 
     public Response<Long> hset(String key, String field, String value) {
-        client.hset(key, field, value);
+        getClient(key).hset(key, field, value);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<Long> hset(byte[] key, byte[] field, byte[] value) {
-        client.hset(key, field, value);
+        getClient(key).hset(key, field, value);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<Long> hsetnx(String key, String field, String value) {
-        client.hsetnx(key, field, value);
+        getClient(key).hsetnx(key, field, value);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<Long> hsetnx(byte[] key, byte[] field, byte[] value) {
-        client.hsetnx(key, field, value);
+        getClient(key).hsetnx(key, field, value);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<List<String>> hvals(String key) {
-        client.hvals(key);
+        getClient(key).hvals(key);
         return getResponse(BuilderFactory.STRING_LIST);
     }
 
     public Response<List<byte[]>> hvals(byte[] key) {
-        client.hvals(key);
+        getClient(key).hvals(key);
         return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
     }
 
     public Response<Long> incr(String key) {
-        client.incr(key);
+        getClient(key).incr(key);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<Long> incr(byte[] key) {
-        client.incr(key);
+        getClient(key).incr(key);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<Long> incrBy(String key, long integer) {
-        client.incrBy(key, integer);
+        getClient(key).incrBy(key, integer);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<Long> incrBy(byte[] key, long integer) {
-        client.incrBy(key, integer);
+        getClient(key).incrBy(key, integer);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<Set<String>> keys(String pattern) {
-        client.keys(pattern);
+        getClient(pattern).keys(pattern);
         return getResponse(BuilderFactory.STRING_SET);
     }
 
     public Response<Set<byte[]>> keys(byte[] pattern) {
-        client.keys(pattern);
+        getClient(pattern).keys(pattern);
         return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
     }
 
     public Response<String> lindex(String key, int index) {
-        client.lindex(key, index);
+        getClient(key).lindex(key, index);
         return getResponse(BuilderFactory.STRING);
     }
 
     public Response<byte[]> lindex(byte[] key, int index) {
-        client.lindex(key, index);
+        getClient(key).lindex(key, index);
         return getResponse(BuilderFactory.BYTE_ARRAY);
     }
 
     public Response<Long> linsert(String key, LIST_POSITION where,
                                   String pivot, String value) {
-        client.linsert(key, where, pivot, value);
+        getClient(key).linsert(key, where, pivot, value);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<Long> linsert(byte[] key, LIST_POSITION where,
                                   byte[] pivot, byte[] value) {
-        client.linsert(key, where, pivot, value);
+        getClient(key).linsert(key, where, pivot, value);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<Long> llen(String key) {
-        client.llen(key);
+        getClient(key).llen(key);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<Long> llen(byte[] key) {
-        client.llen(key);
+        getClient(key).llen(key);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<String> lpop(String key) {
-        client.lpop(key);
+        getClient(key).lpop(key);
         return getResponse(BuilderFactory.STRING);
     }
 
     public Response<byte[]> lpop(byte[] key) {
-        client.lpop(key);
+        getClient(key).lpop(key);
         return getResponse(BuilderFactory.BYTE_ARRAY);
     }
 
     public Response<Long> lpush(String key, String string) {
-        client.lpush(key, string);
+        getClient(key).lpush(key, string);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<Long> lpush(byte[] key, byte[] string) {
-        client.lpush(key, string);
+        getClient(key).lpush(key, string);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<Long> lpushx(String key, String string) {
-        client.lpushx(key, string);
+        getClient(key).lpushx(key, string);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<Long> lpushx(byte[] key, byte[] bytes) {
-        client.lpushx(key, bytes);
+        getClient(key).lpushx(key, bytes);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<List<String>> lrange(String key, long start, long end) {
-        client.lrange(key, start, end);
+        getClient(key).lrange(key, start, end);
         return getResponse(BuilderFactory.STRING_LIST);
     }
 
     public Response<List<byte[]>> lrange(byte[] key, long start, long end) {
-        client.lrange(key, start, end);
+        getClient(key).lrange(key, start, end);
         return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
     }
 
     public Response<Long> lrem(String key, long count, String value) {
-        client.lrem(key, count, value);
+        getClient(key).lrem(key, count, value);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<Long> lrem(byte[] key, long count, byte[] value) {
-        client.lrem(key, count, value);
+        getClient(key).lrem(key, count, value);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<String> lset(String key, long index, String value) {
-        client.lset(key, index, value);
+        getClient(key).lset(key, index, value);
         return getResponse(BuilderFactory.STRING);
     }
 
     public Response<String> lset(byte[] key, long index, byte[] value) {
-        client.lset(key, index, value);
+        getClient(key).lset(key, index, value);
         return getResponse(BuilderFactory.STRING);
     }
 
     public Response<String> ltrim(String key, long start, long end) {
-        client.ltrim(key, start, end);
+        getClient(key).ltrim(key, start, end);
         return getResponse(BuilderFactory.STRING);
     }
 
     public Response<String> ltrim(byte[] key, long start, long end) {
-        client.ltrim(key, start, end);
+        getClient(key).ltrim(key, start, end);
         return getResponse(BuilderFactory.STRING);
     }
 
-    public Response<List<String>> mget(String... keys) {
-        client.mget(keys);
-        return getResponse(BuilderFactory.STRING_LIST);
-    }
-
-    public Response<List<byte[]>> mget(byte[]... keys) {
-        client.mget(keys);
-        return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
-    }
-
     public Response<Long> move(String key, int dbIndex) {
-        client.move(key, dbIndex);
+        getClient(key).move(key, dbIndex);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<Long> move(byte[] key, int dbIndex) {
-        client.move(key, dbIndex);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<String> mset(String... keysvalues) {
-        client.mset(keysvalues);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<String> mset(byte[]... keysvalues) {
-        client.mset(keysvalues);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<Long> msetnx(String... keysvalues) {
-        client.msetnx(keysvalues);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> msetnx(byte[]... keysvalues) {
-        client.msetnx(keysvalues);
+        getClient(key).move(key, dbIndex);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<Long> persist(String key) {
-        client.persist(key);
+        getClient(key).persist(key);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<Long> persist(byte[] key) {
-        client.persist(key);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<String> rename(String oldkey, String newkey) {
-        client.rename(oldkey, newkey);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<String> rename(byte[] oldkey, byte[] newkey) {
-        client.rename(oldkey, newkey);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<Long> renamenx(String oldkey, String newkey) {
-        client.renamenx(oldkey, newkey);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> renamenx(byte[] oldkey, byte[] newkey) {
-        client.renamenx(oldkey, newkey);
+        getClient(key).persist(key);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<String> rpop(String key) {
-        client.rpop(key);
+        getClient(key).rpop(key);
         return getResponse(BuilderFactory.STRING);
     }
 
     public Response<byte[]> rpop(byte[] key) {
-        client.rpop(key);
-        return getResponse(BuilderFactory.BYTE_ARRAY);
-    }
-
-    public Response<String> rpoplpush(String srckey, String dstkey) {
-        client.rpoplpush(srckey, dstkey);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<byte[]> rpoplpush(byte[] srckey, byte[] dstkey) {
-        client.rpoplpush(srckey, dstkey);
+        getClient(key).rpop(key);
         return getResponse(BuilderFactory.BYTE_ARRAY);
     }
 
     public Response<Long> rpush(String key, String string) {
-        client.rpush(key, string);
+        getClient(key).rpush(key, string);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<Long> rpush(byte[] key, byte[] string) {
-        client.rpush(key, string);
+        getClient(key).rpush(key, string);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<Long> rpushx(String key, String string) {
-        client.rpushx(key, string);
+        getClient(key).rpushx(key, string);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<Long> rpushx(byte[] key, byte[] string) {
-        client.rpushx(key, string);
+        getClient(key).rpushx(key, string);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<Long> sadd(String key, String member) {
-        client.sadd(key, member);
+        getClient(key).sadd(key, member);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<Long> sadd(byte[] key, byte[] member) {
-        client.sadd(key, member);
+        getClient(key).sadd(key, member);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<Long> scard(String key) {
-        client.scard(key);
+        getClient(key).scard(key);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<Long> scard(byte[] key) {
-        client.scard(key);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Set<String>> sdiff(String... keys) {
-        client.sdiff(keys);
-        return getResponse(BuilderFactory.STRING_SET);
-    }
-
-    public Response<Set<byte[]>> sdiff(byte[]... keys) {
-        client.sdiff(keys);
-        return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
-    }
-
-    public Response<Long> sdiffstore(String dstkey, String... keys) {
-        client.sdiffstore(dstkey, keys);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> sdiffstore(byte[] dstkey, byte[]... keys) {
-        client.sdiffstore(dstkey, keys);
+        getClient(key).scard(key);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<String> set(String key, String value) {
-        client.set(key, value);
+        getClient(key).set(key, value);
         return getResponse(BuilderFactory.STRING);
     }
 
     public Response<String> set(byte[] key, byte[] value) {
-        client.set(key, value);
+        getClient(key).set(key, value);
         return getResponse(BuilderFactory.STRING);
     }
 
     public Response<Boolean> setbit(String key, long offset, boolean value) {
-        client.setbit(key, offset, value);
+        getClient(key).setbit(key, offset, value);
         return getResponse(BuilderFactory.BOOLEAN);
     }
 
     public Response<Boolean> setbit(byte[] key, long offset, byte[] value) {
-        client.setbit(key, offset, value);
+        getClient(key).setbit(key, offset, value);
         return getResponse(BuilderFactory.BOOLEAN);
     }
 
     public Response<String> setex(String key, int seconds, String value) {
-        client.setex(key, seconds, value);
+        getClient(key).setex(key, seconds, value);
         return getResponse(BuilderFactory.STRING);
     }
 
     public Response<String> setex(byte[] key, int seconds, byte[] value) {
-        client.setex(key, seconds, value);
+        getClient(key).setex(key, seconds, value);
         return getResponse(BuilderFactory.STRING);
     }
 
     public Response<Long> setnx(String key, String value) {
-        client.setnx(key, value);
+        getClient(key).setnx(key, value);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<Long> setnx(byte[] key, byte[] value) {
-        client.setnx(key, value);
+        getClient(key).setnx(key, value);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<Long> setrange(String key, long offset, String value) {
-        client.setrange(key, offset, value);
+        getClient(key).setrange(key, offset, value);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<Long> setrange(byte[] key, long offset, byte[] value) {
-        client.setrange(key, offset, value);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Set<String>> sinter(String... keys) {
-        client.sinter(keys);
-        return getResponse(BuilderFactory.STRING_SET);
-    }
-
-    public Response<Set<byte[]>> sinter(byte[]... keys) {
-        client.sinter(keys);
-        return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
-    }
-
-    public Response<Long> sinterstore(String dstkey, String... keys) {
-        client.sinterstore(dstkey, keys);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> sinterstore(byte[] dstkey, byte[]... keys) {
-        client.sinterstore(dstkey, keys);
+        getClient(key).setrange(key, offset, value);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<Boolean> sismember(String key, String member) {
-        client.sismember(key, member);
+        getClient(key).sismember(key, member);
         return getResponse(BuilderFactory.BOOLEAN);
     }
 
     public Response<Boolean> sismember(byte[] key, byte[] member) {
-        client.sismember(key, member);
+        getClient(key).sismember(key, member);
         return getResponse(BuilderFactory.BOOLEAN);
     }
 
     public Response<Set<String>> smembers(String key) {
-        client.smembers(key);
+        getClient(key).smembers(key);
         return getResponse(BuilderFactory.STRING_SET);
     }
 
     public Response<Set<byte[]>> smembers(byte[] key) {
-        client.smembers(key);
+        getClient(key).smembers(key);
         return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
     }
 
-    public Response<Long> smove(String srckey, String dstkey, String member) {
-        client.smove(srckey, dstkey, member);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> smove(byte[] srckey, byte[] dstkey, byte[] member) {
-        client.smove(srckey, dstkey, member);
-        return getResponse(BuilderFactory.LONG);
-    }
-
     public Response<List<String>> sort(String key) {
-        client.sort(key);
+        getClient(key).sort(key);
         return getResponse(BuilderFactory.STRING_LIST);
     }
 
     public Response<List<byte[]>> sort(byte[] key) {
-        client.sort(key);
+        getClient(key).sort(key);
         return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
     }
 
     public Response<List<String>> sort(String key,
                                        SortingParams sortingParameters) {
-        client.sort(key, sortingParameters);
+        getClient(key).sort(key, sortingParameters);
         return getResponse(BuilderFactory.STRING_LIST);
     }
 
     public Response<List<byte[]>> sort(byte[] key,
                                        SortingParams sortingParameters) {
-        client.sort(key, sortingParameters);
-        return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
-    }
-
-    public Response<List<String>> sort(String key,
-                                       SortingParams sortingParameters, String dstkey) {
-        client.sort(key, sortingParameters, dstkey);
-        return getResponse(BuilderFactory.STRING_LIST);
-    }
-
-    public Response<List<byte[]>> sort(byte[] key,
-                                       SortingParams sortingParameters, byte[] dstkey) {
-        client.sort(key, sortingParameters, dstkey);
-        return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
-    }
-
-    public Response<List<String>> sort(String key, String dstkey) {
-        client.sort(key, dstkey);
-        return getResponse(BuilderFactory.STRING_LIST);
-    }
-
-    public Response<List<byte[]>> sort(byte[] key, byte[] dstkey) {
-        client.sort(key, dstkey);
+        getClient(key).sort(key, sortingParameters);
         return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
     }
 
     public Response<String> spop(String key) {
-        client.spop(key);
+        getClient(key).spop(key);
         return getResponse(BuilderFactory.STRING);
     }
 
     public Response<byte[]> spop(byte[] key) {
-        client.spop(key);
+        getClient(key).spop(key);
         return getResponse(BuilderFactory.BYTE_ARRAY);
     }
 
     public Response<String> srandmember(String key) {
-        client.srandmember(key);
+        getClient(key).srandmember(key);
         return getResponse(BuilderFactory.STRING);
     }
 
     public Response<byte[]> srandmember(byte[] key) {
-        client.srandmember(key);
+        getClient(key).srandmember(key);
         return getResponse(BuilderFactory.BYTE_ARRAY);
     }
 
     public Response<Long> srem(String key, String member) {
-        client.srem(key, member);
+        getClient(key).srem(key, member);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<Long> srem(byte[] key, byte[] member) {
-        client.srem(key, member);
+        getClient(key).srem(key, member);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<Long> strlen(String key) {
-        client.strlen(key);
+        getClient(key).strlen(key);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<Long> strlen(byte[] key) {
-        client.strlen(key);
+        getClient(key).strlen(key);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<String> substr(String key, int start, int end) {
-        client.substr(key, start, end);
+        getClient(key).substr(key, start, end);
         return getResponse(BuilderFactory.STRING);
     }
 
     public Response<String> substr(byte[] key, int start, int end) {
-        client.substr(key, start, end);
+        getClient(key).substr(key, start, end);
         return getResponse(BuilderFactory.STRING);
     }
 
-    public Response<Set<String>> sunion(String... keys) {
-        client.sunion(keys);
-        return getResponse(BuilderFactory.STRING_SET);
-    }
-
-    public Response<Set<byte[]>> sunion(byte[]... keys) {
-        client.sunion(keys);
-        return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
-    }
-
-    public Response<Long> sunionstore(String dstkey, String... keys) {
-        client.sunionstore(dstkey, keys);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> sunionstore(byte[] dstkey, byte[]... keys) {
-        client.sunionstore(dstkey, keys);
-        return getResponse(BuilderFactory.LONG);
-    }
-
     public Response<Long> ttl(String key) {
-        client.ttl(key);
+        getClient(key).ttl(key);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<Long> ttl(byte[] key) {
-        client.ttl(key);
+        getClient(key).ttl(key);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<String> type(String key) {
-        client.type(key);
+        getClient(key).type(key);
         return getResponse(BuilderFactory.STRING);
     }
 
     public Response<String> type(byte[] key) {
-        client.type(key);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<String> watch(String... keys) {
-        client.watch(keys);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<String> watch(byte[]... keys) {
-        client.watch(keys);
+        getClient(key).type(key);
         return getResponse(BuilderFactory.STRING);
     }
 
     public Response<Long> zadd(String key, double score, String member) {
-        client.zadd(key, score, member);
+        getClient(key).zadd(key, score, member);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<Long> zadd(byte[] key, double score, byte[] member) {
-        client.zadd(key, score, member);
+        getClient(key).zadd(key, score, member);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<Long> zcard(String key) {
-        client.zcard(key);
+        getClient(key).zcard(key);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<Long> zcard(byte[] key) {
-        client.zcard(key);
+        getClient(key).zcard(key);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<Long> zcount(String key, double min, double max) {
-        client.zcount(key, min, max);
+        getClient(key).zcount(key, min, max);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<Long> zcount(byte[] key, double min, double max) {
-        client.zcount(key, toByteArray(min), toByteArray(max));
+        getClient(key).zcount(key, toByteArray(min), toByteArray(max));
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<Double> zincrby(String key, double score, String member) {
-        client.zincrby(key, score, member);
+        getClient(key).zincrby(key, score, member);
         return getResponse(BuilderFactory.DOUBLE);
     }
 
     public Response<Double> zincrby(byte[] key, double score, byte[] member) {
-        client.zincrby(key, score, member);
+        getClient(key).zincrby(key, score, member);
         return getResponse(BuilderFactory.DOUBLE);
     }
 
-    public Response<Long> zinterstore(String dstkey, String... sets) {
-        client.zinterstore(dstkey, sets);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> zinterstore(byte[] dstkey, byte[]... sets) {
-        client.zinterstore(dstkey, sets);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> zinterstore(String dstkey, ZParams params,
-                                      String... sets) {
-        client.zinterstore(dstkey, params, sets);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> zinterstore(byte[] dstkey, ZParams params,
-                                      byte[]... sets) {
-        client.zinterstore(dstkey, params, sets);
-        return getResponse(BuilderFactory.LONG);
-    }
-
     public Response<Set<String>> zrange(String key, int start, int end) {
-        client.zrange(key, start, end);
+        getClient(key).zrange(key, start, end);
         return getResponse(BuilderFactory.STRING_ZSET);
     }
 
     public Response<Set<byte[]>> zrange(byte[] key, int start, int end) {
-        client.zrange(key, start, end);
+        getClient(key).zrange(key, start, end);
         return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
     }
 
     public Response<Set<String>> zrangeByScore(String key, double min,
                                                double max) {
-        client.zrangeByScore(key, min, max);
+        getClient(key).zrangeByScore(key, min, max);
         return getResponse(BuilderFactory.STRING_ZSET);
     }
 
@@ -929,19 +712,19 @@ abstract class PipelineBase extends Queable implements
 
     public Response<Set<String>> zrangeByScore(String key, String min,
                                                String max) {
-        client.zrangeByScore(key, min, max);
+        getClient(key).zrangeByScore(key, min, max);
         return getResponse(BuilderFactory.STRING_ZSET);
     }
 
     public Response<Set<byte[]>> zrangeByScore(byte[] key, byte[] min,
                                                byte[] max) {
-        client.zrangeByScore(key, min, max);
+        getClient(key).zrangeByScore(key, min, max);
         return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
     }
 
     public Response<Set<String>> zrangeByScore(String key, double min,
                                                double max, int offset, int count) {
-        client.zrangeByScore(key, min, max, offset, count);
+        getClient(key).zrangeByScore(key, min, max, offset, count);
         return getResponse(BuilderFactory.STRING_ZSET);
     }
 
@@ -952,13 +735,13 @@ abstract class PipelineBase extends Queable implements
 
     public Response<Set<byte[]>> zrangeByScore(byte[] key, byte[] min,
                                                byte[] max, int offset, int count) {
-        client.zrangeByScore(key, min, max, offset, count);
+        getClient(key).zrangeByScore(key, min, max, offset, count);
         return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
     }
 
     public Response<Set<Tuple>> zrangeByScoreWithScores(String key, double min,
                                                         double max) {
-        client.zrangeByScoreWithScores(key, min, max);
+        getClient(key).zrangeByScoreWithScores(key, min, max);
         return getResponse(BuilderFactory.TUPLE_ZSET);
     }
 
@@ -969,354 +752,221 @@ abstract class PipelineBase extends Queable implements
 
     public Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, byte[] min,
                                                         byte[] max) {
-        client.zrangeByScoreWithScores(key, min, max);
+        getClient(key).zrangeByScoreWithScores(key, min, max);
         return getResponse(BuilderFactory.TUPLE_ZSET_BINARY);
     }
 
     public Response<Set<Tuple>> zrangeByScoreWithScores(String key, double min,
                                                         double max, int offset, int count) {
-        client.zrangeByScoreWithScores(key, min, max, offset, count);
+        getClient(key).zrangeByScoreWithScores(key, min, max, offset, count);
         return getResponse(BuilderFactory.TUPLE_ZSET);
     }
 
     public Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, double min,
                                                         double max, int offset, int count) {
-        client.zrangeByScoreWithScores(key, toByteArray(min), toByteArray(max), offset, count);
+        getClient(key).zrangeByScoreWithScores(key, toByteArray(min), toByteArray(max), offset, count);
         return getResponse(BuilderFactory.TUPLE_ZSET_BINARY);
     }
 
     public Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, byte[] min,
                                                         byte[] max, int offset, int count) {
-        client.zrangeByScoreWithScores(key, min, max, offset, count);
+        getClient(key).zrangeByScoreWithScores(key, min, max, offset, count);
         return getResponse(BuilderFactory.TUPLE_ZSET_BINARY);
     }
 
     public Response<Set<String>> zrevrangeByScore(String key, double max,
                                                   double min) {
-        client.zrevrangeByScore(key, max, min);
+        getClient(key).zrevrangeByScore(key, max, min);
         return getResponse(BuilderFactory.STRING_ZSET);
     }
 
     public Response<Set<byte[]>> zrevrangeByScore(byte[] key, double max,
                                                   double min) {
-        client.zrevrangeByScore(key, toByteArray(max), toByteArray(min));
+        getClient(key).zrevrangeByScore(key, toByteArray(max), toByteArray(min));
         return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
     }
 
     public Response<Set<String>> zrevrangeByScore(String key, String max,
                                                   String min) {
-        client.zrevrangeByScore(key, max, min);
+        getClient(key).zrevrangeByScore(key, max, min);
         return getResponse(BuilderFactory.STRING_ZSET);
     }
 
     public Response<Set<byte[]>> zrevrangeByScore(byte[] key, byte[] max,
                                                   byte[] min) {
-        client.zrevrangeByScore(key, max, min);
+        getClient(key).zrevrangeByScore(key, max, min);
         return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
     }
 
     public Response<Set<String>> zrevrangeByScore(String key, double max,
                                                   double min, int offset, int count) {
-        client.zrevrangeByScore(key, max, min, offset, count);
+        getClient(key).zrevrangeByScore(key, max, min, offset, count);
         return getResponse(BuilderFactory.STRING_ZSET);
     }
 
     public Response<Set<byte[]>> zrevrangeByScore(byte[] key, double max,
                                                   double min, int offset, int count) {
-        client.zrevrangeByScore(key, toByteArray(max), toByteArray(min), offset, count);
+        getClient(key).zrevrangeByScore(key, toByteArray(max), toByteArray(min), offset, count);
         return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
     }
 
     public Response<Set<byte[]>> zrevrangeByScore(byte[] key, byte[] max,
                                                   byte[] min, int offset, int count) {
-        client.zrevrangeByScore(key, max, min, offset, count);
+        getClient(key).zrevrangeByScore(key, max, min, offset, count);
         return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
     }
 
     public Response<Set<Tuple>> zrevrangeByScoreWithScores(String key,
                                                            double max, double min) {
-        client.zrevrangeByScoreWithScores(key, max, min);
+        getClient(key).zrevrangeByScoreWithScores(key, max, min);
         return getResponse(BuilderFactory.TUPLE_ZSET);
     }
 
     public Response<Set<Tuple>> zrevrangeByScoreWithScores(byte[] key,
                                                            double max, double min) {
-        client.zrevrangeByScoreWithScores(key, toByteArray(max), toByteArray(min));
+        getClient(key).zrevrangeByScoreWithScores(key, toByteArray(max), toByteArray(min));
         return getResponse(BuilderFactory.TUPLE_ZSET_BINARY);
     }
 
     public Response<Set<Tuple>> zrevrangeByScoreWithScores(byte[] key,
                                                            byte[] max, byte[] min) {
-        client.zrevrangeByScoreWithScores(key, max, min);
+        getClient(key).zrevrangeByScoreWithScores(key, max, min);
         return getResponse(BuilderFactory.TUPLE_ZSET_BINARY);
     }
 
     public Response<Set<Tuple>> zrevrangeByScoreWithScores(String key,
                                                            double max, double min, int offset, int count) {
-        client.zrevrangeByScoreWithScores(key, max, min, offset, count);
+        getClient(key).zrevrangeByScoreWithScores(key, max, min, offset, count);
         return getResponse(BuilderFactory.TUPLE_ZSET);
     }
 
     public Response<Set<Tuple>> zrevrangeByScoreWithScores(byte[] key,
                                                            double max, double min, int offset, int count) {
-        client.zrevrangeByScoreWithScores(key, toByteArray(max), toByteArray(min), offset, count);
+        getClient(key).zrevrangeByScoreWithScores(key, toByteArray(max), toByteArray(min), offset, count);
         return getResponse(BuilderFactory.TUPLE_ZSET_BINARY);
     }
 
     public Response<Set<Tuple>> zrevrangeByScoreWithScores(byte[] key,
                                                            byte[] max, byte[] min, int offset, int count) {
-        client.zrevrangeByScoreWithScores(key, max, min, offset, count);
+        getClient(key).zrevrangeByScoreWithScores(key, max, min, offset, count);
         return getResponse(BuilderFactory.TUPLE_ZSET_BINARY);
     }
 
     public Response<Set<Tuple>> zrangeWithScores(String key, int start, int end) {
-        client.zrangeWithScores(key, start, end);
+        getClient(key).zrangeWithScores(key, start, end);
         return getResponse(BuilderFactory.TUPLE_ZSET);
     }
 
     public Response<Set<Tuple>> zrangeWithScores(byte[] key, int start, int end) {
-        client.zrangeWithScores(key, start, end);
+        getClient(key).zrangeWithScores(key, start, end);
         return getResponse(BuilderFactory.TUPLE_ZSET_BINARY);
     }
 
     public Response<Long> zrank(String key, String member) {
-        client.zrank(key, member);
+        getClient(key).zrank(key, member);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<Long> zrank(byte[] key, byte[] member) {
-        client.zrank(key, member);
+        getClient(key).zrank(key, member);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<Long> zrem(String key, String member) {
-        client.zrem(key, member);
+        getClient(key).zrem(key, member);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<Long> zrem(byte[] key, byte[] member) {
-        client.zrem(key, member);
+        getClient(key).zrem(key, member);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<Long> zremrangeByRank(String key, int start, int end) {
-        client.zremrangeByRank(key, start, end);
+        getClient(key).zremrangeByRank(key, start, end);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<Long> zremrangeByRank(byte[] key, int start, int end) {
-        client.zremrangeByRank(key, start, end);
+        getClient(key).zremrangeByRank(key, start, end);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<Long> zremrangeByScore(String key, double start, double end) {
-        client.zremrangeByScore(key, start, end);
+        getClient(key).zremrangeByScore(key, start, end);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<Long> zremrangeByScore(byte[] key, double start, double end) {
-        client.zremrangeByScore(key, toByteArray(start), toByteArray(end));
+        getClient(key).zremrangeByScore(key, toByteArray(start), toByteArray(end));
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<Long> zremrangeByScore(byte[] key, byte[] start, byte[] end) {
-        client.zremrangeByScore(key, start, end);
+        getClient(key).zremrangeByScore(key, start, end);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<Set<String>> zrevrange(String key, int start, int end) {
-        client.zrevrange(key, start, end);
+        getClient(key).zrevrange(key, start, end);
         return getResponse(BuilderFactory.STRING_ZSET);
     }
 
     public Response<Set<byte[]>> zrevrange(byte[] key, int start, int end) {
-        client.zrevrange(key, start, end);
+        getClient(key).zrevrange(key, start, end);
         return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
     }
 
     public Response<Set<Tuple>> zrevrangeWithScores(String key, int start,
                                                     int end) {
-        client.zrevrangeWithScores(key, start, end);
+        getClient(key).zrevrangeWithScores(key, start, end);
         return getResponse(BuilderFactory.TUPLE_ZSET);
     }
 
     public Response<Set<Tuple>> zrevrangeWithScores(byte[] key, int start,
                                                     int end) {
-        client.zrevrangeWithScores(key, start, end);
+        getClient(key).zrevrangeWithScores(key, start, end);
         return getResponse(BuilderFactory.TUPLE_ZSET);
     }
 
     public Response<Long> zrevrank(String key, String member) {
-        client.zrevrank(key, member);
+        getClient(key).zrevrank(key, member);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<Long> zrevrank(byte[] key, byte[] member) {
-        client.zrevrank(key, member);
+        getClient(key).zrevrank(key, member);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<Double> zscore(String key, String member) {
-        client.zscore(key, member);
+        getClient(key).zscore(key, member);
         return getResponse(BuilderFactory.DOUBLE);
     }
 
     public Response<Double> zscore(byte[] key, byte[] member) {
-        client.zscore(key, member);
+        getClient(key).zscore(key, member);
         return getResponse(BuilderFactory.DOUBLE);
     }
 
-    public Response<Long> zunionstore(String dstkey, String... sets) {
-        client.zunionstore(dstkey, sets);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> zunionstore(byte[] dstkey, byte[]... sets) {
-        client.zunionstore(dstkey, sets);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> zunionstore(String dstkey, ZParams params,
-                                      String... sets) {
-        client.zunionstore(dstkey, params, sets);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> zunionstore(byte[] dstkey, ZParams params,
-                                      byte[]... sets) {
-        client.zunionstore(dstkey, params, sets);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<String> bgrewriteaof() {
-        client.bgrewriteaof();
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<String> bgsave() {
-        client.bgsave();
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<String> configGet(String pattern) {
-        client.configGet(pattern);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<String> configSet(String parameter, String value) {
-        client.configSet(parameter, value);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<String> brpoplpush(String source, String destination,
-                                       int timeout) {
-        client.brpoplpush(source, destination, timeout);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<byte[]> brpoplpush(byte[] source, byte[] destination,
-                                       int timeout) {
-        client.brpoplpush(source, destination, timeout);
-        return getResponse(BuilderFactory.BYTE_ARRAY);
-    }
-
-    public Response<String> configResetStat() {
-        client.configResetStat();
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<String> save() {
-        client.save();
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<Long> lastsave() {
-        client.lastsave();
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> publish(String channel, String message) {
-        client.publish(channel, message);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> publish(byte[] channel, byte[] message) {
-        client.publish(channel, message);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<String> randomKey() {
-        client.randomKey();
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<byte[]> randomKeyBinary() {
-        client.randomKey();
-        return getResponse(BuilderFactory.BYTE_ARRAY);
-    }
-
-    public Response<String> flushDB() {
-        client.flushDB();
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<String> flushAll() {
-        client.flushAll();
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<String> info() {
-        client.info();
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<Long> dbSize() {
-        client.dbSize();
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<String> shutdown() {
-        client.shutdown();
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<String> ping() {
-        client.ping();
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<String> select(int index) {
-        client.select(index);
-        return getResponse(BuilderFactory.STRING);
-    }
-
     public Response<Long> bitcount(String key) {
-        client.bitcount(key);
+        getClient(key).bitcount(key);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<Long> bitcount(String key, long start, long end) {
-        client.bitcount(key, start, end);
+        getClient(key).bitcount(key, start, end);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<Long> bitcount(byte[] key) {
-        client.bitcount(key);
+        getClient(key).bitcount(key);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<Long> bitcount(byte[] key, long start, long end) {
-        client.bitcount(key, start, end);
+        getClient(key).bitcount(key, start, end);
         return getResponse(BuilderFactory.LONG);
     }
 
-    public Response<Long> bitop(BitOP op, byte[] destKey, byte[]... srcKeys) {
-        client.bitop(op, destKey, srcKeys);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> bitop(BitOP op, String destKey, String... srcKeys) {
-        client.bitop(op, destKey, srcKeys);
-        return getResponse(BuilderFactory.LONG);
-    }
 }
diff --git a/src/main/java/redis/clients/jedis/ShardedJedisPipeline.java b/src/main/java/redis/clients/jedis/ShardedJedisPipeline.java
index 2601f9c..be6db92 100644
--- a/src/main/java/redis/clients/jedis/ShardedJedisPipeline.java
+++ b/src/main/java/redis/clients/jedis/ShardedJedisPipeline.java
@@ -1,12 +1,11 @@
 package redis.clients.jedis;
 
-import redis.clients.jedis.BinaryClient.LIST_POSITION;
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Queue;
 
-import java.util.*;
-
-import static redis.clients.jedis.Protocol.toByteArray;
-
-public class ShardedJedisPipeline extends Queable implements BinaryRedisPipeline, RedisPipeline {
+public class ShardedJedisPipeline extends PipelineBase {
     private BinaryShardedJedis jedis;
     private List<FutureResult> results = new ArrayList<FutureResult>();
     private Queue<Client> clients = new LinkedList<Client>();
@@ -27,1289 +26,6 @@ public class ShardedJedisPipeline extends Queable implements BinaryRedisPipeline
         this.jedis = jedis;
     }
 
-    public Response<String> set(String key, String value) {
-        Client c = getClient(key);
-        c.set(key, value);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<String> set(byte[] key, byte[] value) {
-        Client c = getClient(key);
-        c.set(key, value);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<String> get(String key) {
-        Client c = getClient(key);
-        c.get(key);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<byte[]> get(byte[] key) {
-        Client c = getClient(key);
-        c.get(key);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.BYTE_ARRAY);
-    }
-
-    public Response<List<byte[]>> blpop(byte[] arg) {
-        byte[][] temp = new byte[1][];
-        temp[0] = arg;
-        Client c = getClient(arg);
-        c.blpop(temp);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
-    }
-
-    public Response<List<byte[]>> brpop(byte[] arg) {
-        byte[][] temp = new byte[1][];
-        temp[0] = arg;
-        Client c = getClient(arg);
-        c.blpop(temp);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
-    }
-
-    public Response<List<String>> blpop(String arg) {
-        String[] temp = new String[1];
-        temp[0] = arg;
-        Client c = getClient(arg);
-        c.blpop(temp);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING_LIST);
-    }
-
-    public Response<List<String>> brpop(String arg) {
-        String[] temp = new String[1];
-        temp[0] = arg;
-        Client c = getClient(arg);
-        c.brpop(temp);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING_LIST);
-    }
-
-    public Response<Long> move(byte[] key, int dbIndex) {
-        Client c = getClient(key);
-        c.move(key, dbIndex);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> move(String key, int dbIndex) {
-        Client c = getClient(key);
-        c.move(key, dbIndex);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<byte[]> echo(byte[] string) {
-        Client c = getClient(string);
-        c.echo(string);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.BYTE_ARRAY);
-    }
-
-    public Response<String> echo(String string) {
-        Client c = getClient(string);
-        c.echo(string);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<Long> del(byte[] key) {
-        Client c = getClient(key);
-        c.del(key);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> del(String key) {
-        Client c = getClient(key);
-        c.del(key);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Boolean> exists(String key) {
-        Client c = getClient(key);
-        c.exists(key);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.BOOLEAN);
-    }
-
-    public Response<Boolean> exists(byte[] key) {
-        Client c = getClient(key);
-        c.exists(key);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.BOOLEAN);
-    }
-
-    public Response<String> type(String key) {
-        Client c = getClient(key);
-        c.type(key);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<String> type(byte[] key) {
-        Client c = getClient(key);
-        c.type(key);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<Long> expire(String key, int seconds) {
-        Client c = getClient(key);
-        c.expire(key, seconds);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> expire(byte[] key, int seconds) {
-        Client c = getClient(key);
-        c.expire(key, seconds);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> expireAt(String key, long unixTime) {
-        Client c = getClient(key);
-        c.expireAt(key, unixTime);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> expireAt(byte[] key, long unixTime) {
-        Client c = getClient(key);
-        c.expireAt(key, unixTime);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> ttl(String key) {
-        Client c = getClient(key);
-        c.ttl(key);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> ttl(byte[] key) {
-        Client c = getClient(key);
-        c.ttl(key);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<String> getSet(String key, String value) {
-        Client c = getClient(key);
-        c.getSet(key, value);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<byte[]> getSet(byte[] key, byte[] value) {
-        Client c = getClient(key);
-        c.getSet(key, value);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.BYTE_ARRAY);
-    }
-
-    public Response<Long> setnx(String key, String value) {
-        Client c = getClient(key);
-        c.setnx(key, value);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> setnx(byte[] key, byte[] value) {
-        Client c = getClient(key);
-        c.setnx(key, value);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<String> setex(String key, int seconds, String value) {
-        Client c = getClient(key);
-        c.setex(key, seconds, value);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<String> setex(byte[] key, int seconds, byte[] value) {
-        Client c = getClient(key);
-        c.setex(key, seconds, value);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<Long> decrBy(String key, long integer) {
-        Client c = getClient(key);
-        c.decrBy(key, integer);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> decrBy(byte[] key, long integer) {
-        Client c = getClient(key);
-        c.decrBy(key, integer);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> decr(String key) {
-        Client c = getClient(key);
-        c.decr(key);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> decr(byte[] key) {
-        Client c = getClient(key);
-        c.decr(key);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> incrBy(String key, long integer) {
-        Client c = getClient(key);
-        c.incrBy(key, integer);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> incrBy(byte[] key, long integer) {
-        Client c = getClient(key);
-        c.incrBy(key, integer);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> incr(String key) {
-        Client c = getClient(key);
-        c.incr(key);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> incr(byte[] key) {
-        Client c = getClient(key);
-        c.incr(key);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> append(String key, String value) {
-        Client c = getClient(key);
-        c.append(key, value);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> append(byte[] key, byte[] value) {
-        Client c = getClient(key);
-        c.append(key, value);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<String> substr(String key, int start, int end) {
-        Client c = getClient(key);
-        c.substr(key, start, end);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<String> substr(byte[] key, int start, int end) {
-        Client c = getClient(key);
-        c.substr(key, start, end);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<Long> hset(String key, String field, String value) {
-        Client c = getClient(key);
-        c.hset(key, field, value);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> hset(byte[] key, byte[] field, byte[] value) {
-        Client c = getClient(key);
-        c.hset(key, field, value);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<String> hget(String key, String field) {
-        Client c = getClient(key);
-        c.hget(key, field);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<byte[]> hget(byte[] key, byte[] field) {
-        Client c = getClient(key);
-        c.hget(key, field);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.BYTE_ARRAY);
-    }
-
-    public Response<Long> hsetnx(String key, String field, String value) {
-        Client c = getClient(key);
-        c.hsetnx(key, field, value);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> hsetnx(byte[] key, byte[] field, byte[] value) {
-        Client c = getClient(key);
-        c.hsetnx(key, field, value);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<String> hmset(String key, Map<String, String> hash) {
-        Client c = getClient(key);
-        c.hmset(key, hash);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<String> hmset(byte[] key, Map<byte[], byte[]> hash) {
-        Client c = getClient(key);
-        c.hmset(key, hash);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<List<String>> hmget(String key, String... fields) {
-        Client c = getClient(key);
-        c.hmget(key, fields);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING_LIST);
-    }
-
-    public Response<List<byte[]>> hmget(byte[] key, byte[]... fields) {
-        Client c = getClient(key);
-        c.hmget(key, fields);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
-    }
-
-    public Response<Long> hincrBy(String key, String field, long value) {
-        Client c = getClient(key);
-        c.hincrBy(key, field, value);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> hincrBy(byte[] key, byte[] field, long value) {
-        Client c = getClient(key);
-        c.hincrBy(key, field, value);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Boolean> hexists(String key, String field) {
-        Client c = getClient(key);
-        c.hexists(key, field);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.BOOLEAN);
-    }
-
-    public Response<Boolean> hexists(byte[] key, byte[] field) {
-        Client c = getClient(key);
-        c.hexists(key, field);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.BOOLEAN);
-    }
-
-    public Response<Long> hdel(String key, String field) {
-        Client c = getClient(key);
-        c.hdel(key, field);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> hdel(byte[] key, byte[] field) {
-        Client c = getClient(key);
-        c.hdel(key, field);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> hlen(String key) {
-        Client c = getClient(key);
-        c.hlen(key);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> hlen(byte[] key) {
-        Client c = getClient(key);
-        c.hlen(key);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Set<String>> hkeys(String key) {
-        Client c = getClient(key);
-        c.hkeys(key);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING_SET);
-    }
-
-    public Response<Set<byte[]>> hkeys(byte[] key) {
-        Client c = getClient(key);
-        c.hkeys(key);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
-    }
-
-    public Response<List<String>> hvals(String key) {
-        Client c = getClient(key);
-        c.hvals(key);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING_LIST);
-    }
-
-    public Response<List<byte[]>> hvals(byte[] key) {
-        Client c = getClient(key);
-        c.hvals(key);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
-    }
-
-    public Response<Map<String, String>> hgetAll(String key) {
-        Client c = getClient(key);
-        c.hgetAll(key);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING_MAP);
-    }
-
-    public Response<Map<byte[], byte[]>> hgetAll(byte[] key) {
-        Client c = getClient(key);
-        c.hgetAll(key);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.BYTE_ARRAY_MAP);
-    }
-
-    public Response<Long> rpush(String key, String string) {
-        Client c = getClient(key);
-        c.rpush(key, string);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> rpush(byte[] key, byte[] string) {
-        Client c = getClient(key);
-        c.rpush(key, string);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> rpushx(String key, String string) {
-        Client c = getClient(key);
-        c.rpushx(key, string);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> rpushx(byte[] key, byte[] string) {
-        Client c = getClient(key);
-        c.rpushx(key, string);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> lpush(String key, String string) {
-        Client c = getClient(key);
-        c.lpush(key, string);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> lpush(byte[] key, byte[] string) {
-        Client c = getClient(key);
-        c.lpush(key, string);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> lpushx(String key, String string) {
-        Client c = getClient(key);
-        c.lpushx(key, string);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> lpushx(byte[] key, byte[] bytes) {
-        Client c = getClient(key);
-        c.lpushx(key, bytes);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> llen(String key) {
-        Client c = getClient(key);
-        c.llen(key);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> llen(byte[] key) {
-        Client c = getClient(key);
-        c.llen(key);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<List<String>> lrange(String key, long start, long end) {
-        Client c = getClient(key);
-        c.lrange(key, start, end);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING_LIST);
-    }
-
-    public Response<List<byte[]>> lrange(byte[] key, long start, long end) {
-        Client c = getClient(key);
-        c.lrange(key, start, end);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
-    }
-
-    public Response<String> ltrim(String key, long start, long end) {
-        Client c = getClient(key);
-        c.ltrim(key, start, end);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<String> ltrim(byte[] key, long start, long end) {
-        Client c = getClient(key);
-        c.ltrim(key, start, end);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<Long> persist(String key) {
-        Client c = getClient(key);
-        c.persist(key);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> persist(byte[] key) {
-        Client c = getClient(key);
-        c.persist(key);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<String> lindex(String key, int index) {
-        Client c = getClient(key);
-        c.lindex(key, index);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<byte[]> lindex(byte[] key, int index) {
-        Client c = getClient(key);
-        c.lindex(key, index);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.BYTE_ARRAY);
-    }
-
-    public Response<String> lset(String key, long index, String value) {
-        Client c = getClient(key);
-        c.lset(key, index, value);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<String> lset(byte[] key, long index, byte[] value) {
-        Client c = getClient(key);
-        c.lset(key, index, value);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<Long> lrem(String key, long count, String value) {
-        Client c = getClient(key);
-        c.lrem(key, count, value);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> lrem(byte[] key, long count, byte[] value) {
-        Client c = getClient(key);
-        c.lrem(key, count, value);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<String> lpop(String key) {
-        Client c = getClient(key);
-        c.lpop(key);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<byte[]> lpop(byte[] key) {
-        Client c = getClient(key);
-        c.lpop(key);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.BYTE_ARRAY);
-    }
-
-    public Response<String> rpop(String key) {
-        Client c = getClient(key);
-        c.rpop(key);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<byte[]> rpop(byte[] key) {
-        Client c = getClient(key);
-        c.rpop(key);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.BYTE_ARRAY);
-    }
-
-    public Response<Long> sadd(String key, String member) {
-        Client c = getClient(key);
-        c.sadd(key, member);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> sadd(byte[] key, byte[] member) {
-        Client c = getClient(key);
-        c.sadd(key, member);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Set<String>> smembers(String key) {
-        Client c = getClient(key);
-        c.smembers(key);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING_SET);
-    }
-
-    public Response<Set<byte[]>> smembers(byte[] key) {
-        Client c = getClient(key);
-        c.smembers(key);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
-    }
-
-    public Response<Long> srem(String key, String member) {
-        Client c = getClient(key);
-        c.srem(key, member);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> srem(byte[] key, byte[] member) {
-        Client c = getClient(key);
-        c.srem(key, member);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> strlen(String key) {
-        Client c = getClient(key);
-        c.strlen(key);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> strlen(byte[] key) {
-        Client c = getClient(key);
-        c.strlen(key);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<String> spop(String key) {
-        Client c = getClient(key);
-        c.spop(key);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<byte[]> spop(byte[] key) {
-        Client c = getClient(key);
-        c.spop(key);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.BYTE_ARRAY);
-    }
-
-    public Response<Long> scard(String key) {
-        Client c = getClient(key);
-        c.scard(key);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> scard(byte[] key) {
-        Client c = getClient(key);
-        c.scard(key);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Boolean> sismember(String key, String member) {
-        Client c = getClient(key);
-        c.sismember(key, member);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.BOOLEAN);
-    }
-
-    public Response<Boolean> sismember(byte[] key, byte[] member) {
-        Client c = getClient(key);
-        c.sismember(key, member);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.BOOLEAN);
-    }
-
-    public Response<String> srandmember(String key) {
-        Client c = getClient(key);
-        c.srandmember(key);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<byte[]> srandmember(byte[] key) {
-        Client c = getClient(key);
-        c.srandmember(key);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.BYTE_ARRAY);
-    }
-
-    public Response<Long> zadd(String key, double score, String member) {
-        Client c = getClient(key);
-        c.zadd(key, score, member);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> zadd(byte[] key, double score, byte[] member) {
-        Client c = getClient(key);
-        c.zadd(key, score, member);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Set<String>> zrange(String key, int start, int end) {
-        Client c = getClient(key);
-        c.zrange(key, start, end);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING_ZSET);
-    }
-
-    public Response<Set<byte[]>> zrange(byte[] key, int start, int end) {
-        Client c = getClient(key);
-        c.zrange(key, start, end);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
-    }
-
-    public Response<Long> zrem(String key, String member) {
-        Client c = getClient(key);
-        c.zrem(key, member);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> zrem(byte[] key, byte[] member) {
-        Client c = getClient(key);
-        c.zrem(key, member);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Double> zincrby(String key, double score, String member) {
-        Client c = getClient(key);
-        c.zincrby(key, score, member);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.DOUBLE);
-    }
-
-    public Response<Double> zincrby(byte[] key, double score, byte[] member) {
-        Client c = getClient(key);
-        c.zincrby(key, score, member);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.DOUBLE);
-    }
-
-    public Response<Long> zrank(String key, String member) {
-        Client c = getClient(key);
-        c.zrank(key, member);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> zrank(byte[] key, byte[] member) {
-        Client c = getClient(key);
-        c.zrank(key, member);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> zrevrank(String key, String member) {
-        Client c = getClient(key);
-        c.zrevrank(key, member);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> zrevrank(byte[] key, byte[] member) {
-        Client c = getClient(key);
-        c.zrevrank(key, member);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Set<String>> zrevrange(String key, int start, int end) {
-        Client c = getClient(key);
-        c.zrevrange(key, start, end);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING_ZSET);
-    }
-
-    public Response<Set<byte[]>> zrevrange(byte[] key, int start, int end) {
-        Client c = getClient(key);
-        c.zrevrange(key, start, end);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
-    }
-
-    public Response<Set<Tuple>> zrangeWithScores(String key, int start, int end) {
-        Client c = getClient(key);
-        c.zrangeWithScores(key, start, end);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.TUPLE_ZSET);
-    }
-
-    public Response<Set<Tuple>> zrangeWithScores(byte[] key, int start, int end) {
-        Client c = getClient(key);
-        c.zrangeWithScores(key, start, end);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.TUPLE_ZSET);
-    }
-
-    public Response<Set<Tuple>> zrevrangeWithScores(String key, int start, int end) {
-        Client c = getClient(key);
-        c.zrevrangeWithScores(key, start, end);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.TUPLE_ZSET);
-    }
-
-    public Response<Set<Tuple>> zrevrangeWithScores(byte[] key, int start, int end) {
-        Client c = getClient(key);
-        c.zrevrangeWithScores(key, start, end);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.TUPLE_ZSET);
-    }
-
-    public Response<Long> zcard(String key) {
-        Client c = getClient(key);
-        c.zcard(key);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> zcard(byte[] key) {
-        Client c = getClient(key);
-        c.zcard(key);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Double> zscore(String key, String member) {
-        Client c = getClient(key);
-        c.zscore(key, member);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.DOUBLE);
-    }
-
-    public Response<Double> zscore(byte[] key, byte[] member) {
-        Client c = getClient(key);
-        c.zscore(key, member);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.DOUBLE);
-    }
-
-    public Response<List<String>> sort(String key) {
-        Client c = getClient(key);
-        c.sort(key);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING_LIST);
-    }
-
-    public Response<List<byte[]>> sort(byte[] key) {
-        Client c = getClient(key);
-        c.sort(key);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
-    }
-
-    public Response<List<String>> sort(String key, SortingParams sortingParameters) {
-        Client c = getClient(key);
-        c.sort(key, sortingParameters);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING_LIST);
-    }
-
-    public Response<List<byte[]>> sort(byte[] key, SortingParams sortingParameters) {
-        Client c = getClient(key);
-        c.sort(key, sortingParameters);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
-    }
-
-    public Response<Long> zcount(String key, double min, double max) {
-        Client c = getClient(key);
-        c.zcount(key, min, max);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> zcount(byte[] key, double min, double max) {
-        Client c = getClient(key);
-        c.zcount(key, toByteArray(min), toByteArray(max));
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Set<String>> zrevrangeByScore(String key, String max, String min) {
-        Client c = getClient(key);
-        c.zrevrangeByScore(key, min, max);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING_ZSET);
-    }
-
-    public Response<Set<String>> zrevrangeByScore(String key, double max, double min) {
-        Client c = getClient(key);
-        c.zrevrangeByScore(key, min, max);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING_ZSET);
-    }
-
-    public Response<Set<byte[]>> zrevrangeByScore(byte[] key, double max, double min) {
-        Client c = getClient(key);
-        c.zrevrangeByScore(key, toByteArray(min), toByteArray(max));
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
-    }
-
-    public Response<Set<byte[]>> zrevrangeByScore(byte[] key, byte[] max, byte[] min) {
-        Client c = getClient(key);
-        c.zrevrangeByScore(key, min, max);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
-    }
-
-    public Response<Set<String>> zrevrangeByScore(String key, double max, double min, int offset, int count) {
-        Client c = getClient(key);
-        c.zrevrangeByScore(key, min, max, offset, count);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING_ZSET);
-    }
-
-    public Response<Set<byte[]>> zrevrangeByScore(byte[] key, double max, double min, int offset, int count) {
-        Client c = getClient(key);
-        c.zrevrangeByScore(key, toByteArray(min), toByteArray(max), offset, count);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
-    }
-
-    public Response<Set<byte[]>> zrevrangeByScore(byte[] key, byte[] max, byte[] min, int offset, int count) {
-        Client c = getClient(key);
-        c.zrevrangeByScore(key, min, max, offset, count);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
-    }
-
-    public Response<Set<String>> zrangeByScore(String key, String min, String max) {
-        Client c = getClient(key);
-        c.zrangeByScore(key, min, max);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING_ZSET);
-    }
-
-    public Response<Set<String>> zrangeByScore(String key, double min, double max) {
-        Client c = getClient(key);
-        c.zrangeByScore(key, min, max);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING_ZSET);
-    }
-
-    public Response<Set<byte[]>> zrangeByScore(byte[] key, double min, double max) {
-        Client c = getClient(key);
-        c.zrangeByScore(key, toByteArray(min), toByteArray(max));
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
-    }
-
-    public Response<Set<byte[]>> zrangeByScore(byte[] key, byte[] min, byte[] max) {
-        Client c = getClient(key);
-        c.zrangeByScore(key, min, max);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
-    }
-
-    public Response<Set<String>> zrangeByScore(String key, double min, double max,
-                                               int offset, int count) {
-        Client c = getClient(key);
-        c.zrangeByScore(key, min, max, offset, count);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING_ZSET);
-    }
-
-    public Response<Set<byte[]>> zrangeByScore(byte[] key, double min, double max,
-                                               int offset, int count) {
-        Client c = getClient(key);
-        c.zrangeByScore(key, toByteArray(min), toByteArray(max), offset, count);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
-    }
-
-    public Response<Set<byte[]>> zrangeByScore(byte[] key, byte[] min, byte[] max,
-                                               int offset, int count) {
-        Client c = getClient(key);
-        c.zrangeByScore(key, min, max, offset, count);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
-    }
-
-    public Response<Set<Tuple>> zrangeByScoreWithScores(String key, double min, double max) {
-        Client c = getClient(key);
-        c.zrangeByScoreWithScores(key, min, max);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.TUPLE_ZSET);
-    }
-
-    public Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, double min, double max) {
-        Client c = getClient(key);
-        c.zrangeByScoreWithScores(key, toByteArray(min), toByteArray(max));
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.TUPLE_ZSET);
-    }
-
-    public Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max) {
-        Client c = getClient(key);
-        c.zrangeByScoreWithScores(key, min, max);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.TUPLE_ZSET);
-    }
-
-    public Response<Set<Tuple>> zrangeByScoreWithScores(String key, double min, double max,
-            int offset, int count) {
-        Client c = getClient(key);
-        c.zrangeByScoreWithScores(key, min, max, offset, count);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.TUPLE_ZSET);
-    }
-
-    public Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, double min, double max,
-            int offset, int count) {
-        Client c = getClient(key);
-        c.zrangeByScoreWithScores(key, toByteArray(min), toByteArray(max), offset, count);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.TUPLE_ZSET);
-    }
-
-    public Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max,
-            int offset, int count) {
-        Client c = getClient(key);
-        c.zrangeByScoreWithScores(key, min, max, offset, count);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.TUPLE_ZSET);
-    }
-
-    public Response<Set<Tuple>> zrevrangeByScoreWithScores(String key, double max, double min) {
-        Client c = getClient(key);
-        c.zrevrangeByScoreWithScores(key, min, max);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.TUPLE_ZSET);
-    }
-
-    public Response<Set<Tuple>> zrevrangeByScoreWithScores(byte[] key, double max, double min) {
-        Client c = getClient(key);
-        c.zrevrangeByScoreWithScores(key, toByteArray(min), toByteArray(max));
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.TUPLE_ZSET);
-    }
-
-    public Response<Set<Tuple>> zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min) {
-        Client c = getClient(key);
-        c.zrevrangeByScoreWithScores(key, min, max);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.TUPLE_ZSET);
-    }
-
-    public Response<Set<Tuple>> zrevrangeByScoreWithScores(String key, double max, double min, int offset, int count) {
-        Client c = getClient(key);
-        c.zrevrangeByScoreWithScores(key, min, max, offset, count);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.TUPLE_ZSET);
-    }
-
-    public Response<Set<Tuple>> zrevrangeByScoreWithScores(byte[] key, double max, double min, int offset, int count) {
-        Client c = getClient(key);
-        c.zrevrangeByScoreWithScores(key, toByteArray(min), toByteArray(max), offset, count);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.TUPLE_ZSET);
-    }
-
-    public Response<Set<Tuple>> zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min, int offset, int count) {
-        Client c = getClient(key);
-        c.zrevrangeByScoreWithScores(key, min, max, offset, count);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.TUPLE_ZSET);
-    }
-
-    public Response<Long> zremrangeByRank(String key, int start, int end) {
-        Client c = getClient(key);
-        c.zremrangeByRank(key, start, end);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> zremrangeByRank(byte[] key, int start, int end) {
-        Client c = getClient(key);
-        c.zremrangeByRank(key, start, end);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> zremrangeByScore(String key, double start, double end) {
-        Client c = getClient(key);
-        c.zremrangeByScore(key, start, end);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> zremrangeByScore(byte[] key, double start, double end) {
-        Client c = getClient(key);
-        c.zremrangeByScore(key, toByteArray(start), toByteArray(end));
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> zremrangeByScore(byte[] key, byte[] start, byte[] end) {
-        Client c = getClient(key);
-        c.zremrangeByScore(key, start, end);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> linsert(String key, LIST_POSITION where, String pivot,
-                                  String value) {
-        Client c = getClient(key);
-        c.linsert(key, where, pivot, value);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> linsert(byte[] key, LIST_POSITION where, byte[] pivot,
-                                  byte[] value) {
-        Client c = getClient(key);
-        c.linsert(key, where, pivot, value);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Boolean> getbit(String key, long offset) {
-        Client c = getClient(key);
-        c.getbit(key, offset);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.BOOLEAN);
-    }
-
-    public Response<Boolean> getbit(byte[] key, long offset) {
-        Client c = getClient(key);
-        c.getbit(key, offset);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.BOOLEAN);
-    }
-
-    public Response<Boolean> setbit(String key, long offset, boolean value) {
-        Client c = getClient(key);
-        c.setbit(key, offset, value);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.BOOLEAN);
-    }
-
-    public Response<Boolean> setbit(byte[] key, long offset, byte[] value) {
-        Client c = getClient(key);
-        c.setbit(key, offset, value);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.BOOLEAN);
-    }
-
-    public Response<Long> setrange(String key, long offset, String value) {
-        Client c = getClient(key);
-        c.setrange(key, offset, value);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> setrange(byte[] key, long offset, byte[] value) {
-        Client c = getClient(key);
-        c.setrange(key, offset, value);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<String> getrange(String key, long startOffset, long endOffset) {
-        Client c = getClient(key);
-        c.getrange(key, startOffset, endOffset);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<Long> getrange(byte[] key, long startOffset, long endOffset) {
-        Client c = getClient(key);
-        c.getrange(key, startOffset, endOffset);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> bitcount(String key) {
-        Client c = getClient(key);
-        c.bitcount(key);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> bitcount(String key, long start, long end) {
-        Client c = getClient(key);
-        c.bitcount(key, start, end);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> bitcount(byte[] key) {
-        Client c = getClient(key);
-        c.bitcount(key);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> bitcount(byte[] key, long start, long end) {
-        Client c = getClient(key);
-        c.bitcount(key, start, end);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
     public List<Object> getResults() {
         List<Object> r = new ArrayList<Object>();
         for (FutureResult fr : results) {
@@ -1353,15 +69,19 @@ public class ShardedJedisPipeline extends Queable implements BinaryRedisPipeline
     public void execute() {
     }
 
-    private Client getClient(String key) {
+    @Override
+    protected Client getClient(String key) {
         Client client = jedis.getShard(key).getClient();
         clients.add(client);
+        results.add(new FutureResult(client));
         return client;
     }
 
-    private Client getClient(byte[] key) {
+    @Override
+    protected Client getClient(byte[] key) {
         Client client = jedis.getShard(key).getClient();
         clients.add(client);
+        results.add(new FutureResult(client));
         return client;
     }
 }
\ No newline at end of file
diff --git a/src/main/java/redis/clients/jedis/Transaction.java b/src/main/java/redis/clients/jedis/Transaction.java
index 1629b59..bca7157 100644
--- a/src/main/java/redis/clients/jedis/Transaction.java
+++ b/src/main/java/redis/clients/jedis/Transaction.java
@@ -8,7 +8,7 @@ import java.util.List;
 /**
  * Transaction is nearly identical to Pipeline, only differences are the multi/discard behaviors
  */
-public class Transaction extends PipelineBase {
+public class Transaction extends MultiKeyPipelineBase {
 
     protected boolean inTransaction = true;
 
@@ -20,6 +20,16 @@ public class Transaction extends PipelineBase {
         this.client = client;
     }
 
+    @Override
+    protected Client getClient(String key) {
+        return client;
+    }
+
+    @Override
+    protected Client getClient(byte[] key) {
+        return client;
+    }
+
     public List<Object> exec() {
         client.exec();
         client.getAll(1); // Discard all but the last reply
diff --git a/src/main/java/redis/clients/jedis/TransactionBlock.java b/src/main/java/redis/clients/jedis/TransactionBlock.java
index 87df232..e784e19 100644
--- a/src/main/java/redis/clients/jedis/TransactionBlock.java
+++ b/src/main/java/redis/clients/jedis/TransactionBlock.java
@@ -13,6 +13,6 @@ public abstract class TransactionBlock extends Transaction {
     public abstract void execute() throws JedisException;
 
     public void setClient(Client client) {
-	this.client = client;
+	    this.client = client;
     }
 }