From 6707b62342765a0a04cc31325501be3fc5f55193 Mon Sep 17 00:00:00 2001 From: Jonathan Leibiusky Date: Wed, 6 Apr 2011 01:07:20 -0300 Subject: [PATCH] pipeline return formatted values --- .../java/redis/clients/jedis/BinaryJedis.java | 6 +- .../java/redis/clients/jedis/Builder.java | 5 + .../redis/clients/jedis/BuilderFactory.java | 163 ++++ .../java/redis/clients/jedis/Connection.java | 14 +- src/main/java/redis/clients/jedis/Jedis.java | 24 +- .../java/redis/clients/jedis/Pipeline.java | 699 ++++++++++++------ .../redis/clients/jedis/PipelineBlock.java | 462 +----------- .../java/redis/clients/jedis/Response.java | 31 + .../clients/jedis/tests/PipeliningTest.java | 51 +- 9 files changed, 729 insertions(+), 726 deletions(-) create mode 100644 src/main/java/redis/clients/jedis/Builder.java create mode 100644 src/main/java/redis/clients/jedis/BuilderFactory.java create mode 100644 src/main/java/redis/clients/jedis/Response.java diff --git a/src/main/java/redis/clients/jedis/BinaryJedis.java b/src/main/java/redis/clients/jedis/BinaryJedis.java index 501f211..91a2e25 100644 --- a/src/main/java/redis/clients/jedis/BinaryJedis.java +++ b/src/main/java/redis/clients/jedis/BinaryJedis.java @@ -2019,11 +2019,13 @@ public class BinaryJedis implements BinaryJedisCommands { public List pipelined(final PipelineBlock jedisPipeline) { jedisPipeline.setClient(client); jedisPipeline.execute(); - return client.getAll(); + return jedisPipeline.sync(); } public Pipeline pipelined() { - return new Pipeline(client); + Pipeline pipeline = new Pipeline(); + pipeline.setClient(client); + return pipeline; } public void subscribe(final JedisPubSub jedisPubSub, diff --git a/src/main/java/redis/clients/jedis/Builder.java b/src/main/java/redis/clients/jedis/Builder.java new file mode 100644 index 0000000..e13117c --- /dev/null +++ b/src/main/java/redis/clients/jedis/Builder.java @@ -0,0 +1,5 @@ +package redis.clients.jedis; + +public abstract class Builder { + public abstract T build(Object data); +} diff --git a/src/main/java/redis/clients/jedis/BuilderFactory.java b/src/main/java/redis/clients/jedis/BuilderFactory.java new file mode 100644 index 0000000..0dca5b6 --- /dev/null +++ b/src/main/java/redis/clients/jedis/BuilderFactory.java @@ -0,0 +1,163 @@ +package redis.clients.jedis; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Iterator; +import java.util.LinkedHashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; + +import redis.clients.util.SafeEncoder; + +public class BuilderFactory { + public static final Builder DOUBLE = new Builder() { + public Double build(Object data) { + return Double.valueOf((Long) data); + } + + public String toString() { + return "double"; + } + }; + public static final Builder BOOLEAN = new Builder() { + public Boolean build(Object data) { + return ((Long) data) == 1; + } + + public String toString() { + return "boolean"; + } + }; + public static final Builder LONG = new Builder() { + public Long build(Object data) { + return (Long) data; + } + + public String toString() { + return "long"; + } + + }; + public static final Builder STRING = new Builder() { + public String build(Object data) { + return SafeEncoder.encode((byte[]) data); + } + + public String toString() { + return "string"; + } + + }; + public static final Builder> STRING_LIST = new Builder>() { + @SuppressWarnings("unchecked") + public List build(Object data) { + if (null == data) { + return null; + } + List l = (List) data; + final ArrayList result = new ArrayList(l.size()); + for (final byte[] barray : l) { + if (barray == null) { + result.add(null); + } else { + result.add(SafeEncoder.encode(barray)); + } + } + return result; + } + + public String toString() { + return "List"; + } + + }; + public static final Builder> STRING_MAP = new Builder>() { + @SuppressWarnings("unchecked") + public Map build(Object data) { + final List flatHash = (List) data; + final Map hash = new HashMap(); + final Iterator iterator = flatHash.iterator(); + while (iterator.hasNext()) { + hash.put(SafeEncoder.encode(iterator.next()), SafeEncoder + .encode(iterator.next())); + } + + return hash; + } + + public String toString() { + return "Map"; + } + + }; + public static final Builder> STRING_SET = new Builder>() { + @SuppressWarnings("unchecked") + public Set build(Object data) { + if (null == data) { + return null; + } + List l = (List) data; + final Set result = new HashSet(l.size()); + for (final byte[] barray : l) { + if (barray == null) { + result.add(null); + } else { + result.add(SafeEncoder.encode(barray)); + } + } + return result; + } + + public String toString() { + return "Set"; + } + + }; + public static final Builder> STRING_ZSET = new Builder>() { + @SuppressWarnings("unchecked") + public Set build(Object data) { + if (null == data) { + return null; + } + List l = (List) data; + final Set result = new LinkedHashSet(l.size()); + for (final byte[] barray : l) { + if (barray == null) { + result.add(null); + } else { + result.add(SafeEncoder.encode(barray)); + } + } + return result; + } + + public String toString() { + return "ZSet"; + } + + }; + public static final Builder> TUPLE_ZSET = new Builder>() { + @SuppressWarnings("unchecked") + public Set build(Object data) { + if (null == data) { + return null; + } + List l = (List) data; + final Set result = new LinkedHashSet(l.size()); + Iterator iterator = l.iterator(); + while (iterator.hasNext()) { + result.add(new Tuple(SafeEncoder.encode(iterator.next()), + Double.valueOf(SafeEncoder.encode(iterator.next())))); + } + return result; + } + + public String toString() { + return "ZSet"; + } + + }; + +} diff --git a/src/main/java/redis/clients/jedis/Connection.java b/src/main/java/redis/clients/jedis/Connection.java index 4349ae2..9493fb9 100644 --- a/src/main/java/redis/clients/jedis/Connection.java +++ b/src/main/java/redis/clients/jedis/Connection.java @@ -175,19 +175,7 @@ public class Connection { } public List getMultiBulkReply() { - final List bresult = getBinaryMultiBulkReply(); - if (null == bresult) { - return null; - } - final ArrayList result = new ArrayList(bresult.size()); - for (final byte[] barray : bresult) { - if (barray == null) { - result.add(null); - } else { - result.add(SafeEncoder.encode(barray)); - } - } - return result; + return BuilderFactory.STRING_LIST.build(getBinaryMultiBulkReply()); } @SuppressWarnings("unchecked") diff --git a/src/main/java/redis/clients/jedis/Jedis.java b/src/main/java/redis/clients/jedis/Jedis.java index c83bb95..abf5e09 100644 --- a/src/main/java/redis/clients/jedis/Jedis.java +++ b/src/main/java/redis/clients/jedis/Jedis.java @@ -1,7 +1,6 @@ package redis.clients.jedis; import java.util.ArrayList; -import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; import java.util.LinkedHashSet; @@ -175,9 +174,8 @@ public class Jedis extends BinaryJedis implements JedisCommands { public Set keys(final String pattern) { runChecks(); client.keys(pattern); - final HashSet keySet = new HashSet(client - .getMultiBulkReply()); - return keySet; + return BuilderFactory.STRING_SET + .build(client.getBinaryMultiBulkReply()); } /** @@ -830,8 +828,8 @@ public class Jedis extends BinaryJedis implements JedisCommands { public Set hkeys(final String key) { runChecks(); client.hkeys(key); - final List lresult = client.getMultiBulkReply(); - return new HashSet(lresult); + return BuilderFactory.STRING_SET + .build(client.getBinaryMultiBulkReply()); } /** @@ -860,14 +858,8 @@ public class Jedis extends BinaryJedis implements JedisCommands { public Map hgetAll(final String key) { runChecks(); client.hgetAll(key); - final List flatHash = client.getMultiBulkReply(); - final Map hash = new HashMap(); - final Iterator iterator = flatHash.iterator(); - while (iterator.hasNext()) { - hash.put(iterator.next(), iterator.next()); - } - - return hash; + return BuilderFactory.STRING_MAP + .build(client.getBinaryMultiBulkReply()); } /** @@ -1393,8 +1385,8 @@ public class Jedis extends BinaryJedis implements JedisCommands { public Set sdiff(final String... keys) { runChecks(); client.sdiff(keys); - final List members = client.getMultiBulkReply(); - return new HashSet(members); + return BuilderFactory.STRING_SET + .build(client.getBinaryMultiBulkReply()); } /** diff --git a/src/main/java/redis/clients/jedis/Pipeline.java b/src/main/java/redis/clients/jedis/Pipeline.java index 8dc7fd0..9af12ef 100644 --- a/src/main/java/redis/clients/jedis/Pipeline.java +++ b/src/main/java/redis/clients/jedis/Pipeline.java @@ -1,857 +1,1108 @@ package redis.clients.jedis; +import java.util.ArrayList; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; +import java.util.Queue; +import java.util.Set; + import redis.clients.jedis.BinaryClient.LIST_POSITION; -import java.util.List; -import java.util.Map; - -public class Pipeline implements Commands { +public class Pipeline { private Client client; + private Queue> pipelinedResponses = new LinkedList>(); - public Pipeline(Client client) { + public void setClient(Client client) { this.client = client; } - public void append(String key, String value) { + private Response generateResponse(Object data) { + Response response = pipelinedResponses.poll(); + if (response != null) { + response.set(data); + } + return response; + } + + public List sync() { + List unformatted = client.getAll(); + List formatted = new ArrayList(); + for (Object o : unformatted) { + formatted.add(generateResponse(o).get()); + } + return formatted; + } + + private Response getResponse(Builder builder) { + Response lr = new Response(builder); + pipelinedResponses.add(lr); + return lr; + } + + public Response append(String key, String value) { client.append(key, value); + return getResponse(BuilderFactory.LONG); } - public void append(byte[] key, byte[] value) { + public Response append(byte[] key, byte[] value) { client.append(key, value); + return getResponse(BuilderFactory.LONG); } - public void blpop(String[] args) { + public Response> blpop(String... args) { client.blpop(args); + return getResponse(BuilderFactory.STRING_LIST); } - public void blpop(byte[][] args) { + public Response> blpop(byte[]... args) { client.blpop(args); + return getResponse(BuilderFactory.STRING_LIST); } - public void brpop(String[] args) { + public Response> brpop(String... args) { client.brpop(args); + return getResponse(BuilderFactory.STRING_LIST); } - public void brpop(byte[][] args) { + public Response> brpop(byte[]... args) { client.brpop(args); + return getResponse(BuilderFactory.STRING_LIST); } - public void decr(String key) { + public Response decr(String key) { client.decr(key); + return getResponse(BuilderFactory.LONG); } - public void decr(byte[] key) { + public Response decr(byte[] key) { client.decr(key); + return getResponse(BuilderFactory.LONG); } - public void decrBy(String key, long integer) { + public Response decrBy(String key, long integer) { client.decrBy(key, integer); + return getResponse(BuilderFactory.LONG); } - public void decrBy(byte[] key, long integer) { + public Response decrBy(byte[] key, long integer) { client.decrBy(key, integer); + return getResponse(BuilderFactory.LONG); } - public void del(String... keys) { + public Response del(String... keys) { client.del(keys); + return getResponse(BuilderFactory.LONG); } - public void del(byte[]... keys) { + public Response del(byte[]... keys) { client.del(keys); + return getResponse(BuilderFactory.LONG); } - public void echo(String string) { + public Response echo(String string) { client.echo(string); + return getResponse(BuilderFactory.STRING); } - public void echo(byte[] string) { + public Response echo(byte[] string) { client.echo(string); + return getResponse(BuilderFactory.STRING); } - public void exists(String key) { + public Response exists(String key) { client.exists(key); + return getResponse(BuilderFactory.BOOLEAN); } - public void exists(byte[] key) { + public Response exists(byte[] key) { client.exists(key); + return getResponse(BuilderFactory.BOOLEAN); } - public void expire(String key, int seconds) { + public Response expire(String key, int seconds) { client.expire(key, seconds); + return getResponse(BuilderFactory.LONG); } - public void expire(byte[] key, int seconds) { + public Response expire(byte[] key, int seconds) { client.expire(key, seconds); + return getResponse(BuilderFactory.LONG); } - public void expireAt(String key, long unixTime) { + public Response expireAt(String key, long unixTime) { client.expireAt(key, unixTime); + return getResponse(BuilderFactory.LONG); } - public void expireAt(byte[] key, long unixTime) { + public Response expireAt(byte[] key, long unixTime) { client.expireAt(key, unixTime); + return getResponse(BuilderFactory.LONG); } - public void get(String key) { + public Response get(String key) { client.get(key); + return getResponse(BuilderFactory.STRING); } - public void get(byte[] key) { + public Response get(byte[] key) { client.get(key); + return getResponse(BuilderFactory.STRING); } - public void getbit(String key, long offset) { + public Response getbit(String key, long offset) { client.getbit(key, offset); + return getResponse(BuilderFactory.BOOLEAN); } - public void getrange(String key, long startOffset, long endOffset) { + public Response getrange(String key, long startOffset, + long endOffset) { client.getrange(key, startOffset, endOffset); + return getResponse(BuilderFactory.STRING); } - public void getSet(String key, String value) { + public Response getSet(String key, String value) { client.getSet(key, value); + return getResponse(BuilderFactory.STRING); } - public void getSet(byte[] key, byte[] value) { + public Response getSet(byte[] key, byte[] value) { client.getSet(key, value); + return getResponse(BuilderFactory.STRING); } - public void hdel(String key, String field) { + public Response hdel(String key, String field) { client.hdel(key, field); + return getResponse(BuilderFactory.LONG); } - public void hdel(byte[] key, byte[] field) { + public Response hdel(byte[] key, byte[] field) { client.hdel(key, field); + return getResponse(BuilderFactory.LONG); } - public void hexists(String key, String field) { + public Response hexists(String key, String field) { client.hexists(key, field); + return getResponse(BuilderFactory.BOOLEAN); } - public void hexists(byte[] key, byte[] field) { + public Response hexists(byte[] key, byte[] field) { client.hexists(key, field); + return getResponse(BuilderFactory.BOOLEAN); } - public void hget(String key, String field) { + public Response hget(String key, String field) { client.hget(key, field); + return getResponse(BuilderFactory.STRING); } - public void hget(byte[] key, byte[] field) { + public Response hget(byte[] key, byte[] field) { client.hget(key, field); + return getResponse(BuilderFactory.STRING); } - public void hgetAll(String key) { + public Response> hgetAll(String key) { client.hgetAll(key); + return getResponse(BuilderFactory.STRING_MAP); } - public void hgetAll(byte[] key) { + public Response> hgetAll(byte[] key) { client.hgetAll(key); + return getResponse(BuilderFactory.STRING_MAP); } - public void hincrBy(String key, String field, long value) { + public Response hincrBy(String key, String field, long value) { client.hincrBy(key, field, value); + return getResponse(BuilderFactory.LONG); } - public void hincrBy(byte[] key, byte[] field, long value) { + public Response hincrBy(byte[] key, byte[] field, long value) { client.hincrBy(key, field, value); + return getResponse(BuilderFactory.LONG); } - public void hkeys(String key) { + public Response> hkeys(String key) { client.hkeys(key); + return getResponse(BuilderFactory.STRING_SET); } - public void hkeys(byte[] key) { + public Response> hkeys(byte[] key) { client.hkeys(key); + return getResponse(BuilderFactory.STRING_SET); } - public void hlen(String key) { + public Response hlen(String key) { client.hlen(key); + return getResponse(BuilderFactory.LONG); } - public void hlen(byte[] key) { + public Response hlen(byte[] key) { client.hlen(key); + return getResponse(BuilderFactory.LONG); } - public void hmget(String key, String... fields) { + public Response> hmget(String key, String... fields) { client.hmget(key, fields); + return getResponse(BuilderFactory.STRING_LIST); } - public void hmget(byte[] key, byte[]... fields) { + public Response> hmget(byte[] key, byte[]... fields) { client.hmget(key, fields); + return getResponse(BuilderFactory.STRING_LIST); } - public void hmset(String key, Map hash) { + public Response hmset(String key, Map hash) { client.hmset(key, hash); + return getResponse(BuilderFactory.STRING); } - public void hmset(byte[] key, Map hash) { + public Response hmset(byte[] key, Map hash) { client.hmset(key, hash); + return getResponse(BuilderFactory.STRING); } - public void hset(String key, String field, String value) { + public Response hset(String key, String field, String value) { client.hset(key, field, value); + return getResponse(BuilderFactory.LONG); } - public void hset(byte[] key, byte[] field, byte[] value) { + public Response hset(byte[] key, byte[] field, byte[] value) { client.hset(key, field, value); + return getResponse(BuilderFactory.LONG); } - public void hsetnx(String key, String field, String value) { + public Response hsetnx(String key, String field, String value) { client.hsetnx(key, field, value); + return getResponse(BuilderFactory.LONG); } - public void hsetnx(byte[] key, byte[] field, byte[] value) { + public Response hsetnx(byte[] key, byte[] field, byte[] value) { client.hsetnx(key, field, value); + return getResponse(BuilderFactory.LONG); } - public void hvals(String key) { + public Response> hvals(String key) { client.hvals(key); + return getResponse(BuilderFactory.STRING_LIST); } - public void hvals(byte[] key) { + public Response> hvals(byte[] key) { client.hvals(key); + return getResponse(BuilderFactory.STRING_LIST); } - public void incr(String key) { + public Response incr(String key) { client.incr(key); + return getResponse(BuilderFactory.LONG); } - public void incr(byte[] key) { + public Response incr(byte[] key) { client.incr(key); + return getResponse(BuilderFactory.LONG); } - public void incrBy(String key, long integer) { + public Response incrBy(String key, long integer) { client.incrBy(key, integer); + return getResponse(BuilderFactory.LONG); } - public void incrBy(byte[] key, long integer) { + public Response incrBy(byte[] key, long integer) { client.incrBy(key, integer); + return getResponse(BuilderFactory.LONG); } - public void keys(String pattern) { + public Response> keys(String pattern) { client.keys(pattern); + return getResponse(BuilderFactory.STRING_SET); } - public void keys(byte[] pattern) { + public Response> keys(byte[] pattern) { client.keys(pattern); + return getResponse(BuilderFactory.STRING_SET); } - public void lindex(String key, int index) { + public Response lindex(String key, int index) { client.lindex(key, index); + return getResponse(BuilderFactory.STRING); } - public void lindex(byte[] key, int index) { + public Response lindex(byte[] key, int index) { client.lindex(key, index); + return getResponse(BuilderFactory.STRING); } - public void linsert(String key, LIST_POSITION where, String pivot, - String value) { + public Response linsert(String key, LIST_POSITION where, + String pivot, String value) { client.linsert(key, where, pivot, value); + return getResponse(BuilderFactory.LONG); } - public void linsert(byte[] key, LIST_POSITION where, byte[] pivot, - byte[] value) { + public Response linsert(byte[] key, LIST_POSITION where, + byte[] pivot, byte[] value) { client.linsert(key, where, pivot, value); + return getResponse(BuilderFactory.LONG); } - public void llen(String key) { + public Response llen(String key) { client.llen(key); + return getResponse(BuilderFactory.LONG); } - public void llen(byte[] key) { + public Response llen(byte[] key) { client.llen(key); + return getResponse(BuilderFactory.LONG); } - public void lpop(String key) { + public Response lpop(String key) { client.lpop(key); + return getResponse(BuilderFactory.STRING); } - public void lpop(byte[] key) { + public Response lpop(byte[] key) { client.lpop(key); + return getResponse(BuilderFactory.STRING); } - public void lpush(String key, String string) { + public Response lpush(String key, String string) { client.lpush(key, string); + return getResponse(BuilderFactory.LONG); } - public void lpush(byte[] key, byte[] string) { + public Response lpush(byte[] key, byte[] string) { client.lpush(key, string); + return getResponse(BuilderFactory.LONG); } - public void lpushx(String key, String string) { + public Response lpushx(String key, String string) { client.lpushx(key, string); + return getResponse(BuilderFactory.LONG); } - public void lpushx(byte[] key, byte[] bytes) { + public Response lpushx(byte[] key, byte[] bytes) { client.lpushx(key, bytes); + return getResponse(BuilderFactory.LONG); } - public void lrange(String key, int start, int end) { + public Response> lrange(String key, int start, int end) { client.lrange(key, start, end); + return getResponse(BuilderFactory.STRING_LIST); } - public void lrange(byte[] key, int start, int end) { + public Response> lrange(byte[] key, int start, int end) { client.lrange(key, start, end); + return getResponse(BuilderFactory.STRING_LIST); } - public void lrem(String key, int count, String value) { + public Response lrem(String key, int count, String value) { client.lrem(key, count, value); + return getResponse(BuilderFactory.LONG); } - public void lrem(byte[] key, int count, byte[] value) { + public Response lrem(byte[] key, int count, byte[] value) { client.lrem(key, count, value); + return getResponse(BuilderFactory.LONG); } - public void lset(String key, int index, String value) { + public Response lset(String key, int index, String value) { client.lset(key, index, value); + return getResponse(BuilderFactory.STRING); } - public void lset(byte[] key, int index, byte[] value) { + public Response lset(byte[] key, int index, byte[] value) { client.lset(key, index, value); + return getResponse(BuilderFactory.STRING); } - public void ltrim(String key, int start, int end) { + public Response ltrim(String key, int start, int end) { client.ltrim(key, start, end); + return getResponse(BuilderFactory.STRING); } - public void ltrim(byte[] key, int start, int end) { + public Response ltrim(byte[] key, int start, int end) { client.ltrim(key, start, end); + return getResponse(BuilderFactory.STRING); } - public void mget(String... keys) { + public Response> mget(String... keys) { client.mget(keys); + return getResponse(BuilderFactory.STRING_LIST); } - public void mget(byte[]... keys) { + public Response> mget(byte[]... keys) { client.mget(keys); + return getResponse(BuilderFactory.STRING_LIST); } - public void move(String key, int dbIndex) { + public Response move(String key, int dbIndex) { client.move(key, dbIndex); + return getResponse(BuilderFactory.LONG); } - public void move(byte[] key, int dbIndex) { + public Response move(byte[] key, int dbIndex) { client.move(key, dbIndex); + return getResponse(BuilderFactory.LONG); } - public void mset(String... keysvalues) { + public Response mset(String... keysvalues) { client.mset(keysvalues); + return getResponse(BuilderFactory.STRING); } - public void mset(byte[]... keysvalues) { + public Response mset(byte[]... keysvalues) { client.mset(keysvalues); + return getResponse(BuilderFactory.STRING); } - public void msetnx(String... keysvalues) { + public Response msetnx(String... keysvalues) { client.msetnx(keysvalues); + return getResponse(BuilderFactory.LONG); } - public void msetnx(byte[]... keysvalues) { + public Response msetnx(byte[]... keysvalues) { client.msetnx(keysvalues); + return getResponse(BuilderFactory.LONG); } - public void persist(String key) { + public Response persist(String key) { client.persist(key); + return getResponse(BuilderFactory.LONG); } - public void persist(byte[] key) { + public Response persist(byte[] key) { client.persist(key); + return getResponse(BuilderFactory.LONG); } - public void rename(String oldkey, String newkey) { + public Response rename(String oldkey, String newkey) { client.rename(oldkey, newkey); + return getResponse(BuilderFactory.STRING); } - public void rename(byte[] oldkey, byte[] newkey) { + public Response rename(byte[] oldkey, byte[] newkey) { client.rename(oldkey, newkey); + return getResponse(BuilderFactory.STRING); } - public void renamenx(String oldkey, String newkey) { + public Response renamenx(String oldkey, String newkey) { client.renamenx(oldkey, newkey); + return getResponse(BuilderFactory.LONG); } - public void renamenx(byte[] oldkey, byte[] newkey) { + public Response renamenx(byte[] oldkey, byte[] newkey) { client.renamenx(oldkey, newkey); + return getResponse(BuilderFactory.LONG); } - public void rpop(String key) { + public Response rpop(String key) { client.rpop(key); + return getResponse(BuilderFactory.STRING); } - public void rpop(byte[] key) { + public Response rpop(byte[] key) { client.rpop(key); + return getResponse(BuilderFactory.STRING); } - public void rpoplpush(String srckey, String dstkey) { + public Response rpoplpush(String srckey, String dstkey) { client.rpoplpush(srckey, dstkey); + return getResponse(BuilderFactory.STRING); } - public void rpoplpush(byte[] srckey, byte[] dstkey) { + public Response rpoplpush(byte[] srckey, byte[] dstkey) { client.rpoplpush(srckey, dstkey); + return getResponse(BuilderFactory.STRING); } - public void rpush(String key, String string) { + public Response rpush(String key, String string) { client.rpush(key, string); + return getResponse(BuilderFactory.LONG); } - public void rpush(byte[] key, byte[] string) { + public Response rpush(byte[] key, byte[] string) { client.rpush(key, string); + return getResponse(BuilderFactory.LONG); } - public void rpushx(String key, String string) { + public Response rpushx(String key, String string) { client.rpushx(key, string); + return getResponse(BuilderFactory.LONG); } - public void rpushx(byte[] key, byte[] string) { + public Response rpushx(byte[] key, byte[] string) { client.rpushx(key, string); + return getResponse(BuilderFactory.LONG); } - public void sadd(String key, String member) { + public Response sadd(String key, String member) { client.sadd(key, member); + return getResponse(BuilderFactory.LONG); } - public void sadd(byte[] key, byte[] member) { + public Response sadd(byte[] key, byte[] member) { client.sadd(key, member); + return getResponse(BuilderFactory.LONG); } - public void scard(String key) { + public Response scard(String key) { client.scard(key); + return getResponse(BuilderFactory.LONG); } - public void scard(byte[] key) { + public Response scard(byte[] key) { client.scard(key); + return getResponse(BuilderFactory.LONG); } - public void sdiff(String... keys) { + public Response> sdiff(String... keys) { client.sdiff(keys); + return getResponse(BuilderFactory.STRING_SET); } - public void sdiff(byte[]... keys) { + public Response> sdiff(byte[]... keys) { client.sdiff(keys); + return getResponse(BuilderFactory.STRING_SET); } - public void sdiffstore(String dstkey, String... keys) { + public Response sdiffstore(String dstkey, String... keys) { client.sdiffstore(dstkey, keys); + return getResponse(BuilderFactory.LONG); } - public void sdiffstore(byte[] dstkey, byte[]... keys) { + public Response sdiffstore(byte[] dstkey, byte[]... keys) { client.sdiffstore(dstkey, keys); + return getResponse(BuilderFactory.LONG); } - public void set(String key, String value) { + public Response set(String key, String value) { client.set(key, value); + return getResponse(BuilderFactory.STRING); } - public void set(byte[] key, byte[] value) { + public Response set(byte[] key, byte[] value) { client.set(key, value); + return getResponse(BuilderFactory.STRING); } - public void setbit(String key, long offset, boolean value) { + public Response setbit(String key, long offset, boolean value) { client.setbit(key, offset, value); + return getResponse(BuilderFactory.BOOLEAN); } - public void setex(String key, int seconds, String value) { + public Response setex(String key, int seconds, String value) { client.setex(key, seconds, value); + return getResponse(BuilderFactory.STRING); } - public void setex(byte[] key, int seconds, byte[] value) { + public Response setex(byte[] key, int seconds, byte[] value) { client.setex(key, seconds, value); + return getResponse(BuilderFactory.STRING); } - public void setnx(String key, String value) { + public Response setnx(String key, String value) { client.setnx(key, value); + return getResponse(BuilderFactory.LONG); } - public void setnx(byte[] key, byte[] value) { + public Response setnx(byte[] key, byte[] value) { client.setnx(key, value); + return getResponse(BuilderFactory.LONG); } - public void setrange(String key, long offset, String value) { + public Response setrange(String key, long offset, String value) { client.setrange(key, offset, value); + return getResponse(BuilderFactory.LONG); } - public void sinter(String... keys) { + public Response> sinter(String... keys) { client.sinter(keys); + return getResponse(BuilderFactory.STRING_SET); } - public void sinter(byte[]... keys) { + public Response> sinter(byte[]... keys) { client.sinter(keys); + return getResponse(BuilderFactory.STRING_SET); } - public void sinterstore(String dstkey, String... keys) { + public Response sinterstore(String dstkey, String... keys) { client.sinterstore(dstkey, keys); + return getResponse(BuilderFactory.LONG); } - public void sinterstore(byte[] dstkey, byte[]... keys) { + public Response sinterstore(byte[] dstkey, byte[]... keys) { client.sinterstore(dstkey, keys); + return getResponse(BuilderFactory.LONG); } - public void sismember(String key, String member) { + public Response sismember(String key, String member) { client.sismember(key, member); + return getResponse(BuilderFactory.BOOLEAN); } - public void sismember(byte[] key, byte[] member) { + public Response sismember(byte[] key, byte[] member) { client.sismember(key, member); + return getResponse(BuilderFactory.BOOLEAN); } - public void smembers(String key) { + public Response> smembers(String key) { client.smembers(key); + return getResponse(BuilderFactory.STRING_SET); } - public void smembers(byte[] key) { + public Response> smembers(byte[] key) { client.smembers(key); + return getResponse(BuilderFactory.STRING_SET); } - public void smove(String srckey, String dstkey, String member) { + public Response smove(String srckey, String dstkey, String member) { client.smove(srckey, dstkey, member); + return getResponse(BuilderFactory.LONG); } - public void smove(byte[] srckey, byte[] dstkey, byte[] member) { + public Response smove(byte[] srckey, byte[] dstkey, byte[] member) { client.smove(srckey, dstkey, member); + return getResponse(BuilderFactory.LONG); } - public void sort(String key) { + public Response> sort(String key) { client.sort(key); + return getResponse(BuilderFactory.STRING_LIST); } - public void sort(byte[] key) { + public Response> sort(byte[] key) { client.sort(key); + return getResponse(BuilderFactory.STRING_LIST); } - public void sort(String key, SortingParams sortingParameters) { + public Response> sort(String key, + SortingParams sortingParameters) { client.sort(key, sortingParameters); + return getResponse(BuilderFactory.STRING_LIST); } - public void sort(byte[] key, SortingParams sortingParameters) { + public Response> sort(byte[] key, + SortingParams sortingParameters) { client.sort(key, sortingParameters); + return getResponse(BuilderFactory.STRING_LIST); } - public void sort(String key, SortingParams sortingParameters, String dstkey) { + public Response> sort(String key, + SortingParams sortingParameters, String dstkey) { client.sort(key, sortingParameters, dstkey); + return getResponse(BuilderFactory.STRING_LIST); } - public void sort(byte[] key, SortingParams sortingParameters, byte[] dstkey) { + public Response> sort(byte[] key, + SortingParams sortingParameters, byte[] dstkey) { client.sort(key, sortingParameters, dstkey); + return getResponse(BuilderFactory.STRING_LIST); } - public void sort(String key, String dstkey) { + public Response> sort(String key, String dstkey) { client.sort(key, dstkey); + return getResponse(BuilderFactory.STRING_LIST); } - public void sort(byte[] key, byte[] dstkey) { + public Response> sort(byte[] key, byte[] dstkey) { client.sort(key, dstkey); + return getResponse(BuilderFactory.STRING_LIST); } - public void spop(String key) { + public Response spop(String key) { client.spop(key); + return getResponse(BuilderFactory.STRING); } - public void spop(byte[] key) { + public Response spop(byte[] key) { client.spop(key); + return getResponse(BuilderFactory.STRING); } - public void srandmember(String key) { + public Response srandmember(String key) { client.srandmember(key); + return getResponse(BuilderFactory.STRING); } - public void srandmember(byte[] key) { + public Response srandmember(byte[] key) { client.srandmember(key); + return getResponse(BuilderFactory.STRING); } - public void srem(String key, String member) { + public Response srem(String key, String member) { client.srem(key, member); + return getResponse(BuilderFactory.LONG); } - public void srem(byte[] key, byte[] member) { + public Response srem(byte[] key, byte[] member) { client.srem(key, member); + return getResponse(BuilderFactory.LONG); } - public void strlen(String key) { + public Response strlen(String key) { client.strlen(key); + return getResponse(BuilderFactory.LONG); } - public void strlen(byte[] key) { + public Response strlen(byte[] key) { client.strlen(key); + return getResponse(BuilderFactory.LONG); } - public void substr(String key, int start, int end) { + public Response substr(String key, int start, int end) { client.substr(key, start, end); + return getResponse(BuilderFactory.STRING); } - public void substr(byte[] key, int start, int end) { + public Response substr(byte[] key, int start, int end) { client.substr(key, start, end); + return getResponse(BuilderFactory.STRING); } - public void sunion(String... keys) { + public Response> sunion(String... keys) { client.sunion(keys); + return getResponse(BuilderFactory.STRING_SET); } - public void sunion(byte[]... keys) { + public Response> sunion(byte[]... keys) { client.sunion(keys); + return getResponse(BuilderFactory.STRING_SET); } - public void sunionstore(String dstkey, String... keys) { + public Response sunionstore(String dstkey, String... keys) { client.sunionstore(dstkey, keys); + return getResponse(BuilderFactory.LONG); } - public void sunionstore(byte[] dstkey, byte[]... keys) { + public Response sunionstore(byte[] dstkey, byte[]... keys) { client.sunionstore(dstkey, keys); + return getResponse(BuilderFactory.LONG); } - public void ttl(String key) { + public Response ttl(String key) { client.ttl(key); + return getResponse(BuilderFactory.LONG); } - public void ttl(byte[] key) { + public Response ttl(byte[] key) { client.ttl(key); + return getResponse(BuilderFactory.LONG); } - public void type(String key) { + public Response type(String key) { client.type(key); + return getResponse(BuilderFactory.STRING); } - public void type(byte[] key) { + public Response type(byte[] key) { client.type(key); + return getResponse(BuilderFactory.STRING); } - public void watch(String... keys) { + public Response watch(String... keys) { client.watch(keys); + return getResponse(BuilderFactory.STRING); } - public void watch(byte[]... keys) { + public Response watch(byte[]... keys) { client.watch(keys); + return getResponse(BuilderFactory.STRING); } - public void zadd(String key, double score, String member) { + public Response zadd(String key, double score, String member) { client.zadd(key, score, member); + return getResponse(BuilderFactory.LONG); } - public void zadd(byte[] key, double score, byte[] member) { + public Response zadd(byte[] key, double score, byte[] member) { client.zadd(key, score, member); + return getResponse(BuilderFactory.LONG); } - public void zcard(String key) { + public Response zcard(String key) { client.zcard(key); + return getResponse(BuilderFactory.LONG); } - public void zcard(byte[] key) { + public Response zcard(byte[] key) { client.zcard(key); + return getResponse(BuilderFactory.LONG); } - public void zcount(String key, double min, double max) { + public Response zcount(String key, double min, double max) { client.zcount(key, min, max); + return getResponse(BuilderFactory.LONG); } - public void zcount(byte[] key, double min, double max) { + public Response zcount(byte[] key, double min, double max) { client.zcount(key, min, max); + return getResponse(BuilderFactory.LONG); } - public void zincrby(String key, double score, String member) { + public Response zincrby(String key, double score, String member) { client.zincrby(key, score, member); + return getResponse(BuilderFactory.DOUBLE); } - public void zincrby(byte[] key, double score, byte[] member) { + public Response zincrby(byte[] key, double score, byte[] member) { client.zincrby(key, score, member); + return getResponse(BuilderFactory.DOUBLE); } - public void zinterstore(String dstkey, String... sets) { + public Response zinterstore(String dstkey, String... sets) { client.zinterstore(dstkey, sets); + return getResponse(BuilderFactory.LONG); } - public void zinterstore(byte[] dstkey, byte[]... sets) { + public Response zinterstore(byte[] dstkey, byte[]... sets) { client.zinterstore(dstkey, sets); + return getResponse(BuilderFactory.LONG); } - public void zinterstore(String dstkey, ZParams params, String... sets) { + public Response zinterstore(String dstkey, ZParams params, + String... sets) { client.zinterstore(dstkey, params, sets); + return getResponse(BuilderFactory.LONG); } - public void zinterstore(byte[] dstkey, ZParams params, byte[]... sets) { + public Response zinterstore(byte[] dstkey, ZParams params, + byte[]... sets) { client.zinterstore(dstkey, params, sets); + return getResponse(BuilderFactory.LONG); } - public void zrange(String key, int start, int end) { + public Response> zrange(String key, int start, int end) { client.zrange(key, start, end); + return getResponse(BuilderFactory.STRING_ZSET); } - public void zrange(byte[] key, int start, int end) { + public Response> zrange(byte[] key, int start, int end) { client.zrange(key, start, end); + return getResponse(BuilderFactory.STRING_ZSET); } - public void zrangeByScore(String key, double min, double max) { + public Response> zrangeByScore(String key, double min, + double max) { client.zrangeByScore(key, min, max); + return getResponse(BuilderFactory.STRING_ZSET); } - public void zrangeByScore(byte[] key, double min, double max) { + public Response> zrangeByScore(byte[] key, double min, + double max) { client.zrangeByScore(key, min, max); + return getResponse(BuilderFactory.STRING_ZSET); } - public void zrangeByScore(String key, String min, String max) { + public Response> zrangeByScore(String key, String min, + String max) { client.zrangeByScore(key, min, max); + return getResponse(BuilderFactory.STRING_ZSET); } - public void zrangeByScore(byte[] key, byte[] min, byte[] max) { + public Response> zrangeByScore(byte[] key, byte[] min, + byte[] max) { client.zrangeByScore(key, min, max); + return getResponse(BuilderFactory.STRING_ZSET); } - public void zrangeByScore(String key, double min, double max, int offset, - int count) { + public Response> zrangeByScore(String key, double min, + double max, int offset, int count) { client.zrangeByScore(key, min, max, offset, count); + return getResponse(BuilderFactory.STRING_ZSET); } - public void zrangeByScore(byte[] key, double min, double max, int offset, - int count) { + public Response> zrangeByScore(byte[] key, double min, + double max, int offset, int count) { client.zrangeByScore(key, min, max, offset, count); + return getResponse(BuilderFactory.STRING_ZSET); } - public void zrangeByScoreWithScores(String key, double min, double max) { + public Response> zrangeByScoreWithScores(String key, double min, + double max) { client.zrangeByScoreWithScores(key, min, max); + return getResponse(BuilderFactory.TUPLE_ZSET); } - public void zrangeByScoreWithScores(byte[] key, double min, double max) { + public Response> zrangeByScoreWithScores(byte[] key, double min, + double max) { client.zrangeByScoreWithScores(key, min, max); + return getResponse(BuilderFactory.TUPLE_ZSET); } - public void zrangeByScoreWithScores(String key, double min, double max, - int offset, int count) { + public Response> zrangeByScoreWithScores(String key, double min, + double max, int offset, int count) { client.zrangeByScoreWithScores(key, min, max, offset, count); + return getResponse(BuilderFactory.TUPLE_ZSET); } - public void zrangeByScoreWithScores(byte[] key, double min, double max, - int offset, int count) { + public Response> zrangeByScoreWithScores(byte[] key, double min, + double max, int offset, int count) { client.zrangeByScoreWithScores(key, min, max, offset, count); + return getResponse(BuilderFactory.TUPLE_ZSET); } - public void zrangeWithScores(String key, int start, int end) { + public Response> zrangeWithScores(String key, int start, int end) { client.zrangeWithScores(key, start, end); + return getResponse(BuilderFactory.TUPLE_ZSET); } - public void zrangeWithScores(byte[] key, int start, int end) { + public Response> zrangeWithScores(byte[] key, int start, int end) { client.zrangeWithScores(key, start, end); + return getResponse(BuilderFactory.TUPLE_ZSET); } - public void zrank(String key, String member) { + public Response zrank(String key, String member) { client.zrank(key, member); + return getResponse(BuilderFactory.LONG); } - public void zrank(byte[] key, byte[] member) { + public Response zrank(byte[] key, byte[] member) { client.zrank(key, member); + return getResponse(BuilderFactory.LONG); } - public void zrem(String key, String member) { + public Response zrem(String key, String member) { client.zrem(key, member); + return getResponse(BuilderFactory.LONG); } - public void zrem(byte[] key, byte[] member) { + public Response zrem(byte[] key, byte[] member) { client.zrem(key, member); + return getResponse(BuilderFactory.LONG); } - public void zremrangeByRank(String key, int start, int end) { + public Response zremrangeByRank(String key, int start, int end) { client.zremrangeByRank(key, start, end); + return getResponse(BuilderFactory.LONG); } - public void zremrangeByRank(byte[] key, int start, int end) { + public Response zremrangeByRank(byte[] key, int start, int end) { client.zremrangeByRank(key, start, end); + return getResponse(BuilderFactory.LONG); } - public void zremrangeByScore(String key, double start, double end) { + public Response zremrangeByScore(String key, double start, double end) { client.zremrangeByScore(key, start, end); + return getResponse(BuilderFactory.LONG); } - public void zremrangeByScore(byte[] key, double start, double end) { + public Response zremrangeByScore(byte[] key, double start, double end) { client.zremrangeByScore(key, start, end); + return getResponse(BuilderFactory.LONG); } - public void zrevrange(String key, int start, int end) { + public Response> zrevrange(String key, int start, int end) { client.zrevrange(key, start, end); + return getResponse(BuilderFactory.STRING_ZSET); } - public void zrevrange(byte[] key, int start, int end) { + public Response> zrevrange(byte[] key, int start, int end) { client.zrevrange(key, start, end); + return getResponse(BuilderFactory.STRING_ZSET); } - public void zrevrangeWithScores(String key, int start, int end) { + public Response> zrevrangeWithScores(String key, int start, + int end) { client.zrevrangeWithScores(key, start, end); + return getResponse(BuilderFactory.TUPLE_ZSET); } - public void zrevrangeWithScores(byte[] key, int start, int end) { + public Response> zrevrangeWithScores(byte[] key, int start, + int end) { client.zrevrangeWithScores(key, start, end); + return getResponse(BuilderFactory.TUPLE_ZSET); } - public void zrevrank(String key, String member) { + public Response zrevrank(String key, String member) { client.zrevrank(key, member); + return getResponse(BuilderFactory.LONG); } - public void zrevrank(byte[] key, byte[] member) { + public Response zrevrank(byte[] key, byte[] member) { client.zrevrank(key, member); + return getResponse(BuilderFactory.LONG); } - public void zscore(String key, String member) { + public Response zscore(String key, String member) { client.zscore(key, member); + return getResponse(BuilderFactory.DOUBLE); } - public void zscore(byte[] key, byte[] member) { + public Response zscore(byte[] key, byte[] member) { client.zscore(key, member); + return getResponse(BuilderFactory.DOUBLE); } - public void zunionstore(String dstkey, String... sets) { + public Response zunionstore(String dstkey, String... sets) { client.zunionstore(dstkey, sets); + return getResponse(BuilderFactory.LONG); } - public void zunionstore(byte[] dstkey, byte[]... sets) { + public Response zunionstore(byte[] dstkey, byte[]... sets) { client.zunionstore(dstkey, sets); + return getResponse(BuilderFactory.LONG); } - public void zunionstore(String dstkey, ZParams params, String... sets) { + public Response zunionstore(String dstkey, ZParams params, + String... sets) { client.zunionstore(dstkey, params, sets); + return getResponse(BuilderFactory.LONG); } - public void zunionstore(byte[] dstkey, ZParams params, byte[]... sets) { + public Response zunionstore(byte[] dstkey, ZParams params, + byte[]... sets) { client.zunionstore(dstkey, params, sets); + return getResponse(BuilderFactory.LONG); } - public List execute() { - return client.getAll(); - } - - public void bgrewriteaof() { + public Response bgrewriteaof() { client.bgrewriteaof(); + return getResponse(BuilderFactory.STRING); } - public void bgsave() { + public Response bgsave() { client.bgsave(); + return getResponse(BuilderFactory.STRING); } - public void configGet(String pattern) { + public Response configGet(String pattern) { client.configGet(pattern); + return getResponse(BuilderFactory.STRING); } - public void configSet(String parameter, String value) { + public Response configSet(String parameter, String value) { client.configSet(parameter, value); + return getResponse(BuilderFactory.STRING); } - public void brpoplpush(String source, String destination, int timeout) { + public Response brpoplpush(String source, String destination, + int timeout) { client.brpoplpush(source, destination, timeout); + return getResponse(BuilderFactory.STRING); } - public void brpoplpush(byte[] source, byte[] destination, int timeout) { + public Response brpoplpush(byte[] source, byte[] destination, + int timeout) { client.brpoplpush(source, destination, timeout); + return getResponse(BuilderFactory.STRING); } - public void configResetStat() { + public Response configResetStat() { client.configResetStat(); + return getResponse(BuilderFactory.STRING); } - public void save() { + public Response save() { client.save(); + return getResponse(BuilderFactory.STRING); } - public void lastsave() { + public Response lastsave() { client.lastsave(); + return getResponse(BuilderFactory.LONG); } - public void discard() { + public Response discard() { client.discard(); + return getResponse(BuilderFactory.STRING); } public void exec() { @@ -861,4 +1112,4 @@ public class Pipeline implements Commands { public void multi() { client.multi(); } -} +} \ No newline at end of file diff --git a/src/main/java/redis/clients/jedis/PipelineBlock.java b/src/main/java/redis/clients/jedis/PipelineBlock.java index dbde9c4..9afc391 100644 --- a/src/main/java/redis/clients/jedis/PipelineBlock.java +++ b/src/main/java/redis/clients/jedis/PipelineBlock.java @@ -1,466 +1,6 @@ package redis.clients.jedis; -import redis.clients.jedis.BinaryClient.LIST_POSITION; - -import java.util.Map; - -public abstract class PipelineBlock implements Commands { - private Client client; - - public void setClient(Client client) { - this.client = client; - } - - public void append(String key, String value) { - client.append(key, value); - } - - public void blpop(String[] args) { - client.blpop(args); - } - - public void brpop(String[] args) { - client.brpop(args); - } - - public void decr(String key) { - client.decr(key); - } - - public void decrBy(String key, long integer) { - client.decrBy(key, integer); - } - - public void del(String... keys) { - client.del(keys); - } - - public void echo(String string) { - client.echo(string); - } - - public void exists(String key) { - client.exists(key); - } - - public void expire(String key, int seconds) { - client.expire(key, seconds); - } - - public void expireAt(String key, long unixTime) { - client.expireAt(key, unixTime); - } - - public void get(String key) { - client.get(key); - } - - public void getbit(String key, long offset) { - client.getbit(key, offset); - } - - public void getrange(String key, long startOffset, long endOffset) { - client.getrange(key, startOffset, endOffset); - } - - public void getSet(String key, String value) { - client.getSet(key, value); - } - - public void hdel(String key, String field) { - client.hdel(key, field); - } - - public void hexists(String key, String field) { - client.hexists(key, field); - } - - public void hget(String key, String field) { - client.hget(key, field); - } - - public void hgetAll(String key) { - client.hgetAll(key); - } - - public void hincrBy(String key, String field, long value) { - client.hincrBy(key, field, value); - } - - public void hkeys(String key) { - client.hkeys(key); - } - - public void hlen(String key) { - client.hlen(key); - } - - public void hmget(String key, String... fields) { - client.hmget(key, fields); - } - - public void hmset(String key, Map hash) { - client.hmset(key, hash); - } - - public void hset(String key, String field, String value) { - client.hset(key, field, value); - } - - public void hsetnx(String key, String field, String value) { - client.hsetnx(key, field, value); - } - - public void hvals(String key) { - client.hvals(key); - } - - public void incr(String key) { - client.incr(key); - } - - public void incrBy(String key, long integer) { - client.incrBy(key, integer); - } - - public void keys(String pattern) { - client.keys(pattern); - } - - public void lindex(String key, int index) { - client.lindex(key, index); - } - - public void linsert(String key, LIST_POSITION where, String pivot, - String value) { - client.linsert(key, where, pivot, value); - } - - public void llen(String key) { - client.llen(key); - } - - public void lpop(String key) { - client.lpop(key); - } - - public void lpush(String key, String string) { - client.lpush(key, string); - } - - public void lpushx(String key, String string) { - client.lpushx(key, string); - } - - public void lrange(String key, int start, int end) { - client.lrange(key, start, end); - } - - public void lrem(String key, int count, String value) { - client.lrem(key, count, value); - } - - public void lset(String key, int index, String value) { - client.lset(key, index, value); - } - - public void ltrim(String key, int start, int end) { - client.ltrim(key, start, end); - } - - public void mget(String... keys) { - client.mget(keys); - } - - public void move(String key, int dbIndex) { - client.move(key, dbIndex); - } - - public void mset(String... keysvalues) { - client.mset(keysvalues); - } - - public void msetnx(String... keysvalues) { - client.msetnx(keysvalues); - } - - public void persist(String key) { - client.persist(key); - } - - public void rename(String oldkey, String newkey) { - client.rename(oldkey, newkey); - } - - public void renamenx(String oldkey, String newkey) { - client.renamenx(oldkey, newkey); - } - - public void rpop(String key) { - client.rpop(key); - } - - public void rpoplpush(String srckey, String dstkey) { - client.rpoplpush(srckey, dstkey); - } - - public void rpush(String key, String string) { - client.rpush(key, string); - } - - public void rpushx(String key, String string) { - client.rpushx(key, string); - } - - public void sadd(String key, String member) { - client.sadd(key, member); - } - - public void scard(String key) { - client.scard(key); - } - - public void sdiff(String... keys) { - client.sdiff(keys); - } - - public void sdiffstore(String dstkey, String... keys) { - client.sdiffstore(dstkey, keys); - } - - public void set(String key, String value) { - client.set(key, value); - } - - public void setbit(String key, long offset, boolean value) { - client.setbit(key, offset, value); - } - - public void setex(String key, int seconds, String value) { - client.setex(key, seconds, value); - } - - public void setnx(String key, String value) { - client.setnx(key, value); - } - - public void setrange(String key, long offset, String value) { - client.setrange(key, offset, value); - } - - public void sinter(String... keys) { - client.sinter(keys); - } - - public void sinterstore(String dstkey, String... keys) { - client.sinterstore(dstkey, keys); - } - - public void sismember(String key, String member) { - client.sismember(key, member); - } - - public void smembers(String key) { - client.smembers(key); - } - - public void smove(String srckey, String dstkey, String member) { - client.smove(srckey, dstkey, member); - } - - public void sort(String key) { - client.sort(key); - } - - public void sort(String key, SortingParams sortingParameters) { - client.sort(key, sortingParameters); - } - - public void sort(String key, SortingParams sortingParameters, String dstkey) { - client.sort(key, sortingParameters, dstkey); - } - - public void sort(String key, String dstkey) { - client.sort(key, dstkey); - } - - public void spop(String key) { - client.spop(key); - } - - public void srandmember(String key) { - client.srandmember(key); - } - - public void srem(String key, String member) { - client.srem(key, member); - } - - public void strlen(String key) { - client.strlen(key); - } - - public void substr(String key, int start, int end) { - client.substr(key, start, end); - } - - public void sunion(String... keys) { - client.sunion(keys); - } - - public void sunionstore(String dstkey, String... keys) { - client.sunionstore(dstkey, keys); - } - - public void ttl(String key) { - client.ttl(key); - } - - public void type(String key) { - client.type(key); - } - - public void watch(String... keys) { - client.watch(keys); - } - - public void zadd(String key, double score, String member) { - client.zadd(key, score, member); - } - - public void zcard(String key) { - client.zcard(key); - } - - public void zcount(String key, double min, double max) { - client.zcount(key, min, max); - } - - public void zincrby(String key, double score, String member) { - client.zincrby(key, score, member); - } - - public void zinterstore(String dstkey, String... sets) { - client.zinterstore(dstkey, sets); - } - - public void zinterstore(String dstkey, ZParams params, String... sets) { - client.zinterstore(dstkey, params, sets); - } - - public void zrange(String key, int start, int end) { - client.zrange(key, start, end); - } - - public void zrangeByScore(String key, double min, double max) { - client.zrangeByScore(key, min, max); - } - - public void zrangeByScore(String key, String min, String max) { - client.zrangeByScore(key, min, max); - } - - public void zrangeByScore(String key, double min, double max, int offset, - int count) { - client.zrangeByScore(key, min, max, offset, count); - } - - public void zrangeByScoreWithScores(String key, double min, double max) { - client.zrangeByScoreWithScores(key, min, max); - } - - public void zrangeByScoreWithScores(String key, double min, double max, - int offset, int count) { - client.zrangeByScoreWithScores(key, min, max, offset, count); - } - - public void zrangeWithScores(String key, int start, int end) { - client.zrangeWithScores(key, start, end); - } - - public void zrank(String key, String member) { - client.zrank(key, member); - } - - public void zrem(String key, String member) { - client.zrem(key, member); - } - - public void zremrangeByRank(String key, int start, int end) { - client.zremrangeByRank(key, start, end); - } - - public void zremrangeByScore(String key, double start, double end) { - client.zremrangeByScore(key, start, end); - } - - public void zrevrange(String key, int start, int end) { - client.zrevrange(key, start, end); - } - - public void zrevrangeWithScores(String key, int start, int end) { - client.zrevrangeWithScores(key, start, end); - } - - public void zrevrank(String key, String member) { - client.zrevrank(key, member); - } - - public void zscore(String key, String member) { - client.zscore(key, member); - } - - public void zunionstore(String dstkey, String... sets) { - client.zunionstore(dstkey, sets); - } - - public void zunionstore(String dstkey, ZParams params, String... sets) { - client.zunionstore(dstkey, params, sets); - } - - public void bgrewriteaof() { - client.bgrewriteaof(); - } - - public void bgsave() { - client.bgsave(); - } - - public void configGet(String pattern) { - client.configGet(pattern); - } - - public void configSet(String parameter, String value) { - client.configSet(parameter, value); - } - - public void brpoplpush(String source, String destination, int timeout) { - client.brpoplpush(source, destination, timeout); - } - - public void configResetStat() { - client.configResetStat(); - } - - public void save() { - client.save(); - } - - public void lastsave() { - client.lastsave(); - } - - public void discard() { - client.discard(); - } - - public void exec() { - client.exec(); - } - - public void multi() { - client.multi(); - } +public abstract class PipelineBlock extends Pipeline { public abstract void execute(); } diff --git a/src/main/java/redis/clients/jedis/Response.java b/src/main/java/redis/clients/jedis/Response.java new file mode 100644 index 0000000..13a77cb --- /dev/null +++ b/src/main/java/redis/clients/jedis/Response.java @@ -0,0 +1,31 @@ +package redis.clients.jedis; + +import redis.clients.jedis.exceptions.JedisDataException; + +public class Response { + protected T response = null; + private boolean built = false; + private Builder builder; + + public Response(Builder b) { + this.builder = b; + } + + public void set(Object data) { + response = builder.build(data); + built = true; + } + + public T get() { + if (!built) { + throw new JedisDataException( + "Please close pipeline or multi block before calling this method."); + } + return response; + } + + public String toString() { + return "Response " + builder.toString(); + } + +} diff --git a/src/test/java/redis/clients/jedis/tests/PipeliningTest.java b/src/test/java/redis/clients/jedis/tests/PipeliningTest.java index 0928553..ea1c8e3 100644 --- a/src/test/java/redis/clients/jedis/tests/PipeliningTest.java +++ b/src/test/java/redis/clients/jedis/tests/PipeliningTest.java @@ -2,6 +2,7 @@ package redis.clients.jedis.tests; import java.io.UnsupportedEncodingException; import java.util.List; +import java.util.Set; import org.junit.Assert; import org.junit.Before; @@ -10,7 +11,8 @@ import org.junit.Test; import redis.clients.jedis.Jedis; import redis.clients.jedis.Pipeline; import redis.clients.jedis.PipelineBlock; -import redis.clients.jedis.Protocol; +import redis.clients.jedis.Response; +import redis.clients.jedis.exceptions.JedisDataException; import redis.clients.jedis.tests.HostAndPortUtil.HostAndPort; public class PipeliningTest extends Assert { @@ -36,21 +38,50 @@ public class PipeliningTest extends Assert { }); assertEquals(2, results.size()); - assertArrayEquals("OK".getBytes(Protocol.CHARSET), (byte[]) results - .get(0)); - assertArrayEquals("bar".getBytes(Protocol.CHARSET), (byte[]) results - .get(1)); + assertEquals("OK", results.get(0)); + assertEquals("bar", results.get(1)); Pipeline p = jedis.pipelined(); p.set("foo", "bar"); p.get("foo"); - results = p.execute(); + results = p.sync(); assertEquals(2, results.size()); - assertArrayEquals("OK".getBytes(Protocol.CHARSET), (byte[]) results - .get(0)); - assertArrayEquals("bar".getBytes(Protocol.CHARSET), (byte[]) results - .get(1)); + assertEquals("OK", results.get(0)); + assertEquals("bar", results.get(1)); } + + @Test + public void pipelineResponse() { + jedis.set("string", "foo"); + jedis.lpush("list", "foo"); + jedis.hset("hash", "foo", "bar"); + jedis.zadd("zset", 1, "foo"); + jedis.sadd("set", "foo"); + + Pipeline p = jedis.pipelined(); + Response string = p.get("string"); + Response list = p.lpop("list"); + Response hash = p.hget("hash", "foo"); + Response> zset = p.zrange("zset", 0, -1); + Response set = p.spop("set"); + p.sync(); + + assertEquals("foo", string.get()); + assertEquals("foo", list.get()); + assertEquals("bar", hash.get()); + assertEquals("foo", zset.get().iterator().next()); + assertEquals("foo", set.get()); + } + + @Test(expected = JedisDataException.class) + public void pipelineResponseWithinPipeline() { + jedis.set("string", "foo"); + + Pipeline p = jedis.pipelined(); + Response string = p.get("string"); + string.get(); + p.sync(); + } }