From bf9bba6ef221d5e9cb73232ac75576e18710becd Mon Sep 17 00:00:00 2001
From: guycoleman <gtc+github@mm.st>
Date: Tue, 4 Dec 2012 17:21:43 +0000
Subject: [PATCH] Extract string and binary common interfaces for Pipline and
 ShardedJedisPipeline. While I'm here add missing binary methods for some bit
 operations and fix return types for some sharded operations (e.g. getType)

---
 .../clients/jedis/BinaryRedisPipeline.java    | 205 +++++
 .../java/redis/clients/jedis/Pipeline.java    |  92 ++-
 .../redis/clients/jedis/RedisPipeline.java    | 184 +++++
 .../clients/jedis/ShardedJedisPipeline.java   | 725 +++++++++++++++++-
 4 files changed, 1153 insertions(+), 53 deletions(-)
 create mode 100644 src/main/java/redis/clients/jedis/BinaryRedisPipeline.java
 create mode 100644 src/main/java/redis/clients/jedis/RedisPipeline.java

diff --git a/src/main/java/redis/clients/jedis/BinaryRedisPipeline.java b/src/main/java/redis/clients/jedis/BinaryRedisPipeline.java
new file mode 100644
index 0000000..24b6089
--- /dev/null
+++ b/src/main/java/redis/clients/jedis/BinaryRedisPipeline.java
@@ -0,0 +1,205 @@
+package redis.clients.jedis;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * @author guy
+ */
+public interface BinaryRedisPipeline {
+    Response<Long> append(byte[] key, byte[] value);
+
+    Response<Long> decr(byte[] key);
+
+    Response<Long> decrBy(byte[] key, long integer);
+
+    Response<Boolean> exists(byte[] key);
+
+    Response<Long> expire(byte[] key, int seconds);
+
+    Response<Long> expireAt(byte[] key, long unixTime);
+
+    Response<byte[]> get(byte[] key);
+
+    Response<Boolean> getbit(byte[] key, long offset);
+
+    Response<byte[]> getSet(byte[] key, byte[] value);
+
+    Response<Long> getrange(byte[] key, long startOffset, long endOffset);
+
+    Response<Long> hdel(byte[] key, byte[] field);
+
+    Response<Boolean> hexists(byte[] key, byte[] field);
+
+    Response<String> hget(byte[] key, byte[] field);
+
+    Response<Map<String, String>> hgetAll(byte[] key);
+
+    Response<Long> hincrBy(byte[] key, byte[] field, long value);
+
+    Response<Set<String>> hkeys(byte[] key);
+
+    Response<Long> hlen(byte[] key);
+
+    Response<List<String>> hmget(byte[] key, byte[]... fields);
+
+    Response<String> hmset(byte[] key, Map<byte[], byte[]> hash);
+
+    Response<Long> hset(byte[] key, byte[] field, byte[] value);
+
+    Response<Long> hsetnx(byte[] key, byte[] field, byte[] value);
+
+    Response<List<String>> hvals(byte[] key);
+
+    Response<Long> incr(byte[] key);
+
+    Response<Long> incrBy(byte[] key, long integer);
+
+    Response<String> lindex(byte[] key, int index);
+
+    Response<Long> linsert(byte[] key, BinaryClient.LIST_POSITION where,
+                           byte[] pivot, byte[] value);
+
+    Response<Long> llen(byte[] key);
+
+    Response<String> lpop(byte[] key);
+
+    Response<Long> lpush(byte[] key, byte[] string);
+
+    Response<Long> lpushx(byte[] key, byte[] bytes);
+
+    Response<List<String>> lrange(byte[] key, long start, long end);
+
+    Response<Long> lrem(byte[] key, long count, byte[] value);
+
+    Response<String> lset(byte[] key, long index, byte[] value);
+
+    Response<String> ltrim(byte[] key, long start, long end);
+
+    Response<Long> persist(byte[] key);
+
+    Response<String> rpop(byte[] key);
+
+    Response<Long> rpush(byte[] key, byte[] string);
+
+    Response<Long> rpushx(byte[] key, byte[] string);
+
+    Response<Long> sadd(byte[] key, byte[] member);
+
+    Response<Long> scard(byte[] key);
+
+    Response<String> set(byte[] key, byte[] value);
+
+    Response<Boolean> setbit(byte[] key, long offset, byte[] value);
+
+    Response<Long> setrange(byte[] key, long offset, byte[] value);
+
+    Response<String> setex(byte[] key, int seconds, byte[] value);
+
+    Response<Long> setnx(byte[] key, byte[] value);
+
+    Response<Long> setrange(String key, long offset, String value);
+
+    Response<Set<String>> smembers(byte[] key);
+
+    Response<Boolean> sismember(byte[] key, byte[] member);
+
+    Response<Long> sort(byte[] key);
+
+    Response<List<String>> sort(byte[] key,
+                                SortingParams sortingParameters);
+
+    Response<String> spop(byte[] key);
+
+    Response<String> srandmember(byte[] key);
+
+    Response<Long> srem(byte[] key, byte[] member);
+
+    Response<Long> strlen(byte[] key);
+
+    Response<String> substr(byte[] key, int start, int end);
+
+    Response<Long> ttl(byte[] key);
+
+    Response<String> type(byte[] key);
+
+    Response<Long> zadd(byte[] key, double score, byte[] member);
+
+    Response<Long> zcard(byte[] key);
+
+    Response<Long> zcount(byte[] key, double min, double max);
+
+    Response<Double> zincrby(byte[] key, double score, byte[] member);
+
+    Response<Set<String>> zrange(byte[] key, int start, int end);
+
+    Response<Set<String>> zrangeByScore(byte[] key, double min,
+                                        double max);
+
+    Response<Set<String>> zrangeByScore(byte[] key, byte[] min,
+                                        byte[] max);
+
+    Response<Set<String>> zrangeByScore(byte[] key, double min,
+                                        double max, int offset, int count);
+
+    Response<Set<String>> zrangeByScore(byte[] key, byte[] min,
+                                        byte[] max, int offset, int count);
+
+    Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, double min,
+                                                 double max);
+
+    Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, byte[] min,
+                                                 byte[] max);
+
+    Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, double min,
+                                                 double max, int offset, int count);
+
+    Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, byte[] min,
+                                                 byte[] max, int offset, int count);
+
+    Response<Set<String>> zrevrangeByScore(byte[] key, double max,
+                                           double min);
+
+    Response<Set<String>> zrevrangeByScore(byte[] key, byte[] max,
+                                           byte[] min);
+
+    Response<Set<String>> zrevrangeByScore(byte[] key, double max,
+                                           double min, int offset, int count);
+
+    Response<Set<String>> zrevrangeByScore(byte[] key, byte[] max,
+                                           byte[] min, int offset, int count);
+
+    Response<Set<Tuple>> zrevrangeByScoreWithScores(byte[] key,
+                                                    double max, double min);
+
+    Response<Set<Tuple>> zrevrangeByScoreWithScores(byte[] key,
+                                                    byte[] max, byte[] min);
+
+    Response<Set<Tuple>> zrevrangeByScoreWithScores(byte[] key,
+                                                    double max, double min, int offset, int count);
+
+    Response<Set<Tuple>> zrevrangeByScoreWithScores(byte[] key,
+                                                    byte[] max, byte[] min, int offset, int count);
+
+    Response<Set<Tuple>> zrangeWithScores(byte[] key, int start, int end);
+
+    Response<Long> zrank(byte[] key, byte[] member);
+
+    Response<Long> zrem(byte[] key, byte[] member);
+
+    Response<Long> zremrangeByRank(byte[] key, int start, int end);
+
+    Response<Long> zremrangeByScore(byte[] key, double start, double end);
+
+    Response<Long> zremrangeByScore(byte[] key, byte[] start, byte[] end);
+
+    Response<Set<String>> zrevrange(byte[] key, int start, int end);
+
+    Response<Set<Tuple>> zrevrangeWithScores(byte[] key, int start,
+                                             int end);
+
+    Response<Long> zrevrank(byte[] key, byte[] member);
+
+    Response<Double> zscore(byte[] key, byte[] member);
+}
diff --git a/src/main/java/redis/clients/jedis/Pipeline.java b/src/main/java/redis/clients/jedis/Pipeline.java
index d89efea..a85fceb 100644
--- a/src/main/java/redis/clients/jedis/Pipeline.java
+++ b/src/main/java/redis/clients/jedis/Pipeline.java
@@ -9,7 +9,7 @@ import java.util.Set;
 import redis.clients.jedis.BinaryClient.LIST_POSITION;
 import redis.clients.jedis.exceptions.JedisDataException;
 
-public class Pipeline extends Queable {
+public class Pipeline extends Queable implements BinaryRedisPipeline, RedisPipeline {
 	
     private MultiResponseBuilder currentMulti;
     
@@ -209,8 +209,13 @@ public class Pipeline extends Queable {
         return getResponse(BuilderFactory.BOOLEAN);
     }
 
+    public Response<Boolean> getbit(byte[] key, long offset) {
+        client.getbit(key, offset);
+        return getResponse(BuilderFactory.BOOLEAN);
+    }
+
     public Response<String> getrange(String key, long startOffset,
-            long endOffset) {
+                                     long endOffset) {
         client.getrange(key, startOffset, endOffset);
         return getResponse(BuilderFactory.STRING);
     }
@@ -225,6 +230,11 @@ public class Pipeline extends Queable {
         return getResponse(BuilderFactory.BYTE_ARRAY);
     }
 
+    public Response<Long> getrange(byte[] key, long startOffset, long endOffset) {
+        client.getrange(key, startOffset, endOffset);
+        return getResponse(BuilderFactory.LONG);
+    }
+
     public Response<Long> hdel(String key, String field) {
         client.hdel(key, field);
         return getResponse(BuilderFactory.LONG);
@@ -386,13 +396,13 @@ public class Pipeline extends Queable {
     }
 
     public Response<Long> linsert(String key, LIST_POSITION where,
-            String pivot, String value) {
+                                  String pivot, String value) {
         client.linsert(key, where, pivot, value);
         return getResponse(BuilderFactory.LONG);
     }
 
     public Response<Long> linsert(byte[] key, LIST_POSITION where,
-            byte[] pivot, byte[] value) {
+                                  byte[] pivot, byte[] value) {
         client.linsert(key, where, pivot, value);
         return getResponse(BuilderFactory.LONG);
     }
@@ -642,6 +652,11 @@ public class Pipeline extends Queable {
         return getResponse(BuilderFactory.BOOLEAN);
     }
 
+    public Response<Boolean> setbit(byte[] key, long offset, byte[] value) {
+        client.setbit(key, offset, value);
+        return getResponse(BuilderFactory.BOOLEAN);
+    }
+
     public Response<String> setex(String key, int seconds, String value) {
         client.setex(key, seconds, value);
         return getResponse(BuilderFactory.STRING);
@@ -667,6 +682,11 @@ public class Pipeline extends Queable {
         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);
@@ -728,25 +748,25 @@ public class Pipeline extends Queable {
     }
 
     public Response<List<String>> sort(String key,
-            SortingParams sortingParameters) {
+                                       SortingParams sortingParameters) {
         client.sort(key, sortingParameters);
         return getResponse(BuilderFactory.STRING_LIST);
     }
 
     public Response<List<String>> sort(byte[] key,
-            SortingParams sortingParameters) {
+                                       SortingParams sortingParameters) {
         client.sort(key, sortingParameters);
         return getResponse(BuilderFactory.STRING_LIST);
     }
 
     public Response<List<String>> sort(String key,
-            SortingParams sortingParameters, String dstkey) {
+                                       SortingParams sortingParameters, String dstkey) {
         client.sort(key, sortingParameters, dstkey);
         return getResponse(BuilderFactory.STRING_LIST);
     }
 
     public Response<List<String>> sort(byte[] key,
-            SortingParams sortingParameters, byte[] dstkey) {
+                                       SortingParams sortingParameters, byte[] dstkey) {
         client.sort(key, sortingParameters, dstkey);
         return getResponse(BuilderFactory.STRING_LIST);
     }
@@ -934,154 +954,154 @@ public class Pipeline extends Queable {
     }
 
     public Response<Set<String>> zrangeByScore(String key, double min,
-            double max) {
+                                               double max) {
         client.zrangeByScore(key, min, max);
         return getResponse(BuilderFactory.STRING_ZSET);
     }
 
     public Response<Set<String>> zrangeByScore(byte[] key, double min,
-            double max) {
+                                               double max) {
         return zrangeByScore(key, toByteArray(min), toByteArray(max));
     }
     
     public Response<Set<String>> zrangeByScore(String key, String min,
-            String max) {
+                                               String max) {
         client.zrangeByScore(key, min, max);
         return getResponse(BuilderFactory.STRING_ZSET);
     }
 
     public Response<Set<String>> zrangeByScore(byte[] key, byte[] min,
-            byte[] max) {
+                                               byte[] max) {
         client.zrangeByScore(key, min, max);
         return getResponse(BuilderFactory.STRING_ZSET);
     }
 
     public Response<Set<String>> zrangeByScore(String key, double min,
-            double max, int offset, int count) {
+                                               double max, int offset, int count) {
         client.zrangeByScore(key, min, max, offset, count);
         return getResponse(BuilderFactory.STRING_ZSET);
     }
 
     public Response<Set<String>> zrangeByScore(byte[] key, double min,
-            double max, int offset, int count) {
+                                               double max, int offset, int count) {
         return zrangeByScore(key, toByteArray(min), toByteArray(max), offset, count);
     }
     
     public Response<Set<String>> zrangeByScore(byte[] key, byte[] min,
-    		byte[] max, int offset, int count) {
+                                               byte[] max, int offset, int count) {
         client.zrangeByScore(key, min, max, offset, count);
         return getResponse(BuilderFactory.STRING_ZSET);
     }
 
     public Response<Set<Tuple>> zrangeByScoreWithScores(String key, double min,
-            double max) {
+                                                        double max) {
         client.zrangeByScoreWithScores(key, min, max);
         return getResponse(BuilderFactory.TUPLE_ZSET);
     }
 
     public Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, double min,
-            double max) {
+                                                        double max) {
         return zrangeByScoreWithScores(key, toByteArray(min), toByteArray(max));
     }
     
     public Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, byte[] min,
-    		byte[] max) {
+                                                        byte[] max) {
         client.zrangeByScoreWithScores(key, min, max);
         return getResponse(BuilderFactory.TUPLE_ZSET);
     }
 
     public Response<Set<Tuple>> zrangeByScoreWithScores(String key, double min,
-            double max, int offset, int count) {
+                                                        double max, int offset, int count) {
         client.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) {
+                                                        double max, int offset, int count) {
         client.zrangeByScoreWithScores(key, toByteArray(min), toByteArray(max), offset, count);
         return getResponse(BuilderFactory.TUPLE_ZSET);
     }
     
     public Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, byte[] min,
-    		byte[] max, int offset, int count) {
+                                                        byte[] max, int offset, int count) {
         client.zrangeByScoreWithScores(key, min, max, offset, count);
         return getResponse(BuilderFactory.TUPLE_ZSET);
     }
 
     public Response<Set<String>> zrevrangeByScore(String key, double max,
-            double min) {
+                                                  double min) {
         client.zrevrangeByScore(key, max, min);
         return getResponse(BuilderFactory.STRING_ZSET);
     }
 
     public Response<Set<String>> zrevrangeByScore(byte[] key, double max,
-            double min) {
+                                                  double min) {
         client.zrevrangeByScore(key, toByteArray(max), toByteArray(min));
         return getResponse(BuilderFactory.STRING_ZSET);
     }
 
     public Response<Set<String>> zrevrangeByScore(String key, String max,
-            String min) {
+                                                  String min) {
         client.zrevrangeByScore(key, max, min);
         return getResponse(BuilderFactory.STRING_ZSET);
     }
 
     public Response<Set<String>> zrevrangeByScore(byte[] key, byte[] max,
-            byte[] min) {
+                                                  byte[] min) {
         client.zrevrangeByScore(key, max, min);
         return getResponse(BuilderFactory.STRING_ZSET);
     }
 
     public Response<Set<String>> zrevrangeByScore(String key, double max,
-            double min, int offset, int count) {
+                                                  double min, int offset, int count) {
         client.zrevrangeByScore(key, max, min, offset, count);
         return getResponse(BuilderFactory.STRING_ZSET);
     }
 
     public Response<Set<String>> zrevrangeByScore(byte[] key, double max,
-            double min, int offset, int count) {
+                                                  double min, int offset, int count) {
         client.zrevrangeByScore(key, toByteArray(max), toByteArray(min), offset, count);
         return getResponse(BuilderFactory.STRING_ZSET);
     }
     
     public Response<Set<String>> zrevrangeByScore(byte[] key, byte[] max,
-    		byte[] min, int offset, int count) {
+                                                  byte[] min, int offset, int count) {
         client.zrevrangeByScore(key, max, min, offset, count);
         return getResponse(BuilderFactory.STRING_ZSET);
     }
 
     public Response<Set<Tuple>> zrevrangeByScoreWithScores(String key,
-            double max, double min) {
+                                                           double max, double min) {
         client.zrevrangeByScoreWithScores(key, max, min);
         return getResponse(BuilderFactory.TUPLE_ZSET);
     }
 
     public Response<Set<Tuple>> zrevrangeByScoreWithScores(byte[] key,
-            double max, double min) {
+                                                           double max, double min) {
         client.zrevrangeByScoreWithScores(key, toByteArray(max), toByteArray(min));
         return getResponse(BuilderFactory.TUPLE_ZSET);
     }
     
     public Response<Set<Tuple>> zrevrangeByScoreWithScores(byte[] key,
-    		byte[] max, byte[] min) {
+                                                           byte[] max, byte[] min) {
         client.zrevrangeByScoreWithScores(key, max, min);
         return getResponse(BuilderFactory.TUPLE_ZSET);
     }
 
     public Response<Set<Tuple>> zrevrangeByScoreWithScores(String key,
-            double max, double min, int offset, int count) {
+                                                           double max, double min, int offset, int count) {
         client.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) {
+                                                           double max, double min, int offset, int count) {
         client.zrevrangeByScoreWithScores(key, toByteArray(max), toByteArray(min), offset, count);
         return getResponse(BuilderFactory.TUPLE_ZSET);
     }
     
     public Response<Set<Tuple>> zrevrangeByScoreWithScores(byte[] key,
-    		byte[] max, byte[] min, int offset, int count) {
+                                                           byte[] max, byte[] min, int offset, int count) {
         client.zrevrangeByScoreWithScores(key, max, min, offset, count);
         return getResponse(BuilderFactory.TUPLE_ZSET);
     }
@@ -1152,13 +1172,13 @@ public class Pipeline extends Queable {
     }
 
     public Response<Set<Tuple>> zrevrangeWithScores(String key, int start,
-            int end) {
+                                                    int end) {
         client.zrevrangeWithScores(key, start, end);
         return getResponse(BuilderFactory.TUPLE_ZSET);
     }
 
     public Response<Set<Tuple>> zrevrangeWithScores(byte[] key, int start,
-            int end) {
+                                                    int end) {
         client.zrevrangeWithScores(key, start, end);
         return getResponse(BuilderFactory.TUPLE_ZSET);
     }
diff --git a/src/main/java/redis/clients/jedis/RedisPipeline.java b/src/main/java/redis/clients/jedis/RedisPipeline.java
new file mode 100644
index 0000000..ca3370e
--- /dev/null
+++ b/src/main/java/redis/clients/jedis/RedisPipeline.java
@@ -0,0 +1,184 @@
+package redis.clients.jedis;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * @author guy
+ */
+public interface RedisPipeline {
+    Response<Long> append(String key, String value);
+
+    Response<Long> decr(String key);
+
+    Response<Long> decrBy(String key, long integer);
+
+    Response<Boolean> exists(String key);
+
+    Response<Long> expire(String key, int seconds);
+
+    Response<Long> expireAt(String key, long unixTime);
+
+    Response<String> get(String key);
+
+    Response<Boolean> getbit(String key, long offset);
+
+
+
+    Response<String> getrange(String key, long startOffset,
+                              long endOffset);
+
+    Response<String> getSet(String key, String value);
+
+    Response<Long> hdel(String key, String field);
+
+    Response<Boolean> hexists(String key, String field);
+
+    Response<String> hget(String key, String field);
+
+    Response<Map<String, String>> hgetAll(String key);
+
+    Response<Long> hincrBy(String key, String field, long value);
+
+    Response<Set<String>> hkeys(String key);
+
+    Response<Long> hlen(String key);
+
+    Response<List<String>> hmget(String key, String... fields);
+
+    Response<String> hmset(String key, Map<String, String> hash);
+
+    Response<Long> hset(String key, String field, String value);
+
+    Response<Long> hsetnx(String key, String field, String value);
+
+    Response<List<String>> hvals(String key);
+
+    Response<Long> incr(String key);
+
+    Response<Long> incrBy(String key, long integer);
+
+    Response<String> lindex(String key, int index);
+
+    Response<Long> linsert(String key, BinaryClient.LIST_POSITION where,
+                           String pivot, String value);
+
+    Response<Long> llen(String key);
+
+    Response<String> lpop(String key);
+
+    Response<Long> lpush(String key, String string);
+
+    Response<Long> lpushx(String key, String string);
+
+    Response<List<String>> lrange(String key, long start, long end);
+
+    Response<Long> lrem(String key, long count, String value);
+
+    Response<String> lset(String key, long index, String value);
+
+    Response<String> ltrim(String key, long start, long end);
+
+    Response<Long> persist(String key);
+
+    Response<String> rpop(String key);
+
+    Response<Long> rpush(String key, String string);
+
+    Response<Long> rpushx(String key, String string);
+
+    Response<Long> sadd(String key, String member);
+
+    Response<Long> scard(String key);
+
+    Response<Boolean> sismember(String key, String member);
+
+    Response<String> set(String key, String value);
+
+    Response<Boolean> setbit(String key, long offset, boolean value);
+
+    Response<String> setex(String key, int seconds, String value);
+
+    Response<Long> setnx(String key, String value);
+
+    Response<Set<String>> smembers(String key);
+
+    Response<Long> sort(String key);
+
+    Response<List<String>> sort(String key,
+                                SortingParams sortingParameters);
+
+    Response<String> spop(String key);
+
+    Response<String> srandmember(String key);
+
+    Response<Long> srem(String key, String member);
+
+    Response<Long> strlen(String key);
+
+    Response<String> substr(String key, int start, int end);
+
+    Response<Long> ttl(String key);
+
+    Response<String> type(String key);
+
+    Response<Long> zadd(String key, double score, String member);
+
+    Response<Long> zcard(String key);
+
+    Response<Long> zcount(String key, double min, double max);
+
+    Response<Double> zincrby(String key, double score, String member);
+
+    Response<Set<String>> zrange(String key, int start, int end);
+
+    Response<Set<String>> zrangeByScore(String key, double min,
+                                        double max);
+
+    Response<Set<String>> zrangeByScore(String key, String min,
+                                        String max);
+
+    Response<Set<String>> zrangeByScore(String key, double min,
+                                        double max, int offset, int count);
+
+    Response<Set<Tuple>> zrangeByScoreWithScores(String key, double min,
+                                                 double max);
+
+    Response<Set<Tuple>> zrangeByScoreWithScores(String key, double min,
+                                                 double max, int offset, int count);
+
+    Response<Set<String>> zrevrangeByScore(String key, double max,
+                                           double min);
+
+    Response<Set<String>> zrevrangeByScore(String key, String max,
+                                           String min);
+
+    Response<Set<String>> zrevrangeByScore(String key, double max,
+                                           double min, int offset, int count);
+
+    Response<Set<Tuple>> zrevrangeByScoreWithScores(String key,
+                                                    double max, double min);
+
+    Response<Set<Tuple>> zrevrangeByScoreWithScores(String key,
+                                                    double max, double min, int offset, int count);
+
+    Response<Set<Tuple>> zrangeWithScores(String key, int start, int end);
+
+    Response<Long> zrank(String key, String member);
+
+    Response<Long> zrem(String key, String member);
+
+    Response<Long> zremrangeByRank(String key, int start, int end);
+
+    Response<Long> zremrangeByScore(String key, double start, double end);
+
+    Response<Set<String>> zrevrange(String key, int start, int end);
+
+    Response<Set<Tuple>> zrevrangeWithScores(String key, int start,
+                                             int end);
+
+    Response<Long> zrevrank(String key, String member);
+
+    Response<Double> zscore(String key, String member);
+}
diff --git a/src/main/java/redis/clients/jedis/ShardedJedisPipeline.java b/src/main/java/redis/clients/jedis/ShardedJedisPipeline.java
index af416c0..48371ac 100644
--- a/src/main/java/redis/clients/jedis/ShardedJedisPipeline.java
+++ b/src/main/java/redis/clients/jedis/ShardedJedisPipeline.java
@@ -4,7 +4,9 @@ import redis.clients.jedis.BinaryClient.LIST_POSITION;
 
 import java.util.*;
 
-public class ShardedJedisPipeline extends Queable {
+import static redis.clients.jedis.Protocol.toByteArray;
+
+public class ShardedJedisPipeline extends Queable implements BinaryRedisPipeline, RedisPipeline {
     private BinaryShardedJedis jedis;
     private List<FutureResult> results = new ArrayList<FutureResult>();
     private Queue<Client> clients = new LinkedList<Client>();
@@ -32,6 +34,13 @@ public class ShardedJedisPipeline extends Queable {
         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);
@@ -39,6 +48,13 @@ public class ShardedJedisPipeline extends Queable {
         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<Long> del(String key) {
         Client c = getClient(key);
         c.del(key);
@@ -53,13 +69,27 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.BOOLEAN);
     }
 
-    public Response<Boolean> type(String key) {
+    public Response<Boolean> exists(byte[] key) {
         Client c = getClient(key);
-        c.type(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);
@@ -67,6 +97,13 @@ public class ShardedJedisPipeline extends Queable {
         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);
@@ -74,6 +111,13 @@ public class ShardedJedisPipeline extends Queable {
         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);
@@ -81,6 +125,13 @@ public class ShardedJedisPipeline extends Queable {
         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);
@@ -88,6 +139,13 @@ public class ShardedJedisPipeline extends Queable {
         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);
@@ -95,11 +153,25 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.LONG);
     }
 
-    public Response<Long> setex(String key, int seconds, String value) {
+    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.LONG);        
+        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) {
@@ -109,6 +181,13 @@ public class ShardedJedisPipeline extends Queable {
         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);
@@ -116,7 +195,21 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.LONG);
     }
 
-    public Response<Long> incrBy(String key, int integer) {
+    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));
@@ -130,6 +223,13 @@ public class ShardedJedisPipeline extends Queable {
         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);
@@ -137,6 +237,13 @@ public class ShardedJedisPipeline extends Queable {
         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);
@@ -144,6 +251,13 @@ public class ShardedJedisPipeline extends Queable {
         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);
@@ -151,6 +265,13 @@ public class ShardedJedisPipeline extends Queable {
         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);
@@ -158,6 +279,13 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.STRING);
     }
 
+    public Response<String> hget(byte[] key, byte[] field) {
+        Client c = getClient(key);
+        c.hget(key, field);
+        results.add(new FutureResult(c));
+        return getResponse(BuilderFactory.STRING);
+    }
+
     public Response<Long> hsetnx(String key, String field, String value) {
         Client c = getClient(key);
         c.hsetnx(key, field, value);
@@ -165,6 +293,13 @@ public class ShardedJedisPipeline extends Queable {
         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);
@@ -172,6 +307,13 @@ public class ShardedJedisPipeline extends Queable {
         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);
@@ -179,7 +321,21 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.STRING_LIST);
     }
 
-    public Response<Long> hincrBy(String key, String field, int value) {
+    public Response<List<String>> hmget(byte[] key, byte[]... fields) {
+        Client c = getClient(key);
+        c.hmget(key, fields);
+        results.add(new FutureResult(c));
+        return getResponse(BuilderFactory.STRING_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));
@@ -193,6 +349,13 @@ public class ShardedJedisPipeline extends Queable {
         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);
@@ -200,6 +363,13 @@ public class ShardedJedisPipeline extends Queable {
         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);
@@ -207,6 +377,13 @@ public class ShardedJedisPipeline extends Queable {
         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);
@@ -214,13 +391,27 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.STRING_SET);
     }
 
-    public Response<Set<String>> hvals(String key) {
+    public Response<Set<String>> hkeys(byte[] key) {
         Client c = getClient(key);
-        c.hvals(key);
+        c.hkeys(key);
         results.add(new FutureResult(c));
         return getResponse(BuilderFactory.STRING_SET);
     }
 
+    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<String>> hvals(byte[] key) {
+        Client c = getClient(key);
+        c.hvals(key);
+        results.add(new FutureResult(c));
+        return getResponse(BuilderFactory.STRING_LIST);
+    }
+
     public Response<Map<String, String>> hgetAll(String key) {
         Client c = getClient(key);
         c.hgetAll(key);
@@ -228,6 +419,13 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.STRING_MAP);
     }
 
+    public Response<Map<String, String>> hgetAll(byte[] key) {
+        Client c = getClient(key);
+        c.hgetAll(key);
+        results.add(new FutureResult(c));
+        return getResponse(BuilderFactory.STRING_MAP);
+    }
+
     public Response<Long> rpush(String key, String string) {
         Client c = getClient(key);
         c.rpush(key, string);
@@ -235,6 +433,27 @@ public class ShardedJedisPipeline extends Queable {
         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);
@@ -242,6 +461,27 @@ public class ShardedJedisPipeline extends Queable {
         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);
@@ -249,20 +489,55 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.LONG);
     }
 
-    public Response<List<String>> lrange(String key, int start, int end) {
+    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<String> ltrim(String key, int start, int end) {
+    public Response<List<String>> lrange(byte[] 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<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);
@@ -270,14 +545,35 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.STRING);
     }
 
-    public Response<String> lset(String key, int index, String value) {
+    public Response<String> lindex(byte[] key, int index) {
+        Client c = getClient(key);
+        c.lindex(key, index);
+        results.add(new FutureResult(c));
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    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<Long> lrem(String key, int count, String value) {
+    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));
@@ -291,6 +587,13 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.STRING);
     }
 
+    public Response<String> lpop(byte[] key) {
+        Client c = getClient(key);
+        c.lpop(key);
+        results.add(new FutureResult(c));
+        return getResponse(BuilderFactory.STRING);
+    }
+
     public Response<String> rpop(String key) {
         Client c = getClient(key);
         c.rpop(key);
@@ -298,6 +601,13 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.STRING);
     }
 
+    public Response<String> rpop(byte[] key) {
+        Client c = getClient(key);
+        c.rpop(key);
+        results.add(new FutureResult(c));
+        return getResponse(BuilderFactory.STRING);
+    }
+
     public Response<Long> sadd(String key, String member) {
         Client c = getClient(key);
         c.sadd(key, member);
@@ -305,6 +615,13 @@ public class ShardedJedisPipeline extends Queable {
         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);
@@ -312,6 +629,13 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.STRING_SET);
     }
 
+    public Response<Set<String>> smembers(byte[] key) {
+        Client c = getClient(key);
+        c.smembers(key);
+        results.add(new FutureResult(c));
+        return getResponse(BuilderFactory.STRING_SET);
+    }
+
     public Response<Long> srem(String key, String member) {
         Client c = getClient(key);
         c.srem(key, member);
@@ -319,6 +643,27 @@ public class ShardedJedisPipeline extends Queable {
         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);
@@ -326,6 +671,13 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.STRING);
     }
 
+    public Response<String> spop(byte[] key) {
+        Client c = getClient(key);
+        c.spop(key);
+        results.add(new FutureResult(c));
+        return getResponse(BuilderFactory.STRING);
+    }
+
     public Response<Long> scard(String key) {
         Client c = getClient(key);
         c.scard(key);
@@ -333,6 +685,13 @@ public class ShardedJedisPipeline extends Queable {
         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);
@@ -340,6 +699,13 @@ public class ShardedJedisPipeline extends Queable {
         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);
@@ -347,6 +713,13 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.STRING);
     }
 
+    public Response<String> srandmember(byte[] key) {
+        Client c = getClient(key);
+        c.srandmember(key);
+        results.add(new FutureResult(c));
+        return getResponse(BuilderFactory.STRING);
+    }
+
     public Response<Long> zadd(String key, double score, String member) {
         Client c = getClient(key);
         c.zadd(key, score, member);
@@ -354,6 +727,13 @@ public class ShardedJedisPipeline extends Queable {
         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);
@@ -361,6 +741,13 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.STRING_ZSET);
     }
 
+    public Response<Set<String>> zrange(byte[] 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<Long> zrem(String key, String member) {
         Client c = getClient(key);
         c.zrem(key, member);
@@ -368,6 +755,13 @@ public class ShardedJedisPipeline extends Queable {
         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);
@@ -375,6 +769,13 @@ public class ShardedJedisPipeline extends Queable {
         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);
@@ -382,6 +783,13 @@ public class ShardedJedisPipeline extends Queable {
         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);
@@ -389,6 +797,13 @@ public class ShardedJedisPipeline extends Queable {
         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);
@@ -396,6 +811,13 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.STRING_ZSET);
     }
 
+    public Response<Set<String>> zrevrange(byte[] 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<Tuple>> zrangeWithScores(String key, int start, int end) {
         Client c = getClient(key);
         c.zrangeWithScores(key, start, end);
@@ -403,6 +825,13 @@ public class ShardedJedisPipeline extends Queable {
         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);
@@ -410,6 +839,13 @@ public class ShardedJedisPipeline extends Queable {
         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);
@@ -417,6 +853,13 @@ public class ShardedJedisPipeline extends Queable {
         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);
@@ -424,13 +867,27 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.DOUBLE);
     }
 
-    public Response<Double> sort(String key) {
+    public Response<Double> zscore(byte[] key, byte[] member) {
         Client c = getClient(key);
-        c.sort(key);
+        c.zscore(key, member);
         results.add(new FutureResult(c));
         return getResponse(BuilderFactory.DOUBLE);
     }
 
+    public Response<Long> sort(String key) {
+        Client c = getClient(key);
+        c.sort(key);
+        results.add(new FutureResult(c));
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> sort(byte[] key) {
+        Client c = getClient(key);
+        c.sort(key);
+        results.add(new FutureResult(c));
+        return getResponse(BuilderFactory.LONG);
+    }
+
     public Response<List<String>> sort(String key, SortingParams sortingParameters) {
         Client c = getClient(key);
         c.sort(key, sortingParameters);
@@ -438,6 +895,13 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.STRING_LIST);
     }
 
+    public Response<List<String>> sort(byte[] key, SortingParams sortingParameters) {
+        Client c = getClient(key);
+        c.sort(key, sortingParameters);
+        results.add(new FutureResult(c));
+        return getResponse(BuilderFactory.STRING_LIST);
+    }
+
     public Response<Long> zcount(String key, double min, double max) {
         Client c = getClient(key);
         c.zcount(key, min, max);
@@ -445,6 +909,69 @@ public class ShardedJedisPipeline extends Queable {
         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<String>> 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.STRING_ZSET);
+    }
+
+    public Response<Set<String>> zrevrangeByScore(byte[] key, byte[] max, byte[] 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, 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<String>> 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.STRING_ZSET);
+    }
+
+    public Response<Set<String>> 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.STRING_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);
@@ -452,6 +979,20 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.STRING_ZSET);
     }
 
+    public Response<Set<String>> 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.STRING_ZSET);
+    }
+
+    public Response<Set<String>> zrangeByScore(byte[] key, byte[] min, byte[] 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,
                                                int offset, int count) {
         Client c = getClient(key);
@@ -460,6 +1001,22 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.STRING_ZSET);
     }
 
+    public Response<Set<String>> 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.STRING_ZSET);
+    }
+
+    public Response<Set<String>> 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.STRING_ZSET);
+    }
+
     public Response<Set<Tuple>> zrangeByScoreWithScores(String key, double min, double max) {
         Client c = getClient(key);
         c.zrangeByScoreWithScores(key, min, max);
@@ -467,6 +1024,20 @@ public class ShardedJedisPipeline extends Queable {
         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);
@@ -475,6 +1046,64 @@ public class ShardedJedisPipeline extends Queable {
         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);
@@ -482,6 +1111,13 @@ public class ShardedJedisPipeline extends Queable {
         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);
@@ -489,6 +1125,20 @@ public class ShardedJedisPipeline extends Queable {
         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);
@@ -497,6 +1147,14 @@ public class ShardedJedisPipeline extends Queable {
         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);
@@ -504,6 +1162,13 @@ public class ShardedJedisPipeline extends Queable {
         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);
@@ -511,15 +1176,35 @@ public class ShardedJedisPipeline extends Queable {
         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> getrange(String key, long startOffset, long endOffset) {
+    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));
@@ -574,4 +1259,10 @@ public class ShardedJedisPipeline extends Queable {
         clients.add(client);
         return client;
     }
+
+    private Client getClient(byte[] key) {
+        Client client = jedis.getShard(key).getClient();
+        clients.add(client);
+        return client;
+    }
 }
\ No newline at end of file