rik/jlibredis
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'variadic' of git://github.com/ivowiblo/jedis into variadic

Browse Source 
Conflicts:
	src/main/java/redis/clients/jedis/BinaryClient.java
	src/main/java/redis/clients/jedis/BinaryJedis.java
	src/main/java/redis/clients/jedis/BinaryShardedJedis.java
	src/main/java/redis/clients/jedis/Client.java
	src/main/java/redis/clients/jedis/Commands.java
	src/main/java/redis/clients/jedis/Jedis.java
	src/main/java/redis/clients/jedis/ShardedJedis.java
This commit is contained in:
Jonathan Leibiusky
2012-04-23 21:00:29 -03:00
parent 3da2f2dd57 dd88c51db8
commit 05503212aa
13 changed files with 976 additions and 730 deletions
Download Patch File Download Diff File Expand all files Collapse all files

62
src/main/java/redis/clients/jedis/BinaryClient.java
View File

@@ -2,13 +2,13 @@ package redis.clients.jedis;
import static redis.clients.jedis.Protocol.toByteArray;
import static redis.clients.jedis.Protocol.Command.*;
import static redis.clients.jedis.Protocol.Keyword.LEN;
import static redis.clients.jedis.Protocol.Keyword.LIMIT;
import static redis.clients.jedis.Protocol.Keyword.NO;
import static redis.clients.jedis.Protocol.Keyword.ONE;
import static redis.clients.jedis.Protocol.Keyword.RESET;
import static redis.clients.jedis.Protocol.Keyword.STORE;
import static redis.clients.jedis.Protocol.Keyword.WITHSCORES;
import static redis.clients.jedis.Protocol.Keyword.RESET;
import static redis.clients.jedis.Protocol.Keyword.LEN;
import java.util.ArrayList;
import java.util.List;
@@ -47,6 +47,15 @@ public class BinaryClient extends Connection {
super(host, port);
}
private byte[][] joinParameters(byte[] first, byte[][] rest) {
byte[][] result = new byte[rest.length + 1][];
result[0] = first;
for (int i = 0; i < rest.length; i++) {
result[i + 1] = rest[i];
}
return result;
}
public void setPassword(final String password) {
this.password = password;
}
@@ -230,8 +239,8 @@ public class BinaryClient extends Connection {
sendCommand(HEXISTS, key, field);
}
public void hdel(final byte[] key, final byte[] field) {
sendCommand(HDEL, key, field);
public void hdel(final byte[] key, final byte[]... fields) {
sendCommand(HDEL, joinParameters(key, fields));
}
public void hlen(final byte[] key) {
@@ -250,18 +259,12 @@ public class BinaryClient extends Connection {
sendCommand(HGETALL, key);
}
public void rpush(final byte[] key, final byte[]... vals) {
byte[][] args = new byte[vals.length + 1][];
args[0] = key;
System.arraycopy(vals, 0, args, 1, vals.length);
sendCommand(RPUSH, args);
public void rpush(final byte[] key, final byte[]... strings) {
sendCommand(RPUSH, joinParameters(key, strings));
}
public void lpush(final byte[] key, final byte[]... vals) {
byte[][] args = new byte[vals.length + 1][];
args[0] = key;
System.arraycopy(vals, 0, args, 1, vals.length);
sendCommand(LPUSH, args);
public void lpush(final byte[] key, final byte[]... strings) {
sendCommand(LPUSH, joinParameters(key, strings));
}
public void llen(final byte[] key) {
@@ -300,16 +303,16 @@ public class BinaryClient extends Connection {
sendCommand(RPOPLPUSH, srckey, dstkey);
}
public void sadd(final byte[] key, final byte[] member) {
sendCommand(SADD, key, member);
public void sadd(final byte[] key, final byte[]... members) {
sendCommand(SADD, joinParameters(key, members));
}
public void smembers(final byte[] key) {
sendCommand(SMEMBERS, key);
}
public void srem(final byte[] key, final byte[] member) {
sendCommand(SREM, key, member);
public void srem(final byte[] key, final byte[]... members) {
sendCommand(SREM, joinParameters(key, members));
}
public void spop(final byte[] key) {
@@ -370,12 +373,29 @@ public class BinaryClient extends Connection {
sendCommand(ZADD, key, toByteArray(score), member);
}
public void zaddBinary(final byte[] key, Map<Double, byte[]> scoreMembers) {
ArrayList<byte[]> args = new ArrayList<byte[]>(
scoreMembers.size() * 2 + 1);
args.add(key);
for (Map.Entry<Double, byte[]> entry : scoreMembers.entrySet()) {
args.add(toByteArray(entry.getKey()));
args.add(entry.getValue());
}
byte[][] argsArray = new byte[args.size()][];
args.toArray(argsArray);
sendCommand(ZADD, argsArray);
}
public void zrange(final byte[] key, final int start, final int end) {
sendCommand(ZRANGE, key, toByteArray(start), toByteArray(end));
}
public void zrem(final byte[] key, final byte[] member) {
sendCommand(ZREM, key, member);
public void zrem(final byte[] key, final byte[]... members) {
sendCommand(ZREM, joinParameters(key, members));
}
public void zincrby(final byte[] key, final double score,
@@ -785,4 +805,4 @@ public class BinaryClient extends Connection {
public void slowlogLen() {
sendCommand(SLOWLOG, LEN.raw);
}
}
}

46
src/main/java/redis/clients/jedis/BinaryJedis.java
View File

@@ -1,6 +1,6 @@
package redis.clients.jedis;
import static redis.clients.jedis.Protocol.Command.SCRIPT;
import static redis.clients.jedis.Protocol.toByteArray;
import java.util.ArrayList;
import java.util.HashSet;
@@ -11,12 +11,10 @@ import java.util.Map;
import java.util.Set;
import redis.clients.jedis.BinaryClient.LIST_POSITION;
import redis.clients.jedis.Protocol.Keyword;
import redis.clients.jedis.exceptions.JedisDataException;
import redis.clients.jedis.exceptions.JedisException;
import redis.clients.util.JedisByteHashMap;
import redis.clients.util.SafeEncoder;
import static redis.clients.jedis.Protocol.toByteArray;
public class BinaryJedis implements BinaryJedisCommands {
protected Client client = null;
@@ -800,13 +798,13 @@ public class BinaryJedis implements BinaryJedisCommands {
* <b>Time complexity:</b> O(1)
*
* @param key
* @param field
* @param fields
* @return If the field was present in the hash it is deleted and 1 is
* returned, otherwise 0 is returned and no operation is performed.
*/
public Long hdel(final byte[] key, final byte[] field) {
public Long hdel(final byte[] key, final byte[]... fields) {
checkIsInMulti();
client.hdel(key, field);
client.hdel(key, fields);
return client.getIntegerReply();
}
@@ -885,16 +883,16 @@ public class BinaryJedis implements BinaryJedisCommands {
* <p>
* Time complexity: O(1)
*
* @see BinaryJedis#lpush(byte[], byte[])
* @see BinaryJedis#rpush(byte[], byte[]...)
*
* @param key
* @param string
* @param strings
* @return Integer reply, specifically, the number of elements inside the
* list after the push operation.
*/
public Long rpush(final byte[] key, final byte[]... string) {
public Long rpush(final byte[] key, final byte[]... strings) {
checkIsInMulti();
client.rpush(key, string);
client.rpush(key, strings);
return client.getIntegerReply();
}
@@ -906,16 +904,16 @@ public class BinaryJedis implements BinaryJedisCommands {
* <p>
* Time complexity: O(1)
*
* @see BinaryJedis#rpush(byte[], byte[])
* @see BinaryJedis#rpush(byte[], byte[]...)
*
* @param key
* @param string
* @param strings
* @return Integer reply, specifically, the number of elements inside the
* list after the push operation.
*/
public Long lpush(final byte[] key, final byte[]... string) {
public Long lpush(final byte[] key, final byte[]... strings) {
checkIsInMulti();
client.lpush(key, string);
client.lpush(key, strings);
return client.getIntegerReply();
}
@@ -1166,13 +1164,13 @@ public class BinaryJedis implements BinaryJedisCommands {
* Time complexity O(1)
*
* @param key
* @param member
* @param members
* @return Integer reply, specifically: 1 if the new element was added 0 if
* the element was already a member of the set
*/
public Long sadd(final byte[] key, final byte[] member) {
public Long sadd(final byte[] key, final byte[]... members) {
checkIsInMulti();
client.sadd(key, member);
client.sadd(key, members);
return client.getIntegerReply();
}
@@ -1204,7 +1202,7 @@ public class BinaryJedis implements BinaryJedisCommands {
* @return Integer reply, specifically: 1 if the new element was removed 0
* if the new element was not a member of the set
*/
public Long srem(final byte[] key, final byte[] member) {
public Long srem(final byte[] key, final byte[]... member) {
checkIsInMulti();
client.srem(key, member);
return client.getIntegerReply();
@@ -1463,6 +1461,12 @@ public class BinaryJedis implements BinaryJedisCommands {
return client.getIntegerReply();
}
public Long zadd(final byte[] key, final Map<Double, byte[]> scoreMembers) {
checkIsInMulti();
client.zaddBinary(key, scoreMembers);
return client.getIntegerReply();
}
public Set<byte[]> zrange(final byte[] key, final int start, final int end) {
checkIsInMulti();
client.zrange(key, start, end);
@@ -1481,13 +1485,13 @@ public class BinaryJedis implements BinaryJedisCommands {
*
*
* @param key
* @param member
* @param members
* @return Integer reply, specifically: 1 if the new element was removed 0
* if the new element was not a member of the set
*/
public Long zrem(final byte[] key, final byte[] member) {
public Long zrem(final byte[] key, final byte[]... members) {
checkIsInMulti();
client.zrem(key, member);
client.zrem(key, members);
return client.getIntegerReply();
}

10
src/main/java/redis/clients/jedis/BinaryJedisCommands.java
View File

@@ -57,7 +57,7 @@ public interface BinaryJedisCommands {
Boolean hexists(byte[] key, byte[] field);
Long hdel(byte[] key, byte[] field);
Long hdel(byte[] key, byte[]... field);
Long hlen(byte[] key);
@@ -87,11 +87,11 @@ public interface BinaryJedisCommands {
byte[] rpop(byte[] key);
Long sadd(byte[] key, byte[] member);
Long sadd(byte[] key, byte[]... member);
Set<byte[]> smembers(byte[] key);
Long srem(byte[] key, byte[] member);
Long srem(byte[] key, byte[]... member);
byte[] spop(byte[] key);
@@ -102,10 +102,12 @@ public interface BinaryJedisCommands {
byte[] srandmember(byte[] key);
Long zadd(byte[] key, double score, byte[] member);
Long zadd(byte[] key, Map<Double, byte[]> scoreMembers);
Set<byte[]> zrange(byte[] key, int start, int end);
Long zrem(byte[] key, byte[] member);
Long zrem(byte[] key, byte[]... member);
Double zincrby(byte[] key, double score, byte[] member);

355
src/main/java/redis/clients/jedis/BinaryShardedJedis.java
View File

@@ -1,411 +1,416 @@
package redis.clients.jedis;
import redis.clients.jedis.BinaryClient.LIST_POSITION;
import redis.clients.util.Hashing;
import redis.clients.util.Sharded;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.regex.Pattern;
import redis.clients.jedis.BinaryClient.LIST_POSITION;
import redis.clients.util.Hashing;
import redis.clients.util.Sharded;
public class BinaryShardedJedis extends Sharded<Jedis, JedisShardInfo>
implements BinaryJedisCommands {
implements BinaryJedisCommands {
public BinaryShardedJedis(List<JedisShardInfo> shards) {
super(shards);
super(shards);
}
public BinaryShardedJedis(List<JedisShardInfo> shards, Hashing algo) {
super(shards, algo);
super(shards, algo);
}
public BinaryShardedJedis(List<JedisShardInfo> shards, Pattern keyTagPattern) {
super(shards, keyTagPattern);
super(shards, keyTagPattern);
}
public BinaryShardedJedis(List<JedisShardInfo> shards, Hashing algo,
Pattern keyTagPattern) {
super(shards, algo, keyTagPattern);
Pattern keyTagPattern) {
super(shards, algo, keyTagPattern);
}
public void disconnect() throws IOException {
for (Jedis jedis : getAllShards()) {
jedis.disconnect();
}
for (Jedis jedis : getAllShards()) {
jedis.disconnect();
}
}
protected Jedis create(JedisShardInfo shard) {
return new Jedis(shard);
return new Jedis(shard);
}
public String set(byte[] key, byte[] value) {
Jedis j = getShard(key);
return j.set(key, value);
Jedis j = getShard(key);
return j.set(key, value);
}
public byte[] get(byte[] key) {
Jedis j = getShard(key);
return j.get(key);
Jedis j = getShard(key);
return j.get(key);
}
public Boolean exists(byte[] key) {
Jedis j = getShard(key);
return j.exists(key);
Jedis j = getShard(key);
return j.exists(key);
}
public String type(byte[] key) {
Jedis j = getShard(key);
return j.type(key);
Jedis j = getShard(key);
return j.type(key);
}
public Long expire(byte[] key, int seconds) {
Jedis j = getShard(key);
return j.expire(key, seconds);
Jedis j = getShard(key);
return j.expire(key, seconds);
}
public Long expireAt(byte[] key, long unixTime) {
Jedis j = getShard(key);
return j.expireAt(key, unixTime);
Jedis j = getShard(key);
return j.expireAt(key, unixTime);
}
public Long ttl(byte[] key) {
Jedis j = getShard(key);
return j.ttl(key);
Jedis j = getShard(key);
return j.ttl(key);
}
public byte[] getSet(byte[] key, byte[] value) {
Jedis j = getShard(key);
return j.getSet(key, value);
Jedis j = getShard(key);
return j.getSet(key, value);
}
public Long setnx(byte[] key, byte[] value) {
Jedis j = getShard(key);
return j.setnx(key, value);
Jedis j = getShard(key);
return j.setnx(key, value);
}
public String setex(byte[] key, int seconds, byte[] value) {
Jedis j = getShard(key);
return j.setex(key, seconds, value);
Jedis j = getShard(key);
return j.setex(key, seconds, value);
}
public Long decrBy(byte[] key, long integer) {
Jedis j = getShard(key);
return j.decrBy(key, integer);
Jedis j = getShard(key);
return j.decrBy(key, integer);
}
public Long decr(byte[] key) {
Jedis j = getShard(key);
return j.decr(key);
Jedis j = getShard(key);
return j.decr(key);
}
public Long incrBy(byte[] key, long integer) {
Jedis j = getShard(key);
return j.incrBy(key, integer);
Jedis j = getShard(key);
return j.incrBy(key, integer);
}
public Long incr(byte[] key) {
Jedis j = getShard(key);
return j.incr(key);
Jedis j = getShard(key);
return j.incr(key);
}
public Long append(byte[] key, byte[] value) {
Jedis j = getShard(key);
return j.append(key, value);
Jedis j = getShard(key);
return j.append(key, value);
}
public byte[] substr(byte[] key, int start, int end) {
Jedis j = getShard(key);
return j.substr(key, start, end);
Jedis j = getShard(key);
return j.substr(key, start, end);
}
public Long hset(byte[] key, byte[] field, byte[] value) {
Jedis j = getShard(key);
return j.hset(key, field, value);
Jedis j = getShard(key);
return j.hset(key, field, value);
}
public byte[] hget(byte[] key, byte[] field) {
Jedis j = getShard(key);
return j.hget(key, field);
Jedis j = getShard(key);
return j.hget(key, field);
}
public Long hsetnx(byte[] key, byte[] field, byte[] value) {
Jedis j = getShard(key);
return j.hsetnx(key, field, value);
Jedis j = getShard(key);
return j.hsetnx(key, field, value);
}
public String hmset(byte[] key, Map<byte[], byte[]> hash) {
Jedis j = getShard(key);
return j.hmset(key, hash);
Jedis j = getShard(key);
return j.hmset(key, hash);
}
public List<byte[]> hmget(byte[] key, byte[]... fields) {
Jedis j = getShard(key);
return j.hmget(key, fields);
Jedis j = getShard(key);
return j.hmget(key, fields);
}
public Long hincrBy(byte[] key, byte[] field, long value) {
Jedis j = getShard(key);
return j.hincrBy(key, field, value);
Jedis j = getShard(key);
return j.hincrBy(key, field, value);
}
public Boolean hexists(byte[] key, byte[] field) {
Jedis j = getShard(key);
return j.hexists(key, field);
Jedis j = getShard(key);
return j.hexists(key, field);
}
public Long hdel(byte[] key, byte[] field) {
Jedis j = getShard(key);
return j.hdel(key, field);
public Long hdel(byte[] key, byte[]... fields) {
Jedis j = getShard(key);
return j.hdel(key, fields);
}
public Long hlen(byte[] key) {
Jedis j = getShard(key);
return j.hlen(key);
Jedis j = getShard(key);
return j.hlen(key);
}
public Set<byte[]> hkeys(byte[] key) {
Jedis j = getShard(key);
return j.hkeys(key);
Jedis j = getShard(key);
return j.hkeys(key);
}
public Collection<byte[]> hvals(byte[] key) {
Jedis j = getShard(key);
return j.hvals(key);
Jedis j = getShard(key);
return j.hvals(key);
}
public Map<byte[], byte[]> hgetAll(byte[] key) {
Jedis j = getShard(key);
return j.hgetAll(key);
Jedis j = getShard(key);
return j.hgetAll(key);
}
public Long rpush(byte[] key, byte[]... string) {
Jedis j = getShard(key);
return j.rpush(key, string);
public Long rpush(byte[] key, byte[]... strings) {
Jedis j = getShard(key);
return j.rpush(key, strings);
}
public Long lpush(byte[] key, byte[]... string) {
Jedis j = getShard(key);
return j.lpush(key, string);
public Long lpush(byte[] key, byte[]... strings) {
Jedis j = getShard(key);
return j.lpush(key, strings);
}
public Long llen(byte[] key) {
Jedis j = getShard(key);
return j.llen(key);
Jedis j = getShard(key);
return j.llen(key);
}
public List<byte[]> lrange(byte[] key, int start, int end) {
Jedis j = getShard(key);
return j.lrange(key, start, end);
Jedis j = getShard(key);
return j.lrange(key, start, end);
}
public String ltrim(byte[] key, int start, int end) {
Jedis j = getShard(key);
return j.ltrim(key, start, end);
Jedis j = getShard(key);
return j.ltrim(key, start, end);
}
public byte[] lindex(byte[] key, int index) {
Jedis j = getShard(key);
return j.lindex(key, index);
Jedis j = getShard(key);
return j.lindex(key, index);
}
public String lset(byte[] key, int index, byte[] value) {
Jedis j = getShard(key);
return j.lset(key, index, value);
Jedis j = getShard(key);
return j.lset(key, index, value);
}
public Long lrem(byte[] key, int count, byte[] value) {
Jedis j = getShard(key);
return j.lrem(key, count, value);
Jedis j = getShard(key);
return j.lrem(key, count, value);
}
public byte[] lpop(byte[] key) {
Jedis j = getShard(key);
return j.lpop(key);
Jedis j = getShard(key);
return j.lpop(key);
}
public byte[] rpop(byte[] key) {
Jedis j = getShard(key);
return j.rpop(key);
Jedis j = getShard(key);
return j.rpop(key);
}
public Long sadd(byte[] key, byte[] member) {
Jedis j = getShard(key);
return j.sadd(key, member);
public Long sadd(byte[] key, byte[]... members) {
Jedis j = getShard(key);
return j.sadd(key, members);
}
public Set<byte[]> smembers(byte[] key) {
Jedis j = getShard(key);
return j.smembers(key);
Jedis j = getShard(key);
return j.smembers(key);
}
public Long srem(byte[] key, byte[] member) {
Jedis j = getShard(key);
return j.srem(key, member);
public Long srem(byte[] key, byte[]... members) {
Jedis j = getShard(key);
return j.srem(key, members);
}
public byte[] spop(byte[] key) {
Jedis j = getShard(key);
return j.spop(key);
Jedis j = getShard(key);
return j.spop(key);
}
public Long scard(byte[] key) {
Jedis j = getShard(key);
return j.scard(key);
Jedis j = getShard(key);
return j.scard(key);
}
public Boolean sismember(byte[] key, byte[] member) {
Jedis j = getShard(key);
return j.sismember(key, member);
Jedis j = getShard(key);
return j.sismember(key, member);
}
public byte[] srandmember(byte[] key) {
Jedis j = getShard(key);
return j.srandmember(key);
Jedis j = getShard(key);
return j.srandmember(key);
}
public Long zadd(byte[] key, double score, byte[] member) {
Jedis j = getShard(key);
return j.zadd(key, score, member);
Jedis j = getShard(key);
return j.zadd(key, score, member);
}
public Long zadd(byte[] key, Map<Double, byte[]> scoreMembers) {
Jedis j = getShard(key);
return j.zadd(key, scoreMembers);
}
public Set<byte[]> zrange(byte[] key, int start, int end) {
Jedis j = getShard(key);
return j.zrange(key, start, end);
Jedis j = getShard(key);
return j.zrange(key, start, end);
}
public Long zrem(byte[] key, byte[] member) {
Jedis j = getShard(key);
return j.zrem(key, member);
public Long zrem(byte[] key, byte[]... members) {
Jedis j = getShard(key);
return j.zrem(key, members);
}
public Double zincrby(byte[] key, double score, byte[] member) {
Jedis j = getShard(key);
return j.zincrby(key, score, member);
Jedis j = getShard(key);
return j.zincrby(key, score, member);
}
public Long zrank(byte[] key, byte[] member) {
Jedis j = getShard(key);
return j.zrank(key, member);
Jedis j = getShard(key);
return j.zrank(key, member);
}
public Long zrevrank(byte[] key, byte[] member) {
Jedis j = getShard(key);
return j.zrevrank(key, member);
Jedis j = getShard(key);
return j.zrevrank(key, member);
}
public Set<byte[]> zrevrange(byte[] key, int start, int end) {
Jedis j = getShard(key);
return j.zrevrange(key, start, end);
Jedis j = getShard(key);
return j.zrevrange(key, start, end);
}
public Set<Tuple> zrangeWithScores(byte[] key, int start, int end) {
Jedis j = getShard(key);
return j.zrangeWithScores(key, start, end);
Jedis j = getShard(key);
return j.zrangeWithScores(key, start, end);
}
public Set<Tuple> zrevrangeWithScores(byte[] key, int start, int end) {
Jedis j = getShard(key);
return j.zrevrangeWithScores(key, start, end);
Jedis j = getShard(key);
return j.zrevrangeWithScores(key, start, end);
}
public Long zcard(byte[] key) {
Jedis j = getShard(key);
return j.zcard(key);
Jedis j = getShard(key);
return j.zcard(key);
}
public Double zscore(byte[] key, byte[] member) {
Jedis j = getShard(key);
return j.zscore(key, member);
Jedis j = getShard(key);
return j.zscore(key, member);
}
public List<byte[]> sort(byte[] key) {
Jedis j = getShard(key);
return j.sort(key);
Jedis j = getShard(key);
return j.sort(key);
}
public List<byte[]> sort(byte[] key, SortingParams sortingParameters) {
Jedis j = getShard(key);
return j.sort(key, sortingParameters);
Jedis j = getShard(key);
return j.sort(key, sortingParameters);
}
public Long zcount(byte[] key, double min, double max) {
Jedis j = getShard(key);
return j.zcount(key, min, max);
Jedis j = getShard(key);
return j.zcount(key, min, max);
}
public Set<byte[]> zrangeByScore(byte[] key, double min, double max) {
Jedis j = getShard(key);
return j.zrangeByScore(key, min, max);
Jedis j = getShard(key);
return j.zrangeByScore(key, min, max);
}
public Set<byte[]> zrangeByScore(byte[] key, double min, double max,
int offset, int count) {
Jedis j = getShard(key);
return j.zrangeByScore(key, min, max, offset, count);
int offset, int count) {
Jedis j = getShard(key);
return j.zrangeByScore(key, min, max, offset, count);
}
public Set<Tuple> zrangeByScoreWithScores(byte[] key, double min, double max) {
Jedis j = getShard(key);
return j.zrangeByScoreWithScores(key, min, max);
Jedis j = getShard(key);
return j.zrangeByScoreWithScores(key, min, max);
}
public Set<Tuple> zrangeByScoreWithScores(byte[] key, double min,
double max, int offset, int count) {
Jedis j = getShard(key);
return j.zrangeByScoreWithScores(key, min, max, offset, count);
double max, int offset, int count) {
Jedis j = getShard(key);
return j.zrangeByScoreWithScores(key, min, max, offset, count);
}
public Set<byte[]> zrevrangeByScore(byte[] key, double max, double min) {
Jedis j = getShard(key);
return j.zrevrangeByScore(key, max, min);
Jedis j = getShard(key);
return j.zrevrangeByScore(key, max, min);
}
public Set<byte[]> zrevrangeByScore(byte[] key, double max, double min,
int offset, int count) {
Jedis j = getShard(key);
return j.zrevrangeByScore(key, max, min, offset, count);
}
public Set<Tuple> zrevrangeByScoreWithScores(byte[] key, double max, double min) {
Jedis j = getShard(key);
return j.zrevrangeByScoreWithScores(key, max, min);
int offset, int count) {
Jedis j = getShard(key);
return j.zrevrangeByScore(key, max, min, offset, count);
}
public Set<Tuple> zrevrangeByScoreWithScores(byte[] key, double max,
double min, int offset, int count) {
Jedis j = getShard(key);
return j.zrevrangeByScoreWithScores(key, max, min, offset, count);
double min) {
Jedis j = getShard(key);
return j.zrevrangeByScoreWithScores(key, max, min);
}
public Set<Tuple> zrevrangeByScoreWithScores(byte[] key, double max,
double min, int offset, int count) {
Jedis j = getShard(key);
return j.zrevrangeByScoreWithScores(key, max, min, offset, count);
}
public Long zremrangeByRank(byte[] key, int start, int end) {
Jedis j = getShard(key);
return j.zremrangeByRank(key, start, end);
Jedis j = getShard(key);
return j.zremrangeByRank(key, start, end);
}
public Long zremrangeByScore(byte[] key, double start, double end) {
Jedis j = getShard(key);
return j.zremrangeByScore(key, start, end);
Jedis j = getShard(key);
return j.zremrangeByScore(key, start, end);
}
public Long linsert(byte[] key, LIST_POSITION where, byte[] pivot,
byte[] value) {
Jedis j = getShard(key);
return j.linsert(key, where, pivot, value);
byte[] value) {
Jedis j = getShard(key);
return j.linsert(key, where, pivot, value);
}
@Deprecated
public List<Object> pipelined(ShardedJedisPipeline shardedJedisPipeline) {
shardedJedisPipeline.setShardedJedis(this);
shardedJedisPipeline.execute();
return shardedJedisPipeline.getResults();
shardedJedisPipeline.setShardedJedis(this);
shardedJedisPipeline.execute();
return shardedJedisPipeline.getResults();
}
public ShardedJedisPipeline pipelined() {
ShardedJedisPipeline pipeline = new ShardedJedisPipeline();
pipeline.setShardedJedis(this);
return pipeline;
ShardedJedisPipeline pipeline = new ShardedJedisPipeline();
pipeline.setShardedJedis(this);
return pipeline;
}
}

565
src/main/java/redis/clients/jedis/Client.java
View File

@@ -1,640 +1,639 @@
package redis.clients.jedis;
import redis.clients.jedis.Protocol.Keyword;
import redis.clients.util.SafeEncoder;
import static redis.clients.jedis.Protocol.toByteArray;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import static redis.clients.jedis.Protocol.toByteArray;
import static redis.clients.jedis.Protocol.Command.SCRIPT;
import redis.clients.util.SafeEncoder;
public class Client extends BinaryClient implements Commands {
public Client(final String host) {
super(host);
super(host);
}
public Client(final String host, final int port) {
super(host, port);
super(host, port);
}
public void set(final String key, final String value) {
set(SafeEncoder.encode(key), SafeEncoder.encode(value));
set(SafeEncoder.encode(key), SafeEncoder.encode(value));
}
public void get(final String key) {
get(SafeEncoder.encode(key));
get(SafeEncoder.encode(key));
}
public void exists(final String key) {
exists(SafeEncoder.encode(key));
exists(SafeEncoder.encode(key));
}
public void del(final String... keys) {
final byte[][] bkeys = new byte[keys.length][];
for (int i = 0; i < keys.length; i++) {
bkeys[i] = SafeEncoder.encode(keys[i]);
}
del(bkeys);
final byte[][] bkeys = new byte[keys.length][];
for (int i = 0; i < keys.length; i++) {
bkeys[i] = SafeEncoder.encode(keys[i]);
}
del(bkeys);
}
public void type(final String key) {
type(SafeEncoder.encode(key));
type(SafeEncoder.encode(key));
}
public void keys(final String pattern) {
keys(SafeEncoder.encode(pattern));
keys(SafeEncoder.encode(pattern));
}
public void rename(final String oldkey, final String newkey) {
rename(SafeEncoder.encode(oldkey), SafeEncoder.encode(newkey));
rename(SafeEncoder.encode(oldkey), SafeEncoder.encode(newkey));
}
public void renamenx(final String oldkey, final String newkey) {
renamenx(SafeEncoder.encode(oldkey), SafeEncoder.encode(newkey));
renamenx(SafeEncoder.encode(oldkey), SafeEncoder.encode(newkey));
}
public void expire(final String key, final int seconds) {
expire(SafeEncoder.encode(key), seconds);
expire(SafeEncoder.encode(key), seconds);
}
public void expireAt(final String key, final long unixTime) {
expireAt(SafeEncoder.encode(key), unixTime);
expireAt(SafeEncoder.encode(key), unixTime);
}
public void ttl(final String key) {
ttl(SafeEncoder.encode(key));
ttl(SafeEncoder.encode(key));
}
public void move(final String key, final int dbIndex) {
move(SafeEncoder.encode(key), dbIndex);
move(SafeEncoder.encode(key), dbIndex);
}
public void getSet(final String key, final String value) {
getSet(SafeEncoder.encode(key), SafeEncoder.encode(value));
getSet(SafeEncoder.encode(key), SafeEncoder.encode(value));
}
public void mget(final String... keys) {
final byte[][] bkeys = new byte[keys.length][];
for (int i = 0; i < bkeys.length; i++) {
bkeys[i] = SafeEncoder.encode(keys[i]);
}
mget(bkeys);
final byte[][] bkeys = new byte[keys.length][];
for (int i = 0; i < bkeys.length; i++) {
bkeys[i] = SafeEncoder.encode(keys[i]);
}
mget(bkeys);
}
public void setnx(final String key, final String value) {
setnx(SafeEncoder.encode(key), SafeEncoder.encode(value));
setnx(SafeEncoder.encode(key), SafeEncoder.encode(value));
}
public void setex(final String key, final int seconds, final String value) {
setex(SafeEncoder.encode(key), seconds, SafeEncoder.encode(value));
setex(SafeEncoder.encode(key), seconds, SafeEncoder.encode(value));
}
public void mset(final String... keysvalues) {
final byte[][] bkeysvalues = new byte[keysvalues.length][];
for (int i = 0; i < keysvalues.length; i++) {
bkeysvalues[i] = SafeEncoder.encode(keysvalues[i]);
}
mset(bkeysvalues);
final byte[][] bkeysvalues = new byte[keysvalues.length][];
for (int i = 0; i < keysvalues.length; i++) {
bkeysvalues[i] = SafeEncoder.encode(keysvalues[i]);
}
mset(bkeysvalues);
}
public void msetnx(final String... keysvalues) {
final byte[][] bkeysvalues = new byte[keysvalues.length][];
for (int i = 0; i < keysvalues.length; i++) {
bkeysvalues[i] = SafeEncoder.encode(keysvalues[i]);
}
msetnx(bkeysvalues);
final byte[][] bkeysvalues = new byte[keysvalues.length][];
for (int i = 0; i < keysvalues.length; i++) {
bkeysvalues[i] = SafeEncoder.encode(keysvalues[i]);
}
msetnx(bkeysvalues);
}
public void decrBy(final String key, final long integer) {
decrBy(SafeEncoder.encode(key), integer);
decrBy(SafeEncoder.encode(key), integer);
}
public void decr(final String key) {
decr(SafeEncoder.encode(key));
decr(SafeEncoder.encode(key));
}
public void incrBy(final String key, final long integer) {
incrBy(SafeEncoder.encode(key), integer);
incrBy(SafeEncoder.encode(key), integer);
}
public void incr(final String key) {
incr(SafeEncoder.encode(key));
incr(SafeEncoder.encode(key));
}
public void append(final String key, final String value) {
append(SafeEncoder.encode(key), SafeEncoder.encode(value));
append(SafeEncoder.encode(key), SafeEncoder.encode(value));
}
public void substr(final String key, final int start, final int end) {
substr(SafeEncoder.encode(key), start, end);
substr(SafeEncoder.encode(key), start, end);
}
public void hset(final String key, final String field, final String value) {
hset(SafeEncoder.encode(key), SafeEncoder.encode(field), SafeEncoder
.encode(value));
hset(SafeEncoder.encode(key), SafeEncoder.encode(field),
SafeEncoder.encode(value));
}
public void hget(final String key, final String field) {
hget(SafeEncoder.encode(key), SafeEncoder.encode(field));
hget(SafeEncoder.encode(key), SafeEncoder.encode(field));
}
public void hsetnx(final String key, final String field, final String value) {
hsetnx(SafeEncoder.encode(key), SafeEncoder.encode(field), SafeEncoder
.encode(value));
hsetnx(SafeEncoder.encode(key), SafeEncoder.encode(field),
SafeEncoder.encode(value));
}
public void hmset(final String key, final Map<String, String> hash) {
final Map<byte[], byte[]> bhash = new HashMap<byte[], byte[]>(hash
.size());
for (final Entry<String, String> entry : hash.entrySet()) {
bhash.put(SafeEncoder.encode(entry.getKey()), SafeEncoder
.encode(entry.getValue()));
}
hmset(SafeEncoder.encode(key), bhash);
final Map<byte[], byte[]> bhash = new HashMap<byte[], byte[]>(
hash.size());
for (final Entry<String, String> entry : hash.entrySet()) {
bhash.put(SafeEncoder.encode(entry.getKey()),
SafeEncoder.encode(entry.getValue()));
}
hmset(SafeEncoder.encode(key), bhash);
}
public void hmget(final String key, final String... fields) {
final byte[][] bfields = new byte[fields.length][];
for (int i = 0; i < bfields.length; i++) {
bfields[i] = SafeEncoder.encode(fields[i]);
}
hmget(SafeEncoder.encode(key), bfields);
final byte[][] bfields = new byte[fields.length][];
for (int i = 0; i < bfields.length; i++) {
bfields[i] = SafeEncoder.encode(fields[i]);
}
hmget(SafeEncoder.encode(key), bfields);
}
public void hincrBy(final String key, final String field, final long value) {
hincrBy(SafeEncoder.encode(key), SafeEncoder.encode(field), value);
hincrBy(SafeEncoder.encode(key), SafeEncoder.encode(field), value);
}
public void hexists(final String key, final String field) {
hexists(SafeEncoder.encode(key), SafeEncoder.encode(field));
hexists(SafeEncoder.encode(key), SafeEncoder.encode(field));
}
public void hdel(final String key, final String field) {
hdel(SafeEncoder.encode(key), SafeEncoder.encode(field));
public void hdel(final String key, final String... fields) {
hdel(SafeEncoder.encode(key), SafeEncoder.encodeMany(fields));
}
public void hlen(final String key) {
hlen(SafeEncoder.encode(key));
hlen(SafeEncoder.encode(key));
}
public void hkeys(final String key) {
hkeys(SafeEncoder.encode(key));
hkeys(SafeEncoder.encode(key));
}
public void hvals(final String key) {
hvals(SafeEncoder.encode(key));
hvals(SafeEncoder.encode(key));
}
public void hgetAll(final String key) {
hgetAll(SafeEncoder.encode(key));
hgetAll(SafeEncoder.encode(key));
}
public void rpush(final String key, final String... vals) {
final byte[][] bvals = new byte[vals.length][];
for (int i = 0; i < bvals.length; i++) {
bvals[i] = SafeEncoder.encode(vals[i]);
}
rpush(SafeEncoder.encode(key), bvals);
public void rpush(final String key, final String... string) {
rpush(SafeEncoder.encode(key), SafeEncoder.encodeMany(string));
}
public void lpush(final String key, final String... vals) {
final byte[][] bvals = new byte[vals.length][];
for (int i = 0; i < bvals.length; i++) {
bvals[i] = SafeEncoder.encode(vals[i]);
}
lpush(SafeEncoder.encode(key), bvals);
public void lpush(final String key, final String... string) {
lpush(SafeEncoder.encode(key), SafeEncoder.encodeMany(string));
}
public void llen(final String key) {
llen(SafeEncoder.encode(key));
llen(SafeEncoder.encode(key));
}
public void lrange(final String key, final long start, final long end) {
lrange(SafeEncoder.encode(key), start, end);
lrange(SafeEncoder.encode(key), start, end);
}
public void ltrim(final String key, final long start, final long end) {
ltrim(SafeEncoder.encode(key), start, end);
ltrim(SafeEncoder.encode(key), start, end);
}
public void lindex(final String key, final long index) {
lindex(SafeEncoder.encode(key), index);
lindex(SafeEncoder.encode(key), index);
}
public void lset(final String key, final long index, final String value) {
lset(SafeEncoder.encode(key), index, SafeEncoder.encode(value));
lset(SafeEncoder.encode(key), index, SafeEncoder.encode(value));
}
public void lrem(final String key, long count, final String value) {
lrem(SafeEncoder.encode(key), count, SafeEncoder.encode(value));
lrem(SafeEncoder.encode(key), count, SafeEncoder.encode(value));
}
public void lpop(final String key) {
lpop(SafeEncoder.encode(key));
lpop(SafeEncoder.encode(key));
}
public void rpop(final String key) {
rpop(SafeEncoder.encode(key));
rpop(SafeEncoder.encode(key));
}
public void rpoplpush(final String srckey, final String dstkey) {
rpoplpush(SafeEncoder.encode(srckey), SafeEncoder.encode(dstkey));
rpoplpush(SafeEncoder.encode(srckey), SafeEncoder.encode(dstkey));
}
public void sadd(final String key, final String member) {
sadd(SafeEncoder.encode(key), SafeEncoder.encode(member));
public void sadd(final String key, final String... members) {
sadd(SafeEncoder.encode(key), SafeEncoder.encodeMany(members));
}
public void smembers(final String key) {
smembers(SafeEncoder.encode(key));
smembers(SafeEncoder.encode(key));
}
public void srem(final String key, final String member) {
srem(SafeEncoder.encode(key), SafeEncoder.encode(member));
public void srem(final String key, final String... members) {
srem(SafeEncoder.encode(key), SafeEncoder.encodeMany(members));
}
public void spop(final String key) {
spop(SafeEncoder.encode(key));
spop(SafeEncoder.encode(key));
}
public void smove(final String srckey, final String dstkey,
final String member) {
smove(SafeEncoder.encode(srckey), SafeEncoder.encode(dstkey),
SafeEncoder.encode(member));
final String member) {
smove(SafeEncoder.encode(srckey), SafeEncoder.encode(dstkey),
SafeEncoder.encode(member));
}
public void scard(final String key) {
scard(SafeEncoder.encode(key));
scard(SafeEncoder.encode(key));
}
public void sismember(final String key, final String member) {
sismember(SafeEncoder.encode(key), SafeEncoder.encode(member));
sismember(SafeEncoder.encode(key), SafeEncoder.encode(member));
}
public void sinter(final String... keys) {
final byte[][] bkeys = new byte[keys.length][];
for (int i = 0; i < bkeys.length; i++) {
bkeys[i] = SafeEncoder.encode(keys[i]);
}
sinter(bkeys);
final byte[][] bkeys = new byte[keys.length][];
for (int i = 0; i < bkeys.length; i++) {
bkeys[i] = SafeEncoder.encode(keys[i]);
}
sinter(bkeys);
}
public void sinterstore(final String dstkey, final String... keys) {
final byte[][] bkeys = new byte[keys.length][];
for (int i = 0; i < bkeys.length; i++) {
bkeys[i] = SafeEncoder.encode(keys[i]);
}
sinterstore(SafeEncoder.encode(dstkey), bkeys);
final byte[][] bkeys = new byte[keys.length][];
for (int i = 0; i < bkeys.length; i++) {
bkeys[i] = SafeEncoder.encode(keys[i]);
}
sinterstore(SafeEncoder.encode(dstkey), bkeys);
}
public void sunion(final String... keys) {
final byte[][] bkeys = new byte[keys.length][];
for (int i = 0; i < bkeys.length; i++) {
bkeys[i] = SafeEncoder.encode(keys[i]);
}
sunion(bkeys);
final byte[][] bkeys = new byte[keys.length][];
for (int i = 0; i < bkeys.length; i++) {
bkeys[i] = SafeEncoder.encode(keys[i]);
}
sunion(bkeys);
}
public void sunionstore(final String dstkey, final String... keys) {
final byte[][] bkeys = new byte[keys.length][];
for (int i = 0; i < bkeys.length; i++) {
bkeys[i] = SafeEncoder.encode(keys[i]);
}
sunionstore(SafeEncoder.encode(dstkey), bkeys);
final byte[][] bkeys = new byte[keys.length][];
for (int i = 0; i < bkeys.length; i++) {
bkeys[i] = SafeEncoder.encode(keys[i]);
}
sunionstore(SafeEncoder.encode(dstkey), bkeys);
}
public void sdiff(final String... keys) {
final byte[][] bkeys = new byte[keys.length][];
for (int i = 0; i < bkeys.length; i++) {
bkeys[i] = SafeEncoder.encode(keys[i]);
}
sdiff(bkeys);
final byte[][] bkeys = new byte[keys.length][];
for (int i = 0; i < bkeys.length; i++) {
bkeys[i] = SafeEncoder.encode(keys[i]);
}
sdiff(bkeys);
}
public void sdiffstore(final String dstkey, final String... keys) {
final byte[][] bkeys = new byte[keys.length][];
for (int i = 0; i < bkeys.length; i++) {
bkeys[i] = SafeEncoder.encode(keys[i]);
}
sdiffstore(SafeEncoder.encode(dstkey), bkeys);
final byte[][] bkeys = new byte[keys.length][];
for (int i = 0; i < bkeys.length; i++) {
bkeys[i] = SafeEncoder.encode(keys[i]);
}
sdiffstore(SafeEncoder.encode(dstkey), bkeys);
}
public void srandmember(final String key) {
srandmember(SafeEncoder.encode(key));
srandmember(SafeEncoder.encode(key));
}
public void zadd(final String key, final double score, final String member) {
zadd(SafeEncoder.encode(key), score, SafeEncoder.encode(member));
zadd(SafeEncoder.encode(key), score, SafeEncoder.encode(member));
}
public void zrange(final String key, final int start, final int end) {
zrange(SafeEncoder.encode(key), start, end);
zrange(SafeEncoder.encode(key), start, end);
}
public void zrem(final String key, final String member) {
zrem(SafeEncoder.encode(key), SafeEncoder.encode(member));
public void zrem(final String key, final String... members) {
zrem(SafeEncoder.encode(key), SafeEncoder.encodeMany(members));
}
public void zincrby(final String key, final double score,
final String member) {
zincrby(SafeEncoder.encode(key), score, SafeEncoder.encode(member));
final String member) {
zincrby(SafeEncoder.encode(key), score, SafeEncoder.encode(member));
}
public void zrank(final String key, final String member) {
zrank(SafeEncoder.encode(key), SafeEncoder.encode(member));
zrank(SafeEncoder.encode(key), SafeEncoder.encode(member));
}
public void zrevrank(final String key, final String member) {
zrevrank(SafeEncoder.encode(key), SafeEncoder.encode(member));
zrevrank(SafeEncoder.encode(key), SafeEncoder.encode(member));
}
public void zrevrange(final String key, final int start, final int end) {
zrevrange(SafeEncoder.encode(key), start, end);
zrevrange(SafeEncoder.encode(key), start, end);
}
public void zrangeWithScores(final String key, final int start,
final int end) {
zrangeWithScores(SafeEncoder.encode(key), start, end);
final int end) {
zrangeWithScores(SafeEncoder.encode(key), start, end);
}
public void zrevrangeWithScores(final String key, final int start,
final int end) {
zrevrangeWithScores(SafeEncoder.encode(key), start, end);
final int end) {
zrevrangeWithScores(SafeEncoder.encode(key), start, end);
}
public void zcard(final String key) {
zcard(SafeEncoder.encode(key));
zcard(SafeEncoder.encode(key));
}
public void zscore(final String key, final String member) {
zscore(SafeEncoder.encode(key), SafeEncoder.encode(member));
zscore(SafeEncoder.encode(key), SafeEncoder.encode(member));
}
public void watch(final String... keys) {
final byte[][] bargs = new byte[keys.length][];
for (int i = 0; i < bargs.length; i++) {
bargs[i] = SafeEncoder.encode(keys[i]);
}
watch(bargs);
final byte[][] bargs = new byte[keys.length][];
for (int i = 0; i < bargs.length; i++) {
bargs[i] = SafeEncoder.encode(keys[i]);
}
watch(bargs);
}
public void sort(final String key) {
sort(SafeEncoder.encode(key));
sort(SafeEncoder.encode(key));
}
public void sort(final String key, final SortingParams sortingParameters) {
sort(SafeEncoder.encode(key), sortingParameters);
sort(SafeEncoder.encode(key), sortingParameters);
}
public void blpop(final String[] args) {
final byte[][] bargs = new byte[args.length][];
for (int i = 0; i < bargs.length; i++) {
bargs[i] = SafeEncoder.encode(args[i]);
}
blpop(bargs);
final byte[][] bargs = new byte[args.length][];
for (int i = 0; i < bargs.length; i++) {
bargs[i] = SafeEncoder.encode(args[i]);
}
blpop(bargs);
}
public void sort(final String key, final SortingParams sortingParameters,
final String dstkey) {
sort(SafeEncoder.encode(key), sortingParameters, SafeEncoder
.encode(dstkey));
final String dstkey) {
sort(SafeEncoder.encode(key), sortingParameters,
SafeEncoder.encode(dstkey));
}
public void sort(final String key, final String dstkey) {
sort(SafeEncoder.encode(key), SafeEncoder.encode(dstkey));
sort(SafeEncoder.encode(key), SafeEncoder.encode(dstkey));
}
public void brpop(final String[] args) {
final byte[][] bargs = new byte[args.length][];
for (int i = 0; i < bargs.length; i++) {
bargs[i] = SafeEncoder.encode(args[i]);
}
brpop(bargs);
final byte[][] bargs = new byte[args.length][];
for (int i = 0; i < bargs.length; i++) {
bargs[i] = SafeEncoder.encode(args[i]);
}
brpop(bargs);
}
public void zcount(final String key, final double min, final double max) {
zcount(SafeEncoder.encode(key), min, max);
zcount(SafeEncoder.encode(key), min, max);
}
public void zrangeByScore(final String key, final double min,
final double max) {
zrangeByScore(SafeEncoder.encode(key), min, max);
final double max) {
zrangeByScore(SafeEncoder.encode(key), min, max);
}
public void zrangeByScore(final String key, final String min,
final String max) {
zrangeByScore(SafeEncoder.encode(key), SafeEncoder.encode(min),
SafeEncoder.encode(max));
final String max) {
zrangeByScore(SafeEncoder.encode(key), SafeEncoder.encode(min),
SafeEncoder.encode(max));
}
public void zrangeByScore(final String key, final double min,
final double max, final int offset, int count) {
zrangeByScore(SafeEncoder.encode(key), min, max, offset, count);
final double max, final int offset, int count) {
zrangeByScore(SafeEncoder.encode(key), min, max, offset, count);
}
public void zrangeByScoreWithScores(final String key, final double min,
final double max) {
zrangeByScoreWithScores(SafeEncoder.encode(key), min, max);
final double max) {
zrangeByScoreWithScores(SafeEncoder.encode(key), min, max);
}
public void zrangeByScoreWithScores(final String key, final double min,
final double max, final int offset, final int count) {
zrangeByScoreWithScores(SafeEncoder.encode(key), min, max, offset,
count);
final double max, final int offset, final int count) {
zrangeByScoreWithScores(SafeEncoder.encode(key), min, max, offset,
count);
}
public void zrevrangeByScore(final String key, final double max,
final double min) {
zrevrangeByScore(SafeEncoder.encode(key), max, min);
final double min) {
zrevrangeByScore(SafeEncoder.encode(key), max, min);
}
public void zrevrangeByScore(final String key, final String max,
final String min) {
zrevrangeByScore(SafeEncoder.encode(key), SafeEncoder.encode(max),
SafeEncoder.encode(min));
final String min) {
zrevrangeByScore(SafeEncoder.encode(key), SafeEncoder.encode(max),
SafeEncoder.encode(min));
}
public void zrevrangeByScore(final String key, final double max,
final double min, final int offset, int count) {
zrevrangeByScore(SafeEncoder.encode(key), max, min, offset, count);
final double min, final int offset, int count) {
zrevrangeByScore(SafeEncoder.encode(key), max, min, offset, count);
}
public void zrevrangeByScoreWithScores(final String key, final double max,
final double min) {
zrevrangeByScoreWithScores(SafeEncoder.encode(key), max, min);
final double min) {
zrevrangeByScoreWithScores(SafeEncoder.encode(key), max, min);
}
public void zrevrangeByScoreWithScores(final String key, final double max,
final double min, final int offset, final int count) {
zrevrangeByScoreWithScores(SafeEncoder.encode(key), max, min, offset,
count);
final double min, final int offset, final int count) {
zrevrangeByScoreWithScores(SafeEncoder.encode(key), max, min, offset,
count);
}
public void zremrangeByRank(final String key, final int start, final int end) {
zremrangeByRank(SafeEncoder.encode(key), start, end);
zremrangeByRank(SafeEncoder.encode(key), start, end);
}
public void zremrangeByScore(final String key, final double start,
final double end) {
zremrangeByScore(SafeEncoder.encode(key), start, end);
final double end) {
zremrangeByScore(SafeEncoder.encode(key), start, end);
}
public void zunionstore(final String dstkey, final String... sets) {
final byte[][] bsets = new byte[sets.length][];
for (int i = 0; i < bsets.length; i++) {
bsets[i] = SafeEncoder.encode(sets[i]);
}
zunionstore(SafeEncoder.encode(dstkey), bsets);
final byte[][] bsets = new byte[sets.length][];
for (int i = 0; i < bsets.length; i++) {
bsets[i] = SafeEncoder.encode(sets[i]);
}
zunionstore(SafeEncoder.encode(dstkey), bsets);
}
public void zunionstore(final String dstkey, final ZParams params,
final String... sets) {
final byte[][] bsets = new byte[sets.length][];
for (int i = 0; i < bsets.length; i++) {
bsets[i] = SafeEncoder.encode(sets[i]);
}
zunionstore(SafeEncoder.encode(dstkey), params, bsets);
final String... sets) {
final byte[][] bsets = new byte[sets.length][];
for (int i = 0; i < bsets.length; i++) {
bsets[i] = SafeEncoder.encode(sets[i]);
}
zunionstore(SafeEncoder.encode(dstkey), params, bsets);
}
public void zinterstore(final String dstkey, final String... sets) {
final byte[][] bsets = new byte[sets.length][];
for (int i = 0; i < bsets.length; i++) {
bsets[i] = SafeEncoder.encode(sets[i]);
}
zinterstore(SafeEncoder.encode(dstkey), bsets);
final byte[][] bsets = new byte[sets.length][];
for (int i = 0; i < bsets.length; i++) {
bsets[i] = SafeEncoder.encode(sets[i]);
}
zinterstore(SafeEncoder.encode(dstkey), bsets);
}
public void zinterstore(final String dstkey, final ZParams params,
final String... sets) {
final byte[][] bsets = new byte[sets.length][];
for (int i = 0; i < bsets.length; i++) {
bsets[i] = SafeEncoder.encode(sets[i]);
}
zinterstore(SafeEncoder.encode(dstkey), params, bsets);
final String... sets) {
final byte[][] bsets = new byte[sets.length][];
for (int i = 0; i < bsets.length; i++) {
bsets[i] = SafeEncoder.encode(sets[i]);
}
zinterstore(SafeEncoder.encode(dstkey), params, bsets);
}
public void strlen(final String key) {
strlen(SafeEncoder.encode(key));
strlen(SafeEncoder.encode(key));
}
public void lpushx(final String key, final String string) {
lpushx(SafeEncoder.encode(key), SafeEncoder.encode(string));
lpushx(SafeEncoder.encode(key), SafeEncoder.encode(string));
}
public void persist(final String key) {
persist(SafeEncoder.encode(key));
persist(SafeEncoder.encode(key));
}
public void rpushx(final String key, final String string) {
rpushx(SafeEncoder.encode(key), SafeEncoder.encode(string));
rpushx(SafeEncoder.encode(key), SafeEncoder.encode(string));
}
public void echo(final String string) {
echo(SafeEncoder.encode(string));
echo(SafeEncoder.encode(string));
}
public void linsert(final String key, final LIST_POSITION where,
final String pivot, final String value) {
linsert(SafeEncoder.encode(key), where, SafeEncoder.encode(pivot),
SafeEncoder.encode(value));
final String pivot, final String value) {
linsert(SafeEncoder.encode(key), where, SafeEncoder.encode(pivot),
SafeEncoder.encode(value));
}
public void brpoplpush(String source, String destination, int timeout) {
brpoplpush(SafeEncoder.encode(source), SafeEncoder.encode(destination),
timeout);
brpoplpush(SafeEncoder.encode(source), SafeEncoder.encode(destination),
timeout);
}
public void setbit(final String key, final long offset, final boolean value) {
setbit(SafeEncoder.encode(key), offset, toByteArray(value ? 1 : 0));
setbit(SafeEncoder.encode(key), offset, toByteArray(value ? 1 : 0));
}
public void getbit(String key, long offset) {
getbit(SafeEncoder.encode(key), offset);
getbit(SafeEncoder.encode(key), offset);
}
public void setrange(String key, long offset, String value) {
setrange(SafeEncoder.encode(key), offset, SafeEncoder.encode(value));
setrange(SafeEncoder.encode(key), offset, SafeEncoder.encode(value));
}
public void getrange(String key, long startOffset, long endOffset) {
getrange(SafeEncoder.encode(key), startOffset, endOffset);
getrange(SafeEncoder.encode(key), startOffset, endOffset);
}
public void publish(final String channel, final String message) {
publish(SafeEncoder.encode(channel), SafeEncoder.encode(message));
publish(SafeEncoder.encode(channel), SafeEncoder.encode(message));
}
public void unsubscribe(final String... channels) {
final byte[][] cs = new byte[channels.length][];
for (int i = 0; i < cs.length; i++) {
cs[i] = SafeEncoder.encode(channels[i]);
}
unsubscribe(cs);
final byte[][] cs = new byte[channels.length][];
for (int i = 0; i < cs.length; i++) {
cs[i] = SafeEncoder.encode(channels[i]);
}
unsubscribe(cs);
}
public void psubscribe(final String... patterns) {
final byte[][] ps = new byte[patterns.length][];
for (int i = 0; i < ps.length; i++) {
ps[i] = SafeEncoder.encode(patterns[i]);
}
psubscribe(ps);
final byte[][] ps = new byte[patterns.length][];
for (int i = 0; i < ps.length; i++) {
ps[i] = SafeEncoder.encode(patterns[i]);
}
psubscribe(ps);
}
public void punsubscribe(final String... patterns) {
final byte[][] ps = new byte[patterns.length][];
for (int i = 0; i < ps.length; i++) {
ps[i] = SafeEncoder.encode(patterns[i]);
}
punsubscribe(ps);
final byte[][] ps = new byte[patterns.length][];
for (int i = 0; i < ps.length; i++) {
ps[i] = SafeEncoder.encode(patterns[i]);
}
punsubscribe(ps);
}
public void subscribe(final String... channels) {
final byte[][] cs = new byte[channels.length][];
for (int i = 0; i < cs.length; i++) {
cs[i] = SafeEncoder.encode(channels[i]);
}
subscribe(cs);
final byte[][] cs = new byte[channels.length][];
for (int i = 0; i < cs.length; i++) {
cs[i] = SafeEncoder.encode(channels[i]);
}
subscribe(cs);
}
public void configSet(String parameter, String value) {
configSet(SafeEncoder.encode(parameter), SafeEncoder.encode(value));
configSet(SafeEncoder.encode(parameter), SafeEncoder.encode(value));
}
public void configGet(String pattern) {
configGet(SafeEncoder.encode(pattern));
configGet(SafeEncoder.encode(pattern));
}
private byte[][] getByteParams(String... params){
byte[][] p = new byte[params.length][];
for(int i=0;i<params.length;i++)
p[i] = SafeEncoder.encode(params[i]);
return p;
private byte[][] getByteParams(String... params) {
byte[][] p = new byte[params.length][];
for (int i = 0; i < params.length; i++)
p[i] = SafeEncoder.encode(params[i]);
return p;
}
public void eval(String script, int keyCount, String... params) {
eval(SafeEncoder.encode(script),toByteArray(keyCount), getByteParams(params));
eval(SafeEncoder.encode(script), toByteArray(keyCount),
getByteParams(params));
}
public void evalsha(String sha1, int keyCount, String... params) {
evalsha(SafeEncoder.encode(sha1), toByteArray(keyCount),
getByteParams(params));
}
public void scriptExists(String... sha1) {
final byte[][] bsha1 = new byte[sha1.length][];
for (int i = 0; i < bsha1.length; i++) {
bsha1[i] = SafeEncoder.encode(sha1[i]);
}
scriptExists(bsha1);
}
public void scriptLoad(String script) {
scriptLoad(SafeEncoder.encode(script));
}
public void zadd(String key, Map<Double, String> scoreMembers) {
HashMap<Double, byte[]> binaryScoreMembers = new HashMap<Double, byte[]>();
for (Map.Entry<Double, String> entry : scoreMembers.entrySet()) {
binaryScoreMembers.put(entry.getKey(),
SafeEncoder.encode(entry.getValue()));
}
public void evalsha(String sha1, int keyCount, String... params) {
evalsha(SafeEncoder.encode(sha1),toByteArray(keyCount), getByteParams(params));
}
public void scriptExists(String... sha1){
final byte[][] bsha1 = new byte[sha1.length][];
for (int i = 0; i < bsha1.length; i++) {
bsha1[i] = SafeEncoder.encode(sha1[i]);
}
scriptExists(bsha1);
}
public void scriptLoad(String script){
scriptLoad(SafeEncoder.encode(script));
zaddBinary(SafeEncoder.encode(key), binaryScoreMembers);
}
}

54
src/main/java/redis/clients/jedis/Commands.java
View File

@@ -76,7 +76,7 @@ public interface Commands {
public void hexists(final String key, final String field);
public void hdel(final String key, final String field);
public void hdel(final String key, final String... fields);
public void hlen(final String key);
@@ -86,9 +86,9 @@ public interface Commands {
public void hgetAll(final String key);
public void rpush(final String key, final String... string);
public void rpush(final String key, final String... strings);
public void lpush(final String key, final String... string);
public void lpush(final String key, final String... strings);
public void llen(final String key);
@@ -108,16 +108,16 @@ public interface Commands {
public void rpoplpush(final String srckey, final String dstkey);
public void sadd(final String key, final String member);
public void sadd(final String key, final String... members);
public void smembers(final String key);
public void srem(final String key, final String member);
public void srem(final String key, final String... member);
public void spop(final String key);
public void smove(final String srckey, final String dstkey,
final String member);
final String member);
public void scard(final String key);
@@ -139,12 +139,14 @@ public interface Commands {
public void zadd(final String key, final double score, final String member);
public void zadd(final String key, final Map<Double, String> scoreMembers);
public void zrange(final String key, final int start, final int end);
public void zrem(final String key, final String member);
public void zrem(final String key, final String... members);
public void zincrby(final String key, final double score,
final String member);
final String member);
public void zrank(final String key, final String member);
@@ -153,10 +155,10 @@ public interface Commands {
public void zrevrange(final String key, final int start, final int end);
public void zrangeWithScores(final String key, final int start,
final int end);
final int end);
public void zrevrangeWithScores(final String key, final int start,
final int end);
final int end);
public void zcard(final String key);
@@ -171,61 +173,61 @@ public interface Commands {
public void blpop(final String[] args);
public void sort(final String key, final SortingParams sortingParameters,
final String dstkey);
final String dstkey);
public void sort(final String key, final String dstkey);
public void brpop(final String[] args);
public void brpoplpush(final String source, final String destination,
final int timeout);
final int timeout);
public void zcount(final String key, final double min, final double max);
public void zrangeByScore(final String key, final double min,
final double max);
final double max);
public void zrangeByScore(final String key, final String min,
final String max);
final String max);
public void zrangeByScore(final String key, final double min,
final double max, final int offset, int count);
final double max, final int offset, int count);
public void zrangeByScoreWithScores(final String key, final double min,
final double max);
final double max);
public void zrangeByScoreWithScores(final String key, final double min,
final double max, final int offset, final int count);
final double max, final int offset, final int count);
public void zrevrangeByScore(final String key, final double max,
final double min);
final double min);
public void zrevrangeByScore(final String key, final String max,
final String min);
final String min);
public void zrevrangeByScore(final String key, final double max,
final double min, final int offset, int count);
final double min, final int offset, int count);
public void zrevrangeByScoreWithScores(final String key, final double max,
final double min);
final double min);
public void zrevrangeByScoreWithScores(final String key, final double max,
final double min, final int offset, final int count);
final double min, final int offset, final int count);
public void zremrangeByRank(final String key, final int start, final int end);
public void zremrangeByScore(final String key, final double start,
final double end);
final double end);
public void zunionstore(final String dstkey, final String... sets);
public void zunionstore(final String dstkey, final ZParams params,
final String... sets);
final String... sets);
public void zinterstore(final String dstkey, final String... sets);
public void zinterstore(final String dstkey, final ZParams params,
final String... sets);
final String... sets);
public void strlen(final String key);
@@ -238,7 +240,7 @@ public interface Commands {
public void echo(final String string);
public void linsert(final String key, final LIST_POSITION where,
final String pivot, final String value);
final String pivot, final String value);
public void bgrewriteaof();

42
src/main/java/redis/clients/jedis/Jedis.java
View File

@@ -781,13 +781,13 @@ public class Jedis extends BinaryJedis implements JedisCommands {
* <b>Time complexity:</b> O(1)
*
* @param key
* @param field
* @param fields
* @return If the field was present in the hash it is deleted and 1 is
* returned, otherwise 0 is returned and no operation is performed.
*/
public Long hdel(final String key, final String field) {
public Long hdel(final String key, final String... fields) {
checkIsInMulti();
client.hdel(key, field);
client.hdel(key, fields);
return client.getIntegerReply();
}
@@ -863,13 +863,13 @@ public class Jedis extends BinaryJedis implements JedisCommands {
* @see Jedis#lpush(String, String)
*
* @param key
* @param string
* @param strings
* @return Integer reply, specifically, the number of elements inside the
* list after the push operation.
*/
public Long rpush(final String key, final String... string) {
public Long rpush(final String key, final String... strings) {
checkIsInMulti();
client.rpush(key, string);
client.rpush(key, strings);
return client.getIntegerReply();
}
@@ -884,13 +884,13 @@ public class Jedis extends BinaryJedis implements JedisCommands {
* @see Jedis#rpush(String, String)
*
* @param key
* @param string
* @param strings
* @return Integer reply, specifically, the number of elements inside the
* list after the push operation.
*/
public Long lpush(final String key, final String... string) {
public Long lpush(final String key, final String... strings) {
checkIsInMulti();
client.lpush(key, string);
client.lpush(key, strings);
return client.getIntegerReply();
}
@@ -1142,13 +1142,13 @@ public class Jedis extends BinaryJedis implements JedisCommands {
* Time complexity O(1)
*
* @param key
* @param member
* @param members
* @return Integer reply, specifically: 1 if the new element was added 0 if
* the element was already a member of the set
*/
public Long sadd(final String key, final String member) {
public Long sadd(final String key, final String... members) {
checkIsInMulti();
client.sadd(key, member);
client.sadd(key, members);
return client.getIntegerReply();
}
@@ -1176,13 +1176,13 @@ public class Jedis extends BinaryJedis implements JedisCommands {
* Time complexity O(1)
*
* @param key
* @param member
* @param members
* @return Integer reply, specifically: 1 if the new element was removed 0
* if the new element was not a member of the set
*/
public Long srem(final String key, final String member) {
public Long srem(final String key, final String... members) {
checkIsInMulti();
client.srem(key, member);
client.srem(key, members);
return client.getIntegerReply();
}
@@ -1439,6 +1439,12 @@ public class Jedis extends BinaryJedis implements JedisCommands {
return client.getIntegerReply();
}
public Long zadd(final String key, final Map<Double, String> scoreMembers) {
checkIsInMulti();
client.zadd(key, scoreMembers);
return client.getIntegerReply();
}
public Set<String> zrange(final String key, final int start, final int end) {
checkIsInMulti();
client.zrange(key, start, end);
@@ -1457,13 +1463,13 @@ public class Jedis extends BinaryJedis implements JedisCommands {
*
*
* @param key
* @param member
* @param members
* @return Integer reply, specifically: 1 if the new element was removed 0
* if the new element was not a member of the set
*/
public Long zrem(final String key, final String member) {
public Long zrem(final String key, final String... members) {
checkIsInMulti();
client.zrem(key, member);
client.zrem(key, members);
return client.getIntegerReply();
}

10
src/main/java/redis/clients/jedis/JedisCommands.java
View File

@@ -62,7 +62,7 @@ public interface JedisCommands {
Boolean hexists(String key, String field);
Long hdel(String key, String field);
Long hdel(String key, String... field);
Long hlen(String key);
@@ -92,11 +92,11 @@ public interface JedisCommands {
String rpop(String key);
Long sadd(String key, String member);
Long sadd(String key, String... member);
Set<String> smembers(String key);
Long srem(String key, String member);
Long srem(String key, String... member);
String spop(String key);
@@ -107,10 +107,12 @@ public interface JedisCommands {
String srandmember(String key);
Long zadd(String key, double score, String member);
Long zadd(String key, Map<Double, String> scoreMembers);
Set<String> zrange(String key, int start, int end);
Long zrem(String key, String member);
Long zrem(String key, String... member);
Double zincrby(String key, double score, String member);

8
src/main/java/redis/clients/jedis/Pipeline.java
View File

@@ -672,14 +672,14 @@ public class Pipeline extends Queable {
return getResponse(BuilderFactory.LONG);
}
public Response<List<String>> sort(String key) {
public Response<Long> sort(String key) {
client.sort(key);
return getResponse(BuilderFactory.STRING_LIST);
return getResponse(BuilderFactory.LONG);
}
public Response<List<String>> sort(byte[] key) {
public Response<Long> sort(byte[] key) {
client.sort(key);
return getResponse(BuilderFactory.STRING_LIST);
return getResponse(BuilderFactory.LONG);
}
public Response<List<String>> sort(String key,

353
src/main/java/redis/clients/jedis/ShardedJedis.java
View File

@@ -1,416 +1,421 @@
package redis.clients.jedis;
import redis.clients.jedis.BinaryClient.LIST_POSITION;
import redis.clients.util.Hashing;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.regex.Pattern;
import redis.clients.jedis.BinaryClient.LIST_POSITION;
import redis.clients.util.Hashing;
public class ShardedJedis extends BinaryShardedJedis implements JedisCommands {
public ShardedJedis(List<JedisShardInfo> shards) {
super(shards);
super(shards);
}
public ShardedJedis(List<JedisShardInfo> shards, Hashing algo) {
super(shards, algo);
super(shards, algo);
}
public ShardedJedis(List<JedisShardInfo> shards, Pattern keyTagPattern) {
super(shards, keyTagPattern);
super(shards, keyTagPattern);
}
public ShardedJedis(List<JedisShardInfo> shards, Hashing algo,
Pattern keyTagPattern) {
super(shards, algo, keyTagPattern);
Pattern keyTagPattern) {
super(shards, algo, keyTagPattern);
}
public void disconnect() {
for (Jedis jedis : getAllShards()) {
jedis.quit();
jedis.disconnect();
}
for (Jedis jedis : getAllShards()) {
jedis.quit();
jedis.disconnect();
}
}
public String set(String key, String value) {
Jedis j = getShard(key);
return j.set(key, value);
Jedis j = getShard(key);
return j.set(key, value);
}
public String get(String key) {
Jedis j = getShard(key);
return j.get(key);
Jedis j = getShard(key);
return j.get(key);
}
public Boolean exists(String key) {
Jedis j = getShard(key);
return j.exists(key);
Jedis j = getShard(key);
return j.exists(key);
}
public String type(String key) {
Jedis j = getShard(key);
return j.type(key);
Jedis j = getShard(key);
return j.type(key);
}
public Long expire(String key, int seconds) {
Jedis j = getShard(key);
return j.expire(key, seconds);
Jedis j = getShard(key);
return j.expire(key, seconds);
}
public Long expireAt(String key, long unixTime) {
Jedis j = getShard(key);
return j.expireAt(key, unixTime);
Jedis j = getShard(key);
return j.expireAt(key, unixTime);
}
public Long ttl(String key) {
Jedis j = getShard(key);
return j.ttl(key);
Jedis j = getShard(key);
return j.ttl(key);
}
public Boolean setbit(String key, long offset, boolean value) {
Jedis j = getShard(key);
return j.setbit(key, offset, value);
Jedis j = getShard(key);
return j.setbit(key, offset, value);
}
public Boolean getbit(String key, long offset) {
Jedis j = getShard(key);
return j.getbit(key, offset);
Jedis j = getShard(key);
return j.getbit(key, offset);
}
public Long setrange(String key, long offset, String value) {
Jedis j = getShard(key);
return j.setrange(key, offset, value);
Jedis j = getShard(key);
return j.setrange(key, offset, value);
}
public String getrange(String key, long startOffset, long endOffset) {
Jedis j = getShard(key);
return j.getrange(key, startOffset, endOffset);
Jedis j = getShard(key);
return j.getrange(key, startOffset, endOffset);
}
public String getSet(String key, String value) {
Jedis j = getShard(key);
return j.getSet(key, value);
Jedis j = getShard(key);
return j.getSet(key, value);
}
public Long setnx(String key, String value) {
Jedis j = getShard(key);
return j.setnx(key, value);
Jedis j = getShard(key);
return j.setnx(key, value);
}
public String setex(String key, int seconds, String value) {
Jedis j = getShard(key);
return j.setex(key, seconds, value);
Jedis j = getShard(key);
return j.setex(key, seconds, value);
}
public Long decrBy(String key, long integer) {
Jedis j = getShard(key);
return j.decrBy(key, integer);
Jedis j = getShard(key);
return j.decrBy(key, integer);
}
public Long decr(String key) {
Jedis j = getShard(key);
return j.decr(key);
Jedis j = getShard(key);
return j.decr(key);
}
public Long incrBy(String key, long integer) {
Jedis j = getShard(key);
return j.incrBy(key, integer);
Jedis j = getShard(key);
return j.incrBy(key, integer);
}
public Long incr(String key) {
Jedis j = getShard(key);
return j.incr(key);
Jedis j = getShard(key);
return j.incr(key);
}
public Long append(String key, String value) {
Jedis j = getShard(key);
return j.append(key, value);
Jedis j = getShard(key);
return j.append(key, value);
}
public String substr(String key, int start, int end) {
Jedis j = getShard(key);
return j.substr(key, start, end);
Jedis j = getShard(key);
return j.substr(key, start, end);
}
public Long hset(String key, String field, String value) {
Jedis j = getShard(key);
return j.hset(key, field, value);
Jedis j = getShard(key);
return j.hset(key, field, value);
}
public String hget(String key, String field) {
Jedis j = getShard(key);
return j.hget(key, field);
Jedis j = getShard(key);
return j.hget(key, field);
}
public Long hsetnx(String key, String field, String value) {
Jedis j = getShard(key);
return j.hsetnx(key, field, value);
Jedis j = getShard(key);
return j.hsetnx(key, field, value);
}
public String hmset(String key, Map<String, String> hash) {
Jedis j = getShard(key);
return j.hmset(key, hash);
Jedis j = getShard(key);
return j.hmset(key, hash);
}
public List<String> hmget(String key, String... fields) {
Jedis j = getShard(key);
return j.hmget(key, fields);
Jedis j = getShard(key);
return j.hmget(key, fields);
}
public Long hincrBy(String key, String field, long value) {
Jedis j = getShard(key);
return j.hincrBy(key, field, value);
Jedis j = getShard(key);
return j.hincrBy(key, field, value);
}
public Boolean hexists(String key, String field) {
Jedis j = getShard(key);
return j.hexists(key, field);
Jedis j = getShard(key);
return j.hexists(key, field);
}
public Long del(String key) {
Jedis j = getShard(key);
return j.del(key);
Jedis j = getShard(key);
return j.del(key);
}
public Long hdel(String key, String field) {
Jedis j = getShard(key);
return j.hdel(key, field);
public Long hdel(String key, String... fields) {
Jedis j = getShard(key);
return j.hdel(key, fields);
}
public Long hlen(String key) {
Jedis j = getShard(key);
return j.hlen(key);
Jedis j = getShard(key);
return j.hlen(key);
}
public Set<String> hkeys(String key) {
Jedis j = getShard(key);
return j.hkeys(key);
Jedis j = getShard(key);
return j.hkeys(key);
}
public List<String> hvals(String key) {
Jedis j = getShard(key);
return j.hvals(key);
Jedis j = getShard(key);
return j.hvals(key);
}
public Map<String, String> hgetAll(String key) {
Jedis j = getShard(key);
return j.hgetAll(key);
Jedis j = getShard(key);
return j.hgetAll(key);
}
public Long rpush(String key, String... string) {
Jedis j = getShard(key);
return j.rpush(key, string);
public Long rpush(String key, String... strings) {
Jedis j = getShard(key);
return j.rpush(key, strings);
}
public Long lpush(String key, String... string) {
Jedis j = getShard(key);
return j.lpush(key, string);
public Long lpush(String key, String... strings) {
Jedis j = getShard(key);
return j.lpush(key, strings);
}
public Long llen(String key) {
Jedis j = getShard(key);
return j.llen(key);
Jedis j = getShard(key);
return j.llen(key);
}
public List<String> lrange(String key, long start, long end) {
Jedis j = getShard(key);
return j.lrange(key, start, end);
Jedis j = getShard(key);
return j.lrange(key, start, end);
}
public String ltrim(String key, long start, long end) {
Jedis j = getShard(key);
return j.ltrim(key, start, end);
Jedis j = getShard(key);
return j.ltrim(key, start, end);
}
public String lindex(String key, long index) {
Jedis j = getShard(key);
return j.lindex(key, index);
Jedis j = getShard(key);
return j.lindex(key, index);
}
public String lset(String key, long index, String value) {
Jedis j = getShard(key);
return j.lset(key, index, value);
Jedis j = getShard(key);
return j.lset(key, index, value);
}
public Long lrem(String key, long count, String value) {
Jedis j = getShard(key);
return j.lrem(key, count, value);
Jedis j = getShard(key);
return j.lrem(key, count, value);
}
public String lpop(String key) {
Jedis j = getShard(key);
return j.lpop(key);
Jedis j = getShard(key);
return j.lpop(key);
}
public String rpop(String key) {
Jedis j = getShard(key);
return j.rpop(key);
Jedis j = getShard(key);
return j.rpop(key);
}
public Long sadd(String key, String member) {
Jedis j = getShard(key);
return j.sadd(key, member);
public Long sadd(String key, String... members) {
Jedis j = getShard(key);
return j.sadd(key, members);
}
public Set<String> smembers(String key) {
Jedis j = getShard(key);
return j.smembers(key);
Jedis j = getShard(key);
return j.smembers(key);
}
public Long srem(String key, String member) {
Jedis j = getShard(key);
return j.srem(key, member);
public Long srem(String key, String... members) {
Jedis j = getShard(key);
return j.srem(key, members);
}
public String spop(String key) {
Jedis j = getShard(key);
return j.spop(key);
Jedis j = getShard(key);
return j.spop(key);
}
public Long scard(String key) {
Jedis j = getShard(key);
return j.scard(key);
Jedis j = getShard(key);
return j.scard(key);
}
public Boolean sismember(String key, String member) {
Jedis j = getShard(key);
return j.sismember(key, member);
Jedis j = getShard(key);
return j.sismember(key, member);
}
public String srandmember(String key) {
Jedis j = getShard(key);
return j.srandmember(key);
Jedis j = getShard(key);
return j.srandmember(key);
}
public Long zadd(String key, double score, String member) {
Jedis j = getShard(key);
return j.zadd(key, score, member);
Jedis j = getShard(key);
return j.zadd(key, score, member);
}
public Long zadd(String key, Map<Double, String> scoreMembers) {
Jedis j = getShard(key);
return j.zadd(key, scoreMembers);
}
public Set<String> zrange(String key, int start, int end) {
Jedis j = getShard(key);
return j.zrange(key, start, end);
Jedis j = getShard(key);
return j.zrange(key, start, end);
}
public Long zrem(String key, String member) {
Jedis j = getShard(key);
return j.zrem(key, member);
public Long zrem(String key, String... members) {
Jedis j = getShard(key);
return j.zrem(key, members);
}
public Double zincrby(String key, double score, String member) {
Jedis j = getShard(key);
return j.zincrby(key, score, member);
Jedis j = getShard(key);
return j.zincrby(key, score, member);
}
public Long zrank(String key, String member) {
Jedis j = getShard(key);
return j.zrank(key, member);
Jedis j = getShard(key);
return j.zrank(key, member);
}
public Long zrevrank(String key, String member) {
Jedis j = getShard(key);
return j.zrevrank(key, member);
Jedis j = getShard(key);
return j.zrevrank(key, member);
}
public Set<String> zrevrange(String key, int start, int end) {
Jedis j = getShard(key);
return j.zrevrange(key, start, end);
Jedis j = getShard(key);
return j.zrevrange(key, start, end);
}
public Set<Tuple> zrangeWithScores(String key, int start, int end) {
Jedis j = getShard(key);
return j.zrangeWithScores(key, start, end);
Jedis j = getShard(key);
return j.zrangeWithScores(key, start, end);
}
public Set<Tuple> zrevrangeWithScores(String key, int start, int end) {
Jedis j = getShard(key);
return j.zrevrangeWithScores(key, start, end);
Jedis j = getShard(key);
return j.zrevrangeWithScores(key, start, end);
}
public Long zcard(String key) {
Jedis j = getShard(key);
return j.zcard(key);
Jedis j = getShard(key);
return j.zcard(key);
}
public Double zscore(String key, String member) {
Jedis j = getShard(key);
return j.zscore(key, member);
Jedis j = getShard(key);
return j.zscore(key, member);
}
public List<String> sort(String key) {
Jedis j = getShard(key);
return j.sort(key);
Jedis j = getShard(key);
return j.sort(key);
}
public List<String> sort(String key, SortingParams sortingParameters) {
Jedis j = getShard(key);
return j.sort(key, sortingParameters);
Jedis j = getShard(key);
return j.sort(key, sortingParameters);
}
public Long zcount(String key, double min, double max) {
Jedis j = getShard(key);
return j.zcount(key, min, max);
Jedis j = getShard(key);
return j.zcount(key, min, max);
}
public Set<String> zrangeByScore(String key, double min, double max) {
Jedis j = getShard(key);
return j.zrangeByScore(key, min, max);
Jedis j = getShard(key);
return j.zrangeByScore(key, min, max);
}
public Set<String> zrevrangeByScore(String key, double max, double min) {
Jedis j = getShard(key);
return j.zrevrangeByScore(key, max, min);
Jedis j = getShard(key);
return j.zrevrangeByScore(key, max, min);
}
public Set<String> zrangeByScore(String key, double min, double max,
int offset, int count) {
Jedis j = getShard(key);
return j.zrangeByScore(key, min, max, offset, count);
int offset, int count) {
Jedis j = getShard(key);
return j.zrangeByScore(key, min, max, offset, count);
}
public Set<String> zrevrangeByScore(String key, double max, double min,
int offset, int count) {
Jedis j = getShard(key);
return j.zrevrangeByScore(key, max, min, offset, count);
int offset, int count) {
Jedis j = getShard(key);
return j.zrevrangeByScore(key, max, min, offset, count);
}
public Set<Tuple> zrangeByScoreWithScores(String key, double min, double max) {
Jedis j = getShard(key);
return j.zrangeByScoreWithScores(key, min, max);
Jedis j = getShard(key);
return j.zrangeByScoreWithScores(key, min, max);
}
public Set<Tuple> zrevrangeByScoreWithScores(String key, double max,
double min) {
Jedis j = getShard(key);
return j.zrevrangeByScoreWithScores(key, max, min);
double min) {
Jedis j = getShard(key);
return j.zrevrangeByScoreWithScores(key, max, min);
}
public Set<Tuple> zrangeByScoreWithScores(String key, double min,
double max, int offset, int count) {
Jedis j = getShard(key);
return j.zrangeByScoreWithScores(key, min, max, offset, count);
double max, int offset, int count) {
Jedis j = getShard(key);
return j.zrangeByScoreWithScores(key, min, max, offset, count);
}
public Set<Tuple> zrevrangeByScoreWithScores(String key, double max,
double min, int offset, int count) {
Jedis j = getShard(key);
return j.zrevrangeByScoreWithScores(key, max, min, offset, count);
double min, int offset, int count) {
Jedis j = getShard(key);
return j.zrevrangeByScoreWithScores(key, max, min, offset, count);
}
public Long zremrangeByRank(String key, int start, int end) {
Jedis j = getShard(key);
return j.zremrangeByRank(key, start, end);
Jedis j = getShard(key);
return j.zremrangeByRank(key, start, end);
}
public Long zremrangeByScore(String key, double start, double end) {
Jedis j = getShard(key);
return j.zremrangeByScore(key, start, end);
Jedis j = getShard(key);
return j.zremrangeByScore(key, start, end);
}
public Long linsert(String key, LIST_POSITION where, String pivot,
String value) {
Jedis j = getShard(key);
return j.linsert(key, where, pivot, value);
String value) {
Jedis j = getShard(key);
return j.linsert(key, where, pivot, value);
}
}

10
src/main/java/redis/clients/util/SafeEncoder.java
View File

@@ -1,6 +1,8 @@
package redis.clients.util;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.List;
import redis.clients.jedis.Protocol;
import redis.clients.jedis.exceptions.JedisDataException;
@@ -11,6 +13,14 @@ import redis.clients.jedis.exceptions.JedisException;
*
*/
public class SafeEncoder {
public static byte[][] encodeMany(final String... strs){
byte[][] many = new byte[strs.length][];
for(int i=0;i<strs.length;i++){
many[i] = encode(strs[i]);
}
return many;
}
public static byte[] encode(final String str) {
try {
if (str == null) {