vertx / io.vertx.rxjava.redis / RedisClient

# RedisClient

`open class RedisClient`

### Constructors

<init> | `RedisClient(delegate: RedisClient)`

### Properties

__TYPE_ARG | `static val __TYPE_ARG: TypeArg<RedisClient>`

### Functions

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