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