RedisClient (Vert.x Stack - Docs 3.9.15 API)

java.lang.Object
- io.vertx.reactivex.redis.RedisClient

```
public class RedisClient
extends Object
```
This factory is deprecated use Redis instead, or for a typed API RedisAPI.
NOTE: This class has been automatically generated from the original non RX-ified interface using Vert.x codegen.

Field Summary

Fields
Modifier and Type Field and Description

static io.vertx.lang.rx.TypeArg<RedisClient> __TYPE_ARG

Fields
Modifier and Type	Field and Description
`static io.vertx.lang.rx.TypeArg<RedisClient>`	`__TYPE_ARG`

Constructor Summary

Constructors
Constructor and Description

RedisClient(Object delegate)

RedisClient(RedisClient delegate)

Constructors
Constructor and Description
`RedisClient(Object delegate)`
`RedisClient(RedisClient delegate)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`RedisClient`	`append(String key, String value, Handler<AsyncResult<Long>> handler)` Append a value to a key
`RedisClient`	`auth(String password, Handler<AsyncResult<String>> handler)` Authenticate to the server
`RedisClient`	`bgrewriteaof(Handler<AsyncResult<String>> handler)` Asynchronously rewrite the append-only file
`RedisClient`	`bgsave(Handler<AsyncResult<String>> handler)` Asynchronously save the dataset to disk
`RedisClient`	`bitcount(String key, Handler<AsyncResult<Long>> handler)` Count set bits in a string
`RedisClient`	`bitcountRange(String key, long start, long end, Handler<AsyncResult<Long>> handler)` Count set bits in a string
`RedisClient`	`bitfield(String key, BitFieldOptions bitFieldOptions, Handler<AsyncResult<JsonArray>> handler)` Perform arbitrary bitfield integer operations on strings.
`RedisClient`	`bitfieldWithOverflow(String key, BitFieldOptions commands, BitFieldOverflowOptions overflow, Handler<AsyncResult<JsonArray>> handler)` Perform arbitrary bitfield integer operations on strings.
`RedisClient`	`bitop(BitOperation operation, String destkey, List<String> keys, Handler<AsyncResult<Long>> handler)` Perform bitwise operations between strings
`RedisClient`	`bitpos(String key, int bit, Handler<AsyncResult<Long>> handler)` Find first bit set or clear in a string
`RedisClient`	`bitposFrom(String key, int bit, int start, Handler<AsyncResult<Long>> handler)` Find first bit set or clear in a string See also bitposRange() method, which takes start, and stop offset.
`RedisClient`	`bitposRange(String key, int bit, int start, int stop, Handler<AsyncResult<Long>> handler)` Find first bit set or clear in a string Note: when both start, and stop offsets are specified, behaviour is slightly different than if only start is specified
`RedisClient`	`blpop(String key, int seconds, Handler<AsyncResult<JsonArray>> handler)` Remove and get the first element in a list, or block until one is available
`RedisClient`	`blpopMany(List<String> keys, int seconds, Handler<AsyncResult<JsonArray>> handler)` Remove and get the first element in any of the lists, or block until one is available
`RedisClient`	`brpop(String key, int seconds, Handler<AsyncResult<JsonArray>> handler)` Remove and get the last element in a list, or block until one is available
`RedisClient`	`brpoplpush(String key, String destkey, int seconds, Handler<AsyncResult<String>> handler)` Pop a value from a list, push it to another list and return it; or block until one is available
`RedisClient`	`brpopMany(List<String> keys, int seconds, Handler<AsyncResult<JsonArray>> handler)` Remove and get the last element in any of the lists, or block until one is available
`RedisClient`	`clientGetname(Handler<AsyncResult<String>> handler)` Get the current connection name
`RedisClient`	`clientKill(KillFilter filter, Handler<AsyncResult<Long>> handler)` Kill the connection of a client
`RedisClient`	`clientList(Handler<AsyncResult<String>> handler)` Get the list of client connections
`RedisClient`	`clientPause(long millis, Handler<AsyncResult<String>> handler)` Stop processing commands from clients for some time
`RedisClient`	`clientReply(ClientReplyOptions options, Handler<AsyncResult<String>> handler)` Instruct the server whether to reply to commands.
`RedisClient`	`clientSetname(String name, Handler<AsyncResult<String>> handler)` Set the current connection name
`void`	`close(Handler<AsyncResult<Void>> handler)` Close the client - when it is fully closed the handler will be called.
`RedisClient`	`clusterAddslots(List<Long> slots, Handler<AsyncResult<Void>> handler)` Assign new hash slots to receiving node.
`RedisClient`	`clusterCountFailureReports(String nodeId, Handler<AsyncResult<Long>> handler)` Return the number of failure reports active for a given node.
`RedisClient`	`clusterCountkeysinslot(long slot, Handler<AsyncResult<Long>> handler)` Return the number of local keys in the specified hash slot.
`RedisClient`	`clusterDelslots(long slot, Handler<AsyncResult<Void>> handler)` Set hash slots as unbound in receiving node.
`RedisClient`	`clusterDelslotsMany(List<Long> slots, Handler<AsyncResult<Void>> handler)` Set hash slots as unbound in receiving node.
`RedisClient`	`clusterFailover(Handler<AsyncResult<Void>> handler)` Forces a slave to perform a manual failover of its master.
`RedisClient`	`clusterFailOverWithOptions(FailoverOptions options, Handler<AsyncResult<Void>> handler)` Forces a slave to perform a manual failover of its master.
`RedisClient`	`clusterForget(String nodeId, Handler<AsyncResult<Void>> handler)` Remove a node from the nodes table.
`RedisClient`	`clusterGetkeysinslot(long slot, long count, Handler<AsyncResult<JsonArray>> handler)` Return local key names in the specified hash slot.
`RedisClient`	`clusterInfo(Handler<AsyncResult<JsonArray>> handler)` Provides info about Redis Cluster node state.
`RedisClient`	`clusterKeyslot(String key, Handler<AsyncResult<Long>> handler)` Returns the hash slot of the specified key.
`RedisClient`	`clusterMeet(String ip, long port, Handler<AsyncResult<Void>> handler)` Force a node cluster to handshake with another node.
`RedisClient`	`clusterNodes(Handler<AsyncResult<JsonArray>> handler)` Get Cluster config for the node.
`RedisClient`	`clusterReplicate(String nodeId, Handler<AsyncResult<Void>> handler)` Reconfigure a node as a slave of the specified master node.
`RedisClient`	`clusterReset(Handler<AsyncResult<Void>> handler)` Reset a Redis Cluster node.
`RedisClient`	`clusterResetWithOptions(ResetOptions options, Handler<AsyncResult<Void>> handler)` Reset a Redis Cluster node.
`RedisClient`	`clusterSaveconfig(Handler<AsyncResult<Void>> handler)` Forces the node to save cluster state on disk.
`RedisClient`	`clusterSetConfigEpoch(long epoch, Handler<AsyncResult<Void>> handler)` Set the configuration epoch in a new node.
`RedisClient`	`clusterSetslot(long slot, SlotCmd subcommand, Handler<AsyncResult<Void>> handler)` Bind an hash slot to a specific node.
`RedisClient`	`clusterSetslotWithNode(long slot, SlotCmd subcommand, String nodeId, Handler<AsyncResult<Void>> handler)` Bind an hash slot to a specific node.
`RedisClient`	`clusterSlaves(String nodeId, Handler<AsyncResult<JsonArray>> handler)` List slave nodes of the specified master node.
`RedisClient`	`clusterSlots(Handler<AsyncResult<JsonArray>> handler)` Get array of Cluster slot to node mappings
`RedisClient`	`command(Handler<AsyncResult<JsonArray>> handler)` Get array of Redis command details
`RedisClient`	`commandCount(Handler<AsyncResult<Long>> handler)` Get total number of Redis commands
`RedisClient`	`commandGetkeys(Handler<AsyncResult<JsonArray>> handler)` Extract keys given a full Redis command
`RedisClient`	`commandInfo(List<String> commands, Handler<AsyncResult<JsonArray>> handler)` Get array of specific Redis command details
`RedisClient`	`configGet(String parameter, Handler<AsyncResult<JsonArray>> handler)` Get the value of a configuration parameter
`RedisClient`	`configResetstat(Handler<AsyncResult<String>> handler)` Reset the stats returned by INFO
`RedisClient`	`configRewrite(Handler<AsyncResult<String>> handler)` Rewrite the configuration file with the in memory configuration
`RedisClient`	`configSet(String parameter, String value, Handler<AsyncResult<String>> handler)` Set a configuration parameter to the given value
`static RedisClient`	`create(Vertx vertx)`
`static RedisClient`	`create(Vertx vertx, JsonObject config)`
`RedisClient`	`dbsize(Handler<AsyncResult<Long>> handler)` Return the number of keys in the selected database
`RedisClient`	`debugObject(String key, Handler<AsyncResult<String>> handler)` Get debugging information about a key
`RedisClient`	`debugSegfault(Handler<AsyncResult<String>> handler)` Make the server crash
`RedisClient`	`decr(String key, Handler<AsyncResult<Long>> handler)` Decrement the integer value of a key by one
`RedisClient`	`decrby(String key, long decrement, Handler<AsyncResult<Long>> handler)` Decrement the integer value of a key by the given number
`RedisClient`	`del(String key, Handler<AsyncResult<Long>> handler)` Delete a key
`RedisClient`	`delMany(List<String> keys, Handler<AsyncResult<Long>> handler)` Delete many keys
`RedisClient`	`dump(String key, Handler<AsyncResult<String>> handler)` Return a serialized version of the value stored at the specified key.
`RedisClient`	`echo(String message, Handler<AsyncResult<String>> handler)` Echo the given string
`boolean`	`equals(Object o)`
`RedisClient`	`eval(String script, List<String> keys, List<String> args, Handler<AsyncResult<JsonArray>> handler)` Execute a Lua script server side.
`RedisClient`	`evalScript(Script script, List<String> keys, List<String> args, Handler<AsyncResult<JsonArray>> handler)` Execute a Lua script server side.
`RedisClient`	`evalsha(String sha1, List<String> keys, List<String> values, Handler<AsyncResult<JsonArray>> handler)` Execute a Lua script server side.
`RedisClient`	`exists(String key, Handler<AsyncResult<Long>> handler)` Determine if a key exists
`RedisClient`	`existsMany(List<String> keys, Handler<AsyncResult<Long>> handler)` Determine if one or many keys exist
`RedisClient`	`expire(String key, long seconds, Handler<AsyncResult<Long>> handler)` Set a key's time to live in seconds
`RedisClient`	`expireat(String key, long seconds, Handler<AsyncResult<Long>> handler)` Set the expiration for a key as a UNIX timestamp
`RedisClient`	`flushall(Handler<AsyncResult<String>> handler)` Remove all keys from all databases
`RedisClient`	`flushdb(Handler<AsyncResult<String>> handler)` Remove all keys from the current database
`RedisClient`	`geoadd(String key, double longitude, double latitude, String member, Handler<AsyncResult<Long>> handler)` Add one or more geospatial items in the geospatial index represented using a sorted set.
`RedisClient`	`geoaddMany(String key, List<GeoMember> members, Handler<AsyncResult<Long>> handler)` Add one or more geospatial items in the geospatial index represented using a sorted set.
`RedisClient`	`geodist(String key, String member1, String member2, Handler<AsyncResult<String>> handler)` Return the distance between two members in the geospatial index represented by the sorted set.
`RedisClient`	`geodistWithUnit(String key, String member1, String member2, GeoUnit unit, Handler<AsyncResult<String>> handler)` Return the distance between two members in the geospatial index represented by the sorted set.
`RedisClient`	`geohash(String key, String member, Handler<AsyncResult<JsonArray>> handler)` Return valid Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index (where elements were added using GEOADD).
`RedisClient`	`geohashMany(String key, List<String> members, Handler<AsyncResult<JsonArray>> handler)` Return valid Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index (where elements were added using GEOADD).
`RedisClient`	`geopos(String key, String member, Handler<AsyncResult<JsonArray>> handler)` Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.
`RedisClient`	`geoposMany(String key, List<String> members, Handler<AsyncResult<JsonArray>> handler)` Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.
`RedisClient`	`georadius(String key, double longitude, double latitude, double radius, GeoUnit unit, Handler<AsyncResult<JsonArray>> handler)` Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders of the area specified with the center location and the maximum distance from the center (the radius).
`RedisClient`	`georadiusbymember(String key, String member, double radius, GeoUnit unit, Handler<AsyncResult<JsonArray>> handler)` This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial index represented by the sorted set.
`RedisClient`	`georadiusbymemberWithOptions(String key, String member, double radius, GeoUnit unit, GeoRadiusOptions options, Handler<AsyncResult<JsonArray>> handler)` This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial index represented by the sorted set.
`RedisClient`	`georadiusWithOptions(String key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusOptions options, Handler<AsyncResult<JsonArray>> handler)` Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders of the area specified with the center location and the maximum distance from the center (the radius).
`RedisClient`	`get(String key, Handler<AsyncResult<String>> handler)` Get the value of a key
`RedisClient`	`getBinary(String key, Handler<AsyncResult<Buffer>> handler)` Get the value of a key - without decoding as utf-8
`RedisClient`	`getbit(String key, long offset, Handler<AsyncResult<Long>> handler)` Returns the bit value at offset in the string value stored at key
`RedisClient`	`getDelegate()`
`RedisClient`	`getrange(String key, long start, long end, Handler<AsyncResult<String>> handler)` Get a substring of the string stored at a key
`RedisClient`	`getset(String key, String value, Handler<AsyncResult<String>> handler)` Set the string value of a key and return its old value
`int`	`hashCode()`
`RedisClient`	`hdel(String key, String field, Handler<AsyncResult<Long>> handler)` Delete one or more hash fields
`RedisClient`	`hdelMany(String key, List<String> fields, Handler<AsyncResult<Long>> handler)` Delete one or more hash fields
`RedisClient`	`hexists(String key, String field, Handler<AsyncResult<Long>> handler)` Determine if a hash field exists
`RedisClient`	`hget(String key, String field, Handler<AsyncResult<String>> handler)` Get the value of a hash field
`RedisClient`	`hgetall(String key, Handler<AsyncResult<JsonObject>> handler)` Get all the fields and values in a hash
`RedisClient`	`hincrby(String key, String field, long increment, Handler<AsyncResult<Long>> handler)` Increment the integer value of a hash field by the given number
`RedisClient`	`hincrbyfloat(String key, String field, double increment, Handler<AsyncResult<String>> handler)` Increment the float value of a hash field by the given amount
`RedisClient`	`hkeys(String key, Handler<AsyncResult<JsonArray>> handler)` Get all the fields in a hash
`RedisClient`	`hlen(String key, Handler<AsyncResult<Long>> handler)` Get the number of fields in a hash
`RedisClient`	`hmget(String key, List<String> fields, Handler<AsyncResult<JsonArray>> handler)` Get the values of all the given hash fields
`RedisClient`	`hmset(String key, JsonObject values, Handler<AsyncResult<String>> handler)` Set multiple hash fields to multiple values
`RedisClient`	`hscan(String key, String cursor, ScanOptions options, Handler<AsyncResult<JsonArray>> handler)` Incrementally iterate hash fields and associated values
`RedisClient`	`hset(String key, String field, String value, Handler<AsyncResult<Long>> handler)` Set the string value of a hash field
`RedisClient`	`hsetnx(String key, String field, String value, Handler<AsyncResult<Long>> handler)` Set the value of a hash field, only if the field does not exist
`RedisClient`	`hstrlen(String key, String field, Handler<AsyncResult<Long>> handler)` Get the length of the value of a hash field.
`RedisClient`	`hvals(String key, Handler<AsyncResult<JsonArray>> handler)` Get all the values in a hash
`RedisClient`	`incr(String key, Handler<AsyncResult<Long>> handler)` Increment the integer value of a key by one
`RedisClient`	`incrby(String key, long increment, Handler<AsyncResult<Long>> handler)` Increment the integer value of a key by the given amount
`RedisClient`	`incrbyfloat(String key, double increment, Handler<AsyncResult<String>> handler)` Increment the float value of a key by the given amount
`RedisClient`	`info(Handler<AsyncResult<JsonObject>> handler)` Get information and statistics about the server
`RedisClient`	`infoSection(String section, Handler<AsyncResult<JsonObject>> handler)` Get information and statistics about the server
`RedisClient`	`keys(String pattern, Handler<AsyncResult<JsonArray>> handler)` Find all keys matching the given pattern
`RedisClient`	`lastsave(Handler<AsyncResult<Long>> handler)` Get the UNIX time stamp of the last successful save to disk
`RedisClient`	`lindex(String key, int index, Handler<AsyncResult<String>> handler)` Get an element from a list by its index
`RedisClient`	`linsert(String key, InsertOptions option, String pivot, String value, Handler<AsyncResult<Long>> handler)` Insert an element before or after another element in a list
`RedisClient`	`llen(String key, Handler<AsyncResult<Long>> handler)` Get the length of a list
`RedisClient`	`lpop(String key, Handler<AsyncResult<String>> handler)` Remove and get the first element in a list
`RedisClient`	`lpush(String key, String value, Handler<AsyncResult<Long>> handler)` Prepend one value to a list
`RedisClient`	`lpushMany(String key, List<String> values, Handler<AsyncResult<Long>> handler)` Prepend one or multiple values to a list
`RedisClient`	`lpushx(String key, String value, Handler<AsyncResult<Long>> handler)` Prepend a value to a list, only if the list exists
`RedisClient`	`lrange(String key, long from, long to, Handler<AsyncResult<JsonArray>> handler)` Get a range of elements from a list
`RedisClient`	`lrem(String key, long count, String value, Handler<AsyncResult<Long>> handler)` Remove elements from a list
`RedisClient`	`lset(String key, long index, String value, Handler<AsyncResult<String>> handler)` Set the value of an element in a list by its index
`RedisClient`	`ltrim(String key, long from, long to, Handler<AsyncResult<String>> handler)` Trim a list to the specified range
`RedisClient`	`mget(String key, Handler<AsyncResult<JsonArray>> handler)` Get the value of the given key
`RedisClient`	`mgetMany(List<String> keys, Handler<AsyncResult<JsonArray>> handler)` Get the values of all the given keys
`RedisClient`	`migrate(String host, int port, String key, int destdb, long timeout, MigrateOptions options, Handler<AsyncResult<String>> handler)` Atomically transfer a key from a Redis instance to another one.
`RedisClient`	`monitor(Handler<AsyncResult<Void>> handler)` Listen for all requests received by the server in real time
`RedisClient`	`move(String key, int destdb, Handler<AsyncResult<Long>> handler)` Move a key to another database
`RedisClient`	`mset(JsonObject keyvals, Handler<AsyncResult<String>> handler)` Set multiple keys to multiple values
`RedisClient`	`msetnx(JsonObject keyvals, Handler<AsyncResult<Long>> handler)` Set multiple keys to multiple values, only if none of the keys exist
`static RedisClient`	`newInstance(RedisClient arg)`
`RedisClient`	`object(String key, ObjectCmd cmd, Handler<AsyncResult<Void>> handler)` Inspect the internals of Redis objects
`RedisClient`	`persist(String key, Handler<AsyncResult<Long>> handler)` Remove the expiration from a key
`RedisClient`	`pexpire(String key, long millis, Handler<AsyncResult<Long>> handler)` Set a key's time to live in milliseconds
`RedisClient`	`pexpireat(String key, long millis, Handler<AsyncResult<Long>> handler)` Set the expiration for a key as a UNIX timestamp specified in milliseconds
`RedisClient`	`pfadd(String key, String element, Handler<AsyncResult<Long>> handler)` Adds the specified element to the specified HyperLogLog.
`RedisClient`	`pfaddMany(String key, List<String> elements, Handler<AsyncResult<Long>> handler)` Adds the specified elements to the specified HyperLogLog.
`RedisClient`	`pfcount(String key, Handler<AsyncResult<Long>> handler)` Return the approximated cardinality of the set observed by the HyperLogLog at key.
`RedisClient`	`pfcountMany(List<String> keys, Handler<AsyncResult<Long>> handler)` Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).
`RedisClient`	`pfmerge(String destkey, List<String> keys, Handler<AsyncResult<String>> handler)` Merge N different HyperLogLogs into a single one.
`RedisClient`	`ping(Handler<AsyncResult<String>> handler)` Ping the server
`RedisClient`	`psetex(String key, long millis, String value, Handler<AsyncResult<Void>> handler)` Set the value and expiration in milliseconds of a key
`RedisClient`	`psubscribe(String pattern, Handler<AsyncResult<JsonArray>> handler)` Listen for messages published to channels matching the given pattern
`RedisClient`	`psubscribeMany(List<String> patterns, Handler<AsyncResult<JsonArray>> handler)` Listen for messages published to channels matching the given patterns
`RedisClient`	`pttl(String key, Handler<AsyncResult<Long>> handler)` Get the time to live for a key in milliseconds
`RedisClient`	`publish(String channel, String message, Handler<AsyncResult<Long>> handler)` Post a message to a channel
`RedisClient`	`pubsubChannels(String pattern, Handler<AsyncResult<JsonArray>> handler)` Lists the currently active channels - only those matching the pattern
`RedisClient`	`pubsubNumpat(Handler<AsyncResult<Long>> handler)` Returns the number of subscriptions to patterns (that are performed using the PSUBSCRIBE command)
`RedisClient`	`pubsubNumsub(List<String> channels, Handler<AsyncResult<JsonArray>> handler)` Returns the number of subscribers (not counting clients subscribed to patterns) for the specified channels
`RedisClient`	`punsubscribe(List<String> patterns, Handler<AsyncResult<Void>> handler)` Stop listening for messages posted to channels matching the given patterns
`RedisClient`	`randomkey(Handler<AsyncResult<String>> handler)` Return a random key from the keyspace
`RedisClient`	`rename(String key, String newkey, Handler<AsyncResult<String>> handler)` Rename a key
`RedisClient`	`renamenx(String key, String newkey, Handler<AsyncResult<Long>> handler)` Rename a key, only if the new key does not exist
`RedisClient`	`restore(String key, long millis, String serialized, Handler<AsyncResult<String>> handler)` Create a key using the provided serialized value, previously obtained using DUMP.
`RedisClient`	`role(Handler<AsyncResult<JsonArray>> handler)` Return the role of the instance in the context of replication
`RedisClient`	`rpop(String key, Handler<AsyncResult<String>> handler)` Remove and get the last element in a list
`RedisClient`	`rpoplpush(String key, String destkey, Handler<AsyncResult<String>> handler)` Remove the last element in a list, append it to another list and return it
`RedisClient`	`rpush(String key, String value, Handler<AsyncResult<Long>> handler)` Append one or multiple values to a list
`RedisClient`	`rpushMany(String key, List<String> values, Handler<AsyncResult<Long>> handler)` Append one or multiple values to a list
`RedisClient`	`rpushx(String key, String value, Handler<AsyncResult<Long>> handler)` Append a value to a list, only if the list exists
`Single<Long>`	`rxAppend(String key, String value)` Append a value to a key
`Single<String>`	`rxAuth(String password)` Authenticate to the server
`Single<String>`	`rxBgrewriteaof()` Asynchronously rewrite the append-only file
`Single<String>`	`rxBgsave()` Asynchronously save the dataset to disk
`Single<Long>`	`rxBitcount(String key)` Count set bits in a string
`Single<Long>`	`rxBitcountRange(String key, long start, long end)` Count set bits in a string
`Single<JsonArray>`	`rxBitfield(String key, BitFieldOptions bitFieldOptions)` Perform arbitrary bitfield integer operations on strings.
`Single<JsonArray>`	`rxBitfieldWithOverflow(String key, BitFieldOptions commands, BitFieldOverflowOptions overflow)` Perform arbitrary bitfield integer operations on strings.
`Single<Long>`	`rxBitop(BitOperation operation, String destkey, List<String> keys)` Perform bitwise operations between strings
`Single<Long>`	`rxBitpos(String key, int bit)` Find first bit set or clear in a string
`Single<Long>`	`rxBitposFrom(String key, int bit, int start)` Find first bit set or clear in a string See also bitposRange() method, which takes start, and stop offset.
`Single<Long>`	`rxBitposRange(String key, int bit, int start, int stop)` Find first bit set or clear in a string Note: when both start, and stop offsets are specified, behaviour is slightly different than if only start is specified
`Single<JsonArray>`	`rxBlpop(String key, int seconds)` Remove and get the first element in a list, or block until one is available
`Single<JsonArray>`	`rxBlpopMany(List<String> keys, int seconds)` Remove and get the first element in any of the lists, or block until one is available
`Single<JsonArray>`	`rxBrpop(String key, int seconds)` Remove and get the last element in a list, or block until one is available
`Single<String>`	`rxBrpoplpush(String key, String destkey, int seconds)` Pop a value from a list, push it to another list and return it; or block until one is available
`Single<JsonArray>`	`rxBrpopMany(List<String> keys, int seconds)` Remove and get the last element in any of the lists, or block until one is available
`Single<String>`	`rxClientGetname()` Get the current connection name
`Single<Long>`	`rxClientKill(KillFilter filter)` Kill the connection of a client
`Single<String>`	`rxClientList()` Get the list of client connections
`Single<String>`	`rxClientPause(long millis)` Stop processing commands from clients for some time
`Single<String>`	`rxClientReply(ClientReplyOptions options)` Instruct the server whether to reply to commands.
`Single<String>`	`rxClientSetname(String name)` Set the current connection name
`Completable`	`rxClose()` Close the client - when it is fully closed the handler will be called.
`Completable`	`rxClusterAddslots(List<Long> slots)` Assign new hash slots to receiving node.
`Single<Long>`	`rxClusterCountFailureReports(String nodeId)` Return the number of failure reports active for a given node.
`Single<Long>`	`rxClusterCountkeysinslot(long slot)` Return the number of local keys in the specified hash slot.
`Completable`	`rxClusterDelslots(long slot)` Set hash slots as unbound in receiving node.
`Completable`	`rxClusterDelslotsMany(List<Long> slots)` Set hash slots as unbound in receiving node.
`Completable`	`rxClusterFailover()` Forces a slave to perform a manual failover of its master.
`Completable`	`rxClusterFailOverWithOptions(FailoverOptions options)` Forces a slave to perform a manual failover of its master.
`Completable`	`rxClusterForget(String nodeId)` Remove a node from the nodes table.
`Single<JsonArray>`	`rxClusterGetkeysinslot(long slot, long count)` Return local key names in the specified hash slot.
`Single<JsonArray>`	`rxClusterInfo()` Provides info about Redis Cluster node state.
`Single<Long>`	`rxClusterKeyslot(String key)` Returns the hash slot of the specified key.
`Completable`	`rxClusterMeet(String ip, long port)` Force a node cluster to handshake with another node.
`Single<JsonArray>`	`rxClusterNodes()` Get Cluster config for the node.
`Completable`	`rxClusterReplicate(String nodeId)` Reconfigure a node as a slave of the specified master node.
`Completable`	`rxClusterReset()` Reset a Redis Cluster node.
`Completable`	`rxClusterResetWithOptions(ResetOptions options)` Reset a Redis Cluster node.
`Completable`	`rxClusterSaveconfig()` Forces the node to save cluster state on disk.
`Completable`	`rxClusterSetConfigEpoch(long epoch)` Set the configuration epoch in a new node.
`Completable`	`rxClusterSetslot(long slot, SlotCmd subcommand)` Bind an hash slot to a specific node.
`Completable`	`rxClusterSetslotWithNode(long slot, SlotCmd subcommand, String nodeId)` Bind an hash slot to a specific node.
`Single<JsonArray>`	`rxClusterSlaves(String nodeId)` List slave nodes of the specified master node.
`Single<JsonArray>`	`rxClusterSlots()` Get array of Cluster slot to node mappings
`Single<JsonArray>`	`rxCommand()` Get array of Redis command details
`Single<Long>`	`rxCommandCount()` Get total number of Redis commands
`Single<JsonArray>`	`rxCommandGetkeys()` Extract keys given a full Redis command
`Single<JsonArray>`	`rxCommandInfo(List<String> commands)` Get array of specific Redis command details
`Single<JsonArray>`	`rxConfigGet(String parameter)` Get the value of a configuration parameter
`Single<String>`	`rxConfigResetstat()` Reset the stats returned by INFO
`Single<String>`	`rxConfigRewrite()` Rewrite the configuration file with the in memory configuration
`Single<String>`	`rxConfigSet(String parameter, String value)` Set a configuration parameter to the given value
`Single<Long>`	`rxDbsize()` Return the number of keys in the selected database
`Single<String>`	`rxDebugObject(String key)` Get debugging information about a key
`Single<String>`	`rxDebugSegfault()` Make the server crash
`Single<Long>`	`rxDecr(String key)` Decrement the integer value of a key by one
`Single<Long>`	`rxDecrby(String key, long decrement)` Decrement the integer value of a key by the given number
`Single<Long>`	`rxDel(String key)` Delete a key
`Single<Long>`	`rxDelMany(List<String> keys)` Delete many keys
`Single<String>`	`rxDump(String key)` Return a serialized version of the value stored at the specified key.
`Single<String>`	`rxEcho(String message)` Echo the given string
`Single<JsonArray>`	`rxEval(String script, List<String> keys, List<String> args)` Execute a Lua script server side.
`Single<JsonArray>`	`rxEvalScript(Script script, List<String> keys, List<String> args)` Execute a Lua script server side.
`Single<JsonArray>`	`rxEvalsha(String sha1, List<String> keys, List<String> values)` Execute a Lua script server side.
`Single<Long>`	`rxExists(String key)` Determine if a key exists
`Single<Long>`	`rxExistsMany(List<String> keys)` Determine if one or many keys exist
`Single<Long>`	`rxExpire(String key, long seconds)` Set a key's time to live in seconds
`Single<Long>`	`rxExpireat(String key, long seconds)` Set the expiration for a key as a UNIX timestamp
`Single<String>`	`rxFlushall()` Remove all keys from all databases
`Single<String>`	`rxFlushdb()` Remove all keys from the current database
`Single<Long>`	`rxGeoadd(String key, double longitude, double latitude, String member)` Add one or more geospatial items in the geospatial index represented using a sorted set.
`Single<Long>`	`rxGeoaddMany(String key, List<GeoMember> members)` Add one or more geospatial items in the geospatial index represented using a sorted set.
`Single<String>`	`rxGeodist(String key, String member1, String member2)` Return the distance between two members in the geospatial index represented by the sorted set.
`Single<String>`	`rxGeodistWithUnit(String key, String member1, String member2, GeoUnit unit)` Return the distance between two members in the geospatial index represented by the sorted set.
`Single<JsonArray>`	`rxGeohash(String key, String member)` Return valid Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index (where elements were added using GEOADD).
`Single<JsonArray>`	`rxGeohashMany(String key, List<String> members)` Return valid Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index (where elements were added using GEOADD).
`Single<JsonArray>`	`rxGeopos(String key, String member)` Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.
`Single<JsonArray>`	`rxGeoposMany(String key, List<String> members)` Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.
`Single<JsonArray>`	`rxGeoradius(String key, double longitude, double latitude, double radius, GeoUnit unit)` Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders of the area specified with the center location and the maximum distance from the center (the radius).
`Single<JsonArray>`	`rxGeoradiusbymember(String key, String member, double radius, GeoUnit unit)` This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial index represented by the sorted set.
`Single<JsonArray>`	`rxGeoradiusbymemberWithOptions(String key, String member, double radius, GeoUnit unit, GeoRadiusOptions options)` This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial index represented by the sorted set.
`Single<JsonArray>`	`rxGeoradiusWithOptions(String key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusOptions options)` Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders of the area specified with the center location and the maximum distance from the center (the radius).
`Maybe<String>`	`rxGet(String key)` Get the value of a key
`Maybe<Buffer>`	`rxGetBinary(String key)` Get the value of a key - without decoding as utf-8
`Single<Long>`	`rxGetbit(String key, long offset)` Returns the bit value at offset in the string value stored at key
`Single<String>`	`rxGetrange(String key, long start, long end)` Get a substring of the string stored at a key
`Maybe<String>`	`rxGetset(String key, String value)` Set the string value of a key and return its old value
`Single<Long>`	`rxHdel(String key, String field)` Delete one or more hash fields
`Single<Long>`	`rxHdelMany(String key, List<String> fields)` Delete one or more hash fields
`Single<Long>`	`rxHexists(String key, String field)` Determine if a hash field exists
`Maybe<String>`	`rxHget(String key, String field)` Get the value of a hash field
`Single<JsonObject>`	`rxHgetall(String key)` Get all the fields and values in a hash
`Single<Long>`	`rxHincrby(String key, String field, long increment)` Increment the integer value of a hash field by the given number
`Single<String>`	`rxHincrbyfloat(String key, String field, double increment)` Increment the float value of a hash field by the given amount
`Single<JsonArray>`	`rxHkeys(String key)` Get all the fields in a hash
`Single<Long>`	`rxHlen(String key)` Get the number of fields in a hash
`Single<JsonArray>`	`rxHmget(String key, List<String> fields)` Get the values of all the given hash fields
`Single<String>`	`rxHmset(String key, JsonObject values)` Set multiple hash fields to multiple values
`Single<JsonArray>`	`rxHscan(String key, String cursor, ScanOptions options)` Incrementally iterate hash fields and associated values
`Single<Long>`	`rxHset(String key, String field, String value)` Set the string value of a hash field
`Single<Long>`	`rxHsetnx(String key, String field, String value)` Set the value of a hash field, only if the field does not exist
`Single<Long>`	`rxHstrlen(String key, String field)` Get the length of the value of a hash field.
`Single<JsonArray>`	`rxHvals(String key)` Get all the values in a hash
`Single<Long>`	`rxIncr(String key)` Increment the integer value of a key by one
`Single<Long>`	`rxIncrby(String key, long increment)` Increment the integer value of a key by the given amount
`Single<String>`	`rxIncrbyfloat(String key, double increment)` Increment the float value of a key by the given amount
`Single<JsonObject>`	`rxInfo()` Get information and statistics about the server
`Single<JsonObject>`	`rxInfoSection(String section)` Get information and statistics about the server
`Single<JsonArray>`	`rxKeys(String pattern)` Find all keys matching the given pattern
`Single<Long>`	`rxLastsave()` Get the UNIX time stamp of the last successful save to disk
`Single<String>`	`rxLindex(String key, int index)` Get an element from a list by its index
`Single<Long>`	`rxLinsert(String key, InsertOptions option, String pivot, String value)` Insert an element before or after another element in a list
`Single<Long>`	`rxLlen(String key)` Get the length of a list
`Maybe<String>`	`rxLpop(String key)` Remove and get the first element in a list
`Single<Long>`	`rxLpush(String key, String value)` Prepend one value to a list
`Single<Long>`	`rxLpushMany(String key, List<String> values)` Prepend one or multiple values to a list
`Single<Long>`	`rxLpushx(String key, String value)` Prepend a value to a list, only if the list exists
`Single<JsonArray>`	`rxLrange(String key, long from, long to)` Get a range of elements from a list
`Single<Long>`	`rxLrem(String key, long count, String value)` Remove elements from a list
`Single<String>`	`rxLset(String key, long index, String value)` Set the value of an element in a list by its index
`Single<String>`	`rxLtrim(String key, long from, long to)` Trim a list to the specified range
`Single<JsonArray>`	`rxMget(String key)` Get the value of the given key
`Single<JsonArray>`	`rxMgetMany(List<String> keys)` Get the values of all the given keys
`Single<String>`	`rxMigrate(String host, int port, String key, int destdb, long timeout, MigrateOptions options)` Atomically transfer a key from a Redis instance to another one.
`Completable`	`rxMonitor()` Listen for all requests received by the server in real time
`Single<Long>`	`rxMove(String key, int destdb)` Move a key to another database
`Single<String>`	`rxMset(JsonObject keyvals)` Set multiple keys to multiple values
`Single<Long>`	`rxMsetnx(JsonObject keyvals)` Set multiple keys to multiple values, only if none of the keys exist
`Completable`	`rxObject(String key, ObjectCmd cmd)` Inspect the internals of Redis objects
`Single<Long>`	`rxPersist(String key)` Remove the expiration from a key
`Single<Long>`	`rxPexpire(String key, long millis)` Set a key's time to live in milliseconds
`Single<Long>`	`rxPexpireat(String key, long millis)` Set the expiration for a key as a UNIX timestamp specified in milliseconds
`Single<Long>`	`rxPfadd(String key, String element)` Adds the specified element to the specified HyperLogLog.
`Single<Long>`	`rxPfaddMany(String key, List<String> elements)` Adds the specified elements to the specified HyperLogLog.
`Single<Long>`	`rxPfcount(String key)` Return the approximated cardinality of the set observed by the HyperLogLog at key.
`Single<Long>`	`rxPfcountMany(List<String> keys)` Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).
`Single<String>`	`rxPfmerge(String destkey, List<String> keys)` Merge N different HyperLogLogs into a single one.
`Single<String>`	`rxPing()` Ping the server
`Completable`	`rxPsetex(String key, long millis, String value)` Set the value and expiration in milliseconds of a key
`Single<JsonArray>`	`rxPsubscribe(String pattern)` Listen for messages published to channels matching the given pattern
`Single<JsonArray>`	`rxPsubscribeMany(List<String> patterns)` Listen for messages published to channels matching the given patterns
`Single<Long>`	`rxPttl(String key)` Get the time to live for a key in milliseconds
`Single<Long>`	`rxPublish(String channel, String message)` Post a message to a channel
`Single<JsonArray>`	`rxPubsubChannels(String pattern)` Lists the currently active channels - only those matching the pattern
`Single<Long>`	`rxPubsubNumpat()` Returns the number of subscriptions to patterns (that are performed using the PSUBSCRIBE command)
`Single<JsonArray>`	`rxPubsubNumsub(List<String> channels)` Returns the number of subscribers (not counting clients subscribed to patterns) for the specified channels
`Completable`	`rxPunsubscribe(List<String> patterns)` Stop listening for messages posted to channels matching the given patterns
`Single<String>`	`rxRandomkey()` Return a random key from the keyspace
`Single<String>`	`rxRename(String key, String newkey)` Rename a key
`Single<Long>`	`rxRenamenx(String key, String newkey)` Rename a key, only if the new key does not exist
`Single<String>`	`rxRestore(String key, long millis, String serialized)` Create a key using the provided serialized value, previously obtained using DUMP.
`Single<JsonArray>`	`rxRole()` Return the role of the instance in the context of replication
`Single<String>`	`rxRpop(String key)` Remove and get the last element in a list
`Single<String>`	`rxRpoplpush(String key, String destkey)` Remove the last element in a list, append it to another list and return it
`Single<Long>`	`rxRpush(String key, String value)` Append one or multiple values to a list
`Single<Long>`	`rxRpushMany(String key, List<String> values)` Append one or multiple values to a list
`Single<Long>`	`rxRpushx(String key, String value)` Append a value to a list, only if the list exists
`Single<Long>`	`rxSadd(String key, String member)` Add a member to a set
`Single<Long>`	`rxSaddMany(String key, List<String> members)` Add one or more members to a set
`Single<String>`	`rxSave()` Synchronously save the dataset to disk
`Single<JsonArray>`	`rxScan(String cursor, ScanOptions options)` Incrementally iterate the keys space
`Single<Long>`	`rxScard(String key)` Get the number of members in a set
`Single<String>`	`rxScriptDebug(ScriptDebugOptions scriptDebugOptions)` Set the debug mode for executed scripts.
`Single<JsonArray>`	`rxScriptExists(String script)` Check existence of script in the script cache.
`Single<JsonArray>`	`rxScriptExistsMany(List<String> scripts)` Check existence of scripts in the script cache.
`Single<String>`	`rxScriptFlush()` Remove all the scripts from the script cache.
`Single<String>`	`rxScriptKill()` Kill the script currently in execution.
`Single<String>`	`rxScriptLoad(String script)` Load the specified Lua script into the script cache.
`Single<JsonArray>`	`rxSdiff(String key, List<String> cmpkeys)` Subtract multiple sets
`Single<Long>`	`rxSdiffstore(String destkey, String key, List<String> cmpkeys)` Subtract multiple sets and store the resulting set in a key
`Single<String>`	`rxSelect(int dbindex)` Change the selected database for the current connection
`Completable`	`rxSet(String key, String value)` Set the string value of a key
`Completable`	`rxSetBinary(String key, Buffer value)` Set the binary string value of a key - without encoding as utf-8
`Completable`	`rxSetBinaryWithOptions(String key, Buffer value, SetOptions options)` Set the string value of a key
`Single<Long>`	`rxSetbit(String key, long offset, int bit)` Sets or clears the bit at offset in the string value stored at key
`Single<String>`	`rxSetex(String key, long seconds, String value)` Set the value and expiration of a key
`Single<Long>`	`rxSetnx(String key, String value)` Set the value of a key, only if the key does not exist
`Single<Long>`	`rxSetrange(String key, int offset, String value)` Overwrite part of a string at key starting at the specified offset
`Single<String>`	`rxSetWithOptions(String key, String value, SetOptions options)` Set the string value of a key
`Single<JsonArray>`	`rxSinter(List<String> keys)` Intersect multiple sets
`Single<Long>`	`rxSinterstore(String destkey, List<String> keys)` Intersect multiple sets and store the resulting set in a key
`Single<Long>`	`rxSismember(String key, String member)` Determine if a given value is a member of a set
`Single<String>`	`rxSlaveof(String host, int port)` Make the server a slave of another instance
`Single<String>`	`rxSlaveofNoone()` Make this server a master
`Single<JsonArray>`	`rxSlowlogGet(int limit)` Read the Redis slow queries log
`Single<Long>`	`rxSlowlogLen()` Get the length of the Redis slow queries log
`Completable`	`rxSlowlogReset()` Reset the Redis slow queries log
`Single<JsonArray>`	`rxSmembers(String key)` Get all the members in a set
`Single<Long>`	`rxSmove(String key, String destkey, String member)` Move a member from one set to another
`Single<JsonArray>`	`rxSort(String key, SortOptions options)` Sort the elements in a list, set or sorted set
`Maybe<String>`	`rxSpop(String key)` Remove and return a random member from a set
`Single<JsonArray>`	`rxSpopMany(String key, int count)` Remove and return random members from a set
`Single<String>`	`rxSrandmember(String key)` Get one or multiple random members from a set
`Single<JsonArray>`	`rxSrandmemberCount(String key, int count)` Get one or multiple random members from a set
`Single<Long>`	`rxSrem(String key, String member)` Remove one member from a set
`Single<Long>`	`rxSremMany(String key, List<String> members)` Remove one or more members from a set
`Single<JsonArray>`	`rxSscan(String key, String cursor, ScanOptions options)` Incrementally iterate Set elements
`Single<Long>`	`rxStrlen(String key)` Get the length of the value stored in a key
`Single<JsonArray>`	`rxSubscribe(String channel)` Listen for messages published to the given channels
`Single<JsonArray>`	`rxSubscribeMany(List<String> channels)` Listen for messages published to the given channels
`Single<JsonArray>`	`rxSunion(List<String> keys)` Add multiple sets
`Single<Long>`	`rxSunionstore(String destkey, List<String> keys)` Add multiple sets and store the resulting set in a key
`Single<String>`	`rxSwapdb(int index1, int index2)` Swaps two Redis databases
`Completable`	`rxSync()` Internal command used for replication
`Single<JsonArray>`	`rxTime()` Return the current server time
`Single<Long>`	`rxTouch(String key)` Alters the last access time of a key(s).
`Single<Long>`	`rxTouchMany(List<String> keys)` Alters the last access time of a key(s).
`Single<Long>`	`rxTtl(String key)` Get the time to live for a key
`Single<String>`	`rxType(String key)` Determine the type stored at key
`Single<Long>`	`rxUnlink(String key)` Delete a key asynchronously in another thread.
`Single<Long>`	`rxUnlinkMany(List<String> keys)` Delete multiple keys asynchronously in another thread.
`Completable`	`rxUnsubscribe(List<String> channels)` Stop listening for messages posted to the given channels
`Single<String>`	`rxWait(long numSlaves, long timeout)` Wait for the synchronous replication of all the write commands sent in the context of the current connection.
`Single<Long>`	`rxZadd(String key, double score, String member)` Add one or more members to a sorted set, or update its score if it already exists
`Single<Long>`	`rxZaddMany(String key, Map<String,Double> members)` Add one or more members to a sorted set, or update its score if it already exists
`Single<Long>`	`rxZcard(String key)` Get the number of members in a sorted set
`Single<Long>`	`rxZcount(String key, double min, double max)` Count the members in a sorted set with scores within the given values
`Single<String>`	`rxZincrby(String key, double increment, String member)` Increment the score of a member in a sorted set
`Single<Long>`	`rxZinterstore(String destkey, List<String> sets, AggregateOptions options)` Intersect multiple sorted sets and store the resulting sorted set in a new key
`Single<Long>`	`rxZinterstoreWeighed(String destkey, Map<String,Double> sets, AggregateOptions options)` Intersect multiple sorted sets and store the resulting sorted set in a new key using weights for scoring
`Single<Long>`	`rxZlexcount(String key, String min, String max)` Count the number of members in a sorted set between a given lexicographical range
`Single<JsonArray>`	`rxZrange(String key, long start, long stop)` Return a range of members in a sorted set, by index
`Single<JsonArray>`	`rxZrangebylex(String key, String min, String max, LimitOptions options)` Return a range of members in a sorted set, by lexicographical range
`Single<JsonArray>`	`rxZrangebyscore(String key, String min, String max, RangeLimitOptions options)` Return a range of members in a sorted set, by score
`Single<JsonArray>`	`rxZrangeWithOptions(String key, long start, long stop, RangeOptions options)` Return a range of members in a sorted set, by index
`Single<Long>`	`rxZrank(String key, String member)` Determine the index of a member in a sorted set
`Single<Long>`	`rxZrem(String key, String member)` Remove one member from a sorted set
`Single<Long>`	`rxZremMany(String key, List<String> members)` Remove one or more members from a sorted set
`Single<Long>`	`rxZremrangebylex(String key, String min, String max)` Remove all members in a sorted set between the given lexicographical range
`Single<Long>`	`rxZremrangebyrank(String key, long start, long stop)` Remove all members in a sorted set within the given indexes
`Single<Long>`	`rxZremrangebyscore(String key, String min, String max)` Remove all members in a sorted set within the given scores
`Single<JsonArray>`	`rxZrevrange(String key, long start, long stop, RangeOptions options)` Return a range of members in a sorted set, by index, with scores ordered from high to low
`Single<JsonArray>`	`rxZrevrangebylex(String key, String max, String min, LimitOptions options)` Return a range of members in a sorted set, by score, between the given lexicographical range with scores ordered from high to low
`Single<JsonArray>`	`rxZrevrangebyscore(String key, String max, String min, RangeLimitOptions options)` Return a range of members in a sorted set, by score, with scores ordered from high to low
`Single<Long>`	`rxZrevrank(String key, String member)` Determine the index of a member in a sorted set, with scores ordered from high to low
`Single<JsonArray>`	`rxZscan(String key, String cursor, ScanOptions options)` Incrementally iterate sorted sets elements and associated scores
`Single<String>`	`rxZscore(String key, String member)` Get the score associated with the given member in a sorted set
`Single<Long>`	`rxZunionstore(String destkey, List<String> sets, AggregateOptions options)` Add multiple sorted sets and store the resulting sorted set in a new key
`Single<Long>`	`rxZunionstoreWeighed(String key, Map<String,Double> sets, AggregateOptions options)` Add multiple sorted sets using weights, and store the resulting sorted set in a new key
`RedisClient`	`sadd(String key, String member, Handler<AsyncResult<Long>> handler)` Add a member to a set
`RedisClient`	`saddMany(String key, List<String> members, Handler<AsyncResult<Long>> handler)` Add one or more members to a set
`RedisClient`	`save(Handler<AsyncResult<String>> handler)` Synchronously save the dataset to disk
`RedisClient`	`scan(String cursor, ScanOptions options, Handler<AsyncResult<JsonArray>> handler)` Incrementally iterate the keys space
`RedisClient`	`scard(String key, Handler<AsyncResult<Long>> handler)` Get the number of members in a set
`RedisClient`	`scriptDebug(ScriptDebugOptions scriptDebugOptions, Handler<AsyncResult<String>> handler)` Set the debug mode for executed scripts.
`RedisClient`	`scriptExists(String script, Handler<AsyncResult<JsonArray>> handler)` Check existence of script in the script cache.
`RedisClient`	`scriptExistsMany(List<String> scripts, Handler<AsyncResult<JsonArray>> handler)` Check existence of scripts in the script cache.
`RedisClient`	`scriptFlush(Handler<AsyncResult<String>> handler)` Remove all the scripts from the script cache.
`RedisClient`	`scriptKill(Handler<AsyncResult<String>> handler)` Kill the script currently in execution.
`RedisClient`	`scriptLoad(String script, Handler<AsyncResult<String>> handler)` Load the specified Lua script into the script cache.
`RedisClient`	`sdiff(String key, List<String> cmpkeys, Handler<AsyncResult<JsonArray>> handler)` Subtract multiple sets
`RedisClient`	`sdiffstore(String destkey, String key, List<String> cmpkeys, Handler<AsyncResult<Long>> handler)` Subtract multiple sets and store the resulting set in a key
`RedisClient`	`select(int dbindex, Handler<AsyncResult<String>> handler)` Change the selected database for the current connection
`RedisClient`	`set(String key, String value, Handler<AsyncResult<Void>> handler)` Set the string value of a key
`RedisClient`	`setBinary(String key, Buffer value, Handler<AsyncResult<Void>> handler)` Set the binary string value of a key - without encoding as utf-8
`RedisClient`	`setBinaryWithOptions(String key, Buffer value, SetOptions options, Handler<AsyncResult<Void>> handler)` Set the string value of a key
`RedisClient`	`setbit(String key, long offset, int bit, Handler<AsyncResult<Long>> handler)` Sets or clears the bit at offset in the string value stored at key
`RedisClient`	`setex(String key, long seconds, String value, Handler<AsyncResult<String>> handler)` Set the value and expiration of a key
`RedisClient`	`setnx(String key, String value, Handler<AsyncResult<Long>> handler)` Set the value of a key, only if the key does not exist
`RedisClient`	`setrange(String key, int offset, String value, Handler<AsyncResult<Long>> handler)` Overwrite part of a string at key starting at the specified offset
`RedisClient`	`setWithOptions(String key, String value, SetOptions options, Handler<AsyncResult<String>> handler)` Set the string value of a key
`RedisClient`	`sinter(List<String> keys, Handler<AsyncResult<JsonArray>> handler)` Intersect multiple sets
`RedisClient`	`sinterstore(String destkey, List<String> keys, Handler<AsyncResult<Long>> handler)` Intersect multiple sets and store the resulting set in a key
`RedisClient`	`sismember(String key, String member, Handler<AsyncResult<Long>> handler)` Determine if a given value is a member of a set
`RedisClient`	`slaveof(String host, int port, Handler<AsyncResult<String>> handler)` Make the server a slave of another instance
`RedisClient`	`slaveofNoone(Handler<AsyncResult<String>> handler)` Make this server a master
`RedisClient`	`slowlogGet(int limit, Handler<AsyncResult<JsonArray>> handler)` Read the Redis slow queries log
`RedisClient`	`slowlogLen(Handler<AsyncResult<Long>> handler)` Get the length of the Redis slow queries log
`RedisClient`	`slowlogReset(Handler<AsyncResult<Void>> handler)` Reset the Redis slow queries log
`RedisClient`	`smembers(String key, Handler<AsyncResult<JsonArray>> handler)` Get all the members in a set
`RedisClient`	`smove(String key, String destkey, String member, Handler<AsyncResult<Long>> handler)` Move a member from one set to another
`RedisClient`	`sort(String key, SortOptions options, Handler<AsyncResult<JsonArray>> handler)` Sort the elements in a list, set or sorted set
`RedisClient`	`spop(String key, Handler<AsyncResult<String>> handler)` Remove and return a random member from a set
`RedisClient`	`spopMany(String key, int count, Handler<AsyncResult<JsonArray>> handler)` Remove and return random members from a set
`RedisClient`	`srandmember(String key, Handler<AsyncResult<String>> handler)` Get one or multiple random members from a set
`RedisClient`	`srandmemberCount(String key, int count, Handler<AsyncResult<JsonArray>> handler)` Get one or multiple random members from a set
`RedisClient`	`srem(String key, String member, Handler<AsyncResult<Long>> handler)` Remove one member from a set
`RedisClient`	`sremMany(String key, List<String> members, Handler<AsyncResult<Long>> handler)` Remove one or more members from a set
`RedisClient`	`sscan(String key, String cursor, ScanOptions options, Handler<AsyncResult<JsonArray>> handler)` Incrementally iterate Set elements
`RedisClient`	`strlen(String key, Handler<AsyncResult<Long>> handler)` Get the length of the value stored in a key
`RedisClient`	`subscribe(String channel, Handler<AsyncResult<JsonArray>> handler)` Listen for messages published to the given channels
`RedisClient`	`subscribeMany(List<String> channels, Handler<AsyncResult<JsonArray>> handler)` Listen for messages published to the given channels
`RedisClient`	`sunion(List<String> keys, Handler<AsyncResult<JsonArray>> handler)` Add multiple sets
`RedisClient`	`sunionstore(String destkey, List<String> keys, Handler<AsyncResult<Long>> handler)` Add multiple sets and store the resulting set in a key
`RedisClient`	`swapdb(int index1, int index2, Handler<AsyncResult<String>> handler)` Swaps two Redis databases
`RedisClient`	`sync(Handler<AsyncResult<Void>> handler)` Internal command used for replication
`RedisClient`	`time(Handler<AsyncResult<JsonArray>> handler)` Return the current server time
`String`	`toString()`
`RedisClient`	`touch(String key, Handler<AsyncResult<Long>> handler)` Alters the last access time of a key(s).
`RedisClient`	`touchMany(List<String> keys, Handler<AsyncResult<Long>> handler)` Alters the last access time of a key(s).
`RedisTransaction`	`transaction()` Return a RedisTransaction instance
`RedisClient`	`ttl(String key, Handler<AsyncResult<Long>> handler)` Get the time to live for a key
`RedisClient`	`type(String key, Handler<AsyncResult<String>> handler)` Determine the type stored at key
`RedisClient`	`unlink(String key, Handler<AsyncResult<Long>> handler)` Delete a key asynchronously in another thread.
`RedisClient`	`unlinkMany(List<String> keys, Handler<AsyncResult<Long>> handler)` Delete multiple keys asynchronously in another thread.
`RedisClient`	`unsubscribe(List<String> channels, Handler<AsyncResult<Void>> handler)` Stop listening for messages posted to the given channels
`RedisClient`	`wait(long numSlaves, long timeout, Handler<AsyncResult<String>> handler)` Wait for the synchronous replication of all the write commands sent in the context of the current connection.
`RedisClient`	`zadd(String key, double score, String member, Handler<AsyncResult<Long>> handler)` Add one or more members to a sorted set, or update its score if it already exists
`RedisClient`	`zaddMany(String key, Map<String,Double> members, Handler<AsyncResult<Long>> handler)` Add one or more members to a sorted set, or update its score if it already exists
`RedisClient`	`zcard(String key, Handler<AsyncResult<Long>> handler)` Get the number of members in a sorted set
`RedisClient`	`zcount(String key, double min, double max, Handler<AsyncResult<Long>> handler)` Count the members in a sorted set with scores within the given values
`RedisClient`	`zincrby(String key, double increment, String member, Handler<AsyncResult<String>> handler)` Increment the score of a member in a sorted set
`RedisClient`	`zinterstore(String destkey, List<String> sets, AggregateOptions options, Handler<AsyncResult<Long>> handler)` Intersect multiple sorted sets and store the resulting sorted set in a new key
`RedisClient`	`zinterstoreWeighed(String destkey, Map<String,Double> sets, AggregateOptions options, Handler<AsyncResult<Long>> handler)` Intersect multiple sorted sets and store the resulting sorted set in a new key using weights for scoring
`RedisClient`	`zlexcount(String key, String min, String max, Handler<AsyncResult<Long>> handler)` Count the number of members in a sorted set between a given lexicographical range
`RedisClient`	`zrange(String key, long start, long stop, Handler<AsyncResult<JsonArray>> handler)` Return a range of members in a sorted set, by index
`RedisClient`	`zrangebylex(String key, String min, String max, LimitOptions options, Handler<AsyncResult<JsonArray>> handler)` Return a range of members in a sorted set, by lexicographical range
`RedisClient`	`zrangebyscore(String key, String min, String max, RangeLimitOptions options, Handler<AsyncResult<JsonArray>> handler)` Return a range of members in a sorted set, by score
`RedisClient`	`zrangeWithOptions(String key, long start, long stop, RangeOptions options, Handler<AsyncResult<JsonArray>> handler)` Return a range of members in a sorted set, by index
`RedisClient`	`zrank(String key, String member, Handler<AsyncResult<Long>> handler)` Determine the index of a member in a sorted set
`RedisClient`	`zrem(String key, String member, Handler<AsyncResult<Long>> handler)` Remove one member from a sorted set
`RedisClient`	`zremMany(String key, List<String> members, Handler<AsyncResult<Long>> handler)` Remove one or more members from a sorted set
`RedisClient`	`zremrangebylex(String key, String min, String max, Handler<AsyncResult<Long>> handler)` Remove all members in a sorted set between the given lexicographical range
`RedisClient`	`zremrangebyrank(String key, long start, long stop, Handler<AsyncResult<Long>> handler)` Remove all members in a sorted set within the given indexes
`RedisClient`	`zremrangebyscore(String key, String min, String max, Handler<AsyncResult<Long>> handler)` Remove all members in a sorted set within the given scores
`RedisClient`	`zrevrange(String key, long start, long stop, RangeOptions options, Handler<AsyncResult<JsonArray>> handler)` Return a range of members in a sorted set, by index, with scores ordered from high to low
`RedisClient`	`zrevrangebylex(String key, String max, String min, LimitOptions options, Handler<AsyncResult<JsonArray>> handler)` Return a range of members in a sorted set, by score, between the given lexicographical range with scores ordered from high to low
`RedisClient`	`zrevrangebyscore(String key, String max, String min, RangeLimitOptions options, Handler<AsyncResult<JsonArray>> handler)` Return a range of members in a sorted set, by score, with scores ordered from high to low
`RedisClient`	`zrevrank(String key, String member, Handler<AsyncResult<Long>> handler)` Determine the index of a member in a sorted set, with scores ordered from high to low
`RedisClient`	`zscan(String key, String cursor, ScanOptions options, Handler<AsyncResult<JsonArray>> handler)` Incrementally iterate sorted sets elements and associated scores
`RedisClient`	`zscore(String key, String member, Handler<AsyncResult<String>> handler)` Get the score associated with the given member in a sorted set
`RedisClient`	`zunionstore(String destkey, List<String> sets, AggregateOptions options, Handler<AsyncResult<Long>> handler)` Add multiple sorted sets and store the resulting sorted set in a new key
`RedisClient`	`zunionstoreWeighed(String key, Map<String,Double> sets, AggregateOptions options, Handler<AsyncResult<Long>> handler)` Add multiple sorted sets using weights, and store the resulting sorted set in a new key

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Field Detail

__TYPE_ARG

public static final io.vertx.lang.rx.TypeArg<RedisClient> __TYPE_ARG

Constructor Detail

RedisClient

public RedisClient(RedisClient delegate)

RedisClient
```
public RedisClient(Object delegate)
```

Method Detail

toString
```
public String toString()
```
Overrides:

toString in class Object

equals
```
public boolean equals(Object o)
```
Overrides:

equals in class Object

hashCode
```
public int hashCode()
```
Overrides:

hashCode in class Object

getDelegate
```
public RedisClient getDelegate()
```

create

public static RedisClient create(Vertx vertx)

create

public static RedisClient create(Vertx vertx,
                                 JsonObject config)

close
```
public void close(Handler<AsyncResult<Void>> handler)
```
Close the client - when it is fully closed the handler will be called.

Parameters:

handler -

rxClose
```
public Completable rxClose()
```
Close the client - when it is fully closed the handler will be called.

Returns:

append

public RedisClient append(String key,
                          String value,
                          Handler<AsyncResult<Long>> handler)

Append a value to a key

Parameters:: key - Key string; value - Value to append; handler - Handler for the result of this call.
Returns:

rxAppend

public Single<Long> rxAppend(String key,
                             String value)

Append a value to a key

Parameters:: key - Key string; value - Value to append
Returns:

auth

public RedisClient auth(String password,
                        Handler<AsyncResult<String>> handler)

Authenticate to the server

Parameters:: password - Password for authentication; handler - Handler for the result of this call.
Returns:

rxAuth
```
public Single<String> rxAuth(String password)
```
Authenticate to the server

Parameters:

password - Password for authentication

Returns:

bgrewriteaof
```
public RedisClient bgrewriteaof(Handler<AsyncResult<String>> handler)
```
Asynchronously rewrite the append-only file

Parameters:

handler -

Returns:

rxBgrewriteaof
```
public Single<String> rxBgrewriteaof()
```
Asynchronously rewrite the append-only file

Returns:

bgsave
```
public RedisClient bgsave(Handler<AsyncResult<String>> handler)
```
Asynchronously save the dataset to disk

Parameters:

handler -

Returns:

rxBgsave
```
public Single<String> rxBgsave()
```
Asynchronously save the dataset to disk

Returns:

bitcount

public RedisClient bitcount(String key,
                            Handler<AsyncResult<Long>> handler)

Count set bits in a string

Parameters:: key - Key string; handler - Handler for the result of this call.
Returns:

rxBitcount
```
public Single<Long> rxBitcount(String key)
```
Count set bits in a string

Parameters:

key - Key string

Returns:

bitcountRange

public RedisClient bitcountRange(String key,
                                 long start,
                                 long end,
                                 Handler<AsyncResult<Long>> handler)

Count set bits in a string

Parameters:: key - Key string; start - Start index; end - End index; handler - Handler for the result of this call.
Returns:

rxBitcountRange

public Single<Long> rxBitcountRange(String key,
                                    long start,
                                    long end)

Count set bits in a string

Parameters:: key - Key string; start - Start index; end - End index
Returns:

bitop

public RedisClient bitop(BitOperation operation,
                         String destkey,
                         List<String> keys,
                         Handler<AsyncResult<Long>> handler)

Perform bitwise operations between strings

Parameters:: operation - Bitwise operation to perform; destkey - Destination key where result is stored; keys - List of keys on which to perform the operation; handler - Handler for the result of this call.
Returns:

rxBitop

public Single<Long> rxBitop(BitOperation operation,
                            String destkey,
                            List<String> keys)

Perform bitwise operations between strings

Parameters:: operation - Bitwise operation to perform; destkey - Destination key where result is stored; keys - List of keys on which to perform the operation
Returns:

bitpos
```
public RedisClient bitpos(String key,
                          int bit,
                          Handler<AsyncResult<Long>> handler)
```
Find first bit set or clear in a string

Parameters:

key - Key string

bit - What bit value to look for - must be 1, or 0

handler - Handler for the result of this call.

Returns:

rxBitpos
```
public Single<Long> rxBitpos(String key,
                             int bit)
```
Find first bit set or clear in a string

Parameters:

key - Key string

bit - What bit value to look for - must be 1, or 0

Returns:

bitposFrom
```
public RedisClient bitposFrom(String key,
                              int bit,
                              int start,
                              Handler<AsyncResult<Long>> handler)
```
Find first bit set or clear in a string See also bitposRange() method, which takes start, and stop offset.

Parameters:

key - Key string

bit - What bit value to look for - must be 1, or 0

start - Start offset

handler - Handler for the result of this call.

Returns:

rxBitposFrom
```
public Single<Long> rxBitposFrom(String key,
                                 int bit,
                                 int start)
```
Find first bit set or clear in a string See also bitposRange() method, which takes start, and stop offset.

Parameters:

key - Key string

bit - What bit value to look for - must be 1, or 0

start - Start offset

Returns:

bitposRange
```
public RedisClient bitposRange(String key,
                               int bit,
                               int start,
                               int stop,
                               Handler<AsyncResult<Long>> handler)
```
Find first bit set or clear in a string Note: when both start, and stop offsets are specified, behaviour is slightly different than if only start is specified

Parameters:

key - Key string

bit - What bit value to look for - must be 1, or 0

start - Start offset

stop - End offset - inclusive

handler - Handler for the result of this call.

Returns:

rxBitposRange
```
public Single<Long> rxBitposRange(String key,
                                  int bit,
                                  int start,
                                  int stop)
```
Find first bit set or clear in a string Note: when both start, and stop offsets are specified, behaviour is slightly different than if only start is specified

Parameters:

key - Key string

bit - What bit value to look for - must be 1, or 0

start - Start offset

stop - End offset - inclusive

Returns:

blpop
```
public RedisClient blpop(String key,
                         int seconds,
                         Handler<AsyncResult<JsonArray>> handler)
```
Remove and get the first element in a list, or block until one is available

Parameters:

key - Key string identifying a list to watch

seconds - Timeout in seconds

handler - Handler for the result of this call.

Returns:

rxBlpop
```
public Single<JsonArray> rxBlpop(String key,
                                 int seconds)
```
Remove and get the first element in a list, or block until one is available

Parameters:

key - Key string identifying a list to watch

seconds - Timeout in seconds

Returns:

blpopMany
```
public RedisClient blpopMany(List<String> keys,
                             int seconds,
                             Handler<AsyncResult<JsonArray>> handler)
```
Remove and get the first element in any of the lists, or block until one is available

Parameters:

keys - List of key strings identifying lists to watch

seconds - Timeout in seconds

handler - Handler for the result of this call.

Returns:

rxBlpopMany
```
public Single<JsonArray> rxBlpopMany(List<String> keys,
                                     int seconds)
```
Remove and get the first element in any of the lists, or block until one is available

Parameters:

keys - List of key strings identifying lists to watch

seconds - Timeout in seconds

Returns:

brpop
```
public RedisClient brpop(String key,
                         int seconds,
                         Handler<AsyncResult<JsonArray>> handler)
```
Remove and get the last element in a list, or block until one is available

Parameters:

key - Key string identifying a list to watch

seconds - Timeout in seconds

handler - Handler for the result of this call.

Returns:

rxBrpop
```
public Single<JsonArray> rxBrpop(String key,
                                 int seconds)
```
Remove and get the last element in a list, or block until one is available

Parameters:

key - Key string identifying a list to watch

seconds - Timeout in seconds

Returns:

brpopMany
```
public RedisClient brpopMany(List<String> keys,
                             int seconds,
                             Handler<AsyncResult<JsonArray>> handler)
```
Remove and get the last element in any of the lists, or block until one is available

Parameters:

keys - List of key strings identifying lists to watch

seconds - Timeout in seconds

handler - Handler for the result of this call.

Returns:

rxBrpopMany
```
public Single<JsonArray> rxBrpopMany(List<String> keys,
                                     int seconds)
```
Remove and get the last element in any of the lists, or block until one is available

Parameters:

keys - List of key strings identifying lists to watch

seconds - Timeout in seconds

Returns:

brpoplpush
```
public RedisClient brpoplpush(String key,
                              String destkey,
                              int seconds,
                              Handler<AsyncResult<String>> handler)
```
Pop a value from a list, push it to another list and return it; or block until one is available

Parameters:

key - Key string identifying the source list

destkey - Key string identifying the destination list

seconds - Timeout in seconds

handler - Handler for the result of this call.

Returns:

rxBrpoplpush
```
public Single<String> rxBrpoplpush(String key,
                                   String destkey,
                                   int seconds)
```
Pop a value from a list, push it to another list and return it; or block until one is available

Parameters:

key - Key string identifying the source list

destkey - Key string identifying the destination list

seconds - Timeout in seconds

Returns:

clientKill

public RedisClient clientKill(KillFilter filter,
                              Handler<AsyncResult<Long>> handler)

Kill the connection of a client

Parameters:: filter - Filter options; handler - Handler for the result of this call.
Returns:

rxClientKill
```
public Single<Long> rxClientKill(KillFilter filter)
```
Kill the connection of a client

Parameters:

filter - Filter options

Returns:

clientList

public RedisClient clientList(Handler<AsyncResult<String>> handler)

Get the list of client connections

Parameters:: handler -
Returns:

rxClientList
```
public Single<String> rxClientList()
```
Get the list of client connections

Returns:

clientGetname

public RedisClient clientGetname(Handler<AsyncResult<String>> handler)

Get the current connection name

Parameters:: handler -
Returns:

rxClientGetname
```
public Single<String> rxClientGetname()
```
Get the current connection name

Returns:

clientPause
```
public RedisClient clientPause(long millis,
                               Handler<AsyncResult<String>> handler)
```
Stop processing commands from clients for some time

Parameters:

millis - Pause time in milliseconds

handler - Handler for the result of this call.

Returns:

rxClientPause
```
public Single<String> rxClientPause(long millis)
```
Stop processing commands from clients for some time

Parameters:

millis - Pause time in milliseconds

Returns:

clientSetname

public RedisClient clientSetname(String name,
                                 Handler<AsyncResult<String>> handler)

Set the current connection name

Parameters:: name - New name for current connection; handler - Handler for the result of this call.
Returns:

rxClientSetname
```
public Single<String> rxClientSetname(String name)
```
Set the current connection name

Parameters:

name - New name for current connection

Returns:

clusterAddslots

public RedisClient clusterAddslots(List<Long> slots,
                                   Handler<AsyncResult<Void>> handler)

Assign new hash slots to receiving node.

Parameters:: slots -; handler - Handler for the result of this call.
Returns:

rxClusterAddslots
```
public Completable rxClusterAddslots(List<Long> slots)
```
Assign new hash slots to receiving node.

Parameters:

slots -

Returns:

clusterCountFailureReports

public RedisClient clusterCountFailureReports(String nodeId,
                                              Handler<AsyncResult<Long>> handler)

Return the number of failure reports active for a given node.

Parameters:: nodeId -; handler - Handler for the result of this call.
Returns:

rxClusterCountFailureReports
```
public Single<Long> rxClusterCountFailureReports(String nodeId)
```
Return the number of failure reports active for a given node.

Parameters:

nodeId -

Returns:

clusterCountkeysinslot

public RedisClient clusterCountkeysinslot(long slot,
                                          Handler<AsyncResult<Long>> handler)

Return the number of local keys in the specified hash slot.

Parameters:: slot -; handler - Handler for the result of this call.
Returns:

rxClusterCountkeysinslot
```
public Single<Long> rxClusterCountkeysinslot(long slot)
```
Return the number of local keys in the specified hash slot.

Parameters:

slot -

Returns:

clusterDelslots

public RedisClient clusterDelslots(long slot,
                                   Handler<AsyncResult<Void>> handler)

Set hash slots as unbound in receiving node.

Parameters:: slot -; handler - Handler for the result of this call.
Returns:

rxClusterDelslots
```
public Completable rxClusterDelslots(long slot)
```
Set hash slots as unbound in receiving node.

Parameters:

slot -

Returns:

clusterDelslotsMany

public RedisClient clusterDelslotsMany(List<Long> slots,
                                       Handler<AsyncResult<Void>> handler)

Set hash slots as unbound in receiving node.

Parameters:: slots -; handler - Handler for the result of this call.
Returns:

rxClusterDelslotsMany
```
public Completable rxClusterDelslotsMany(List<Long> slots)
```
Set hash slots as unbound in receiving node.

Parameters:

slots -

Returns:

clusterFailover
```
public RedisClient clusterFailover(Handler<AsyncResult<Void>> handler)
```
Forces a slave to perform a manual failover of its master.

Parameters:

handler - Handler for the result of this call.

Returns:

rxClusterFailover
```
public Completable rxClusterFailover()
```
Forces a slave to perform a manual failover of its master.

Returns:

clusterFailOverWithOptions

public RedisClient clusterFailOverWithOptions(FailoverOptions options,
                                              Handler<AsyncResult<Void>> handler)

Forces a slave to perform a manual failover of its master.

Parameters:: options -; handler - Handler for the result of this call.
Returns:

rxClusterFailOverWithOptions
```
public Completable rxClusterFailOverWithOptions(FailoverOptions options)
```
Forces a slave to perform a manual failover of its master.

Parameters:

options -

Returns:

clusterForget

public RedisClient clusterForget(String nodeId,
                                 Handler<AsyncResult<Void>> handler)

Remove a node from the nodes table.

Parameters:: nodeId -; handler - Handler for the result of this call.
Returns:

rxClusterForget
```
public Completable rxClusterForget(String nodeId)
```
Remove a node from the nodes table.

Parameters:

nodeId -

Returns:

clusterGetkeysinslot

public RedisClient clusterGetkeysinslot(long slot,
                                        long count,
                                        Handler<AsyncResult<JsonArray>> handler)

Return local key names in the specified hash slot.

Parameters:: slot -; count -; handler - Handler for the result of this call.
Returns:

rxClusterGetkeysinslot

public Single<JsonArray> rxClusterGetkeysinslot(long slot,
                                                long count)

Return local key names in the specified hash slot.

Parameters:: slot -; count -
Returns:

clusterInfo
```
public RedisClient clusterInfo(Handler<AsyncResult<JsonArray>> handler)
```
Provides info about Redis Cluster node state.

Parameters:

handler - Handler for the result of this call.

Returns:

rxClusterInfo
```
public Single<JsonArray> rxClusterInfo()
```
Provides info about Redis Cluster node state.

Returns:

clusterKeyslot

public RedisClient clusterKeyslot(String key,
                                  Handler<AsyncResult<Long>> handler)

Returns the hash slot of the specified key.

Parameters:: key -; handler - Handler for the result of this call.
Returns:

rxClusterKeyslot
```
public Single<Long> rxClusterKeyslot(String key)
```
Returns the hash slot of the specified key.

Parameters:

key -

Returns:

clusterMeet

public RedisClient clusterMeet(String ip,
                               long port,
                               Handler<AsyncResult<Void>> handler)

Force a node cluster to handshake with another node.

Parameters:: ip -; port -; handler - Handler for the result of this call.
Returns:

rxClusterMeet

public Completable rxClusterMeet(String ip,
                                 long port)

Force a node cluster to handshake with another node.

Parameters:: ip -; port -
Returns:

clusterNodes
```
public RedisClient clusterNodes(Handler<AsyncResult<JsonArray>> handler)
```
Get Cluster config for the node.

Parameters:

handler - Handler for the result of this call.

Returns:

rxClusterNodes
```
public Single<JsonArray> rxClusterNodes()
```
Get Cluster config for the node.

Returns:

clusterReplicate

public RedisClient clusterReplicate(String nodeId,
                                    Handler<AsyncResult<Void>> handler)

Reconfigure a node as a slave of the specified master node.

Parameters:: nodeId -; handler - Handler for the result of this call.
Returns:

rxClusterReplicate
```
public Completable rxClusterReplicate(String nodeId)
```
Reconfigure a node as a slave of the specified master node.

Parameters:

nodeId -

Returns:

clusterReset
```
public RedisClient clusterReset(Handler<AsyncResult<Void>> handler)
```
Reset a Redis Cluster node.

Parameters:

handler - Handler for the result of this call.

Returns:

rxClusterReset
```
public Completable rxClusterReset()
```
Reset a Redis Cluster node.

Returns:

clusterResetWithOptions

public RedisClient clusterResetWithOptions(ResetOptions options,
                                           Handler<AsyncResult<Void>> handler)

Reset a Redis Cluster node.

Parameters:: options -; handler - Handler for the result of this call.
Returns:

rxClusterResetWithOptions
```
public Completable rxClusterResetWithOptions(ResetOptions options)
```
Reset a Redis Cluster node.

Parameters:

options -

Returns:

clusterSaveconfig
```
public RedisClient clusterSaveconfig(Handler<AsyncResult<Void>> handler)
```
Forces the node to save cluster state on disk.

Parameters:

handler - Handler for the result of this call.

Returns:

rxClusterSaveconfig
```
public Completable rxClusterSaveconfig()
```
Forces the node to save cluster state on disk.

Returns:

clusterSetConfigEpoch

public RedisClient clusterSetConfigEpoch(long epoch,
                                         Handler<AsyncResult<Void>> handler)

Set the configuration epoch in a new node.

Parameters:: epoch -; handler - Handler for the result of this call.
Returns:

rxClusterSetConfigEpoch
```
public Completable rxClusterSetConfigEpoch(long epoch)
```
Set the configuration epoch in a new node.

Parameters:

epoch -

Returns:

clusterSetslot

public RedisClient clusterSetslot(long slot,
                                  SlotCmd subcommand,
                                  Handler<AsyncResult<Void>> handler)

Bind an hash slot to a specific node.

Parameters:: slot -; subcommand -; handler - Handler for the result of this call.
Returns:

rxClusterSetslot

public Completable rxClusterSetslot(long slot,
                                    SlotCmd subcommand)

Bind an hash slot to a specific node.

Parameters:: slot -; subcommand -
Returns:

clusterSetslotWithNode

public RedisClient clusterSetslotWithNode(long slot,
                                          SlotCmd subcommand,
                                          String nodeId,
                                          Handler<AsyncResult<Void>> handler)

Bind an hash slot to a specific node.

Parameters:: slot -; subcommand -; nodeId -; handler - Handler for the result of this call.
Returns:

rxClusterSetslotWithNode

public Completable rxClusterSetslotWithNode(long slot,
                                            SlotCmd subcommand,
                                            String nodeId)

Bind an hash slot to a specific node.

Parameters:: slot -; subcommand -; nodeId -
Returns:

clusterSlaves

public RedisClient clusterSlaves(String nodeId,
                                 Handler<AsyncResult<JsonArray>> handler)

List slave nodes of the specified master node.

Parameters:: nodeId -; handler - Handler for the result of this call.
Returns:

rxClusterSlaves
```
public Single<JsonArray> rxClusterSlaves(String nodeId)
```
List slave nodes of the specified master node.

Parameters:

nodeId -

Returns:

clusterSlots
```
public RedisClient clusterSlots(Handler<AsyncResult<JsonArray>> handler)
```
Get array of Cluster slot to node mappings

Parameters:

handler -

Returns:

rxClusterSlots
```
public Single<JsonArray> rxClusterSlots()
```
Get array of Cluster slot to node mappings

Returns:

command

public RedisClient command(Handler<AsyncResult<JsonArray>> handler)

Get array of Redis command details

Parameters:: handler -
Returns:

rxCommand
```
public Single<JsonArray> rxCommand()
```
Get array of Redis command details

Returns:

commandCount

public RedisClient commandCount(Handler<AsyncResult<Long>> handler)

Get total number of Redis commands

Parameters:: handler -
Returns:

rxCommandCount
```
public Single<Long> rxCommandCount()
```
Get total number of Redis commands

Returns:

commandGetkeys

public RedisClient commandGetkeys(Handler<AsyncResult<JsonArray>> handler)

Extract keys given a full Redis command

Parameters:: handler -
Returns:

rxCommandGetkeys
```
public Single<JsonArray> rxCommandGetkeys()
```
Extract keys given a full Redis command

Returns:

commandInfo

public RedisClient commandInfo(List<String> commands,
                               Handler<AsyncResult<JsonArray>> handler)

Get array of specific Redis command details

Parameters:: commands - List of commands to get info for; handler - Handler for the result of this call.
Returns:

rxCommandInfo
```
public Single<JsonArray> rxCommandInfo(List<String> commands)
```
Get array of specific Redis command details

Parameters:

commands - List of commands to get info for

Returns:

configGet

public RedisClient configGet(String parameter,
                             Handler<AsyncResult<JsonArray>> handler)

Get the value of a configuration parameter

Parameters:: parameter - Configuration parameter; handler - Handler for the result of this call.
Returns:

rxConfigGet
```
public Single<JsonArray> rxConfigGet(String parameter)
```
Get the value of a configuration parameter

Parameters:

parameter - Configuration parameter

Returns:

configRewrite
```
public RedisClient configRewrite(Handler<AsyncResult<String>> handler)
```
Rewrite the configuration file with the in memory configuration

Parameters:

handler -

Returns:

rxConfigRewrite
```
public Single<String> rxConfigRewrite()
```
Rewrite the configuration file with the in memory configuration

Returns:

configSet

public RedisClient configSet(String parameter,
                             String value,
                             Handler<AsyncResult<String>> handler)

Set a configuration parameter to the given value

Parameters:: parameter - Configuration parameter; value - New value; handler - Handler for the result of this call.
Returns:

rxConfigSet

public Single<String> rxConfigSet(String parameter,
                                  String value)

Set a configuration parameter to the given value

Parameters:: parameter - Configuration parameter; value - New value
Returns:

configResetstat

public RedisClient configResetstat(Handler<AsyncResult<String>> handler)

Reset the stats returned by INFO

Parameters:: handler -
Returns:

rxConfigResetstat
```
public Single<String> rxConfigResetstat()
```
Reset the stats returned by INFO

Returns:

dbsize
```
public RedisClient dbsize(Handler<AsyncResult<Long>> handler)
```
Return the number of keys in the selected database

Parameters:

handler -

Returns:

rxDbsize
```
public Single<Long> rxDbsize()
```
Return the number of keys in the selected database

Returns:

debugObject

public RedisClient debugObject(String key,
                               Handler<AsyncResult<String>> handler)

Get debugging information about a key

Parameters:: key - Key string; handler - Handler for the result of this call.
Returns:

rxDebugObject
```
public Single<String> rxDebugObject(String key)
```
Get debugging information about a key

Parameters:

key - Key string

Returns:

debugSegfault

public RedisClient debugSegfault(Handler<AsyncResult<String>> handler)

Make the server crash

Parameters:: handler -
Returns:

rxDebugSegfault
```
public Single<String> rxDebugSegfault()
```
Make the server crash

Returns:

decr

public RedisClient decr(String key,
                        Handler<AsyncResult<Long>> handler)

Decrement the integer value of a key by one

Parameters:: key - Key string; handler - Handler for the result of this call.
Returns:

rxDecr
```
public Single<Long> rxDecr(String key)
```
Decrement the integer value of a key by one

Parameters:

key - Key string

Returns:

decrby

public RedisClient decrby(String key,
                          long decrement,
                          Handler<AsyncResult<Long>> handler)

Decrement the integer value of a key by the given number

Parameters:: key - Key string; decrement - Value by which to decrement; handler - Handler for the result of this call.
Returns:

rxDecrby
```
public Single<Long> rxDecrby(String key,
                             long decrement)
```
Decrement the integer value of a key by the given number

Parameters:

key - Key string

decrement - Value by which to decrement

Returns:

del

public RedisClient del(String key,
                       Handler<AsyncResult<Long>> handler)

Delete a key

Parameters:: key - Keys to delete; handler - Handler for the result of this call.
Returns:

rxDel
```
public Single<Long> rxDel(String key)
```
Delete a key

Parameters:

key - Keys to delete

Returns:

delMany

public RedisClient delMany(List<String> keys,
                           Handler<AsyncResult<Long>> handler)

Delete many keys

Parameters:: keys - List of keys to delete; handler - Handler for the result of this call.
Returns:

rxDelMany
```
public Single<Long> rxDelMany(List<String> keys)
```
Delete many keys

Parameters:

keys - List of keys to delete

Returns:

dump
```
public RedisClient dump(String key,
                        Handler<AsyncResult<String>> handler)
```
Return a serialized version of the value stored at the specified key.

Parameters:

key - Key string

handler - Handler for the result of this call.

Returns:

rxDump
```
public Single<String> rxDump(String key)
```
Return a serialized version of the value stored at the specified key.

Parameters:

key - Key string

Returns:

echo

public RedisClient echo(String message,
                        Handler<AsyncResult<String>> handler)

Echo the given string

Parameters:: message - String to echo; handler - Handler for the result of this call.
Returns:

rxEcho
```
public Single<String> rxEcho(String message)
```
Echo the given string

Parameters:

message - String to echo

Returns:

eval
```
public RedisClient eval(String script,
                        List<String> keys,
                        List<String> args,
                        Handler<AsyncResult<JsonArray>> handler)
```
Execute a Lua script server side. Due to the dynamic nature of this command any response type could be returned for This reason and to ensure type safety the reply is always guaranteed to be a JsonArray. When a reply if for example a String the handler will be called with a JsonArray with a single element containing the String.

Parameters:

script - Lua script to evaluate

keys - List of keys

args - List of argument values

handler - Handler for the result of this call.

Returns:

rxEval
```
public Single<JsonArray> rxEval(String script,
                                List<String> keys,
                                List<String> args)
```
Execute a Lua script server side. Due to the dynamic nature of this command any response type could be returned for This reason and to ensure type safety the reply is always guaranteed to be a JsonArray. When a reply if for example a String the handler will be called with a JsonArray with a single element containing the String.

Parameters:

script - Lua script to evaluate

keys - List of keys

args - List of argument values

Returns:

evalsha
```
public RedisClient evalsha(String sha1,
                           List<String> keys,
                           List<String> values,
                           Handler<AsyncResult<JsonArray>> handler)
```
Execute a Lua script server side. Due to the dynamic nature of this command any response type could be returned for This reason and to ensure type safety the reply is always guaranteed to be a JsonArray. When a reply if for example a String the handler will be called with a JsonArray with a single element containing the String.

Parameters:

sha1 - SHA1 digest of the script cached on the server

keys - List of keys

values - List of values

handler - Handler for the result of this call.

Returns:

rxEvalsha
```
public Single<JsonArray> rxEvalsha(String sha1,
                                   List<String> keys,
                                   List<String> values)
```
Execute a Lua script server side. Due to the dynamic nature of this command any response type could be returned for This reason and to ensure type safety the reply is always guaranteed to be a JsonArray. When a reply if for example a String the handler will be called with a JsonArray with a single element containing the String.

Parameters:

sha1 - SHA1 digest of the script cached on the server

keys - List of keys

values - List of values

Returns:

evalScript
```
public RedisClient evalScript(Script script,
                              List<String> keys,
                              List<String> args,
                              Handler<AsyncResult<JsonArray>> handler)
```
Execute a Lua script server side. This method is a high level wrapper around EVAL and EVALSHA using the latter if possible, falling back to EVAL if the script is not cached by the server yet. According to Redis documentation, executed scripts are guaranteed to be in the script cache of a given execution of a Redis instance forever, which means typically the overhead incurred by optimistically sending EVALSHA is minimal, while improving performance and saving bandwidth compared to using EVAL every time.

Parameters:

script - Lua script and its SHA1 digest

keys - List of keys

args - List of argument values

handler - Handler for the result of this call. group: scripting

Returns:

rxEvalScript
```
public Single<JsonArray> rxEvalScript(Script script,
                                      List<String> keys,
                                      List<String> args)
```
Execute a Lua script server side. This method is a high level wrapper around EVAL and EVALSHA using the latter if possible, falling back to EVAL if the script is not cached by the server yet. According to Redis documentation, executed scripts are guaranteed to be in the script cache of a given execution of a Redis instance forever, which means typically the overhead incurred by optimistically sending EVALSHA is minimal, while improving performance and saving bandwidth compared to using EVAL every time.

Parameters:

script - Lua script and its SHA1 digest

keys - List of keys

args - List of argument values

Returns:

exists

public RedisClient exists(String key,
                          Handler<AsyncResult<Long>> handler)

Determine if a key exists

Parameters:: key - Key string; handler - Handler for the result of this call.
Returns:

rxExists
```
public Single<Long> rxExists(String key)
```
Determine if a key exists

Parameters:

key - Key string

Returns:

existsMany

public RedisClient existsMany(List<String> keys,
                              Handler<AsyncResult<Long>> handler)

Determine if one or many keys exist

Parameters:: keys - List of key strings; handler - Handler for the result of this call.
Returns:

rxExistsMany
```
public Single<Long> rxExistsMany(List<String> keys)
```
Determine if one or many keys exist

Parameters:

keys - List of key strings

Returns:

expire

public RedisClient expire(String key,
                          long seconds,
                          Handler<AsyncResult<Long>> handler)

Set a key's time to live in seconds

Parameters:: key - Key string; seconds - Time to live in seconds; handler - Handler for the result of this call.
Returns:

rxExpire
```
public Single<Long> rxExpire(String key,
                             long seconds)
```
Set a key's time to live in seconds

Parameters:

key - Key string

seconds - Time to live in seconds

Returns:

expireat

public RedisClient expireat(String key,
                            long seconds,
                            Handler<AsyncResult<Long>> handler)

Set the expiration for a key as a UNIX timestamp

Parameters:: key - Key string; seconds - Expiry time as Unix timestamp in seconds; handler - Handler for the result of this call.
Returns:

rxExpireat
```
public Single<Long> rxExpireat(String key,
                               long seconds)
```
Set the expiration for a key as a UNIX timestamp

Parameters:

key - Key string

seconds - Expiry time as Unix timestamp in seconds

Returns:

flushall

public RedisClient flushall(Handler<AsyncResult<String>> handler)

Remove all keys from all databases

Parameters:: handler -
Returns:

rxFlushall
```
public Single<String> rxFlushall()
```
Remove all keys from all databases

Returns:

flushdb
```
public RedisClient flushdb(Handler<AsyncResult<String>> handler)
```
Remove all keys from the current database

Parameters:

handler -

Returns:

rxFlushdb
```
public Single<String> rxFlushdb()
```
Remove all keys from the current database

Returns:

get

public RedisClient get(String key,
                       Handler<AsyncResult<String>> handler)

Get the value of a key

Parameters:: key - Key string; handler - Handler for the result of this call.
Returns:

rxGet
```
public Maybe<String> rxGet(String key)
```
Get the value of a key

Parameters:

key - Key string

Returns:

getBinary

public RedisClient getBinary(String key,
                             Handler<AsyncResult<Buffer>> handler)

Get the value of a key - without decoding as utf-8

Parameters:: key - Key string; handler - Handler for the result of this call.
Returns:

rxGetBinary
```
public Maybe<Buffer> rxGetBinary(String key)
```
Get the value of a key - without decoding as utf-8

Parameters:

key - Key string

Returns:

getbit

public RedisClient getbit(String key,
                          long offset,
                          Handler<AsyncResult<Long>> handler)

Returns the bit value at offset in the string value stored at key

Parameters:: key - Key string; offset - Offset in bits; handler - Handler for the result of this call.
Returns:

rxGetbit
```
public Single<Long> rxGetbit(String key,
                             long offset)
```
Returns the bit value at offset in the string value stored at key

Parameters:

key - Key string

offset - Offset in bits

Returns:

getrange

public RedisClient getrange(String key,
                            long start,
                            long end,
                            Handler<AsyncResult<String>> handler)

Get a substring of the string stored at a key

Parameters:: key - Key string; start - Start offset; end - End offset - inclusive; handler - Handler for the result of this call.
Returns:

rxGetrange

public Single<String> rxGetrange(String key,
                                 long start,
                                 long end)

Get a substring of the string stored at a key

Parameters:: key - Key string; start - Start offset; end - End offset - inclusive
Returns:

getset

public RedisClient getset(String key,
                          String value,
                          Handler<AsyncResult<String>> handler)

Set the string value of a key and return its old value

Parameters:: key - Key of which value to set; value - New value for the key; handler - Handler for the result of this call.
Returns:

rxGetset
```
public Maybe<String> rxGetset(String key,
                              String value)
```
Set the string value of a key and return its old value

Parameters:

key - Key of which value to set

value - New value for the key

Returns:

hdel

public RedisClient hdel(String key,
                        String field,
                        Handler<AsyncResult<Long>> handler)

Delete one or more hash fields

Parameters:: key - Key string; field - Field name; handler - Handler for the result of this call.
Returns:

rxHdel

public Single<Long> rxHdel(String key,
                           String field)

Delete one or more hash fields

Parameters:: key - Key string; field - Field name
Returns:

hdelMany

public RedisClient hdelMany(String key,
                            List<String> fields,
                            Handler<AsyncResult<Long>> handler)

Delete one or more hash fields

Parameters:: key - Key string; fields - Field names; handler - Handler for the result of this call.
Returns:

rxHdelMany

public Single<Long> rxHdelMany(String key,
                               List<String> fields)

Delete one or more hash fields

Parameters:: key - Key string; fields - Field names
Returns:

hexists

public RedisClient hexists(String key,
                           String field,
                           Handler<AsyncResult<Long>> handler)

Determine if a hash field exists

Parameters:: key - Key string; field - Field name; handler - Handler for the result of this call.
Returns:

rxHexists

public Single<Long> rxHexists(String key,
                              String field)

Determine if a hash field exists

Parameters:: key - Key string; field - Field name
Returns:

hget

public RedisClient hget(String key,
                        String field,
                        Handler<AsyncResult<String>> handler)

Get the value of a hash field

Parameters:: key - Key string; field - Field name; handler - Handler for the result of this call.
Returns:

rxHget

public Maybe<String> rxHget(String key,
                            String field)

Get the value of a hash field

Parameters:: key - Key string; field - Field name
Returns:

hgetall

public RedisClient hgetall(String key,
                           Handler<AsyncResult<JsonObject>> handler)

Get all the fields and values in a hash

Parameters:: key - Key string; handler - Handler for the result of this call.
Returns:

rxHgetall
```
public Single<JsonObject> rxHgetall(String key)
```
Get all the fields and values in a hash

Parameters:

key - Key string

Returns:

hincrby

public RedisClient hincrby(String key,
                           String field,
                           long increment,
                           Handler<AsyncResult<Long>> handler)

Increment the integer value of a hash field by the given number

Parameters:: key - Key string; field - Field name; increment - Value by which to increment; handler - Handler for the result of this call.
Returns:

rxHincrby

public Single<Long> rxHincrby(String key,
                              String field,
                              long increment)

Increment the integer value of a hash field by the given number

Parameters:: key - Key string; field - Field name; increment - Value by which to increment
Returns:

hincrbyfloat

public RedisClient hincrbyfloat(String key,
                                String field,
                                double increment,
                                Handler<AsyncResult<String>> handler)

Increment the float value of a hash field by the given amount

Parameters:: key - Key string; field - Field name; increment - Value by which to increment; handler - Handler for the result of this call.
Returns:

rxHincrbyfloat

public Single<String> rxHincrbyfloat(String key,
                                     String field,
                                     double increment)

Increment the float value of a hash field by the given amount

Parameters:: key - Key string; field - Field name; increment - Value by which to increment
Returns:

hkeys

public RedisClient hkeys(String key,
                         Handler<AsyncResult<JsonArray>> handler)

Get all the fields in a hash

Parameters:: key - Key string; handler - Handler for the result of this call.
Returns:

rxHkeys
```
public Single<JsonArray> rxHkeys(String key)
```
Get all the fields in a hash

Parameters:

key - Key string

Returns:

hlen

public RedisClient hlen(String key,
                        Handler<AsyncResult<Long>> handler)

Get the number of fields in a hash

Parameters:: key - Key string; handler - Handler for the result of this call.
Returns:

rxHlen
```
public Single<Long> rxHlen(String key)
```
Get the number of fields in a hash

Parameters:

key - Key string

Returns:

hmget

public RedisClient hmget(String key,
                         List<String> fields,
                         Handler<AsyncResult<JsonArray>> handler)

Get the values of all the given hash fields

Parameters:: key - Key string; fields - Field names; handler - Handler for the result of this call.
Returns:

rxHmget

public Single<JsonArray> rxHmget(String key,
                                 List<String> fields)

Get the values of all the given hash fields

Parameters:: key - Key string; fields - Field names
Returns:

hmset

public RedisClient hmset(String key,
                         JsonObject values,
                         Handler<AsyncResult<String>> handler)

Set multiple hash fields to multiple values

Parameters:: key - Key string; values - Map of field:value pairs; handler - Handler for the result of this call.
Returns:

rxHmset

public Single<String> rxHmset(String key,
                              JsonObject values)

Set multiple hash fields to multiple values

Parameters:: key - Key string; values - Map of field:value pairs
Returns:

hset

public RedisClient hset(String key,
                        String field,
                        String value,
                        Handler<AsyncResult<Long>> handler)

Set the string value of a hash field

Parameters:: key - Key string; field - Field name; value - New value; handler - Handler for the result of this call.
Returns:

rxHset

public Single<Long> rxHset(String key,
                           String field,
                           String value)

Set the string value of a hash field

Parameters:: key - Key string; field - Field name; value - New value
Returns:

hsetnx

public RedisClient hsetnx(String key,
                          String field,
                          String value,
                          Handler<AsyncResult<Long>> handler)

Set the value of a hash field, only if the field does not exist

Parameters:: key - Key string; field - Field name; value - New value; handler - Handler for the result of this call.
Returns:

rxHsetnx

public Single<Long> rxHsetnx(String key,
                             String field,
                             String value)

Set the value of a hash field, only if the field does not exist

Parameters:: key - Key string; field - Field name; value - New value
Returns:

hvals

public RedisClient hvals(String key,
                         Handler<AsyncResult<JsonArray>> handler)

Get all the values in a hash

Parameters:: key - Key string; handler - Handler for the result of this call.
Returns:

rxHvals
```
public Single<JsonArray> rxHvals(String key)
```
Get all the values in a hash

Parameters:

key - Key string

Returns:

incr

public RedisClient incr(String key,
                        Handler<AsyncResult<Long>> handler)

Increment the integer value of a key by one

Parameters:: key - Key string; handler - Handler for the result of this call.
Returns:

rxIncr
```
public Single<Long> rxIncr(String key)
```
Increment the integer value of a key by one

Parameters:

key - Key string

Returns:

incrby

public RedisClient incrby(String key,
                          long increment,
                          Handler<AsyncResult<Long>> handler)

Increment the integer value of a key by the given amount

Parameters:: key - Key string; increment - Value by which to increment; handler - Handler for the result of this call.
Returns:

rxIncrby
```
public Single<Long> rxIncrby(String key,
                             long increment)
```
Increment the integer value of a key by the given amount

Parameters:

key - Key string

increment - Value by which to increment

Returns:

incrbyfloat

public RedisClient incrbyfloat(String key,
                               double increment,
                               Handler<AsyncResult<String>> handler)

Increment the float value of a key by the given amount

Parameters:: key - Key string; increment - Value by which to increment; handler - Handler for the result of this call.
Returns:

rxIncrbyfloat
```
public Single<String> rxIncrbyfloat(String key,
                                    double increment)
```
Increment the float value of a key by the given amount

Parameters:

key - Key string

increment - Value by which to increment

Returns:

info
```
public RedisClient info(Handler<AsyncResult<JsonObject>> handler)
```
Get information and statistics about the server

Parameters:

handler - Handler for the result of this call.

Returns:

rxInfo
```
public Single<JsonObject> rxInfo()
```
Get information and statistics about the server

Returns:

infoSection
```
public RedisClient infoSection(String section,
                               Handler<AsyncResult<JsonObject>> handler)
```
Get information and statistics about the server

Parameters:

section - Specific section of information to return

handler - Handler for the result of this call.

Returns:

rxInfoSection
```
public Single<JsonObject> rxInfoSection(String section)
```
Get information and statistics about the server

Parameters:

section - Specific section of information to return

Returns:

keys
```
public RedisClient keys(String pattern,
                        Handler<AsyncResult<JsonArray>> handler)
```
Find all keys matching the given pattern

Parameters:

pattern - Pattern to limit the keys returned

handler - Handler for the result of this call.

Returns:

rxKeys
```
public Single<JsonArray> rxKeys(String pattern)
```
Find all keys matching the given pattern

Parameters:

pattern - Pattern to limit the keys returned

Returns:

lastsave
```
public RedisClient lastsave(Handler<AsyncResult<Long>> handler)
```
Get the UNIX time stamp of the last successful save to disk

Parameters:

handler -

Returns:

rxLastsave
```
public Single<Long> rxLastsave()
```
Get the UNIX time stamp of the last successful save to disk

Returns:

lindex

public RedisClient lindex(String key,
                          int index,
                          Handler<AsyncResult<String>> handler)

Get an element from a list by its index

Parameters:: key - Key string; index - Index of list element to get; handler - Handler for the result of this call.
Returns:

rxLindex
```
public Single<String> rxLindex(String key,
                               int index)
```
Get an element from a list by its index

Parameters:

key - Key string

index - Index of list element to get

Returns:

linsert

public RedisClient linsert(String key,
                           InsertOptions option,
                           String pivot,
                           String value,
                           Handler<AsyncResult<Long>> handler)

Insert an element before or after another element in a list

Parameters:: key - Key string; option - BEFORE or AFTER; pivot - Key to use as a pivot; value - Value to be inserted before or after the pivot; handler - Handler for the result of this call.
Returns:

rxLinsert

public Single<Long> rxLinsert(String key,
                              InsertOptions option,
                              String pivot,
                              String value)

Insert an element before or after another element in a list

Parameters:: key - Key string; option - BEFORE or AFTER; pivot - Key to use as a pivot; value - Value to be inserted before or after the pivot
Returns:

llen

public RedisClient llen(String key,
                        Handler<AsyncResult<Long>> handler)

Get the length of a list

Parameters:: key - String key; handler - Handler for the result of this call.
Returns:

rxLlen
```
public Single<Long> rxLlen(String key)
```
Get the length of a list

Parameters:

key - String key

Returns:

lpop

public RedisClient lpop(String key,
                        Handler<AsyncResult<String>> handler)

Remove and get the first element in a list

Parameters:: key - String key; handler - Handler for the result of this call.
Returns:

rxLpop
```
public Maybe<String> rxLpop(String key)
```
Remove and get the first element in a list

Parameters:

key - String key

Returns:

lpushMany

public RedisClient lpushMany(String key,
                             List<String> values,
                             Handler<AsyncResult<Long>> handler)

Prepend one or multiple values to a list

Parameters:: key - Key string; values - Values to be added at the beginning of the list, one by one; handler - Handler for the result of this call.
Returns:

rxLpushMany
```
public Single<Long> rxLpushMany(String key,
                                List<String> values)
```
Prepend one or multiple values to a list

Parameters:

key - Key string

values - Values to be added at the beginning of the list, one by one

Returns:

lpush

public RedisClient lpush(String key,
                         String value,
                         Handler<AsyncResult<Long>> handler)

Prepend one value to a list

Parameters:: key - Key string; value - Value to be added at the beginning of the list; handler - Handler for the result of this call.
Returns:

rxLpush
```
public Single<Long> rxLpush(String key,
                            String value)
```
Prepend one value to a list

Parameters:

key - Key string

value - Value to be added at the beginning of the list

Returns:

lpushx

public RedisClient lpushx(String key,
                          String value,
                          Handler<AsyncResult<Long>> handler)

Prepend a value to a list, only if the list exists

Parameters:: key - Key string; value - Value to add at the beginning of the list; handler - Handler for the result of this call.
Returns:

rxLpushx
```
public Single<Long> rxLpushx(String key,
                             String value)
```
Prepend a value to a list, only if the list exists

Parameters:

key - Key string

value - Value to add at the beginning of the list

Returns:

lrange

public RedisClient lrange(String key,
                          long from,
                          long to,
                          Handler<AsyncResult<JsonArray>> handler)

Get a range of elements from a list

Parameters:: key - Key string; from - Start index; to - Stop index; handler - Handler for the result of this call.
Returns:

rxLrange

public Single<JsonArray> rxLrange(String key,
                                  long from,
                                  long to)

Get a range of elements from a list

Parameters:: key - Key string; from - Start index; to - Stop index
Returns:

lrem

public RedisClient lrem(String key,
                        long count,
                        String value,
                        Handler<AsyncResult<Long>> handler)

Remove elements from a list

Parameters:: key - Key string; count - Number of first found occurrences equal to $value to remove from the list; value - Value to be removed; handler - Handler for the result of this call.
Returns:

rxLrem
```
public Single<Long> rxLrem(String key,
                           long count,
                           String value)
```
Remove elements from a list

Parameters:

key - Key string

count - Number of first found occurrences equal to $value to remove from the list

value - Value to be removed

Returns:

lset

public RedisClient lset(String key,
                        long index,
                        String value,
                        Handler<AsyncResult<String>> handler)

Set the value of an element in a list by its index

Parameters:: key - Key string; index - Position within list; value - New value; handler - Handler for the result of this call.
Returns:

rxLset

public Single<String> rxLset(String key,
                             long index,
                             String value)

Set the value of an element in a list by its index

Parameters:: key - Key string; index - Position within list; value - New value
Returns:

ltrim

public RedisClient ltrim(String key,
                         long from,
                         long to,
                         Handler<AsyncResult<String>> handler)

Trim a list to the specified range

Parameters:: key - Key string; from - Start index; to - Stop index; handler - Handler for the result of this call.
Returns:

rxLtrim

public Single<String> rxLtrim(String key,
                              long from,
                              long to)

Trim a list to the specified range

Parameters:: key - Key string; from - Start index; to - Stop index
Returns:

mget

public RedisClient mget(String key,
                        Handler<AsyncResult<JsonArray>> handler)

Get the value of the given key

Parameters:: key - Key string; handler - Handler for the result of this call.
Returns:

rxMget
```
public Single<JsonArray> rxMget(String key)
```
Get the value of the given key

Parameters:

key - Key string

Returns:

mgetMany

public RedisClient mgetMany(List<String> keys,
                            Handler<AsyncResult<JsonArray>> handler)

Get the values of all the given keys

Parameters:: keys - List of keys to get; handler - Handler for the result of this call.
Returns:

rxMgetMany
```
public Single<JsonArray> rxMgetMany(List<String> keys)
```
Get the values of all the given keys

Parameters:

keys - List of keys to get

Returns:

migrate

public RedisClient migrate(String host,
                           int port,
                           String key,
                           int destdb,
                           long timeout,
                           MigrateOptions options,
                           Handler<AsyncResult<String>> handler)

Atomically transfer a key from a Redis instance to another one.

Parameters:: host - Destination host; port - Destination port; key - Key to migrate; destdb - Destination database index; timeout -; options - Migrate options; handler - Handler for the result of this call.
Returns:

rxMigrate

public Single<String> rxMigrate(String host,
                                int port,
                                String key,
                                int destdb,
                                long timeout,
                                MigrateOptions options)

Atomically transfer a key from a Redis instance to another one.

Parameters:: host - Destination host; port - Destination port; key - Key to migrate; destdb - Destination database index; timeout -; options - Migrate options
Returns:

monitor
```
public RedisClient monitor(Handler<AsyncResult<Void>> handler)
```
Listen for all requests received by the server in real time

Parameters:

handler -

Returns:

rxMonitor
```
public Completable rxMonitor()
```
Listen for all requests received by the server in real time

Returns:

move

public RedisClient move(String key,
                        int destdb,
                        Handler<AsyncResult<Long>> handler)

Move a key to another database

Parameters:: key - Key to migrate; destdb - Destination database index; handler - Handler for the result of this call.
Returns:

rxMove
```
public Single<Long> rxMove(String key,
                           int destdb)
```
Move a key to another database

Parameters:

key - Key to migrate

destdb - Destination database index

Returns:

mset

public RedisClient mset(JsonObject keyvals,
                        Handler<AsyncResult<String>> handler)

Set multiple keys to multiple values

Parameters:: keyvals - Key value pairs to set; handler - Handler for the result of this call.
Returns:

rxMset
```
public Single<String> rxMset(JsonObject keyvals)
```
Set multiple keys to multiple values

Parameters:

keyvals - Key value pairs to set

Returns:

msetnx
```
public RedisClient msetnx(JsonObject keyvals,
                          Handler<AsyncResult<Long>> handler)
```
Set multiple keys to multiple values, only if none of the keys exist

Parameters:

keyvals - Key value pairs to set

handler - Handler for the result of this call.

Returns:

rxMsetnx
```
public Single<Long> rxMsetnx(JsonObject keyvals)
```
Set multiple keys to multiple values, only if none of the keys exist

Parameters:

keyvals - Key value pairs to set

Returns:

object

public RedisClient object(String key,
                          ObjectCmd cmd,
                          Handler<AsyncResult<Void>> handler)

Inspect the internals of Redis objects

Parameters:: key - Key string; cmd - Object sub command; handler - Handler for the result of this call.
Returns:

rxObject

public Completable rxObject(String key,
                            ObjectCmd cmd)

Inspect the internals of Redis objects

Parameters:: key - Key string; cmd - Object sub command
Returns:

persist

public RedisClient persist(String key,
                           Handler<AsyncResult<Long>> handler)

Remove the expiration from a key

Parameters:: key - Key string; handler - Handler for the result of this call.
Returns:

rxPersist
```
public Single<Long> rxPersist(String key)
```
Remove the expiration from a key

Parameters:

key - Key string

Returns:

pexpire

public RedisClient pexpire(String key,
                           long millis,
                           Handler<AsyncResult<Long>> handler)

Set a key's time to live in milliseconds

Parameters:: key - String key; millis - Time to live in milliseconds; handler - Handler for the result of this call.
Returns:

rxPexpire
```
public Single<Long> rxPexpire(String key,
                              long millis)
```
Set a key's time to live in milliseconds

Parameters:

key - String key

millis - Time to live in milliseconds

Returns:

pexpireat
```
public RedisClient pexpireat(String key,
                             long millis,
                             Handler<AsyncResult<Long>> handler)
```
Set the expiration for a key as a UNIX timestamp specified in milliseconds

Parameters:

key - Key string

millis - Expiry time as Unix timestamp in milliseconds

handler - Handler for the result of this call.

Returns:

rxPexpireat
```
public Single<Long> rxPexpireat(String key,
                                long millis)
```
Set the expiration for a key as a UNIX timestamp specified in milliseconds

Parameters:

key - Key string

millis - Expiry time as Unix timestamp in milliseconds

Returns:

pfadd

public RedisClient pfadd(String key,
                         String element,
                         Handler<AsyncResult<Long>> handler)

Adds the specified element to the specified HyperLogLog.

Parameters:: key - Key string; element - Element to add; handler - Handler for the result of this call.
Returns:

rxPfadd

public Single<Long> rxPfadd(String key,
                            String element)

Adds the specified element to the specified HyperLogLog.

Parameters:: key - Key string; element - Element to add
Returns:

pfaddMany

public RedisClient pfaddMany(String key,
                             List<String> elements,
                             Handler<AsyncResult<Long>> handler)

Adds the specified elements to the specified HyperLogLog.

Parameters:: key - Key string; elements - Elementa to add; handler - Handler for the result of this call.
Returns:

rxPfaddMany

public Single<Long> rxPfaddMany(String key,
                                List<String> elements)

Adds the specified elements to the specified HyperLogLog.

Parameters:: key - Key string; elements - Elementa to add
Returns:

pfcount
```
public RedisClient pfcount(String key,
                           Handler<AsyncResult<Long>> handler)
```
Return the approximated cardinality of the set observed by the HyperLogLog at key.

Parameters:

key - Key string

handler - Handler for the result of this call.

Returns:

rxPfcount
```
public Single<Long> rxPfcount(String key)
```
Return the approximated cardinality of the set observed by the HyperLogLog at key.

Parameters:

key - Key string

Returns:

pfcountMany
```
public RedisClient pfcountMany(List<String> keys,
                               Handler<AsyncResult<Long>> handler)
```
Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).

Parameters:

keys - List of keys

handler - Handler for the result of this call.

Returns:

rxPfcountMany
```
public Single<Long> rxPfcountMany(List<String> keys)
```
Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).

Parameters:

keys - List of keys

Returns:

pfmerge

public RedisClient pfmerge(String destkey,
                           List<String> keys,
                           Handler<AsyncResult<String>> handler)

Merge N different HyperLogLogs into a single one.

Parameters:: destkey - Destination key; keys - List of source keys; handler - Handler for the result of this call.
Returns:

rxPfmerge

public Single<String> rxPfmerge(String destkey,
                                List<String> keys)

Merge N different HyperLogLogs into a single one.

Parameters:: destkey - Destination key; keys - List of source keys
Returns:

ping

public RedisClient ping(Handler<AsyncResult<String>> handler)

Ping the server

Parameters:: handler -
Returns:

rxPing
```
public Single<String> rxPing()
```
Ping the server

Returns:

psetex

public RedisClient psetex(String key,
                          long millis,
                          String value,
                          Handler<AsyncResult<Void>> handler)

Set the value and expiration in milliseconds of a key

Parameters:: key - Key string; millis - Number of milliseconds until the key expires; value - New value for key; handler - Handler for the result of this call.
Returns:

rxPsetex
```
public Completable rxPsetex(String key,
                            long millis,
                            String value)
```
Set the value and expiration in milliseconds of a key

Parameters:

key - Key string

millis - Number of milliseconds until the key expires

value - New value for key

Returns:

psubscribe
```
public RedisClient psubscribe(String pattern,
                              Handler<AsyncResult<JsonArray>> handler)
```
Listen for messages published to channels matching the given pattern

Parameters:

pattern - Pattern string

handler - Handler for the result of this call.

Returns:

rxPsubscribe
```
public Single<JsonArray> rxPsubscribe(String pattern)
```
Listen for messages published to channels matching the given pattern

Parameters:

pattern - Pattern string

Returns:

psubscribeMany

public RedisClient psubscribeMany(List<String> patterns,
                                  Handler<AsyncResult<JsonArray>> handler)

Listen for messages published to channels matching the given patterns

Parameters:: patterns - List of patterns; handler - Handler for the result of this call.
Returns:

rxPsubscribeMany
```
public Single<JsonArray> rxPsubscribeMany(List<String> patterns)
```
Listen for messages published to channels matching the given patterns

Parameters:

patterns - List of patterns

Returns:

pubsubChannels
```
public RedisClient pubsubChannels(String pattern,
                                  Handler<AsyncResult<JsonArray>> handler)
```
Lists the currently active channels - only those matching the pattern

Parameters:

pattern - A glob-style pattern - an empty string means no pattern

handler - Handler for the result of this call.

Returns:

rxPubsubChannels
```
public Single<JsonArray> rxPubsubChannels(String pattern)
```
Lists the currently active channels - only those matching the pattern

Parameters:

pattern - A glob-style pattern - an empty string means no pattern

Returns:

pubsubNumsub
```
public RedisClient pubsubNumsub(List<String> channels,
                                Handler<AsyncResult<JsonArray>> handler)
```
Returns the number of subscribers (not counting clients subscribed to patterns) for the specified channels

Parameters:

channels - List of channels

handler - Handler for the result of this call.

Returns:

rxPubsubNumsub
```
public Single<JsonArray> rxPubsubNumsub(List<String> channels)
```
Returns the number of subscribers (not counting clients subscribed to patterns) for the specified channels

Parameters:

channels - List of channels

Returns:

pubsubNumpat
```
public RedisClient pubsubNumpat(Handler<AsyncResult<Long>> handler)
```
Returns the number of subscriptions to patterns (that are performed using the PSUBSCRIBE command)

Parameters:

handler - Handler for the result of this call.

Returns:

rxPubsubNumpat
```
public Single<Long> rxPubsubNumpat()
```
Returns the number of subscriptions to patterns (that are performed using the PSUBSCRIBE command)

Returns:

pttl

public RedisClient pttl(String key,
                        Handler<AsyncResult<Long>> handler)

Get the time to live for a key in milliseconds

Parameters:: key - Key string; handler - Handler for the result of this call.
Returns:

rxPttl
```
public Single<Long> rxPttl(String key)
```
Get the time to live for a key in milliseconds

Parameters:

key - Key string

Returns:

publish

public RedisClient publish(String channel,
                           String message,
                           Handler<AsyncResult<Long>> handler)

Post a message to a channel

Parameters:: channel - Channel key; message - Message to send to channel; handler - Handler for the result of this call.
Returns:

rxPublish

public Single<Long> rxPublish(String channel,
                              String message)

Post a message to a channel

Parameters:: channel - Channel key; message - Message to send to channel
Returns:

punsubscribe
```
public RedisClient punsubscribe(List<String> patterns,
                                Handler<AsyncResult<Void>> handler)
```
Stop listening for messages posted to channels matching the given patterns

Parameters:

patterns - List of patterns to match against

handler - Handler for the result of this call.

Returns:

rxPunsubscribe
```
public Completable rxPunsubscribe(List<String> patterns)
```
Stop listening for messages posted to channels matching the given patterns

Parameters:

patterns - List of patterns to match against

Returns:

randomkey

public RedisClient randomkey(Handler<AsyncResult<String>> handler)

Return a random key from the keyspace

Parameters:: handler -
Returns:

rxRandomkey
```
public Single<String> rxRandomkey()
```
Return a random key from the keyspace

Returns:

rename

public RedisClient rename(String key,
                          String newkey,
                          Handler<AsyncResult<String>> handler)

Rename a key

Parameters:: key - Key string to be renamed; newkey - New key string; handler - Handler for the result of this call.
Returns:

rxRename

public Single<String> rxRename(String key,
                               String newkey)

Rename a key

Parameters:: key - Key string to be renamed; newkey - New key string
Returns:

renamenx

public RedisClient renamenx(String key,
                            String newkey,
                            Handler<AsyncResult<Long>> handler)

Rename a key, only if the new key does not exist

Parameters:: key - Key string to be renamed; newkey - New key string; handler - Handler for the result of this call.
Returns:

rxRenamenx

public Single<Long> rxRenamenx(String key,
                               String newkey)

Rename a key, only if the new key does not exist

Parameters:: key - Key string to be renamed; newkey - New key string
Returns:

restore
```
public RedisClient restore(String key,
                           long millis,
                           String serialized,
                           Handler<AsyncResult<String>> handler)
```
Create a key using the provided serialized value, previously obtained using DUMP.

Parameters:

key - Key string

millis - Expiry time in milliseconds to set on the key

serialized - Serialized form of the key value as obtained using DUMP

handler - Handler for the result of this call.

Returns:

rxRestore
```
public Single<String> rxRestore(String key,
                                long millis,
                                String serialized)
```
Create a key using the provided serialized value, previously obtained using DUMP.

Parameters:

key - Key string

millis - Expiry time in milliseconds to set on the key

serialized - Serialized form of the key value as obtained using DUMP

Returns:

role
```
public RedisClient role(Handler<AsyncResult<JsonArray>> handler)
```
Return the role of the instance in the context of replication

Parameters:

handler -

Returns:

rxRole
```
public Single<JsonArray> rxRole()
```
Return the role of the instance in the context of replication

Returns:

rpop

public RedisClient rpop(String key,
                        Handler<AsyncResult<String>> handler)

Remove and get the last element in a list

Parameters:: key - Key string; handler - Handler for the result of this call.
Returns:

rxRpop
```
public Single<String> rxRpop(String key)
```
Remove and get the last element in a list

Parameters:

key - Key string

Returns:

rpoplpush
```
public RedisClient rpoplpush(String key,
                             String destkey,
                             Handler<AsyncResult<String>> handler)
```
Remove the last element in a list, append it to another list and return it

Parameters:

key - Key string identifying source list

destkey - Key string identifying destination list

handler - Handler for the result of this call.

Returns:

rxRpoplpush
```
public Single<String> rxRpoplpush(String key,
                                  String destkey)
```
Remove the last element in a list, append it to another list and return it

Parameters:

key - Key string identifying source list

destkey - Key string identifying destination list

Returns:

rpushMany

public RedisClient rpushMany(String key,
                             List<String> values,
                             Handler<AsyncResult<Long>> handler)

Append one or multiple values to a list

Parameters:: key - Key string; values - List of values to add to the end of the list; handler - Handler for the result of this call.
Returns:

rxRpushMany

public Single<Long> rxRpushMany(String key,
                                List<String> values)

Append one or multiple values to a list

Parameters:: key - Key string; values - List of values to add to the end of the list
Returns:

rpush

public RedisClient rpush(String key,
                         String value,
                         Handler<AsyncResult<Long>> handler)

Append one or multiple values to a list

Parameters:: key - Key string; value - Value to be added to the end of the list; handler - Handler for the result of this call.
Returns:

rxRpush
```
public Single<Long> rxRpush(String key,
                            String value)
```
Append one or multiple values to a list

Parameters:

key - Key string

value - Value to be added to the end of the list

Returns:

rpushx

public RedisClient rpushx(String key,
                          String value,
                          Handler<AsyncResult<Long>> handler)

Append a value to a list, only if the list exists

Parameters:: key - Key string; value - Value to be added to the end of the list; handler - Handler for the result of this call.
Returns:

rxRpushx
```
public Single<Long> rxRpushx(String key,
                             String value)
```
Append a value to a list, only if the list exists

Parameters:

key - Key string

value - Value to be added to the end of the list

Returns:

sadd

public RedisClient sadd(String key,
                        String member,
                        Handler<AsyncResult<Long>> handler)

Add a member to a set

Parameters:: key - Key string; member - Value to be added to the set; handler - Handler for the result of this call.
Returns:

rxSadd

public Single<Long> rxSadd(String key,
                           String member)

Add a member to a set

Parameters:: key - Key string; member - Value to be added to the set
Returns:

saddMany

public RedisClient saddMany(String key,
                            List<String> members,
                            Handler<AsyncResult<Long>> handler)

Add one or more members to a set

Parameters:: key - Key string; members - Values to be added to the set; handler - Handler for the result of this call.
Returns:

rxSaddMany

public Single<Long> rxSaddMany(String key,
                               List<String> members)

Add one or more members to a set

Parameters:: key - Key string; members - Values to be added to the set
Returns:

save
```
public RedisClient save(Handler<AsyncResult<String>> handler)
```
Synchronously save the dataset to disk

Parameters:

handler -

Returns:

rxSave
```
public Single<String> rxSave()
```
Synchronously save the dataset to disk

Returns:

scard

public RedisClient scard(String key,
                         Handler<AsyncResult<Long>> handler)

Get the number of members in a set

Parameters:: key - Key string; handler - Handler for the result of this call.
Returns:

rxScard
```
public Single<Long> rxScard(String key)
```
Get the number of members in a set

Parameters:

key - Key string

Returns:

scriptExists
```
public RedisClient scriptExists(String script,
                                Handler<AsyncResult<JsonArray>> handler)
```
Check existence of script in the script cache.

Parameters:

script - SHA1 digest identifying a script in the script cache

handler - Handler for the result of this call.

Returns:

rxScriptExists
```
public Single<JsonArray> rxScriptExists(String script)
```
Check existence of script in the script cache.

Parameters:

script - SHA1 digest identifying a script in the script cache

Returns:

scriptExistsMany
```
public RedisClient scriptExistsMany(List<String> scripts,
                                    Handler<AsyncResult<JsonArray>> handler)
```
Check existence of scripts in the script cache.

Parameters:

scripts - List of SHA1 digests identifying scripts in the script cache

handler - Handler for the result of this call.

Returns:

rxScriptExistsMany
```
public Single<JsonArray> rxScriptExistsMany(List<String> scripts)
```
Check existence of scripts in the script cache.

Parameters:

scripts - List of SHA1 digests identifying scripts in the script cache

Returns:

scriptFlush
```
public RedisClient scriptFlush(Handler<AsyncResult<String>> handler)
```
Remove all the scripts from the script cache.

Parameters:

handler -

Returns:

rxScriptFlush
```
public Single<String> rxScriptFlush()
```
Remove all the scripts from the script cache.

Returns:

scriptKill
```
public RedisClient scriptKill(Handler<AsyncResult<String>> handler)
```
Kill the script currently in execution.

Parameters:

handler -

Returns:

rxScriptKill
```
public Single<String> rxScriptKill()
```
Kill the script currently in execution.

Returns:

scriptLoad

public RedisClient scriptLoad(String script,
                              Handler<AsyncResult<String>> handler)

Load the specified Lua script into the script cache.

Parameters:: script - Lua script; handler - Handler for the result of this call.
Returns:

rxScriptLoad
```
public Single<String> rxScriptLoad(String script)
```
Load the specified Lua script into the script cache.

Parameters:

script - Lua script

Returns:

sdiff
```
public RedisClient sdiff(String key,
                         List<String> cmpkeys,
                         Handler<AsyncResult<JsonArray>> handler)
```
Subtract multiple sets

Parameters:

key - Key identifying the set to compare with all other sets combined

cmpkeys - List of keys identifying sets to subtract from the key set

handler - Handler for the result of this call.

Returns:

rxSdiff
```
public Single<JsonArray> rxSdiff(String key,
                                 List<String> cmpkeys)
```
Subtract multiple sets

Parameters:

key - Key identifying the set to compare with all other sets combined

cmpkeys - List of keys identifying sets to subtract from the key set

Returns:

sdiffstore
```
public RedisClient sdiffstore(String destkey,
                              String key,
                              List<String> cmpkeys,
                              Handler<AsyncResult<Long>> handler)
```
Subtract multiple sets and store the resulting set in a key

Parameters:

destkey - Destination key where the result should be stored

key - Key identifying the set to compare with all other sets combined

cmpkeys - List of keys identifying sets to subtract from the key set

handler - Handler for the result of this call.

Returns:

rxSdiffstore
```
public Single<Long> rxSdiffstore(String destkey,
                                 String key,
                                 List<String> cmpkeys)
```
Subtract multiple sets and store the resulting set in a key

Parameters:

destkey - Destination key where the result should be stored

key - Key identifying the set to compare with all other sets combined

cmpkeys - List of keys identifying sets to subtract from the key set

Returns:

select
```
public RedisClient select(int dbindex,
                          Handler<AsyncResult<String>> handler)
```
Change the selected database for the current connection

Parameters:

dbindex - Index identifying the new active database

handler - Handler for the result of this call.

Returns:

rxSelect
```
public Single<String> rxSelect(int dbindex)
```
Change the selected database for the current connection

Parameters:

dbindex - Index identifying the new active database

Returns:

set

public RedisClient set(String key,
                       String value,
                       Handler<AsyncResult<Void>> handler)

Set the string value of a key

Parameters:: key - Key of which value to set; value - New value for the key; handler - Handler for the result of this call.
Returns:

rxSet

public Completable rxSet(String key,
                         String value)

Set the string value of a key

Parameters:: key - Key of which value to set; value - New value for the key
Returns:

setWithOptions

public RedisClient setWithOptions(String key,
                                  String value,
                                  SetOptions options,
                                  Handler<AsyncResult<String>> handler)

Set the string value of a key

Parameters:: key - Key of which value to set; value - New value for the key; options - Set options; handler - Handler for the result of this call.
Returns:

rxSetWithOptions

public Single<String> rxSetWithOptions(String key,
                                       String value,
                                       SetOptions options)

Set the string value of a key

Parameters:: key - Key of which value to set; value - New value for the key; options - Set options
Returns:

setBinary

public RedisClient setBinary(String key,
                             Buffer value,
                             Handler<AsyncResult<Void>> handler)

Set the binary string value of a key - without encoding as utf-8

Parameters:: key - Key of which value to set; value - New value for the key; handler - Handler for the result of this call.
Returns:

rxSetBinary
```
public Completable rxSetBinary(String key,
                               Buffer value)
```
Set the binary string value of a key - without encoding as utf-8

Parameters:

key - Key of which value to set

value - New value for the key

Returns:

setBinaryWithOptions

public RedisClient setBinaryWithOptions(String key,
                                        Buffer value,
                                        SetOptions options,
                                        Handler<AsyncResult<Void>> handler)

Set the string value of a key

Parameters:: key - Key of which value to set; value - New value for the key; options - Set options; handler - Handler for the result of this call.
Returns:

rxSetBinaryWithOptions

public Completable rxSetBinaryWithOptions(String key,
                                          Buffer value,
                                          SetOptions options)

Set the string value of a key

Parameters:: key - Key of which value to set; value - New value for the key; options - Set options
Returns:

setbit

public RedisClient setbit(String key,
                          long offset,
                          int bit,
                          Handler<AsyncResult<Long>> handler)

Sets or clears the bit at offset in the string value stored at key

Parameters:: key - Key string; offset - Bit offset; bit - New value - must be 1 or 0; handler - Handler for the result of this call.
Returns:

rxSetbit
```
public Single<Long> rxSetbit(String key,
                             long offset,
                             int bit)
```
Sets or clears the bit at offset in the string value stored at key

Parameters:

key - Key string

offset - Bit offset

bit - New value - must be 1 or 0

Returns:

setex

public RedisClient setex(String key,
                         long seconds,
                         String value,
                         Handler<AsyncResult<String>> handler)

Set the value and expiration of a key

Parameters:: key - Key string; seconds - Number of seconds until the key expires; value - New value for key; handler - Handler for the result of this call.
Returns:

rxSetex

public Single<String> rxSetex(String key,
                              long seconds,
                              String value)

Set the value and expiration of a key

Parameters:: key - Key string; seconds - Number of seconds until the key expires; value - New value for key
Returns:

setnx

public RedisClient setnx(String key,
                         String value,
                         Handler<AsyncResult<Long>> handler)

Set the value of a key, only if the key does not exist

Parameters:: key - Key of which value to set; value - New value for the key; handler - Handler for the result of this call.
Returns:

rxSetnx
```
public Single<Long> rxSetnx(String key,
                            String value)
```
Set the value of a key, only if the key does not exist

Parameters:

key - Key of which value to set

value - New value for the key

Returns:

setrange
```
public RedisClient setrange(String key,
                            int offset,
                            String value,
                            Handler<AsyncResult<Long>> handler)
```
Overwrite part of a string at key starting at the specified offset

Parameters:

key - Key string

offset - Offset - the maximum offset that you can set is 2^29 -1 (536870911), as Redis Strings are limited to 512 megabytes

value - Value to overwrite with

handler - Handler for the result of this call.

Returns:

rxSetrange
```
public Single<Long> rxSetrange(String key,
                               int offset,
                               String value)
```
Overwrite part of a string at key starting at the specified offset

Parameters:

key - Key string

offset - Offset - the maximum offset that you can set is 2^29 -1 (536870911), as Redis Strings are limited to 512 megabytes

value - Value to overwrite with

Returns:

sinter

public RedisClient sinter(List<String> keys,
                          Handler<AsyncResult<JsonArray>> handler)

Intersect multiple sets

Parameters:: keys - List of keys to perform intersection on; handler - Handler for the result of this call.
Returns:

rxSinter
```
public Single<JsonArray> rxSinter(List<String> keys)
```
Intersect multiple sets

Parameters:

keys - List of keys to perform intersection on

Returns:

sinterstore

public RedisClient sinterstore(String destkey,
                               List<String> keys,
                               Handler<AsyncResult<Long>> handler)

Intersect multiple sets and store the resulting set in a key

Parameters:: destkey - Key where to store the results; keys - List of keys to perform intersection on; handler - Handler for the result of this call.
Returns:

rxSinterstore
```
public Single<Long> rxSinterstore(String destkey,
                                  List<String> keys)
```
Intersect multiple sets and store the resulting set in a key

Parameters:

destkey - Key where to store the results

keys - List of keys to perform intersection on

Returns:

sismember

public RedisClient sismember(String key,
                             String member,
                             Handler<AsyncResult<Long>> handler)

Determine if a given value is a member of a set

Parameters:: key - Key string; member - Member to look for; handler - Handler for the result of this call.
Returns:

rxSismember

public Single<Long> rxSismember(String key,
                                String member)

Determine if a given value is a member of a set

Parameters:: key - Key string; member - Member to look for
Returns:

slaveof
```
public RedisClient slaveof(String host,
                           int port,
                           Handler<AsyncResult<String>> handler)
```
Make the server a slave of another instance

Parameters:

host - Host to become this server's master

port - Port of our new master

handler - Handler for the result of this call.

Returns:

rxSlaveof
```
public Single<String> rxSlaveof(String host,
                                int port)
```
Make the server a slave of another instance

Parameters:

host - Host to become this server's master

port - Port of our new master

Returns:

slaveofNoone
```
public RedisClient slaveofNoone(Handler<AsyncResult<String>> handler)
```
Make this server a master

Parameters:

handler - Handler for the result of this call.

Returns:

rxSlaveofNoone
```
public Single<String> rxSlaveofNoone()
```
Make this server a master

Returns:

slowlogGet
```
public RedisClient slowlogGet(int limit,
                              Handler<AsyncResult<JsonArray>> handler)
```
Read the Redis slow queries log

Parameters:

limit - Number of log entries to return. If value is less than zero all entries are returned

handler - Handler for the result of this call.

Returns:

rxSlowlogGet
```
public Single<JsonArray> rxSlowlogGet(int limit)
```
Read the Redis slow queries log

Parameters:

limit - Number of log entries to return. If value is less than zero all entries are returned

Returns:

slowlogLen
```
public RedisClient slowlogLen(Handler<AsyncResult<Long>> handler)
```
Get the length of the Redis slow queries log

Parameters:

handler - Handler for the result of this call.

Returns:

rxSlowlogLen
```
public Single<Long> rxSlowlogLen()
```
Get the length of the Redis slow queries log

Returns:

slowlogReset
```
public RedisClient slowlogReset(Handler<AsyncResult<Void>> handler)
```
Reset the Redis slow queries log

Parameters:

handler - Handler for the result of this call.

Returns:

rxSlowlogReset
```
public Completable rxSlowlogReset()
```
Reset the Redis slow queries log

Returns:

smembers

public RedisClient smembers(String key,
                            Handler<AsyncResult<JsonArray>> handler)

Get all the members in a set

Parameters:: key - Key string; handler - Handler for the result of this call.
Returns:

rxSmembers
```
public Single<JsonArray> rxSmembers(String key)
```
Get all the members in a set

Parameters:

key - Key string

Returns:

smove

public RedisClient smove(String key,
                         String destkey,
                         String member,
                         Handler<AsyncResult<Long>> handler)

Move a member from one set to another

Parameters:: key - Key of source set currently containing the member; destkey - Key identifying the destination set; member - Member to move; handler - Handler for the result of this call.
Returns:

rxSmove

public Single<Long> rxSmove(String key,
                            String destkey,
                            String member)

Move a member from one set to another

Parameters:: key - Key of source set currently containing the member; destkey - Key identifying the destination set; member - Member to move
Returns:

sort

public RedisClient sort(String key,
                        SortOptions options,
                        Handler<AsyncResult<JsonArray>> handler)

Sort the elements in a list, set or sorted set

Parameters:: key - Key string; options - Sort options; handler - Handler for the result of this call.
Returns:

rxSort

public Single<JsonArray> rxSort(String key,
                                SortOptions options)

Sort the elements in a list, set or sorted set

Parameters:: key - Key string; options - Sort options
Returns:

spop

public RedisClient spop(String key,
                        Handler<AsyncResult<String>> handler)

Remove and return a random member from a set

Parameters:: key - Key string; handler - Handler for the result of this call.
Returns:

rxSpop
```
public Maybe<String> rxSpop(String key)
```
Remove and return a random member from a set

Parameters:

key - Key string

Returns:

spopMany

public RedisClient spopMany(String key,
                            int count,
                            Handler<AsyncResult<JsonArray>> handler)

Remove and return random members from a set

Parameters:: key - Key string; count - Number of members to remove; handler - Handler for the result of this call.
Returns:

rxSpopMany
```
public Single<JsonArray> rxSpopMany(String key,
                                    int count)
```
Remove and return random members from a set

Parameters:

key - Key string

count - Number of members to remove

Returns:

srandmember

public RedisClient srandmember(String key,
                               Handler<AsyncResult<String>> handler)

Get one or multiple random members from a set

Parameters:: key - Key string; handler - Handler for the result of this call.
Returns:

rxSrandmember
```
public Single<String> rxSrandmember(String key)
```
Get one or multiple random members from a set

Parameters:

key - Key string

Returns:

srandmemberCount

public RedisClient srandmemberCount(String key,
                                    int count,
                                    Handler<AsyncResult<JsonArray>> handler)

Get one or multiple random members from a set

Parameters:: key - Key string; count - Number of members to get; handler - Handler for the result of this call.
Returns:

rxSrandmemberCount
```
public Single<JsonArray> rxSrandmemberCount(String key,
                                            int count)
```
Get one or multiple random members from a set

Parameters:

key - Key string

count - Number of members to get

Returns:

srem

public RedisClient srem(String key,
                        String member,
                        Handler<AsyncResult<Long>> handler)

Remove one member from a set

Parameters:: key - Key string; member - Member to remove; handler - Handler for the result of this call.
Returns:

rxSrem

public Single<Long> rxSrem(String key,
                           String member)

Remove one member from a set

Parameters:: key - Key string; member - Member to remove
Returns:

sremMany

public RedisClient sremMany(String key,
                            List<String> members,
                            Handler<AsyncResult<Long>> handler)

Remove one or more members from a set

Parameters:: key - Key string; members - Members to remove; handler - Handler for the result of this call.
Returns:

rxSremMany

public Single<Long> rxSremMany(String key,
                               List<String> members)

Remove one or more members from a set

Parameters:: key - Key string; members - Members to remove
Returns:

strlen

public RedisClient strlen(String key,
                          Handler<AsyncResult<Long>> handler)

Get the length of the value stored in a key

Parameters:: key - Key string; handler - Handler for the result of this call.
Returns:

rxStrlen
```
public Single<Long> rxStrlen(String key)
```
Get the length of the value stored in a key

Parameters:

key - Key string

Returns:

subscribe
```
public RedisClient subscribe(String channel,
                             Handler<AsyncResult<JsonArray>> handler)
```
Listen for messages published to the given channels

Parameters:

channel - Channel to subscribe to

handler - Handler for the result of this call.

Returns:

rxSubscribe
```
public Single<JsonArray> rxSubscribe(String channel)
```
Listen for messages published to the given channels

Parameters:

channel - Channel to subscribe to

Returns:

subscribeMany

public RedisClient subscribeMany(List<String> channels,
                                 Handler<AsyncResult<JsonArray>> handler)

Listen for messages published to the given channels

Parameters:: channels - List of channels to subscribe to; handler - Handler for the result of this call.
Returns:

rxSubscribeMany
```
public Single<JsonArray> rxSubscribeMany(List<String> channels)
```
Listen for messages published to the given channels

Parameters:

channels - List of channels to subscribe to

Returns:

sunion

public RedisClient sunion(List<String> keys,
                          Handler<AsyncResult<JsonArray>> handler)

Add multiple sets

Parameters:: keys - List of keys identifying sets to add up; handler - Handler for the result of this call.
Returns:

rxSunion
```
public Single<JsonArray> rxSunion(List<String> keys)
```
Add multiple sets

Parameters:

keys - List of keys identifying sets to add up

Returns:

sunionstore

public RedisClient sunionstore(String destkey,
                               List<String> keys,
                               Handler<AsyncResult<Long>> handler)

Add multiple sets and store the resulting set in a key

Parameters:: destkey - Destination key; keys - List of keys identifying sets to add up; handler - Handler for the result of this call.
Returns:

rxSunionstore
```
public Single<Long> rxSunionstore(String destkey,
                                  List<String> keys)
```
Add multiple sets and store the resulting set in a key

Parameters:

destkey - Destination key

keys - List of keys identifying sets to add up

Returns:

sync
```
public RedisClient sync(Handler<AsyncResult<Void>> handler)
```
Internal command used for replication

Parameters:

handler -

Returns:

rxSync
```
public Completable rxSync()
```
Internal command used for replication

Returns:

time

public RedisClient time(Handler<AsyncResult<JsonArray>> handler)

Return the current server time

Parameters:: handler -
Returns:

rxTime
```
public Single<JsonArray> rxTime()
```
Return the current server time

Returns:

transaction
```
public RedisTransaction transaction()
```
Return a RedisTransaction instance

Returns:

transaction instance

ttl

public RedisClient ttl(String key,
                       Handler<AsyncResult<Long>> handler)

Get the time to live for a key

Parameters:: key - Key string; handler - Handler for the result of this call.
Returns:

rxTtl
```
public Single<Long> rxTtl(String key)
```
Get the time to live for a key

Parameters:

key - Key string

Returns:

type

public RedisClient type(String key,
                        Handler<AsyncResult<String>> handler)

Determine the type stored at key

Parameters:: key - Key string; handler - Handler for the result of this call.
Returns:

rxType
```
public Single<String> rxType(String key)
```
Determine the type stored at key

Parameters:

key - Key string

Returns:

unsubscribe
```
public RedisClient unsubscribe(List<String> channels,
                               Handler<AsyncResult<Void>> handler)
```
Stop listening for messages posted to the given channels

Parameters:

channels - List of channels to subscribe to

handler - Handler for the result of this call.

Returns:

rxUnsubscribe
```
public Completable rxUnsubscribe(List<String> channels)
```
Stop listening for messages posted to the given channels

Parameters:

channels - List of channels to subscribe to

Returns:

wait
```
public RedisClient wait(long numSlaves,
                        long timeout,
                        Handler<AsyncResult<String>> handler)
```
Wait for the synchronous replication of all the write commands sent in the context of the current connection.

Parameters:

numSlaves -

timeout -

handler - Handler for the result of this call.

Returns:

rxWait
```
public Single<String> rxWait(long numSlaves,
                             long timeout)
```
Wait for the synchronous replication of all the write commands sent in the context of the current connection.

Parameters:

numSlaves -

timeout -

Returns:

zadd

public RedisClient zadd(String key,
                        double score,
                        String member,
                        Handler<AsyncResult<Long>> handler)

Add one or more members to a sorted set, or update its score if it already exists

Parameters:: key - Key string; score - Score used for sorting; member - New member key; handler - Handler for the result of this call.
Returns:

rxZadd
```
public Single<Long> rxZadd(String key,
                           double score,
                           String member)
```
Add one or more members to a sorted set, or update its score if it already exists

Parameters:

key - Key string

score - Score used for sorting

member - New member key

Returns:

zaddMany

public RedisClient zaddMany(String key,
                            Map<String,Double> members,
                            Handler<AsyncResult<Long>> handler)

Add one or more members to a sorted set, or update its score if it already exists

Parameters:: key - Key string; members - New member keys and their scores; handler - Handler for the result of this call.
Returns:

rxZaddMany
```
public Single<Long> rxZaddMany(String key,
                               Map<String,Double> members)
```
Add one or more members to a sorted set, or update its score if it already exists

Parameters:

key - Key string

members - New member keys and their scores

Returns:

zcard

public RedisClient zcard(String key,
                         Handler<AsyncResult<Long>> handler)

Get the number of members in a sorted set

Parameters:: key - Key string; handler - Handler for the result of this call.
Returns:

rxZcard
```
public Single<Long> rxZcard(String key)
```
Get the number of members in a sorted set

Parameters:

key - Key string

Returns:

zcount

public RedisClient zcount(String key,
                          double min,
                          double max,
                          Handler<AsyncResult<Long>> handler)

Count the members in a sorted set with scores within the given values

Parameters:: key - Key string; min - Minimum score; max - Maximum score; handler - Handler for the result of this call.
Returns:

rxZcount
```
public Single<Long> rxZcount(String key,
                             double min,
                             double max)
```
Count the members in a sorted set with scores within the given values

Parameters:

key - Key string

min - Minimum score

max - Maximum score

Returns:

zincrby

public RedisClient zincrby(String key,
                           double increment,
                           String member,
                           Handler<AsyncResult<String>> handler)

Increment the score of a member in a sorted set

Parameters:: key - Key string; increment - Increment amount; member - Member key; handler - Handler for the result of this call.
Returns:

rxZincrby

public Single<String> rxZincrby(String key,
                                double increment,
                                String member)

Increment the score of a member in a sorted set

Parameters:: key - Key string; increment - Increment amount; member - Member key
Returns:

zinterstore

public RedisClient zinterstore(String destkey,
                               List<String> sets,
                               AggregateOptions options,
                               Handler<AsyncResult<Long>> handler)

Intersect multiple sorted sets and store the resulting sorted set in a new key

Parameters:: destkey - Destination key; sets - List of keys identifying sorted sets to intersect; options - Aggregation options; handler - Handler for the result of this call.
Returns:

rxZinterstore

public Single<Long> rxZinterstore(String destkey,
                                  List<String> sets,
                                  AggregateOptions options)

Intersect multiple sorted sets and store the resulting sorted set in a new key

Parameters:: destkey - Destination key; sets - List of keys identifying sorted sets to intersect; options - Aggregation options
Returns:

zinterstoreWeighed

public RedisClient zinterstoreWeighed(String destkey,
                                      Map<String,Double> sets,
                                      AggregateOptions options,
                                      Handler<AsyncResult<Long>> handler)

Intersect multiple sorted sets and store the resulting sorted set in a new key using weights for scoring

Parameters:: destkey - Destination key; sets - List of keys identifying sorted sets to intersect; options - Aggregation options; handler - Handler for the result of this call.
Returns:

rxZinterstoreWeighed

public Single<Long> rxZinterstoreWeighed(String destkey,
                                         Map<String,Double> sets,
                                         AggregateOptions options)

Intersect multiple sorted sets and store the resulting sorted set in a new key using weights for scoring

Parameters:: destkey - Destination key; sets - List of keys identifying sorted sets to intersect; options - Aggregation options
Returns:

zlexcount

public RedisClient zlexcount(String key,
                             String min,
                             String max,
                             Handler<AsyncResult<Long>> handler)

Count the number of members in a sorted set between a given lexicographical range

Parameters:: key - Key string; min - Pattern to compare against for minimum value; max - Pattern to compare against for maximum value; handler - Handler for the result of this call.
Returns:

rxZlexcount
```
public Single<Long> rxZlexcount(String key,
                                String min,
                                String max)
```
Count the number of members in a sorted set between a given lexicographical range

Parameters:

key - Key string

min - Pattern to compare against for minimum value

max - Pattern to compare against for maximum value

Returns:

zrange

public RedisClient zrange(String key,
                          long start,
                          long stop,
                          Handler<AsyncResult<JsonArray>> handler)

Return a range of members in a sorted set, by index

Parameters:: key - Key string; start - Start index for the range; stop - Stop index for the range - inclusive; handler - Handler for the result of this call.
Returns:

rxZrange
```
public Single<JsonArray> rxZrange(String key,
                                  long start,
                                  long stop)
```
Return a range of members in a sorted set, by index

Parameters:

key - Key string

start - Start index for the range

stop - Stop index for the range - inclusive

Returns:

zrangeWithOptions

public RedisClient zrangeWithOptions(String key,
                                     long start,
                                     long stop,
                                     RangeOptions options,
                                     Handler<AsyncResult<JsonArray>> handler)

Return a range of members in a sorted set, by index

Parameters:: key - Key string; start - Start index for the range; stop - Stop index for the range - inclusive; options - Range options; handler - Handler for the result of this call.
Returns:

rxZrangeWithOptions

public Single<JsonArray> rxZrangeWithOptions(String key,
                                             long start,
                                             long stop,
                                             RangeOptions options)

Return a range of members in a sorted set, by index

Parameters:: key - Key string; start - Start index for the range; stop - Stop index for the range - inclusive; options - Range options
Returns:

zrangebylex

public RedisClient zrangebylex(String key,
                               String min,
                               String max,
                               LimitOptions options,
                               Handler<AsyncResult<JsonArray>> handler)

Return a range of members in a sorted set, by lexicographical range

Parameters:: key - Key string; min - Pattern representing a minimum allowed value; max - Pattern representing a maximum allowed value; options - Limit options where limit can be specified; handler - Handler for the result of this call.
Returns:

rxZrangebylex

public Single<JsonArray> rxZrangebylex(String key,
                                       String min,
                                       String max,
                                       LimitOptions options)

Return a range of members in a sorted set, by lexicographical range

Parameters:: key - Key string; min - Pattern representing a minimum allowed value; max - Pattern representing a maximum allowed value; options - Limit options where limit can be specified
Returns:

zrangebyscore

public RedisClient zrangebyscore(String key,
                                 String min,
                                 String max,
                                 RangeLimitOptions options,
                                 Handler<AsyncResult<JsonArray>> handler)

Return a range of members in a sorted set, by score

Parameters:: key - Key string; min - Pattern defining a minimum value; max - Pattern defining a maximum value; options - Range and limit options; handler - Handler for the result of this call.
Returns:

rxZrangebyscore

public Single<JsonArray> rxZrangebyscore(String key,
                                         String min,
                                         String max,
                                         RangeLimitOptions options)

Return a range of members in a sorted set, by score

Parameters:: key - Key string; min - Pattern defining a minimum value; max - Pattern defining a maximum value; options - Range and limit options
Returns:

zrank

public RedisClient zrank(String key,
                         String member,
                         Handler<AsyncResult<Long>> handler)

Determine the index of a member in a sorted set

Parameters:: key - Key string; member - Member in the sorted set identified by key; handler - Handler for the result of this call.
Returns:

rxZrank
```
public Single<Long> rxZrank(String key,
                            String member)
```
Determine the index of a member in a sorted set

Parameters:

key - Key string

member - Member in the sorted set identified by key

Returns:

zrem

public RedisClient zrem(String key,
                        String member,
                        Handler<AsyncResult<Long>> handler)

Remove one member from a sorted set

Parameters:: key - Key string; member - Member in the sorted set identified by key; handler - Handler for the result of this call.
Returns:

rxZrem
```
public Single<Long> rxZrem(String key,
                           String member)
```
Remove one member from a sorted set

Parameters:

key - Key string

member - Member in the sorted set identified by key

Returns:

zremMany

public RedisClient zremMany(String key,
                            List<String> members,
                            Handler<AsyncResult<Long>> handler)

Remove one or more members from a sorted set

Parameters:: key - Key string; members - Members in the sorted set identified by key; handler - Handler for the result of this call.
Returns:

rxZremMany
```
public Single<Long> rxZremMany(String key,
                               List<String> members)
```
Remove one or more members from a sorted set

Parameters:

key - Key string

members - Members in the sorted set identified by key

Returns:

zremrangebylex

public RedisClient zremrangebylex(String key,
                                  String min,
                                  String max,
                                  Handler<AsyncResult<Long>> handler)

Remove all members in a sorted set between the given lexicographical range

Parameters:: key - Key string; min - Pattern defining a minimum value; max - Pattern defining a maximum value; handler - Handler for the result of this call.
Returns:

rxZremrangebylex

public Single<Long> rxZremrangebylex(String key,
                                     String min,
                                     String max)

Remove all members in a sorted set between the given lexicographical range

Parameters:: key - Key string; min - Pattern defining a minimum value; max - Pattern defining a maximum value
Returns:

zremrangebyrank

public RedisClient zremrangebyrank(String key,
                                   long start,
                                   long stop,
                                   Handler<AsyncResult<Long>> handler)

Remove all members in a sorted set within the given indexes

Parameters:: key - Key string; start - Start index; stop - Stop index; handler - Handler for the result of this call.
Returns:

rxZremrangebyrank

public Single<Long> rxZremrangebyrank(String key,
                                      long start,
                                      long stop)

Remove all members in a sorted set within the given indexes

Parameters:: key - Key string; start - Start index; stop - Stop index
Returns:

zremrangebyscore

public RedisClient zremrangebyscore(String key,
                                    String min,
                                    String max,
                                    Handler<AsyncResult<Long>> handler)

Remove all members in a sorted set within the given scores

Parameters:: key - Key string; min - Pattern defining a minimum value; max - Pattern defining a maximum value; handler -
Returns:

rxZremrangebyscore

public Single<Long> rxZremrangebyscore(String key,
                                       String min,
                                       String max)

Remove all members in a sorted set within the given scores

Parameters:: key - Key string; min - Pattern defining a minimum value; max - Pattern defining a maximum value
Returns:

zrevrange

public RedisClient zrevrange(String key,
                             long start,
                             long stop,
                             RangeOptions options,
                             Handler<AsyncResult<JsonArray>> handler)

Return a range of members in a sorted set, by index, with scores ordered from high to low

Parameters:: key - Key string; start - Start index for the range; stop - Stop index for the range - inclusive; options - Range options; handler - Handler for the result of this call.
Returns:

rxZrevrange

public Single<JsonArray> rxZrevrange(String key,
                                     long start,
                                     long stop,
                                     RangeOptions options)

Return a range of members in a sorted set, by index, with scores ordered from high to low

Parameters:: key - Key string; start - Start index for the range; stop - Stop index for the range - inclusive; options - Range options
Returns:

zrevrangebylex

public RedisClient zrevrangebylex(String key,
                                  String max,
                                  String min,
                                  LimitOptions options,
                                  Handler<AsyncResult<JsonArray>> handler)

Return a range of members in a sorted set, by score, between the given lexicographical range with scores ordered from high to low

Parameters:: key - Key string; max - Pattern defining a maximum value; min - Pattern defining a minimum value; options - Limit options; handler - Handler for the result of this call.
Returns:

rxZrevrangebylex

public Single<JsonArray> rxZrevrangebylex(String key,
                                          String max,
                                          String min,
                                          LimitOptions options)

Return a range of members in a sorted set, by score, between the given lexicographical range with scores ordered from high to low

Parameters:: key - Key string; max - Pattern defining a maximum value; min - Pattern defining a minimum value; options - Limit options
Returns:

zrevrangebyscore

public RedisClient zrevrangebyscore(String key,
                                    String max,
                                    String min,
                                    RangeLimitOptions options,
                                    Handler<AsyncResult<JsonArray>> handler)

Return a range of members in a sorted set, by score, with scores ordered from high to low

Parameters:: key - Key string; max - Pattern defining a maximum value; min - Pattern defining a minimum value; options - Range and limit options; handler - Handler for the result of this call.
Returns:

rxZrevrangebyscore

public Single<JsonArray> rxZrevrangebyscore(String key,
                                            String max,
                                            String min,
                                            RangeLimitOptions options)

Return a range of members in a sorted set, by score, with scores ordered from high to low

Parameters:: key - Key string; max - Pattern defining a maximum value; min - Pattern defining a minimum value; options - Range and limit options
Returns:

zrevrank
```
public RedisClient zrevrank(String key,
                            String member,
                            Handler<AsyncResult<Long>> handler)
```
Determine the index of a member in a sorted set, with scores ordered from high to low

Parameters:

key - Key string

member - Member in the sorted set identified by key

handler - Handler for the result of this call.

Returns:

rxZrevrank
```
public Single<Long> rxZrevrank(String key,
                               String member)
```
Determine the index of a member in a sorted set, with scores ordered from high to low

Parameters:

key - Key string

member - Member in the sorted set identified by key

Returns:

zscore

public RedisClient zscore(String key,
                          String member,
                          Handler<AsyncResult<String>> handler)

Get the score associated with the given member in a sorted set

Parameters:: key - Key string; member - Member in the sorted set identified by key; handler - Handler for the result of this call.
Returns:

rxZscore
```
public Single<String> rxZscore(String key,
                               String member)
```
Get the score associated with the given member in a sorted set

Parameters:

key - Key string

member - Member in the sorted set identified by key

Returns:

zunionstore

public RedisClient zunionstore(String destkey,
                               List<String> sets,
                               AggregateOptions options,
                               Handler<AsyncResult<Long>> handler)

Add multiple sorted sets and store the resulting sorted set in a new key

Parameters:: destkey - Destination key; sets - List of keys identifying sorted sets; options - Aggregation options; handler - Handler for the result of this call.
Returns:

rxZunionstore

public Single<Long> rxZunionstore(String destkey,
                                  List<String> sets,
                                  AggregateOptions options)

Add multiple sorted sets and store the resulting sorted set in a new key

Parameters:: destkey - Destination key; sets - List of keys identifying sorted sets; options - Aggregation options
Returns:

zunionstoreWeighed

public RedisClient zunionstoreWeighed(String key,
                                      Map<String,Double> sets,
                                      AggregateOptions options,
                                      Handler<AsyncResult<Long>> handler)

Add multiple sorted sets using weights, and store the resulting sorted set in a new key

Parameters:: key - Destination key; sets - Map containing set-key:weight pairs; options - Aggregation options; handler - Handler for the result of this call.
Returns:

rxZunionstoreWeighed

public Single<Long> rxZunionstoreWeighed(String key,
                                         Map<String,Double> sets,
                                         AggregateOptions options)

Add multiple sorted sets using weights, and store the resulting sorted set in a new key

Parameters:: key - Destination key; sets - Map containing set-key:weight pairs; options - Aggregation options
Returns:

scan

public RedisClient scan(String cursor,
                        ScanOptions options,
                        Handler<AsyncResult<JsonArray>> handler)

Incrementally iterate the keys space

Parameters:: cursor - Cursor id; options - Scan options; handler - Handler for the result of this call.
Returns:

rxScan

public Single<JsonArray> rxScan(String cursor,
                                ScanOptions options)

Incrementally iterate the keys space

Parameters:: cursor - Cursor id; options - Scan options
Returns:

sscan

public RedisClient sscan(String key,
                         String cursor,
                         ScanOptions options,
                         Handler<AsyncResult<JsonArray>> handler)

Incrementally iterate Set elements

Parameters:: key - Key string; cursor - Cursor id; options - Scan options; handler - Handler for the result of this call.
Returns:

rxSscan

public Single<JsonArray> rxSscan(String key,
                                 String cursor,
                                 ScanOptions options)

Incrementally iterate Set elements

Parameters:: key - Key string; cursor - Cursor id; options - Scan options
Returns:

hscan

public RedisClient hscan(String key,
                         String cursor,
                         ScanOptions options,
                         Handler<AsyncResult<JsonArray>> handler)

Incrementally iterate hash fields and associated values

Parameters:: key - Key string; cursor - Cursor id; options - Scan options; handler - Handler for the result of this call.
Returns:

rxHscan

public Single<JsonArray> rxHscan(String key,
                                 String cursor,
                                 ScanOptions options)

Incrementally iterate hash fields and associated values

Parameters:: key - Key string; cursor - Cursor id; options - Scan options
Returns:

zscan

public RedisClient zscan(String key,
                         String cursor,
                         ScanOptions options,
                         Handler<AsyncResult<JsonArray>> handler)

Incrementally iterate sorted sets elements and associated scores

Parameters:: key - Key string; cursor - Cursor id; options - Scan options; handler - Handler for the result of this call.
Returns:

rxZscan

public Single<JsonArray> rxZscan(String key,
                                 String cursor,
                                 ScanOptions options)

Incrementally iterate sorted sets elements and associated scores

Parameters:: key - Key string; cursor - Cursor id; options - Scan options
Returns:

geoadd

public RedisClient geoadd(String key,
                          double longitude,
                          double latitude,
                          String member,
                          Handler<AsyncResult<Long>> handler)

Add one or more geospatial items in the geospatial index represented using a sorted set.

Parameters:: key - Key string; longitude - longitude; latitude - latitude; member - member; handler - Handler for the result of this call.
Returns:

rxGeoadd

public Single<Long> rxGeoadd(String key,
                             double longitude,
                             double latitude,
                             String member)

Add one or more geospatial items in the geospatial index represented using a sorted set.

Parameters:: key - Key string; longitude - longitude; latitude - latitude; member - member
Returns:

geoaddMany

public RedisClient geoaddMany(String key,
                              List<GeoMember> members,
                              Handler<AsyncResult<Long>> handler)

Add one or more geospatial items in the geospatial index represented using a sorted set.

Parameters:: key - Key string; members - list of <lon, lat, member>; handler - Handler for the result of this call.
Returns:

rxGeoaddMany
```
public Single<Long> rxGeoaddMany(String key,
                                 List<GeoMember> members)
```
Add one or more geospatial items in the geospatial index represented using a sorted set.

Parameters:

key - Key string

members - list of <lon, lat, member>

Returns:

geohash
```
public RedisClient geohash(String key,
                           String member,
                           Handler<AsyncResult<JsonArray>> handler)
```
Return valid Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index (where elements were added using GEOADD).

Parameters:

key - Key string

member - member

handler - Handler for the result of this call.

Returns:

rxGeohash
```
public Single<JsonArray> rxGeohash(String key,
                                   String member)
```
Return valid Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index (where elements were added using GEOADD).

Parameters:

key - Key string

member - member

Returns:

geohashMany
```
public RedisClient geohashMany(String key,
                               List<String> members,
                               Handler<AsyncResult<JsonArray>> handler)
```
Return valid Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index (where elements were added using GEOADD).

Parameters:

key - Key string

members - list of members

handler - Handler for the result of this call.

Returns:

rxGeohashMany
```
public Single<JsonArray> rxGeohashMany(String key,
                                       List<String> members)
```
Return valid Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index (where elements were added using GEOADD).

Parameters:

key - Key string

members - list of members

Returns:

geopos
```
public RedisClient geopos(String key,
                          String member,
                          Handler<AsyncResult<JsonArray>> handler)
```
Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.

Parameters:

key - Key string

member - member

handler - Handler for the result of this call.

Returns:

rxGeopos
```
public Single<JsonArray> rxGeopos(String key,
                                  String member)
```
Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.

Parameters:

key - Key string

member - member

Returns:

geoposMany
```
public RedisClient geoposMany(String key,
                              List<String> members,
                              Handler<AsyncResult<JsonArray>> handler)
```
Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.

Parameters:

key - Key string

members - list of members

handler - Handler for the result of this call.

Returns:

rxGeoposMany
```
public Single<JsonArray> rxGeoposMany(String key,
                                      List<String> members)
```
Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.

Parameters:

key - Key string

members - list of members

Returns:

geodist

public RedisClient geodist(String key,
                           String member1,
                           String member2,
                           Handler<AsyncResult<String>> handler)

Return the distance between two members in the geospatial index represented by the sorted set.

Parameters:: key - Key string; member1 - member 1; member2 - member 2; handler - Handler for the result of this call.
Returns:

rxGeodist

public Single<String> rxGeodist(String key,
                                String member1,
                                String member2)

Return the distance between two members in the geospatial index represented by the sorted set.

Parameters:: key - Key string; member1 - member 1; member2 - member 2
Returns:

geodistWithUnit

public RedisClient geodistWithUnit(String key,
                                   String member1,
                                   String member2,
                                   GeoUnit unit,
                                   Handler<AsyncResult<String>> handler)

Return the distance between two members in the geospatial index represented by the sorted set.

Parameters:: key - Key string; member1 - member 1; member2 - member 2; unit - geo unit; handler - Handler for the result of this call.
Returns:

rxGeodistWithUnit

public Single<String> rxGeodistWithUnit(String key,
                                        String member1,
                                        String member2,
                                        GeoUnit unit)

Return the distance between two members in the geospatial index represented by the sorted set.

Parameters:: key - Key string; member1 - member 1; member2 - member 2; unit - geo unit
Returns:

georadius
```
public RedisClient georadius(String key,
                             double longitude,
                             double latitude,
                             double radius,
                             GeoUnit unit,
                             Handler<AsyncResult<JsonArray>> handler)
```
Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders of the area specified with the center location and the maximum distance from the center (the radius).

Parameters:

key - Key string

longitude - longitude

latitude - latitude

radius - radius

unit - geo unit

handler - Handler for the result of this call.

Returns:

rxGeoradius
```
public Single<JsonArray> rxGeoradius(String key,
                                     double longitude,
                                     double latitude,
                                     double radius,
                                     GeoUnit unit)
```
Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders of the area specified with the center location and the maximum distance from the center (the radius).

Parameters:

key - Key string

longitude - longitude

latitude - latitude

radius - radius

unit - geo unit

Returns:

georadiusWithOptions

public RedisClient georadiusWithOptions(String key,
                                        double longitude,
                                        double latitude,
                                        double radius,
                                        GeoUnit unit,
                                        GeoRadiusOptions options,
                                        Handler<AsyncResult<JsonArray>> handler)

Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders of the area specified with the center location and the maximum distance from the center (the radius).

Parameters:: key - Key string; longitude - longitude; latitude - latitude; radius - radius; unit - geo unit; options - geo radius options; handler - Handler for the result of this call.
Returns:

rxGeoradiusWithOptions

public Single<JsonArray> rxGeoradiusWithOptions(String key,
                                                double longitude,
                                                double latitude,
                                                double radius,
                                                GeoUnit unit,
                                                GeoRadiusOptions options)

Parameters:: key - Key string; longitude - longitude; latitude - latitude; radius - radius; unit - geo unit; options - geo radius options
Returns:

georadiusbymember

public RedisClient georadiusbymember(String key,
                                     String member,
                                     double radius,
                                     GeoUnit unit,
                                     Handler<AsyncResult<JsonArray>> handler)

This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial index represented by the sorted set.

Parameters:: key - Key string; member - member; radius - radius; unit - geo unit; handler - Handler for the result of this call.
Returns:

rxGeoradiusbymember
```
public Single<JsonArray> rxGeoradiusbymember(String key,
                                             String member,
                                             double radius,
                                             GeoUnit unit)
```
This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial index represented by the sorted set.

Parameters:

key - Key string

member - member

radius - radius

unit - geo unit

Returns:

georadiusbymemberWithOptions

public RedisClient georadiusbymemberWithOptions(String key,
                                                String member,
                                                double radius,
                                                GeoUnit unit,
                                                GeoRadiusOptions options,
                                                Handler<AsyncResult<JsonArray>> handler)

Parameters:: key - Key string; member - member; radius - radius; unit - geo unit; options - geo radius options; handler - Handler for the result of this call.
Returns:

rxGeoradiusbymemberWithOptions

public Single<JsonArray> rxGeoradiusbymemberWithOptions(String key,
                                                        String member,
                                                        double radius,
                                                        GeoUnit unit,
                                                        GeoRadiusOptions options)

Parameters:: key - Key string; member - member; radius - radius; unit - geo unit; options - geo radius options
Returns:

clientReply

public RedisClient clientReply(ClientReplyOptions options,
                               Handler<AsyncResult<String>> handler)

Instruct the server whether to reply to commands.

Parameters:: options -; handler -
Returns:

rxClientReply
```
public Single<String> rxClientReply(ClientReplyOptions options)
```
Instruct the server whether to reply to commands.

Parameters:

options -

Returns:

hstrlen

public RedisClient hstrlen(String key,
                           String field,
                           Handler<AsyncResult<Long>> handler)

Get the length of the value of a hash field.

Parameters:: key - Key String; field - field; handler -
Returns:

rxHstrlen

public Single<Long> rxHstrlen(String key,
                              String field)

Get the length of the value of a hash field.

Parameters:: key - Key String; field - field
Returns:

touch
```
public RedisClient touch(String key,
                         Handler<AsyncResult<Long>> handler)
```
Alters the last access time of a key(s). Returns the number of existing keys specified.

Parameters:

key - Key String

handler -

Returns:

rxTouch
```
public Single<Long> rxTouch(String key)
```
Alters the last access time of a key(s). Returns the number of existing keys specified.

Parameters:

key - Key String

Returns:

touchMany

public RedisClient touchMany(List<String> keys,
                             Handler<AsyncResult<Long>> handler)

Alters the last access time of a key(s). Returns the number of existing keys specified.

Parameters:: keys - list of keys; handler -
Returns:

rxTouchMany
```
public Single<Long> rxTouchMany(List<String> keys)
```
Alters the last access time of a key(s). Returns the number of existing keys specified.

Parameters:

keys - list of keys

Returns:

scriptDebug

public RedisClient scriptDebug(ScriptDebugOptions scriptDebugOptions,
                               Handler<AsyncResult<String>> handler)

Set the debug mode for executed scripts.

Parameters:: scriptDebugOptions - the option; handler -
Returns:

rxScriptDebug
```
public Single<String> rxScriptDebug(ScriptDebugOptions scriptDebugOptions)
```
Set the debug mode for executed scripts.

Parameters:

scriptDebugOptions - the option

Returns:

bitfield

public RedisClient bitfield(String key,
                            BitFieldOptions bitFieldOptions,
                            Handler<AsyncResult<JsonArray>> handler)

Perform arbitrary bitfield integer operations on strings.

Parameters:: key - Key string; bitFieldOptions -; handler -
Returns:

rxBitfield

public Single<JsonArray> rxBitfield(String key,
                                    BitFieldOptions bitFieldOptions)

Perform arbitrary bitfield integer operations on strings.

Parameters:: key - Key string; bitFieldOptions -
Returns:

bitfieldWithOverflow

public RedisClient bitfieldWithOverflow(String key,
                                        BitFieldOptions commands,
                                        BitFieldOverflowOptions overflow,
                                        Handler<AsyncResult<JsonArray>> handler)

Perform arbitrary bitfield integer operations on strings.

Parameters:: key - Key string; commands -; overflow -; handler -
Returns:

rxBitfieldWithOverflow

public Single<JsonArray> rxBitfieldWithOverflow(String key,
                                                BitFieldOptions commands,
                                                BitFieldOverflowOptions overflow)

Perform arbitrary bitfield integer operations on strings.

Parameters:: key - Key string; commands -; overflow -
Returns:

unlink
```
public RedisClient unlink(String key,
                          Handler<AsyncResult<Long>> handler)
```
Delete a key asynchronously in another thread. Otherwise it is just as DEL, but non blocking.

Parameters:

key - Key to delete

handler - Handler for the result of this call.

Returns:

rxUnlink
```
public Single<Long> rxUnlink(String key)
```
Delete a key asynchronously in another thread. Otherwise it is just as DEL, but non blocking.

Parameters:

key - Key to delete

Returns:

unlinkMany
```
public RedisClient unlinkMany(List<String> keys,
                              Handler<AsyncResult<Long>> handler)
```
Delete multiple keys asynchronously in another thread. Otherwise it is just as DEL, but non blocking.

Parameters:

keys - List of keys to delete

handler - Handler for the result of this call.

Returns:

rxUnlinkMany
```
public Single<Long> rxUnlinkMany(List<String> keys)
```
Delete multiple keys asynchronously in another thread. Otherwise it is just as DEL, but non blocking.

Parameters:

keys - List of keys to delete

Returns:

swapdb

public RedisClient swapdb(int index1,
                          int index2,
                          Handler<AsyncResult<String>> handler)

Swaps two Redis databases

Parameters:: index1 - index of first database to swap; index2 - index of second database to swap; handler - Handler for the result of this call.
Returns:

rxSwapdb
```
public Single<String> rxSwapdb(int index1,
                               int index2)
```
Swaps two Redis databases

Parameters:

index1 - index of first database to swap

index2 - index of second database to swap

Returns:

newInstance

public static RedisClient newInstance(RedisClient arg)

Class RedisClient

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

__TYPE_ARG

Constructor Detail

RedisClient

RedisClient

Method Detail

toString

equals

hashCode

getDelegate

create

create

close

rxClose

append

rxAppend

auth

rxAuth

bgrewriteaof

rxBgrewriteaof

bgsave

rxBgsave

bitcount

rxBitcount

bitcountRange

rxBitcountRange

bitop

rxBitop

bitpos

rxBitpos

bitposFrom

rxBitposFrom

bitposRange

rxBitposRange

blpop

rxBlpop

blpopMany

rxBlpopMany

brpop

rxBrpop

brpopMany

rxBrpopMany

brpoplpush

rxBrpoplpush

clientKill

rxClientKill

clientList

rxClientList

clientGetname

rxClientGetname

clientPause

rxClientPause

clientSetname

rxClientSetname

clusterAddslots

rxClusterAddslots

clusterCountFailureReports

rxClusterCountFailureReports

clusterCountkeysinslot

rxClusterCountkeysinslot

clusterDelslots

rxClusterDelslots

clusterDelslotsMany

rxClusterDelslotsMany

clusterFailover

rxClusterFailover

clusterFailOverWithOptions

rxClusterFailOverWithOptions

clusterForget

rxClusterForget

clusterGetkeysinslot

rxClusterGetkeysinslot

clusterInfo

rxClusterInfo

clusterKeyslot