diff --git a/pom.xml b/pom.xml
index b550c90..2f5723b 100644
--- a/pom.xml
+++ b/pom.xml
@@ -54,7 +54,7 @@
junit4.8.1jar
- compile
+ test
diff --git a/src/main/java/redis/clients/jedis/BinaryClient.java b/src/main/java/redis/clients/jedis/BinaryClient.java
new file mode 100644
index 0000000..4893cc6
--- /dev/null
+++ b/src/main/java/redis/clients/jedis/BinaryClient.java
@@ -0,0 +1,629 @@
+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.LIMIT;
+import static redis.clients.jedis.Protocol.Keyword.NO;
+import static redis.clients.jedis.Protocol.Keyword.ONE;
+import static redis.clients.jedis.Protocol.Keyword.STORE;
+import static redis.clients.jedis.Protocol.Keyword.WITHSCORES;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+import redis.clients.jedis.Protocol.Command;
+import redis.clients.jedis.Protocol.Keyword;
+
+public class BinaryClient extends Connection {
+ public enum LIST_POSITION {
+ BEFORE, AFTER;
+ public final byte[] raw;
+
+ private LIST_POSITION() {
+ raw = name().getBytes(Protocol.UTF8);
+ }
+ }
+
+ private boolean isInMulti;
+
+ public boolean isInMulti() {
+ return isInMulti;
+ }
+
+ public BinaryClient(final String host) {
+ super(host);
+ }
+
+ public BinaryClient(final String host, final int port) {
+ super(host, port);
+ }
+
+ public void ping() {
+ sendCommand(PING);
+ }
+
+ public void set(final byte[] key, final byte[] value) {
+ sendCommand(Command.SET, key, value);
+ }
+
+ public void get(final byte[] key) {
+ sendCommand(Command.GET, key);
+ }
+
+ public void quit() {
+ sendCommand(QUIT);
+ }
+
+ public void exists(final byte[] key) {
+ sendCommand(EXISTS, key);
+ }
+
+ public void del(final byte[]... keys) {
+ sendCommand(DEL, keys);
+ }
+
+ public void type(final byte[] key) {
+ sendCommand(TYPE, key);
+ }
+
+ public void flushDB() {
+ sendCommand(FLUSHDB);
+ }
+
+ public void keys(final byte[] pattern) {
+ sendCommand(KEYS, pattern);
+ }
+
+ public void randomKey() {
+ sendCommand(RANDOMKEY);
+ }
+
+ public void rename(final byte[] oldkey, final byte[] newkey) {
+ sendCommand(RENAME, oldkey, newkey);
+ }
+
+ public void renamenx(final byte[] oldkey, final byte[] newkey) {
+ sendCommand(RENAMENX, oldkey, newkey);
+ }
+
+ public void dbSize() {
+ sendCommand(DBSIZE);
+ }
+
+ public void expire(final byte[] key, final int seconds) {
+ sendCommand(EXPIRE, key, toByteArray(seconds));
+ }
+
+ public void expireAt(final byte[] key, final long unixTime) {
+ sendCommand(EXPIREAT, key, toByteArray(unixTime));
+ }
+
+ public void ttl(final byte[] key) {
+ sendCommand(TTL, key);
+ }
+
+ public void select(final int index) {
+ sendCommand(SELECT, toByteArray(index));
+ }
+
+ public void move(final byte[] key, final int dbIndex) {
+ sendCommand(MOVE, key, toByteArray(dbIndex));
+ }
+
+ public void flushAll() {
+ sendCommand(FLUSHALL);
+ }
+
+ public void getSet(final byte[] key, final byte[] value) {
+ sendCommand(GETSET, key, value);
+ }
+
+ public void mget(final byte[]... keys) {
+ sendCommand(MGET, keys);
+ }
+
+ public void setnx(final byte[] key, final byte[] value) {
+ sendCommand(SETNX, key, value);
+ }
+
+ public void setex(final byte[] key, final int seconds, final byte[] value) {
+ sendCommand(SETEX, key, toByteArray(seconds), value);
+ }
+
+ public void mset(final byte[]... keysvalues) {
+ sendCommand(MSET, keysvalues);
+ }
+
+ public void msetnx(final byte[]... keysvalues) {
+ sendCommand(MSETNX, keysvalues);
+ }
+
+ public void decrBy(final byte[] key, final int integer) {
+ sendCommand(DECRBY, key, toByteArray(integer));
+ }
+
+ public void decr(final byte[] key) {
+ sendCommand(DECR, key);
+ }
+
+ public void incrBy(final byte[] key, final int integer) {
+ sendCommand(INCRBY, key, toByteArray(integer));
+ }
+
+ public void incr(final byte[] key) {
+ sendCommand(INCR, key);
+ }
+
+ public void append(final byte[] key, final byte[] value) {
+ sendCommand(APPEND, key, value);
+ }
+
+ public void substr(final byte[] key, final int start, final int end) {
+ sendCommand(SUBSTR, key, toByteArray(start), toByteArray(end));
+ }
+
+ public void hset(final byte[] key, final byte[] field, final byte[] value) {
+ sendCommand(HSET, key, field, value);
+ }
+
+ public void hget(final byte[] key, final byte[] field) {
+ sendCommand(HGET, key, field);
+ }
+
+ public void hsetnx(final byte[] key, final byte[] field, final byte[] value) {
+ sendCommand(HSETNX, key, field, value);
+ }
+
+ public void hmset(final byte[] key, final Map hash) {
+ final List params = new ArrayList();
+ params.add(key);
+
+ for (final byte[] field : hash.keySet()) {
+ params.add(field);
+ params.add(hash.get(field));
+ }
+ sendCommand(HMSET, params.toArray(new byte[params.size()][]));
+ }
+
+ public void hmget(final byte[] key, final byte[]... fields) {
+ final byte[][] params = new byte[fields.length + 1][];
+ params[0] = key;
+ System.arraycopy(fields, 0, params, 1, fields.length);
+ sendCommand(HMGET, params);
+ }
+
+ public void hincrBy(final byte[] key, final byte[] field, final int value) {
+ sendCommand(HINCRBY, key, field, toByteArray(value));
+ }
+
+ public void hexists(final byte[] key, final byte[] field) {
+ sendCommand(HEXISTS, key, field);
+ }
+
+ public void hdel(final byte[] key, final byte[] field) {
+ sendCommand(HDEL, key, field);
+ }
+
+ public void hlen(final byte[] key) {
+ sendCommand(HLEN, key);
+ }
+
+ public void hkeys(final byte[] key) {
+ sendCommand(HKEYS, key);
+ }
+
+ public void hvals(final byte[] key) {
+ sendCommand(HVALS, key);
+ }
+
+ public void hgetAll(final byte[] key) {
+ sendCommand(HGETALL, key);
+ }
+
+ public void rpush(final byte[] key, final byte[] string) {
+ sendCommand(RPUSH, key, string);
+ }
+
+ public void lpush(final byte[] key, final byte[] string) {
+ sendCommand(LPUSH, key, string);
+ }
+
+ public void llen(final byte[] key) {
+ sendCommand(LLEN, key);
+ }
+
+ public void lrange(final byte[] key, final int start, final int end) {
+ sendCommand(LRANGE, key, toByteArray(start), toByteArray(end));
+ }
+
+ public void ltrim(final byte[] key, final int start, final int end) {
+ sendCommand(LTRIM, key, toByteArray(start), toByteArray(end));
+ }
+
+ public void lindex(final byte[] key, final int index) {
+ sendCommand(LINDEX, key, toByteArray(index));
+ }
+
+ public void lset(final byte[] key, final int index, final byte[] value) {
+ sendCommand(LSET, key, toByteArray(index), value);
+ }
+
+ public void lrem(final byte[] key, int count, final byte[] value) {
+ sendCommand(LREM, key, toByteArray(count), value);
+ }
+
+ public void lpop(final byte[] key) {
+ sendCommand(LPOP, key);
+ }
+
+ public void rpop(final byte[] key) {
+ sendCommand(RPOP, key);
+ }
+
+ public void rpoplpush(final byte[] srckey, final byte[] dstkey) {
+ sendCommand(RPOPLPUSH, srckey, dstkey);
+ }
+
+ public void sadd(final byte[] key, final byte[] member) {
+ sendCommand(SADD, key, member);
+ }
+
+ public void smembers(final byte[] key) {
+ sendCommand(SMEMBERS, key);
+ }
+
+ public void srem(final byte[] key, final byte[] member) {
+ sendCommand(SREM, key, member);
+ }
+
+ public void spop(final byte[] key) {
+ sendCommand(SPOP, key);
+ }
+
+ public void smove(final byte[] srckey, final byte[] dstkey,
+ final byte[] member) {
+ sendCommand(SMOVE, srckey, dstkey, member);
+ }
+
+ public void scard(final byte[] key) {
+ sendCommand(SCARD, key);
+ }
+
+ public void sismember(final byte[] key, final byte[] member) {
+ sendCommand(SISMEMBER, key, member);
+ }
+
+ public void sinter(final byte[]... keys) {
+ sendCommand(SINTER, keys);
+ }
+
+ public void sinterstore(final byte[] dstkey, final byte[]... keys) {
+ final byte[][] params = new byte[keys.length + 1][];
+ params[0] = dstkey;
+ System.arraycopy(keys, 0, params, 1, keys.length);
+ sendCommand(SINTERSTORE, params);
+ }
+
+ public void sunion(final byte[]... keys) {
+ sendCommand(SUNION, keys);
+ }
+
+ public void sunionstore(final byte[] dstkey, final byte[]... keys) {
+ byte[][] params = new byte[keys.length + 1][];
+ params[0] = dstkey;
+ System.arraycopy(keys, 0, params, 1, keys.length);
+ sendCommand(SUNIONSTORE, params);
+ }
+
+ public void sdiff(final byte[]... keys) {
+ sendCommand(SDIFF, keys);
+ }
+
+ public void sdiffstore(final byte[] dstkey, final byte[]... keys) {
+ byte[][] params = new byte[keys.length + 1][];
+ params[0] = dstkey;
+ System.arraycopy(keys, 0, params, 1, keys.length);
+ sendCommand(SDIFFSTORE, params);
+ }
+
+ public void srandmember(final byte[] key) {
+ sendCommand(SRANDMEMBER, key);
+ }
+
+ public void zadd(final byte[] key, final double score, final byte[] member) {
+ sendCommand(ZADD, key, toByteArray(score), member);
+ }
+
+ 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 zincrby(final byte[] key, final double score,
+ final byte[] member) {
+ sendCommand(ZINCRBY, key, toByteArray(score), member);
+ }
+
+ public void zrank(final byte[] key, final byte[] member) {
+ sendCommand(ZRANK, key, member);
+ }
+
+ public void zrevrank(final byte[] key, final byte[] member) {
+ sendCommand(ZREVRANK, key, member);
+ }
+
+ public void zrevrange(final byte[] key, final int start, final int end) {
+ sendCommand(ZREVRANGE, key, toByteArray(start), toByteArray(end));
+ }
+
+ public void zrangeWithScores(final byte[] key, final int start,
+ final int end) {
+ sendCommand(ZRANGE, key, toByteArray(start), toByteArray(end),
+ WITHSCORES.raw);
+ }
+
+ public void zrevrangeWithScores(final byte[] key, final int start,
+ final int end) {
+ sendCommand(ZREVRANGE, key, toByteArray(start), toByteArray(end),
+ WITHSCORES.raw);
+ }
+
+ public void zcard(final byte[] key) {
+ sendCommand(ZCARD, key);
+ }
+
+ public void zscore(final byte[] key, final byte[] member) {
+ sendCommand(ZSCORE, key, member);
+ }
+
+ public void multi() {
+ sendCommand(MULTI);
+ isInMulti = true;
+ }
+
+ public void discard() {
+ sendCommand(DISCARD);
+ isInMulti = false;
+ }
+
+ public void exec() {
+ sendCommand(EXEC);
+ isInMulti = false;
+ }
+
+ public void watch(final byte[] key) {
+ sendCommand(WATCH, key);
+ }
+
+ public void unwatch() {
+ sendCommand(UNWATCH);
+ }
+
+ public void sort(final byte[] key) {
+ sendCommand(SORT, key);
+ }
+
+ public void sort(final byte[] key, final SortingParams sortingParameters) {
+ final List args = new ArrayList();
+ args.add(key);
+ args.addAll(sortingParameters.getParams());
+ sendCommand(SORT, args.toArray(new byte[args.size()][]));
+ }
+
+ public void blpop(final byte[][] args) {
+ sendCommand(BLPOP, args);
+ }
+
+ public void sort(final byte[] key, final SortingParams sortingParameters,
+ final byte[] dstkey) {
+ final List args = new ArrayList();
+ args.add(key);
+ args.addAll(sortingParameters.getParams());
+ args.add(STORE.raw);
+ args.add(dstkey);
+ sendCommand(SORT, args.toArray(new byte[args.size()][]));
+ }
+
+ public void sort(final byte[] key, final byte[] dstkey) {
+ sendCommand(SORT, key, STORE.raw, dstkey);
+ }
+
+ public void brpop(final byte[][] args) {
+ sendCommand(BRPOP, args);
+ }
+
+ public void auth(final String password) {
+ sendCommand(AUTH, password);
+ }
+
+ public void subscribe(final String... channels) {
+ sendCommand(SUBSCRIBE, channels);
+ }
+
+ public void publish(final String channel, final String message) {
+ sendCommand(PUBLISH, channel, message);
+ }
+
+ public void unsubscribe() {
+ sendCommand(UNSUBSCRIBE);
+ }
+
+ public void unsubscribe(final String... channels) {
+ sendCommand(UNSUBSCRIBE, channels);
+ }
+
+ public void psubscribe(final String[] patterns) {
+ sendCommand(PSUBSCRIBE, patterns);
+ }
+
+ public void punsubscribe() {
+ sendCommand(PUNSUBSCRIBE);
+ }
+
+ public void punsubscribe(final String... patterns) {
+ sendCommand(PUNSUBSCRIBE, patterns);
+ }
+
+ public void zcount(final byte[] key, final double min, final double max) {
+ sendCommand(ZCOUNT, key, toByteArray(min), toByteArray(max));
+ }
+
+ public void zrangeByScore(final byte[] key, final double min,
+ final double max) {
+ sendCommand(ZRANGEBYSCORE, key, toByteArray(min), toByteArray(max));
+ }
+
+ public void zrangeByScore(final byte[] key, final byte[] min,
+ final byte[] max) {
+ sendCommand(ZRANGEBYSCORE, key, min, max);
+ }
+
+ public void zrangeByScore(final byte[] key, final double min,
+ final double max, final int offset, int count) {
+ sendCommand(ZRANGEBYSCORE, key, toByteArray(min), toByteArray(max),
+ LIMIT.raw, toByteArray(offset), toByteArray(count));
+ }
+
+ public void zrangeByScoreWithScores(final byte[] key, final double min,
+ final double max) {
+ sendCommand(ZRANGEBYSCORE, key, toByteArray(min), toByteArray(max),
+ WITHSCORES.raw);
+ }
+
+ public void zrangeByScoreWithScores(final byte[] key, final double min,
+ final double max, final int offset, final int count) {
+ sendCommand(ZRANGEBYSCORE, key, toByteArray(min), toByteArray(max),
+ LIMIT.raw, toByteArray(offset), toByteArray(count),
+ WITHSCORES.raw);
+ }
+
+ public void zremrangeByRank(final byte[] key, final int start, final int end) {
+ sendCommand(ZREMRANGEBYRANK, key, toByteArray(start), toByteArray(end));
+ }
+
+ public void zremrangeByScore(final byte[] key, final double start,
+ final double end) {
+ sendCommand(ZREMRANGEBYSCORE, key, toByteArray(start), toByteArray(end));
+ }
+
+ public void zunionstore(final byte[] dstkey, final byte[]... sets) {
+ final byte[][] params = new byte[sets.length + 2][];
+ params[0] = dstkey;
+ params[1] = toByteArray(sets.length);
+ System.arraycopy(sets, 0, params, 2, sets.length);
+ sendCommand(ZUNIONSTORE, params);
+ }
+
+ public void zunionstore(final byte[] dstkey, final ZParams params,
+ final byte[]... sets) {
+ final List args = new ArrayList();
+ args.add(dstkey);
+ args.add(Protocol.toByteArray(sets.length));
+ for (final byte[] set : sets) {
+ args.add(set);
+ }
+ args.addAll(params.getParams());
+ sendCommand(ZUNIONSTORE, args.toArray(new byte[args.size()][]));
+ }
+
+ public void zinterstore(final byte[] dstkey, final byte[]... sets) {
+ final byte[][] params = new byte[sets.length + 2][];
+ params[0] = dstkey;
+ params[1] = Protocol.toByteArray(sets.length);
+ System.arraycopy(sets, 0, params, 2, sets.length);
+ sendCommand(ZINTERSTORE, params);
+ }
+
+ public void zinterstore(final byte[] dstkey, final ZParams params,
+ final byte[]... sets) {
+ final List args = new ArrayList();
+ args.add(dstkey);
+ args.add(Protocol.toByteArray(sets.length));
+ for (final byte[] set : sets) {
+ args.add(set);
+ }
+ args.addAll(params.getParams());
+ sendCommand(ZINTERSTORE, args.toArray(new byte[args.size()][]));
+ }
+
+ public void save() {
+ sendCommand(SAVE);
+ }
+
+ public void bgsave() {
+ sendCommand(BGSAVE);
+ }
+
+ public void bgrewriteaof() {
+ sendCommand(BGREWRITEAOF);
+ }
+
+ public void lastsave() {
+ sendCommand(LASTSAVE);
+ }
+
+ public void shutdown() {
+ sendCommand(SHUTDOWN);
+ }
+
+ public void info() {
+ sendCommand(INFO);
+ }
+
+ public void monitor() {
+ sendCommand(MONITOR);
+ }
+
+ public void slaveof(final String host, final int port) {
+ sendCommand(SLAVEOF, host, String.valueOf(port));
+ }
+
+ public void slaveofNoOne() {
+ sendCommand(SLAVEOF, NO.raw, ONE.raw);
+ }
+
+ public void configGet(final String pattern) {
+ sendCommand(CONFIG, Keyword.GET.name(), pattern);
+ }
+
+ public void configSet(final String parameter, final String value) {
+ sendCommand(CONFIG, Keyword.SET.name(), parameter, value);
+ }
+
+ public void strlen(final byte[] key) {
+ sendCommand(STRLEN, key);
+ }
+
+ public void sync() {
+ sendCommand(SYNC);
+ }
+
+ public void lpushx(final byte[] key, final byte[] string) {
+ sendCommand(LPUSHX, key, string);
+ }
+
+ public void persist(final byte[] key) {
+ sendCommand(PERSIST, key);
+ }
+
+ public void rpushx(final byte[] key, final byte[] string) {
+ sendCommand(RPUSHX, key, string);
+ }
+
+ public void echo(final byte[] string) {
+ sendCommand(ECHO, string);
+ }
+
+ public void linsert(final byte[] key, final LIST_POSITION where,
+ final byte[] pivot, final byte[] value) {
+ sendCommand(LINSERT, key, where.raw, pivot, value);
+ }
+
+ public void debug(final DebugParams params) {
+ sendCommand(DEBUG, params.getCommand());
+ }
+}
\ No newline at end of file
diff --git a/src/main/java/redis/clients/jedis/BinaryJedis.java b/src/main/java/redis/clients/jedis/BinaryJedis.java
new file mode 100644
index 0000000..8f57a3d
--- /dev/null
+++ b/src/main/java/redis/clients/jedis/BinaryJedis.java
@@ -0,0 +1,2877 @@
+package redis.clients.jedis;
+
+import java.io.IOException;
+import java.net.UnknownHostException;
+import java.util.ArrayList;
+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.jedis.BinaryClient.LIST_POSITION;
+import redis.clients.util.JedisByteHashMap;
+
+public class BinaryJedis implements BinaryJedisCommands {
+ protected Client client = null;
+ protected String password = null;
+
+ public BinaryJedis(final String host) {
+ client = new Client(host);
+ }
+
+ public BinaryJedis(final String host, final int port) {
+ client = new Client(host, port);
+ }
+
+ public BinaryJedis(final String host, final int port, final int timeout) {
+ client = new Client(host, port);
+ client.setTimeout(timeout);
+ }
+
+ public BinaryJedis(final JedisShardInfo shardInfo) {
+ client = new Client(shardInfo.getHost(), shardInfo.getPort());
+ client.setTimeout(shardInfo.getTimeout());
+ this.password = shardInfo.getPassword();
+ }
+
+ public String ping() {
+ checkIsInMulti();
+ client.ping();
+ return client.getStatusCodeReply();
+ }
+
+ /**
+ * Set the string value as value of the key. The string can't be longer than
+ * 1073741824 bytes (1 GB).
+ *
+ * Time complexity: O(1)
+ *
+ * @param key
+ * @param value
+ * @return Status code reply
+ */
+ public String set(final byte[] key, final byte[] value) {
+ checkIsInMulti();
+ client.set(key, value);
+ return client.getStatusCodeReply();
+ }
+
+ /**
+ * Get the value of the specified key. If the key does not exist the special
+ * value 'nil' is returned. If the value stored at key is not a string an
+ * error is returned because GET can only handle string values.
+ *
+ * Time complexity: O(1)
+ *
+ * @param key
+ * @return Bulk reply
+ */
+ public byte[] get(final byte[] key) {
+ checkIsInMulti();
+ client.get(key);
+ return client.getBinaryBulkReply();
+ }
+
+ /**
+ * Ask the server to silently close the connection.
+ */
+ public void quit() {
+ checkIsInMulti();
+ client.quit();
+ }
+
+ /**
+ * Test if the specified key exists. The command returns "0" if the key
+ * exists, otherwise "1" is returned. Note that even keys set with an empty
+ * string as value will return "1".
+ *
+ * Time complexity: O(1)
+ *
+ * @param key
+ * @return Integer reply, "0" if the key exists, otherwise "1"
+ */
+ public Integer exists(final byte[] key) {
+ checkIsInMulti();
+ client.exists(key);
+ return client.getIntegerReply();
+ }
+
+ /**
+ * Remove the specified keys. If a given key does not exist no operation is
+ * performed for this key. The command returns the number of keys removed.
+ *
+ * Time complexity: O(1)
+ *
+ * @param keys
+ * @return Integer reply, specifically: an integer greater than 0 if one or
+ * more keys were removed 0 if none of the specified key existed
+ */
+ public Integer del(final byte[]... keys) {
+ checkIsInMulti();
+ client.del(keys);
+ return client.getIntegerReply();
+ }
+
+ /**
+ * Return the type of the value stored at key in form of a string. The type
+ * can be one of "none", "string", "list", "set". "none" is returned if the
+ * key does not exist.
+ *
+ * Time complexity: O(1)
+ *
+ * @param key
+ * @return Status code reply, specifically: "none" if the key does not exist
+ * "string" if the key contains a String value "list" if the key
+ * contains a List value "set" if the key contains a Set value
+ * "zset" if the key contains a Sorted Set value "hash" if the key
+ * contains a Hash value
+ */
+ public String type(final byte[] key) {
+ checkIsInMulti();
+ client.type(key);
+ return client.getStatusCodeReply();
+ }
+
+ /**
+ * Delete all the keys of the currently selected DB. This command never
+ * fails.
+ *
+ * @return Status code reply
+ */
+ public String flushDB() {
+ checkIsInMulti();
+ client.flushDB();
+ return client.getStatusCodeReply();
+ }
+
+ /**
+ * Returns all the keys matching the glob-style pattern as space separated
+ * strings. For example if you have in the database the keys "foo" and
+ * "foobar" the command "KEYS foo*" will return "foo foobar".
+ *
+ * Note that while the time complexity for this operation is O(n) the
+ * constant times are pretty low. For example Redis running on an entry
+ * level laptop can scan a 1 million keys database in 40 milliseconds.
+ * Still it's better to consider this one of the slow commands that may
+ * ruin the DB performance if not used with care.
+ *
+ * In other words this command is intended only for debugging and special
+ * operations like creating a script to change the DB schema. Don't use it
+ * in your normal code. Use Redis Sets in order to group together a subset
+ * of objects.
+ *
+ * Glob style patterns examples:
+ *
+ *
h?llo will match hello hallo hhllo
+ *
h*llo will match hllo heeeello
+ *
h[ae]llo will match hello and hallo, but not hillo
+ *
+ *
+ * Use \ to escape special chars if you want to match them verbatim.
+ *
+ * Time complexity: O(n) (with n being the number of keys in the DB, and
+ * assuming keys and pattern of limited length)
+ *
+ * @param pattern
+ * @return Multi bulk reply
+ */
+ public Set keys(final byte[] pattern) {
+ checkIsInMulti();
+ client.keys(pattern);
+ final HashSet keySet = new LinkedHashSet(client
+ .getBinaryMultiBulkReply());
+ return keySet;
+ }
+
+ /**
+ * Return a randomly selected key from the currently selected DB.
+ *
+ * Time complexity: O(1)
+ *
+ * @return Singe line reply, specifically the randomly selected key or an
+ * empty string is the database is empty
+ */
+ public byte[] randomBinaryKey() {
+ checkIsInMulti();
+ client.randomKey();
+ return client.getBinaryBulkReply();
+ }
+
+ /**
+ * Atomically renames the key oldkey to newkey. If the source and
+ * destination name are the same an error is returned. If newkey already
+ * exists it is overwritten.
+ *
+ * Time complexity: O(1)
+ *
+ * @param oldkey
+ * @param newkey
+ * @return Status code repy
+ */
+ public String rename(final byte[] oldkey, final byte[] newkey) {
+ checkIsInMulti();
+ client.rename(oldkey, newkey);
+ return client.getStatusCodeReply();
+ }
+
+ /**
+ * Rename oldkey into newkey but fails if the destination key newkey already
+ * exists.
+ *
+ * Time complexity: O(1)
+ *
+ * @param oldkey
+ * @param newkey
+ * @return Integer reply, specifically: 1 if the key was renamed 0 if the
+ * target key already exist
+ */
+ public Integer renamenx(final byte[] oldkey, final byte[] newkey) {
+ checkIsInMulti();
+ client.renamenx(oldkey, newkey);
+ return client.getIntegerReply();
+ }
+
+ /**
+ * Return the number of keys in the currently selected database.
+ *
+ * @return Integer reply
+ */
+ public Integer dbSize() {
+ checkIsInMulti();
+ client.dbSize();
+ return client.getIntegerReply();
+ }
+
+ /**
+ * Set a timeout on the specified key. After the timeout the key will be
+ * automatically deleted by the server. A key with an associated timeout is
+ * said to be volatile in Redis terminology.
+ *
+ * Voltile keys are stored on disk like the other keys, the timeout is
+ * persistent too like all the other aspects of the dataset. Saving a
+ * dataset containing expires and stopping the server does not stop the flow
+ * of time as Redis stores on disk the time when the key will no longer be
+ * available as Unix time, and not the remaining seconds.
+ *
+ * Since Redis 2.1.3 you can update the value of the timeout of a key
+ * already having an expire set. It is also possible to undo the expire at
+ * all turning the key into a normal key using the {@link #persist(String)
+ * PERSIST} command.
+ *
+ * Time complexity: O(1)
+ *
+ * @see ExpireCommand
+ *
+ * @param key
+ * @param seconds
+ * @return Integer reply, specifically: 1: the timeout was set. 0: the
+ * timeout was not set since the key already has an associated
+ * timeout (this may happen only in Redis versions < 2.1.3, Redis >=
+ * 2.1.3 will happily update the timeout), or the key does not
+ * exist.
+ */
+ public Integer expire(final byte[] key, final int seconds) {
+ checkIsInMulti();
+ client.expire(key, seconds);
+ return client.getIntegerReply();
+ }
+
+ /**
+ * EXPIREAT works exctly like {@link #expire(String, int) EXPIRE} but
+ * instead to get the number of seconds representing the Time To Live of the
+ * key as a second argument (that is a relative way of specifing the TTL),
+ * it takes an absolute one in the form of a UNIX timestamp (Number of
+ * seconds elapsed since 1 Gen 1970).
+ *
+ * EXPIREAT was introduced in order to implement the Append Only File
+ * persistence mode so that EXPIRE commands are automatically translated
+ * into EXPIREAT commands for the append only file. Of course EXPIREAT can
+ * also used by programmers that need a way to simply specify that a given
+ * key should expire at a given time in the future.
+ *
+ * Since Redis 2.1.3 you can update the value of the timeout of a key
+ * already having an expire set. It is also possible to undo the expire at
+ * all turning the key into a normal key using the {@link #persist(String)
+ * PERSIST} command.
+ *
+ * Time complexity: O(1)
+ *
+ * @see ExpireCommand
+ *
+ * @param key
+ * @param unixTime
+ * @return Integer reply, specifically: 1: the timeout was set. 0: the
+ * timeout was not set since the key already has an associated
+ * timeout (this may happen only in Redis versions < 2.1.3, Redis >=
+ * 2.1.3 will happily update the timeout), or the key does not
+ * exist.
+ */
+ public Integer expireAt(final byte[] key, final long unixTime) {
+ checkIsInMulti();
+ client.expireAt(key, unixTime);
+ return client.getIntegerReply();
+ }
+
+ /**
+ * The TTL command returns the remaining time to live in seconds of a key
+ * that has an {@link #expire(String, int) EXPIRE} set. This introspection
+ * capability allows a Redis client to check how many seconds a given key
+ * will continue to be part of the dataset.
+ *
+ * @param key
+ * @return Integer reply, returns the remaining time to live in seconds of a
+ * key that has an EXPIRE. If the Key does not exists or does not
+ * have an associated expire, -1 is returned.
+ */
+ public Integer ttl(final byte[] key) {
+ checkIsInMulti();
+ client.ttl(key);
+ return client.getIntegerReply();
+ }
+
+ /**
+ * Select the DB with having the specified zero-based numeric index. For
+ * default every new client connection is automatically selected to DB 0.
+ *
+ * @param index
+ * @return Status code reply
+ */
+ public String select(final int index) {
+ checkIsInMulti();
+ client.select(index);
+ return client.getStatusCodeReply();
+ }
+
+ /**
+ * Move the specified key from the currently selected DB to the specified
+ * destination DB. Note that this command returns 1 only if the key was
+ * successfully moved, and 0 if the target key was already there or if the
+ * source key was not found at all, so it is possible to use MOVE as a
+ * locking primitive.
+ *
+ * @param key
+ * @param dbIndex
+ * @return Integer reply, specifically: 1 if the key was moved 0 if the key
+ * was not moved because already present on the target DB or was not
+ * found in the current DB.
+ */
+ public Integer move(final byte[] key, final int dbIndex) {
+ checkIsInMulti();
+ client.move(key, dbIndex);
+ return client.getIntegerReply();
+ }
+
+ /**
+ * Delete all the keys of all the existing databases, not just the currently
+ * selected one. This command never fails.
+ *
+ * @return Status code reply
+ */
+ public String flushAll() {
+ checkIsInMulti();
+ client.flushAll();
+ return client.getStatusCodeReply();
+ }
+
+ /**
+ * GETSET is an atomic set this value and return the old value command. Set
+ * key to the string value and return the old value stored at key. The
+ * string can't be longer than 1073741824 bytes (1 GB).
+ *
+ * Time complexity: O(1)
+ *
+ * @param key
+ * @param value
+ * @return Bulk reply
+ */
+ public byte[] getSet(final byte[] key, final byte[] value) {
+ checkIsInMulti();
+ client.getSet(key, value);
+ return client.getBinaryBulkReply();
+ }
+
+ /**
+ * Get the values of all the specified keys. If one or more keys dont exist
+ * or is not of type String, a 'nil' value is returned instead of the value
+ * of the specified key, but the operation never fails.
+ *
+ * Time complexity: O(1) for every key
+ *
+ * @param keys
+ * @return Multi bulk reply
+ */
+ public List mget(final byte[]... keys) {
+ checkIsInMulti();
+ client.mget(keys);
+ return client.getBinaryMultiBulkReply();
+ }
+
+ /**
+ * SETNX works exactly like {@link #set(String, String) SET} with the only
+ * difference that if the key already exists no operation is performed.
+ * SETNX actually means "SET if Not eXists".
+ *
+ * Time complexity: O(1)
+ *
+ * @param key
+ * @param value
+ * @return Integer reply, specifically: 1 if the key was set 0 if the key
+ * was not set
+ */
+ public Integer setnx(final byte[] key, final byte[] value) {
+ checkIsInMulti();
+ client.setnx(key, value);
+ return client.getIntegerReply();
+ }
+
+ /**
+ * The command is exactly equivalent to the following group of commands:
+ * {@link #set(String, String) SET} + {@link #expire(String, int) EXPIRE}.
+ * The operation is atomic.
+ *
+ * Time complexity: O(1)
+ *
+ * @param key
+ * @param seconds
+ * @param value
+ * @return Status code reply
+ */
+ public String setex(final byte[] key, final int seconds, final byte[] value) {
+ checkIsInMulti();
+ client.setex(key, seconds, value);
+ return client.getStatusCodeReply();
+ }
+
+ /**
+ * Set the the respective keys to the respective values. MSET will replace
+ * old values with new values, while {@link #msetnx(String...) MSETNX} will
+ * not perform any operation at all even if just a single key already
+ * exists.
+ *
+ * Because of this semantic MSETNX can be used in order to set different
+ * keys representing different fields of an unique logic object in a way
+ * that ensures that either all the fields or none at all are set.
+ *
+ * Both MSET and MSETNX are atomic operations. This means that for instance
+ * if the keys A and B are modified, another client talking to Redis can
+ * either see the changes to both A and B at once, or no modification at
+ * all.
+ *
+ * @see #msetnx(String...)
+ *
+ * @param keysvalues
+ * @return Status code reply Basically +OK as MSET can't fail
+ */
+ public String mset(final byte[]... keysvalues) {
+ checkIsInMulti();
+ client.mset(keysvalues);
+ return client.getStatusCodeReply();
+ }
+
+ /**
+ * Set the the respective keys to the respective values.
+ * {@link #mset(String...) MSET} will replace old values with new values,
+ * while MSETNX will not perform any operation at all even if just a single
+ * key already exists.
+ *
+ * Because of this semantic MSETNX can be used in order to set different
+ * keys representing different fields of an unique logic object in a way
+ * that ensures that either all the fields or none at all are set.
+ *
+ * Both MSET and MSETNX are atomic operations. This means that for instance
+ * if the keys A and B are modified, another client talking to Redis can
+ * either see the changes to both A and B at once, or no modification at
+ * all.
+ *
+ * @see #mset(String...)
+ *
+ * @param keysvalues
+ * @return Integer reply, specifically: 1 if the all the keys were set 0 if
+ * no key was set (at least one key already existed)
+ */
+ public Integer msetnx(final byte[]... keysvalues) {
+ checkIsInMulti();
+ client.msetnx(keysvalues);
+ return client.getIntegerReply();
+ }
+
+ /**
+ * IDECRBY work just like {@link #decr(String) INCR} but instead to
+ * decrement by 1 the decrement is integer.
+ *
+ * INCR commands are limited to 64 bit signed integers.
+ *
+ * Note: this is actually a string operation, that is, in Redis there are
+ * not "integer" types. Simply the string stored at the key is parsed as a
+ * base 10 64 bit signed integer, incremented, and then converted back as a
+ * string.
+ *
+ * Time complexity: O(1)
+ *
+ * @see #incr(String)
+ * @see #decr(String)
+ * @see #incrBy(String, int)
+ *
+ * @param key
+ * @param integer
+ * @return Integer reply, this commands will reply with the new value of key
+ * after the increment.
+ */
+ public Integer decrBy(final byte[] key, final int integer) {
+ checkIsInMulti();
+ client.decrBy(key, integer);
+ return client.getIntegerReply();
+ }
+
+ /**
+ * Decrement the number stored at key by one. If the key does not exist or
+ * contains a value of a wrong type, set the key to the value of "0" before
+ * to perform the decrement operation.
+ *
+ * INCR commands are limited to 64 bit signed integers.
+ *
+ * Note: this is actually a string operation, that is, in Redis there are
+ * not "integer" types. Simply the string stored at the key is parsed as a
+ * base 10 64 bit signed integer, incremented, and then converted back as a
+ * string.
+ *
+ * Time complexity: O(1)
+ *
+ * @see #incr(String)
+ * @see #incrBy(String, int)
+ * @see #decrBy(String, int)
+ *
+ * @param key
+ * @return Integer reply, this commands will reply with the new value of key
+ * after the increment.
+ */
+ public Integer decr(final byte[] key) {
+ checkIsInMulti();
+ client.decr(key);
+ return client.getIntegerReply();
+ }
+
+ /**
+ * INCRBY work just like {@link #incr(String) INCR} but instead to increment
+ * by 1 the increment is integer.
+ *
+ * INCR commands are limited to 64 bit signed integers.
+ *
+ * Note: this is actually a string operation, that is, in Redis there are
+ * not "integer" types. Simply the string stored at the key is parsed as a
+ * base 10 64 bit signed integer, incremented, and then converted back as a
+ * string.
+ *
+ * Time complexity: O(1)
+ *
+ * @see #incr(String)
+ * @see #decr(String)
+ * @see #decrBy(String, int)
+ *
+ * @param key
+ * @param integer
+ * @return Integer reply, this commands will reply with the new value of key
+ * after the increment.
+ */
+ public Integer incrBy(final byte[] key, final int integer) {
+ checkIsInMulti();
+ client.incrBy(key, integer);
+ return client.getIntegerReply();
+ }
+
+ /**
+ * Increment the number stored at key by one. If the key does not exist or
+ * contains a value of a wrong type, set the key to the value of "0" before
+ * to perform the increment operation.
+ *
+ * INCR commands are limited to 64 bit signed integers.
+ *
+ * Note: this is actually a string operation, that is, in Redis there are
+ * not "integer" types. Simply the string stored at the key is parsed as a
+ * base 10 64 bit signed integer, incremented, and then converted back as a
+ * string.
+ *
+ * Time complexity: O(1)
+ *
+ * @see #incrBy(String, int)
+ * @see #decr(String)
+ * @see #decrBy(String, int)
+ *
+ * @param key
+ * @return Integer reply, this commands will reply with the new value of key
+ * after the increment.
+ */
+ public Integer incr(final byte[] key) {
+ checkIsInMulti();
+ client.incr(key);
+ return client.getIntegerReply();
+ }
+
+ /**
+ * If the key already exists and is a string, this command appends the
+ * provided value at the end of the string. If the key does not exist it is
+ * created and set as an empty string, so APPEND will be very similar to SET
+ * in this special case.
+ *
+ * Time complexity: O(1). The amortized time complexity is O(1) assuming the
+ * appended value is small and the already present value is of any size,
+ * since the dynamic string library used by Redis will double the free space
+ * available on every reallocation.
+ *
+ * @param key
+ * @param value
+ * @return Integer reply, specifically the total length of the string after
+ * the append operation.
+ */
+ public Integer append(final byte[] key, final byte[] value) {
+ checkIsInMulti();
+ client.append(key, value);
+ return client.getIntegerReply();
+ }
+
+ /**
+ * Return a subset of the string from offset start to offset end (both
+ * offsets are inclusive). Negative offsets can be used in order to provide
+ * an offset starting from the end of the string. So -1 means the last char,
+ * -2 the penultimate and so forth.
+ *
+ * The function handles out of range requests without raising an error, but
+ * just limiting the resulting range to the actual length of the string.
+ *
+ * Time complexity: O(start+n) (with start being the start index and n the
+ * total length of the requested range). Note that the lookup part of this
+ * command is O(1) so for small strings this is actually an O(1) command.
+ *
+ * @param key
+ * @param start
+ * @param end
+ * @return Bulk reply
+ */
+ public byte[] substr(final byte[] key, final int start, final int end) {
+ checkIsInMulti();
+ client.substr(key, start, end);
+ return client.getBinaryBulkReply();
+ }
+
+ /**
+ *
+ * Set the specified hash field to the specified value.
+ *
+ * If key does not exist, a new key holding a hash is created.
+ *
+ * Time complexity: O(1)
+ *
+ * @param key
+ * @param field
+ * @param value
+ * @return If the field already exists, and the HSET just produced an update
+ * of the value, 0 is returned, otherwise if a new field is created
+ * 1 is returned.
+ */
+ public Integer hset(final byte[] key, final byte[] field, final byte[] value) {
+ checkIsInMulti();
+ client.hset(key, field, value);
+ return client.getIntegerReply();
+ }
+
+ /**
+ * If key holds a hash, retrieve the value associated to the specified
+ * field.
+ *
+ * If the field is not found or the key does not exist, a special 'nil'
+ * value is returned.
+ *
+ * Time complexity: O(1)
+ *
+ * @param key
+ * @param field
+ * @return Bulk reply
+ */
+ public byte[] hget(final byte[] key, final byte[] field) {
+ checkIsInMulti();
+ client.hget(key, field);
+ return client.getBinaryBulkReply();
+ }
+
+ /**
+ *
+ * Set the specified hash field to the specified value if the field not
+ * exists. Time complexity: O(1)
+ *
+ * @param key
+ * @param field
+ * @param value
+ * @return If the field already exists, 0 is returned, otherwise if a new
+ * field is created 1 is returned.
+ */
+ public Integer hsetnx(final byte[] key, final byte[] field,
+ final byte[] value) {
+ checkIsInMulti();
+ client.hsetnx(key, field, value);
+ return client.getIntegerReply();
+ }
+
+ /**
+ * Set the respective fields to the respective values. HMSET replaces old
+ * values with new values.
+ *
+ * If key does not exist, a new key holding a hash is created.
+ *
+ * Time complexity: O(N) (with N being the number of fields)
+ *
+ * @param key
+ * @param hash
+ * @return Always OK because HMSET can't fail
+ */
+ public String hmset(final byte[] key, final Map hash) {
+ checkIsInMulti();
+ client.hmset(key, hash);
+ return client.getStatusCodeReply();
+ }
+
+ /**
+ * Retrieve the values associated to the specified fields.
+ *
+ * If some of the specified fields do not exist, nil values are returned.
+ * Non existing keys are considered like empty hashes.
+ *
+ * Time complexity: O(N) (with N being the number of fields)
+ *
+ * @param key
+ * @param fields
+ * @return Multi Bulk Reply specifically a list of all the values associated
+ * with the specified fields, in the same order of the request.
+ */
+ public List hmget(final byte[] key, final byte[]... fields) {
+ checkIsInMulti();
+ client.hmget(key, fields);
+ return client.getBinaryMultiBulkReply();
+ }
+
+ /**
+ * Increment the number stored at field in the hash at key by value. If key
+ * does not exist, a new key holding a hash is created. If field does not
+ * exist or holds a string, the value is set to 0 before applying the
+ * operation. Since the value argument is signed you can use this command to
+ * perform both increments and decrements.
+ *
+ * The range of values supported by HINCRBY is limited to 64 bit signed
+ * integers.
+ *
+ * Time complexity: O(1)
+ *
+ * @param key
+ * @param field
+ * @param value
+ * @return Integer reply The new value at field after the increment
+ * operation.
+ */
+ public Integer hincrBy(final byte[] key, final byte[] field, final int value) {
+ checkIsInMulti();
+ client.hincrBy(key, field, value);
+ return client.getIntegerReply();
+ }
+
+ /**
+ * Test for existence of a specified field in a hash.
+ *
+ * Time complexity: O(1)
+ *
+ * @param key
+ * @param field
+ * @return Return 1 if the hash stored at key contains the specified field.
+ * Return 0 if the key is not found or the field is not present.
+ */
+ public Integer hexists(final byte[] key, final byte[] field) {
+ checkIsInMulti();
+ client.hexists(key, field);
+ return client.getIntegerReply();
+ }
+
+ /**
+ * Remove the specified field from an hash stored at key.
+ *
+ * Time complexity: O(1)
+ *
+ * @param key
+ * @param field
+ * @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 Integer hdel(final byte[] key, final byte[] field) {
+ checkIsInMulti();
+ client.hdel(key, field);
+ return client.getIntegerReply();
+ }
+
+ /**
+ * Return the number of items in a hash.
+ *
+ * Time complexity: O(1)
+ *
+ * @param key
+ * @return The number of entries (fields) contained in the hash stored at
+ * key. If the specified key does not exist, 0 is returned assuming
+ * an empty hash.
+ */
+ public Integer hlen(final byte[] key) {
+ checkIsInMulti();
+ client.hlen(key);
+ return client.getIntegerReply();
+ }
+
+ /**
+ * Return all the fields in a hash.
+ *
+ * Time complexity: O(N), where N is the total number of entries
+ *
+ * @param key
+ * @return All the fields names contained into a hash.
+ */
+ public Set hkeys(final byte[] key) {
+ checkIsInMulti();
+ client.hkeys(key);
+ final List lresult = client.getBinaryMultiBulkReply();
+ return new LinkedHashSet(lresult);
+ }
+
+ /**
+ * Return all the values in a hash.
+ *
+ * Time complexity: O(N), where N is the total number of entries
+ *
+ * @param key
+ * @return All the fields values contained into a hash.
+ */
+ public List hvals(final byte[] key) {
+ checkIsInMulti();
+ client.hvals(key);
+ final List lresult = client.getBinaryMultiBulkReply();
+ return lresult;
+ }
+
+ /**
+ * Return all the fields and associated values in a hash.
+ *
+ * Time complexity: O(N), where N is the total number of entries
+ *
+ * @param key
+ * @return All the fields and values contained into a hash.
+ */
+ public Map hgetAll(final byte[] key) {
+ checkIsInMulti();
+ client.hgetAll(key);
+ final List flatHash = client.getBinaryMultiBulkReply();
+ final Map hash = new JedisByteHashMap();
+ final Iterator iterator = flatHash.iterator();
+ while (iterator.hasNext()) {
+ hash.put(iterator.next(), iterator.next());
+ }
+
+ return hash;
+ }
+
+ /**
+ * Add the string value to the head (LPUSH) or tail (RPUSH) of the list
+ * stored at key. If the key does not exist an empty list is created just
+ * before the append operation. If the key exists but is not a List an error
+ * is returned.
+ *
+ * Time complexity: O(1)
+ *
+ * @see BinaryJedis#lpush(String, String)
+ *
+ * @param key
+ * @param string
+ * @return Integer reply, specifically, the number of elements inside the
+ * list after the push operation.
+ */
+ public Integer rpush(final byte[] key, final byte[] string) {
+ checkIsInMulti();
+ client.rpush(key, string);
+ return client.getIntegerReply();
+ }
+
+ /**
+ * Add the string value to the head (LPUSH) or tail (RPUSH) of the list
+ * stored at key. If the key does not exist an empty list is created just
+ * before the append operation. If the key exists but is not a List an error
+ * is returned.
+ *
+ * Time complexity: O(1)
+ *
+ * @see BinaryJedis#rpush(String, String)
+ *
+ * @param key
+ * @param string
+ * @return Integer reply, specifically, the number of elements inside the
+ * list after the push operation.
+ */
+ public Integer lpush(final byte[] key, final byte[] string) {
+ checkIsInMulti();
+ client.lpush(key, string);
+ return client.getIntegerReply();
+ }
+
+ /**
+ * Return the length of the list stored at the specified key. If the key
+ * does not exist zero is returned (the same behaviour as for empty lists).
+ * If the value stored at key is not a list an error is returned.
+ *
+ * Time complexity: O(1)
+ *
+ * @param key
+ * @return The length of the list.
+ */
+ public Integer llen(final byte[] key) {
+ checkIsInMulti();
+ client.llen(key);
+ return client.getIntegerReply();
+ }
+
+ /**
+ * Return the specified elements of the list stored at the specified key.
+ * Start and end are zero-based indexes. 0 is the first element of the list
+ * (the list head), 1 the next element and so on.
+ *
+ * For example LRANGE foobar 0 2 will return the first three elements of the
+ * list.
+ *
+ * start and end can also be negative numbers indicating offsets from the
+ * end of the list. For example -1 is the last element of the list, -2 the
+ * penultimate element and so on.
+ *
+ * Consistency with range functions in various programming languages
+ *
+ * Note that if you have a list of numbers from 0 to 100, LRANGE 0 10 will
+ * return 11 elements, that is, rightmost item is included. This may or may
+ * not be consistent with behavior of range-related functions in your
+ * programming language of choice (think Ruby's Range.new, Array#slice or
+ * Python's range() function).
+ *
+ * LRANGE behavior is consistent with one of Tcl.
+ *
+ * Out-of-range indexes
+ *
+ * Indexes out of range will not produce an error: if start is over the end
+ * of the list, or start > end, an empty list is returned. If end is over
+ * the end of the list Redis will threat it just like the last element of
+ * the list.
+ *
+ * Time complexity: O(start+n) (with n being the length of the range and
+ * start being the start offset)
+ *
+ * @param key
+ * @param start
+ * @param end
+ * @return Multi bulk reply, specifically a list of elements in the
+ * specified range.
+ */
+ public List lrange(final byte[] key, final int start, final int end) {
+ checkIsInMulti();
+ client.lrange(key, start, end);
+ return client.getBinaryMultiBulkReply();
+ }
+
+ /**
+ * Trim an existing list so that it will contain only the specified range of
+ * elements specified. Start and end are zero-based indexes. 0 is the first
+ * element of the list (the list head), 1 the next element and so on.
+ *
+ * For example LTRIM foobar 0 2 will modify the list stored at foobar key so
+ * that only the first three elements of the list will remain.
+ *
+ * start and end can also be negative numbers indicating offsets from the
+ * end of the list. For example -1 is the last element of the list, -2 the
+ * penultimate element and so on.
+ *
+ * Indexes out of range will not produce an error: if start is over the end
+ * of the list, or start > end, an empty list is left as value. If end over
+ * the end of the list Redis will threat it just like the last element of
+ * the list.
+ *
+ * Hint: the obvious use of LTRIM is together with LPUSH/RPUSH. For example:
+ *
+ * The above two commands will push elements in the list taking care that
+ * the list will not grow without limits. This is very useful when using
+ * Redis to store logs for example. It is important to note that when used
+ * in this way LTRIM is an O(1) operation because in the average case just
+ * one element is removed from the tail of the list.
+ *
+ * Time complexity: O(n) (with n being len of list - len of range)
+ *
+ * @param key
+ * @param start
+ * @param end
+ * @return Status code reply
+ */
+ public String ltrim(final byte[] key, final int start, final int end) {
+ checkIsInMulti();
+ client.ltrim(key, start, end);
+ return client.getStatusCodeReply();
+ }
+
+ /**
+ * Return the specified element of the list stored at the specified key. 0
+ * is the first element, 1 the second and so on. Negative indexes are
+ * supported, for example -1 is the last element, -2 the penultimate and so
+ * on.
+ *
+ * If the value stored at key is not of list type an error is returned. If
+ * the index is out of range a 'nil' reply is returned.
+ *
+ * Note that even if the average time complexity is O(n) asking for the
+ * first or the last element of the list is O(1).
+ *
+ * Time complexity: O(n) (with n being the length of the list)
+ *
+ * @param key
+ * @param index
+ * @return Bulk reply, specifically the requested element
+ */
+ public byte[] lindex(final byte[] key, final int index) {
+ checkIsInMulti();
+ client.lindex(key, index);
+ return client.getBinaryBulkReply();
+ }
+
+ /**
+ * Set a new value as the element at index position of the List at key.
+ *
+ * Out of range indexes will generate an error.
+ *
+ * Similarly to other list commands accepting indexes, the index can be
+ * negative to access elements starting from the end of the list. So -1 is
+ * the last element, -2 is the penultimate, and so forth.
+ *
+ * Time complexity:
+ *
+ * O(N) (with N being the length of the list), setting the first or last
+ * elements of the list is O(1).
+ *
+ * @see #lindex(String, int)
+ *
+ * @param key
+ * @param index
+ * @param value
+ * @return Status code reply
+ */
+ public String lset(final byte[] key, final int index, final byte[] value) {
+ checkIsInMulti();
+ client.lset(key, index, value);
+ return client.getStatusCodeReply();
+ }
+
+ /**
+ * Remove the first count occurrences of the value element from the list. If
+ * count is zero all the elements are removed. If count is negative elements
+ * are removed from tail to head, instead to go from head to tail that is
+ * the normal behaviour. So for example LREM with count -2 and hello as
+ * value to remove against the list (a,b,c,hello,x,hello,hello) will lave
+ * the list (a,b,c,hello,x). The number of removed elements is returned as
+ * an integer, see below for more information about the returned value. Note
+ * that non existing keys are considered like empty lists by LREM, so LREM
+ * against non existing keys will always return 0.
+ *
+ * Time complexity: O(N) (with N being the length of the list)
+ *
+ * @param key
+ * @param count
+ * @param value
+ * @return Integer Reply, specifically: The number of removed elements if
+ * the operation succeeded
+ */
+ public Integer lrem(final byte[] key, final int count, final byte[] value) {
+ checkIsInMulti();
+ client.lrem(key, count, value);
+ return client.getIntegerReply();
+ }
+
+ /**
+ * Atomically return and remove the first (LPOP) or last (RPOP) element of
+ * the list. For example if the list contains the elements "a","b","c" LPOP
+ * will return "a" and the list will become "b","c".
+ *
+ * If the key does not exist or the list is already empty the special value
+ * 'nil' is returned.
+ *
+ * @see #rpop(String)
+ *
+ * @param key
+ * @return Bulk reply
+ */
+ public byte[] lpop(final byte[] key) {
+ checkIsInMulti();
+ client.lpop(key);
+ return client.getBinaryBulkReply();
+ }
+
+ /**
+ * Atomically return and remove the first (LPOP) or last (RPOP) element of
+ * the list. For example if the list contains the elements "a","b","c" LPOP
+ * will return "a" and the list will become "b","c".
+ *
+ * If the key does not exist or the list is already empty the special value
+ * 'nil' is returned.
+ *
+ * @see #lpop(String)
+ *
+ * @param key
+ * @return Bulk reply
+ */
+ public byte[] rpop(final byte[] key) {
+ checkIsInMulti();
+ client.rpop(key);
+ return client.getBinaryBulkReply();
+ }
+
+ /**
+ * Atomically return and remove the last (tail) element of the srckey list,
+ * and push the element as the first (head) element of the dstkey list. For
+ * example if the source list contains the elements "a","b","c" and the
+ * destination list contains the elements "foo","bar" after an RPOPLPUSH
+ * command the content of the two lists will be "a","b" and "c","foo","bar".
+ *
+ * If the key does not exist or the list is already empty the special value
+ * 'nil' is returned. If the srckey and dstkey are the same the operation is
+ * equivalent to removing the last element from the list and pusing it as
+ * first element of the list, so it's a "list rotation" command.
+ *
+ * Time complexity: O(1)
+ *
+ * @param srckey
+ * @param dstkey
+ * @return Bulk reply
+ */
+ public byte[] rpoplpush(final byte[] srckey, final byte[] dstkey) {
+ checkIsInMulti();
+ client.rpoplpush(srckey, dstkey);
+ return client.getBinaryBulkReply();
+ }
+
+ /**
+ * Add the specified member to the set value stored at key. If member is
+ * already a member of the set no operation is performed. If key does not
+ * exist a new set with the specified member as sole member is created. If
+ * the key exists but does not hold a set value an error is returned.
+ *
+ * Time complexity O(1)
+ *
+ * @param key
+ * @param member
+ * @return Integer reply, specifically: 1 if the new element was added 0 if
+ * the element was already a member of the set
+ */
+ public Integer sadd(final byte[] key, final byte[] member) {
+ checkIsInMulti();
+ client.sadd(key, member);
+ return client.getIntegerReply();
+ }
+
+ /**
+ * Return all the members (elements) of the set value stored at key. This is
+ * just syntax glue for {@link #sinter(String...) SINTER}.
+ *
+ * Time complexity O(N)
+ *
+ * @param key
+ * @return Multi bulk reply
+ */
+ public Set smembers(final byte[] key) {
+ checkIsInMulti();
+ client.smembers(key);
+ final List members = client.getBinaryMultiBulkReply();
+ return new LinkedHashSet(members);
+ }
+
+ /**
+ * Remove the specified member from the set value stored at key. If member
+ * was not a member of the set no operation is performed. If key does not
+ * hold a set value an error is returned.
+ *
+ * Time complexity O(1)
+ *
+ * @param key
+ * @param member
+ * @return Integer reply, specifically: 1 if the new element was removed 0
+ * if the new element was not a member of the set
+ */
+ public Integer srem(final byte[] key, final byte[] member) {
+ checkIsInMulti();
+ client.srem(key, member);
+ return client.getIntegerReply();
+ }
+
+ /**
+ * Remove a random element from a Set returning it as return value. If the
+ * Set is empty or the key does not exist, a nil object is returned.
+ *
+ * The {@link #srandmember(String)} command does a similar work but the
+ * returned element is not removed from the Set.
+ *
+ * Time complexity O(1)
+ *
+ * @param key
+ * @return Bulk reply
+ */
+ public byte[] spop(final byte[] key) {
+ checkIsInMulti();
+ client.spop(key);
+ return client.getBinaryBulkReply();
+ }
+
+ /**
+ * Move the specifided member from the set at srckey to the set at dstkey.
+ * This operation is atomic, in every given moment the element will appear
+ * to be in the source or destination set for accessing clients.
+ *
+ * If the source set does not exist or does not contain the specified
+ * element no operation is performed and zero is returned, otherwise the
+ * element is removed from the source set and added to the destination set.
+ * On success one is returned, even if the element was already present in
+ * the destination set.
+ *
+ * An error is raised if the source or destination keys contain a non Set
+ * value.
+ *
+ * Time complexity O(1)
+ *
+ * @param srckey
+ * @param dstkey
+ * @param member
+ * @return Integer reply, specifically: 1 if the element was moved 0 if the
+ * element was not found on the first set and no operation was
+ * performed
+ */
+ public Integer smove(final byte[] srckey, final byte[] dstkey,
+ final byte[] member) {
+ checkIsInMulti();
+ client.smove(srckey, dstkey, member);
+ return client.getIntegerReply();
+ }
+
+ /**
+ * Return the set cardinality (number of elements). If the key does not
+ * exist 0 is returned, like for empty sets.
+ *
+ * @param key
+ * @return Integer reply, specifically: the cardinality (number of elements)
+ * of the set as an integer.
+ */
+ public Integer scard(final byte[] key) {
+ checkIsInMulti();
+ client.scard(key);
+ return client.getIntegerReply();
+ }
+
+ /**
+ * Return 1 if member is a member of the set stored at key, otherwise 0 is
+ * returned.
+ *
+ * Time complexity O(1)
+ *
+ * @param key
+ * @param member
+ * @return Integer reply, specifically: 1 if the element is a member of the
+ * set 0 if the element is not a member of the set OR if the key
+ * does not exist
+ */
+ public Integer sismember(final byte[] key, final byte[] member) {
+ checkIsInMulti();
+ client.sismember(key, member);
+ return client.getIntegerReply();
+ }
+
+ /**
+ * Return the members of a set resulting from the intersection of all the
+ * sets hold at the specified keys. Like in
+ * {@link #lrange(String, int, int) LRANGE} the result is sent to the client
+ * as a multi-bulk reply (see the protocol specification for more
+ * information). If just a single key is specified, then this command
+ * produces the same result as {@link #smembers(String) SMEMBERS}. Actually
+ * SMEMBERS is just syntax sugar for SINTER.
+ *
+ * Non existing keys are considered like empty sets, so if one of the keys
+ * is missing an empty set is returned (since the intersection with an empty
+ * set always is an empty set).
+ *
+ * Time complexity O(N*M) worst case where N is the cardinality of the
+ * smallest set and M the number of sets
+ *
+ * @param keys
+ * @return Multi bulk reply, specifically the list of common elements.
+ */
+ public Set sinter(final byte[]... keys) {
+ checkIsInMulti();
+ client.sinter(keys);
+ final List members = client.getBinaryMultiBulkReply();
+ return new LinkedHashSet(members);
+ }
+
+ /**
+ * This commnad works exactly like {@link #sinter(String...) SINTER} but
+ * instead of being returned the resulting set is sotred as dstkey.
+ *
+ * Time complexity O(N*M) worst case where N is the cardinality of the
+ * smallest set and M the number of sets
+ *
+ * @param dstkey
+ * @param keys
+ * @return Status code reply
+ */
+ public Integer sinterstore(final byte[] dstkey, final byte[]... keys) {
+ checkIsInMulti();
+ client.sinterstore(dstkey, keys);
+ return client.getIntegerReply();
+ }
+
+ /**
+ * Return the members of a set resulting from the union of all the sets hold
+ * at the specified keys. Like in {@link #lrange(String, int, int) LRANGE}
+ * the result is sent to the client as a multi-bulk reply (see the protocol
+ * specification for more information). If just a single key is specified,
+ * then this command produces the same result as {@link #smembers(String)
+ * SMEMBERS}.
+ *
+ * Non existing keys are considered like empty sets.
+ *
+ * Time complexity O(N) where N is the total number of elements in all the
+ * provided sets
+ *
+ * @param keys
+ * @return Multi bulk reply, specifically the list of common elements.
+ */
+ public Set sunion(final byte[]... keys) {
+ checkIsInMulti();
+ client.sunion(keys);
+ final List members = client.getBinaryMultiBulkReply();
+ return new LinkedHashSet(members);
+ }
+
+ /**
+ * This command works exactly like {@link #sunion(String...) SUNION} but
+ * instead of being returned the resulting set is stored as dstkey. Any
+ * existing value in dstkey will be over-written.
+ *
+ * Time complexity O(N) where N is the total number of elements in all the
+ * provided sets
+ *
+ * @param dstkey
+ * @param keys
+ * @return Status code reply
+ */
+ public Integer sunionstore(final byte[] dstkey, final byte[]... keys) {
+ checkIsInMulti();
+ client.sunionstore(dstkey, keys);
+ return client.getIntegerReply();
+ }
+
+ /**
+ * Return the difference between the Set stored at key1 and all the Sets
+ * key2, ..., keyN
+ *
+ *
+ * Non existing keys are considered like empty sets.
+ *
+ * Time complexity:
+ *
+ * O(N) with N being the total number of elements of all the sets
+ *
+ * @param keys
+ * @return Return the members of a set resulting from the difference between
+ * the first set provided and all the successive sets.
+ */
+ public Set sdiff(final byte[]... keys) {
+ checkIsInMulti();
+ client.sdiff(keys);
+ final List members = client.getBinaryMultiBulkReply();
+ return new LinkedHashSet(members);
+ }
+
+ /**
+ * This command works exactly like {@link #sdiff(String...) SDIFF} but
+ * instead of being returned the resulting set is stored in dstkey.
+ *
+ * @param dstkey
+ * @param keys
+ * @return Status code reply
+ */
+ public Integer sdiffstore(final byte[] dstkey, final byte[]... keys) {
+ checkIsInMulti();
+ client.sdiffstore(dstkey, keys);
+ return client.getIntegerReply();
+ }
+
+ /**
+ * Return a random element from a Set, without removing the element. If the
+ * Set is empty or the key does not exist, a nil object is returned.
+ *
+ * The SPOP command does a similar work but the returned element is popped
+ * (removed) from the Set.
+ *
+ * Time complexity O(1)
+ *
+ * @param key
+ * @return Bulk reply
+ */
+ public byte[] srandmember(final byte[] key) {
+ checkIsInMulti();
+ client.srandmember(key);
+ return client.getBinaryBulkReply();
+ }
+
+ /**
+ * Add the specified member having the specifeid score to the sorted set
+ * stored at key. If member is already a member of the sorted set the score
+ * is updated, and the element reinserted in the right position to ensure
+ * sorting. If key does not exist a new sorted set with the specified member
+ * as sole member is crated. If the key exists but does not hold a sorted
+ * set value an error is returned.
+ *
+ * The score value can be the string representation of a double precision
+ * floating point number.
+ *
+ * Time complexity O(log(N)) with N being the number of elements in the
+ * sorted set
+ *
+ * @param key
+ * @param score
+ * @param member
+ * @return Integer reply, specifically: 1 if the new element was added 0 if
+ * the element was already a member of the sorted set and the score
+ * was updated
+ */
+ public Integer zadd(final byte[] key, final double score,
+ final byte[] member) {
+ checkIsInMulti();
+ client.zadd(key, score, member);
+ return client.getIntegerReply();
+ }
+
+ public Set zrange(final byte[] key, final int start, final int end) {
+ checkIsInMulti();
+ client.zrange(key, start, end);
+ final List members = client.getBinaryMultiBulkReply();
+ return new LinkedHashSet(members);
+ }
+
+ /**
+ * Remove the specified member from the sorted set value stored at key. If
+ * member was not a member of the set no operation is performed. If key does
+ * not not hold a set value an error is returned.
+ *
+ * Time complexity O(log(N)) with N being the number of elements in the
+ * sorted set
+ *
+ *
+ *
+ * @param key
+ * @param member
+ * @return Integer reply, specifically: 1 if the new element was removed 0
+ * if the new element was not a member of the set
+ */
+ public Integer zrem(final byte[] key, final byte[] member) {
+ checkIsInMulti();
+ client.zrem(key, member);
+ return client.getIntegerReply();
+ }
+
+ /**
+ * If member already exists in the sorted set adds the increment to its
+ * score and updates the position of the element in the sorted set
+ * accordingly. If member does not already exist in the sorted set it is
+ * added with increment as score (that is, like if the previous score was
+ * virtually zero). If key does not exist a new sorted set with the
+ * specified member as sole member is crated. If the key exists but does not
+ * hold a sorted set value an error is returned.
+ *
+ * The score value can be the string representation of a double precision
+ * floating point number. It's possible to provide a negative value to
+ * perform a decrement.
+ *
+ * For an introduction to sorted sets check the Introduction to Redis data
+ * types page.
+ *
+ * Time complexity O(log(N)) with N being the number of elements in the
+ * sorted set
+ *
+ * @param key
+ * @param score
+ * @param member
+ * @return The new score
+ */
+ public Double zincrby(final byte[] key, final double score,
+ final byte[] member) {
+ checkIsInMulti();
+ client.zincrby(key, score, member);
+ String newscore = client.getBulkReply();
+ return Double.valueOf(newscore);
+ }
+
+ /**
+ * Return the rank (or index) or member in the sorted set at key, with
+ * scores being ordered from low to high.
+ *
+ * When the given member does not exist in the sorted set, the special value
+ * 'nil' is returned. The returned rank (or index) of the member is 0-based
+ * for both commands.
+ *
+ * Time complexity:
+ *
+ * O(log(N))
+ *
+ * @see #zrevrank(String, String)
+ *
+ * @param key
+ * @param member
+ * @return Integer reply or a nil bulk reply, specifically: the rank of the
+ * element as an integer reply if the element exists. A nil bulk
+ * reply if there is no such element.
+ */
+ public Integer zrank(final byte[] key, final byte[] member) {
+ checkIsInMulti();
+ client.zrank(key, member);
+ return client.getIntegerReply();
+ }
+
+ /**
+ * Return the rank (or index) or member in the sorted set at key, with
+ * scores being ordered from high to low.
+ *
+ * When the given member does not exist in the sorted set, the special value
+ * 'nil' is returned. The returned rank (or index) of the member is 0-based
+ * for both commands.
+ *
+ * Time complexity:
+ *
+ * O(log(N))
+ *
+ * @see #zrank(String, String)
+ *
+ * @param key
+ * @param member
+ * @return Integer reply or a nil bulk reply, specifically: the rank of the
+ * element as an integer reply if the element exists. A nil bulk
+ * reply if there is no such element.
+ */
+ public Integer zrevrank(final byte[] key, final byte[] member) {
+ checkIsInMulti();
+ client.zrevrank(key, member);
+ return client.getIntegerReply();
+ }
+
+ public Set zrevrange(final byte[] key, final int start,
+ final int end) {
+ checkIsInMulti();
+ client.zrevrange(key, start, end);
+ final List members = client.getBinaryMultiBulkReply();
+ return new LinkedHashSet(members);
+ }
+
+ public Set zrangeWithScores(final byte[] key, final int start,
+ final int end) {
+ checkIsInMulti();
+ client.zrangeWithScores(key, start, end);
+ Set set = getBinaryTupledSet();
+ return set;
+ }
+
+ public Set zrevrangeWithScores(final byte[] key, final int start,
+ final int end) {
+ checkIsInMulti();
+ client.zrevrangeWithScores(key, start, end);
+ Set set = getBinaryTupledSet();
+ return set;
+ }
+
+ /**
+ * Return the sorted set cardinality (number of elements). If the key does
+ * not exist 0 is returned, like for empty sorted sets.
+ *
+ * Time complexity O(1)
+ *
+ * @param key
+ * @return the cardinality (number of elements) of the set as an integer.
+ */
+ public Integer zcard(final byte[] key) {
+ checkIsInMulti();
+ client.zcard(key);
+ return client.getIntegerReply();
+ }
+
+ /**
+ * Return the score of the specified element of the sorted set at key. If
+ * the specified element does not exist in the sorted set, or the key does
+ * not exist at all, a special 'nil' value is returned.
+ *
+ * Time complexity: O(1)
+ *
+ * @param key
+ * @param member
+ * @return the score
+ */
+ public Double zscore(final byte[] key, final byte[] member) {
+ checkIsInMulti();
+ client.zscore(key, member);
+ final String score = client.getBulkReply();
+ return (score != null ? new Double(score) : null);
+ }
+
+ public Transaction multi() {
+ client.multi();
+ client.getStatusCodeReply();
+ return new Transaction(client);
+ }
+
+ public List