io.vertx.rxjava.redis

## Class RedisTransaction

- java.lang.Object
- - io.vertx.rxjava.redis.RedisTransaction

-     public class RedisTransaction
      extends Object

  This Interface represents a TX

  NOTE: This class has been automatically generated from the `original` non RX-ified interface using Vert.x codegen.

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `RedisTransaction(RedisTransaction delegate)`

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `RedisTransaction` | `append(String key, String value, Handler<AsyncResult<String>> handler)` Append a value to a key
    `Observable<String>` | `appendObservable(String key, String value)` Append a value to a key
    `RedisTransaction` | `auth(String password, Handler<AsyncResult<String>> handler)` Authenticate to the server
    `Observable<String>` | `authObservable(String password)` Authenticate to the server
    `RedisTransaction` | `bgrewriteaof(Handler<AsyncResult<String>> handler)` Asynchronously rewrite the append-only file
    `Observable<String>` | `bgrewriteaofObservable()` Asynchronously rewrite the append-only file
    `RedisTransaction` | `bgsave(Handler<AsyncResult<String>> handler)` Asynchronously save the dataset to disk
    `Observable<String>` | `bgsaveObservable()` Asynchronously save the dataset to disk
    `RedisTransaction` | `bitcount(String key, Handler<AsyncResult<String>> handler)` Count set bits in a string
    `Observable<String>` | `bitcountObservable(String key)` Count set bits in a string
    `RedisTransaction` | `bitcountRange(String key, long start, long end, Handler<AsyncResult<String>> handler)` Count set bits in a string
    `Observable<String>` | `bitcountRangeObservable(String key, long start, long end)` Count set bits in a string
    `RedisTransaction` | `bitop(BitOperation operation, String destkey, List<String> keys, Handler<AsyncResult<String>> handler)` Perform bitwise operations between strings
    `Observable<String>` | `bitopObservable(BitOperation operation, String destkey, List<String> keys)` Perform bitwise operations between strings
    `RedisTransaction` | `bitpos(String key, int bit, Handler<AsyncResult<String>> handler)` Find first bit set or clear in a string
    `RedisTransaction` | `bitposFrom(String key, int bit, int start, Handler<AsyncResult<String>> handler)` Find first bit set or clear in a string
    `Observable<String>` | `bitposFromObservable(String key, int bit, int start)` Find first bit set or clear in a string
    `Observable<String>` | `bitposObservable(String key, int bit)` Find first bit set or clear in a string
    `RedisTransaction` | `bitposRange(String key, int bit, int start, int stop, Handler<AsyncResult<String>> handler)` Find first bit set or clear in a string
    `Observable<String>` | `bitposRangeObservable(String key, int bit, int start, int stop)` Find first bit set or clear in a string
    `RedisTransaction` | `blpop(String key, int seconds, Handler<AsyncResult<String>> handler)` Remove and get the first element in a list, or block until one is available
    `RedisTransaction` | `blpopMany(List<String> keys, int seconds, Handler<AsyncResult<String>> handler)` Remove and get the first element in any of the lists, or block until one is available
    `Observable<String>` | `blpopManyObservable(List<String> keys, int seconds)` Remove and get the first element in any of the lists, or block until one is available
    `Observable<String>` | `blpopObservable(String key, int seconds)` Remove and get the first element in a list, or block until one is available
    `RedisTransaction` | `brpop(String key, int seconds, Handler<AsyncResult<String>> handler)` Remove and get the last element in a list, or block until one is available
    `RedisTransaction` | `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
    `Observable<String>` | `brpoplpushObservable(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
    `RedisTransaction` | `brpopMany(List<String> keys, int seconds, Handler<AsyncResult<String>> handler)` Remove and get the last element in any of the lists, or block until one is available
    `Observable<String>` | `brpopManyObservable(List<String> keys, int seconds)` Remove and get the last element in any of the lists, or block until one is available
    `Observable<String>` | `brpopObservable(String key, int seconds)` Remove and get the last element in a list, or block until one is available
    `RedisTransaction` | `clientGetname(Handler<AsyncResult<String>> handler)` Get the current connection name
    `Observable<String>` | `clientGetnameObservable()` Get the current connection name
    `RedisTransaction` | `clientKill(KillFilter filter, Handler<AsyncResult<String>> handler)` Kill the connection of a client
    `Observable<String>` | `clientKillObservable(KillFilter filter)` Kill the connection of a client
    `RedisTransaction` | `clientList(Handler<AsyncResult<String>> handler)` Get the list of client connections
    `Observable<String>` | `clientListObservable()` Get the list of client connections
    `RedisTransaction` | `clientPause(long millis, Handler<AsyncResult<String>> handler)` Stop processing commands from clients for some time
    `Observable<String>` | `clientPauseObservable(long millis)` Stop processing commands from clients for some time
    `RedisTransaction` | `clientSetname(String name, Handler<AsyncResult<String>> handler)` Set the current connection name
    `Observable<String>` | `clientSetnameObservable(String name)` Set the current connection name
    `void` | `close(Handler<AsyncResult<Void>> handler)` Close the client - when it is fully closed the handler will be called.
    `Observable<Void>` | `closeObservable()` Close the client - when it is fully closed the handler will be called.
    `RedisTransaction` | `clusterAddslots(List<String> slots, Handler<AsyncResult<String>> handler)` Assign new hash slots to receiving node.
    `Observable<String>` | `clusterAddslotsObservable(List<String> slots)` Assign new hash slots to receiving node.
    `RedisTransaction` | `clusterCountFailureReports(String nodeId, Handler<AsyncResult<String>> handler)` Return the number of failure reports active for a given node.
    `Observable<String>` | `clusterCountFailureReportsObservable(String nodeId)` Return the number of failure reports active for a given node.
    `RedisTransaction` | `clusterCountkeysinslot(long slot, Handler<AsyncResult<String>> handler)` Return the number of local keys in the specified hash slot.
    `Observable<String>` | `clusterCountkeysinslotObservable(long slot)` Return the number of local keys in the specified hash slot.
    `RedisTransaction` | `clusterDelslots(long slot, Handler<AsyncResult<String>> handler)` Set hash slots as unbound in receiving node.
    `RedisTransaction` | `clusterDelslotsMany(List<String> slots, Handler<AsyncResult<String>> handler)` Set hash slots as unbound in receiving node.
    `Observable<String>` | `clusterDelslotsManyObservable(List<String> slots)` Set hash slots as unbound in receiving node.
    `Observable<String>` | `clusterDelslotsObservable(long slot)` Set hash slots as unbound in receiving node.
    `RedisTransaction` | `clusterFailover(Handler<AsyncResult<String>> handler)` Forces a slave to perform a manual failover of its master.
    `Observable<String>` | `clusterFailoverObservable()` Forces a slave to perform a manual failover of its master.
    `RedisTransaction` | `clusterFailOverWithOptions(FailoverOptions options, Handler<AsyncResult<String>> handler)` Forces a slave to perform a manual failover of its master.
    `Observable<String>` | `clusterFailOverWithOptionsObservable(FailoverOptions options)` Forces a slave to perform a manual failover of its master.
    `RedisTransaction` | `clusterForget(String nodeId, Handler<AsyncResult<String>> handler)` Remove a node from the nodes table.
    `Observable<String>` | `clusterForgetObservable(String nodeId)` Remove a node from the nodes table.
    `RedisTransaction` | `clusterGetkeysinslot(long slot, long count, Handler<AsyncResult<String>> handler)` Return local key names in the specified hash slot.
    `Observable<String>` | `clusterGetkeysinslotObservable(long slot, long count)` Return local key names in the specified hash slot.
    `RedisTransaction` | `clusterInfo(Handler<AsyncResult<String>> handler)` Provides info about Redis Cluster node state.
    `Observable<String>` | `clusterInfoObservable()` Provides info about Redis Cluster node state.
    `RedisTransaction` | `clusterKeyslot(String key, Handler<AsyncResult<String>> handler)` Returns the hash slot of the specified key.
    `Observable<String>` | `clusterKeyslotObservable(String key)` Returns the hash slot of the specified key.
    `RedisTransaction` | `clusterMeet(String ip, long port, Handler<AsyncResult<String>> handler)` Force a node cluster to handshake with another node.
    `Observable<String>` | `clusterMeetObservable(String ip, long port)` Force a node cluster to handshake with another node.
    `RedisTransaction` | `clusterNodes(Handler<AsyncResult<String>> handler)` Get Cluster config for the node.
    `Observable<String>` | `clusterNodesObservable()` Get Cluster config for the node.
    `RedisTransaction` | `clusterReplicate(String nodeId, Handler<AsyncResult<String>> handler)` Reconfigure a node as a slave of the specified master node.
    `Observable<String>` | `clusterReplicateObservable(String nodeId)` Reconfigure a node as a slave of the specified master node.
    `RedisTransaction` | `clusterReset(Handler<AsyncResult<String>> handler)` Reset a Redis Cluster node.
    `Observable<String>` | `clusterResetObservable()` Reset a Redis Cluster node.
    `RedisTransaction` | `clusterResetWithOptions(ResetOptions options, Handler<AsyncResult<String>> handler)` Reset a Redis Cluster node.
    `Observable<String>` | `clusterResetWithOptionsObservable(ResetOptions options)` Reset a Redis Cluster node.
    `RedisTransaction` | `clusterSaveconfig(Handler<AsyncResult<String>> handler)` Forces the node to save cluster state on disk.
    `Observable<String>` | `clusterSaveconfigObservable()` Forces the node to save cluster state on disk.
    `RedisTransaction` | `clusterSetConfigEpoch(long epoch, Handler<AsyncResult<String>> handler)` Set the configuration epoch in a new node.
    `Observable<String>` | `clusterSetConfigEpochObservable(long epoch)` Set the configuration epoch in a new node.
    `RedisTransaction` | `clusterSetslot(long slot, SlotCmd subcommand, Handler<AsyncResult<String>> handler)` Bind an hash slot to a specific node.
    `Observable<String>` | `clusterSetslotObservable(long slot, SlotCmd subcommand)` Bind an hash slot to a specific node.
    `RedisTransaction` | `clusterSetslotWithNode(long slot, SlotCmd subcommand, String nodeId, Handler<AsyncResult<String>> handler)` Bind an hash slot to a specific node.
    `Observable<String>` | `clusterSetslotWithNodeObservable(long slot, SlotCmd subcommand, String nodeId)` Bind an hash slot to a specific node.
    `RedisTransaction` | `clusterSlaves(String nodeId, Handler<AsyncResult<String>> handler)` List slave nodes of the specified master node.
    `Observable<String>` | `clusterSlavesObservable(String nodeId)` List slave nodes of the specified master node.
    `RedisTransaction` | `clusterSlots(Handler<AsyncResult<String>> handler)` Get array of Cluster slot to node mappings
    `Observable<String>` | `clusterSlotsObservable()` Get array of Cluster slot to node mappings
    `RedisTransaction` | `command(Handler<AsyncResult<String>> handler)` Get array of Redis command details
    `RedisTransaction` | `commandCount(Handler<AsyncResult<String>> handler)` Get total number of Redis commands
    `Observable<String>` | `commandCountObservable()` Get total number of Redis commands
    `RedisTransaction` | `commandGetkeys(Handler<AsyncResult<String>> handler)` Extract keys given a full Redis command
    `Observable<String>` | `commandGetkeysObservable()` Extract keys given a full Redis command
    `RedisTransaction` | `commandInfo(List<String> commands, Handler<AsyncResult<String>> handler)` Get array of specific Redis command details
    `Observable<String>` | `commandInfoObservable(List<String> commands)` Get array of specific Redis command details
    `Observable<String>` | `commandObservable()` Get array of Redis command details
    `RedisTransaction` | `configGet(String parameter, Handler<AsyncResult<String>> handler)` Get the value of a configuration parameter
    `Observable<String>` | `configGetObservable(String parameter)` Get the value of a configuration parameter
    `RedisTransaction` | `configResetstat(Handler<AsyncResult<String>> handler)` Reset the stats returned by INFO
    `Observable<String>` | `configResetstatObservable()` Reset the stats returned by INFO
    `RedisTransaction` | `configRewrite(Handler<AsyncResult<String>> handler)` Rewrite the configuration file with the in memory configuration
    `Observable<String>` | `configRewriteObservable()` Rewrite the configuration file with the in memory configuration
    `RedisTransaction` | `configSet(String parameter, String value, Handler<AsyncResult<String>> handler)` Set a configuration parameter to the given value
    `Observable<String>` | `configSetObservable(String parameter, String value)` Set a configuration parameter to the given value
    `RedisTransaction` | `dbsize(Handler<AsyncResult<String>> handler)` Return the number of keys in the selected database
    `Observable<String>` | `dbsizeObservable()` Return the number of keys in the selected database
    `RedisTransaction` | `debugObject(String key, Handler<AsyncResult<String>> handler)` Get debugging information about a key
    `Observable<String>` | `debugObjectObservable(String key)` Get debugging information about a key
    `RedisTransaction` | `debugSegfault(Handler<AsyncResult<String>> handler)` Make the server crash
    `Observable<String>` | `debugSegfaultObservable()` Make the server crash
    `RedisTransaction` | `decr(String key, Handler<AsyncResult<String>> handler)` Decrement the integer value of a key by one
    `RedisTransaction` | `decrby(String key, long decrement, Handler<AsyncResult<String>> handler)` Decrement the integer value of a key by the given number
    `Observable<String>` | `decrbyObservable(String key, long decrement)` Decrement the integer value of a key by the given number
    `Observable<String>` | `decrObservable(String key)` Decrement the integer value of a key by one
    `RedisTransaction` | `del(String key, Handler<AsyncResult<String>> handler)` Delete a key
    `RedisTransaction` | `delMany(List<String> keys, Handler<AsyncResult<String>> handler)` Delete many keys
    `Observable<String>` | `delManyObservable(List<String> keys)` Delete many keys
    `Observable<String>` | `delObservable(String key)` Delete a key
    `RedisTransaction` | `discard(Handler<AsyncResult<String>> handler)` Discard all commands issued after MULTI
    `Observable<String>` | `discardObservable()` Discard all commands issued after MULTI
    `RedisTransaction` | `dump(String key, Handler<AsyncResult<String>> handler)` Return a serialized version of the value stored at the specified key.
    `Observable<String>` | `dumpObservable(String key)` Return a serialized version of the value stored at the specified key.
    `RedisTransaction` | `echo(String message, Handler<AsyncResult<String>> handler)` Echo the given string
    `Observable<String>` | `echoObservable(String message)` Echo the given string
    `RedisTransaction` | `eval(String script, List<String> keys, List<String> args, Handler<AsyncResult<String>> handler)` Execute a Lua script server side.
    `Observable<String>` | `evalObservable(String script, List<String> keys, List<String> args)` Execute a Lua script server side.
    `RedisTransaction` | `evalsha(String sha1, List<String> keys, List<String> values, Handler<AsyncResult<String>> handler)` Execute a Lua script server side.
    `Observable<String>` | `evalshaObservable(String sha1, List<String> keys, List<String> values)` Execute a Lua script server side.
    `RedisTransaction` | `exec(Handler<AsyncResult<JsonArray>> handler)` Execute all commands issued after MULTI
    `Observable<JsonArray>` | `execObservable()` Execute all commands issued after MULTI
    `RedisTransaction` | `exists(String key, Handler<AsyncResult<String>> handler)` Determine if a key exists
    `Observable<String>` | `existsObservable(String key)` Determine if a key exists
    `RedisTransaction` | `expire(String key, int seconds, Handler<AsyncResult<String>> handler)` Set a key's time to live in seconds
    `RedisTransaction` | `expireat(String key, long seconds, Handler<AsyncResult<String>> handler)` Set the expiration for a key as a UNIX timestamp
    `Observable<String>` | `expireatObservable(String key, long seconds)` Set the expiration for a key as a UNIX timestamp
    `Observable<String>` | `expireObservable(String key, int seconds)` Set a key's time to live in seconds
    `RedisTransaction` | `flushall(Handler<AsyncResult<String>> handler)` Remove all keys from all databases
    `Observable<String>` | `flushallObservable()` Remove all keys from all databases
    `RedisTransaction` | `flushdb(Handler<AsyncResult<String>> handler)` Remove all keys from the current database
    `Observable<String>` | `flushdbObservable()` Remove all keys from the current database
    `RedisTransaction` | `geoadd(String key, double longitude, double latitude, String member, Handler<AsyncResult<String>> handler)` Add one or more geospatial items in the geospatial index represented using a sorted set.
    `RedisTransaction` | `geoaddMany(String key, List<GeoMember> members, Handler<AsyncResult<String>> handler)` Add one or more geospatial items in the geospatial index represented using a sorted set.
    `Observable<String>` | `geoaddManyObservable(String key, List<GeoMember> members)` Add one or more geospatial items in the geospatial index represented using a sorted set.
    `Observable<String>` | `geoaddObservable(String key, double longitude, double latitude, String member)` Add one or more geospatial items in the geospatial index represented using a sorted set.
    `RedisTransaction` | `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.
    `Observable<String>` | `geodistObservable(String key, String member1, String member2)` Return the distance between two members in the geospatial index represented by the sorted set.
    `RedisTransaction` | `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.
    `Observable<String>` | `geodistWithUnitObservable(String key, String member1, String member2, GeoUnit unit)` Return the distance between two members in the geospatial index represented by the sorted set.
    `RedisTransaction` | `geohash(String key, String member, Handler<AsyncResult<String>> 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).
    `RedisTransaction` | `geohashMany(String key, List<String> members, Handler<AsyncResult<String>> 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).
    `Observable<String>` | `geohashManyObservable(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).
    `Observable<String>` | `geohashObservable(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).
    `RedisTransaction` | `geopos(String key, String member, Handler<AsyncResult<String>> handler)` Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.
    `RedisTransaction` | `geoposMany(String key, List<String> members, Handler<AsyncResult<String>> handler)` Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.
    `Observable<String>` | `geoposManyObservable(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.
    `Observable<String>` | `geoposObservable(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.
    `RedisTransaction` | `georadius(String key, double longitude, double latitude, double radius, GeoUnit unit, Handler<AsyncResult<String>> 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).
    `RedisTransaction` | `georadiusbymember(String key, String member, double radius, GeoUnit unit, Handler<AsyncResult<String>> 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.
    `Observable<String>` | `georadiusbymemberObservable(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.
    `RedisTransaction` | `georadiusbymemberWithOptions(String key, String member, double radius, GeoUnit unit, GeoRadiusOptions options, Handler<AsyncResult<String>> 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.
    `Observable<String>` | `georadiusbymemberWithOptionsObservable(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.
    `Observable<String>` | `georadiusObservable(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).
    `RedisTransaction` | `georadiusWithOptions(String key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusOptions options, Handler<AsyncResult<String>> 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).
    `Observable<String>` | `georadiusWithOptionsObservable(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).
    `RedisTransaction` | `get(String key, Handler<AsyncResult<String>> handler)` Get the value of a key
    `RedisTransaction` | `getBinary(String key, Handler<AsyncResult<String>> handler)` Get the value of a key - without decoding as utf-8
    `Observable<String>` | `getBinaryObservable(String key)` Get the value of a key - without decoding as utf-8
    `RedisTransaction` | `getbit(String key, long offset, Handler<AsyncResult<String>> handler)` Returns the bit value at offset in the string value stored at key
    `Observable<String>` | `getbitObservable(String key, long offset)` Returns the bit value at offset in the string value stored at key
    `Object` | `getDelegate()`
    `Observable<String>` | `getObservable(String key)` Get the value of a key
    `RedisTransaction` | `getrange(String key, long start, long end, Handler<AsyncResult<String>> handler)` Get a substring of the string stored at a key
    `Observable<String>` | `getrangeObservable(String key, long start, long end)` Get a substring of the string stored at a key
    `RedisTransaction` | `getset(String key, String value, Handler<AsyncResult<String>> handler)` Set the string value of a key and return its old value
    `Observable<String>` | `getsetObservable(String key, String value)` Set the string value of a key and return its old value
    `RedisTransaction` | `hdel(String key, String field, Handler<AsyncResult<String>> handler)` Delete one or more hash fields
    `RedisTransaction` | `hdelMany(String key, List<String> fields, Handler<AsyncResult<String>> handler)` Delete one or more hash fields
    `Observable<String>` | `hdelManyObservable(String key, List<String> fields)` Delete one or more hash fields
    `Observable<String>` | `hdelObservable(String key, String field)` Delete one or more hash fields
    `RedisTransaction` | `hexists(String key, String field, Handler<AsyncResult<String>> handler)` Determine if a hash field exists
    `Observable<String>` | `hexistsObservable(String key, String field)` Determine if a hash field exists
    `RedisTransaction` | `hget(String key, String field, Handler<AsyncResult<String>> handler)` Get the value of a hash field
    `RedisTransaction` | `hgetall(String key, Handler<AsyncResult<String>> handler)` Get all the fields and values in a hash
    `Observable<String>` | `hgetallObservable(String key)` Get all the fields and values in a hash
    `Observable<String>` | `hgetObservable(String key, String field)` Get the value of a hash field
    `RedisTransaction` | `hincrby(String key, String field, long increment, Handler<AsyncResult<String>> handler)` Increment the integer value of a hash field by the given number
    `RedisTransaction` | `hincrbyfloat(String key, String field, double increment, Handler<AsyncResult<String>> handler)` Increment the float value of a hash field by the given amount
    `Observable<String>` | `hincrbyfloatObservable(String key, String field, double increment)` Increment the float value of a hash field by the given amount
    `Observable<String>` | `hincrbyObservable(String key, String field, long increment)` Increment the integer value of a hash field by the given number
    `RedisTransaction` | `hkeys(String key, Handler<AsyncResult<String>> handler)` Get all the fields in a hash
    `Observable<String>` | `hkeysObservable(String key)` Get all the fields in a hash
    `RedisTransaction` | `hlen(String key, Handler<AsyncResult<String>> handler)` Get the number of fields in a hash
    `Observable<String>` | `hlenObservable(String key)` Get the number of fields in a hash
    `RedisTransaction` | `hmget(String key, List<String> fields, Handler<AsyncResult<String>> handler)` Get the values of all the given hash fields
    `Observable<String>` | `hmgetObservable(String key, List<String> fields)` Get the values of all the given hash fields
    `RedisTransaction` | `hmset(String key, JsonObject values, Handler<AsyncResult<String>> handler)` Set multiple hash fields to multiple values
    `Observable<String>` | `hmsetObservable(String key, JsonObject values)` Set multiple hash fields to multiple values
    `RedisTransaction` | `hscan(String key, String cursor, ScanOptions options, Handler<AsyncResult<String>> handler)` Incrementally iterate hash fields and associated values
    `Observable<String>` | `hscanObservable(String key, String cursor, ScanOptions options)` Incrementally iterate hash fields and associated values
    `RedisTransaction` | `hset(String key, String field, String value, Handler<AsyncResult<String>> handler)` Set the string value of a hash field
    `RedisTransaction` | `hsetnx(String key, String field, String value, Handler<AsyncResult<String>> handler)` Set the value of a hash field, only if the field does not exist
    `Observable<String>` | `hsetnxObservable(String key, String field, String value)` Set the value of a hash field, only if the field does not exist
    `Observable<String>` | `hsetObservable(String key, String field, String value)` Set the string value of a hash field
    `RedisTransaction` | `hvals(String key, Handler<AsyncResult<String>> handler)` Get all the values in a hash
    `Observable<String>` | `hvalsObservable(String key)` Get all the values in a hash
    `RedisTransaction` | `incr(String key, Handler<AsyncResult<String>> handler)` Increment the integer value of a key by one
    `RedisTransaction` | `incrby(String key, long increment, Handler<AsyncResult<String>> handler)` Increment the integer value of a key by the given amount
    `RedisTransaction` | `incrbyfloat(String key, double increment, Handler<AsyncResult<String>> handler)` Increment the float value of a key by the given amount
    `Observable<String>` | `incrbyfloatObservable(String key, double increment)` Increment the float value of a key by the given amount
    `Observable<String>` | `incrbyObservable(String key, long increment)` Increment the integer value of a key by the given amount
    `Observable<String>` | `incrObservable(String key)` Increment the integer value of a key by one
    `RedisTransaction` | `info(Handler<AsyncResult<String>> handler)` Get information and statistics about the server
    `Observable<String>` | `infoObservable()` Get information and statistics about the server
    `RedisTransaction` | `infoSection(String section, Handler<AsyncResult<String>> handler)` Get information and statistics about the server
    `Observable<String>` | `infoSectionObservable(String section)` Get information and statistics about the server
    `RedisTransaction` | `keys(String pattern, Handler<AsyncResult<String>> handler)` Find all keys matching the given pattern
    `Observable<String>` | `keysObservable(String pattern)` Find all keys matching the given pattern
    `RedisTransaction` | `lastsave(Handler<AsyncResult<String>> handler)` Get the UNIX time stamp of the last successful save to disk
    `Observable<String>` | `lastsaveObservable()` Get the UNIX time stamp of the last successful save to disk
    `RedisTransaction` | `lindex(String key, int index, Handler<AsyncResult<String>> handler)` Get an element from a list by its index
    `Observable<String>` | `lindexObservable(String key, int index)` Get an element from a list by its index
    `RedisTransaction` | `linsert(String key, InsertOptions option, String pivot, String value, Handler<AsyncResult<String>> handler)` Insert an element before or after another element in a list
    `Observable<String>` | `linsertObservable(String key, InsertOptions option, String pivot, String value)` Insert an element before or after another element in a list
    `RedisTransaction` | `llen(String key, Handler<AsyncResult<String>> handler)` Get the length of a list
    `Observable<String>` | `llenObservable(String key)` Get the length of a list
    `RedisTransaction` | `lpop(String key, Handler<AsyncResult<String>> handler)` Remove and get the first element in a list
    `Observable<String>` | `lpopObservable(String key)` Remove and get the first element in a list
    `RedisTransaction` | `lpush(String key, String value, Handler<AsyncResult<String>> handler)` Prepend one value to a list
    `RedisTransaction` | `lpushMany(String key, List<String> values, Handler<AsyncResult<String>> handler)` Prepend one or multiple values to a list
    `Observable<String>` | `lpushManyObservable(String key, List<String> values)` Prepend one or multiple values to a list
    `Observable<String>` | `lpushObservable(String key, String value)` Prepend one value to a list
    `RedisTransaction` | `lpushx(String key, String value, Handler<AsyncResult<String>> handler)` Prepend a value to a list, only if the list exists
    `Observable<String>` | `lpushxObservable(String key, String value)` Prepend a value to a list, only if the list exists
    `RedisTransaction` | `lrange(String key, long from, long to, Handler<AsyncResult<String>> handler)` Get a range of elements from a list
    `Observable<String>` | `lrangeObservable(String key, long from, long to)` Get a range of elements from a list
    `RedisTransaction` | `lrem(String key, long count, String value, Handler<AsyncResult<String>> handler)` Remove elements from a list
    `Observable<String>` | `lremObservable(String key, long count, String value)` Remove elements from a list
    `RedisTransaction` | `lset(String key, long index, String value, Handler<AsyncResult<String>> handler)` Set the value of an element in a list by its index
    `Observable<String>` | `lsetObservable(String key, long index, String value)` Set the value of an element in a list by its index
    `RedisTransaction` | `ltrim(String key, long from, long to, Handler<AsyncResult<String>> handler)` Trim a list to the specified range
    `Observable<String>` | `ltrimObservable(String key, long from, long to)` Trim a list to the specified range
    `RedisTransaction` | `mget(String key, Handler<AsyncResult<String>> handler)` Get the value of the given key
    `RedisTransaction` | `mgetMany(List<String> keys, Handler<AsyncResult<String>> handler)` Get the values of all the given keys
    `Observable<String>` | `mgetManyObservable(List<String> keys)` Get the values of all the given keys
    `Observable<String>` | `mgetObservable(String key)` Get the value of the given key
    `RedisTransaction` | `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.
    `Observable<String>` | `migrateObservable(String host, int port, String key, int destdb, long timeout, MigrateOptions options)` Atomically transfer a key from a Redis instance to another one.
    `RedisTransaction` | `monitor(Handler<AsyncResult<String>> handler)` Listen for all requests received by the server in real time
    `Observable<String>` | `monitorObservable()` Listen for all requests received by the server in real time
    `RedisTransaction` | `move(String key, int destdb, Handler<AsyncResult<String>> handler)` Move a key to another database
    `Observable<String>` | `moveObservable(String key, int destdb)` Move a key to another database
    `RedisTransaction` | `mset(JsonObject keyvals, Handler<AsyncResult<String>> handler)` Set multiple keys to multiple values
    `RedisTransaction` | `msetnx(JsonObject keyvals, Handler<AsyncResult<String>> handler)` Set multiple keys to multiple values, only if none of the keys exist
    `Observable<String>` | `msetnxObservable(JsonObject keyvals)` Set multiple keys to multiple values, only if none of the keys exist
    `Observable<String>` | `msetObservable(JsonObject keyvals)` Set multiple keys to multiple values
    `RedisTransaction` | `multi(Handler<AsyncResult<String>> handler)` Mark the start of a RedisTransaction block
    `Observable<String>` | `multiObservable()` Mark the start of a RedisTransaction block
    `static RedisTransaction` | `newInstance(RedisTransaction arg)`
    `RedisTransaction` | `object(String key, ObjectCmd cmd, Handler<AsyncResult<String>> handler)` Inspect the internals of Redis objects
    `Observable<String>` | `objectObservable(String key, ObjectCmd cmd)` Inspect the internals of Redis objects
    `RedisTransaction` | `persist(String key, Handler<AsyncResult<String>> handler)` Remove the expiration from a key
    `Observable<String>` | `persistObservable(String key)` Remove the expiration from a key
    `RedisTransaction` | `pexpire(String key, long millis, Handler<AsyncResult<String>> handler)` Set a key's time to live in milliseconds
    `RedisTransaction` | `pexpireat(String key, long millis, Handler<AsyncResult<String>> handler)` Set the expiration for a key as a UNIX timestamp specified in milliseconds
    `Observable<String>` | `pexpireatObservable(String key, long millis)` Set the expiration for a key as a UNIX timestamp specified in milliseconds
    `Observable<String>` | `pexpireObservable(String key, long millis)` Set a key's time to live in milliseconds
    `RedisTransaction` | `pfadd(String key, String element, Handler<AsyncResult<String>> handler)` Adds the specified element to the specified HyperLogLog.
    `RedisTransaction` | `pfaddMany(String key, List<String> elements, Handler<AsyncResult<String>> handler)` Adds the specified elements to the specified HyperLogLog.
    `Observable<String>` | `pfaddManyObservable(String key, List<String> elements)` Adds the specified elements to the specified HyperLogLog.
    `Observable<String>` | `pfaddObservable(String key, String element)` Adds the specified element to the specified HyperLogLog.
    `RedisTransaction` | `pfcount(String key, Handler<AsyncResult<String>> handler)` Return the approximated cardinality of the set observed by the HyperLogLog at key.
    `RedisTransaction` | `pfcountMany(List<String> keys, Handler<AsyncResult<String>> handler)` Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).
    `Observable<String>` | `pfcountManyObservable(List<String> keys)` Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).
    `Observable<String>` | `pfcountObservable(String key)` Return the approximated cardinality of the set observed by the HyperLogLog at key.
    `RedisTransaction` | `pfmerge(String destkey, List<String> keys, Handler<AsyncResult<String>> handler)` Merge N different HyperLogLogs into a single one.
    `Observable<String>` | `pfmergeObservable(String destkey, List<String> keys)` Merge N different HyperLogLogs into a single one.
    `RedisTransaction` | `ping(Handler<AsyncResult<String>> handler)` Ping the server
    `Observable<String>` | `pingObservable()` Ping the server
    `RedisTransaction` | `psetex(String key, long millis, String value, Handler<AsyncResult<String>> handler)` Set the value and expiration in milliseconds of a key
    `Observable<String>` | `psetexObservable(String key, long millis, String value)` Set the value and expiration in milliseconds of a key
    `RedisTransaction` | `psubscribe(String pattern, Handler<AsyncResult<String>> handler)` Listen for messages published to channels matching the given pattern
    `RedisTransaction` | `psubscribeMany(List<String> patterns, Handler<AsyncResult<String>> handler)` Listen for messages published to channels matching the given patterns
    `Observable<String>` | `psubscribeManyObservable(List<String> patterns)` Listen for messages published to channels matching the given patterns
    `Observable<String>` | `psubscribeObservable(String pattern)` Listen for messages published to channels matching the given pattern
    `RedisTransaction` | `pttl(String key, Handler<AsyncResult<String>> handler)` Get the time to live for a key in milliseconds
    `Observable<String>` | `pttlObservable(String key)` Get the time to live for a key in milliseconds
    `RedisTransaction` | `publish(String channel, String message, Handler<AsyncResult<String>> handler)` Post a message to a channel
    `Observable<String>` | `publishObservable(String channel, String message)` Post a message to a channel
    `RedisTransaction` | `pubsubChannels(String pattern, Handler<AsyncResult<String>> handler)` Lists the currently active channels - only those matching the pattern
    `Observable<String>` | `pubsubChannelsObservable(String pattern)` Lists the currently active channels - only those matching the pattern
    `RedisTransaction` | `pubsubNumpat(Handler<AsyncResult<String>> handler)` Returns the number of subscriptions to patterns (that are performed using the PSUBSCRIBE command)
    `Observable<String>` | `pubsubNumpatObservable()` Returns the number of subscriptions to patterns (that are performed using the PSUBSCRIBE command)
    `RedisTransaction` | `pubsubNumsub(List<String> channels, Handler<AsyncResult<String>> handler)` Returns the number of subscribers (not counting clients subscribed to patterns) for the specified channels
    `Observable<String>` | `pubsubNumsubObservable(List<String> channels)` Returns the number of subscribers (not counting clients subscribed to patterns) for the specified channels
    `RedisTransaction` | `punsubscribe(List<String> patterns, Handler<AsyncResult<String>> handler)` Stop listening for messages posted to channels matching the given patterns
    `Observable<String>` | `punsubscribeObservable(List<String> patterns)` Stop listening for messages posted to channels matching the given patterns
    `RedisTransaction` | `randomkey(Handler<AsyncResult<String>> handler)` Return a random key from the keyspace
    `Observable<String>` | `randomkeyObservable()` Return a random key from the keyspace
    `RedisTransaction` | `rename(String key, String newkey, Handler<AsyncResult<String>> handler)` Rename a key
    `RedisTransaction` | `renamenx(String key, String newkey, Handler<AsyncResult<String>> handler)` Rename a key, only if the new key does not exist
    `Observable<String>` | `renamenxObservable(String key, String newkey)` Rename a key, only if the new key does not exist
    `Observable<String>` | `renameObservable(String key, String newkey)` Rename a key
    `RedisTransaction` | `restore(String key, long millis, String serialized, Handler<AsyncResult<String>> handler)` Create a key using the provided serialized value, previously obtained using DUMP.
    `Observable<String>` | `restoreObservable(String key, long millis, String serialized)` Create a key using the provided serialized value, previously obtained using DUMP.
    `RedisTransaction` | `role(Handler<AsyncResult<String>> handler)` Return the role of the instance in the context of replication
    `Observable<String>` | `roleObservable()` Return the role of the instance in the context of replication
    `RedisTransaction` | `rpop(String key, Handler<AsyncResult<String>> handler)` Remove and get the last element in a list
    `RedisTransaction` | `rpoplpush(String key, String destkey, Handler<AsyncResult<String>> handler)` Remove the last element in a list, append it to another list and return it
    `Observable<String>` | `rpoplpushObservable(String key, String destkey)` Remove the last element in a list, append it to another list and return it
    `Observable<String>` | `rpopObservable(String key)` Remove and get the last element in a list
    `RedisTransaction` | `rpush(String key, String value, Handler<AsyncResult<String>> handler)` Append one or multiple values to a list
    `RedisTransaction` | `rpushMany(String key, List<String> values, Handler<AsyncResult<String>> handler)` Append one or multiple values to a list
    `Observable<String>` | `rpushManyObservable(String key, List<String> values)` Append one or multiple values to a list
    `Observable<String>` | `rpushObservable(String key, String value)` Append one or multiple values to a list
    `RedisTransaction` | `rpushx(String key, String value, Handler<AsyncResult<String>> handler)` Append a value to a list, only if the list exists
    `Observable<String>` | `rpushxObservable(String key, String value)` Append a value to a list, only if the list exists
    `RedisTransaction` | `sadd(String key, String member, Handler<AsyncResult<String>> handler)` Add a member to a set
    `RedisTransaction` | `saddMany(String key, List<String> members, Handler<AsyncResult<String>> handler)` Add one or more members to a set
    `Observable<String>` | `saddManyObservable(String key, List<String> members)` Add one or more members to a set
    `Observable<String>` | `saddObservable(String key, String member)` Add a member to a set
    `RedisTransaction` | `save(Handler<AsyncResult<String>> handler)` Synchronously save the dataset to disk
    `Observable<String>` | `saveObservable()` Synchronously save the dataset to disk
    `RedisTransaction` | `scan(String cursor, ScanOptions options, Handler<AsyncResult<String>> handler)` Incrementally iterate the keys space
    `Observable<String>` | `scanObservable(String cursor, ScanOptions options)` Incrementally iterate the keys space
    `RedisTransaction` | `scard(String key, Handler<AsyncResult<String>> handler)` Get the number of members in a set
    `Observable<String>` | `scardObservable(String key)` Get the number of members in a set
    `RedisTransaction` | `scriptExists(String script, Handler<AsyncResult<String>> handler)` Check existence of script in the script cache.
    `RedisTransaction` | `scriptExistsMany(List<String> scripts, Handler<AsyncResult<String>> handler)` Check existence of scripts in the script cache.
    `Observable<String>` | `scriptExistsManyObservable(List<String> scripts)` Check existence of scripts in the script cache.
    `Observable<String>` | `scriptExistsObservable(String script)` Check existence of script in the script cache.
    `RedisTransaction` | `scriptFlush(Handler<AsyncResult<String>> handler)` Remove all the scripts from the script cache.
    `Observable<String>` | `scriptFlushObservable()` Remove all the scripts from the script cache.
    `RedisTransaction` | `scriptKill(Handler<AsyncResult<String>> handler)` Kill the script currently in execution.
    `Observable<String>` | `scriptKillObservable()` Kill the script currently in execution.
    `RedisTransaction` | `scriptLoad(String script, Handler<AsyncResult<String>> handler)` Load the specified Lua script into the script cache.
    `Observable<String>` | `scriptLoadObservable(String script)` Load the specified Lua script into the script cache.
    `RedisTransaction` | `sdiff(String key, List<String> cmpkeys, Handler<AsyncResult<String>> handler)` Subtract multiple sets
    `Observable<String>` | `sdiffObservable(String key, List<String> cmpkeys)` Subtract multiple sets
    `RedisTransaction` | `sdiffstore(String destkey, String key, List<String> cmpkeys, Handler<AsyncResult<String>> handler)` Subtract multiple sets and store the resulting set in a key
    `Observable<String>` | `sdiffstoreObservable(String destkey, String key, List<String> cmpkeys)` Subtract multiple sets and store the resulting set in a key
    `RedisTransaction` | `select(int dbindex, Handler<AsyncResult<String>> handler)` Change the selected database for the current connection
    `Observable<String>` | `selectObservable(int dbindex)` Change the selected database for the current connection
    `RedisTransaction` | `set(String key, String value, Handler<AsyncResult<String>> handler)` Set the string value of a key
    `RedisTransaction` | `setBinary(String key, Buffer value, Handler<AsyncResult<String>> handler)` Set the binary string value of a key - without encoding as utf-8
    `Observable<String>` | `setBinaryObservable(String key, Buffer value)` Set the binary string value of a key - without encoding as utf-8
    `RedisTransaction` | `setBinaryWithOptions(String key, Buffer value, SetOptions options, Handler<AsyncResult<String>> handler)` Set the string value of a key
    `Observable<String>` | `setBinaryWithOptionsObservable(String key, Buffer value, SetOptions options)` Set the string value of a key
    `RedisTransaction` | `setbit(String key, long offset, int bit, Handler<AsyncResult<String>> handler)` Sets or clears the bit at offset in the string value stored at key
    `Observable<String>` | `setbitObservable(String key, long offset, int bit)` Sets or clears the bit at offset in the string value stored at key
    `RedisTransaction` | `setex(String key, long seconds, String value, Handler<AsyncResult<String>> handler)` Set the value and expiration of a key
    `Observable<String>` | `setexObservable(String key, long seconds, String value)` Set the value and expiration of a key
    `RedisTransaction` | `setnx(String key, String value, Handler<AsyncResult<String>> handler)` Set the value of a key, only if the key does not exist
    `Observable<String>` | `setnxObservable(String key, String value)` Set the value of a key, only if the key does not exist
    `Observable<String>` | `setObservable(String key, String value)` Set the string value of a key
    `RedisTransaction` | `setrange(String key, int offset, String value, Handler<AsyncResult<String>> handler)` Overwrite part of a string at key starting at the specified offset
    `Observable<String>` | `setrangeObservable(String key, int offset, String value)` Overwrite part of a string at key starting at the specified offset
    `RedisTransaction` | `setWithOptions(String key, String value, SetOptions options, Handler<AsyncResult<String>> handler)` Set the string value of a key
    `Observable<String>` | `setWithOptionsObservable(String key, String value, SetOptions options)` Set the string value of a key
    `RedisTransaction` | `sinter(List<String> keys, Handler<AsyncResult<String>> handler)` Intersect multiple sets
    `Observable<String>` | `sinterObservable(List<String> keys)` Intersect multiple sets
    `RedisTransaction` | `sinterstore(String destkey, List<String> keys, Handler<AsyncResult<String>> handler)` Intersect multiple sets and store the resulting set in a key
    `Observable<String>` | `sinterstoreObservable(String destkey, List<String> keys)` Intersect multiple sets and store the resulting set in a key
    `RedisTransaction` | `sismember(String key, String member, Handler<AsyncResult<String>> handler)` Determine if a given value is a member of a set
    `Observable<String>` | `sismemberObservable(String key, String member)` Determine if a given value is a member of a set
    `RedisTransaction` | `slaveof(String host, int port, Handler<AsyncResult<String>> handler)` Make the server a slave of another instance
    `RedisTransaction` | `slaveofNoone(Handler<AsyncResult<String>> handler)` Make this server a master
    `Observable<String>` | `slaveofNooneObservable()` Make this server a master
    `Observable<String>` | `slaveofObservable(String host, int port)` Make the server a slave of another instance
    `RedisTransaction` | `slowlogGet(int limit, Handler<AsyncResult<String>> handler)` Read the Redis slow queries log
    `Observable<String>` | `slowlogGetObservable(int limit)` Read the Redis slow queries log
    `RedisTransaction` | `slowlogLen(Handler<AsyncResult<String>> handler)` Get the length of the Redis slow queries log
    `Observable<String>` | `slowlogLenObservable()` Get the length of the Redis slow queries log
    `RedisTransaction` | `slowlogReset(Handler<AsyncResult<String>> handler)` Reset the Redis slow queries log
    `Observable<String>` | `slowlogResetObservable()` Reset the Redis slow queries log
    `RedisTransaction` | `smembers(String key, Handler<AsyncResult<String>> handler)` Get all the members in a set
    `Observable<String>` | `smembersObservable(String key)` Get all the members in a set
    `RedisTransaction` | `smove(String key, String destkey, String member, Handler<AsyncResult<String>> handler)` Move a member from one set to another
    `Observable<String>` | `smoveObservable(String key, String destkey, String member)` Move a member from one set to another
    `RedisTransaction` | `sort(String key, SortOptions options, Handler<AsyncResult<String>> handler)` Sort the elements in a list, set or sorted set
    `Observable<String>` | `sortObservable(String key, SortOptions options)` Sort the elements in a list, set or sorted set
    `RedisTransaction` | `spop(String key, Handler<AsyncResult<String>> handler)` Remove and return a random member from a set
    `RedisTransaction` | `spopMany(String key, int count, Handler<AsyncResult<String>> handler)` Remove and return random members from a set
    `Observable<String>` | `spopManyObservable(String key, int count)` Remove and return random members from a set
    `Observable<String>` | `spopObservable(String key)` Remove and return a random member from a set
    `RedisTransaction` | `srandmember(String key, Handler<AsyncResult<String>> handler)` Get one or multiple random members from a set
    `RedisTransaction` | `srandmemberCount(String key, int count, Handler<AsyncResult<String>> handler)` Get one or multiple random members from a set
    `Observable<String>` | `srandmemberCountObservable(String key, int count)` Get one or multiple random members from a set
    `Observable<String>` | `srandmemberObservable(String key)` Get one or multiple random members from a set
    `RedisTransaction` | `srem(String key, String member, Handler<AsyncResult<String>> handler)` Remove one member from a set
    `RedisTransaction` | `sremMany(String key, List<String> members, Handler<AsyncResult<String>> handler)` Remove one or more members from a set
    `Observable<String>` | `sremManyObservable(String key, List<String> members)` Remove one or more members from a set
    `Observable<String>` | `sremObservable(String key, String member)` Remove one member from a set
    `RedisTransaction` | `sscan(String key, String cursor, ScanOptions options, Handler<AsyncResult<String>> handler)` Incrementally iterate Set elements
    `Observable<String>` | `sscanObservable(String key, String cursor, ScanOptions options)` Incrementally iterate Set elements
    `RedisTransaction` | `strlen(String key, Handler<AsyncResult<String>> handler)` Get the length of the value stored in a key
    `Observable<String>` | `strlenObservable(String key)` Get the length of the value stored in a key
    `RedisTransaction` | `subscribe(String channel, Handler<AsyncResult<String>> handler)` Listen for messages published to the given channels
    `RedisTransaction` | `subscribeMany(List<String> channels, Handler<AsyncResult<String>> handler)` Listen for messages published to the given channels
    `Observable<String>` | `subscribeManyObservable(List<String> channels)` Listen for messages published to the given channels
    `Observable<String>` | `subscribeObservable(String channel)` Listen for messages published to the given channels
    `RedisTransaction` | `sunion(List<String> keys, Handler<AsyncResult<String>> handler)` Add multiple sets
    `Observable<String>` | `sunionObservable(List<String> keys)` Add multiple sets
    `RedisTransaction` | `sunionstore(String destkey, List<String> keys, Handler<AsyncResult<String>> handler)` Add multiple sets and store the resulting set in a key
    `Observable<String>` | `sunionstoreObservable(String destkey, List<String> keys)` Add multiple sets and store the resulting set in a key
    `RedisTransaction` | `sync(Handler<AsyncResult<String>> handler)` Internal command used for replication
    `Observable<String>` | `syncObservable()` Internal command used for replication
    `RedisTransaction` | `time(Handler<AsyncResult<String>> handler)` Return the current server time
    `Observable<String>` | `timeObservable()` Return the current server time
    `RedisTransaction` | `ttl(String key, Handler<AsyncResult<String>> handler)` Get the time to live for a key
    `Observable<String>` | `ttlObservable(String key)` Get the time to live for a key
    `RedisTransaction` | `type(String key, Handler<AsyncResult<String>> handler)` Determine the type stored at key
    `Observable<String>` | `typeObservable(String key)` Determine the type stored at key
    `RedisTransaction` | `unsubscribe(List<String> channels, Handler<AsyncResult<String>> handler)` Stop listening for messages posted to the given channels
    `Observable<String>` | `unsubscribeObservable(List<String> channels)` Stop listening for messages posted to the given channels
    `RedisTransaction` | `unwatch(Handler<AsyncResult<String>> handler)` Forget about all watched keys
    `Observable<String>` | `unwatchObservable()` Forget about all watched keys
    `RedisTransaction` | `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.
    `Observable<String>` | `waitObservable(long numSlaves, long timeout)` Wait for the synchronous replication of all the write commands sent in the context of the current connection.
    `RedisTransaction` | `watch(String key, Handler<AsyncResult<String>> handler)` Watch the given keys to determine execution of the MULTI/EXEC block
    `RedisTransaction` | `watchMany(List<String> keys, Handler<AsyncResult<String>> handler)` Watch the given keys to determine execution of the MULTI/EXEC block
    `Observable<String>` | `watchManyObservable(List<String> keys)` Watch the given keys to determine execution of the MULTI/EXEC block
    `Observable<String>` | `watchObservable(String key)` Watch the given keys to determine execution of the MULTI/EXEC block
    `RedisTransaction` | `zadd(String key, double score, String member, Handler<AsyncResult<String>> handler)` Add one or more members to a sorted set, or update its score if it already exists
    `RedisTransaction` | `zaddMany(String key, Map<String,Double> members, Handler<AsyncResult<String>> handler)` Add one or more members to a sorted set, or update its score if it already exists
    `Observable<String>` | `zaddManyObservable(String key, Map<String,Double> members)` Add one or more members to a sorted set, or update its score if it already exists
    `Observable<String>` | `zaddObservable(String key, double score, String member)` Add one or more members to a sorted set, or update its score if it already exists
    `RedisTransaction` | `zcard(String key, Handler<AsyncResult<String>> handler)` Get the number of members in a sorted set
    `Observable<String>` | `zcardObservable(String key)` Get the number of members in a sorted set
    `RedisTransaction` | `zcount(String key, double min, double max, Handler<AsyncResult<String>> handler)` Count the members in a sorted set with scores within the given values
    `Observable<String>` | `zcountObservable(String key, double min, double max)` Count the members in a sorted set with scores within the given values
    `RedisTransaction` | `zincrby(String key, double increment, String member, Handler<AsyncResult<String>> handler)` Increment the score of a member in a sorted set
    `Observable<String>` | `zincrbyObservable(String key, double increment, String member)` Increment the score of a member in a sorted set
    `RedisTransaction` | `zinterstore(String destkey, List<String> sets, AggregateOptions options, Handler<AsyncResult<String>> handler)` Intersect multiple sorted sets and store the resulting sorted set in a new key
    `Observable<String>` | `zinterstoreObservable(String destkey, List<String> sets, AggregateOptions options)` Intersect multiple sorted sets and store the resulting sorted set in a new key
    `RedisTransaction` | `zinterstoreWeighed(String destkey, Map<String,Double> sets, AggregateOptions options, Handler<AsyncResult<String>> handler)` Intersect multiple sorted sets and store the resulting sorted set in a new key using weights for scoring
    `Observable<String>` | `zinterstoreWeighedObservable(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
    `RedisTransaction` | `zlexcount(String key, String min, String max, Handler<AsyncResult<String>> handler)` Count the number of members in a sorted set between a given lexicographical range
    `Observable<String>` | `zlexcountObservable(String key, String min, String max)` Count the number of members in a sorted set between a given lexicographical range
    `RedisTransaction` | `zrange(String key, long start, long stop, Handler<AsyncResult<String>> handler)` Return a range of members in a sorted set, by index
    `RedisTransaction` | `zrangebylex(String key, String min, String max, LimitOptions options, Handler<AsyncResult<String>> handler)` Return a range of members in a sorted set, by lexicographical range
    `Observable<String>` | `zrangebylexObservable(String key, String min, String max, LimitOptions options)` Return a range of members in a sorted set, by lexicographical range
    `RedisTransaction` | `zrangebyscore(String key, String min, String max, RangeLimitOptions options, Handler<AsyncResult<String>> handler)` Return a range of members in a sorted set, by score
    `Observable<String>` | `zrangebyscoreObservable(String key, String min, String max, RangeLimitOptions options)` Return a range of members in a sorted set, by score
    `Observable<String>` | `zrangeObservable(String key, long start, long stop)` Return a range of members in a sorted set, by index
    `RedisTransaction` | `zrangeWithOptions(String key, long start, long stop, RangeOptions options, Handler<AsyncResult<String>> handler)` Return a range of members in a sorted set, by index
    `Observable<String>` | `zrangeWithOptionsObservable(String key, long start, long stop, RangeOptions options)` Return a range of members in a sorted set, by index
    `RedisTransaction` | `zrank(String key, String member, Handler<AsyncResult<String>> handler)` Determine the index of a member in a sorted set
    `Observable<String>` | `zrankObservable(String key, String member)` Determine the index of a member in a sorted set
    `RedisTransaction` | `zrem(String key, String member, Handler<AsyncResult<String>> handler)` Remove one member from a sorted set
    `RedisTransaction` | `zremMany(String key, List<String> members, Handler<AsyncResult<String>> handler)` Remove one or more members from a sorted set
    `Observable<String>` | `zremManyObservable(String key, List<String> members)` Remove one or more members from a sorted set
    `Observable<String>` | `zremObservable(String key, String member)` Remove one member from a sorted set
    `RedisTransaction` | `zremrangebylex(String key, String min, String max, Handler<AsyncResult<String>> handler)` Remove all members in a sorted set between the given lexicographical range
    `Observable<String>` | `zremrangebylexObservable(String key, String min, String max)` Remove all members in a sorted set between the given lexicographical range
    `RedisTransaction` | `zremrangebyrank(String key, long start, long stop, Handler<AsyncResult<String>> handler)` Remove all members in a sorted set within the given indexes
    `Observable<String>` | `zremrangebyrankObservable(String key, long start, long stop)` Remove all members in a sorted set within the given indexes
    `RedisTransaction` | `zremrangebyscore(String key, String min, String max, Handler<AsyncResult<String>> handler)` Remove all members in a sorted set within the given scores
    `Observable<String>` | `zremrangebyscoreObservable(String key, String min, String max)` Remove all members in a sorted set within the given scores
    `RedisTransaction` | `zrevrange(String key, long start, long stop, RangeOptions options, Handler<AsyncResult<String>> handler)` Return a range of members in a sorted set, by index, with scores ordered from high to low
    `RedisTransaction` | `zrevrangebylex(String key, String max, String min, LimitOptions options, Handler<AsyncResult<String>> handler)` Return a range of members in a sorted set, by score, between the given lexicographical range with scores ordered from high to low
    `Observable<String>` | `zrevrangebylexObservable(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
    `RedisTransaction` | `zrevrangebyscore(String key, String max, String min, RangeLimitOptions options, Handler<AsyncResult<String>> handler)` Return a range of members in a sorted set, by score, with scores ordered from high to low
    `Observable<String>` | `zrevrangebyscoreObservable(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
    `Observable<String>` | `zrevrangeObservable(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
    `RedisTransaction` | `zrevrank(String key, String member, Handler<AsyncResult<String>> handler)` Determine the index of a member in a sorted set, with scores ordered from high to low
    `Observable<String>` | `zrevrankObservable(String key, String member)` Determine the index of a member in a sorted set, with scores ordered from high to low
    `RedisTransaction` | `zscan(String key, String cursor, ScanOptions options, Handler<AsyncResult<String>> handler)` Incrementally iterate sorted sets elements and associated scores
    `Observable<String>` | `zscanObservable(String key, String cursor, ScanOptions options)` Incrementally iterate sorted sets elements and associated scores
    `RedisTransaction` | `zscore(String key, String member, Handler<AsyncResult<String>> handler)` Get the score associated with the given member in a sorted set
    `Observable<String>` | `zscoreObservable(String key, String member)` Get the score associated with the given member in a sorted set
    `RedisTransaction` | `zunionstore(String destkey, List<String> sets, AggregateOptions options, Handler<AsyncResult<String>> handler)` Add multiple sorted sets and store the resulting sorted set in a new key
    `Observable<String>` | `zunionstoreObservable(String destkey, List<String> sets, AggregateOptions options)` Add multiple sorted sets and store the resulting sorted set in a new key
    `RedisTransaction` | `zunionstoreWeighed(String key, Map<String,Double> sets, AggregateOptions options, Handler<AsyncResult<String>> handler)` Add multiple sorted sets using weights, and store the resulting sorted set in a new key
    `Observable<String>` | `zunionstoreWeighedObservable(String key, Map<String,Double> sets, AggregateOptions options)` Add multiple sorted sets using weights, and store the resulting sorted set in a new key

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Constructor Detail

    - #### RedisTransaction

          public RedisTransaction(RedisTransaction delegate)

  - ### Method Detail

    - #### getDelegate

          public Object getDelegate()

    - #### close

          public void close(Handler<AsyncResult<Void>> handler)

      Close the client - when it is fully closed the handler will be called.
      Parameters:
        `handler` -

    - #### closeObservable

          public Observable<Void> closeObservable()

      Close the client - when it is fully closed the handler will be called.
      Returns:

    - #### append

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

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

    - #### appendObservable

          public Observable<String> appendObservable(String key,
                                                     String value)

      Append a value to a key
      Parameters:
        `key` - Key string
        `value` - Value to append
      Returns:

    - #### auth

          public RedisTransaction 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:

    - #### authObservable

          public Observable<String> authObservable(String password)

      Authenticate to the server
      Parameters:
        `password` - Password for authentication
      Returns:

    - #### bgrewriteaof

          public RedisTransaction bgrewriteaof(Handler<AsyncResult<String>> handler)

      Asynchronously rewrite the append-only file
      Parameters:
        `handler` -
      Returns:

    - #### bgrewriteaofObservable

          public Observable<String> bgrewriteaofObservable()

      Asynchronously rewrite the append-only file
      Returns:

    - #### bgsave

          public RedisTransaction bgsave(Handler<AsyncResult<String>> handler)

      Asynchronously save the dataset to disk
      Parameters:
        `handler` -
      Returns:

    - #### bgsaveObservable

          public Observable<String> bgsaveObservable()

      Asynchronously save the dataset to disk
      Returns:

    - #### bitcount

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

      Count set bits in a string
      Parameters:
        `key` - Key string
        `handler` - Handler for the result of this call.
      Returns:

    - #### bitcountObservable

          public Observable<String> bitcountObservable(String key)

      Count set bits in a string
      Parameters:
        `key` - Key string
      Returns:

    - #### bitcountRange

          public RedisTransaction bitcountRange(String key,
                                                long start,
                                                long end,
                                                Handler<AsyncResult<String>> 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:

    - #### bitcountRangeObservable

          public Observable<String> bitcountRangeObservable(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 RedisTransaction bitop(BitOperation operation,
                                        String destkey,
                                        List<String> keys,
                                        Handler<AsyncResult<String>> 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:

    - #### bitopObservable

          public Observable<String> bitopObservable(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 RedisTransaction bitpos(String key,
                                         int bit,
                                         Handler<AsyncResult<String>> 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:

    - #### bitposObservable

          public Observable<String> bitposObservable(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 RedisTransaction bitposFrom(String key,
                                             int bit,
                                             int start,
                                             Handler<AsyncResult<String>> 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:

    - #### bitposFromObservable

          public Observable<String> bitposFromObservable(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 RedisTransaction bitposRange(String key,
                                              int bit,
                                              int start,
                                              int stop,
                                              Handler<AsyncResult<String>> 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:

    - #### bitposRangeObservable

          public Observable<String> bitposRangeObservable(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 RedisTransaction blpop(String key,
                                        int seconds,
                                        Handler<AsyncResult<String>> 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:

    - #### blpopObservable

          public Observable<String> blpopObservable(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 RedisTransaction blpopMany(List<String> keys,
                                            int seconds,
                                            Handler<AsyncResult<String>> 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:

    - #### blpopManyObservable

          public Observable<String> blpopManyObservable(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 RedisTransaction brpop(String key,
                                        int seconds,
                                        Handler<AsyncResult<String>> 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:

    - #### brpopObservable

          public Observable<String> brpopObservable(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 RedisTransaction brpopMany(List<String> keys,
                                            int seconds,
                                            Handler<AsyncResult<String>> 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:

    - #### brpopManyObservable

          public Observable<String> brpopManyObservable(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 RedisTransaction 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:

    - #### brpoplpushObservable

          public Observable<String> brpoplpushObservable(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 RedisTransaction clientKill(KillFilter filter,
                                             Handler<AsyncResult<String>> handler)

      Kill the connection of a client
      Parameters:
        `filter` - Filter options
        `handler` - Handler for the result of this call.
      Returns:

    - #### clientKillObservable

          public Observable<String> clientKillObservable(KillFilter filter)

      Kill the connection of a client
      Parameters:
        `filter` - Filter options
      Returns:

    - #### clientList

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

      Get the list of client connections
      Parameters:
        `handler` -
      Returns:

    - #### clientListObservable

          public Observable<String> clientListObservable()

      Get the list of client connections
      Returns:

    - #### clientGetname

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

      Get the current connection name
      Parameters:
        `handler` -
      Returns:

    - #### clientGetnameObservable

          public Observable<String> clientGetnameObservable()

      Get the current connection name
      Returns:

    - #### clientPause

          public RedisTransaction 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:

    - #### clientPauseObservable

          public Observable<String> clientPauseObservable(long millis)

      Stop processing commands from clients for some time
      Parameters:
        `millis` - Pause time in milliseconds
      Returns:

    - #### clientSetname

          public RedisTransaction 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:

    - #### clientSetnameObservable

          public Observable<String> clientSetnameObservable(String name)

      Set the current connection name
      Parameters:
        `name` - New name for current connection
      Returns:

    - #### clusterAddslots

          public RedisTransaction clusterAddslots(List<String> slots,
                                                  Handler<AsyncResult<String>> handler)

      Assign new hash slots to receiving node.
      Parameters:
        `slots` -
        `handler` - Handler for the result of this call.
      Returns:

    - #### clusterAddslotsObservable

          public Observable<String> clusterAddslotsObservable(List<String> slots)

      Assign new hash slots to receiving node.
      Parameters:
        `slots` -
      Returns:

    - #### clusterCountFailureReports

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

      Return the number of failure reports active for a given node.
      Parameters:
        `nodeId` -
        `handler` - Handler for the result of this call.
      Returns:

    - #### clusterCountFailureReportsObservable

          public Observable<String> clusterCountFailureReportsObservable(String nodeId)

      Return the number of failure reports active for a given node.
      Parameters:
        `nodeId` -
      Returns:

    - #### clusterCountkeysinslot

          public RedisTransaction clusterCountkeysinslot(long slot,
                                                         Handler<AsyncResult<String>> handler)

      Return the number of local keys in the specified hash slot.
      Parameters:
        `slot` -
        `handler` - Handler for the result of this call.
      Returns:

    - #### clusterCountkeysinslotObservable

          public Observable<String> clusterCountkeysinslotObservable(long slot)

      Return the number of local keys in the specified hash slot.
      Parameters:
        `slot` -
      Returns:

    - #### clusterDelslots

          public RedisTransaction clusterDelslots(long slot,
                                                  Handler<AsyncResult<String>> handler)

      Set hash slots as unbound in receiving node.
      Parameters:
        `slot` -
        `handler` - Handler for the result of this call.
      Returns:

    - #### clusterDelslotsObservable

          public Observable<String> clusterDelslotsObservable(long slot)

      Set hash slots as unbound in receiving node.
      Parameters:
        `slot` -
      Returns:

    - #### clusterDelslotsMany

          public RedisTransaction clusterDelslotsMany(List<String> slots,
                                                      Handler<AsyncResult<String>> handler)

      Set hash slots as unbound in receiving node.
      Parameters:
        `slots` -
        `handler` - Handler for the result of this call.
      Returns:

    - #### clusterDelslotsManyObservable

          public Observable<String> clusterDelslotsManyObservable(List<String> slots)

      Set hash slots as unbound in receiving node.
      Parameters:
        `slots` -
      Returns:

    - #### clusterFailover

          public RedisTransaction clusterFailover(Handler<AsyncResult<String>> handler)

      Forces a slave to perform a manual failover of its master.
      Parameters:
        `handler` - Handler for the result of this call.
      Returns:

    - #### clusterFailoverObservable

          public Observable<String> clusterFailoverObservable()

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

    - #### clusterFailOverWithOptions

          public RedisTransaction clusterFailOverWithOptions(FailoverOptions options,
                                                             Handler<AsyncResult<String>> handler)

      Forces a slave to perform a manual failover of its master.
      Parameters:
        `options` -
        `handler` - Handler for the result of this call.
      Returns:

    - #### clusterFailOverWithOptionsObservable

          public Observable<String> clusterFailOverWithOptionsObservable(FailoverOptions options)

      Forces a slave to perform a manual failover of its master.
      Parameters:
        `options` -
      Returns:

    - #### clusterForget

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

      Remove a node from the nodes table.
      Parameters:
        `nodeId` -
        `handler` - Handler for the result of this call.
      Returns:

    - #### clusterForgetObservable

          public Observable<String> clusterForgetObservable(String nodeId)

      Remove a node from the nodes table.
      Parameters:
        `nodeId` -
      Returns:

    - #### clusterGetkeysinslot

          public RedisTransaction clusterGetkeysinslot(long slot,
                                                       long count,
                                                       Handler<AsyncResult<String>> handler)

      Return local key names in the specified hash slot.
      Parameters:
        `slot` -
        `count` -
        `handler` - Handler for the result of this call.
      Returns:

    - #### clusterGetkeysinslotObservable

          public Observable<String> clusterGetkeysinslotObservable(long slot,
                                                                   long count)

      Return local key names in the specified hash slot.
      Parameters:
        `slot` -
        `count` -
      Returns:

    - #### clusterInfo

          public RedisTransaction clusterInfo(Handler<AsyncResult<String>> handler)

      Provides info about Redis Cluster node state.
      Parameters:
        `handler` - Handler for the result of this call.
      Returns:

    - #### clusterInfoObservable

          public Observable<String> clusterInfoObservable()

      Provides info about Redis Cluster node state.
      Returns:

    - #### clusterKeyslot

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

      Returns the hash slot of the specified key.
      Parameters:
        `key` -
        `handler` - Handler for the result of this call.
      Returns:

    - #### clusterKeyslotObservable

          public Observable<String> clusterKeyslotObservable(String key)

      Returns the hash slot of the specified key.
      Parameters:
        `key` -
      Returns:

    - #### clusterMeet

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

      Force a node cluster to handshake with another node.
      Parameters:
        `ip` -
        `port` -
        `handler` - Handler for the result of this call.
      Returns:

    - #### clusterMeetObservable

          public Observable<String> clusterMeetObservable(String ip,
                                                          long port)

      Force a node cluster to handshake with another node.
      Parameters:
        `ip` -
        `port` -
      Returns:

    - #### clusterNodes

          public RedisTransaction clusterNodes(Handler<AsyncResult<String>> handler)

      Get Cluster config for the node.
      Parameters:
        `handler` - Handler for the result of this call.
      Returns:

    - #### clusterNodesObservable

          public Observable<String> clusterNodesObservable()

      Get Cluster config for the node.
      Returns:

    - #### clusterReplicate

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

      Reconfigure a node as a slave of the specified master node.
      Parameters:
        `nodeId` -
        `handler` - Handler for the result of this call.
      Returns:

    - #### clusterReplicateObservable

          public Observable<String> clusterReplicateObservable(String nodeId)

      Reconfigure a node as a slave of the specified master node.
      Parameters:
        `nodeId` -
      Returns:

    - #### clusterReset

          public RedisTransaction clusterReset(Handler<AsyncResult<String>> handler)

      Reset a Redis Cluster node.
      Parameters:
        `handler` - Handler for the result of this call.
      Returns:

    - #### clusterResetObservable

          public Observable<String> clusterResetObservable()

      Reset a Redis Cluster node.
      Returns:

    - #### clusterResetWithOptions

          public RedisTransaction clusterResetWithOptions(ResetOptions options,
                                                          Handler<AsyncResult<String>> handler)

      Reset a Redis Cluster node.
      Parameters:
        `options` -
        `handler` - Handler for the result of this call.
      Returns:

    - #### clusterResetWithOptionsObservable

          public Observable<String> clusterResetWithOptionsObservable(ResetOptions options)

      Reset a Redis Cluster node.
      Parameters:
        `options` -
      Returns:

    - #### clusterSaveconfig

          public RedisTransaction clusterSaveconfig(Handler<AsyncResult<String>> handler)

      Forces the node to save cluster state on disk.
      Parameters:
        `handler` - Handler for the result of this call.
      Returns:

    - #### clusterSaveconfigObservable

          public Observable<String> clusterSaveconfigObservable()

      Forces the node to save cluster state on disk.
      Returns:

    - #### clusterSetConfigEpoch

          public RedisTransaction clusterSetConfigEpoch(long epoch,
                                                        Handler<AsyncResult<String>> handler)

      Set the configuration epoch in a new node.
      Parameters:
        `epoch` -
        `handler` - Handler for the result of this call.
      Returns:

    - #### clusterSetConfigEpochObservable

          public Observable<String> clusterSetConfigEpochObservable(long epoch)

      Set the configuration epoch in a new node.
      Parameters:
        `epoch` -
      Returns:

    - #### clusterSetslot

          public RedisTransaction clusterSetslot(long slot,
                                                 SlotCmd subcommand,
                                                 Handler<AsyncResult<String>> handler)

      Bind an hash slot to a specific node.
      Parameters:
        `slot` -
        `subcommand` -
        `handler` - Handler for the result of this call.
      Returns:

    - #### clusterSetslotObservable

          public Observable<String> clusterSetslotObservable(long slot,
                                                             SlotCmd subcommand)

      Bind an hash slot to a specific node.
      Parameters:
        `slot` -
        `subcommand` -
      Returns:

    - #### clusterSetslotWithNode

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

      Bind an hash slot to a specific node.
      Parameters:
        `slot` -
        `subcommand` -
        `nodeId` -
        `handler` - Handler for the result of this call.
      Returns:

    - #### clusterSetslotWithNodeObservable

          public Observable<String> clusterSetslotWithNodeObservable(long slot,
                                                                     SlotCmd subcommand,
                                                                     String nodeId)

      Bind an hash slot to a specific node.
      Parameters:
        `slot` -
        `subcommand` -
        `nodeId` -
      Returns:

    - #### clusterSlaves

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

      List slave nodes of the specified master node.
      Parameters:
        `nodeId` -
        `handler` - Handler for the result of this call.
      Returns:

    - #### clusterSlavesObservable

          public Observable<String> clusterSlavesObservable(String nodeId)

      List slave nodes of the specified master node.
      Parameters:
        `nodeId` -
      Returns:

    - #### clusterSlots

          public RedisTransaction clusterSlots(Handler<AsyncResult<String>> handler)

      Get array of Cluster slot to node mappings
      Parameters:
        `handler` -
      Returns:

    - #### clusterSlotsObservable

          public Observable<String> clusterSlotsObservable()

      Get array of Cluster slot to node mappings
      Returns:

    - #### command

          public RedisTransaction command(Handler<AsyncResult<String>> handler)

      Get array of Redis command details
      Parameters:
        `handler` -
      Returns:

    - #### commandObservable

          public Observable<String> commandObservable()

      Get array of Redis command details
      Returns:

    - #### commandCount

          public RedisTransaction commandCount(Handler<AsyncResult<String>> handler)

      Get total number of Redis commands
      Parameters:
        `handler` -
      Returns:

    - #### commandCountObservable

          public Observable<String> commandCountObservable()

      Get total number of Redis commands
      Returns:

    - #### commandGetkeys

          public RedisTransaction commandGetkeys(Handler<AsyncResult<String>> handler)

      Extract keys given a full Redis command
      Parameters:
        `handler` -
      Returns:

    - #### commandGetkeysObservable

          public Observable<String> commandGetkeysObservable()

      Extract keys given a full Redis command
      Returns:

    - #### commandInfo

          public RedisTransaction commandInfo(List<String> commands,
                                              Handler<AsyncResult<String>> 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:

    - #### commandInfoObservable

          public Observable<String> commandInfoObservable(List<String> commands)

      Get array of specific Redis command details
      Parameters:
        `commands` - List of commands to get info for
      Returns:

    - #### configGet

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

      Get the value of a configuration parameter
      Parameters:
        `parameter` - Configuration parameter
        `handler` - Handler for the result of this call.
      Returns:

    - #### configGetObservable

          public Observable<String> configGetObservable(String parameter)

      Get the value of a configuration parameter
      Parameters:
        `parameter` - Configuration parameter
      Returns:

    - #### configRewrite

          public RedisTransaction configRewrite(Handler<AsyncResult<String>> handler)

      Rewrite the configuration file with the in memory configuration
      Parameters:
        `handler` -
      Returns:

    - #### configRewriteObservable

          public Observable<String> configRewriteObservable()

      Rewrite the configuration file with the in memory configuration
      Returns:

    - #### configSet

          public RedisTransaction 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:

    - #### configSetObservable

          public Observable<String> configSetObservable(String parameter,
                                                        String value)

      Set a configuration parameter to the given value
      Parameters:
        `parameter` - Configuration parameter
        `value` - New value
      Returns:

    - #### configResetstat

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

      Reset the stats returned by INFO
      Parameters:
        `handler` -
      Returns:

    - #### configResetstatObservable

          public Observable<String> configResetstatObservable()

      Reset the stats returned by INFO
      Returns:

    - #### dbsize

          public RedisTransaction dbsize(Handler<AsyncResult<String>> handler)

      Return the number of keys in the selected database
      Parameters:
        `handler` -
      Returns:

    - #### dbsizeObservable

          public Observable<String> dbsizeObservable()

      Return the number of keys in the selected database
      Returns:

    - #### debugObject

          public RedisTransaction 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:

    - #### debugObjectObservable

          public Observable<String> debugObjectObservable(String key)

      Get debugging information about a key
      Parameters:
        `key` - Key string
      Returns:

    - #### debugSegfault

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

      Make the server crash
      Parameters:
        `handler` -
      Returns:

    - #### debugSegfaultObservable

          public Observable<String> debugSegfaultObservable()

      Make the server crash
      Returns:

    - #### decr

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

      Decrement the integer value of a key by one
      Parameters:
        `key` - Key string
        `handler` - Handler for the result of this call.
      Returns:

    - #### decrObservable

          public Observable<String> decrObservable(String key)

      Decrement the integer value of a key by one
      Parameters:
        `key` - Key string
      Returns:

    - #### decrby

          public RedisTransaction decrby(String key,
                                         long decrement,
                                         Handler<AsyncResult<String>> 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:

    - #### decrbyObservable

          public Observable<String> decrbyObservable(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 RedisTransaction del(String key,
                                      Handler<AsyncResult<String>> handler)

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

    - #### delObservable

          public Observable<String> delObservable(String key)

      Delete a key
      Parameters:
        `key` - Keys to delete
      Returns:

    - #### delMany

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

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

    - #### delManyObservable

          public Observable<String> delManyObservable(List<String> keys)

      Delete many keys
      Parameters:
        `keys` - List of keys to delete
      Returns:

    - #### discard

          public RedisTransaction discard(Handler<AsyncResult<String>> handler)

      Discard all commands issued after MULTI
      Parameters:
        `handler` -
      Returns:

    - #### discardObservable

          public Observable<String> discardObservable()

      Discard all commands issued after MULTI
      Returns:

    - #### dump

          public RedisTransaction 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:

    - #### dumpObservable

          public Observable<String> dumpObservable(String key)

      Return a serialized version of the value stored at the specified key.
      Parameters:
        `key` - Key string
      Returns:

    - #### echo

          public RedisTransaction 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:

    - #### echoObservable

          public Observable<String> echoObservable(String message)

      Echo the given string
      Parameters:
        `message` - String to echo
      Returns:

    - #### eval

          public RedisTransaction eval(String script,
                                       List<String> keys,
                                       List<String> args,
                                       Handler<AsyncResult<String>> 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:

    - #### evalObservable

          public Observable<String> evalObservable(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 RedisTransaction evalsha(String sha1,
                                          List<String> keys,
                                          List<String> values,
                                          Handler<AsyncResult<String>> 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:

    - #### evalshaObservable

          public Observable<String> evalshaObservable(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:

    - #### exec

          public RedisTransaction exec(Handler<AsyncResult<JsonArray>> handler)

      Execute all commands issued after MULTI
      Parameters:
        `handler` -
      Returns:

    - #### execObservable

          public Observable<JsonArray> execObservable()

      Execute all commands issued after MULTI
      Returns:

    - #### exists

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

      Determine if a key exists
      Parameters:
        `key` - Key string
        `handler` - Handler for the result of this call.
      Returns:

    - #### existsObservable

          public Observable<String> existsObservable(String key)

      Determine if a key exists
      Parameters:
        `key` - Key string
      Returns:

    - #### expire

          public RedisTransaction expire(String key,
                                         int seconds,
                                         Handler<AsyncResult<String>> 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:

    - #### expireObservable

          public Observable<String> expireObservable(String key,
                                                     int seconds)

      Set a key's time to live in seconds
      Parameters:
        `key` - Key string
        `seconds` - Time to live in seconds
      Returns:

    - #### expireat

          public RedisTransaction expireat(String key,
                                           long seconds,
                                           Handler<AsyncResult<String>> 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:

    - #### expireatObservable

          public Observable<String> expireatObservable(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 RedisTransaction flushall(Handler<AsyncResult<String>> handler)

      Remove all keys from all databases
      Parameters:
        `handler` -
      Returns:

    - #### flushallObservable

          public Observable<String> flushallObservable()

      Remove all keys from all databases
      Returns:

    - #### flushdb

          public RedisTransaction flushdb(Handler<AsyncResult<String>> handler)

      Remove all keys from the current database
      Parameters:
        `handler` -
      Returns:

    - #### flushdbObservable

          public Observable<String> flushdbObservable()

      Remove all keys from the current database
      Returns:

    - #### get

          public RedisTransaction 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:

    - #### getObservable

          public Observable<String> getObservable(String key)

      Get the value of a key
      Parameters:
        `key` - Key string
      Returns:

    - #### getBinary

          public RedisTransaction getBinary(String key,
                                            Handler<AsyncResult<String>> 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:

    - #### getBinaryObservable

          public Observable<String> getBinaryObservable(String key)

      Get the value of a key - without decoding as utf-8
      Parameters:
        `key` - Key string
      Returns:

    - #### getbit

          public RedisTransaction getbit(String key,
                                         long offset,
                                         Handler<AsyncResult<String>> 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:

    - #### getbitObservable

          public Observable<String> getbitObservable(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 RedisTransaction 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:

    - #### getrangeObservable

          public Observable<String> getrangeObservable(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 RedisTransaction 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:

    - #### getsetObservable

          public Observable<String> getsetObservable(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 RedisTransaction hdel(String key,
                                       String field,
                                       Handler<AsyncResult<String>> handler)

      Delete one or more hash fields
      Parameters:
        `key` - Key string
        `field` - Field name
        `handler` - Handler for the result of this call.
      Returns:

    - #### hdelObservable

          public Observable<String> hdelObservable(String key,
                                                   String field)

      Delete one or more hash fields
      Parameters:
        `key` - Key string
        `field` - Field name
      Returns:

    - #### hdelMany

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

      Delete one or more hash fields
      Parameters:
        `key` - Key string
        `fields` - Field names
        `handler` - Handler for the result of this call.
      Returns:

    - #### hdelManyObservable

          public Observable<String> hdelManyObservable(String key,
                                                       List<String> fields)

      Delete one or more hash fields
      Parameters:
        `key` - Key string
        `fields` - Field names
      Returns:

    - #### hexists

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

      Determine if a hash field exists
      Parameters:
        `key` - Key string
        `field` - Field name
        `handler` - Handler for the result of this call.
      Returns:

    - #### hexistsObservable

          public Observable<String> hexistsObservable(String key,
                                                      String field)

      Determine if a hash field exists
      Parameters:
        `key` - Key string
        `field` - Field name
      Returns:

    - #### hget

          public RedisTransaction 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:

    - #### hgetObservable

          public Observable<String> hgetObservable(String key,
                                                   String field)

      Get the value of a hash field
      Parameters:
        `key` - Key string
        `field` - Field name
      Returns:

    - #### hgetall

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

      Get all the fields and values in a hash
      Parameters:
        `key` - Key string
        `handler` - Handler for the result of this call.
      Returns:

    - #### hgetallObservable

          public Observable<String> hgetallObservable(String key)

      Get all the fields and values in a hash
      Parameters:
        `key` - Key string
      Returns:

    - #### hincrby

          public RedisTransaction hincrby(String key,
                                          String field,
                                          long increment,
                                          Handler<AsyncResult<String>> 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:

    - #### hincrbyObservable

          public Observable<String> hincrbyObservable(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 RedisTransaction 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:

    - #### hincrbyfloatObservable

          public Observable<String> hincrbyfloatObservable(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 RedisTransaction hkeys(String key,
                                        Handler<AsyncResult<String>> handler)

      Get all the fields in a hash
      Parameters:
        `key` - Key string
        `handler` - Handler for the result of this call.
      Returns:

    - #### hkeysObservable

          public Observable<String> hkeysObservable(String key)

      Get all the fields in a hash
      Parameters:
        `key` - Key string
      Returns:

    - #### hlen

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

      Get the number of fields in a hash
      Parameters:
        `key` - Key string
        `handler` - Handler for the result of this call.
      Returns:

    - #### hlenObservable

          public Observable<String> hlenObservable(String key)

      Get the number of fields in a hash
      Parameters:
        `key` - Key string
      Returns:

    - #### hmget

          public RedisTransaction hmget(String key,
                                        List<String> fields,
                                        Handler<AsyncResult<String>> 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:

    - #### hmgetObservable

          public Observable<String> hmgetObservable(String key,
                                                    List<String> fields)

      Get the values of all the given hash fields
      Parameters:
        `key` - Key string
        `fields` - Field names
      Returns:

    - #### hmset

          public RedisTransaction 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:

    - #### hmsetObservable

          public Observable<String> hmsetObservable(String key,
                                                    JsonObject values)

      Set multiple hash fields to multiple values
      Parameters:
        `key` - Key string
        `values` - Map of field:value pairs
      Returns:

    - #### hset

          public RedisTransaction hset(String key,
                                       String field,
                                       String value,
                                       Handler<AsyncResult<String>> 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:

    - #### hsetObservable

          public Observable<String> hsetObservable(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 RedisTransaction hsetnx(String key,
                                         String field,
                                         String value,
                                         Handler<AsyncResult<String>> 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:

    - #### hsetnxObservable

          public Observable<String> hsetnxObservable(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 RedisTransaction hvals(String key,
                                        Handler<AsyncResult<String>> handler)

      Get all the values in a hash
      Parameters:
        `key` - Key string
        `handler` - Handler for the result of this call.
      Returns:

    - #### hvalsObservable

          public Observable<String> hvalsObservable(String key)

      Get all the values in a hash
      Parameters:
        `key` - Key string
      Returns:

    - #### incr

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

      Increment the integer value of a key by one
      Parameters:
        `key` - Key string
        `handler` - Handler for the result of this call.
      Returns:

    - #### incrObservable

          public Observable<String> incrObservable(String key)

      Increment the integer value of a key by one
      Parameters:
        `key` - Key string
      Returns:

    - #### incrby

          public RedisTransaction incrby(String key,
                                         long increment,
                                         Handler<AsyncResult<String>> 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:

    - #### incrbyObservable

          public Observable<String> incrbyObservable(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 RedisTransaction 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:

    - #### incrbyfloatObservable

          public Observable<String> incrbyfloatObservable(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 RedisTransaction info(Handler<AsyncResult<String>> handler)

      Get information and statistics about the server
      Parameters:
        `handler` - Handler for the result of this call.
      Returns:

    - #### infoObservable

          public Observable<String> infoObservable()

      Get information and statistics about the server
      Returns:

    - #### infoSection

          public RedisTransaction infoSection(String section,
                                              Handler<AsyncResult<String>> 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:

    - #### infoSectionObservable

          public Observable<String> infoSectionObservable(String section)

      Get information and statistics about the server
      Parameters:
        `section` - Specific section of information to return
      Returns:

    - #### keys

          public RedisTransaction keys(String pattern,
                                       Handler<AsyncResult<String>> 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:

    - #### keysObservable

          public Observable<String> keysObservable(String pattern)

      Find all keys matching the given pattern
      Parameters:
        `pattern` - Pattern to limit the keys returned
      Returns:

    - #### lastsave

          public RedisTransaction lastsave(Handler<AsyncResult<String>> handler)

      Get the UNIX time stamp of the last successful save to disk
      Parameters:
        `handler` -
      Returns:

    - #### lastsaveObservable

          public Observable<String> lastsaveObservable()

      Get the UNIX time stamp of the last successful save to disk
      Returns:

    - #### lindex

          public RedisTransaction 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:

    - #### lindexObservable

          public Observable<String> lindexObservable(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 RedisTransaction linsert(String key,
                                          InsertOptions option,
                                          String pivot,
                                          String value,
                                          Handler<AsyncResult<String>> 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:

    - #### linsertObservable

          public Observable<String> linsertObservable(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 RedisTransaction llen(String key,
                                       Handler<AsyncResult<String>> handler)

      Get the length of a list
      Parameters:
        `key` - String key
        `handler` - Handler for the result of this call.
      Returns:

    - #### llenObservable

          public Observable<String> llenObservable(String key)

      Get the length of a list
      Parameters:
        `key` - String key
      Returns:

    - #### lpop

          public RedisTransaction 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:

    - #### lpopObservable

          public Observable<String> lpopObservable(String key)

      Remove and get the first element in a list
      Parameters:
        `key` - String key
      Returns:

    - #### lpushMany

          public RedisTransaction lpushMany(String key,
                                            List<String> values,
                                            Handler<AsyncResult<String>> 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:

    - #### lpushManyObservable

          public Observable<String> lpushManyObservable(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 RedisTransaction lpush(String key,
                                        String value,
                                        Handler<AsyncResult<String>> 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:

    - #### lpushObservable

          public Observable<String> lpushObservable(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 RedisTransaction lpushx(String key,
                                         String value,
                                         Handler<AsyncResult<String>> 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:

    - #### lpushxObservable

          public Observable<String> lpushxObservable(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 RedisTransaction lrange(String key,
                                         long from,
                                         long to,
                                         Handler<AsyncResult<String>> 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:

    - #### lrangeObservable

          public Observable<String> lrangeObservable(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 RedisTransaction lrem(String key,
                                       long count,
                                       String value,
                                       Handler<AsyncResult<String>> 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:

    - #### lremObservable

          public Observable<String> lremObservable(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 RedisTransaction 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:

    - #### lsetObservable

          public Observable<String> lsetObservable(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 RedisTransaction 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:

    - #### ltrimObservable

          public Observable<String> ltrimObservable(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 RedisTransaction mget(String key,
                                       Handler<AsyncResult<String>> handler)

      Get the value of the given key
      Parameters:
        `key` - Key string
        `handler` - Handler for the result of this call.
      Returns:

    - #### mgetObservable

          public Observable<String> mgetObservable(String key)

      Get the value of the given key
      Parameters:
        `key` - Key string
      Returns:

    - #### mgetMany

          public RedisTransaction mgetMany(List<String> keys,
                                           Handler<AsyncResult<String>> 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:

    - #### mgetManyObservable

          public Observable<String> mgetManyObservable(List<String> keys)

      Get the values of all the given keys
      Parameters:
        `keys` - List of keys to get
      Returns:

    - #### migrate

          public RedisTransaction 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:

    - #### migrateObservable

          public Observable<String> migrateObservable(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 RedisTransaction monitor(Handler<AsyncResult<String>> handler)

      Listen for all requests received by the server in real time
      Parameters:
        `handler` -
      Returns:

    - #### monitorObservable

          public Observable<String> monitorObservable()

      Listen for all requests received by the server in real time
      Returns:

    - #### move

          public RedisTransaction move(String key,
                                       int destdb,
                                       Handler<AsyncResult<String>> 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:

    - #### moveObservable

          public Observable<String> moveObservable(String key,
                                                   int destdb)

      Move a key to another database
      Parameters:
        `key` - Key to migrate
        `destdb` - Destination database index
      Returns:

    - #### mset

          public RedisTransaction 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:

    - #### msetObservable

          public Observable<String> msetObservable(JsonObject keyvals)

      Set multiple keys to multiple values
      Parameters:
        `keyvals` - Key value pairs to set
      Returns:

    - #### msetnx

          public RedisTransaction msetnx(JsonObject keyvals,
                                         Handler<AsyncResult<String>> 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:

    - #### msetnxObservable

          public Observable<String> msetnxObservable(JsonObject keyvals)

      Set multiple keys to multiple values, only if none of the keys exist
      Parameters:
        `keyvals` - Key value pairs to set
      Returns:

    - #### multi

          public RedisTransaction multi(Handler<AsyncResult<String>> handler)

      Mark the start of a RedisTransaction block
      Parameters:
        `handler` -
      Returns:

    - #### multiObservable

          public Observable<String> multiObservable()

      Mark the start of a RedisTransaction block
      Returns:

    - #### object

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

      Inspect the internals of Redis objects
      Parameters:
        `key` - Key string
        `cmd` - Object sub command
        `handler` - Handler for the result of this call.
      Returns:

    - #### objectObservable

          public Observable<String> objectObservable(String key,
                                                     ObjectCmd cmd)

      Inspect the internals of Redis objects
      Parameters:
        `key` - Key string
        `cmd` - Object sub command
      Returns:

    - #### persist

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

      Remove the expiration from a key
      Parameters:
        `key` - Key string
        `handler` - Handler for the result of this call.
      Returns:

    - #### persistObservable

          public Observable<String> persistObservable(String key)

      Remove the expiration from a key
      Parameters:
        `key` - Key string
      Returns:

    - #### pexpire

          public RedisTransaction pexpire(String key,
                                          long millis,
                                          Handler<AsyncResult<String>> 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:

    - #### pexpireObservable

          public Observable<String> pexpireObservable(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 RedisTransaction pexpireat(String key,
                                            long millis,
                                            Handler<AsyncResult<String>> 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:

    - #### pexpireatObservable

          public Observable<String> pexpireatObservable(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 RedisTransaction pfadd(String key,
                                        String element,
                                        Handler<AsyncResult<String>> 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:

    - #### pfaddObservable

          public Observable<String> pfaddObservable(String key,
                                                    String element)

      Adds the specified element to the specified HyperLogLog.
      Parameters:
        `key` - Key string
        `element` - Element to add
      Returns:

    - #### pfaddMany

          public RedisTransaction pfaddMany(String key,
                                            List<String> elements,
                                            Handler<AsyncResult<String>> 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:

    - #### pfaddManyObservable

          public Observable<String> pfaddManyObservable(String key,
                                                        List<String> elements)

      Adds the specified elements to the specified HyperLogLog.
      Parameters:
        `key` - Key string
        `elements` - Elementa to add
      Returns:

    - #### pfcount

          public RedisTransaction pfcount(String key,
                                          Handler<AsyncResult<String>> 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:

    - #### pfcountObservable

          public Observable<String> pfcountObservable(String key)

      Return the approximated cardinality of the set observed by the HyperLogLog at key.
      Parameters:
        `key` - Key string
      Returns:

    - #### pfcountMany

          public RedisTransaction pfcountMany(List<String> keys,
                                              Handler<AsyncResult<String>> 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:

    - #### pfcountManyObservable

          public Observable<String> pfcountManyObservable(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 RedisTransaction 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:

    - #### pfmergeObservable

          public Observable<String> pfmergeObservable(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 RedisTransaction ping(Handler<AsyncResult<String>> handler)

      Ping the server
      Parameters:
        `handler` -
      Returns:

    - #### pingObservable

          public Observable<String> pingObservable()

      Ping the server
      Returns:

    - #### psetex

          public RedisTransaction psetex(String key,
                                         long millis,
                                         String value,
                                         Handler<AsyncResult<String>> 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:

    - #### psetexObservable

          public Observable<String> psetexObservable(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 RedisTransaction psubscribe(String pattern,
                                             Handler<AsyncResult<String>> handler)

      Listen for messages published to channels matching the given pattern
      Parameters:
        `pattern` - Pattern string
        `handler` - Handler for the result of this call.
      Returns:

    - #### psubscribeObservable

          public Observable<String> psubscribeObservable(String pattern)

      Listen for messages published to channels matching the given pattern
      Parameters:
        `pattern` - Pattern string
      Returns:

    - #### psubscribeMany

          public RedisTransaction psubscribeMany(List<String> patterns,
                                                 Handler<AsyncResult<String>> 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:

    - #### psubscribeManyObservable

          public Observable<String> psubscribeManyObservable(List<String> patterns)

      Listen for messages published to channels matching the given patterns
      Parameters:
        `patterns` - List of patterns
      Returns:

    - #### pubsubChannels

          public RedisTransaction pubsubChannels(String pattern,
                                                 Handler<AsyncResult<String>> 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:

    - #### pubsubChannelsObservable

          public Observable<String> pubsubChannelsObservable(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 RedisTransaction pubsubNumsub(List<String> channels,
                                               Handler<AsyncResult<String>> 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:

    - #### pubsubNumsubObservable

          public Observable<String> pubsubNumsubObservable(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 RedisTransaction pubsubNumpat(Handler<AsyncResult<String>> 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:

    - #### pubsubNumpatObservable

          public Observable<String> pubsubNumpatObservable()

      Returns the number of subscriptions to patterns (that are performed using the PSUBSCRIBE command)
      Returns:

    - #### pttl

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

      Get the time to live for a key in milliseconds
      Parameters:
        `key` - Key string
        `handler` - Handler for the result of this call.
      Returns:

    - #### pttlObservable

          public Observable<String> pttlObservable(String key)

      Get the time to live for a key in milliseconds
      Parameters:
        `key` - Key string
      Returns:

    - #### publish

          public RedisTransaction publish(String channel,
                                          String message,
                                          Handler<AsyncResult<String>> 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:

    - #### publishObservable

          public Observable<String> publishObservable(String channel,
                                                      String message)

      Post a message to a channel
      Parameters:
        `channel` - Channel key
        `message` - Message to send to channel
      Returns:

    - #### punsubscribe

          public RedisTransaction punsubscribe(List<String> patterns,
                                               Handler<AsyncResult<String>> 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:

    - #### punsubscribeObservable

          public Observable<String> punsubscribeObservable(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 RedisTransaction randomkey(Handler<AsyncResult<String>> handler)

      Return a random key from the keyspace
      Parameters:
        `handler` -
      Returns:

    - #### randomkeyObservable

          public Observable<String> randomkeyObservable()

      Return a random key from the keyspace
      Returns:

    - #### rename

          public RedisTransaction 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:

    - #### renameObservable

          public Observable<String> renameObservable(String key,
                                                     String newkey)

      Rename a key
      Parameters:
        `key` - Key string to be renamed
        `newkey` - New key string
      Returns:

    - #### renamenx

          public RedisTransaction renamenx(String key,
                                           String newkey,
                                           Handler<AsyncResult<String>> 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:

    - #### renamenxObservable

          public Observable<String> renamenxObservable(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 RedisTransaction 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:

    - #### restoreObservable

          public Observable<String> restoreObservable(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 RedisTransaction role(Handler<AsyncResult<String>> handler)

      Return the role of the instance in the context of replication
      Parameters:
        `handler` -
      Returns:

    - #### roleObservable

          public Observable<String> roleObservable()

      Return the role of the instance in the context of replication
      Returns:

    - #### rpop

          public RedisTransaction 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:

    - #### rpopObservable

          public Observable<String> rpopObservable(String key)

      Remove and get the last element in a list
      Parameters:
        `key` - Key string
      Returns:

    - #### rpoplpush

          public RedisTransaction 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:

    - #### rpoplpushObservable

          public Observable<String> rpoplpushObservable(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 RedisTransaction rpushMany(String key,
                                            List<String> values,
                                            Handler<AsyncResult<String>> 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:

    - #### rpushManyObservable

          public Observable<String> rpushManyObservable(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 RedisTransaction rpush(String key,
                                        String value,
                                        Handler<AsyncResult<String>> 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:

    - #### rpushObservable

          public Observable<String> rpushObservable(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 RedisTransaction rpushx(String key,
                                         String value,
                                         Handler<AsyncResult<String>> 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:

    - #### rpushxObservable

          public Observable<String> rpushxObservable(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 RedisTransaction sadd(String key,
                                       String member,
                                       Handler<AsyncResult<String>> 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:

    - #### saddObservable

          public Observable<String> saddObservable(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 RedisTransaction saddMany(String key,
                                           List<String> members,
                                           Handler<AsyncResult<String>> 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:

    - #### saddManyObservable

          public Observable<String> saddManyObservable(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 RedisTransaction save(Handler<AsyncResult<String>> handler)

      Synchronously save the dataset to disk
      Parameters:
        `handler` -
      Returns:

    - #### saveObservable

          public Observable<String> saveObservable()

      Synchronously save the dataset to disk
      Returns:

    - #### scard

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

      Get the number of members in a set
      Parameters:
        `key` - Key string
        `handler` - Handler for the result of this call.
      Returns:

    - #### scardObservable

          public Observable<String> scardObservable(String key)

      Get the number of members in a set
      Parameters:
        `key` - Key string
      Returns:

    - #### scriptExists

          public RedisTransaction scriptExists(String script,
                                               Handler<AsyncResult<String>> 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:

    - #### scriptExistsObservable

          public Observable<String> scriptExistsObservable(String script)

      Check existence of script in the script cache.
      Parameters:
        `script` - SHA1 digest identifying a script in the script cache
      Returns:

    - #### scriptExistsMany

          public RedisTransaction scriptExistsMany(List<String> scripts,
                                                   Handler<AsyncResult<String>> 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:

    - #### scriptExistsManyObservable

          public Observable<String> scriptExistsManyObservable(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 RedisTransaction scriptFlush(Handler<AsyncResult<String>> handler)

      Remove all the scripts from the script cache.
      Parameters:
        `handler` -
      Returns:

    - #### scriptFlushObservable

          public Observable<String> scriptFlushObservable()

      Remove all the scripts from the script cache.
      Returns:

    - #### scriptKill

          public RedisTransaction scriptKill(Handler<AsyncResult<String>> handler)

      Kill the script currently in execution.
      Parameters:
        `handler` -
      Returns:

    - #### scriptKillObservable

          public Observable<String> scriptKillObservable()

      Kill the script currently in execution.
      Returns:

    - #### scriptLoad

          public RedisTransaction 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:

    - #### scriptLoadObservable

          public Observable<String> scriptLoadObservable(String script)

      Load the specified Lua script into the script cache.
      Parameters:
        `script` - Lua script
      Returns:

    - #### sdiff

          public RedisTransaction sdiff(String key,
                                        List<String> cmpkeys,
                                        Handler<AsyncResult<String>> 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:

    - #### sdiffObservable

          public Observable<String> sdiffObservable(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 RedisTransaction sdiffstore(String destkey,
                                             String key,
                                             List<String> cmpkeys,
                                             Handler<AsyncResult<String>> 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:

    - #### sdiffstoreObservable

          public Observable<String> sdiffstoreObservable(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 RedisTransaction 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:

    - #### selectObservable

          public Observable<String> selectObservable(int dbindex)

      Change the selected database for the current connection
      Parameters:
        `dbindex` - Index identifying the new active database
      Returns:

    - #### set

          public RedisTransaction set(String key,
                                      String value,
                                      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
        `handler` - Handler for the result of this call.
      Returns:

    - #### setObservable

          public Observable<String> setObservable(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 RedisTransaction 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:

    - #### setWithOptionsObservable

          public Observable<String> setWithOptionsObservable(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 RedisTransaction setBinary(String key,
                                            Buffer value,
                                            Handler<AsyncResult<String>> 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:

    - #### setBinaryObservable

          public Observable<String> setBinaryObservable(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 RedisTransaction setBinaryWithOptions(String key,
                                                       Buffer 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:

    - #### setBinaryWithOptionsObservable

          public Observable<String> setBinaryWithOptionsObservable(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 RedisTransaction setbit(String key,
                                         long offset,
                                         int bit,
                                         Handler<AsyncResult<String>> 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:

    - #### setbitObservable

          public Observable<String> setbitObservable(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 RedisTransaction 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:

    - #### setexObservable

          public Observable<String> setexObservable(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 RedisTransaction setnx(String key,
                                        String value,
                                        Handler<AsyncResult<String>> 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:

    - #### setnxObservable

          public Observable<String> setnxObservable(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 RedisTransaction setrange(String key,
                                           int offset,
                                           String value,
                                           Handler<AsyncResult<String>> 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:

    - #### setrangeObservable

          public Observable<String> setrangeObservable(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 RedisTransaction sinter(List<String> keys,
                                         Handler<AsyncResult<String>> handler)

      Intersect multiple sets
      Parameters:
        `keys` - List of keys to perform intersection on
        `handler` - Handler for the result of this call.
      Returns:

    - #### sinterObservable

          public Observable<String> sinterObservable(List<String> keys)

      Intersect multiple sets
      Parameters:
        `keys` - List of keys to perform intersection on
      Returns:

    - #### sinterstore

          public RedisTransaction sinterstore(String destkey,
                                              List<String> keys,
                                              Handler<AsyncResult<String>> 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:

    - #### sinterstoreObservable

          public Observable<String> sinterstoreObservable(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 RedisTransaction sismember(String key,
                                            String member,
                                            Handler<AsyncResult<String>> 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:

    - #### sismemberObservable

          public Observable<String> sismemberObservable(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 RedisTransaction 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:

    - #### slaveofObservable

          public Observable<String> slaveofObservable(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 RedisTransaction slaveofNoone(Handler<AsyncResult<String>> handler)

      Make this server a master
      Parameters:
        `handler` - Handler for the result of this call.
      Returns:

    - #### slaveofNooneObservable

          public Observable<String> slaveofNooneObservable()

      Make this server a master
      Returns:

    - #### slowlogGet

          public RedisTransaction slowlogGet(int limit,
                                             Handler<AsyncResult<String>> 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:

    - #### slowlogGetObservable

          public Observable<String> slowlogGetObservable(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 RedisTransaction slowlogLen(Handler<AsyncResult<String>> handler)

      Get the length of the Redis slow queries log
      Parameters:
        `handler` - Handler for the result of this call.
      Returns:

    - #### slowlogLenObservable

          public Observable<String> slowlogLenObservable()

      Get the length of the Redis slow queries log
      Returns:

    - #### slowlogReset

          public RedisTransaction slowlogReset(Handler<AsyncResult<String>> handler)

      Reset the Redis slow queries log
      Parameters:
        `handler` - Handler for the result of this call.
      Returns:

    - #### slowlogResetObservable

          public Observable<String> slowlogResetObservable()

      Reset the Redis slow queries log
      Returns:

    - #### smembers

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

      Get all the members in a set
      Parameters:
        `key` - Key string
        `handler` - Handler for the result of this call.
      Returns:

    - #### smembersObservable

          public Observable<String> smembersObservable(String key)

      Get all the members in a set
      Parameters:
        `key` - Key string
      Returns:

    - #### smove

          public RedisTransaction smove(String key,
                                        String destkey,
                                        String member,
                                        Handler<AsyncResult<String>> 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:

    - #### smoveObservable

          public Observable<String> smoveObservable(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 RedisTransaction sort(String key,
                                       SortOptions options,
                                       Handler<AsyncResult<String>> 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:

    - #### sortObservable

          public Observable<String> sortObservable(String key,
                                                   SortOptions options)

      Sort the elements in a list, set or sorted set
      Parameters:
        `key` - Key string
        `options` - Sort options
      Returns:

    - #### spop

          public RedisTransaction 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:

    - #### spopObservable

          public Observable<String> spopObservable(String key)

      Remove and return a random member from a set
      Parameters:
        `key` - Key string
      Returns:

    - #### spopMany

          public RedisTransaction spopMany(String key,
                                           int count,
                                           Handler<AsyncResult<String>> 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:

    - #### spopManyObservable

          public Observable<String> spopManyObservable(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 RedisTransaction 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:

    - #### srandmemberObservable

          public Observable<String> srandmemberObservable(String key)

      Get one or multiple random members from a set
      Parameters:
        `key` - Key string
      Returns:

    - #### srandmemberCount

          public RedisTransaction srandmemberCount(String key,
                                                   int count,
                                                   Handler<AsyncResult<String>> 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:

    - #### srandmemberCountObservable

          public Observable<String> srandmemberCountObservable(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 RedisTransaction srem(String key,
                                       String member,
                                       Handler<AsyncResult<String>> handler)

      Remove one member from a set
      Parameters:
        `key` - Key string
        `member` - Member to remove
        `handler` - Handler for the result of this call.
      Returns:

    - #### sremObservable

          public Observable<String> sremObservable(String key,
                                                   String member)

      Remove one member from a set
      Parameters:
        `key` - Key string
        `member` - Member to remove
      Returns:

    - #### sremMany

          public RedisTransaction sremMany(String key,
                                           List<String> members,
                                           Handler<AsyncResult<String>> 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:

    - #### sremManyObservable

          public Observable<String> sremManyObservable(String key,
                                                       List<String> members)

      Remove one or more members from a set
      Parameters:
        `key` - Key string
        `members` - Members to remove
      Returns:

    - #### strlen

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

      Get the length of the value stored in a key
      Parameters:
        `key` - Key string
        `handler` - Handler for the result of this call.
      Returns:

    - #### strlenObservable

          public Observable<String> strlenObservable(String key)

      Get the length of the value stored in a key
      Parameters:
        `key` - Key string
      Returns:

    - #### subscribe

          public RedisTransaction subscribe(String channel,
                                            Handler<AsyncResult<String>> handler)

      Listen for messages published to the given channels
      Parameters:
        `channel` - Channel to subscribe to
        `handler` - Handler for the result of this call.
      Returns:

    - #### subscribeObservable

          public Observable<String> subscribeObservable(String channel)

      Listen for messages published to the given channels
      Parameters:
        `channel` - Channel to subscribe to
      Returns:

    - #### subscribeMany

          public RedisTransaction subscribeMany(List<String> channels,
                                                Handler<AsyncResult<String>> 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:

    - #### subscribeManyObservable

          public Observable<String> subscribeManyObservable(List<String> channels)

      Listen for messages published to the given channels
      Parameters:
        `channels` - List of channels to subscribe to
      Returns:

    - #### sunion

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

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

    - #### sunionObservable

          public Observable<String> sunionObservable(List<String> keys)

      Add multiple sets
      Parameters:
        `keys` - List of keys identifying sets to add up
      Returns:

    - #### sunionstore

          public RedisTransaction sunionstore(String destkey,
                                              List<String> keys,
                                              Handler<AsyncResult<String>> 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:

    - #### sunionstoreObservable

          public Observable<String> sunionstoreObservable(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 RedisTransaction sync(Handler<AsyncResult<String>> handler)

      Internal command used for replication
      Parameters:
        `handler` -
      Returns:

    - #### syncObservable

          public Observable<String> syncObservable()

      Internal command used for replication
      Returns:

    - #### time

          public RedisTransaction time(Handler<AsyncResult<String>> handler)

      Return the current server time
      Parameters:
        `handler` -
      Returns:

    - #### timeObservable

          public Observable<String> timeObservable()

      Return the current server time
      Returns:

    - #### ttl

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

      Get the time to live for a key
      Parameters:
        `key` - Key string
        `handler` - Handler for the result of this call.
      Returns:

    - #### ttlObservable

          public Observable<String> ttlObservable(String key)

      Get the time to live for a key
      Parameters:
        `key` - Key string
      Returns:

    - #### type

          public RedisTransaction 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:

    - #### typeObservable

          public Observable<String> typeObservable(String key)

      Determine the type stored at key
      Parameters:
        `key` - Key string
      Returns:

    - #### unsubscribe

          public RedisTransaction unsubscribe(List<String> channels,
                                              Handler<AsyncResult<String>> 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:

    - #### unsubscribeObservable

          public Observable<String> unsubscribeObservable(List<String> channels)

      Stop listening for messages posted to the given channels
      Parameters:
        `channels` - List of channels to subscribe to
      Returns:

    - #### unwatch

          public RedisTransaction unwatch(Handler<AsyncResult<String>> handler)

      Forget about all watched keys
      Parameters:
        `handler` -
      Returns:

    - #### unwatchObservable

          public Observable<String> unwatchObservable()

      Forget about all watched keys
      Returns:

    - #### wait

          public RedisTransaction 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:

    - #### waitObservable

          public Observable<String> waitObservable(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:

    - #### watch

          public RedisTransaction watch(String key,
                                        Handler<AsyncResult<String>> handler)

      Watch the given keys to determine execution of the MULTI/EXEC block
      Parameters:
        `key` - Key to watch
        `handler` - Handler for the result of this call.
      Returns:

    - #### watchObservable

          public Observable<String> watchObservable(String key)

      Watch the given keys to determine execution of the MULTI/EXEC block
      Parameters:
        `key` - Key to watch
      Returns:

    - #### watchMany

          public RedisTransaction watchMany(List<String> keys,
                                            Handler<AsyncResult<String>> handler)

      Watch the given keys to determine execution of the MULTI/EXEC block
      Parameters:
        `keys` - List of keys to watch
        `handler` - Handler for the result of this call.
      Returns:

    - #### watchManyObservable

          public Observable<String> watchManyObservable(List<String> keys)

      Watch the given keys to determine execution of the MULTI/EXEC block
      Parameters:
        `keys` - List of keys to watch
      Returns:

    - #### zadd

          public RedisTransaction zadd(String key,
                                       double score,
                                       String member,
                                       Handler<AsyncResult<String>> 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:

    - #### zaddObservable

          public Observable<String> zaddObservable(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 RedisTransaction zaddMany(String key,
                                           Map<String,Double> members,
                                           Handler<AsyncResult<String>> 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:

    - #### zaddManyObservable

          public Observable<String> zaddManyObservable(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 RedisTransaction zcard(String key,
                                        Handler<AsyncResult<String>> handler)

      Get the number of members in a sorted set
      Parameters:
        `key` - Key string
        `handler` - Handler for the result of this call.
      Returns:

    - #### zcardObservable

          public Observable<String> zcardObservable(String key)

      Get the number of members in a sorted set
      Parameters:
        `key` - Key string
      Returns:

    - #### zcount

          public RedisTransaction zcount(String key,
                                         double min,
                                         double max,
                                         Handler<AsyncResult<String>> 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:

    - #### zcountObservable

          public Observable<String> zcountObservable(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 RedisTransaction 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:

    - #### zincrbyObservable

          public Observable<String> zincrbyObservable(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 RedisTransaction zinterstore(String destkey,
                                              List<String> sets,
                                              AggregateOptions options,
                                              Handler<AsyncResult<String>> 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:

    - #### zinterstoreObservable

          public Observable<String> zinterstoreObservable(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 RedisTransaction zinterstoreWeighed(String destkey,
                                                     Map<String,Double> sets,
                                                     AggregateOptions options,
                                                     Handler<AsyncResult<String>> 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:

    - #### zinterstoreWeighedObservable

          public Observable<String> zinterstoreWeighedObservable(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 RedisTransaction zlexcount(String key,
                                            String min,
                                            String max,
                                            Handler<AsyncResult<String>> 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:

    - #### zlexcountObservable

          public Observable<String> zlexcountObservable(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 RedisTransaction zrange(String key,
                                         long start,
                                         long stop,
                                         Handler<AsyncResult<String>> 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:

    - #### zrangeObservable

          public Observable<String> zrangeObservable(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 RedisTransaction zrangeWithOptions(String key,
                                                    long start,
                                                    long stop,
                                                    RangeOptions options,
                                                    Handler<AsyncResult<String>> 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:

    - #### zrangeWithOptionsObservable

          public Observable<String> zrangeWithOptionsObservable(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 RedisTransaction zrangebylex(String key,
                                              String min,
                                              String max,
                                              LimitOptions options,
                                              Handler<AsyncResult<String>> 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:

    - #### zrangebylexObservable

          public Observable<String> zrangebylexObservable(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 RedisTransaction zrangebyscore(String key,
                                                String min,
                                                String max,
                                                RangeLimitOptions options,
                                                Handler<AsyncResult<String>> 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:

    - #### zrangebyscoreObservable

          public Observable<String> zrangebyscoreObservable(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 RedisTransaction zrank(String key,
                                        String member,
                                        Handler<AsyncResult<String>> 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:

    - #### zrankObservable

          public Observable<String> zrankObservable(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 RedisTransaction zrem(String key,
                                       String member,
                                       Handler<AsyncResult<String>> 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:

    - #### zremObservable

          public Observable<String> zremObservable(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 RedisTransaction zremMany(String key,
                                           List<String> members,
                                           Handler<AsyncResult<String>> 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:

    - #### zremManyObservable

          public Observable<String> zremManyObservable(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 RedisTransaction zremrangebylex(String key,
                                                 String min,
                                                 String max,
                                                 Handler<AsyncResult<String>> 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:

    - #### zremrangebylexObservable

          public Observable<String> zremrangebylexObservable(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 RedisTransaction zremrangebyrank(String key,
                                                  long start,
                                                  long stop,
                                                  Handler<AsyncResult<String>> 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:

    - #### zremrangebyrankObservable

          public Observable<String> zremrangebyrankObservable(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 RedisTransaction zremrangebyscore(String key,
                                                   String min,
                                                   String max,
                                                   Handler<AsyncResult<String>> 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:

    - #### zremrangebyscoreObservable

          public Observable<String> zremrangebyscoreObservable(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 RedisTransaction zrevrange(String key,
                                            long start,
                                            long stop,
                                            RangeOptions options,
                                            Handler<AsyncResult<String>> 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:

    - #### zrevrangeObservable

          public Observable<String> zrevrangeObservable(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 RedisTransaction zrevrangebylex(String key,
                                                 String max,
                                                 String min,
                                                 LimitOptions options,
                                                 Handler<AsyncResult<String>> 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:

    - #### zrevrangebylexObservable

          public Observable<String> zrevrangebylexObservable(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 RedisTransaction zrevrangebyscore(String key,
                                                   String max,
                                                   String min,
                                                   RangeLimitOptions options,
                                                   Handler<AsyncResult<String>> 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:

    - #### zrevrangebyscoreObservable

          public Observable<String> zrevrangebyscoreObservable(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 RedisTransaction zrevrank(String key,
                                           String member,
                                           Handler<AsyncResult<String>> 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:

    - #### zrevrankObservable

          public Observable<String> zrevrankObservable(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 RedisTransaction 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:

    - #### zscoreObservable

          public Observable<String> zscoreObservable(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 RedisTransaction zunionstore(String destkey,
                                              List<String> sets,
                                              AggregateOptions options,
                                              Handler<AsyncResult<String>> 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:

    - #### zunionstoreObservable

          public Observable<String> zunionstoreObservable(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 RedisTransaction zunionstoreWeighed(String key,
                                                     Map<String,Double> sets,
                                                     AggregateOptions options,
                                                     Handler<AsyncResult<String>> 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:

    - #### zunionstoreWeighedObservable

          public Observable<String> zunionstoreWeighedObservable(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 RedisTransaction scan(String cursor,
                                       ScanOptions options,
                                       Handler<AsyncResult<String>> handler)

      Incrementally iterate the keys space
      Parameters:
        `cursor` - Cursor id
        `options` - Scan options
        `handler` - Handler for the result of this call.
      Returns:

    - #### scanObservable

          public Observable<String> scanObservable(String cursor,
                                                   ScanOptions options)

      Incrementally iterate the keys space
      Parameters:
        `cursor` - Cursor id
        `options` - Scan options
      Returns:

    - #### sscan

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

      Incrementally iterate Set elements
      Parameters:
        `key` - Key string
        `cursor` - Cursor id
        `options` - Scan options
        `handler` - Handler for the result of this call.
      Returns:

    - #### sscanObservable

          public Observable<String> sscanObservable(String key,
                                                    String cursor,
                                                    ScanOptions options)

      Incrementally iterate Set elements
      Parameters:
        `key` - Key string
        `cursor` - Cursor id
        `options` - Scan options
      Returns:

    - #### hscan

          public RedisTransaction hscan(String key,
                                        String cursor,
                                        ScanOptions options,
                                        Handler<AsyncResult<String>> 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:

    - #### hscanObservable

          public Observable<String> hscanObservable(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 RedisTransaction zscan(String key,
                                        String cursor,
                                        ScanOptions options,
                                        Handler<AsyncResult<String>> 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:

    - #### zscanObservable

          public Observable<String> zscanObservable(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 RedisTransaction geoadd(String key,
                                         double longitude,
                                         double latitude,
                                         String member,
                                         Handler<AsyncResult<String>> 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:

    - #### geoaddObservable

          public Observable<String> geoaddObservable(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 RedisTransaction geoaddMany(String key,
                                             List<GeoMember> members,
                                             Handler<AsyncResult<String>> 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:

    - #### geoaddManyObservable

          public Observable<String> geoaddManyObservable(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 RedisTransaction geohash(String key,
                                          String member,
                                          Handler<AsyncResult<String>> 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:

    - #### geohashObservable

          public Observable<String> geohashObservable(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 RedisTransaction geohashMany(String key,
                                              List<String> members,
                                              Handler<AsyncResult<String>> 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:

    - #### geohashManyObservable

          public Observable<String> geohashManyObservable(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 RedisTransaction geopos(String key,
                                         String member,
                                         Handler<AsyncResult<String>> 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:

    - #### geoposObservable

          public Observable<String> geoposObservable(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 RedisTransaction geoposMany(String key,
                                             List<String> members,
                                             Handler<AsyncResult<String>> 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:

    - #### geoposManyObservable

          public Observable<String> geoposManyObservable(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 RedisTransaction 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:

    - #### geodistObservable

          public Observable<String> geodistObservable(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 RedisTransaction 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:

    - #### geodistWithUnitObservable

          public Observable<String> geodistWithUnitObservable(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 RedisTransaction georadius(String key,
                                            double longitude,
                                            double latitude,
                                            double radius,
                                            GeoUnit unit,
                                            Handler<AsyncResult<String>> 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:

    - #### georadiusObservable

          public Observable<String> georadiusObservable(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 RedisTransaction georadiusWithOptions(String key,
                                                       double longitude,
                                                       double latitude,
                                                       double radius,
                                                       GeoUnit unit,
                                                       GeoRadiusOptions options,
                                                       Handler<AsyncResult<String>> 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:

    - #### georadiusWithOptionsObservable

          public Observable<String> georadiusWithOptionsObservable(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).
      Parameters:
        `key` - Key string
        `longitude` - longitude
        `latitude` - latitude
        `radius` - radius
        `unit` - geo unit
        `options` - geo radius options
      Returns:

    - #### georadiusbymember

          public RedisTransaction georadiusbymember(String key,
                                                    String member,
                                                    double radius,
                                                    GeoUnit unit,
                                                    Handler<AsyncResult<String>> 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:

    - #### georadiusbymemberObservable

          public Observable<String> georadiusbymemberObservable(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 RedisTransaction georadiusbymemberWithOptions(String key,
                                                               String member,
                                                               double radius,
                                                               GeoUnit unit,
                                                               GeoRadiusOptions options,
                                                               Handler<AsyncResult<String>> 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
        `options` - geo radius options
        `handler` - Handler for the result of this call.
      Returns:

    - #### georadiusbymemberWithOptionsObservable

          public Observable<String> georadiusbymemberWithOptionsObservable(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.
      Parameters:
        `key` - Key string
        `member` - member
        `radius` - radius
        `unit` - geo unit
        `options` - geo radius options
      Returns:

    - #### newInstance

          public static RedisTransaction newInstance(RedisTransaction arg)

Copyright © 2016. All rights reserved.