RedisServer (netty4-server 0.11 API)

All Known Implementing Classes:

SimpleRedisServer
```
public interface RedisServer
```

Method Summary

Methods
Modifier and Type	Method and Description
`IntegerReply`	`append(byte[] key0, byte[] value1)` Append a value to a key String
`StatusReply`	`bgrewriteaof()` Asynchronously rewrite the append-only file Server
`StatusReply`	`bgsave()` Asynchronously save the dataset to disk Server
`IntegerReply`	`bitcount(byte[] key0, byte[] start1, byte[] end2)` Count set bits in a string String
`IntegerReply`	`bitop(byte[] operation0, byte[] destkey1, byte[][] key2)` Perform bitwise operations between strings String
`MultiBulkReply`	`blpop(byte[][] key0)` Remove and get the first element in a list, or block until one is available List
`MultiBulkReply`	`brpop(byte[][] key0)` Remove and get the last element in a list, or block until one is available List
`BulkReply`	`brpoplpush(byte[] source0, byte[] destination1, byte[] timeout2)` Pop a value from a list, push it to another list and return it; or block until one is available List
`Reply`	`client_getname()` Get the current connection name Server
`Reply`	`client_kill(byte[] ip_port0)` Kill the connection of a client Server
`Reply`	`client_list()` Get the list of client connections Server
`Reply`	`client_setname(byte[] connection_name0)` Set the current connection name Server
`Reply`	`config_get(byte[] parameter0)` Get the value of a configuration parameter Server
`Reply`	`config_resetstat()` Reset the stats returned by INFO Server
`Reply`	`config_set(byte[] parameter0, byte[] value1)` Set a configuration parameter to the given value Server
`IntegerReply`	`dbsize()` Return the number of keys in the selected database Server
`Reply`	`debug_object(byte[] key0)` Get debugging information about a key Server
`Reply`	`debug_segfault()` Make the server crash Server
`IntegerReply`	`decr(byte[] key0)` Decrement the integer value of a key by one String
`IntegerReply`	`decrby(byte[] key0, byte[] decrement1)` Decrement the integer value of a key by the given number String
`IntegerReply`	`del(byte[][] key0)` Delete a key Generic
`BulkReply`	`dump(byte[] key0)` Return a serialized version of the value stored at the specified key.
`BulkReply`	`echo(byte[] message0)` Echo the given string Connection
`Reply`	`eval(byte[] script0, byte[] numkeys1, byte[][] key2)` Execute a Lua script server side Scripting
`Reply`	`evalsha(byte[] sha10, byte[] numkeys1, byte[][] key2)` Execute a Lua script server side Scripting
`IntegerReply`	`exists(byte[] key0)` Determine if a key exists Generic
`IntegerReply`	`expire(byte[] key0, byte[] seconds1)` Set a key's time to live in seconds Generic
`IntegerReply`	`expireat(byte[] key0, byte[] timestamp1)` Set the expiration for a key as a UNIX timestamp Generic
`StatusReply`	`flushall()` Remove all keys from all databases Server
`StatusReply`	`flushdb()` Remove all keys from the current database Server
`BulkReply`	`get(byte[] key0)` Get the value of a key String
`IntegerReply`	`getbit(byte[] key0, byte[] offset1)` Returns the bit value at offset in the string value stored at key String
`BulkReply`	`getrange(byte[] key0, byte[] start1, byte[] end2)` Get a substring of the string stored at a key String
`BulkReply`	`getset(byte[] key0, byte[] value1)` Set the string value of a key and return its old value String
`IntegerReply`	`hdel(byte[] key0, byte[][] field1)` Delete one or more hash fields Hash
`IntegerReply`	`hexists(byte[] key0, byte[] field1)` Determine if a hash field exists Hash
`BulkReply`	`hget(byte[] key0, byte[] field1)` Get the value of a hash field Hash
`MultiBulkReply`	`hgetall(byte[] key0)` Get all the fields and values in a hash Hash
`IntegerReply`	`hincrby(byte[] key0, byte[] field1, byte[] increment2)` Increment the integer value of a hash field by the given number Hash
`BulkReply`	`hincrbyfloat(byte[] key0, byte[] field1, byte[] increment2)` Increment the float value of a hash field by the given amount Hash
`MultiBulkReply`	`hkeys(byte[] key0)` Get all the fields in a hash Hash
`IntegerReply`	`hlen(byte[] key0)` Get the number of fields in a hash Hash
`MultiBulkReply`	`hmget(byte[] key0, byte[][] field1)` Get the values of all the given hash fields Hash
`StatusReply`	`hmset(byte[] key0, byte[][] field_or_value1)` Set multiple hash fields to multiple values Hash
`IntegerReply`	`hset(byte[] key0, byte[] field1, byte[] value2)` Set the string value of a hash field Hash
`IntegerReply`	`hsetnx(byte[] key0, byte[] field1, byte[] value2)` Set the value of a hash field, only if the field does not exist Hash
`MultiBulkReply`	`hvals(byte[] key0)` Get all the values in a hash Hash
`IntegerReply`	`incr(byte[] key0)` Increment the integer value of a key by one String
`IntegerReply`	`incrby(byte[] key0, byte[] increment1)` Increment the integer value of a key by the given amount String
`BulkReply`	`incrbyfloat(byte[] key0, byte[] increment1)` Increment the float value of a key by the given amount String
`BulkReply`	`info(byte[] section0)` Get information and statistics about the server Server
`MultiBulkReply`	`keys(byte[] pattern0)` Find all keys matching the given pattern Generic
`IntegerReply`	`lastsave()` Get the UNIX time stamp of the last successful save to disk Server
`BulkReply`	`lindex(byte[] key0, byte[] index1)` Get an element from a list by its index List
`IntegerReply`	`linsert(byte[] key0, byte[] where1, byte[] pivot2, byte[] value3)` Insert an element before or after another element in a list List
`IntegerReply`	`llen(byte[] key0)` Get the length of a list List
`BulkReply`	`lpop(byte[] key0)` Remove and get the first element in a list List
`IntegerReply`	`lpush(byte[] key0, byte[][] value1)` Prepend one or multiple values to a list List
`IntegerReply`	`lpushx(byte[] key0, byte[] value1)` Prepend a value to a list, only if the list exists List
`MultiBulkReply`	`lrange(byte[] key0, byte[] start1, byte[] stop2)` Get a range of elements from a list List
`IntegerReply`	`lrem(byte[] key0, byte[] count1, byte[] value2)` Remove elements from a list List
`StatusReply`	`lset(byte[] key0, byte[] index1, byte[] value2)` Set the value of an element in a list by its index List
`StatusReply`	`ltrim(byte[] key0, byte[] start1, byte[] stop2)` Trim a list to the specified range List
`MultiBulkReply`	`mget(byte[][] key0)` Get the values of all the given keys String
`StatusReply`	`migrate(byte[] host0, byte[] port1, byte[] key2, byte[] destination_db3, byte[] timeout4)` Atomically transfer a key from a Redis instance to another one.
`Reply`	`monitor()` Listen for all requests received by the server in real time Server
`IntegerReply`	`move(byte[] key0, byte[] db1)` Move a key to another database Generic
`StatusReply`	`mset(byte[][] key_or_value0)` Set multiple keys to multiple values String
`IntegerReply`	`msetnx(byte[][] key_or_value0)` Set multiple keys to multiple values, only if none of the keys exist String
`Reply`	`object(byte[] subcommand0, byte[][] arguments1)` Inspect the internals of Redis objects Generic
`IntegerReply`	`persist(byte[] key0)` Remove the expiration from a key Generic
`IntegerReply`	`pexpire(byte[] key0, byte[] milliseconds1)` Set a key's time to live in milliseconds Generic
`IntegerReply`	`pexpireat(byte[] key0, byte[] milliseconds_timestamp1)` Set the expiration for a key as a UNIX timestamp specified in milliseconds Generic
`StatusReply`	`ping()` Ping the server Connection
`Reply`	`psetex(byte[] key0, byte[] milliseconds1, byte[] value2)` Set the value and expiration in milliseconds of a key String
`IntegerReply`	`pttl(byte[] key0)` Get the time to live for a key in milliseconds Generic
`IntegerReply`	`publish(byte[] channel0, byte[] message1)` Post a message to a channel Pubsub
`StatusReply`	`quit()` Close the connection Connection
`BulkReply`	`randomkey()` Return a random key from the keyspace Generic
`StatusReply`	`rename(byte[] key0, byte[] newkey1)` Rename a key Generic
`IntegerReply`	`renamenx(byte[] key0, byte[] newkey1)` Rename a key, only if the new key does not exist Generic
`StatusReply`	`restore(byte[] key0, byte[] ttl1, byte[] serialized_value2)` Create a key using the provided serialized value, previously obtained using DUMP.
`BulkReply`	`rpop(byte[] key0)` Remove and get the last element in a list List
`BulkReply`	`rpoplpush(byte[] source0, byte[] destination1)` Remove the last element in a list, append it to another list and return it List
`IntegerReply`	`rpush(byte[] key0, byte[][] value1)` Append one or multiple values to a list List
`IntegerReply`	`rpushx(byte[] key0, byte[] value1)` Append a value to a list, only if the list exists List
`IntegerReply`	`sadd(byte[] key0, byte[][] member1)` Add one or more members to a set Set
`Reply`	`save()` Synchronously save the dataset to disk Server
`IntegerReply`	`scard(byte[] key0)` Get the number of members in a set Set
`Reply`	`script_exists(byte[][] script0)` Check existence of scripts in the script cache.
`Reply`	`script_flush()` Remove all the scripts from the script cache.
`Reply`	`script_kill()` Kill the script currently in execution.
`Reply`	`script_load(byte[] script0)` Load the specified Lua script into the script cache.
`MultiBulkReply`	`sdiff(byte[][] key0)` Subtract multiple sets Set
`IntegerReply`	`sdiffstore(byte[] destination0, byte[][] key1)` Subtract multiple sets and store the resulting set in a key Set
`StatusReply`	`select(byte[] index0)` Change the selected database for the current connection Connection
`StatusReply`	`set(byte[] key0, byte[] value1)` Set the string value of a key String
`IntegerReply`	`setbit(byte[] key0, byte[] offset1, byte[] value2)` Sets or clears the bit at offset in the string value stored at key String
`StatusReply`	`setex(byte[] key0, byte[] seconds1, byte[] value2)` Set the value and expiration of a key String
`IntegerReply`	`setnx(byte[] key0, byte[] value1)` Set the value of a key, only if the key does not exist String
`IntegerReply`	`setrange(byte[] key0, byte[] offset1, byte[] value2)` Overwrite part of a string at key starting at the specified offset String
`StatusReply`	`shutdown(byte[] NOSAVE0, byte[] SAVE1)` Synchronously save the dataset to disk and then shut down the server Server
`MultiBulkReply`	`sinter(byte[][] key0)` Intersect multiple sets Set
`IntegerReply`	`sinterstore(byte[] destination0, byte[][] key1)` Intersect multiple sets and store the resulting set in a key Set
`IntegerReply`	`sismember(byte[] key0, byte[] member1)` Determine if a given value is a member of a set Set
`StatusReply`	`slaveof(byte[] host0, byte[] port1)` Make the server a slave of another instance, or promote it as master Server
`Reply`	`slowlog(byte[] subcommand0, byte[] argument1)` Manages the Redis slow queries log Server
`MultiBulkReply`	`smembers(byte[] key0)` Get all the members in a set Set
`IntegerReply`	`smove(byte[] source0, byte[] destination1, byte[] member2)` Move a member from one set to another Set
`Reply`	`sort(byte[] key0, byte[][] pattern1)` Sort the elements in a list, set or sorted set Generic
`BulkReply`	`spop(byte[] key0)` Remove and return a random member from a set Set
`Reply`	`srandmember(byte[] key0, byte[] count1)` Get one or multiple random members from a set Set
`IntegerReply`	`srem(byte[] key0, byte[][] member1)` Remove one or more members from a set Set
`IntegerReply`	`strlen(byte[] key0)` Get the length of the value stored in a key String
`MultiBulkReply`	`sunion(byte[][] key0)` Add multiple sets Set
`IntegerReply`	`sunionstore(byte[] destination0, byte[][] key1)` Add multiple sets and store the resulting set in a key Set
`Reply`	`sync()` Internal command used for replication Server
`MultiBulkReply`	`time()` Return the current server time Server
`IntegerReply`	`ttl(byte[] key0)` Get the time to live for a key Generic
`StatusReply`	`type(byte[] key0)` Determine the type stored at key Generic
`StatusReply`	`unwatch()` Forget about all watched keys Transactions
`StatusReply`	`watch(byte[][] key0)` Watch the given keys to determine execution of the MULTI/EXEC block Transactions
`IntegerReply`	`zadd(byte[][] args)` Add one or more members to a sorted set, or update its score if it already exists Sorted_set
`IntegerReply`	`zcard(byte[] key0)` Get the number of members in a sorted set Sorted_set
`IntegerReply`	`zcount(byte[] key0, byte[] min1, byte[] max2)` Count the members in a sorted set with scores within the given values Sorted_set
`BulkReply`	`zincrby(byte[] key0, byte[] increment1, byte[] member2)` Increment the score of a member in a sorted set Sorted_set
`IntegerReply`	`zinterstore(byte[] destination0, byte[] numkeys1, byte[][] key2)` Intersect multiple sorted sets and store the resulting sorted set in a new key Sorted_set
`MultiBulkReply`	`zrange(byte[] key0, byte[] start1, byte[] stop2, byte[] withscores3)` Return a range of members in a sorted set, by index Sorted_set
`MultiBulkReply`	`zrangebyscore(byte[] key0, byte[] min1, byte[] max2, byte[][] withscores_offset_or_count4)` Return a range of members in a sorted set, by score Sorted_set
`Reply`	`zrank(byte[] key0, byte[] member1)` Determine the index of a member in a sorted set Sorted_set
`IntegerReply`	`zrem(byte[] key0, byte[][] member1)` Remove one or more members from a sorted set Sorted_set
`IntegerReply`	`zremrangebyrank(byte[] key0, byte[] start1, byte[] stop2)` Remove all members in a sorted set within the given indexes Sorted_set
`IntegerReply`	`zremrangebyscore(byte[] key0, byte[] min1, byte[] max2)` Remove all members in a sorted set within the given scores Sorted_set
`MultiBulkReply`	`zrevrange(byte[] key0, byte[] start1, byte[] stop2, byte[] withscores3)` Return a range of members in a sorted set, by index, with scores ordered from high to low Sorted_set
`MultiBulkReply`	`zrevrangebyscore(byte[] key0, byte[] max1, byte[] min2, byte[][] withscores_offset_or_count4)` Return a range of members in a sorted set, by score, with scores ordered from high to low Sorted_set
`Reply`	`zrevrank(byte[] key0, byte[] member1)` Determine the index of a member in a sorted set, with scores ordered from high to low Sorted_set
`BulkReply`	`zscore(byte[] key0, byte[] member1)` Get the score associated with the given member in a sorted set Sorted_set
`IntegerReply`	`zunionstore(byte[] destination0, byte[] numkeys1, byte[][] key2)` Add multiple sorted sets and store the resulting sorted set in a new key Sorted_set

- Method Detail
  - append
```
IntegerReply append(byte[] key0,
                  byte[] value1)
                    throws RedisException
```
    Append a value to a key String
    
    Parameters:
    key0 -
    value1 -
    
    Returns:
    IntegerReply
    
    Throws:
    
    RedisException
  - bitcount
```
IntegerReply bitcount(byte[] key0,
                    byte[] start1,
                    byte[] end2)
                      throws RedisException
```
    Count set bits in a string String
    
    Parameters:
    key0 -
    start1 -
    end2 -
    
    Returns:
    IntegerReply
    
    Throws:
    
    RedisException
  - bitop
```
IntegerReply bitop(byte[] operation0,
                 byte[] destkey1,
                 byte[][] key2)
                   throws RedisException
```
    Perform bitwise operations between strings String
    
    Parameters:
    operation0 -
    destkey1 -
    key2 -
    
    Returns:
    IntegerReply
    
    Throws:
    
    RedisException
  - decr
```
IntegerReply decr(byte[] key0)
                  throws RedisException
```
    Decrement the integer value of a key by one String
    
    Parameters:
    key0 -
    
    Returns:
    IntegerReply
    
    Throws:
    
    RedisException
  - decrby
```
IntegerReply decrby(byte[] key0,
                  byte[] decrement1)
                    throws RedisException
```
    Decrement the integer value of a key by the given number String
    
    Parameters:
    key0 -
    decrement1 -
    
    Returns:
    IntegerReply
    
    Throws:
    
    RedisException
  - get
```
BulkReply get(byte[] key0)
              throws RedisException
```
    Get the value of a key String
    
    Parameters:
    key0 -
    
    Returns:
    BulkReply
    
    Throws:
    
    RedisException
  - getbit
```
IntegerReply getbit(byte[] key0,
                  byte[] offset1)
                    throws RedisException
```
    Returns the bit value at offset in the string value stored at key String
    
    Parameters:
    key0 -
    offset1 -
    
    Returns:
    IntegerReply
    
    Throws:
    
    RedisException
  - getrange
```
BulkReply getrange(byte[] key0,
                 byte[] start1,
                 byte[] end2)
                   throws RedisException
```
    Get a substring of the string stored at a key String
    
    Parameters:
    key0 -
    start1 -
    end2 -
    
    Returns:
    BulkReply
    
    Throws:
    
    RedisException
  - getset
```
BulkReply getset(byte[] key0,
               byte[] value1)
                 throws RedisException
```
    Set the string value of a key and return its old value String
    
    Parameters:
    key0 -
    value1 -
    
    Returns:
    BulkReply
    
    Throws:
    
    RedisException
  - incr
```
IntegerReply incr(byte[] key0)
                  throws RedisException
```
    Increment the integer value of a key by one String
    
    Parameters:
    key0 -
    
    Returns:
    IntegerReply
    
    Throws:
    
    RedisException
  - incrby
```
IntegerReply incrby(byte[] key0,
                  byte[] increment1)
                    throws RedisException
```
    Increment the integer value of a key by the given amount String
    
    Parameters:
    key0 -
    increment1 -
    
    Returns:
    IntegerReply
    
    Throws:
    
    RedisException
  - incrbyfloat
```
BulkReply incrbyfloat(byte[] key0,
                    byte[] increment1)
                      throws RedisException
```
    Increment the float value of a key by the given amount String
    
    Parameters:
    key0 -
    increment1 -
    
    Returns:
    BulkReply
    
    Throws:
    
    RedisException
  - mget
```
MultiBulkReply mget(byte[][] key0)
                    throws RedisException
```
    Get the values of all the given keys String
    
    Parameters:
    key0 -
    
    Returns:
    MultiBulkReply
    
    Throws:
    
    RedisException
  - mset
```
StatusReply mset(byte[][] key_or_value0)
                 throws RedisException
```
    Set multiple keys to multiple values String
    
    Parameters:
    key_or_value0 -
    
    Returns:
    StatusReply
    
    Throws:
    
    RedisException
  - msetnx
```
IntegerReply msetnx(byte[][] key_or_value0)
                    throws RedisException
```
    Set multiple keys to multiple values, only if none of the keys exist String
    
    Parameters:
    key_or_value0 -
    
    Returns:
    IntegerReply
    
    Throws:
    
    RedisException
  - psetex
```
Reply psetex(byte[] key0,
           byte[] milliseconds1,
           byte[] value2)
             throws RedisException
```
    Set the value and expiration in milliseconds of a key String
    
    Parameters:
    key0 -
    milliseconds1 -
    value2 -
    
    Returns:
    Reply
    
    Throws:
    
    RedisException
  - set
```
StatusReply set(byte[] key0,
              byte[] value1)
                throws RedisException
```
    Set the string value of a key String
    
    Parameters:
    key0 -
    value1 -
    
    Returns:
    StatusReply
    
    Throws:
    
    RedisException
  - setbit
```
IntegerReply setbit(byte[] key0,
                  byte[] offset1,
                  byte[] value2)
                    throws RedisException
```
    Sets or clears the bit at offset in the string value stored at key String
    
    Parameters:
    key0 -
    offset1 -
    value2 -
    
    Returns:
    IntegerReply
    
    Throws:
    
    RedisException
  - setex
```
StatusReply setex(byte[] key0,
                byte[] seconds1,
                byte[] value2)
                  throws RedisException
```
    Set the value and expiration of a key String
    
    Parameters:
    key0 -
    seconds1 -
    value2 -
    
    Returns:
    StatusReply
    
    Throws:
    
    RedisException
  - setnx
```
IntegerReply setnx(byte[] key0,
                 byte[] value1)
                   throws RedisException
```
    Set the value of a key, only if the key does not exist String
    
    Parameters:
    key0 -
    value1 -
    
    Returns:
    IntegerReply
    
    Throws:
    
    RedisException
  - setrange
```
IntegerReply setrange(byte[] key0,
                    byte[] offset1,
                    byte[] value2)
                      throws RedisException
```
    Overwrite part of a string at key starting at the specified offset String
    
    Parameters:
    key0 -
    offset1 -
    value2 -
    
    Returns:
    IntegerReply
    
    Throws:
    
    RedisException
  - strlen
```
IntegerReply strlen(byte[] key0)
                    throws RedisException
```
    Get the length of the value stored in a key String
    
    Parameters:
    key0 -
    
    Returns:
    IntegerReply
    
    Throws:
    
    RedisException
  - echo
```
BulkReply echo(byte[] message0)
               throws RedisException
```
    Echo the given string Connection
    
    Parameters:
    message0 -
    
    Returns:
    BulkReply
    
    Throws:
    
    RedisException
  - ping
```
StatusReply ping()
                 throws RedisException
```
    Ping the server Connection
    
    Returns:
    StatusReply
    
    Throws:
    
    RedisException
  - quit
```
StatusReply quit()
                 throws RedisException
```
    Close the connection Connection
    
    Returns:
    StatusReply
    
    Throws:
    
    RedisException
  - select
```
StatusReply select(byte[] index0)
                   throws RedisException
```
    Change the selected database for the current connection Connection
    
    Parameters:
    index0 -
    
    Returns:
    StatusReply
    
    Throws:
    
    RedisException
  - bgrewriteaof
```
StatusReply bgrewriteaof()
                         throws RedisException
```
    Asynchronously rewrite the append-only file Server
    
    Returns:
    StatusReply
    
    Throws:
    
    RedisException
  - bgsave
```
StatusReply bgsave()
                   throws RedisException
```
    Asynchronously save the dataset to disk Server
    
    Returns:
    StatusReply
    
    Throws:
    
    RedisException
  - client_kill
```
Reply client_kill(byte[] ip_port0)
                  throws RedisException
```
    Kill the connection of a client Server
    
    Parameters:
    ip_port0 -
    
    Returns:
    Reply
    
    Throws:
    
    RedisException
  - client_list
```
Reply client_list()
                  throws RedisException
```
    Get the list of client connections Server
    
    Returns:
    Reply
    
    Throws:
    
    RedisException
  - client_getname
```
Reply client_getname()
                     throws RedisException
```
    Get the current connection name Server
    
    Returns:
    Reply
    
    Throws:
    
    RedisException
  - client_setname
```
Reply client_setname(byte[] connection_name0)
                     throws RedisException
```
    Set the current connection name Server
    
    Parameters:
    connection_name0 -
    
    Returns:
    Reply
    
    Throws:
    
    RedisException
  - config_get
```
Reply config_get(byte[] parameter0)
                 throws RedisException
```
    Get the value of a configuration parameter Server
    
    Parameters:
    parameter0 -
    
    Returns:
    Reply
    
    Throws:
    
    RedisException
  - config_set
```
Reply config_set(byte[] parameter0,
               byte[] value1)
                 throws RedisException
```
    Set a configuration parameter to the given value Server
    
    Parameters:
    parameter0 -
    value1 -
    
    Returns:
    Reply
    
    Throws:
    
    RedisException
  - config_resetstat
```
Reply config_resetstat()
                       throws RedisException
```
    Reset the stats returned by INFO Server
    
    Returns:
    Reply
    
    Throws:
    
    RedisException
  - dbsize
```
IntegerReply dbsize()
                    throws RedisException
```
    Return the number of keys in the selected database Server
    
    Returns:
    IntegerReply
    
    Throws:
    
    RedisException
  - debug_object
```
Reply debug_object(byte[] key0)
                   throws RedisException
```
    Get debugging information about a key Server
    
    Parameters:
    key0 -
    
    Returns:
    Reply
    
    Throws:
    
    RedisException
  - debug_segfault
```
Reply debug_segfault()
                     throws RedisException
```
    Make the server crash Server
    
    Returns:
    Reply
    
    Throws:
    
    RedisException
  - flushall
```
StatusReply flushall()
                     throws RedisException
```
    Remove all keys from all databases Server
    
    Returns:
    StatusReply
    
    Throws:
    
    RedisException
  - flushdb
```
StatusReply flushdb()
                    throws RedisException
```
    Remove all keys from the current database Server
    
    Returns:
    StatusReply
    
    Throws:
    
    RedisException
  - info
```
BulkReply info(byte[] section0)
               throws RedisException
```
    Get information and statistics about the server Server
    
    Parameters:
    section0 -
    
    Returns:
    BulkReply
    
    Throws:
    
    RedisException
  - lastsave
```
IntegerReply lastsave()
                      throws RedisException
```
    Get the UNIX time stamp of the last successful save to disk Server
    
    Returns:
    IntegerReply
    
    Throws:
    
    RedisException
  - monitor
```
Reply monitor()
              throws RedisException
```
    Listen for all requests received by the server in real time Server
    
    Returns:
    Reply
    
    Throws:
    
    RedisException
  - save
```
Reply save()
           throws RedisException
```
    Synchronously save the dataset to disk Server
    
    Returns:
    Reply
    
    Throws:
    
    RedisException
  - shutdown
```
StatusReply shutdown(byte[] NOSAVE0,
                   byte[] SAVE1)
                     throws RedisException
```
    Synchronously save the dataset to disk and then shut down the server Server
    
    Parameters:
    NOSAVE0 -
    SAVE1 -
    
    Returns:
    StatusReply
    
    Throws:
    
    RedisException
  - slaveof
```
StatusReply slaveof(byte[] host0,
                  byte[] port1)
                    throws RedisException
```
    Make the server a slave of another instance, or promote it as master Server
    
    Parameters:
    host0 -
    port1 -
    
    Returns:
    StatusReply
    
    Throws:
    
    RedisException
  - slowlog
```
Reply slowlog(byte[] subcommand0,
            byte[] argument1)
              throws RedisException
```
    Manages the Redis slow queries log Server
    
    Parameters:
    subcommand0 -
    argument1 -
    
    Returns:
    Reply
    
    Throws:
    
    RedisException
  - sync
```
Reply sync()
           throws RedisException
```
    Internal command used for replication Server
    
    Returns:
    Reply
    
    Throws:
    
    RedisException
  - time
```
MultiBulkReply time()
                    throws RedisException
```
    Return the current server time Server
    
    Returns:
    MultiBulkReply
    
    Throws:
    
    RedisException
  - blpop
```
MultiBulkReply blpop(byte[][] key0)
                     throws RedisException
```
    Remove and get the first element in a list, or block until one is available List
    
    Parameters:
    key0 -
    
    Returns:
    MultiBulkReply
    
    Throws:
    
    RedisException
  - brpop
```
MultiBulkReply brpop(byte[][] key0)
                     throws RedisException
```
    Remove and get the last element in a list, or block until one is available List
    
    Parameters:
    key0 -
    
    Returns:
    MultiBulkReply
    
    Throws:
    
    RedisException
  - brpoplpush
```
BulkReply brpoplpush(byte[] source0,
                   byte[] destination1,
                   byte[] timeout2)
                     throws RedisException
```
    Pop a value from a list, push it to another list and return it; or block until one is available List
    
    Parameters:
    source0 -
    destination1 -
    timeout2 -
    
    Returns:
    BulkReply
    
    Throws:
    
    RedisException
  - lindex
```
BulkReply lindex(byte[] key0,
               byte[] index1)
                 throws RedisException
```
    Get an element from a list by its index List
    
    Parameters:
    key0 -
    index1 -
    
    Returns:
    BulkReply
    
    Throws:
    
    RedisException
  - linsert
```
IntegerReply linsert(byte[] key0,
                   byte[] where1,
                   byte[] pivot2,
                   byte[] value3)
                     throws RedisException
```
    Insert an element before or after another element in a list List
    
    Parameters:
    key0 -
    where1 -
    pivot2 -
    value3 -
    
    Returns:
    IntegerReply
    
    Throws:
    
    RedisException
  - llen
```
IntegerReply llen(byte[] key0)
                  throws RedisException
```
    Get the length of a list List
    
    Parameters:
    key0 -
    
    Returns:
    IntegerReply
    
    Throws:
    
    RedisException
  - lpop
```
BulkReply lpop(byte[] key0)
               throws RedisException
```
    Remove and get the first element in a list List
    
    Parameters:
    key0 -
    
    Returns:
    BulkReply
    
    Throws:
    
    RedisException
  - lpush
```
IntegerReply lpush(byte[] key0,
                 byte[][] value1)
                   throws RedisException
```
    Prepend one or multiple values to a list List
    
    Parameters:
    key0 -
    value1 -
    
    Returns:
    IntegerReply
    
    Throws:
    
    RedisException
  - lpushx
```
IntegerReply lpushx(byte[] key0,
                  byte[] value1)
                    throws RedisException
```
    Prepend a value to a list, only if the list exists List
    
    Parameters:
    key0 -
    value1 -
    
    Returns:
    IntegerReply
    
    Throws:
    
    RedisException
  - lrange
```
MultiBulkReply lrange(byte[] key0,
                    byte[] start1,
                    byte[] stop2)
                      throws RedisException
```
    Get a range of elements from a list List
    
    Parameters:
    key0 -
    start1 -
    stop2 -
    
    Returns:
    MultiBulkReply
    
    Throws:
    
    RedisException
  - lrem
```
IntegerReply lrem(byte[] key0,
                byte[] count1,
                byte[] value2)
                  throws RedisException
```
    Remove elements from a list List
    
    Parameters:
    key0 -
    count1 -
    value2 -
    
    Returns:
    IntegerReply
    
    Throws:
    
    RedisException
  - lset
```
StatusReply lset(byte[] key0,
               byte[] index1,
               byte[] value2)
                 throws RedisException
```
    Set the value of an element in a list by its index List
    
    Parameters:
    key0 -
    index1 -
    value2 -
    
    Returns:
    StatusReply
    
    Throws:
    
    RedisException
  - ltrim
```
StatusReply ltrim(byte[] key0,
                byte[] start1,
                byte[] stop2)
                  throws RedisException
```
    Trim a list to the specified range List
    
    Parameters:
    key0 -
    start1 -
    stop2 -
    
    Returns:
    StatusReply
    
    Throws:
    
    RedisException
  - rpop
```
BulkReply rpop(byte[] key0)
               throws RedisException
```
    Remove and get the last element in a list List
    
    Parameters:
    key0 -
    
    Returns:
    BulkReply
    
    Throws:
    
    RedisException
  - rpoplpush
```
BulkReply rpoplpush(byte[] source0,
                  byte[] destination1)
                    throws RedisException
```
    Remove the last element in a list, append it to another list and return it List
    
    Parameters:
    source0 -
    destination1 -
    
    Returns:
    BulkReply
    
    Throws:
    
    RedisException
  - rpush
```
IntegerReply rpush(byte[] key0,
                 byte[][] value1)
                   throws RedisException
```
    Append one or multiple values to a list List
    
    Parameters:
    key0 -
    value1 -
    
    Returns:
    IntegerReply
    
    Throws:
    
    RedisException
  - rpushx
```
IntegerReply rpushx(byte[] key0,
                  byte[] value1)
                    throws RedisException
```
    Append a value to a list, only if the list exists List
    
    Parameters:
    key0 -
    value1 -
    
    Returns:
    IntegerReply
    
    Throws:
    
    RedisException
  - del
```
IntegerReply del(byte[][] key0)
                 throws RedisException
```
    Delete a key Generic
    
    Parameters:
    key0 -
    
    Returns:
    IntegerReply
    
    Throws:
    
    RedisException
  - dump
```
BulkReply dump(byte[] key0)
               throws RedisException
```
    Return a serialized version of the value stored at the specified key. Generic
    
    Parameters:
    key0 -
    
    Returns:
    BulkReply
    
    Throws:
    
    RedisException
  - exists
```
IntegerReply exists(byte[] key0)
                    throws RedisException
```
    Determine if a key exists Generic
    
    Parameters:
    key0 -
    
    Returns:
    IntegerReply
    
    Throws:
    
    RedisException
  - expire
```
IntegerReply expire(byte[] key0,
                  byte[] seconds1)
                    throws RedisException
```
    Set a key's time to live in seconds Generic
    
    Parameters:
    key0 -
    seconds1 -
    
    Returns:
    IntegerReply
    
    Throws:
    
    RedisException
  - expireat
```
IntegerReply expireat(byte[] key0,
                    byte[] timestamp1)
                      throws RedisException
```
    Set the expiration for a key as a UNIX timestamp Generic
    
    Parameters:
    key0 -
    timestamp1 -
    
    Returns:
    IntegerReply
    
    Throws:
    
    RedisException
  - keys
```
MultiBulkReply keys(byte[] pattern0)
                    throws RedisException
```
    Find all keys matching the given pattern Generic
    
    Parameters:
    pattern0 -
    
    Returns:
    MultiBulkReply
    
    Throws:
    
    RedisException
  - migrate
```
StatusReply migrate(byte[] host0,
                  byte[] port1,
                  byte[] key2,
                  byte[] destination_db3,
                  byte[] timeout4)
                    throws RedisException
```
    Atomically transfer a key from a Redis instance to another one. Generic
    
    Parameters:
    host0 -
    port1 -
    key2 -
    destination_db3 -
    timeout4 -
    
    Returns:
    StatusReply
    
    Throws:
    
    RedisException
  - move
```
IntegerReply move(byte[] key0,
                byte[] db1)
                  throws RedisException
```
    Move a key to another database Generic
    
    Parameters:
    key0 -
    db1 -
    
    Returns:
    IntegerReply
    
    Throws:
    
    RedisException
  - object
```
Reply object(byte[] subcommand0,
           byte[][] arguments1)
             throws RedisException
```
    Inspect the internals of Redis objects Generic
    
    Parameters:
    subcommand0 -
    arguments1 -
    
    Returns:
    Reply
    
    Throws:
    
    RedisException
  - persist
```
IntegerReply persist(byte[] key0)
                     throws RedisException
```
    Remove the expiration from a key Generic
    
    Parameters:
    key0 -
    
    Returns:
    IntegerReply
    
    Throws:
    
    RedisException
  - pexpire
```
IntegerReply pexpire(byte[] key0,
                   byte[] milliseconds1)
                     throws RedisException
```
    Set a key's time to live in milliseconds Generic
    
    Parameters:
    key0 -
    milliseconds1 -
    
    Returns:
    IntegerReply
    
    Throws:
    
    RedisException
  - pexpireat
```
IntegerReply pexpireat(byte[] key0,
                     byte[] milliseconds_timestamp1)
                       throws RedisException
```
    Set the expiration for a key as a UNIX timestamp specified in milliseconds Generic
    
    Parameters:
    key0 -
    milliseconds_timestamp1 -
    
    Returns:
    IntegerReply
    
    Throws:
    
    RedisException
  - pttl
```
IntegerReply pttl(byte[] key0)
                  throws RedisException
```
    Get the time to live for a key in milliseconds Generic
    
    Parameters:
    key0 -
    
    Returns:
    IntegerReply
    
    Throws:
    
    RedisException
  - randomkey
```
BulkReply randomkey()
                    throws RedisException
```
    Return a random key from the keyspace Generic
    
    Returns:
    BulkReply
    
    Throws:
    
    RedisException
  - rename
```
StatusReply rename(byte[] key0,
                 byte[] newkey1)
                   throws RedisException
```
    Rename a key Generic
    
    Parameters:
    key0 -
    newkey1 -
    
    Returns:
    StatusReply
    
    Throws:
    
    RedisException
  - renamenx
```
IntegerReply renamenx(byte[] key0,
                    byte[] newkey1)
                      throws RedisException
```
    Rename a key, only if the new key does not exist Generic
    
    Parameters:
    key0 -
    newkey1 -
    
    Returns:
    IntegerReply
    
    Throws:
    
    RedisException
  - restore
```
StatusReply restore(byte[] key0,
                  byte[] ttl1,
                  byte[] serialized_value2)
                    throws RedisException
```
    Create a key using the provided serialized value, previously obtained using DUMP. Generic
    
    Parameters:
    key0 -
    ttl1 -
    serialized_value2 -
    
    Returns:
    StatusReply
    
    Throws:
    
    RedisException
  - sort
```
Reply sort(byte[] key0,
         byte[][] pattern1)
           throws RedisException
```
    Sort the elements in a list, set or sorted set Generic
    
    Parameters:
    key0 -
    pattern1 -
    
    Returns:
    Reply
    
    Throws:
    
    RedisException
  - ttl
```
IntegerReply ttl(byte[] key0)
                 throws RedisException
```
    Get the time to live for a key Generic
    
    Parameters:
    key0 -
    
    Returns:
    IntegerReply
    
    Throws:
    
    RedisException
  - type
```
StatusReply type(byte[] key0)
                 throws RedisException
```
    Determine the type stored at key Generic
    
    Parameters:
    key0 -
    
    Returns:
    StatusReply
    
    Throws:
    
    RedisException
  - unwatch
```
StatusReply unwatch()
                    throws RedisException
```
    Forget about all watched keys Transactions
    
    Returns:
    StatusReply
    
    Throws:
    
    RedisException
  - watch
```
StatusReply watch(byte[][] key0)
                  throws RedisException
```
    Watch the given keys to determine execution of the MULTI/EXEC block Transactions
    
    Parameters:
    key0 -
    
    Returns:
    StatusReply
    
    Throws:
    
    RedisException
  - eval
```
Reply eval(byte[] script0,
         byte[] numkeys1,
         byte[][] key2)
           throws RedisException
```
    Execute a Lua script server side Scripting
    
    Parameters:
    script0 -
    numkeys1 -
    key2 -
    
    Returns:
    Reply
    
    Throws:
    
    RedisException
  - evalsha
```
Reply evalsha(byte[] sha10,
            byte[] numkeys1,
            byte[][] key2)
              throws RedisException
```
    Execute a Lua script server side Scripting
    
    Parameters:
    sha10 -
    numkeys1 -
    key2 -
    
    Returns:
    Reply
    
    Throws:
    
    RedisException
  - script_exists
```
Reply script_exists(byte[][] script0)
                    throws RedisException
```
    Check existence of scripts in the script cache. Scripting
    
    Parameters:
    script0 -
    
    Returns:
    Reply
    
    Throws:
    
    RedisException
  - script_flush
```
Reply script_flush()
                   throws RedisException
```
    Remove all the scripts from the script cache. Scripting
    
    Returns:
    Reply
    
    Throws:
    
    RedisException
  - script_kill
```
Reply script_kill()
                  throws RedisException
```
    Kill the script currently in execution. Scripting
    
    Returns:
    Reply
    
    Throws:
    
    RedisException
  - script_load
```
Reply script_load(byte[] script0)
                  throws RedisException
```
    Load the specified Lua script into the script cache. Scripting
    
    Parameters:
    script0 -
    
    Returns:
    Reply
    
    Throws:
    
    RedisException
  - hdel
```
IntegerReply hdel(byte[] key0,
                byte[][] field1)
                  throws RedisException
```
    Delete one or more hash fields Hash
    
    Parameters:
    key0 -
    field1 -
    
    Returns:
    IntegerReply
    
    Throws:
    
    RedisException
  - hexists
```
IntegerReply hexists(byte[] key0,
                   byte[] field1)
                     throws RedisException
```
    Determine if a hash field exists Hash
    
    Parameters:
    key0 -
    field1 -
    
    Returns:
    IntegerReply
    
    Throws:
    
    RedisException
  - hget
```
BulkReply hget(byte[] key0,
             byte[] field1)
               throws RedisException
```
    Get the value of a hash field Hash
    
    Parameters:
    key0 -
    field1 -
    
    Returns:
    BulkReply
    
    Throws:
    
    RedisException
  - hgetall
```
MultiBulkReply hgetall(byte[] key0)
                       throws RedisException
```
    Get all the fields and values in a hash Hash
    
    Parameters:
    key0 -
    
    Returns:
    MultiBulkReply
    
    Throws:
    
    RedisException
  - hincrby
```
IntegerReply hincrby(byte[] key0,
                   byte[] field1,
                   byte[] increment2)
                     throws RedisException
```
    Increment the integer value of a hash field by the given number Hash
    
    Parameters:
    key0 -
    field1 -
    increment2 -
    
    Returns:
    IntegerReply
    
    Throws:
    
    RedisException
  - hincrbyfloat
```
BulkReply hincrbyfloat(byte[] key0,
                     byte[] field1,
                     byte[] increment2)
                       throws RedisException
```
    Increment the float value of a hash field by the given amount Hash
    
    Parameters:
    key0 -
    field1 -
    increment2 -
    
    Returns:
    BulkReply
    
    Throws:
    
    RedisException
  - hkeys
```
MultiBulkReply hkeys(byte[] key0)
                     throws RedisException
```
    Get all the fields in a hash Hash
    
    Parameters:
    key0 -
    
    Returns:
    MultiBulkReply
    
    Throws:
    
    RedisException
  - hlen
```
IntegerReply hlen(byte[] key0)
                  throws RedisException
```
    Get the number of fields in a hash Hash
    
    Parameters:
    key0 -
    
    Returns:
    IntegerReply
    
    Throws:
    
    RedisException
  - hmget
```
MultiBulkReply hmget(byte[] key0,
                   byte[][] field1)
                     throws RedisException
```
    Get the values of all the given hash fields Hash
    
    Parameters:
    key0 -
    field1 -
    
    Returns:
    MultiBulkReply
    
    Throws:
    
    RedisException
  - hmset
```
StatusReply hmset(byte[] key0,
                byte[][] field_or_value1)
                  throws RedisException
```
    Set multiple hash fields to multiple values Hash
    
    Parameters:
    key0 -
    field_or_value1 -
    
    Returns:
    StatusReply
    
    Throws:
    
    RedisException
  - hset
```
IntegerReply hset(byte[] key0,
                byte[] field1,
                byte[] value2)
                  throws RedisException
```
    Set the string value of a hash field Hash
    
    Parameters:
    key0 -
    field1 -
    value2 -
    
    Returns:
    IntegerReply
    
    Throws:
    
    RedisException
  - hsetnx
```
IntegerReply hsetnx(byte[] key0,
                  byte[] field1,
                  byte[] value2)
                    throws RedisException
```
    Set the value of a hash field, only if the field does not exist Hash
    
    Parameters:
    key0 -
    field1 -
    value2 -
    
    Returns:
    IntegerReply
    
    Throws:
    
    RedisException
  - hvals
```
MultiBulkReply hvals(byte[] key0)
                     throws RedisException
```
    Get all the values in a hash Hash
    
    Parameters:
    key0 -
    
    Returns:
    MultiBulkReply
    
    Throws:
    
    RedisException
  - publish
```
IntegerReply publish(byte[] channel0,
                   byte[] message1)
                     throws RedisException
```
    Post a message to a channel Pubsub
    
    Parameters:
    channel0 -
    message1 -
    
    Returns:
    IntegerReply
    
    Throws:
    
    RedisException
  - sadd
```
IntegerReply sadd(byte[] key0,
                byte[][] member1)
                  throws RedisException
```
    Add one or more members to a set Set
    
    Parameters:
    key0 -
    member1 -
    
    Returns:
    IntegerReply
    
    Throws:
    
    RedisException
  - scard
```
IntegerReply scard(byte[] key0)
                   throws RedisException
```
    Get the number of members in a set Set
    
    Parameters:
    key0 -
    
    Returns:
    IntegerReply
    
    Throws:
    
    RedisException
  - sdiff
```
MultiBulkReply sdiff(byte[][] key0)
                     throws RedisException
```
    Subtract multiple sets Set
    
    Parameters:
    key0 -
    
    Returns:
    MultiBulkReply
    
    Throws:
    
    RedisException
  - sdiffstore
```
IntegerReply sdiffstore(byte[] destination0,
                      byte[][] key1)
                        throws RedisException
```
    Subtract multiple sets and store the resulting set in a key Set
    
    Parameters:
    destination0 -
    key1 -
    
    Returns:
    IntegerReply
    
    Throws:
    
    RedisException
  - sinter
```
MultiBulkReply sinter(byte[][] key0)
                      throws RedisException
```
    Intersect multiple sets Set
    
    Parameters:
    key0 -
    
    Returns:
    MultiBulkReply
    
    Throws:
    
    RedisException
  - sinterstore
```
IntegerReply sinterstore(byte[] destination0,
                       byte[][] key1)
                         throws RedisException
```
    Intersect multiple sets and store the resulting set in a key Set
    
    Parameters:
    destination0 -
    key1 -
    
    Returns:
    IntegerReply
    
    Throws:
    
    RedisException
  - sismember
```
IntegerReply sismember(byte[] key0,
                     byte[] member1)
                       throws RedisException
```
    Determine if a given value is a member of a set Set
    
    Parameters:
    key0 -
    member1 -
    
    Returns:
    IntegerReply
    
    Throws:
    
    RedisException
  - smembers
```
MultiBulkReply smembers(byte[] key0)
                        throws RedisException
```
    Get all the members in a set Set
    
    Parameters:
    key0 -
    
    Returns:
    MultiBulkReply
    
    Throws:
    
    RedisException
  - smove
```
IntegerReply smove(byte[] source0,
                 byte[] destination1,
                 byte[] member2)
                   throws RedisException
```
    Move a member from one set to another Set
    
    Parameters:
    source0 -
    destination1 -
    member2 -
    
    Returns:
    IntegerReply
    
    Throws:
    
    RedisException
  - spop
```
BulkReply spop(byte[] key0)
               throws RedisException
```
    Remove and return a random member from a set Set
    
    Parameters:
    key0 -
    
    Returns:
    BulkReply
    
    Throws:
    
    RedisException
  - srandmember
```
Reply srandmember(byte[] key0,
                byte[] count1)
                  throws RedisException
```
    Get one or multiple random members from a set Set
    
    Parameters:
    key0 -
    count1 -
    
    Returns:
    Reply
    
    Throws:
    
    RedisException
  - srem
```
IntegerReply srem(byte[] key0,
                byte[][] member1)
                  throws RedisException
```
    Remove one or more members from a set Set
    
    Parameters:
    key0 -
    member1 -
    
    Returns:
    IntegerReply
    
    Throws:
    
    RedisException
  - sunion
```
MultiBulkReply sunion(byte[][] key0)
                      throws RedisException
```
    Add multiple sets Set
    
    Parameters:
    key0 -
    
    Returns:
    MultiBulkReply
    
    Throws:
    
    RedisException
  - sunionstore
```
IntegerReply sunionstore(byte[] destination0,
                       byte[][] key1)
                         throws RedisException
```
    Add multiple sets and store the resulting set in a key Set
    
    Parameters:
    destination0 -
    key1 -
    
    Returns:
    IntegerReply
    
    Throws:
    
    RedisException
  - zadd
```
IntegerReply zadd(byte[][] args)
                  throws RedisException
```
    Add one or more members to a sorted set, or update its score if it already exists Sorted_set
    
    Parameters:
    args -
    
    Returns:
    IntegerReply
    
    Throws:
    
    RedisException
  - zcard
```
IntegerReply zcard(byte[] key0)
                   throws RedisException
```
    Get the number of members in a sorted set Sorted_set
    
    Parameters:
    key0 -
    
    Returns:
    IntegerReply
    
    Throws:
    
    RedisException
  - zcount
```
IntegerReply zcount(byte[] key0,
                  byte[] min1,
                  byte[] max2)
                    throws RedisException
```
    Count the members in a sorted set with scores within the given values Sorted_set
    
    Parameters:
    key0 -
    min1 -
    max2 -
    
    Returns:
    IntegerReply
    
    Throws:
    
    RedisException
  - zincrby
```
BulkReply zincrby(byte[] key0,
                byte[] increment1,
                byte[] member2)
                  throws RedisException
```
    Increment the score of a member in a sorted set Sorted_set
    
    Parameters:
    key0 -
    increment1 -
    member2 -
    
    Returns:
    BulkReply
    
    Throws:
    
    RedisException
  - zinterstore
```
IntegerReply zinterstore(byte[] destination0,
                       byte[] numkeys1,
                       byte[][] key2)
                         throws RedisException
```
    Intersect multiple sorted sets and store the resulting sorted set in a new key Sorted_set
    
    Parameters:
    destination0 -
    numkeys1 -
    key2 -
    
    Returns:
    IntegerReply
    
    Throws:
    
    RedisException
  - zrange
```
MultiBulkReply zrange(byte[] key0,
                    byte[] start1,
                    byte[] stop2,
                    byte[] withscores3)
                      throws RedisException
```
    Return a range of members in a sorted set, by index Sorted_set
    
    Parameters:
    key0 -
    start1 -
    stop2 -
    withscores3 -
    
    Returns:
    MultiBulkReply
    
    Throws:
    
    RedisException
  - zrangebyscore
```
MultiBulkReply zrangebyscore(byte[] key0,
                           byte[] min1,
                           byte[] max2,
                           byte[][] withscores_offset_or_count4)
                             throws RedisException
```
    Return a range of members in a sorted set, by score Sorted_set
    
    Parameters:
    key0 -
    min1 -
    max2 -
    withscores3 -
    offset_or_count4 -
    
    Returns:
    MultiBulkReply
    
    Throws:
    
    RedisException
  - zrank
```
Reply zrank(byte[] key0,
          byte[] member1)
            throws RedisException
```
    Determine the index of a member in a sorted set Sorted_set
    
    Parameters:
    key0 -
    member1 -
    
    Returns:
    Reply
    
    Throws:
    
    RedisException
  - zrem
```
IntegerReply zrem(byte[] key0,
                byte[][] member1)
                  throws RedisException
```
    Remove one or more members from a sorted set Sorted_set
    
    Parameters:
    key0 -
    member1 -
    
    Returns:
    IntegerReply
    
    Throws:
    
    RedisException
  - zremrangebyrank
```
IntegerReply zremrangebyrank(byte[] key0,
                           byte[] start1,
                           byte[] stop2)
                             throws RedisException
```
    Remove all members in a sorted set within the given indexes Sorted_set
    
    Parameters:
    key0 -
    start1 -
    stop2 -
    
    Returns:
    IntegerReply
    
    Throws:
    
    RedisException
  - zremrangebyscore
```
IntegerReply zremrangebyscore(byte[] key0,
                            byte[] min1,
                            byte[] max2)
                              throws RedisException
```
    Remove all members in a sorted set within the given scores Sorted_set
    
    Parameters:
    key0 -
    min1 -
    max2 -
    
    Returns:
    IntegerReply
    
    Throws:
    
    RedisException
  - zrevrange
```
MultiBulkReply zrevrange(byte[] key0,
                       byte[] start1,
                       byte[] stop2,
                       byte[] withscores3)
                         throws RedisException
```
    Return a range of members in a sorted set, by index, with scores ordered from high to low Sorted_set
    
    Parameters:
    key0 -
    start1 -
    stop2 -
    withscores3 -
    
    Returns:
    MultiBulkReply
    
    Throws:
    
    RedisException
  - zrevrangebyscore
```
MultiBulkReply zrevrangebyscore(byte[] key0,
                              byte[] max1,
                              byte[] min2,
                              byte[][] withscores_offset_or_count4)
                                throws RedisException
```
    Return a range of members in a sorted set, by score, with scores ordered from high to low Sorted_set
    
    Parameters:
    key0 -
    max1 -
    min2 -
    withscores3 -
    offset_or_count4 -
    
    Returns:
    MultiBulkReply
    
    Throws:
    
    RedisException
  - zrevrank
```
Reply zrevrank(byte[] key0,
             byte[] member1)
               throws RedisException
```
    Determine the index of a member in a sorted set, with scores ordered from high to low Sorted_set
    
    Parameters:
    key0 -
    member1 -
    
    Returns:
    Reply
    
    Throws:
    
    RedisException
  - zscore
```
BulkReply zscore(byte[] key0,
               byte[] member1)
                 throws RedisException
```
    Get the score associated with the given member in a sorted set Sorted_set
    
    Parameters:
    key0 -
    member1 -
    
    Returns:
    BulkReply
    
    Throws:
    
    RedisException
  - zunionstore
```
IntegerReply zunionstore(byte[] destination0,
                       byte[] numkeys1,
                       byte[][] key2)
                         throws RedisException
```
    Add multiple sorted sets and store the resulting sorted set in a new key Sorted_set
    
    Parameters:
    destination0 -
    numkeys1 -
    key2 -
    
    Returns:
    IntegerReply
    
    Throws:
    
    RedisException

Interface RedisServer

Method Summary

Method Detail

append

bitcount

bitop

decr

decrby

get

getbit

getrange

getset

incr

incrby

incrbyfloat

mget

mset

msetnx

psetex

set

setbit

setex

setnx

setrange

strlen

echo

ping

quit

select

bgrewriteaof

bgsave

client_kill

client_list

client_getname

client_setname

config_get

config_set

config_resetstat

dbsize

debug_object

debug_segfault

flushall

flushdb

info

lastsave

monitor

save

shutdown

slaveof

slowlog

sync

time

blpop

brpop

brpoplpush

lindex

linsert

llen

lpop

lpush

lpushx

lrange

lrem

lset

ltrim

rpop

rpoplpush

rpush

rpushx

del

dump

exists

expire

expireat

keys

migrate

move

object

persist

pexpire