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