java.lang.Object

com.blackrook.redis.RedisPipeline

All Implemented Interfaces:: RedisDeferredCommands

public class RedisPipeline extends Object implements RedisDeferredCommands

A Redis Pipeline, created from a Redis Connection. Each call in this object queues the command and sends them all at once when completed.

Author:: Matthew Tropiano

Method Summary

Modifier and Type

Method

Description

void

append(String key, String value)

From http://redis.io/commands/append:

void

bitcount(String key)

From http://redis.io/commands/bitcount:

void

bitcount(String key, long start, long end)

From http://redis.io/commands/bitcount:

void

bitop(BitwiseOperation operation, String destkey, String key, String... keys)

From http://redis.io/commands/bitop:

void

bitpos(String key, long bit)

From http://redis.io/commands/bitpos:

void

bitpos(String key, long bit, Long start, Long end)

From http://redis.io/commands/bitpos:

void

blpop(long timeout, String key, String... keys)

From http://redis.io/commands/blpop:

void

brpop(long timeout, String key, String... keys)

From http://redis.io/commands/brpop:

void

brpoplpush(long timeout, String source, String destination)

From http://redis.io/commands/brpoplpush:

void

decr(String key)

From http://redis.io/commands/decr:

void

decrby(String key, long decrement)

From http://redis.io/commands/decrby:

void

del(String key, String... keys)

From http://redis.io/commands/del:

void

dump(String key)

From http://redis.io/commands/dump:

void

echo(String message)

From http://redis.io/commands/echo:

void

eval(String scriptContent, String[] keys, Object... args)

From http://redis.io/commands/eval:

void

evalsha(String hash, String[] keys, Object... args)

From http://redis.io/commands/evalsha:

void

exists(String key)

From http://redis.io/commands/exists:

void

expire(String key, long seconds)

From http://redis.io/commands/expire:

void

expireat(String key, long timestamp)

From http://redis.io/commands/expireat:

RedisObject[]

finish()

Send all pending commands in the pipeline and returns all of their return values.

void

get(String key)

From http://redis.io/commands/get:

void

getbit(String key, long offset)

From http://redis.io/commands/getbit:

void

getrange(String key, long start, long end)

From http://redis.io/commands/getrange:

void

getset(String key, Number value)

From http://redis.io/commands/getset:

void

getset(String key, String value)

From http://redis.io/commands/getset:

void

hdel(String key, String field, String... fields)

From http://redis.io/commands/hdel:

void

hexists(String key, String field)

From http://redis.io/commands/hexists:

void

hget(String key, String field)

From http://redis.io/commands/hget:

void

hgetall(String key)

From http://redis.io/commands/hgetall:

void

hincrby(String key, String field, long increment)

From http://redis.io/commands/hincrby:

void

hincrbyfloat(String key, String field, double increment)

From http://redis.io/commands/hincrbyfloat:

void

hkeys(String key)

From http://redis.io/commands/hkeys:

void

hlen(String key)

From http://redis.io/commands/hlen:

void

hmget(String key, String field, String... fields)

From http://redis.io/commands/hmget:

void

hmset(String key, KeyValue<String,Object>... pairs)

From http://redis.io/commands/hmset:

void

hmset(String key, Object field, Object value, Object... fieldvalues)

From http://redis.io/commands/hmset:

void

hmset(String key, String field, String value, String... fieldvalues)

From http://redis.io/commands/hmset:

void

hset(String key, String field, Number value)

From http://redis.io/commands/hset:

void

hset(String key, String field, String value)

From http://redis.io/commands/hset:

void

hsetnx(String key, String field, Number value)

From http://redis.io/commands/hsetnx:

void

hsetnx(String key, String field, String value)

From http://redis.io/commands/hsetnx:

void

hvals(String key)

From http://redis.io/commands/hvals:

void

incr(String key)

From http://redis.io/commands/incr:

void

incrby(String key, long increment)

From http://redis.io/commands/incrby:

void

incrbyfloat(String key, double increment)

From http://redis.io/commands/incrbyfloat:

void

keys(String pattern)

From http://redis.io/commands/keys:

void

lindex(String key, long index)

From http://redis.io/commands/lindex:

void

linsert(String key, boolean before, String pivot, Number value)

From http://redis.io/commands/linsert:

void

linsert(String key, boolean before, String pivot, String value)

From http://redis.io/commands/linsert:

void

llen(String key)

From http://redis.io/commands/llen:

void

lpop(String key)

From http://redis.io/commands/lpop:

void

lpush(String key, String value, String... values)

From http://redis.io/commands/lpush:

void

lpushx(String key, String value)

From http://redis.io/commands/lpushx:

void

lrange(String key, long start, long stop)

From http://redis.io/commands/lrange:

void

lrem(String key, long count, String value)

From http://redis.io/commands/lrem:

void

lset(String key, long index, String value)

From http://redis.io/commands/lset:

void

ltrim(String key, long start, long stop)

From http://redis.io/commands/ltrim:

void

mget(String key, String... keys)

From http://redis.io/commands/mget:

void

move(String key, long db)

From http://redis.io/commands/move:

void

mset(KeyValue<String,Object>... pairs)

Like RedisDeferredCommands.mset(String, String, String...), but takes key-value pairs.

void

mset(String key, String value, String... keyValues)

From http://redis.io/commands/mset:

void

msetnx(KeyValue<String,Object>... pairs)

Like RedisDeferredCommands.msetnx(String, String, String...), but takes key-value pairs.

void

msetnx(String key, String value, String... keyValues)

From http://redis.io/commands/msetnx:

void

persist(String key)

From http://redis.io/commands/persist:

void

pexpire(String key, long milliseconds)

From http://redis.io/commands/pexpire:

void

pexpireat(String key, long timestamp)

From http://redis.io/commands/pexpireat:

void

psetex(String key, long milliseconds, String value)

From http://redis.io/commands/psetex:

void

pttl(String key)

From http://redis.io/commands/pttl:

void

publish(String channel, String message)

From http://redis.io/commands/publish:

void

randomkey()

From http://redis.io/commands/randomkey:

void

rename(String key, String newkey)

From http://redis.io/commands/rename:

void

renamenx(String key, String newkey)

From http://redis.io/commands/renamenx:

void

restore(String key, long ttl, String serializedvalue)

From http://redis.io/commands/restore:

void

rpop(String key)

From http://redis.io/commands/rpop:

void

rpoplpush(String source, String destination)

From http://redis.io/commands/rpoplpush:

void

rpush(String key, String value, String... values)

From http://redis.io/commands/rpush:

void

rpushx(String key, String value)

From http://redis.io/commands/rpushx:

void

sadd(String key, Object member, Object... members)

From http://redis.io/commands/sadd:

void

sadd(String key, String member, String... members)

From http://redis.io/commands/sadd:

void

scard(String key)

From http://redis.io/commands/scard:

void

scriptExists(String scriptHash, String... scriptHashes)

From http://redis.io/commands/script-exists:

void

scriptFlush()

From http://redis.io/commands/script-flush:

void

scriptKill(String hash)

From http://redis.io/commands/script-kill:

void

scriptLoad(File content)

From http://redis.io/commands/script-load:

void

scriptLoad(InputStream content)

From http://redis.io/commands/script-load:

void

scriptLoad(String content)

From http://redis.io/commands/script-load:

void

sdiff(String key, String... keys)

From http://redis.io/commands/sdiff:

void

sdiffstore(String destination, String key, String... keys)

From http://redis.io/commands/sdiffstore:

void

set(String key, Number value)

From http://redis.io/commands/set:

void

set(String key, String value)

From http://redis.io/commands/set:

void

setbit(String key, long offset, long value)

From http://redis.io/commands/setbit:

void

setex(String key, long seconds, String value)

From http://redis.io/commands/setex:

void

setnx(String key, String value)

From http://redis.io/commands/setnx:

void

setrange(String key, long offset, String value)

From http://redis.io/commands/setrange:

void

sinter(String key, String... keys)

From http://redis.io/commands/sinter:

void

sinterstore(String destination, String key, String... keys)

From http://redis.io/commands/sinterstore:

void

sismember(String key, Number member)

From http://redis.io/commands/sismember:

void

sismember(String key, String member)

From http://redis.io/commands/sismember:

void

smembers(String key)

From http://redis.io/commands/smembers:

void

smove(String source, String destination, String member)

From http://redis.io/commands/smove:

void

sort(String key, String pattern, SortOrder sortOrder, boolean alpha, Long limitOffset, Long limitCount, String storeKey, String... getPatterns)

From http://redis.io/commands/sort:

protected String

specialDouble(double d)

Converts some of Java's primitive doubles to Redis interval values.

void

spop(String key)

From http://redis.io/commands/spop:

void

srandmember(String key)

From http://redis.io/commands/srandmember:

void

srandmember(String key, long count)

From http://redis.io/commands/srandmember:

void

srem(String key, Object member, Object... members)

From http://redis.io/commands/srem:

void

srem(String key, String member, String... members)

From http://redis.io/commands/srem:

void

strlen(String key)

From http://redis.io/commands/strlen:

void

sunion(String key, String... keys)

From http://redis.io/commands/sunion:

void

sunionstore(String destination, String key, String... keys)

From http://redis.io/commands/sunionstore:

void

ttl(String key)

From http://redis.io/commands/ttl:

void

type(String key)

From http://redis.io/commands/type:

void

zadd(String key, double score, Number member)

From http://redis.io/commands/zadd:

void

zadd(String key, double score, String member)

From http://redis.io/commands/zadd:

void

zadd(String key, KeyValue<Double,String>... pairs)

From http://redis.io/commands/zadd:

void

zcard(String key)

From http://redis.io/commands/zcard:

void

zcount(String key, double min, double max)

Like zcount(String, String, String), except it accepts doubles for min and max, not strings.

void

zcount(String key, String min, String max)

From http://redis.io/commands/zcount:

void

zincrby(String key, double increment, String member)

From http://redis.io/commands/zincrby:

void

zinterstore(String destination, double[] weights, Aggregation aggregation, String key, String... keys)

From http://redis.io/commands/zinterstore:

void

zinterstore(String destination, double[] weights, String key, String... keys)

Like RedisDeferredCommands.zinterstore(String, double[], Aggregation, String, String...), except it does no aggregation of scores.

void

zinterstore(String destination, Aggregation aggregation, String key, String... keys)

Like RedisDeferredCommands.zinterstore(String, double[], Aggregation, String, String...), except no weights are applied to the source value scores.

void

zinterstore(String destination, String key, String... keys)

Like RedisDeferredCommands.zinterstore(String, double[], Aggregation, String, String...), except no weights are applied to the source value scores, and does no aggregation of scores.

void

zlexcount(String key, double min, double max)

Like RedisDeferredCommands.zlexcount(String, String, String), except it accepts doubles for min and max, not strings.

void

zlexcount(String key, String min, String max)

From http://redis.io/commands/zlexcount:

void

zrange(String key, long start, long stop, boolean withScores)

From http://redis.io/commands/zrange:

void

zrangebylex(String key, double min, double max)

Like zrangebylex(String, String, String), except it accepts doubles for min and max, not strings, with no limit.

void

zrangebylex(String key, double min, double max, Long limitOffset, Long limitCount)

Like zrangebylex(String, String, String, Long, Long), except it accepts doubles for min and max, not strings.

void

zrangebylex(String key, String min, String max)

Like zrangebylex(String, String, String, Long, Long), with no limit.

void

zrangebylex(String key, String min, String max, Long limitOffset, Long limitCount)

From http://redis.io/commands/zrangebylex:

void

zrangebyscore(String key, double min, double max, boolean withScores)

Like RedisDeferredCommands.zrangebyscore(String, String, String, boolean), except it accepts doubles for min and max, not strings.

void

zrangebyscore(String key, double min, double max, boolean withScores, Long limitOffset, Long limitCount)

Like RedisDeferredCommands.zrangebyscore(String, String, String, boolean, Long, Long), except it accepts doubles for min and max, not strings.

void

zrangebyscore(String key, String min, String max, boolean withScores)

Like RedisDeferredCommands.zrangebyscore(String, String, String, boolean, Long, Long), except specifies no limit.

void

zrangebyscore(String key, String min, String max, boolean withScores, Long limitOffset, Long limitCount)

From http://redis.io/commands/zrangebyscore:

void

zrank(String key, Number member)

From http://redis.io/commands/zrank:

void

zrank(String key, String member)

From http://redis.io/commands/zrank:

void

zrem(String key, Number member, Number... members)

From http://redis.io/commands/zrem:

void

zrem(String key, String member, String... members)

From http://redis.io/commands/zrem:

void

zremrangebylex(String key, double min, double max)

Like RedisDeferredCommands.zrangebylex(String, String, String), except it accepts doubles for min and max.

void

zremrangebylex(String key, String min, String max)

From http://redis.io/commands/zremrangebylex:

void

zremrangebyrank(String key, long start, long stop)

From http://redis.io/commands/zremrangebyrank:

void

zremrangebyscore(String key, double min, double max)

Like zremrangebyscore(String, String, String), except it accepts doubles for min and max, not strings.

void

zremrangebyscore(String key, String min, String max)

From http://redis.io/commands/zremrangebyscore:

void

zrevrange(String key, long start, long stop, boolean withScores)

From http://redis.io/commands/zrevrange:

void

zrevrangebyscore(String key, double min, double max, boolean withScores)

Like RedisDeferredCommands.zrevrangebyscore(String, String, String, boolean), except it accepts doubles for min and max, not strings.

void

zrevrangebyscore(String key, double min, double max, boolean withScores, Long limitOffset, Long limitCount)

Like RedisDeferredCommands.zrevrangebyscore(String, String, String, boolean, Long, Long), except it accepts doubles for min and max, not strings.

void

zrevrangebyscore(String key, String min, String max, boolean withScores)

Like RedisDeferredCommands.zrevrangebyscore(String, String, String, boolean, Long, Long), except specifies no limit.

void

zrevrangebyscore(String key, String min, String max, boolean withScores, Long limitOffset, Long limitCount)

From http://redis.io/commands/zrevrangebyscore:

void

zrevrank(String key, String member)

From http://redis.io/commands/zrevrank:

void

zscore(String key, String member)

From http://redis.io/commands/zscore:

void

zunionstore(String destination, double[] weights, Aggregation aggregation, String key, String... keys)

From http://redis.io/commands/zunionstore:

void

zunionstore(String destination, double[] weights, String key, String... keys)

Like RedisDeferredCommands.zunionstore(String, double[], Aggregation, String, String...), except it does no aggregation of scores.

void

zunionstore(String destination, Aggregation aggregation, String key, String... keys)

Like RedisDeferredCommands.zunionstore(String, double[], Aggregation, String, String...), except no weights are applied to the source value scores.

void

zunionstore(String destination, String key, String... keys)

Like RedisDeferredCommands.zunionstore(String, double[], Aggregation, String, String...), except no weights are applied to the source value scores, and does no aggregation of scores.

Methods inherited from class Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Details
- finish
  
  public RedisObject[] finish()
  
  Send all pending commands in the pipeline and returns all of their return values.
  
  Returns:
  
  an array of Redis objects whose contents are in the order of the commands issued.
- echo
  
  public void echo(String message)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/echo:
  Available since 1.0.0.
  
  Specified by:
  
  echo in interface RedisDeferredCommands
- del
  
  public void del(String key, String... keys)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/del:
  Available since 1.0.0.
  Time complexity: O(N) where N is the number of keys that will be removed. When a key to remove holds a value other than a string, the individual complexity for this key is O(M) where M is the number of elements in the list, set, sorted set or hash. Removing a single key that holds a string value is O(1).
  Removes the specified keys. A key is ignored if it does not exist.
  
  Specified by:
  
  del in interface RedisDeferredCommands
  
  Parameters:
  
  key - the first key to delete.
  
  keys - the additional keys to delete.
- dump
  
  public void dump(String key)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/dump:
  Available since 2.6.0.
  Time complexity: O(1) to access the key and additional O(N*M) to serialized it, where N is the number of Redis objects composing the value and M their average size. For small string values the time complexity is thus O(1)+O(1*M) where M is small, so simply O(1).
  Serialize the value stored at key in a Redis-specific format and return it to the user. The returned value can be synthesized back into a Redis key using the RedisDeferredCommands.restore(String, long, String) command.
  
  Specified by:
  
  dump in interface RedisDeferredCommands
- exists
  
  public void exists(String key)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/exists:
  Available since 1.0.0.
  Time complexity: O(1)
  Returns if key exists.
  
  Specified by:
  
  exists in interface RedisDeferredCommands
- expire
  
  public void expire(String key, long seconds)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/expire:
  Available since 1.0.0.
  Time complexity: O(1)
  Set a timeout on key. After the timeout has expired, the key will automatically be deleted. A key with an associated timeout is often said to be volatile in Redis terminology.
  
  Specified by:
  
  expire in interface RedisDeferredCommands
  
  Parameters:
  
  key - the key to expire.
  
  seconds - the time-to-live in seconds.
- expireat
  
  public void expireat(String key, long timestamp)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/expireat:
  Available since 1.2.0.
  Time complexity: O(1)
  expireat has the same effect and semantic as RedisDeferredCommands.expire(String, long), but instead of specifying the number of seconds representing the TTL (time to live), it takes an absolute Unix timestamp (seconds since January 1, 1970).
  
  Specified by:
  
  expireat in interface RedisDeferredCommands
  
  Parameters:
  
  key - the key to expire.
  
  timestamp - the timestamp in from-Epoch milliseconds.
- keys
  
  public void keys(String pattern)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/keys:
  Available since 1.0.0.
  Time complexity: O(N) with N being the number of keys in the database, under the assumption that the key names in the database and the given pattern have limited length.
  Returns all keys matching pattern.
  
  Specified by:
  
  keys in interface RedisDeferredCommands
  
  Parameters:
  
  pattern - a wildcard pattern for matching key names.
- move
  
  public void move(String key, long db)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/move:
  Available since 1.0.0.
  Time complexity: O(1)
  Move key from the currently selected database to the specified destination database. When key already exists in the destination database, or it does not exist in the source database, it does nothing. It is possible to use MOVE as a locking primitive because of this.
  
  Specified by:
  
  move in interface RedisDeferredCommands
  
  Parameters:
  
  key - the key to move.
  
  db - the target database.
- persist
  
  public void persist(String key)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/persist:
  Available since 2.2.0.
  Time complexity: O(1)
  Remove the existing timeout on key, turning the key from volatile (a key with an expire set) to persistent (a key that will never expire as no timeout is associated).
  
  Specified by:
  
  persist in interface RedisDeferredCommands
  
  Parameters:
  
  key - the key to persist (remove TTL).
- pexpire
  
  public void pexpire(String key, long milliseconds)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/pexpire:
  Available since 2.6.0.
  Time complexity: O(1)
  This command works exactly like RedisDeferredCommands.expire(String, long) but the time to live of the key is specified in milliseconds instead of seconds.
  
  Specified by:
  
  pexpire in interface RedisDeferredCommands
  
  Parameters:
  
  key - the key to expire.
  
  milliseconds - the time-to-live in milliseconds.
- pexpireat
  
  public void pexpireat(String key, long timestamp)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/pexpireat:
  Available since 2.6.0.
  Time complexity: O(1)
  PEXPIREAT has the same effect and semantic as RedisDeferredCommands.expireat(String, long), but the Unix time at which the key will expire is specified in milliseconds instead of seconds.
  
  Specified by:
  
  pexpireat in interface RedisDeferredCommands
  
  Parameters:
  
  key - the key to expire.
  
  timestamp - the timestamp in from-Epoch milliseconds.
- pttl
  
  public void pttl(String key)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/pttl:
  Available since 2.6.0.
  Time complexity: O(1)
  Like RedisDeferredCommands.ttl(String), this command returns the remaining time to live of a key that has an expire set, with the sole difference that TTL returns the amount of remaining time in seconds while PTTL returns it in milliseconds.
  
  Specified by:
  
  pttl in interface RedisDeferredCommands
  
  Parameters:
  
  key - the key to inspect.
- publish
  
  public void publish(String channel, String message)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/publish:
  Available since 2.0.0.
  Time complexity: O(N+M) where N is the number of clients subscribed to the receiving channel and M is the total number of subscribed patterns (by any client).
  Posts a message to the given channel.
  
  Specified by:
  
  publish in interface RedisDeferredCommands
- randomkey
  
  public void randomkey()
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/randomkey:
  Available since 1.0.0.
  Time complexity: O(1)
  Return a random key from the currently selected database.
  
  Specified by:
  
  randomkey in interface RedisDeferredCommands
- rename
  
  public void rename(String key, String newkey)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/rename:
  Available since 1.0.0.
  Time complexity: O(1)
  Renames key to newkey. It returns an error when the source and destination names are the same, or when key does not exist. If newkey already exists it is overwritten, when this happens RedisDeferredCommands.rename(String, String) executes an implicit RedisDeferredCommands.del(String, String...) operation, so if the deleted key contains a very big value it may cause high latency even if RedisDeferredCommands.rename(String, String) itself is usually a constant-time operation.
  
  Specified by:
  
  rename in interface RedisDeferredCommands
  
  Parameters:
  
  key - the old name.
  
  newkey - the new name.
- renamenx
  
  public void renamenx(String key, String newkey)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/renamenx:
  Available since 1.0.0.
  Time complexity: O(1)
  Renames key to newkey if newkey does not yet exist. It returns an error under the same conditions as RedisDeferredCommands.rename(String, String).
  
  Specified by:
  
  renamenx in interface RedisDeferredCommands
  
  Parameters:
  
  key - the old name.
  
  newkey - the new name.
- restore
  
  public void restore(String key, long ttl, String serializedvalue)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/restore:
  Available since 2.6.0.
  Time complexity: O(1) to create the new key and additional O(N*M) to recostruct the serialized value, where N is the number of Redis objects composing the value and M their average size. For small string values the time complexity is thus O(1)+O(1*M) where M is small, so simply O(1). However for sorted set values the complexity is O(N*M*log(N)) because inserting values into sorted sets is O(log(N)).
  Create a key associated with a value that is obtained by deserializing the provided serialized value (obtained via RedisDeferredCommands.dump(String)).
  
  Specified by:
  
  restore in interface RedisDeferredCommands
  
  Parameters:
  
  key - the key to restore.
  
  ttl - the time-to-live in milliseconds.
  
  serializedvalue - the serialized value (from a RedisDeferredCommands.dump(String) call).
- sort
  
  public void sort(String key, String pattern, SortOrder sortOrder, boolean alpha, Long limitOffset, Long limitCount, String storeKey, String... getPatterns)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/sort:
  Available since 1.0.0.
  Time complexity: O(N+M*log(M)) where N is the number of elements in the list or set to sort, and M the number of returned elements. When the elements are not sorted, complexity is currently O(N) as there is a copy step that will be avoided in next releases.
  Returns or stores the elements contained in the list, set, or sorted set at key. By default, sorting is numeric and elements are compared by their value interpreted as double precision floating point number.
  
  Specified by:
  
  sort in interface RedisDeferredCommands
  
  Parameters:
  
  key - the key to sort the contents of.
  
  pattern - if not null,
  
  sortOrder - if true, sort descending. if false or null, sort ascending.
  
  alpha - if true, sort lexicographically, not by a score.
  
  limitOffset - if not null, the starting offset into the list (0-based).
  
  limitCount - if not null, the amount of objects from the offset to sort. else, return all the way to the end.
  
  storeKey - if not null, this is the key to store the result in.
  
  getPatterns - the patterns for finding the sort score.
- ttl
  
  public void ttl(String key)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/ttl:
  Available since 1.0.0.
  Time complexity: O(1)
  Returns the remaining time to live of a key that has a timeout. This introspection capability allows a Redis client to check how many seconds a given key will continue to be part of the dataset.
  
  Specified by:
  
  ttl in interface RedisDeferredCommands
  
  Parameters:
  
  key - the key to inspect.
- type
  
  public void type(String key)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/type:
  Available since 1.0.0.
  Time complexity: O(1)
  Returns the string representation of the type of the value stored at key.
  
  Specified by:
  
  type in interface RedisDeferredCommands
- append
  
  public void append(String key, String value)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/append:
  Available since 2.0.0.
  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.
  If key already exists and is a string, this command appends the value at the end of the string. If key does not exist it is created and set as an empty string, so APPEND will be similar to SET in this special case.
  
  Specified by:
  
  append in interface RedisDeferredCommands
- bitcount
  
  public void bitcount(String key)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/bitcount:
  Available since 2.6.0.
  Time complexity: O(N)
  Count the number of set bits (population counting) in a string.
  
  Specified by:
  
  bitcount in interface RedisDeferredCommands
- bitcount
  
  public void bitcount(String key, long start, long end)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/bitcount:
  Available since 2.6.0.
  Time complexity: O(N)
  Count the number of set bits (population counting) in a string between a start and end bit.
  
  Specified by:
  
  bitcount in interface RedisDeferredCommands
- bitop
  
  public void bitop(BitwiseOperation operation, String destkey, String key, String... keys)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/bitop:
  Available since 2.6.0.
  Time complexity: O(N)
  Perform a bitwise operation between multiple keys (containing string values) and store the result in the destination key. equal to the size of the longest input string.
  
  Specified by:
  
  bitop in interface RedisDeferredCommands
- bitpos
  
  public void bitpos(String key, long bit)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/bitpos:
  Available since 2.8.7.
  Time complexity: O(N)
  Return the position of the first bit set to 1 or 0 in a string.
  
  Specified by:
  
  bitpos in interface RedisDeferredCommands
- bitpos
  
  public void bitpos(String key, long bit, Long start, Long end)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/bitpos:
  Available since 2.8.7.
  Time complexity: O(N)
  Return the position of the first bit set to 1 or 0 in a string.
  
  Specified by:
  
  bitpos in interface RedisDeferredCommands
- decr
  
  public void decr(String key)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/decr:
  Available since 1.0.0.
  Time complexity: O(1)
  Decrements the number stored at key by one. If the key does not exist, it is set to 0 before performing the operation. An error is returned if the key contains a value of the wrong type or contains a string that can not be represented as integer. This operation is limited to 64 bit signed integers.
  
  Specified by:
  
  decr in interface RedisDeferredCommands
- decrby
  
  public void decrby(String key, long decrement)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/decrby:
  Available since 1.0.0.
  Time complexity: O(1)
  Decrements the number stored at key by decrement. If the key does not exist, it is set to 0 before performing the operation. An error is returned if the key contains a value of the wrong type or contains a string that can not be represented as integer. This operation is limited to 64 bit signed integers.
  
  Specified by:
  
  decrby in interface RedisDeferredCommands
- get
  
  public void get(String key)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/get:
  Available since 1.0.0.
  Time complexity: O(1)
  Get the value of key. If the key does not exist the special value null is returned. An error is returned if the value stored at key is not a string, because GET only handles string values. does not exist.
  
  Specified by:
  
  get in interface RedisDeferredCommands
- getbit
  
  public void getbit(String key, long offset)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/getbit:
  Available since 2.2.0.
  Time complexity: O(1)
  Returns the bit value at offset in the string value stored at key.
  
  Specified by:
  
  getbit in interface RedisDeferredCommands
- getrange
  
  public void getrange(String key, long start, long end)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/getrange:
  Available since 2.4.0.
  Time complexity: O(N) where N is the length of the returned string. The complexity is ultimately determined by the returned length, but because creating a substring from an existing string is very cheap, it can be considered O(1) for small strings. it is called SUBSTR in Redis versions <= 2.0.
  
  Specified by:
  
  getrange in interface RedisDeferredCommands
- getset
  
  public void getset(String key, String value)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/getset:
  Available since 1.0.0.
  Time complexity: O(1)
  Atomically sets key to value and returns the old value stored at key. Returns an error when key exists but does not hold a string value.
  
  Specified by:
  
  getset in interface RedisDeferredCommands
- getset
  
  public void getset(String key, Number value)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/getset:
  Available since 1.0.0.
  Time complexity: O(1)
  Atomically sets key to value and returns the old value stored at key. Returns an error when key exists but does not hold a string value.
  
  Specified by:
  
  getset in interface RedisDeferredCommands
- incr
  
  public void incr(String key)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/incr:
  Available since 1.0.0.
  Time complexity: O(1)
  Increments the number stored at key by one. If the key does not exist, it is set to 0 before performing the operation. An error is returned if the key contains a value of the wrong type or contains a string that can not be represented as integer. This operation is limited to 64 bit signed integers.
  
  Specified by:
  
  incr in interface RedisDeferredCommands
- incrby
  
  public void incrby(String key, long increment)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/incrby:
  Available since 1.0.0.
  Time complexity: O(1)
  Increments the number stored at key by increment. If the key does not exist, it is set to 0 before performing the operation. An error is returned if the key contains a value of the wrong type or contains a string that can not be represented as integer. This operation is limited to 64 bit signed integers.
  
  Specified by:
  
  incrby in interface RedisDeferredCommands
- incrbyfloat
  
  public void incrbyfloat(String key, double increment)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/incrbyfloat:
  Available since 2.6.0.
  Time complexity: O(1)
  Increment the string representing a floating point number stored at key by the specified increment. If the key does not exist, it is set to 0 before performing the operation. An error is returned if one of the following conditions occur:
  
  Specified by:
  
  incrbyfloat in interface RedisDeferredCommands
- mget
  
  public void mget(String key, String... keys)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/mget:
  Available since 1.0.0.
  Time complexity: O(N) where N is the number of keys to retrieve.
  Returns the values of all specified keys. For every key that does not hold a string value or does not exist, the special value nil is returned. Because of this, the operation never fails.
  
  Specified by:
  
  mget in interface RedisDeferredCommands
- mset
  
  public void mset(String key, String value, String... keyValues)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/mset:
  Available since 1.0.1.
  Time complexity: O(N) where N is the number of keys to set.
  Sets the given keys to their respective values. MSET replaces existing values with new values, just as regular SET. See RedisDeferredCommands.msetnx(String, String, String...) if you don't want to overwrite existing values.
  
  Specified by:
  
  mset in interface RedisDeferredCommands
- mset
  
  public void mset(KeyValue<String,Object>... pairs)
  
  Description copied from interface: RedisDeferredCommands
  
  Like RedisDeferredCommands.mset(String, String, String...), but takes key-value pairs.
  
  Specified by:
  
  mset in interface RedisDeferredCommands
- msetnx
  
  public void msetnx(String key, String value, String... keyValues)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/msetnx:
  Available since 1.0.1.
  Time complexity: O(N) where N is the number of keys to set.
  Sets the given keys to their respective values. MSETNX will not perform any operation at all even if just a single key already exists.
  
  Specified by:
  
  msetnx in interface RedisDeferredCommands
- msetnx
  
  public void msetnx(KeyValue<String,Object>... pairs)
  
  Description copied from interface: RedisDeferredCommands
  
  Like RedisDeferredCommands.msetnx(String, String, String...), but takes key-value pairs.
  
  Specified by:
  
  msetnx in interface RedisDeferredCommands
- psetex
  
  public void psetex(String key, long milliseconds, String value)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/psetex:
  Available since 2.6.0.
  Time complexity: O(1)
  PSETEX works exactly like RedisDeferredCommands.setex(String, long, String) with the sole difference that the expire time is specified in milliseconds instead of seconds.
  
  Specified by:
  
  psetex in interface RedisDeferredCommands
- set
  
  public void set(String key, String value)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/set:
  Available since 1.0.0.
  Time complexity: O(1)
  Set key to hold the string value. If key already holds a value, it is overwritten, regardless of its type. Any previous time to live associated with the key is discarded on successful SET operation.
  
  Specified by:
  
  set in interface RedisDeferredCommands
- set
  
  public void set(String key, Number value)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/set:
  Available since 1.0.0.
  Time complexity: O(1)
  Set key to hold the string value. If key already holds a value, it is overwritten, regardless of its type. Any previous time to live associated with the key is discarded on successful SET operation.
  
  Specified by:
  
  set in interface RedisDeferredCommands
- setbit
  
  public void setbit(String key, long offset, long value)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/setbit:
  Available since 2.2.0.
  Time complexity: O(1)
  Sets or clears the bit at offset in the string value stored at key.
  
  Specified by:
  
  setbit in interface RedisDeferredCommands
- setex
  
  public void setex(String key, long seconds, String value)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/setex:
  Available since 2.0.0.
  Time complexity: O(1)
  Set key to hold the string value and set key to timeout after a given number of seconds. This command is equivalent to executing the following commands:
  
  Specified by:
  
  setex in interface RedisDeferredCommands
- setnx
  
  public void setnx(String key, String value)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/setnx:
  Available since 1.0.0.
  Time complexity: O(1)
  Set key to hold string value if key does not exist. In that case, it is equal to RedisDeferredCommands.set(String, String). When key already holds a value, no operation is performed. SETNX is short for "SET if N ot e X ists".
  
  Specified by:
  
  setnx in interface RedisDeferredCommands
- setrange
  
  public void setrange(String key, long offset, String value)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/setrange:
  Available since 2.2.0.
  Time complexity: O(1), not counting the time taken to copy the new string in place. Usually, this string is very small so the amortized complexity is O(1). Otherwise, complexity is O(M) with M being the length of the value argument.
  Overwrites part of the string stored at key, starting at the specified offset, for the entire length of value. If the offset is larger than the current length of the string at key, the string is padded with zero-bytes to make offset fit. Non-existing keys are considered as empty strings, so this command will make sure it holds a string large enough to be able to set value at offset.
  
  Specified by:
  
  setrange in interface RedisDeferredCommands
- strlen
  
  public void strlen(String key)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/strlen:
  Available since 2.2.0.
  Time complexity: O(1)
  Returns the length of the string value stored at key. An error is returned when key holds a non-string value.
  
  Specified by:
  
  strlen in interface RedisDeferredCommands
- hdel
  
  public void hdel(String key, String field, String... fields)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/hdel:
  Available since 2.0.0.
  Time complexity: O(N) where N is the number of fields to be removed.
  Removes the specified fields from the hash stored at key. Specified fields that do not exist within this hash are ignored. If key does not exist, it is treated as an empty hash and this command returns 0. specified but non existing fields.
  
  Specified by:
  
  hdel in interface RedisDeferredCommands
- hexists
  
  public void hexists(String key, String field)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/hexists:
  Available since 2.0.0.
  Time complexity: O(1)
  Returns if field is an existing field in the hash stored at key.
  
  Specified by:
  
  hexists in interface RedisDeferredCommands
- hget
  
  public void hget(String key, String field)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/hget:
  Available since 2.0.0.
  Time complexity: O(1)
  Returns the value associated with field in the hash stored at key. when field is not present in the hash or key does not exist.
  
  Specified by:
  
  hget in interface RedisDeferredCommands
- hgetall
  
  public void hgetall(String key)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/hgetall:
  Available since 2.0.0.
  Time complexity: O(N) where N is the size of the hash.
  Returns all fields and values of the hash stored at key. In the returned value, every field name is followed by its value, so the length of the reply is twice the size of the hash. list when key does not exist.
  
  Specified by:
  
  hgetall in interface RedisDeferredCommands
- hincrby
  
  public void hincrby(String key, String field, long increment)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/hincrby:
  Available since 2.0.0.
  Time complexity: O(1)
  Increments the number stored at field in the hash stored at key by increment. If key does not exist, a new key holding a hash is created. If field does not exist the value is set to 0 before the operation is performed.
  
  Specified by:
  
  hincrby in interface RedisDeferredCommands
- hincrbyfloat
  
  public void hincrbyfloat(String key, String field, double increment)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/hincrbyfloat:
  Available since 2.6.0.
  Time complexity: O(1)
  Increment the specified field of an hash stored at key, and representing a floating point number, by the specified increment. If the field does not exist, it is set to 0 before performing the operation.
  
  Specified by:
  
  hincrbyfloat in interface RedisDeferredCommands
- hkeys
  
  public void hkeys(String key)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/hkeys:
  Available since 2.0.0.
  Time complexity: O(N) where N is the size of the hash.
  Returns all field names in the hash stored at key.
  
  Specified by:
  
  hkeys in interface RedisDeferredCommands
- hlen
  
  public void hlen(String key)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/hlen:
  Available since 2.0.0.
  Time complexity: O(1)
  Returns the number of fields contained in the hash stored at key.
  
  Specified by:
  
  hlen in interface RedisDeferredCommands
- hmget
  
  public void hmget(String key, String field, String... fields)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/hmget:
  Available since 2.0.0.
  Time complexity: O(N) where N is the number of fields being requested.
  Returns the values associated with the specified fields in the hash stored at key.
  
  Specified by:
  
  hmget in interface RedisDeferredCommands
- hmset
  
  public void hmset(String key, String field, String value, String... fieldvalues)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/hmset:
  Available since 2.0.0.
  Time complexity: O(N) where N is the number of fields being set.
  Sets the specified fields to their respective values in the hash stored at key. This command overwrites any existing fields in the hash. If key does not exist, a new key holding a hash is created.
  Parameters should alternate between field, value, field, value ...
  
  Specified by:
  
  hmset in interface RedisDeferredCommands
- hmset
  
  public void hmset(String key, Object field, Object value, Object... fieldvalues)
  
  From http://redis.io/commands/hmset:
  
  Available since 2.0.0.
  
  Time complexity: O(N) where N is the number of fields being set.
  
  Sets the specified fields to their respective values in the hash stored at key. This command overwrites any existing fields in the hash. If key does not exist, a new key holding a hash is created.
  
  Parameters should alternate between field, value, field, value ...
  
  Parameters:
  
  key - the key to use.
  
  field - the first field.
  
  value - the first value.
  
  fieldvalues - the subsequent fields and values.
- hmset
  
  public void hmset(String key, KeyValue<String,Object>... pairs)
  
  From http://redis.io/commands/hmset:
  
  Available since 2.0.0.
  
  Time complexity: O(N) where N is the number of fields being set.
  
  Sets the specified fields to their respective values in the hash stored at key. This command overwrites any existing fields in the hash. If key does not exist, a new key holding a hash is created.
  
  Parameters:
  
  key - the key to use.
  
  pairs - the field-value pairs to set on the hash.
- hset
  
  public void hset(String key, String field, String value)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/hset:
  Available since 2.0.0.
  Time complexity: O(1)
  Sets field in the hash stored at key to value. If key does not exist, a new key holding a hash is created. If field already exists in the hash, it is overwritten.
  
  Specified by:
  
  hset in interface RedisDeferredCommands
- hset
  
  public void hset(String key, String field, Number value)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/hset:
  Available since 2.0.0.
  Time complexity: O(1)
  Sets field in the hash stored at key to value. If key does not exist, a new key holding a hash is created. If field already exists in the hash, it is overwritten.
  
  Specified by:
  
  hset in interface RedisDeferredCommands
- hsetnx
  
  public void hsetnx(String key, String field, String value)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/hsetnx:
  Available since 2.0.0.
  Time complexity: O(1)
  Sets field in the hash stored at key to value, only if field does not yet exist. If key does not exist, a new key holding a hash is created. If field already exists, this operation has no effect.
  
  Specified by:
  
  hsetnx in interface RedisDeferredCommands
- hsetnx
  
  public void hsetnx(String key, String field, Number value)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/hsetnx:
  Available since 2.0.0.
  Time complexity: O(1)
  Sets field in the hash stored at key to value, only if field does not yet exist. If key does not exist, a new key holding a hash is created. If field already exists, this operation has no effect.
  
  Specified by:
  
  hsetnx in interface RedisDeferredCommands
- hvals
  
  public void hvals(String key)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/hvals:
  Available since 2.0.0.
  Time complexity: O(N) where N is the size of the hash.
  Returns all values in the hash stored at key.
  
  Specified by:
  
  hvals in interface RedisDeferredCommands
- blpop
  
  public void blpop(long timeout, String key, String... keys)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/blpop:
  Available since 2.0.0.
  Time complexity: O(1)
  BLPOP is a blocking list pop primitive. It is the blocking version of RedisDeferredCommands.lpop(String) because it blocks the connection when there are no elements to pop from any of the given lists. An element is popped from the head of the first list that is non-empty, with the given keys being checked in the order that they are given. A timeout of zero can be used to block indefinitely. Timeout is in seconds.
  
  Specified by:
  
  blpop in interface RedisDeferredCommands
- brpop
  
  public void brpop(long timeout, String key, String... keys)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/brpop:
  Available since 2.0.0.
  Time complexity: O(1)
  BRPOP is a blocking list pop primitive. It is the blocking version of RedisDeferredCommands.rpop(String) because it blocks the connection when there are no elements to pop from any of the given lists. An element is popped from the tail of the first list that is non-empty, with the given keys being checked in the order that they are given. A timeout of zero can be used to block indefinitely. Timeout is in seconds.
  
  Specified by:
  
  brpop in interface RedisDeferredCommands
- brpoplpush
  
  public void brpoplpush(long timeout, String source, String destination)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/brpoplpush:
  Available since 2.2.0.
  Time complexity: O(1)
  BRPOPLPUSH is the blocking variant of RedisDeferredCommands.rpoplpush(String, String). When source contains elements, this command behaves exactly like RedisDeferredCommands.rpoplpush(String, String). When source is empty, Redis will block the connection until another client pushes to it or until timeout is reached. A timeout of zero can be used to block indefinitely. Timeout is in seconds.
  
  Specified by:
  
  brpoplpush in interface RedisDeferredCommands
- lindex
  
  public void lindex(String key, long index)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/lindex:
  Available since 1.0.0.
  Time complexity: O(N) where N is the number of elements to traverse to get to the element at index. This makes asking for the first or the last element of the list O(1).
  Returns the element at index index in the list stored at key. The index is zero-based, so 0 means the first element, 1 the second element and so on. Negative indices can be used to designate elements starting at the tail of the list. Here, -1 means the last element, -2 means the penultimate and so forth.
  
  Specified by:
  
  lindex in interface RedisDeferredCommands
- linsert
  
  public void linsert(String key, boolean before, String pivot, String value)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/linsert:
  Available since 2.2.0.
  Time complexity: O(N) where N is the number of elements to traverse before seeing the value pivot. This means that inserting somewhere on the left end on the list (head) can be considered O(1) and inserting somewhere on the right end (tail) is O(N).
  Inserts value in the list stored at key either before or after the reference value pivot. when the value pivot was not found.
  
  Specified by:
  
  linsert in interface RedisDeferredCommands
- linsert
  
  public void linsert(String key, boolean before, String pivot, Number value)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/linsert:
  Available since 2.2.0.
  Time complexity: O(N) where N is the number of elements to traverse before seeing the value pivot. This means that inserting somewhere on the left end on the list (head) can be considered O(1) and inserting somewhere on the right end (tail) is O(N).
  Inserts value in the list stored at key either before or after the reference value pivot. when the value pivot was not found.
  
  Specified by:
  
  linsert in interface RedisDeferredCommands
- llen
  
  public void llen(String key)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/llen:
  Available since 1.0.0.
  Time complexity: O(1)
  Returns the length of the list stored at key. If key does not exist, it is interpreted as an empty list and 0 is returned. An error is returned when the value stored at key is not a list.
  
  Specified by:
  
  llen in interface RedisDeferredCommands
- lpop
  
  public void lpop(String key)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/lpop:
  Available since 1.0.0.
  Time complexity: O(1)
  Removes and returns the first element of the list stored at key.
  
  Specified by:
  
  lpop in interface RedisDeferredCommands
- lpush
  
  public void lpush(String key, String value, String... values)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/lpush:
  Available since 1.0.0.
  Time complexity: O(1)
  Insert all the specified values at the head of the list stored at key. If key does not exist, it is created as empty list before performing the push operations. When key holds a value that is not a list, an error is returned.
  
  Specified by:
  
  lpush in interface RedisDeferredCommands
- lpushx
  
  public void lpushx(String key, String value)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/lpushx:
  Available since 2.2.0.
  Time complexity: O(1)
  Inserts value at the head of the list stored at key, only if key already exists and holds a list. In contrary to RedisDeferredCommands.lpush(String, String, String...), no operation will be performed when key does not yet exist.
  
  Specified by:
  
  lpushx in interface RedisDeferredCommands
- lrange
  
  public void lrange(String key, long start, long stop)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/lrange:
  Available since 1.0.0.
  Time complexity: O(S+N) where S is the start offset and N is the number of elements in the specified range.
  Returns the specified elements of the list stored at key. The offsets start and stop are zero-based indexes, with 0 being the first element of the list (the head of the list), 1 being the next element and so on.
  
  Specified by:
  
  lrange in interface RedisDeferredCommands
- lrem
  public void lrem(String key, long count, String value)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/lrem:
  Available since 1.0.0.
  Time complexity: O(N) where N is the length of the list.
  Removes the first count occurrences of elements equal to value from the list stored at key. The count argument influences the operation in the following ways:
  
  count > 0: Remove elements equal to value moving from head to tail.
  
  count < 0: Remove elements equal to value moving from tail to head.
  
  count = 0: Remove all elements equal to value.
  
  Specified by:
  
  lrem in interface RedisDeferredCommands
- lset
  
  public void lset(String key, long index, String value)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/lset:
  Available since 1.0.0.
  Time complexity: O(N) where N is the length of the list. Setting either the first or the last element of the list is O(1).
  Sets the list element at index to value. For more information on the index argument, see RedisDeferredCommands.lindex(String, long).
  
  Specified by:
  
  lset in interface RedisDeferredCommands
- ltrim
  
  public void ltrim(String key, long start, long stop)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/ltrim:
  Available since 1.0.0.
  Time complexity: O(N) where N is the number of elements to be removed by the operation.
  Trim an existing list so that it will contain only the specified range of elements specified. Both start and stop are zero-based indexes, where 0 is the first element of the list (the head), 1 the next element and so on.
  
  Specified by:
  
  ltrim in interface RedisDeferredCommands
- rpop
  
  public void rpop(String key)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/rpop:
  Available since 1.0.0.
  Time complexity: O(1)
  Removes and returns the last element of the list stored at key.
  
  Specified by:
  
  rpop in interface RedisDeferredCommands
- rpoplpush
  
  public void rpoplpush(String source, String destination)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/rpoplpush:
  Available since 1.2.0.
  Time complexity: O(1)
  Atomically returns and removes the last element (tail) of the list stored at source, and pushes the element at the first element (head) of the list stored at destination.
  
  Specified by:
  
  rpoplpush in interface RedisDeferredCommands
- rpush
  
  public void rpush(String key, String value, String... values)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/rpush:
  Available since 1.0.0.
  Time complexity: O(1)
  Insert all the specified values at the tail of the list stored at key. If key does not exist, it is created as empty list before performing the push operation. When key holds a value that is not a list, an error is returned.
  
  Specified by:
  
  rpush in interface RedisDeferredCommands
- rpushx
  
  public void rpushx(String key, String value)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/rpushx:
  Available since 2.2.0.
  Time complexity: O(1)
  Inserts value at the tail of the list stored at key, only if key already exists and holds a list. In contrary to RedisDeferredCommands.rpush(String, String, String...), no operation will be performed when key does not yet exist.
  
  Specified by:
  
  rpushx in interface RedisDeferredCommands
- eval
  
  public void eval(String scriptContent, String[] keys, Object... args)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/eval:
  Available since 2.6.0.
  Time complexity: Depends on the script that is executed.
  Evaluates a Lua script. The keys specified in keys should be used as a hint for Redis as to what keys are touched during the script call.
  
  Specified by:
  
  eval in interface RedisDeferredCommands
- evalsha
  
  public void evalsha(String hash, String[] keys, Object... args)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/evalsha:
  Available since 2.6.0.
  Time complexity: Depends on the script that is executed.
  Evaluates a script cached on the server side by its SHA1 digest. Scripts are cached on the server side using the RedisDeferredCommands.scriptLoad(String) command. The command is otherwise identical to RedisDeferredCommands.eval(String, String[], Object...).
  
  Specified by:
  
  evalsha in interface RedisDeferredCommands
- scriptExists
  
  public void scriptExists(String scriptHash, String... scriptHashes)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/script-exists:
  Available since 2.6.0.
  Time complexity: O(N) with N being the number of scripts to check (so checking a single script is an O(1) operation).
  Returns information about the existence of the scripts in the script cache. SHA1 digest arguments. For every corresponding SHA1 digest of a script that actually exists in the script cache, true is returned, otherwise false is returned.
  
  Specified by:
  
  scriptExists in interface RedisDeferredCommands
- scriptFlush
  
  public void scriptFlush()
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/script-flush:
  Available since 2.6.0.
  Time complexity: O(N) with N being the number of scripts in cache
  Flush the Lua scripts cache.
  
  Specified by:
  
  scriptFlush in interface RedisDeferredCommands
- scriptKill
  
  public void scriptKill(String hash)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/script-kill:
  Available since 2.6.0.
  Time complexity: O(1)
  Kills the currently executing Lua script, assuming no write operation was yet performed by the script.
  
  Specified by:
  
  scriptKill in interface RedisDeferredCommands
- scriptLoad
  
  public void scriptLoad(String content)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/script-load:
  Available since 2.6.0.
  Time complexity: O(N) with N being the length in bytes of the script body.
  Load a script into the scripts cache, without executing it. After the specified command is loaded into the script cache it will be callable using RedisDeferredCommands.evalsha(String, String[], Object...) with the correct SHA1 digest of the script, exactly like after the first successful invocation of RedisDeferredCommands.eval(String, String[], Object...).
  
  Specified by:
  
  scriptLoad in interface RedisDeferredCommands
- scriptLoad
  
  public void scriptLoad(File content) throws IOException
  
  From http://redis.io/commands/script-load:
  
  Available since 2.6.0.
  
  Time complexity: O(N) with N being the length in bytes of the script body.
  
  Load a script into the scripts cache from the specified file without executing it. After the specified command is loaded into the script cache it will be callable using evalsha(String, String[], Object...) with the correct SHA1 digest of the script, exactly like after the first successful invocation of eval(String, String[], Object...).
  
  Specified by:
  
  scriptLoad in interface RedisDeferredCommands
  
  Throws:
  
  IOException
- scriptLoad
  
  public void scriptLoad(InputStream content) throws IOException
  
  From http://redis.io/commands/script-load:
  
  Available since 2.6.0.
  
  Time complexity: O(N) with N being the length in bytes of the script body.
  
  Load a script into the scripts cache from the specified input stream (until the end is reached) without executing it. The stream is not closed after read. After the specified command is loaded into the script cache it will be callable using evalsha(String, String[], Object...) with the correct SHA1 digest of the script, exactly like after the first successful invocation of eval(String, String[], Object...).
  
  Specified by:
  
  scriptLoad in interface RedisDeferredCommands
  
  Throws:
  
  IOException
- sadd
  
  public void sadd(String key, String member, String... members)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/sadd:
  Available since 1.0.0.
  Time complexity: O(N) where N is the number of members to be added.
  Add the specified members to the set stored at key. Specified members that are already a member of this set are ignored. If key does not exist, a new set is created before adding the specified members.
  
  Specified by:
  
  sadd in interface RedisDeferredCommands
- sadd
  
  public void sadd(String key, Object member, Object... members)
  
  From http://redis.io/commands/sadd:
  
  Available since 1.0.0.
  
  Time complexity: O(N) where N is the number of members to be added.
  
  Add the specified members to the set stored at key. Specified members that are already a member of this set are ignored. If key does not exist, a new set is created before adding the specified members.
  
  Specified by:
  
  sadd in interface RedisDeferredCommands
- scard
  
  public void scard(String key)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/scard:
  Available since 1.0.0.
  Time complexity: O(1)
  Returns the set cardinality (number of elements) of the set stored at key.
  
  Specified by:
  
  scard in interface RedisDeferredCommands
- sdiff
  
  public void sdiff(String key, String... keys)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/sdiff:
  Available since 1.0.0.
  Time complexity: O(N) where N is the total number of elements in all given sets.
  Returns the members of the set resulting from the difference between the first set and all the successive sets.
  
  Specified by:
  
  sdiff in interface RedisDeferredCommands
- sdiffstore
  
  public void sdiffstore(String destination, String key, String... keys)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/sdiffstore:
  Available since 1.0.0.
  Time complexity: O(N) where N is the total number of elements in all given sets.
  This command is equal to SDIFF, but instead of returning the resulting set, it is stored in destination.
  
  Specified by:
  
  sdiffstore in interface RedisDeferredCommands
- sinter
  
  public void sinter(String key, String... keys)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/sinter:
  Available since 1.0.0.
  Time complexity: O(N*M) worst case where N is the cardinality of the smallest set and M is the number of sets.
  Returns the members of the set resulting from the intersection of all the given sets.
  
  Specified by:
  
  sinter in interface RedisDeferredCommands
- sinterstore
  
  public void sinterstore(String destination, String key, String... keys)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/sinterstore:
  Available since 1.0.0.
  Time complexity: O(N*M) worst case where N is the cardinality of the smallest set and M is the number of sets.
  This command is equal to SINTER, but instead of returning the resulting set, it is stored in destination.
  
  Specified by:
  
  sinterstore in interface RedisDeferredCommands
- sismember
  
  public void sismember(String key, String member)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/sismember:
  Available since 1.0.0.
  Time complexity: O(1)
  Returns if member is a member of the set stored at key.
  
  Specified by:
  
  sismember in interface RedisDeferredCommands
- sismember
  
  public void sismember(String key, Number member)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/sismember:
  Available since 1.0.0.
  Time complexity: O(1)
  Returns if member is a member of the set stored at key.
  
  Specified by:
  
  sismember in interface RedisDeferredCommands
- smembers
  
  public void smembers(String key)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/smembers:
  Available since 1.0.0.
  Time complexity: O(N) where N is the set cardinality.
  Returns all the members of the set value stored at key.
  
  Specified by:
  
  smembers in interface RedisDeferredCommands
- smove
  
  public void smove(String source, String destination, String member)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/smove:
  Available since 1.0.0.
  Time complexity: O(1)
  Move member from the set at source to the set at destination. This operation is atomic. In every given moment the element will appear to be a member of source or destination for other clients.
  
  Specified by:
  
  smove in interface RedisDeferredCommands
- spop
  
  public void spop(String key)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/spop:
  Available since 1.0.0.
  Time complexity: O(1)
  Removes and returns a random element from the set value stored at key.
  
  Specified by:
  
  spop in interface RedisDeferredCommands
- srandmember
  
  public void srandmember(String key)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/srandmember:
  Available since 1.0.0.
  Time complexity: O(1).
  When called with just the key argument, return a random element from the set value stored at key.
  
  Specified by:
  
  srandmember in interface RedisDeferredCommands
- srandmember
  
  public void srandmember(String key, long count)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/srandmember:
  Available since 1.0.0.
  Time complexity: O(N) where N is the absolute value of the passed count.
  When called with just the key argument, return a random element from the set value stored at key.
  
  Specified by:
  
  srandmember in interface RedisDeferredCommands
- srem
  
  public void srem(String key, String member, String... members)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/srem:
  Available since 1.0.0.
  Time complexity: O(N) where N is the number of members to be removed.
  Remove the specified members from the set stored at key. Specified members that are not a member of this set are ignored. If key does not exist, it is treated as an empty set and this command returns 0.
  
  Specified by:
  
  srem in interface RedisDeferredCommands
- srem
  
  public void srem(String key, Object member, Object... members)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/srem:
  Available since 1.0.0.
  Time complexity: O(N) where N is the number of members to be removed.
  Remove the specified members from the set stored at key. Specified members that are not a member of this set are ignored. If key does not exist, it is treated as an empty set and this command returns 0.
  
  Specified by:
  
  srem in interface RedisDeferredCommands
- sunion
  
  public void sunion(String key, String... keys)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/sunion:
  Available since 1.0.0.
  Time complexity: O(N) where N is the total number of elements in all given sets.
  Returns the members of the set resulting from the union of all the given sets.
  
  Specified by:
  
  sunion in interface RedisDeferredCommands
- sunionstore
  
  public void sunionstore(String destination, String key, String... keys)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/sunionstore:
  Available since 1.0.0.
  Time complexity: O(N) where N is the total number of elements in all given sets.
  This command is equal to SUNION, but instead of returning the resulting set, it is stored in destination.
  
  Specified by:
  
  sunionstore in interface RedisDeferredCommands
- zadd
  
  public void zadd(String key, double score, String member)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/zadd:
  Available since 1.2.0.
  Time complexity: O(log(N)) where N is the number of elements in the sorted set.
  Adds all the specified members with the specified scores to the sorted set stored at key. It is possible to specify multiple score/member pairs. If a specified member is already a member of the sorted set, the score is updated and the element reinserted at the right position to ensure the correct ordering. If key does not exist, a new sorted set with the specified members as sole members is created, like if the sorted set was empty. If the key exists but does not hold a sorted set, an error is returned.
  
  Specified by:
  
  zadd in interface RedisDeferredCommands
- zadd
  
  public void zadd(String key, double score, Number member)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/zadd:
  Available since 1.2.0.
  Time complexity: O(log(N)) where N is the number of elements in the sorted set.
  Adds all the specified members with the specified scores to the sorted set stored at key. It is possible to specify multiple score/member pairs. If a specified member is already a member of the sorted set, the score is updated and the element reinserted at the right position to ensure the correct ordering. If key does not exist, a new sorted set with the specified members as sole members is created, like if the sorted set was empty. If the key exists but does not hold a sorted set, an error is returned.
  
  Specified by:
  
  zadd in interface RedisDeferredCommands
- zadd
  
  public void zadd(String key, KeyValue<Double,String>... pairs)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/zadd:
  Available since 1.2.0.
  Time complexity: O(log(N)) where N is the number of elements in the sorted set.
  Adds all the specified members with the specified scores to the sorted set stored at key. It is possible to specify multiple score/member pairs. If a specified member is already a member of the sorted set, the score is updated and the element reinserted at the right position to ensure the correct ordering. If key does not exist, a new sorted set with the specified members as sole members is created, like if the sorted set was empty. If the key exists but does not hold a sorted set, an error is returned.
  
  Specified by:
  
  zadd in interface RedisDeferredCommands
- zcard
  
  public void zcard(String key)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/zcard:
  Available since 1.2.0.
  Time complexity: O(1)
  Returns the sorted set cardinality (number of elements) of the sorted set stored at key.
  
  Specified by:
  
  zcard in interface RedisDeferredCommands
- zcount
  
  public void zcount(String key, String min, String max)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/zcount:
  Available since 2.0.0.
  Time complexity: O(log(N)) with N being the number of elements in the sorted set.
  Returns the number of elements in the sorted set at key with a score between min and max.
  The arguments min and max are Strings so they can accept special ranges.
  
  Specified by:
  
  zcount in interface RedisDeferredCommands
- zcount
  
  public void zcount(String key, double min, double max)
  
  Like zcount(String, String, String), except it accepts doubles for min and max, not strings.
  
  Specified by:
  
  zcount in interface RedisDeferredCommands
- zincrby
  
  public void zincrby(String key, double increment, String member)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/zincrby:
  Available since 1.2.0.
  Time complexity: O(log(N)) where N is the number of elements in the sorted set.
  Increments the score of member in the sorted set stored at key by increment. If member does not exist in the sorted set, it is added with increment as its score (as if its previous score was 0.0). If key does not exist, a new sorted set with the specified member as its sole member is created.
  
  Specified by:
  
  zincrby in interface RedisDeferredCommands
- zrange
  
  public void zrange(String key, long start, long stop, boolean withScores)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/zrange:
  Available since 1.2.0.
  Time complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements returned.
  Returns the specified range of elements in the sorted set stored at key. The elements are considered to be ordered from the lowest to the highest score. Lexicographical order is used for elements with equal score.
  
  Specified by:
  
  zrange in interface RedisDeferredCommands
- zrangebyscore
  
  public void zrangebyscore(String key, String min, String max, boolean withScores, Long limitOffset, Long limitCount)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/zrangebyscore:
  Available since 1.0.5.
  Time complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements being returned. If M is constant (e.g. always asking for the first 10 elements with LIMIT), you can consider it O(log(N)).
  Returns all the elements in the sorted set at key with a score between min and max (including elements with score equal to min or max). The elements are considered to be ordered from low to high scores.
  The optional LIMIT argument can be used to only get a range of the matching elements (similar to SELECT LIMIT offset, count in SQL). Keep in mind that if offset is large, the sorted set needs to be traversed for offset elements before getting to the elements to return, which can add up to O(N) time complexity.
  The arguments min and max are Strings so they can accept special ranges.
  
  Specified by:
  
  zrangebyscore in interface RedisDeferredCommands
- zrangebyscore
  
  public void zrangebyscore(String key, double min, double max, boolean withScores)
  
  Description copied from interface: RedisDeferredCommands
  
  Like RedisDeferredCommands.zrangebyscore(String, String, String, boolean), except it accepts doubles for min and max, not strings.
  
  Specified by:
  
  zrangebyscore in interface RedisDeferredCommands
- zrangebyscore
  
  public void zrangebyscore(String key, String min, String max, boolean withScores)
  
  Description copied from interface: RedisDeferredCommands
  
  Like RedisDeferredCommands.zrangebyscore(String, String, String, boolean, Long, Long), except specifies no limit.
  
  Specified by:
  
  zrangebyscore in interface RedisDeferredCommands
- zrangebyscore
  
  public void zrangebyscore(String key, double min, double max, boolean withScores, Long limitOffset, Long limitCount)
  
  Description copied from interface: RedisDeferredCommands
  
  Like RedisDeferredCommands.zrangebyscore(String, String, String, boolean, Long, Long), except it accepts doubles for min and max, not strings.
  
  Specified by:
  
  zrangebyscore in interface RedisDeferredCommands
- zrank
  
  public void zrank(String key, String member)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/zrank:
  Available since 2.0.0.
  Time complexity: O(log(N))
  Returns the rank of member in the sorted set stored at key, with the scores ordered from low to high. The rank (or index) is 0-based, which means that the member with the lowest score has rank 0. If member does not exist in the sorted set or key does not exist, null.
  
  Specified by:
  
  zrank in interface RedisDeferredCommands
- zrank
  
  public void zrank(String key, Number member)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/zrank:
  Available since 2.0.0.
  Time complexity: O(log(N))
  Returns the rank of member in the sorted set stored at key, with the scores ordered from low to high. The rank (or index) is 0-based, which means that the member with the lowest score has rank 0. If member does not exist in the sorted set or key does not exist, null.
  
  Specified by:
  
  zrank in interface RedisDeferredCommands
- zrem
  
  public void zrem(String key, String member, String... members)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/zrem:
  Available since 1.2.0.
  Time complexity: O(M*log(N)) with N being the number of elements in the sorted set and M the number of elements to be removed.
  Removes the specified members from the sorted set stored at key. Non existing members are ignored.
  
  Specified by:
  
  zrem in interface RedisDeferredCommands
- zrem
  
  public void zrem(String key, Number member, Number... members)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/zrem:
  Available since 1.2.0.
  Time complexity: O(M*log(N)) with N being the number of elements in the sorted set and M the number of elements to be removed.
  Removes the specified members from the sorted set stored at key. Non existing members are ignored.
  
  Specified by:
  
  zrem in interface RedisDeferredCommands
- zremrangebyrank
  
  public void zremrangebyrank(String key, long start, long stop)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/zremrangebyrank:
  Available since 2.0.0.
  Time complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements removed by the operation.
  Removes all elements in the sorted set stored at key with rank between start and stop. Both start and stop are 0 -based indexes with 0 being the element with the lowest score. These indexes can be negative numbers, where they indicate offsets starting at the element with the highest score. For example: -1 is the element with the highest score, -2 the element with the second highest score and so forth.
  
  Specified by:
  
  zremrangebyrank in interface RedisDeferredCommands
- zremrangebyscore
  
  public void zremrangebyscore(String key, String min, String max)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/zremrangebyscore:
  Available since 1.2.0.
  Time complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements removed by the operation.
  Removes all elements in the sorted set stored at key with a score between min and max (inclusive).
  The arguments min and max are Strings so they can accept special ranges.
  
  Specified by:
  
  zremrangebyscore in interface RedisDeferredCommands
- zremrangebyscore
  
  public void zremrangebyscore(String key, double min, double max)
  
  Like zremrangebyscore(String, String, String), except it accepts doubles for min and max, not strings.
  
  Specified by:
  
  zremrangebyscore in interface RedisDeferredCommands
- zrevrank
  
  public void zrevrank(String key, String member)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/zrevrank:
  Available since 2.0.0.
  Time complexity: O(log(N))
  Returns the rank of member in the sorted set stored at key, with the scores ordered from high to low. The rank (or index) is 0-based, which means that the member with the highest score has rank 0. If member does not exist in the sorted set or key does not exist, null.
  
  Specified by:
  
  zrevrank in interface RedisDeferredCommands
- zrevrange
  
  public void zrevrange(String key, long start, long stop, boolean withScores)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/zrevrange:
  Available since 1.2.0.
  Time complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements returned.
  Returns the specified range of elements in the sorted set stored at key. The elements are considered to be ordered from the highest to the lowest score. Descending lexicographical order is used for elements with equal score.
  
  Specified by:
  
  zrevrange in interface RedisDeferredCommands
- zrevrangebyscore
  
  public void zrevrangebyscore(String key, String min, String max, boolean withScores, Long limitOffset, Long limitCount)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/zrevrangebyscore:
  Available since 2.2.0.
  Time complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements removed by the operation.
  Returns all the elements in the sorted set at key with a score between max and min (including elements with score equal to max or min). In contrary to the default ordering of sorted sets, for this command the elements are considered to be ordered from high to low scores.
  The optional LIMIT argument can be used to only get a range of the matching elements (similar to SELECT LIMIT offset, count in SQL). Keep in mind that if offset is large, the sorted set needs to be traversed for offset elements before getting to the elements to return, which can add up to O(N) time complexity.
  The arguments min and max are Strings so they can accept special ranges.
  
  Specified by:
  
  zrevrangebyscore in interface RedisDeferredCommands
- zrevrangebyscore
  
  public void zrevrangebyscore(String key, double min, double max, boolean withScores)
  
  Description copied from interface: RedisDeferredCommands
  
  Like RedisDeferredCommands.zrevrangebyscore(String, String, String, boolean), except it accepts doubles for min and max, not strings.
  
  Specified by:
  
  zrevrangebyscore in interface RedisDeferredCommands
- zrevrangebyscore
  
  public void zrevrangebyscore(String key, String min, String max, boolean withScores)
  
  Description copied from interface: RedisDeferredCommands
  
  Like RedisDeferredCommands.zrevrangebyscore(String, String, String, boolean, Long, Long), except specifies no limit.
  
  Specified by:
  
  zrevrangebyscore in interface RedisDeferredCommands
- zrevrangebyscore
  
  public void zrevrangebyscore(String key, double min, double max, boolean withScores, Long limitOffset, Long limitCount)
  
  Description copied from interface: RedisDeferredCommands
  
  Like RedisDeferredCommands.zrevrangebyscore(String, String, String, boolean, Long, Long), except it accepts doubles for min and max, not strings.
  
  Specified by:
  
  zrevrangebyscore in interface RedisDeferredCommands
- zscore
  
  public void zscore(String key, String member)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/zscore:
  Available since 1.2.0.
  Time complexity: O(1)
  Returns the score of member in the sorted set at key.
  
  Specified by:
  
  zscore in interface RedisDeferredCommands
- zinterstore
  
  public void zinterstore(String destination, double[] weights, Aggregation aggregation, String key, String... keys)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/zinterstore:
  Available since 2.0.0.
  Time complexity: O(N*K)+O(M*log(M)) worst case with N being the smallest input sorted set, K being the number of input sorted sets and M being the number of elements in the resulting sorted set.
  Computes the intersection of numkeys sorted sets given by the specified keys, and stores the result in destination. It is mandatory to provide the number of input keys (numkeys) before passing the input keys and the other (optional) arguments.
  
  Specified by:
  
  zinterstore in interface RedisDeferredCommands
- zinterstore
  
  public void zinterstore(String destination, Aggregation aggregation, String key, String... keys)
  
  Description copied from interface: RedisDeferredCommands
  
  Like RedisDeferredCommands.zinterstore(String, double[], Aggregation, String, String...), except no weights are applied to the source value scores.
  Equivalent to: zinterstore(destination, null, aggregation, key, keys)
  
  Specified by:
  
  zinterstore in interface RedisDeferredCommands
- zinterstore
  
  public void zinterstore(String destination, double[] weights, String key, String... keys)
  
  Description copied from interface: RedisDeferredCommands
  
  Like RedisDeferredCommands.zinterstore(String, double[], Aggregation, String, String...), except it does no aggregation of scores.
  Equivalent to: zinterstore(destination, weights, null, key, keys)
  
  Specified by:
  
  zinterstore in interface RedisDeferredCommands
- zinterstore
  
  public void zinterstore(String destination, String key, String... keys)
  
  Description copied from interface: RedisDeferredCommands
  
  Like RedisDeferredCommands.zinterstore(String, double[], Aggregation, String, String...), except no weights are applied to the source value scores, and does no aggregation of scores.
  Equivalent to: zinterstore(destination, null, null, key, keys)
  
  Specified by:
  
  zinterstore in interface RedisDeferredCommands
- zunionstore
  
  public void zunionstore(String destination, double[] weights, Aggregation aggregation, String key, String... keys)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/zunionstore:
  Available since 2.0.0.
  Time complexity: O(N)+O(M log(M)) with N being the sum of the sizes of the input sorted sets, and M being the number of elements in the resulting sorted set.
  Computes the union of numkeys sorted sets given by the specified keys, and stores the result in destination. It is mandatory to provide the number of input keys (numkeys) before passing the input keys and the other (optional) arguments.
  
  Specified by:
  
  zunionstore in interface RedisDeferredCommands
- zunionstore
  
  public void zunionstore(String destination, Aggregation aggregation, String key, String... keys)
  
  Description copied from interface: RedisDeferredCommands
  
  Like RedisDeferredCommands.zunionstore(String, double[], Aggregation, String, String...), except no weights are applied to the source value scores.
  Equivalent to: zunionstore(destination, null, aggregation, key, keys)
  
  Specified by:
  
  zunionstore in interface RedisDeferredCommands
- zunionstore
  
  public void zunionstore(String destination, double[] weights, String key, String... keys)
  
  Description copied from interface: RedisDeferredCommands
  
  Like RedisDeferredCommands.zunionstore(String, double[], Aggregation, String, String...), except it does no aggregation of scores.
  Equivalent to: zunionstore(destination, weights, null, key, keys)
  
  Specified by:
  
  zunionstore in interface RedisDeferredCommands
- zunionstore
  
  public void zunionstore(String destination, String key, String... keys)
  
  Description copied from interface: RedisDeferredCommands
  
  Like RedisDeferredCommands.zunionstore(String, double[], Aggregation, String, String...), except no weights are applied to the source value scores, and does no aggregation of scores.
  Equivalent to: zunionstore(destination, null, null, key, keys)
  
  Specified by:
  
  zunionstore in interface RedisDeferredCommands
- zlexcount
  
  public void zlexcount(String key, String min, String max)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/zlexcount:
  Available since 2.8.9.
  Time complexity: O(log(N)) with N being the number of elements in the sorted set.
  When all the elements in a sorted set are inserted with the same score, in order to force lexicographical ordering, this command returns the number of elements in the sorted set at key with a value between min and max.
  The arguments min and max are Strings so they can accept special ranges.
  
  Specified by:
  
  zlexcount in interface RedisDeferredCommands
- zlexcount
  
  public void zlexcount(String key, double min, double max)
  
  Description copied from interface: RedisDeferredCommands
  
  Like RedisDeferredCommands.zlexcount(String, String, String), except it accepts doubles for min and max, not strings.
  
  Specified by:
  
  zlexcount in interface RedisDeferredCommands
- zrangebylex
  
  public void zrangebylex(String key, String min, String max, Long limitOffset, Long limitCount)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/zrangebylex:
  Available since 2.8.9.
  Time complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements being returned. If M is constant (e.g. always asking for the first 10 elements with LIMIT), you can consider it O(log(N)).
  When all the elements in a sorted set are inserted with the same score, in order to force lexicographical ordering, this command returns all the elements in the sorted set at key with a value between min and max.
  The optional LIMIT argument can be used to only get a range of the matching elements (similar to SELECT LIMIT offset, count in SQL). Keep in mind that if offset is large, the sorted set needs to be traversed for offset elements before getting to the elements to return, which can add up to O(N) time complexity.
  The arguments min and max are Strings so they can accept special ranges.
  
  Specified by:
  
  zrangebylex in interface RedisDeferredCommands
- zrangebylex
  
  public void zrangebylex(String key, double min, double max, Long limitOffset, Long limitCount)
  
  Like zrangebylex(String, String, String, Long, Long), except it accepts doubles for min and max, not strings.
  
  Specified by:
  
  zrangebylex in interface RedisDeferredCommands
- zrangebylex
  
  public void zrangebylex(String key, String min, String max)
  
  Like zrangebylex(String, String, String, Long, Long), with no limit.
  
  Specified by:
  
  zrangebylex in interface RedisDeferredCommands
- zrangebylex
  
  public void zrangebylex(String key, double min, double max)
  
  Like zrangebylex(String, String, String), except it accepts doubles for min and max, not strings, with no limit.
  
  Specified by:
  
  zrangebylex in interface RedisDeferredCommands
- zremrangebylex
  
  public void zremrangebylex(String key, String min, String max)
  
  Description copied from interface: RedisDeferredCommands
  
  From http://redis.io/commands/zremrangebylex:
  Available since 2.8.9.
  Time complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements removed by the operation.
  When all the elements in a sorted set are inserted with the same score, in order to force lexicographical ordering, this command removes all elements in the sorted set stored at key between the lexicographical range specified by min and max.
  The arguments min and max are Strings so they can accept special ranges.
  
  Specified by:
  
  zremrangebylex in interface RedisDeferredCommands
- zremrangebylex
  
  public void zremrangebylex(String key, double min, double max)
  
  Description copied from interface: RedisDeferredCommands
  
  Like RedisDeferredCommands.zrangebylex(String, String, String), except it accepts doubles for min and max.
  
  Specified by:
  
  zremrangebylex in interface RedisDeferredCommands
- specialDouble
  protected String specialDouble(double d)
  
  Converts some of Java's primitive doubles to Redis interval values.
  
  Double.NEGATIVE_INFINITY converts to "-".
  
  Double.POSITIVE_INFINITY converts to "+".
  
  All others convert to their string representation.
  
  Parameters:
  
  d - the input double.
  
  Returns:
  
  the string representation of the value.

Class RedisPipeline

Method Summary

Methods inherited from class Object

Method Details

finish

echo

del

dump

exists

expire

expireat

keys

move

persist

pexpire

pexpireat

pttl

publish

randomkey

rename

renamenx

restore

sort

ttl

type

append

bitcount

bitcount

bitop

bitpos

bitpos

decr

decrby

get

getbit

getrange

getset

getset

incr

incrby

incrbyfloat

mget

mset

mset

msetnx

msetnx

psetex

set

set

setbit

setex

setnx

setrange

strlen

hdel

hexists

hget

hgetall

hincrby

hincrbyfloat

hkeys

hlen

hmget

hmset

hmset

hmset

hset

hset

hsetnx

hsetnx

hvals

blpop

brpop

brpoplpush

lindex

linsert

linsert

llen

lpop

lpush