io.vertx.reactivex.redis

Class RedisClient

java.lang.Object

io.vertx.reactivex.redis.RedisClient

public class RedisClient
extends Object

Field Summary

Fields

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

Constructor Summary

Constructors

Constructor and Description
RedisClient(RedisClient delegate)

Method Summary

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

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Field Detail

__TYPE_ARG

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

Constructor Detail

RedisClient

public RedisClient(RedisClient delegate)

Method Detail

toString

public String toString()

Overrides:

toString in class Object

equals

public boolean equals(Object o)

Overrides:

equals in class Object

hashCode

public int hashCode()

Overrides:

hashCode in class Object

getDelegate

public RedisClient getDelegate()

create

public static RedisClient create(Vertx vertx)

create

public static RedisClient create(Vertx vertx,
                                 RedisOptions config)

close

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

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

Parameters:

handler -

rxClose

public io.reactivex.Completable rxClose()

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

Returns:

append

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

Append a value to a key

Parameters:

key - Key string

value - Value to append

handler - Handler for the result of this call.

Returns:

rxAppend

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

Append a value to a key

Parameters:

key - Key string

value - Value to append

Returns:

auth

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

Authenticate to the server

Parameters:

password - Password for authentication

handler - Handler for the result of this call.

Returns:

rxAuth

public io.reactivex.Single<String> rxAuth(String password)

Authenticate to the server

Parameters:

password - Password for authentication

Returns:

bgrewriteaof

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

Asynchronously rewrite the append-only file

Parameters:

handler -

Returns:

rxBgrewriteaof

public io.reactivex.Single<String> rxBgrewriteaof()

Asynchronously rewrite the append-only file

Returns:

bgsave

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

Asynchronously save the dataset to disk

Parameters:

handler -

Returns:

rxBgsave

public io.reactivex.Single<String> rxBgsave()

Asynchronously save the dataset to disk

Returns:

bitcount

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

Count set bits in a string

Parameters:

key - Key string

handler - Handler for the result of this call.

Returns:

rxBitcount

public io.reactivex.Single<Long> rxBitcount(String key)

Count set bits in a string

Parameters:

key - Key string

Returns:

bitcountRange

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

Count set bits in a string

Parameters:

key - Key string

start - Start index

end - End index

handler - Handler for the result of this call.

Returns:

rxBitcountRange

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

Count set bits in a string

Parameters:

key - Key string

start - Start index

end - End index

Returns:

bitop

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

Perform bitwise operations between strings

Parameters:

operation - Bitwise operation to perform

destkey - Destination key where result is stored

keys - List of keys on which to perform the operation

handler - Handler for the result of this call.

Returns:

rxBitop

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

Perform bitwise operations between strings

Parameters:

operation - Bitwise operation to perform

destkey - Destination key where result is stored

keys - List of keys on which to perform the operation

Returns:

bitpos

public RedisClient bitpos(String key,
                          int bit,
                          Handler<AsyncResult<Long>> handler)

Find first bit set or clear in a string

Parameters:

key - Key string

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

handler - Handler for the result of this call.

Returns:

rxBitpos

public io.reactivex.Single<Long> rxBitpos(String key,
                                          int bit)

Find first bit set or clear in a string

Parameters:

key - Key string

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

Returns:

bitposFrom

public RedisClient bitposFrom(String key,
                              int bit,
                              int start,
                              Handler<AsyncResult<Long>> handler)

Find first bit set or clear in a string See also bitposRange() method, which takes start, and stop offset.

Parameters:

key - Key string

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

start - Start offset

handler - Handler for the result of this call.

Returns:

rxBitposFrom

public io.reactivex.Single<Long> rxBitposFrom(String key,
                                              int bit,
                                              int start)

Find first bit set or clear in a string See also bitposRange() method, which takes start, and stop offset.

Parameters:

key - Key string

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

start - Start offset

Returns:

bitposRange

public RedisClient bitposRange(String key,
                               int bit,
                               int start,
                               int stop,
                               Handler<AsyncResult<Long>> handler)

Find first bit set or clear in a string Note: when both start, and stop offsets are specified, behaviour is slightly different than if only start is specified

Parameters:

key - Key string

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

start - Start offset

stop - End offset - inclusive

handler - Handler for the result of this call.

Returns:

rxBitposRange

public io.reactivex.Single<Long> rxBitposRange(String key,
                                               int bit,
                                               int start,
                                               int stop)

Find first bit set or clear in a string Note: when both start, and stop offsets are specified, behaviour is slightly different than if only start is specified

Parameters:

key - Key string

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

start - Start offset

stop - End offset - inclusive

Returns:

blpop

public RedisClient blpop(String key,
                         int seconds,
                         Handler<AsyncResult<JsonArray>> handler)

Remove and get the first element in a list, or block until one is available

Parameters:

key - Key string identifying a list to watch

seconds - Timeout in seconds

handler - Handler for the result of this call.

Returns:

rxBlpop

public io.reactivex.Single<JsonArray> rxBlpop(String key,
                                              int seconds)

Remove and get the first element in a list, or block until one is available

Parameters:

key - Key string identifying a list to watch

seconds - Timeout in seconds

Returns:

blpopMany

public RedisClient blpopMany(List<String> keys,
                             int seconds,
                             Handler<AsyncResult<JsonArray>> handler)

Remove and get the first element in any of the lists, or block until one is available

Parameters:

keys - List of key strings identifying lists to watch

seconds - Timeout in seconds

handler - Handler for the result of this call.

Returns:

rxBlpopMany

public io.reactivex.Single<JsonArray> rxBlpopMany(List<String> keys,
                                                  int seconds)

Remove and get the first element in any of the lists, or block until one is available

Parameters:

keys - List of key strings identifying lists to watch

seconds - Timeout in seconds

Returns:

brpop

public RedisClient brpop(String key,
                         int seconds,
                         Handler<AsyncResult<JsonArray>> handler)

Remove and get the last element in a list, or block until one is available

Parameters:

key - Key string identifying a list to watch

seconds - Timeout in seconds

handler - Handler for the result of this call.

Returns:

rxBrpop

public io.reactivex.Single<JsonArray> rxBrpop(String key,
                                              int seconds)

Remove and get the last element in a list, or block until one is available

Parameters:

key - Key string identifying a list to watch

seconds - Timeout in seconds

Returns:

brpopMany

public RedisClient brpopMany(List<String> keys,
                             int seconds,
                             Handler<AsyncResult<JsonArray>> handler)

Remove and get the last element in any of the lists, or block until one is available

Parameters:

keys - List of key strings identifying lists to watch

seconds - Timeout in seconds

handler - Handler for the result of this call.

Returns:

rxBrpopMany

public io.reactivex.Single<JsonArray> rxBrpopMany(List<String> keys,
                                                  int seconds)

Remove and get the last element in any of the lists, or block until one is available

Parameters:

keys - List of key strings identifying lists to watch

seconds - Timeout in seconds

Returns:

brpoplpush

public RedisClient brpoplpush(String key,
                              String destkey,
                              int seconds,
                              Handler<AsyncResult<String>> handler)

Pop a value from a list, push it to another list and return it; or block until one is available

Parameters:

key - Key string identifying the source list

destkey - Key string identifying the destination list

seconds - Timeout in seconds

handler - Handler for the result of this call.

Returns:

rxBrpoplpush

public io.reactivex.Single<String> rxBrpoplpush(String key,
                                                String destkey,
                                                int seconds)

Pop a value from a list, push it to another list and return it; or block until one is available

Parameters:

key - Key string identifying the source list

destkey - Key string identifying the destination list

seconds - Timeout in seconds

Returns:

clientKill

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

Kill the connection of a client

Parameters:

filter - Filter options

handler - Handler for the result of this call.

Returns:

rxClientKill

public io.reactivex.Single<Long> rxClientKill(KillFilter filter)

Kill the connection of a client

Parameters:

filter - Filter options

Returns:

clientList

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

Get the list of client connections

Parameters:

handler -

Returns:

rxClientList

public io.reactivex.Single<String> rxClientList()

Get the list of client connections

Returns:

clientGetname

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

Get the current connection name

Parameters:

handler -

Returns:

rxClientGetname

public io.reactivex.Single<String> rxClientGetname()

Get the current connection name

Returns:

clientPause

public RedisClient clientPause(long millis,
                               Handler<AsyncResult<String>> handler)

Stop processing commands from clients for some time

Parameters:

millis - Pause time in milliseconds

handler - Handler for the result of this call.

Returns:

rxClientPause

public io.reactivex.Single<String> rxClientPause(long millis)

Stop processing commands from clients for some time

Parameters:

millis - Pause time in milliseconds

Returns:

clientSetname

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

Set the current connection name

Parameters:

name - New name for current connection

handler - Handler for the result of this call.

Returns:

rxClientSetname

public io.reactivex.Single<String> rxClientSetname(String name)

Set the current connection name

Parameters:

name - New name for current connection

Returns:

clusterAddslots

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

Assign new hash slots to receiving node.

Parameters:

slots -

handler - Handler for the result of this call.

Returns:

rxClusterAddslots

public io.reactivex.Completable rxClusterAddslots(List<Long> slots)

Assign new hash slots to receiving node.

Parameters:

slots -

Returns:

clusterCountFailureReports

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

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

Parameters:

nodeId -

handler - Handler for the result of this call.

Returns:

rxClusterCountFailureReports

public io.reactivex.Single<Long> rxClusterCountFailureReports(String nodeId)

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

Parameters:

nodeId -

Returns:

clusterCountkeysinslot

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

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

Parameters:

slot -

handler - Handler for the result of this call.

Returns:

rxClusterCountkeysinslot

public io.reactivex.Single<Long> rxClusterCountkeysinslot(long slot)

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

Parameters:

slot -

Returns:

clusterDelslots

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

Set hash slots as unbound in receiving node.

Parameters:

slot -

handler - Handler for the result of this call.

Returns:

rxClusterDelslots

public io.reactivex.Completable rxClusterDelslots(long slot)

Set hash slots as unbound in receiving node.

Parameters:

slot -

Returns:

clusterDelslotsMany

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

Set hash slots as unbound in receiving node.

Parameters:

slots -

handler - Handler for the result of this call.

Returns:

rxClusterDelslotsMany

public io.reactivex.Completable rxClusterDelslotsMany(List<Long> slots)

Set hash slots as unbound in receiving node.

Parameters:

slots -

Returns:

clusterFailover

public RedisClient clusterFailover(Handler<AsyncResult<Void>> handler)

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

Parameters:

handler - Handler for the result of this call.

Returns:

rxClusterFailover

public io.reactivex.Completable rxClusterFailover()

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

Returns:

clusterFailOverWithOptions

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

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

Parameters:

options -

handler - Handler for the result of this call.

Returns:

rxClusterFailOverWithOptions

public io.reactivex.Completable rxClusterFailOverWithOptions(FailoverOptions options)

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

Parameters:

options -

Returns:

clusterForget

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

Remove a node from the nodes table.

Parameters:

nodeId -

handler - Handler for the result of this call.

Returns:

rxClusterForget

public io.reactivex.Completable rxClusterForget(String nodeId)

Remove a node from the nodes table.

Parameters:

nodeId -

Returns:

clusterGetkeysinslot

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

Return local key names in the specified hash slot.

Parameters:

slot -

count -

handler - Handler for the result of this call.

Returns:

rxClusterGetkeysinslot

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

Return local key names in the specified hash slot.

Parameters:

slot -

count -

Returns:

clusterInfo

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

Provides info about Redis Cluster node state.

Parameters:

handler - Handler for the result of this call.

Returns:

rxClusterInfo

public io.reactivex.Single<JsonArray> rxClusterInfo()

Provides info about Redis Cluster node state.

Returns:

clusterKeyslot

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

Returns the hash slot of the specified key.

Parameters:

key -

handler - Handler for the result of this call.

Returns:

rxClusterKeyslot

public io.reactivex.Single<Long> rxClusterKeyslot(String key)

Returns the hash slot of the specified key.

Parameters:

key -

Returns:

clusterMeet

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

Force a node cluster to handshake with another node.

Parameters:

ip -

port -

handler - Handler for the result of this call.

Returns:

rxClusterMeet

public io.reactivex.Completable rxClusterMeet(String ip,
                                              long port)

Force a node cluster to handshake with another node.

Parameters:

ip -

port -

Returns:

clusterNodes

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

Get Cluster config for the node.

Parameters:

handler - Handler for the result of this call.

Returns:

rxClusterNodes

public io.reactivex.Single<JsonArray> rxClusterNodes()

Get Cluster config for the node.

Returns:

clusterReplicate

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

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

Parameters:

nodeId -

handler - Handler for the result of this call.

Returns:

rxClusterReplicate

public io.reactivex.Completable rxClusterReplicate(String nodeId)

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

Parameters:

nodeId -

Returns:

clusterReset

public RedisClient clusterReset(Handler<AsyncResult<Void>> handler)

Reset a Redis Cluster node.

Parameters:

handler - Handler for the result of this call.

Returns:

rxClusterReset

public io.reactivex.Completable rxClusterReset()

Reset a Redis Cluster node.

Returns:

clusterResetWithOptions

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

Reset a Redis Cluster node.

Parameters:

options -

handler - Handler for the result of this call.

Returns:

rxClusterResetWithOptions

public io.reactivex.Completable rxClusterResetWithOptions(ResetOptions options)

Reset a Redis Cluster node.

Parameters:

options -

Returns:

clusterSaveconfig

public RedisClient clusterSaveconfig(Handler<AsyncResult<Void>> handler)

Forces the node to save cluster state on disk.

Parameters:

handler - Handler for the result of this call.

Returns:

rxClusterSaveconfig

public io.reactivex.Completable rxClusterSaveconfig()

Forces the node to save cluster state on disk.

Returns:

clusterSetConfigEpoch

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

Set the configuration epoch in a new node.

Parameters:

epoch -

handler - Handler for the result of this call.

Returns:

rxClusterSetConfigEpoch

public io.reactivex.Completable rxClusterSetConfigEpoch(long epoch)

Set the configuration epoch in a new node.

Parameters:

epoch -

Returns:

clusterSetslot

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

Bind an hash slot to a specific node.

Parameters:

slot -

subcommand -

handler - Handler for the result of this call.

Returns:

rxClusterSetslot

public io.reactivex.Completable rxClusterSetslot(long slot,
                                                 SlotCmd subcommand)

Bind an hash slot to a specific node.

Parameters:

slot -

subcommand -

Returns:

clusterSetslotWithNode

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

Bind an hash slot to a specific node.

Parameters:

slot -

subcommand -

nodeId -

handler - Handler for the result of this call.

Returns:

rxClusterSetslotWithNode

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

Bind an hash slot to a specific node.

Parameters:

slot -

subcommand -

nodeId -

Returns:

clusterSlaves

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

List slave nodes of the specified master node.

Parameters:

nodeId -

handler - Handler for the result of this call.

Returns:

rxClusterSlaves

public io.reactivex.Single<JsonArray> rxClusterSlaves(String nodeId)

List slave nodes of the specified master node.

Parameters:

nodeId -

Returns:

clusterSlots

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

Get array of Cluster slot to node mappings

Parameters:

handler -

Returns:

rxClusterSlots

public io.reactivex.Single<JsonArray> rxClusterSlots()

Get array of Cluster slot to node mappings

Returns:

command

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

Get array of Redis command details

Parameters:

handler -

Returns:

rxCommand

public io.reactivex.Single<JsonArray> rxCommand()

Get array of Redis command details

Returns:

commandCount

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

Get total number of Redis commands

Parameters:

handler -

Returns:

rxCommandCount

public io.reactivex.Single<Long> rxCommandCount()

Get total number of Redis commands

Returns:

commandGetkeys

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

Extract keys given a full Redis command

Parameters:

handler -

Returns:

rxCommandGetkeys

public io.reactivex.Single<JsonArray> rxCommandGetkeys()

Extract keys given a full Redis command

Returns:

commandInfo

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

Get array of specific Redis command details

Parameters:

commands - List of commands to get info for

handler - Handler for the result of this call.

Returns:

rxCommandInfo

public io.reactivex.Single<JsonArray> rxCommandInfo(List<String> commands)

Get array of specific Redis command details

Parameters:

commands - List of commands to get info for

Returns:

configGet

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

Get the value of a configuration parameter

Parameters:

parameter - Configuration parameter

handler - Handler for the result of this call.

Returns:

rxConfigGet

public io.reactivex.Single<JsonArray> rxConfigGet(String parameter)

Get the value of a configuration parameter

Parameters:

parameter - Configuration parameter

Returns:

configRewrite

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

Rewrite the configuration file with the in memory configuration

Parameters:

handler -

Returns:

rxConfigRewrite

public io.reactivex.Single<String> rxConfigRewrite()

Rewrite the configuration file with the in memory configuration

Returns:

configSet

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

Set a configuration parameter to the given value

Parameters:

parameter - Configuration parameter

value - New value

handler - Handler for the result of this call.

Returns:

rxConfigSet

public io.reactivex.Single<String> rxConfigSet(String parameter,
                                               String value)

Set a configuration parameter to the given value

Parameters:

parameter - Configuration parameter

value - New value

Returns:

configResetstat

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

Reset the stats returned by INFO

Parameters:

handler -

Returns:

rxConfigResetstat

public io.reactivex.Single<String> rxConfigResetstat()

Reset the stats returned by INFO

Returns:

dbsize

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

Return the number of keys in the selected database

Parameters:

handler -

Returns:

rxDbsize

public io.reactivex.Single<Long> rxDbsize()

Return the number of keys in the selected database

Returns:

debugObject

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

Get debugging information about a key

Parameters:

key - Key string

handler - Handler for the result of this call.

Returns:

rxDebugObject

public io.reactivex.Single<String> rxDebugObject(String key)

Get debugging information about a key

Parameters:

key - Key string

Returns:

debugSegfault

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

Make the server crash

Parameters:

handler -

Returns:

rxDebugSegfault

public io.reactivex.Single<String> rxDebugSegfault()

Make the server crash

Returns:

decr

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

Decrement the integer value of a key by one

Parameters:

key - Key string

handler - Handler for the result of this call.

Returns:

rxDecr

public io.reactivex.Single<Long> rxDecr(String key)

Decrement the integer value of a key by one

Parameters:

key - Key string

Returns:

decrby

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

Decrement the integer value of a key by the given number

Parameters:

key - Key string

decrement - Value by which to decrement

handler - Handler for the result of this call.

Returns:

rxDecrby

public io.reactivex.Single<Long> rxDecrby(String key,
                                          long decrement)

Decrement the integer value of a key by the given number

Parameters:

key - Key string

decrement - Value by which to decrement

Returns:

del

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

Delete a key

Parameters:

key - Keys to delete

handler - Handler for the result of this call.

Returns:

rxDel

public io.reactivex.Single<Long> rxDel(String key)

Delete a key

Parameters:

key - Keys to delete

Returns:

delMany

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

Delete many keys

Parameters:

keys - List of keys to delete

handler - Handler for the result of this call.

Returns:

rxDelMany

public io.reactivex.Single<Long> rxDelMany(List<String> keys)

Delete many keys

Parameters:

keys - List of keys to delete

Returns:

dump

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

Return a serialized version of the value stored at the specified key.

Parameters:

key - Key string

handler - Handler for the result of this call.

Returns:

rxDump

public io.reactivex.Single<String> rxDump(String key)

Return a serialized version of the value stored at the specified key.

Parameters:

key - Key string

Returns:

echo

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

Echo the given string

Parameters:

message - String to echo

handler - Handler for the result of this call.

Returns:

rxEcho

public io.reactivex.Single<String> rxEcho(String message)

Echo the given string

Parameters:

message - String to echo

Returns:

eval

public RedisClient eval(String script,
                        List<String> keys,
                        List<String> args,
                        Handler<AsyncResult<JsonArray>> handler)

Execute a Lua script server side. Due to the dynamic nature of this command any response type could be returned for This reason and to ensure type safety the reply is always guaranteed to be a JsonArray. When a reply if for example a String the handler will be called with a JsonArray with a single element containing the String.

Parameters:

script - Lua script to evaluate

keys - List of keys

args - List of argument values

handler - Handler for the result of this call.

Returns:

rxEval

public io.reactivex.Single<JsonArray> rxEval(String script,
                                             List<String> keys,
                                             List<String> args)

Execute a Lua script server side. Due to the dynamic nature of this command any response type could be returned for This reason and to ensure type safety the reply is always guaranteed to be a JsonArray. When a reply if for example a String the handler will be called with a JsonArray with a single element containing the String.

Parameters:

script - Lua script to evaluate

keys - List of keys

args - List of argument values

Returns:

evalsha

public RedisClient evalsha(String sha1,
                           List<String> keys,
                           List<String> values,
                           Handler<AsyncResult<JsonArray>> handler)

Execute a Lua script server side. Due to the dynamic nature of this command any response type could be returned for This reason and to ensure type safety the reply is always guaranteed to be a JsonArray. When a reply if for example a String the handler will be called with a JsonArray with a single element containing the String.

Parameters:

sha1 - SHA1 digest of the script cached on the server

keys - List of keys

values - List of values

handler - Handler for the result of this call.

Returns:

rxEvalsha

public io.reactivex.Single<JsonArray> rxEvalsha(String sha1,
                                                List<String> keys,
                                                List<String> values)

Execute a Lua script server side. Due to the dynamic nature of this command any response type could be returned for This reason and to ensure type safety the reply is always guaranteed to be a JsonArray. When a reply if for example a String the handler will be called with a JsonArray with a single element containing the String.

Parameters:

sha1 - SHA1 digest of the script cached on the server

keys - List of keys

values - List of values

Returns:

evalScript

public RedisClient evalScript(Script script,
                              List<String> keys,
                              List<String> args,
                              Handler<AsyncResult<JsonArray>> handler)

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

Parameters:

script - Lua script and its SHA1 digest

keys - List of keys

args - List of argument values

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

Returns:

rxEvalScript

public io.reactivex.Single<JsonArray> rxEvalScript(Script script,
                                                   List<String> keys,
                                                   List<String> args)

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

Parameters:

script - Lua script and its SHA1 digest

keys - List of keys

args - List of argument values

Returns:

exists

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

Determine if a key exists

Parameters:

key - Key string

handler - Handler for the result of this call.

Returns:

rxExists

public io.reactivex.Single<Long> rxExists(String key)

Determine if a key exists

Parameters:

key - Key string

Returns:

existsMany

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

Determine if one or many keys exist

Parameters:

keys - List of key strings

handler - Handler for the result of this call.

Returns:

rxExistsMany

public io.reactivex.Single<Long> rxExistsMany(List<String> keys)

Determine if one or many keys exist

Parameters:

keys - List of key strings

Returns:

expire

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

Set a key's time to live in seconds

Parameters:

key - Key string

seconds - Time to live in seconds

handler - Handler for the result of this call.

Returns:

rxExpire

public io.reactivex.Single<Long> rxExpire(String key,
                                          long seconds)

Set a key's time to live in seconds

Parameters:

key - Key string

seconds - Time to live in seconds

Returns:

expireat

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

Set the expiration for a key as a UNIX timestamp

Parameters:

key - Key string

seconds - Expiry time as Unix timestamp in seconds

handler - Handler for the result of this call.

Returns:

rxExpireat

public io.reactivex.Single<Long> rxExpireat(String key,
                                            long seconds)

Set the expiration for a key as a UNIX timestamp

Parameters:

key - Key string

seconds - Expiry time as Unix timestamp in seconds

Returns:

flushall

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

Remove all keys from all databases

Parameters:

handler -

Returns:

rxFlushall

public io.reactivex.Single<String> rxFlushall()

Remove all keys from all databases

Returns:

flushdb

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

Remove all keys from the current database

Parameters:

handler -

Returns:

rxFlushdb

public io.reactivex.Single<String> rxFlushdb()

Remove all keys from the current database

Returns:

get

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

Get the value of a key

Parameters:

key - Key string

handler - Handler for the result of this call.

Returns:

rxGet

public io.reactivex.Maybe<String> rxGet(String key)

Get the value of a key

Parameters:

key - Key string

Returns:

getBinary

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

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

Parameters:

key - Key string

handler - Handler for the result of this call.

Returns:

rxGetBinary

public io.reactivex.Maybe<Buffer> rxGetBinary(String key)

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

Parameters:

key - Key string

Returns:

getbit

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

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

Parameters:

key - Key string

offset - Offset in bits

handler - Handler for the result of this call.

Returns:

rxGetbit

public io.reactivex.Single<Long> rxGetbit(String key,
                                          long offset)

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

Parameters:

key - Key string

offset - Offset in bits

Returns:

getrange

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

Get a substring of the string stored at a key

Parameters:

key - Key string

start - Start offset

end - End offset - inclusive

handler - Handler for the result of this call.

Returns:

rxGetrange

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

Get a substring of the string stored at a key

Parameters:

key - Key string

start - Start offset

end - End offset - inclusive

Returns:

getset

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

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

Parameters:

key - Key of which value to set

value - New value for the key

handler - Handler for the result of this call.

Returns:

rxGetset

public io.reactivex.Maybe<String> rxGetset(String key,
                                           String value)

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

Parameters:

key - Key of which value to set

value - New value for the key

Returns:

hdel

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

Delete one or more hash fields

Parameters:

key - Key string

field - Field name

handler - Handler for the result of this call.

Returns:

rxHdel

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

Delete one or more hash fields

Parameters:

key - Key string

field - Field name

Returns:

hdelMany

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

Delete one or more hash fields

Parameters:

key - Key string

fields - Field names

handler - Handler for the result of this call.

Returns:

rxHdelMany

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

Delete one or more hash fields

Parameters:

key - Key string

fields - Field names

Returns:

hexists

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

Determine if a hash field exists

Parameters:

key - Key string

field - Field name

handler - Handler for the result of this call.

Returns:

rxHexists

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

Determine if a hash field exists

Parameters:

key - Key string

field - Field name

Returns:

hget

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

Get the value of a hash field

Parameters:

key - Key string

field - Field name

handler - Handler for the result of this call.

Returns:

rxHget

public io.reactivex.Maybe<String> rxHget(String key,
                                         String field)

Get the value of a hash field

Parameters:

key - Key string

field - Field name

Returns:

hgetall

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

Get all the fields and values in a hash

Parameters:

key - Key string

handler - Handler for the result of this call.

Returns:

rxHgetall

public io.reactivex.Single<JsonObject> rxHgetall(String key)

Get all the fields and values in a hash

Parameters:

key - Key string

Returns:

hincrby

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

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

Parameters:

key - Key string

field - Field name

increment - Value by which to increment

handler - Handler for the result of this call.

Returns:

rxHincrby

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

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

Parameters:

key - Key string

field - Field name

increment - Value by which to increment

Returns:

hincrbyfloat

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

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

Parameters:

key - Key string

field - Field name

increment - Value by which to increment

handler - Handler for the result of this call.

Returns:

rxHincrbyfloat

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

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

Parameters:

key - Key string

field - Field name

increment - Value by which to increment

Returns:

hkeys

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

Get all the fields in a hash

Parameters:

key - Key string

handler - Handler for the result of this call.

Returns:

rxHkeys

public io.reactivex.Single<JsonArray> rxHkeys(String key)

Get all the fields in a hash

Parameters:

key - Key string

Returns:

hlen

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

Get the number of fields in a hash

Parameters:

key - Key string

handler - Handler for the result of this call.

Returns:

rxHlen

public io.reactivex.Single<Long> rxHlen(String key)

Get the number of fields in a hash

Parameters:

key - Key string

Returns:

hmget

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

Get the values of all the given hash fields

Parameters:

key - Key string

fields - Field names

handler - Handler for the result of this call.

Returns:

rxHmget

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

Get the values of all the given hash fields

Parameters:

key - Key string

fields - Field names

Returns:

hmset

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

Set multiple hash fields to multiple values

Parameters:

key - Key string

values - Map of field:value pairs

handler - Handler for the result of this call.

Returns:

rxHmset

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

Set multiple hash fields to multiple values

Parameters:

key - Key string

values - Map of field:value pairs

Returns:

hset

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

Set the string value of a hash field

Parameters:

key - Key string

field - Field name

value - New value

handler - Handler for the result of this call.

Returns:

rxHset

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

Set the string value of a hash field

Parameters:

key - Key string

field - Field name

value - New value

Returns:

hsetnx

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

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

Parameters:

key - Key string

field - Field name

value - New value

handler - Handler for the result of this call.

Returns:

rxHsetnx

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

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

Parameters:

key - Key string

field - Field name

value - New value

Returns:

hvals

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

Get all the values in a hash

Parameters:

key - Key string

handler - Handler for the result of this call.

Returns:

rxHvals

public io.reactivex.Single<JsonArray> rxHvals(String key)

Get all the values in a hash

Parameters:

key - Key string

Returns:

incr

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

Increment the integer value of a key by one

Parameters:

key - Key string

handler - Handler for the result of this call.

Returns:

rxIncr

public io.reactivex.Single<Long> rxIncr(String key)

Increment the integer value of a key by one

Parameters:

key - Key string

Returns:

incrby

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

Increment the integer value of a key by the given amount

Parameters:

key - Key string

increment - Value by which to increment

handler - Handler for the result of this call.

Returns:

rxIncrby

public io.reactivex.Single<Long> rxIncrby(String key,
                                          long increment)

Increment the integer value of a key by the given amount

Parameters:

key - Key string

increment - Value by which to increment

Returns:

incrbyfloat

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

Increment the float value of a key by the given amount

Parameters:

key - Key string

increment - Value by which to increment

handler - Handler for the result of this call.

Returns:

rxIncrbyfloat

public io.reactivex.Single<String> rxIncrbyfloat(String key,
                                                 double increment)

Increment the float value of a key by the given amount

Parameters:

key - Key string

increment - Value by which to increment

Returns:

info

public RedisClient info(Handler<AsyncResult<JsonObject>> handler)

Get information and statistics about the server

Parameters:

handler - Handler for the result of this call.

Returns:

rxInfo

public io.reactivex.Single<JsonObject> rxInfo()

Get information and statistics about the server

Returns:

infoSection

public RedisClient infoSection(String section,
                               Handler<AsyncResult<JsonObject>> handler)

Get information and statistics about the server

Parameters:

section - Specific section of information to return

handler - Handler for the result of this call.

Returns:

rxInfoSection

public io.reactivex.Single<JsonObject> rxInfoSection(String section)

Get information and statistics about the server

Parameters:

section - Specific section of information to return

Returns:

keys

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

Find all keys matching the given pattern

Parameters:

pattern - Pattern to limit the keys returned

handler - Handler for the result of this call.

Returns:

rxKeys

public io.reactivex.Single<JsonArray> rxKeys(String pattern)

Find all keys matching the given pattern

Parameters:

pattern - Pattern to limit the keys returned

Returns:

lastsave

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

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

Parameters:

handler -

Returns:

rxLastsave

public io.reactivex.Single<Long> rxLastsave()

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

Returns:

lindex

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

Get an element from a list by its index

Parameters:

key - Key string

index - Index of list element to get

handler - Handler for the result of this call.

Returns:

rxLindex

public io.reactivex.Single<String> rxLindex(String key,
                                            int index)

Get an element from a list by its index

Parameters:

key - Key string

index - Index of list element to get

Returns:

linsert

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

Insert an element before or after another element in a list

Parameters:

key - Key string

option - BEFORE or AFTER

pivot - Key to use as a pivot

value - Value to be inserted before or after the pivot

handler - Handler for the result of this call.

Returns:

rxLinsert

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

Insert an element before or after another element in a list

Parameters:

key - Key string

option - BEFORE or AFTER

pivot - Key to use as a pivot

value - Value to be inserted before or after the pivot

Returns:

llen

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

Get the length of a list

Parameters:

key - String key

handler - Handler for the result of this call.

Returns:

rxLlen

public io.reactivex.Single<Long> rxLlen(String key)

Get the length of a list

Parameters:

key - String key

Returns:

lpop

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

Remove and get the first element in a list

Parameters:

key - String key

handler - Handler for the result of this call.

Returns:

rxLpop

public io.reactivex.Maybe<String> rxLpop(String key)

Remove and get the first element in a list

Parameters:

key - String key

Returns:

lpushMany

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

Prepend one or multiple values to a list

Parameters:

key - Key string

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

handler - Handler for the result of this call.

Returns:

rxLpushMany

public io.reactivex.Single<Long> rxLpushMany(String key,
                                             List<String> values)

Prepend one or multiple values to a list

Parameters:

key - Key string

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

Returns:

lpush

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

Prepend one value to a list

Parameters:

key - Key string

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

handler - Handler for the result of this call.

Returns:

rxLpush

public io.reactivex.Single<Long> rxLpush(String key,
                                         String value)

Prepend one value to a list

Parameters:

key - Key string

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

Returns:

lpushx

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

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

Parameters:

key - Key string

value - Value to add at the beginning of the list

handler - Handler for the result of this call.

Returns:

rxLpushx

public io.reactivex.Single<Long> rxLpushx(String key,
                                          String value)

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

Parameters:

key - Key string

value - Value to add at the beginning of the list

Returns:

lrange

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

Get a range of elements from a list

Parameters:

key - Key string

from - Start index

to - Stop index

handler - Handler for the result of this call.

Returns:

rxLrange

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

Get a range of elements from a list

Parameters:

key - Key string

from - Start index

to - Stop index

Returns:

lrem

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

Remove elements from a list

Parameters:

key - Key string

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

value - Value to be removed

handler - Handler for the result of this call.

Returns:

rxLrem

public io.reactivex.Single<Long> rxLrem(String key,
                                        long count,
                                        String value)

Remove elements from a list

Parameters:

key - Key string

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

value - Value to be removed

Returns:

lset

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

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

Parameters:

key - Key string

index - Position within list

value - New value

handler - Handler for the result of this call.

Returns:

rxLset

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

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

Parameters:

key - Key string

index - Position within list

value - New value

Returns:

ltrim

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

Trim a list to the specified range

Parameters:

key - Key string

from - Start index

to - Stop index

handler - Handler for the result of this call.

Returns:

rxLtrim

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

Trim a list to the specified range

Parameters:

key - Key string

from - Start index

to - Stop index

Returns:

mget

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

Get the value of the given key

Parameters:

key - Key string

handler - Handler for the result of this call.

Returns:

rxMget

public io.reactivex.Single<JsonArray> rxMget(String key)

Get the value of the given key

Parameters:

key - Key string

Returns:

mgetMany

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

Get the values of all the given keys

Parameters:

keys - List of keys to get

handler - Handler for the result of this call.

Returns:

rxMgetMany

public io.reactivex.Single<JsonArray> rxMgetMany(List<String> keys)

Get the values of all the given keys

Parameters:

keys - List of keys to get

Returns:

migrate

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

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

Parameters:

host - Destination host

port - Destination port

key - Key to migrate

destdb - Destination database index

timeout -

options - Migrate options

handler - Handler for the result of this call.

Returns:

rxMigrate

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

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

Parameters:

host - Destination host

port - Destination port

key - Key to migrate

destdb - Destination database index

timeout -

options - Migrate options

Returns:

monitor

public RedisClient monitor(Handler<AsyncResult<Void>> handler)

Listen for all requests received by the server in real time

Parameters:

handler -

Returns:

rxMonitor

public io.reactivex.Completable rxMonitor()

Listen for all requests received by the server in real time

Returns:

move

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

Move a key to another database

Parameters:

key - Key to migrate

destdb - Destination database index

handler - Handler for the result of this call.

Returns:

rxMove

public io.reactivex.Single<Long> rxMove(String key,
                                        int destdb)

Move a key to another database

Parameters:

key - Key to migrate

destdb - Destination database index

Returns:

mset

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

Set multiple keys to multiple values

Parameters:

keyvals - Key value pairs to set

handler - Handler for the result of this call.

Returns:

rxMset

public io.reactivex.Single<String> rxMset(JsonObject keyvals)

Set multiple keys to multiple values

Parameters:

keyvals - Key value pairs to set

Returns:

msetnx

public RedisClient msetnx(JsonObject keyvals,
                          Handler<AsyncResult<Long>> handler)

Set multiple keys to multiple values, only if none of the keys exist

Parameters:

keyvals - Key value pairs to set

handler - Handler for the result of this call.

Returns:

rxMsetnx

public io.reactivex.Single<Long> rxMsetnx(JsonObject keyvals)

Set multiple keys to multiple values, only if none of the keys exist

Parameters:

keyvals - Key value pairs to set

Returns:

object

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

Inspect the internals of Redis objects

Parameters:

key - Key string

cmd - Object sub command

handler - Handler for the result of this call.

Returns:

rxObject

public io.reactivex.Completable rxObject(String key,
                                         ObjectCmd cmd)

Inspect the internals of Redis objects

Parameters:

key - Key string

cmd - Object sub command

Returns:

persist

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

Remove the expiration from a key

Parameters:

key - Key string

handler - Handler for the result of this call.

Returns:

rxPersist

public io.reactivex.Single<Long> rxPersist(String key)

Remove the expiration from a key

Parameters:

key - Key string

Returns:

pexpire

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

Set a key's time to live in milliseconds

Parameters:

key - String key

millis - Time to live in milliseconds

handler - Handler for the result of this call.

Returns:

rxPexpire

public io.reactivex.Single<Long> rxPexpire(String key,
                                           long millis)

Set a key's time to live in milliseconds

Parameters:

key - String key

millis - Time to live in milliseconds

Returns:

pexpireat

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

Set the expiration for a key as a UNIX timestamp specified in milliseconds

Parameters:

key - Key string

millis - Expiry time as Unix timestamp in milliseconds

handler - Handler for the result of this call.

Returns:

rxPexpireat

public io.reactivex.Single<Long> rxPexpireat(String key,
                                             long millis)

Set the expiration for a key as a UNIX timestamp specified in milliseconds

Parameters:

key - Key string

millis - Expiry time as Unix timestamp in milliseconds

Returns:

pfadd

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

Adds the specified element to the specified HyperLogLog.

Parameters:

key - Key string

element - Element to add

handler - Handler for the result of this call.

Returns:

rxPfadd

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

Adds the specified element to the specified HyperLogLog.

Parameters:

key - Key string

element - Element to add

Returns:

pfaddMany

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

Adds the specified elements to the specified HyperLogLog.

Parameters:

key - Key string

elements - Elementa to add

handler - Handler for the result of this call.

Returns:

rxPfaddMany

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

Adds the specified elements to the specified HyperLogLog.

Parameters:

key - Key string

elements - Elementa to add

Returns:

pfcount

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

Return the approximated cardinality of the set observed by the HyperLogLog at key.

Parameters:

key - Key string

handler - Handler for the result of this call.

Returns:

rxPfcount

public io.reactivex.Single<Long> rxPfcount(String key)

Return the approximated cardinality of the set observed by the HyperLogLog at key.

Parameters:

key - Key string

Returns:

pfcountMany

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

Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).

Parameters:

keys - List of keys

handler - Handler for the result of this call.

Returns:

rxPfcountMany

public io.reactivex.Single<Long> rxPfcountMany(List<String> keys)

Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).

Parameters:

keys - List of keys

Returns:

pfmerge

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

Merge N different HyperLogLogs into a single one.

Parameters:

destkey - Destination key

keys - List of source keys

handler - Handler for the result of this call.

Returns:

rxPfmerge

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

Merge N different HyperLogLogs into a single one.

Parameters:

destkey - Destination key

keys - List of source keys

Returns:

ping

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

Ping the server

Parameters:

handler -

Returns:

rxPing

public io.reactivex.Single<String> rxPing()

Ping the server

Returns:

psetex

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

Set the value and expiration in milliseconds of a key

Parameters:

key - Key string

millis - Number of milliseconds until the key expires

value - New value for key

handler - Handler for the result of this call.

Returns:

rxPsetex

public io.reactivex.Completable rxPsetex(String key,
                                         long millis,
                                         String value)

Set the value and expiration in milliseconds of a key

Parameters:

key - Key string

millis - Number of milliseconds until the key expires

value - New value for key

Returns:

psubscribe

public RedisClient psubscribe(String pattern,
                              Handler<AsyncResult<JsonArray>> handler)

Listen for messages published to channels matching the given pattern

Parameters:

pattern - Pattern string

handler - Handler for the result of this call.

Returns:

rxPsubscribe

public io.reactivex.Single<JsonArray> rxPsubscribe(String pattern)

Listen for messages published to channels matching the given pattern

Parameters:

pattern - Pattern string

Returns:

psubscribeMany

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

Listen for messages published to channels matching the given patterns

Parameters:

patterns - List of patterns

handler - Handler for the result of this call.

Returns:

rxPsubscribeMany

public io.reactivex.Single<JsonArray> rxPsubscribeMany(List<String> patterns)

Listen for messages published to channels matching the given patterns

Parameters:

patterns - List of patterns

Returns:

pubsubChannels

public RedisClient pubsubChannels(String pattern,
                                  Handler<AsyncResult<JsonArray>> handler)

Lists the currently active channels - only those matching the pattern

Parameters:

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

handler - Handler for the result of this call.

Returns:

rxPubsubChannels

public io.reactivex.Single<JsonArray> rxPubsubChannels(String pattern)

Lists the currently active channels - only those matching the pattern

Parameters:

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

Returns:

pubsubNumsub

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

Returns the number of subscribers (not counting clients subscribed to patterns) for the specified channels

Parameters:

channels - List of channels

handler - Handler for the result of this call.

Returns:

rxPubsubNumsub

public io.reactivex.Single<JsonArray> rxPubsubNumsub(List<String> channels)

Returns the number of subscribers (not counting clients subscribed to patterns) for the specified channels

Parameters:

channels - List of channels

Returns:

pubsubNumpat

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

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

Parameters:

handler - Handler for the result of this call.

Returns:

rxPubsubNumpat

public io.reactivex.Single<Long> rxPubsubNumpat()

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

Returns:

pttl

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

Get the time to live for a key in milliseconds

Parameters:

key - Key string

handler - Handler for the result of this call.

Returns:

rxPttl

public io.reactivex.Single<Long> rxPttl(String key)

Get the time to live for a key in milliseconds

Parameters:

key - Key string

Returns:

publish

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

Post a message to a channel

Parameters:

channel - Channel key

message - Message to send to channel

handler - Handler for the result of this call.

Returns:

rxPublish

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

Post a message to a channel

Parameters:

channel - Channel key

message - Message to send to channel

Returns:

punsubscribe

public RedisClient punsubscribe(List<String> patterns,
                                Handler<AsyncResult<Void>> handler)

Stop listening for messages posted to channels matching the given patterns

Parameters:

patterns - List of patterns to match against

handler - Handler for the result of this call.

Returns:

rxPunsubscribe

public io.reactivex.Completable rxPunsubscribe(List<String> patterns)

Stop listening for messages posted to channels matching the given patterns

Parameters:

patterns - List of patterns to match against

Returns:

randomkey

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

Return a random key from the keyspace

Parameters:

handler -

Returns:

rxRandomkey

public io.reactivex.Single<String> rxRandomkey()

Return a random key from the keyspace

Returns:

rename

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

Rename a key

Parameters:

key - Key string to be renamed

newkey - New key string

handler - Handler for the result of this call.

Returns:

rxRename

public io.reactivex.Single<String> rxRename(String key,
                                            String newkey)

Rename a key

Parameters:

key - Key string to be renamed

newkey - New key string

Returns:

renamenx

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

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

Parameters:

key - Key string to be renamed

newkey - New key string

handler - Handler for the result of this call.

Returns:

rxRenamenx

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

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

Parameters:

key - Key string to be renamed

newkey - New key string

Returns:

restore

public RedisClient restore(String key,
                           long millis,
                           String serialized,
                           Handler<AsyncResult<String>> handler)

Create a key using the provided serialized value, previously obtained using DUMP.

Parameters:

key - Key string

millis - Expiry time in milliseconds to set on the key

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

handler - Handler for the result of this call.

Returns:

rxRestore

public io.reactivex.Single<String> rxRestore(String key,
                                             long millis,
                                             String serialized)

Create a key using the provided serialized value, previously obtained using DUMP.

Parameters:

key - Key string

millis - Expiry time in milliseconds to set on the key

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

Returns:

role

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

Return the role of the instance in the context of replication

Parameters:

handler -

Returns:

rxRole

public io.reactivex.Single<JsonArray> rxRole()

Return the role of the instance in the context of replication

Returns:

rpop

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

Remove and get the last element in a list

Parameters:

key - Key string

handler - Handler for the result of this call.

Returns:

rxRpop

public io.reactivex.Single<String> rxRpop(String key)

Remove and get the last element in a list

Parameters:

key - Key string

Returns:

rpoplpush

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

Remove the last element in a list, append it to another list and return it

Parameters:

key - Key string identifying source list

destkey - Key string identifying destination list

handler - Handler for the result of this call.

Returns:

rxRpoplpush

public io.reactivex.Single<String> rxRpoplpush(String key,
                                               String destkey)

Remove the last element in a list, append it to another list and return it

Parameters:

key - Key string identifying source list

destkey - Key string identifying destination list

Returns:

rpushMany

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

Append one or multiple values to a list

Parameters:

key - Key string

values - List of values to add to the end of the list

handler - Handler for the result of this call.

Returns:

rxRpushMany

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

Append one or multiple values to a list

Parameters:

key - Key string

values - List of values to add to the end of the list

Returns:

rpush

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

Append one or multiple values to a list

Parameters:

key - Key string

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

handler - Handler for the result of this call.

Returns:

rxRpush

public io.reactivex.Single<Long> rxRpush(String key,
                                         String value)

Append one or multiple values to a list

Parameters:

key - Key string

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

Returns:

rpushx

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

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

Parameters:

key - Key string

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

handler - Handler for the result of this call.

Returns:

rxRpushx

public io.reactivex.Single<Long> rxRpushx(String key,
                                          String value)

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

Parameters:

key - Key string

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

Returns:

sadd

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

Add a member to a set

Parameters:

key - Key string

member - Value to be added to the set

handler - Handler for the result of this call.

Returns:

rxSadd

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

Add a member to a set

Parameters:

key - Key string

member - Value to be added to the set

Returns:

saddMany

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

Add one or more members to a set

Parameters:

key - Key string

members - Values to be added to the set

handler - Handler for the result of this call.

Returns:

rxSaddMany

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

Add one or more members to a set

Parameters:

key - Key string

members - Values to be added to the set

Returns:

save

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

Synchronously save the dataset to disk

Parameters:

handler -

Returns:

rxSave

public io.reactivex.Single<String> rxSave()

Synchronously save the dataset to disk

Returns:

scard

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

Get the number of members in a set

Parameters:

key - Key string

handler - Handler for the result of this call.

Returns:

rxScard

public io.reactivex.Single<Long> rxScard(String key)

Get the number of members in a set

Parameters:

key - Key string

Returns:

scriptExists

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

Check existence of script in the script cache.

Parameters:

script - SHA1 digest identifying a script in the script cache

handler - Handler for the result of this call.

Returns:

rxScriptExists

public io.reactivex.Single<JsonArray> rxScriptExists(String script)

Check existence of script in the script cache.

Parameters:

script - SHA1 digest identifying a script in the script cache

Returns:

scriptExistsMany

public RedisClient scriptExistsMany(List<String> scripts,
                                    Handler<AsyncResult<JsonArray>> handler)

Check existence of scripts in the script cache.

Parameters:

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

handler - Handler for the result of this call.

Returns:

rxScriptExistsMany

public io.reactivex.Single<JsonArray> rxScriptExistsMany(List<String> scripts)

Check existence of scripts in the script cache.

Parameters:

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

Returns:

scriptFlush

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

Remove all the scripts from the script cache.

Parameters:

handler -

Returns:

rxScriptFlush

public io.reactivex.Single<String> rxScriptFlush()

Remove all the scripts from the script cache.

Returns:

scriptKill

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

Kill the script currently in execution.

Parameters:

handler -

Returns:

rxScriptKill

public io.reactivex.Single<String> rxScriptKill()

Kill the script currently in execution.

Returns:

scriptLoad

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

Load the specified Lua script into the script cache.

Parameters:

script - Lua script

handler - Handler for the result of this call.

Returns:

rxScriptLoad

public io.reactivex.Single<String> rxScriptLoad(String script)

Load the specified Lua script into the script cache.

Parameters:

script - Lua script

Returns:

sdiff

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

Subtract multiple sets

Parameters:

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

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

handler - Handler for the result of this call.

Returns:

rxSdiff

public io.reactivex.Single<JsonArray> rxSdiff(String key,
                                              List<String> cmpkeys)

Subtract multiple sets

Parameters:

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

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

Returns:

sdiffstore

public RedisClient sdiffstore(String destkey,
                              String key,
                              List<String> cmpkeys,
                              Handler<AsyncResult<Long>> handler)

Subtract multiple sets and store the resulting set in a key

Parameters:

destkey - Destination key where the result should be stored

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

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

handler - Handler for the result of this call.

Returns:

rxSdiffstore

public io.reactivex.Single<Long> rxSdiffstore(String destkey,
                                              String key,
                                              List<String> cmpkeys)

Subtract multiple sets and store the resulting set in a key

Parameters:

destkey - Destination key where the result should be stored

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

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

Returns:

select

public RedisClient select(int dbindex,
                          Handler<AsyncResult<String>> handler)

Change the selected database for the current connection

Parameters:

dbindex - Index identifying the new active database

handler - Handler for the result of this call.

Returns:

rxSelect

public io.reactivex.Single<String> rxSelect(int dbindex)

Change the selected database for the current connection

Parameters:

dbindex - Index identifying the new active database

Returns:

set

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

Set the string value of a key

Parameters:

key - Key of which value to set

value - New value for the key

handler - Handler for the result of this call.

Returns:

rxSet

public io.reactivex.Completable rxSet(String key,
                                      String value)

Set the string value of a key

Parameters:

key - Key of which value to set

value - New value for the key

Returns:

setWithOptions

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

Set the string value of a key

Parameters:

key - Key of which value to set

value - New value for the key

options - Set options

handler - Handler for the result of this call.

Returns:

rxSetWithOptions

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

Set the string value of a key

Parameters:

key - Key of which value to set

value - New value for the key

options - Set options

Returns:

setBinary

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

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

Parameters:

key - Key of which value to set

value - New value for the key

handler - Handler for the result of this call.

Returns:

rxSetBinary

public io.reactivex.Completable rxSetBinary(String key,
                                            Buffer value)

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

Parameters:

key - Key of which value to set

value - New value for the key

Returns:

setBinaryWithOptions

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

Set the string value of a key

Parameters:

key - Key of which value to set

value - New value for the key

options - Set options

handler - Handler for the result of this call.

Returns:

rxSetBinaryWithOptions

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

Set the string value of a key

Parameters:

key - Key of which value to set

value - New value for the key

options - Set options

Returns:

setbit

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

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

Parameters:

key - Key string

offset - Bit offset

bit - New value - must be 1 or 0

handler - Handler for the result of this call.

Returns:

rxSetbit

public io.reactivex.Single<Long> rxSetbit(String key,
                                          long offset,
                                          int bit)

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

Parameters:

key - Key string

offset - Bit offset

bit - New value - must be 1 or 0

Returns:

setex

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

Set the value and expiration of a key

Parameters:

key - Key string

seconds - Number of seconds until the key expires

value - New value for key

handler - Handler for the result of this call.

Returns:

rxSetex

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

Set the value and expiration of a key

Parameters:

key - Key string

seconds - Number of seconds until the key expires

value - New value for key

Returns:

setnx

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

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

Parameters:

key - Key of which value to set

value - New value for the key

handler - Handler for the result of this call.

Returns:

rxSetnx

public io.reactivex.Single<Long> rxSetnx(String key,
                                         String value)

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

Parameters:

key - Key of which value to set

value - New value for the key

Returns:

setrange

public RedisClient setrange(String key,
                            int offset,
                            String value,
                            Handler<AsyncResult<Long>> handler)

Overwrite part of a string at key starting at the specified offset

Parameters:

key - Key string

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

value - Value to overwrite with

handler - Handler for the result of this call.

Returns:

rxSetrange

public io.reactivex.Single<Long> rxSetrange(String key,
                                            int offset,
                                            String value)

Overwrite part of a string at key starting at the specified offset

Parameters:

key - Key string

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

value - Value to overwrite with

Returns:

sinter

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

Intersect multiple sets

Parameters:

keys - List of keys to perform intersection on

handler - Handler for the result of this call.

Returns:

rxSinter

public io.reactivex.Single<JsonArray> rxSinter(List<String> keys)

Intersect multiple sets

Parameters:

keys - List of keys to perform intersection on

Returns:

sinterstore

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

Intersect multiple sets and store the resulting set in a key

Parameters:

destkey - Key where to store the results

keys - List of keys to perform intersection on

handler - Handler for the result of this call.

Returns:

rxSinterstore

public io.reactivex.Single<Long> rxSinterstore(String destkey,
                                               List<String> keys)

Intersect multiple sets and store the resulting set in a key

Parameters:

destkey - Key where to store the results

keys - List of keys to perform intersection on

Returns:

sismember

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

Determine if a given value is a member of a set

Parameters:

key - Key string

member - Member to look for

handler - Handler for the result of this call.

Returns:

rxSismember

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

Determine if a given value is a member of a set

Parameters:

key - Key string

member - Member to look for

Returns:

slaveof

public RedisClient slaveof(String host,
                           int port,
                           Handler<AsyncResult<String>> handler)

Make the server a slave of another instance

Parameters:

host - Host to become this server's master

port - Port of our new master

handler - Handler for the result of this call.

Returns:

rxSlaveof

public io.reactivex.Single<String> rxSlaveof(String host,
                                             int port)

Make the server a slave of another instance

Parameters:

host - Host to become this server's master

port - Port of our new master

Returns:

slaveofNoone

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

Make this server a master

Parameters:

handler - Handler for the result of this call.

Returns:

rxSlaveofNoone

public io.reactivex.Single<String> rxSlaveofNoone()

Make this server a master

Returns:

slowlogGet

public RedisClient slowlogGet(int limit,
                              Handler<AsyncResult<JsonArray>> handler)

Read the Redis slow queries log

Parameters:

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

handler - Handler for the result of this call.

Returns:

rxSlowlogGet

public io.reactivex.Single<JsonArray> rxSlowlogGet(int limit)

Read the Redis slow queries log

Parameters:

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

Returns:

slowlogLen

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

Get the length of the Redis slow queries log

Parameters:

handler - Handler for the result of this call.

Returns:

rxSlowlogLen

public io.reactivex.Single<Long> rxSlowlogLen()

Get the length of the Redis slow queries log

Returns:

slowlogReset

public RedisClient slowlogReset(Handler<AsyncResult<Void>> handler)

Reset the Redis slow queries log

Parameters:

handler - Handler for the result of this call.

Returns:

rxSlowlogReset

public io.reactivex.Completable rxSlowlogReset()

Reset the Redis slow queries log

Returns:

smembers

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

Get all the members in a set

Parameters:

key - Key string

handler - Handler for the result of this call.

Returns:

rxSmembers

public io.reactivex.Single<JsonArray> rxSmembers(String key)

Get all the members in a set

Parameters:

key - Key string

Returns:

smove

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

Move a member from one set to another

Parameters:

key - Key of source set currently containing the member

destkey - Key identifying the destination set

member - Member to move

handler - Handler for the result of this call.

Returns:

rxSmove

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

Move a member from one set to another

Parameters:

key - Key of source set currently containing the member

destkey - Key identifying the destination set

member - Member to move

Returns:

sort

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

Sort the elements in a list, set or sorted set

Parameters:

key - Key string

options - Sort options

handler - Handler for the result of this call.

Returns:

rxSort

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

Sort the elements in a list, set or sorted set

Parameters:

key - Key string

options - Sort options

Returns:

spop

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

Remove and return a random member from a set

Parameters:

key - Key string

handler - Handler for the result of this call.

Returns:

rxSpop

public io.reactivex.Maybe<String> rxSpop(String key)

Remove and return a random member from a set

Parameters:

key - Key string

Returns:

spopMany

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

Remove and return random members from a set

Parameters:

key - Key string

count - Number of members to remove

handler - Handler for the result of this call.

Returns:

rxSpopMany

public io.reactivex.Single<JsonArray> rxSpopMany(String key,
                                                 int count)

Remove and return random members from a set

Parameters:

key - Key string

count - Number of members to remove

Returns:

srandmember

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

Get one or multiple random members from a set

Parameters:

key - Key string

handler - Handler for the result of this call.

Returns:

rxSrandmember

public io.reactivex.Single<String> rxSrandmember(String key)

Get one or multiple random members from a set

Parameters:

key - Key string

Returns:

srandmemberCount

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

Get one or multiple random members from a set

Parameters:

key - Key string

count - Number of members to get

handler - Handler for the result of this call.

Returns:

rxSrandmemberCount

public io.reactivex.Single<JsonArray> rxSrandmemberCount(String key,
                                                         int count)

Get one or multiple random members from a set

Parameters:

key - Key string

count - Number of members to get

Returns:

srem

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

Remove one member from a set

Parameters:

key - Key string

member - Member to remove

handler - Handler for the result of this call.

Returns:

rxSrem

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

Remove one member from a set

Parameters:

key - Key string

member - Member to remove

Returns:

sremMany

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

Remove one or more members from a set

Parameters:

key - Key string

members - Members to remove

handler - Handler for the result of this call.

Returns:

rxSremMany

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

Remove one or more members from a set

Parameters:

key - Key string

members - Members to remove

Returns:

strlen

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

Get the length of the value stored in a key

Parameters:

key - Key string

handler - Handler for the result of this call.

Returns:

rxStrlen

public io.reactivex.Single<Long> rxStrlen(String key)

Get the length of the value stored in a key

Parameters:

key - Key string

Returns:

subscribe

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

Listen for messages published to the given channels

Parameters:

channel - Channel to subscribe to

handler - Handler for the result of this call.

Returns:

rxSubscribe

public io.reactivex.Single<JsonArray> rxSubscribe(String channel)

Listen for messages published to the given channels

Parameters:

channel - Channel to subscribe to

Returns:

subscribeMany

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

Listen for messages published to the given channels

Parameters:

channels - List of channels to subscribe to

handler - Handler for the result of this call.

Returns:

rxSubscribeMany

public io.reactivex.Single<JsonArray> rxSubscribeMany(List<String> channels)

Listen for messages published to the given channels

Parameters:

channels - List of channels to subscribe to

Returns:

sunion

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

Add multiple sets

Parameters:

keys - List of keys identifying sets to add up

handler - Handler for the result of this call.

Returns:

rxSunion

public io.reactivex.Single<JsonArray> rxSunion(List<String> keys)

Add multiple sets

Parameters:

keys - List of keys identifying sets to add up

Returns:

sunionstore

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

Add multiple sets and store the resulting set in a key

Parameters:

destkey - Destination key

keys - List of keys identifying sets to add up

handler - Handler for the result of this call.

Returns:

rxSunionstore

public io.reactivex.Single<Long> rxSunionstore(String destkey,
                                               List<String> keys)

Add multiple sets and store the resulting set in a key

Parameters:

destkey - Destination key

keys - List of keys identifying sets to add up

Returns:

sync

public RedisClient sync(Handler<AsyncResult<Void>> handler)

Internal command used for replication

Parameters:

handler -

Returns:

rxSync

public io.reactivex.Completable rxSync()

Internal command used for replication

Returns:

time

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

Return the current server time

Parameters:

handler -

Returns:

rxTime

public io.reactivex.Single<JsonArray> rxTime()

Return the current server time

Returns:

transaction

public RedisTransaction transaction()

Return a RedisTransaction instance

Returns:

transaction instance

ttl

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

Get the time to live for a key

Parameters:

key - Key string

handler - Handler for the result of this call.

Returns:

rxTtl

public io.reactivex.Single<Long> rxTtl(String key)

Get the time to live for a key

Parameters:

key - Key string

Returns:

type

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

Determine the type stored at key

Parameters:

key - Key string

handler - Handler for the result of this call.

Returns:

rxType

public io.reactivex.Single<String> rxType(String key)

Determine the type stored at key

Parameters:

key - Key string

Returns:

unsubscribe

public RedisClient unsubscribe(List<String> channels,
                               Handler<AsyncResult<Void>> handler)

Stop listening for messages posted to the given channels

Parameters:

channels - List of channels to subscribe to

handler - Handler for the result of this call.

Returns:

rxUnsubscribe

public io.reactivex.Completable rxUnsubscribe(List<String> channels)

Stop listening for messages posted to the given channels

Parameters:

channels - List of channels to subscribe to

Returns:

wait

public RedisClient wait(long numSlaves,
                        long timeout,
                        Handler<AsyncResult<String>> handler)

Wait for the synchronous replication of all the write commands sent in the context of the current connection.

Parameters:

numSlaves -

timeout -

handler - Handler for the result of this call.

Returns:

rxWait

public io.reactivex.Single<String> rxWait(long numSlaves,
                                          long timeout)

Wait for the synchronous replication of all the write commands sent in the context of the current connection.

Parameters:

numSlaves -

timeout -

Returns:

zadd

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

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

Parameters:

key - Key string

score - Score used for sorting

member - New member key

handler - Handler for the result of this call.

Returns:

rxZadd

public io.reactivex.Single<Long> rxZadd(String key,
                                        double score,
                                        String member)

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

Parameters:

key - Key string

score - Score used for sorting

member - New member key

Returns:

zaddMany

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

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

Parameters:

key - Key string

members - New member keys and their scores

handler - Handler for the result of this call.

Returns:

rxZaddMany

public io.reactivex.Single<Long> rxZaddMany(String key,
                                            Map<String,Double> members)

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

Parameters:

key - Key string

members - New member keys and their scores

Returns:

zcard

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

Get the number of members in a sorted set

Parameters:

key - Key string

handler - Handler for the result of this call.

Returns:

rxZcard

public io.reactivex.Single<Long> rxZcard(String key)

Get the number of members in a sorted set

Parameters:

key - Key string

Returns:

zcount

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

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

Parameters:

key - Key string

min - Minimum score

max - Maximum score

handler - Handler for the result of this call.

Returns:

rxZcount

public io.reactivex.Single<Long> rxZcount(String key,
                                          double min,
                                          double max)

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

Parameters:

key - Key string

min - Minimum score

max - Maximum score

Returns:

zincrby

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

Increment the score of a member in a sorted set

Parameters:

key - Key string

increment - Increment amount

member - Member key

handler - Handler for the result of this call.

Returns:

rxZincrby

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

Increment the score of a member in a sorted set

Parameters:

key - Key string

increment - Increment amount

member - Member key

Returns:

zinterstore

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

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

Parameters:

destkey - Destination key

sets - List of keys identifying sorted sets to intersect

options - Aggregation options

handler - Handler for the result of this call.

Returns:

rxZinterstore

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

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

Parameters:

destkey - Destination key

sets - List of keys identifying sorted sets to intersect

options - Aggregation options

Returns:

zinterstoreWeighed

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

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

Parameters:

destkey - Destination key

sets - List of keys identifying sorted sets to intersect

options - Aggregation options

handler - Handler for the result of this call.

Returns:

rxZinterstoreWeighed

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

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

Parameters:

destkey - Destination key

sets - List of keys identifying sorted sets to intersect

options - Aggregation options

Returns:

zlexcount

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

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

Parameters:

key - Key string

min - Pattern to compare against for minimum value

max - Pattern to compare against for maximum value

handler - Handler for the result of this call.

Returns:

rxZlexcount

public io.reactivex.Single<Long> rxZlexcount(String key,
                                             String min,
                                             String max)

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

Parameters:

key - Key string

min - Pattern to compare against for minimum value

max - Pattern to compare against for maximum value

Returns:

zrange

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

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

Parameters:

key - Key string

start - Start index for the range

stop - Stop index for the range - inclusive

handler - Handler for the result of this call.

Returns:

rxZrange

public io.reactivex.Single<JsonArray> rxZrange(String key,
                                               long start,
                                               long stop)

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

Parameters:

key - Key string

start - Start index for the range

stop - Stop index for the range - inclusive

Returns:

zrangeWithOptions

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

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

Parameters:

key - Key string

start - Start index for the range

stop - Stop index for the range - inclusive

options - Range options

handler - Handler for the result of this call.

Returns:

rxZrangeWithOptions

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

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

Parameters:

key - Key string

start - Start index for the range

stop - Stop index for the range - inclusive

options - Range options

Returns:

zrangebylex

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

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

Parameters:

key - Key string

min - Pattern representing a minimum allowed value

max - Pattern representing a maximum allowed value

options - Limit options where limit can be specified

handler - Handler for the result of this call.

Returns:

rxZrangebylex

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

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

Parameters:

key - Key string

min - Pattern representing a minimum allowed value

max - Pattern representing a maximum allowed value

options - Limit options where limit can be specified

Returns:

zrangebyscore

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

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

Parameters:

key - Key string

min - Pattern defining a minimum value

max - Pattern defining a maximum value

options - Range and limit options

handler - Handler for the result of this call.

Returns:

rxZrangebyscore

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

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

Parameters:

key - Key string

min - Pattern defining a minimum value

max - Pattern defining a maximum value

options - Range and limit options

Returns:

zrank

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

Determine the index of a member in a sorted set

Parameters:

key - Key string

member - Member in the sorted set identified by key

handler - Handler for the result of this call.

Returns:

rxZrank

public io.reactivex.Single<Long> rxZrank(String key,
                                         String member)

Determine the index of a member in a sorted set

Parameters:

key - Key string

member - Member in the sorted set identified by key

Returns:

zrem

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

Remove one member from a sorted set

Parameters:

key - Key string

member - Member in the sorted set identified by key

handler - Handler for the result of this call.

Returns:

rxZrem

public io.reactivex.Single<Long> rxZrem(String key,
                                        String member)

Remove one member from a sorted set

Parameters:

key - Key string

member - Member in the sorted set identified by key

Returns:

zremMany

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

Remove one or more members from a sorted set

Parameters:

key - Key string

members - Members in the sorted set identified by key

handler - Handler for the result of this call.

Returns:

rxZremMany

public io.reactivex.Single<Long> rxZremMany(String key,
                                            List<String> members)

Remove one or more members from a sorted set

Parameters:

key - Key string

members - Members in the sorted set identified by key

Returns:

zremrangebylex

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

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

Parameters:

key - Key string

min - Pattern defining a minimum value

max - Pattern defining a maximum value

handler - Handler for the result of this call.

Returns:

rxZremrangebylex

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

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

Parameters:

key - Key string

min - Pattern defining a minimum value

max - Pattern defining a maximum value

Returns:

zremrangebyrank

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

Remove all members in a sorted set within the given indexes

Parameters:

key - Key string

start - Start index

stop - Stop index

handler - Handler for the result of this call.

Returns:

rxZremrangebyrank

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

Remove all members in a sorted set within the given indexes

Parameters:

key - Key string

start - Start index

stop - Stop index

Returns:

zremrangebyscore

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

Remove all members in a sorted set within the given scores

Parameters:

key - Key string

min - Pattern defining a minimum value

max - Pattern defining a maximum value

handler -

Returns:

rxZremrangebyscore

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

Remove all members in a sorted set within the given scores

Parameters:

key - Key string

min - Pattern defining a minimum value

max - Pattern defining a maximum value

Returns:

zrevrange

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

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

Parameters:

key - Key string

start - Start index for the range

stop - Stop index for the range - inclusive

options - Range options

handler - Handler for the result of this call.

Returns:

rxZrevrange

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

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

Parameters:

key - Key string

start - Start index for the range

stop - Stop index for the range - inclusive

options - Range options

Returns:

zrevrangebylex

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

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

Parameters:

key - Key string

max - Pattern defining a maximum value

min - Pattern defining a minimum value

options - Limit options

handler - Handler for the result of this call.

Returns:

rxZrevrangebylex

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

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

Parameters:

key - Key string

max - Pattern defining a maximum value

min - Pattern defining a minimum value

options - Limit options

Returns:

zrevrangebyscore

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

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

Parameters:

key - Key string

max - Pattern defining a maximum value

min - Pattern defining a minimum value

options - Range and limit options

handler - Handler for the result of this call.

Returns:

rxZrevrangebyscore

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

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

Parameters:

key - Key string

max - Pattern defining a maximum value

min - Pattern defining a minimum value

options - Range and limit options

Returns:

zrevrank

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

Determine the index of a member in a sorted set, with scores ordered from high to low

Parameters:

key - Key string

member - Member in the sorted set identified by key

handler - Handler for the result of this call.

Returns:

rxZrevrank

public io.reactivex.Single<Long> rxZrevrank(String key,
                                            String member)

Determine the index of a member in a sorted set, with scores ordered from high to low

Parameters:

key - Key string

member - Member in the sorted set identified by key

Returns:

zscore

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

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

Parameters:

key - Key string

member - Member in the sorted set identified by key

handler - Handler for the result of this call.

Returns:

rxZscore

public io.reactivex.Single<String> rxZscore(String key,
                                            String member)

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

Parameters:

key - Key string

member - Member in the sorted set identified by key

Returns:

zunionstore

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

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

Parameters:

destkey - Destination key

sets - List of keys identifying sorted sets

options - Aggregation options

handler - Handler for the result of this call.

Returns:

rxZunionstore

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

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

Parameters:

destkey - Destination key

sets - List of keys identifying sorted sets

options - Aggregation options

Returns:

zunionstoreWeighed

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

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

Parameters:

key - Destination key

sets - Map containing set-key:weight pairs

options - Aggregation options

handler - Handler for the result of this call.

Returns:

rxZunionstoreWeighed

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

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

Parameters:

key - Destination key

sets - Map containing set-key:weight pairs

options - Aggregation options

Returns:

scan

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

Incrementally iterate the keys space

Parameters:

cursor - Cursor id

options - Scan options

handler - Handler for the result of this call.

Returns:

rxScan

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

Incrementally iterate the keys space

Parameters:

cursor - Cursor id

options - Scan options

Returns:

sscan

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

Incrementally iterate Set elements

Parameters:

key - Key string

cursor - Cursor id

options - Scan options

handler - Handler for the result of this call.

Returns:

rxSscan

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

Incrementally iterate Set elements

Parameters:

key - Key string

cursor - Cursor id

options - Scan options

Returns:

hscan

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

Incrementally iterate hash fields and associated values

Parameters:

key - Key string

cursor - Cursor id

options - Scan options

handler - Handler for the result of this call.

Returns:

rxHscan

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

Incrementally iterate hash fields and associated values

Parameters:

key - Key string

cursor - Cursor id

options - Scan options

Returns:

zscan

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

Incrementally iterate sorted sets elements and associated scores

Parameters:

key - Key string

cursor - Cursor id

options - Scan options

handler - Handler for the result of this call.

Returns:

rxZscan

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

Incrementally iterate sorted sets elements and associated scores

Parameters:

key - Key string

cursor - Cursor id

options - Scan options

Returns:

geoadd

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

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

Parameters:

key - Key string

longitude - longitude

latitude - latitude

member - member

handler - Handler for the result of this call.

Returns:

rxGeoadd

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

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

Parameters:

key - Key string

longitude - longitude

latitude - latitude

member - member

Returns:

geoaddMany

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

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

Parameters:

key - Key string

members - list of <lon, lat, member>

handler - Handler for the result of this call.

Returns:

rxGeoaddMany

public io.reactivex.Single<Long> rxGeoaddMany(String key,
                                              List<GeoMember> members)

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

Parameters:

key - Key string

members - list of <lon, lat, member>

Returns:

geohash

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

Return valid Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index (where elements were added using GEOADD).

Parameters:

key - Key string

member - member

handler - Handler for the result of this call.

Returns:

rxGeohash

public io.reactivex.Single<JsonArray> rxGeohash(String key,
                                                String member)

Return valid Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index (where elements were added using GEOADD).

Parameters:

key - Key string

member - member

Returns:

geohashMany

public RedisClient geohashMany(String key,
                               List<String> members,
                               Handler<AsyncResult<JsonArray>> handler)

Return valid Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index (where elements were added using GEOADD).

Parameters:

key - Key string

members - list of members

handler - Handler for the result of this call.

Returns:

rxGeohashMany

public io.reactivex.Single<JsonArray> rxGeohashMany(String key,
                                                    List<String> members)

Return valid Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index (where elements were added using GEOADD).

Parameters:

key - Key string

members - list of members

Returns:

geopos

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

Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.

Parameters:

key - Key string

member - member

handler - Handler for the result of this call.

Returns:

rxGeopos

public io.reactivex.Single<JsonArray> rxGeopos(String key,
                                               String member)

Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.

Parameters:

key - Key string

member - member

Returns:

geoposMany

public RedisClient geoposMany(String key,
                              List<String> members,
                              Handler<AsyncResult<JsonArray>> handler)

Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.

Parameters:

key - Key string

members - list of members

handler - Handler for the result of this call.

Returns:

rxGeoposMany

public io.reactivex.Single<JsonArray> rxGeoposMany(String key,
                                                   List<String> members)

Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.

Parameters:

key - Key string

members - list of members

Returns:

geodist

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

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

Parameters:

key - Key string

member1 - member 1

member2 - member 2

handler - Handler for the result of this call.

Returns:

rxGeodist

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

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

Parameters:

key - Key string

member1 - member 1

member2 - member 2

Returns:

geodistWithUnit

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

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

Parameters:

key - Key string

member1 - member 1

member2 - member 2

unit - geo unit

handler - Handler for the result of this call.

Returns:

rxGeodistWithUnit

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

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

Parameters:

key - Key string

member1 - member 1

member2 - member 2

unit - geo unit

Returns:

georadius

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

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

Parameters:

key - Key string

longitude - longitude

latitude - latitude

radius - radius

unit - geo unit

handler - Handler for the result of this call.

Returns:

rxGeoradius

public io.reactivex.Single<JsonArray> rxGeoradius(String key,
                                                  double longitude,
                                                  double latitude,
                                                  double radius,
                                                  GeoUnit unit)

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

Parameters:

key - Key string

longitude - longitude

latitude - latitude

radius - radius

unit - geo unit

Returns:

georadiusWithOptions

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

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

Parameters:

key - Key string

longitude - longitude

latitude - latitude

radius - radius

unit - geo unit

options - geo radius options

handler - Handler for the result of this call.

Returns:

rxGeoradiusWithOptions

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

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

Parameters:

key - Key string

longitude - longitude

latitude - latitude

radius - radius

unit - geo unit

options - geo radius options

Returns:

georadiusbymember

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

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

Parameters:

key - Key string

member - member

radius - radius

unit - geo unit

handler - Handler for the result of this call.

Returns:

rxGeoradiusbymember

public io.reactivex.Single<JsonArray> rxGeoradiusbymember(String key,
                                                          String member,
                                                          double radius,
                                                          GeoUnit unit)

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

Parameters:

key - Key string

member - member

radius - radius

unit - geo unit

Returns:

georadiusbymemberWithOptions

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

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:

rxGeoradiusbymemberWithOptions

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

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

Parameters:

key - Key string

member - member

radius - radius

unit - geo unit

options - geo radius options

Returns:

clientReply

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

Instruct the server whether to reply to commands.

Parameters:

options -

handler -

Returns:

rxClientReply

public io.reactivex.Single<String> rxClientReply(ClientReplyOptions options)

Instruct the server whether to reply to commands.

Parameters:

options -

Returns:

hstrlen

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

Get the length of the value of a hash field.

Parameters:

key - Key String

field - field

handler -

Returns:

rxHstrlen

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

Get the length of the value of a hash field.

Parameters:

key - Key String

field - field

Returns:

touch

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

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

Parameters:

key - Key String

handler -

Returns:

rxTouch

public io.reactivex.Single<Long> rxTouch(String key)

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

Parameters:

key - Key String

Returns:

touchMany

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

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

Parameters:

keys - list of keys

handler -

Returns:

rxTouchMany

public io.reactivex.Single<Long> rxTouchMany(List<String> keys)

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

Parameters:

keys - list of keys

Returns:

scriptDebug

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

Set the debug mode for executed scripts.

Parameters:

scriptDebugOptions - the option

handler -

Returns:

rxScriptDebug

public io.reactivex.Single<String> rxScriptDebug(ScriptDebugOptions scriptDebugOptions)

Set the debug mode for executed scripts.

Parameters:

scriptDebugOptions - the option

Returns:

bitfield

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

Perform arbitrary bitfield integer operations on strings.

Parameters:

key - Key string

bitFieldOptions -

handler -

Returns:

rxBitfield

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

Perform arbitrary bitfield integer operations on strings.

Parameters:

key - Key string

bitFieldOptions -

Returns:

bitfieldWithOverflow

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

Perform arbitrary bitfield integer operations on strings.

Parameters:

key - Key string

commands -

overflow -

handler -

Returns:

rxBitfieldWithOverflow

public io.reactivex.Single<JsonArray> rxBitfieldWithOverflow(String key,
                                                             BitFieldOptions commands,
                                                             BitFieldOverflowOptions overflow)

Perform arbitrary bitfield integer operations on strings.

Parameters:

key - Key string

commands -

overflow -

Returns:

unlink

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

Delete a key asynchronously in another thread. Otherwise it is just as DEL, but non blocking.

Parameters:

key - Key to delete

handler - Handler for the result of this call.

Returns:

rxUnlink

public io.reactivex.Single<Long> rxUnlink(String key)

Delete a key asynchronously in another thread. Otherwise it is just as DEL, but non blocking.

Parameters:

key - Key to delete

Returns:

unlinkMany

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

Delete multiple keys asynchronously in another thread. Otherwise it is just as DEL, but non blocking.

Parameters:

keys - List of keys to delete

handler - Handler for the result of this call.

Returns:

rxUnlinkMany

public io.reactivex.Single<Long> rxUnlinkMany(List<String> keys)

Delete multiple keys asynchronously in another thread. Otherwise it is just as DEL, but non blocking.

Parameters:

keys - List of keys to delete

Returns:

swapdb

public RedisClient swapdb(int index1,
                          int index2,
                          Handler<AsyncResult<String>> handler)

Swaps two Redis databases

Parameters:

index1 - index of first database to swap

index2 - index of second database to swap

handler - Handler for the result of this call.

Returns:

rxSwapdb

public io.reactivex.Single<String> rxSwapdb(int index1,
                                            int index2)

Swaps two Redis databases

Parameters:

index1 - index of first database to swap

index2 - index of second database to swap

Returns:

newInstance

public static RedisClient newInstance(RedisClient arg)