vertx / io.vertx.reactivex.redis / RedisTransaction

RedisTransaction

open class RedisTransaction

This Interface represents a TX NOTE: This class has been automatically generated from the io.vertx.redis.RedisTransaction non RX-ified interface using Vert.x codegen.

Constructors

<init>

RedisTransaction(delegate: RedisTransaction)

Properties

__TYPE_ARG

static val __TYPE_ARG: TypeArg<RedisTransaction>

Functions

append

open fun append(key: String, value: String, handler: Handler<AsyncResult<String>>): RedisTransaction

Append a value to a key

auth

open fun auth(password: String, handler: Handler<AsyncResult<String>>): RedisTransaction

Authenticate to the server

bgrewriteaof

open fun bgrewriteaof(handler: Handler<AsyncResult<String>>): RedisTransaction

Asynchronously rewrite the append-only file

bgsave

open fun bgsave(handler: Handler<AsyncResult<String>>): RedisTransaction

Asynchronously save the dataset to disk

bitcount

open fun bitcount(key: String, handler: Handler<AsyncResult<String>>): RedisTransaction

Count set bits in a string

bitcountRange

open fun bitcountRange(key: String, start: Long, end: Long, handler: Handler<AsyncResult<String>>): RedisTransaction

Count set bits in a string

bitop

open fun bitop(operation: BitOperation, destkey: String, keys: MutableList<String>, handler: Handler<AsyncResult<String>>): RedisTransaction

Perform bitwise operations between strings

bitpos

open fun bitpos(key: String, bit: Int, handler: Handler<AsyncResult<String>>): RedisTransaction

Find first bit set or clear in a string

bitposFrom

open fun bitposFrom(key: String, bit: Int, start: Int, handler: Handler<AsyncResult<String>>): RedisTransaction

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<String>>): RedisTransaction

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<String>>): RedisTransaction

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<String>>): RedisTransaction

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<String>>): RedisTransaction

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<String>>): RedisTransaction

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

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

Get the current connection name

clientKill

open fun clientKill(filter: KillFilter, handler: Handler<AsyncResult<String>>): RedisTransaction

Kill the connection of a client

clientList

open fun clientList(handler: Handler<AsyncResult<String>>): RedisTransaction

Get the list of client connections

clientPause

open fun clientPause(millis: Long, handler: Handler<AsyncResult<String>>): RedisTransaction

Stop processing commands from clients for some time

clientSetname

open fun clientSetname(name: String, handler: Handler<AsyncResult<String>>): RedisTransaction

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<String>, handler: Handler<AsyncResult<String>>): RedisTransaction

Assign new hash slots to receiving node.

clusterCountFailureReports

open fun clusterCountFailureReports(nodeId: String, handler: Handler<AsyncResult<String>>): RedisTransaction

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

clusterCountkeysinslot

open fun clusterCountkeysinslot(slot: Long, handler: Handler<AsyncResult<String>>): RedisTransaction

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

clusterDelslots

open fun clusterDelslots(slot: Long, handler: Handler<AsyncResult<String>>): RedisTransaction

Set hash slots as unbound in receiving node.

clusterDelslotsMany

open fun clusterDelslotsMany(slots: MutableList<String>, handler: Handler<AsyncResult<String>>): RedisTransaction

Set hash slots as unbound in receiving node.

clusterFailOverWithOptions

open fun clusterFailOverWithOptions(options: FailoverOptions, handler: Handler<AsyncResult<String>>): RedisTransaction

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

clusterFailover

open fun clusterFailover(handler: Handler<AsyncResult<String>>): RedisTransaction

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

clusterForget

open fun clusterForget(nodeId: String, handler: Handler<AsyncResult<String>>): RedisTransaction

Remove a node from the nodes table.

clusterGetkeysinslot

open fun clusterGetkeysinslot(slot: Long, count: Long, handler: Handler<AsyncResult<String>>): RedisTransaction

Return local key names in the specified hash slot.

clusterInfo

open fun clusterInfo(handler: Handler<AsyncResult<String>>): RedisTransaction

Provides info about Redis Cluster node state.

clusterKeyslot

open fun clusterKeyslot(key: String, handler: Handler<AsyncResult<String>>): RedisTransaction

Returns the hash slot of the specified key.

clusterMeet

open fun clusterMeet(ip: String, port: Long, handler: Handler<AsyncResult<String>>): RedisTransaction

Force a node cluster to handshake with another node.

clusterNodes

open fun clusterNodes(handler: Handler<AsyncResult<String>>): RedisTransaction

Get Cluster config for the node.

clusterReplicate

open fun clusterReplicate(nodeId: String, handler: Handler<AsyncResult<String>>): RedisTransaction

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

clusterReset

open fun clusterReset(handler: Handler<AsyncResult<String>>): RedisTransaction

Reset a Redis Cluster node.

clusterResetWithOptions

open fun clusterResetWithOptions(options: ResetOptions, handler: Handler<AsyncResult<String>>): RedisTransaction

Reset a Redis Cluster node.

clusterSaveconfig

open fun clusterSaveconfig(handler: Handler<AsyncResult<String>>): RedisTransaction

Forces the node to save cluster state on disk.

clusterSetConfigEpoch

open fun clusterSetConfigEpoch(epoch: Long, handler: Handler<AsyncResult<String>>): RedisTransaction

Set the configuration epoch in a new node.

clusterSetslot

open fun clusterSetslot(slot: Long, subcommand: SlotCmd, handler: Handler<AsyncResult<String>>): RedisTransaction

Bind an hash slot to a specific node.

clusterSetslotWithNode

open fun clusterSetslotWithNode(slot: Long, subcommand: SlotCmd, nodeId: String, handler: Handler<AsyncResult<String>>): RedisTransaction

Bind an hash slot to a specific node.

clusterSlaves

open fun clusterSlaves(nodeId: String, handler: Handler<AsyncResult<String>>): RedisTransaction

List slave nodes of the specified master node.

clusterSlots

open fun clusterSlots(handler: Handler<AsyncResult<String>>): RedisTransaction

Get array of Cluster slot to node mappings

command

open fun command(handler: Handler<AsyncResult<String>>): RedisTransaction

Get array of Redis command details

commandCount

open fun commandCount(handler: Handler<AsyncResult<String>>): RedisTransaction

Get total number of Redis commands

commandGetkeys

open fun commandGetkeys(handler: Handler<AsyncResult<String>>): RedisTransaction

Extract keys given a full Redis command

commandInfo

open fun commandInfo(commands: MutableList<String>, handler: Handler<AsyncResult<String>>): RedisTransaction

Get array of specific Redis command details

configGet

open fun configGet(parameter: String, handler: Handler<AsyncResult<String>>): RedisTransaction

Get the value of a configuration parameter

configResetstat

open fun configResetstat(handler: Handler<AsyncResult<String>>): RedisTransaction

Reset the stats returned by INFO

configRewrite

open fun configRewrite(handler: Handler<AsyncResult<String>>): RedisTransaction

Rewrite the configuration file with the in memory configuration

configSet

open fun configSet(parameter: String, value: String, handler: Handler<AsyncResult<String>>): RedisTransaction

Set a configuration parameter to the given value

dbsize

open fun dbsize(handler: Handler<AsyncResult<String>>): RedisTransaction

Return the number of keys in the selected database

debugObject

open fun debugObject(key: String, handler: Handler<AsyncResult<String>>): RedisTransaction

Get debugging information about a key

debugSegfault

open fun debugSegfault(handler: Handler<AsyncResult<String>>): RedisTransaction

Make the server crash

decr

open fun decr(key: String, handler: Handler<AsyncResult<String>>): RedisTransaction

Decrement the integer value of a key by one

decrby

open fun decrby(key: String, decrement: Long, handler: Handler<AsyncResult<String>>): RedisTransaction

Decrement the integer value of a key by the given number

del

open fun del(key: String, handler: Handler<AsyncResult<String>>): RedisTransaction

Delete a key

delMany

open fun delMany(keys: MutableList<String>, handler: Handler<AsyncResult<String>>): RedisTransaction

Delete many keys

discard

open fun discard(handler: Handler<AsyncResult<String>>): RedisTransaction

Discard all commands issued after MULTI

dump

open fun dump(key: String, handler: Handler<AsyncResult<String>>): RedisTransaction

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

echo

open fun echo(message: String, handler: Handler<AsyncResult<String>>): RedisTransaction

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<String>>): RedisTransaction

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.

evalsha

open fun evalsha(sha1: String, keys: MutableList<String>, values: MutableList<String>, handler: Handler<AsyncResult<String>>): RedisTransaction

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.

exec

open fun exec(handler: Handler<AsyncResult<JsonArray>>): RedisTransaction

Execute all commands issued after MULTI

exists

open fun exists(key: String, handler: Handler<AsyncResult<String>>): RedisTransaction

Determine if a key exists

existsMany

open fun existsMany(keys: MutableList<String>, handler: Handler<AsyncResult<String>>): RedisTransaction

Determine if one or many keys exist

expire

open fun expire(key: String, seconds: Int, handler: Handler<AsyncResult<String>>): RedisTransaction

Set a key's time to live in seconds

expireat

open fun expireat(key: String, seconds: Long, handler: Handler<AsyncResult<String>>): RedisTransaction

Set the expiration for a key as a UNIX timestamp

flushall

open fun flushall(handler: Handler<AsyncResult<String>>): RedisTransaction

Remove all keys from all databases

flushdb

open fun flushdb(handler: Handler<AsyncResult<String>>): RedisTransaction

Remove all keys from the current database

geoadd

open fun geoadd(key: String, longitude: Double, latitude: Double, member: String, handler: Handler<AsyncResult<String>>): RedisTransaction

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<String>>): RedisTransaction

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

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

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<String>>): RedisTransaction

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<String>>): RedisTransaction

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<String>>): RedisTransaction

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<String>>): RedisTransaction

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<String>>): RedisTransaction

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<String>>): RedisTransaction

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<String>>): RedisTransaction

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<String>>): RedisTransaction

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

Get the value of a key

getBinary

open fun getBinary(key: String, handler: Handler<AsyncResult<Buffer>>): RedisTransaction

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

getDelegate

open fun getDelegate(): RedisTransaction

getbit

open fun getbit(key: String, offset: Long, handler: Handler<AsyncResult<String>>): RedisTransaction

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

Get a substring of the string stored at a key

getset

open fun getset(key: String, value: String, handler: Handler<AsyncResult<String>>): RedisTransaction

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<String>>): RedisTransaction

Delete one or more hash fields

hdelMany

open fun hdelMany(key: String, fields: MutableList<String>, handler: Handler<AsyncResult<String>>): RedisTransaction

Delete one or more hash fields

hexists

open fun hexists(key: String, field: String, handler: Handler<AsyncResult<String>>): RedisTransaction

Determine if a hash field exists

hget

open fun hget(key: String, field: String, handler: Handler<AsyncResult<String>>): RedisTransaction

Get the value of a hash field

hgetall

open fun hgetall(key: String, handler: Handler<AsyncResult<String>>): RedisTransaction

Get all the fields and values in a hash

hincrby

open fun hincrby(key: String, field: String, increment: Long, handler: Handler<AsyncResult<String>>): RedisTransaction

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

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

hkeys

open fun hkeys(key: String, handler: Handler<AsyncResult<String>>): RedisTransaction

Get all the fields in a hash

hlen

open fun hlen(key: String, handler: Handler<AsyncResult<String>>): RedisTransaction

Get the number of fields in a hash

hmget

open fun hmget(key: String, fields: MutableList<String>, handler: Handler<AsyncResult<String>>): RedisTransaction

Get the values of all the given hash fields

hmset

open fun hmset(key: String, values: JsonObject, handler: Handler<AsyncResult<String>>): RedisTransaction

Set multiple hash fields to multiple values

hscan

open fun hscan(key: String, cursor: String, options: ScanOptions, handler: Handler<AsyncResult<String>>): RedisTransaction

Incrementally iterate hash fields and associated values

hset

open fun hset(key: String, field: String, value: String, handler: Handler<AsyncResult<String>>): RedisTransaction

Set the string value of a hash field

hsetnx

open fun hsetnx(key: String, field: String, value: String, handler: Handler<AsyncResult<String>>): RedisTransaction

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

hvals

open fun hvals(key: String, handler: Handler<AsyncResult<String>>): RedisTransaction

Get all the values in a hash

incr

open fun incr(key: String, handler: Handler<AsyncResult<String>>): RedisTransaction

Increment the integer value of a key by one

incrby

open fun incrby(key: String, increment: Long, handler: Handler<AsyncResult<String>>): RedisTransaction

Increment the integer value of a key by the given amount

incrbyfloat

open fun incrbyfloat(key: String, increment: Double, handler: Handler<AsyncResult<String>>): RedisTransaction

Increment the float value of a key by the given amount

info

open fun info(handler: Handler<AsyncResult<String>>): RedisTransaction

Get information and statistics about the server

infoSection

open fun infoSection(section: String, handler: Handler<AsyncResult<String>>): RedisTransaction

Get information and statistics about the server

keys

open fun keys(pattern: String, handler: Handler<AsyncResult<String>>): RedisTransaction

Find all keys matching the given pattern

lastsave

open fun lastsave(handler: Handler<AsyncResult<String>>): RedisTransaction

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

lindex

open fun lindex(key: String, index: Int, handler: Handler<AsyncResult<String>>): RedisTransaction

Get an element from a list by its index

linsert

open fun linsert(key: String, option: InsertOptions, pivot: String, value: String, handler: Handler<AsyncResult<String>>): RedisTransaction

Insert an element before or after another element in a list

llen

open fun llen(key: String, handler: Handler<AsyncResult<String>>): RedisTransaction

Get the length of a list

lpop

open fun lpop(key: String, handler: Handler<AsyncResult<String>>): RedisTransaction

Remove and get the first element in a list

lpush

open fun lpush(key: String, value: String, handler: Handler<AsyncResult<String>>): RedisTransaction

Prepend one value to a list

lpushMany

open fun lpushMany(key: String, values: MutableList<String>, handler: Handler<AsyncResult<String>>): RedisTransaction

Prepend one or multiple values to a list

lpushx

open fun lpushx(key: String, value: String, handler: Handler<AsyncResult<String>>): RedisTransaction

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

lrange

open fun lrange(key: String, from: Long, to: Long, handler: Handler<AsyncResult<String>>): RedisTransaction

Get a range of elements from a list

lrem

open fun lrem(key: String, count: Long, value: String, handler: Handler<AsyncResult<String>>): RedisTransaction

Remove elements from a list

lset

open fun lset(key: String, index: Long, value: String, handler: Handler<AsyncResult<String>>): RedisTransaction

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

Trim a list to the specified range

mget

open fun mget(key: String, handler: Handler<AsyncResult<String>>): RedisTransaction

Get the value of the given key

mgetMany

open fun mgetMany(keys: MutableList<String>, handler: Handler<AsyncResult<String>>): RedisTransaction

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

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

monitor

open fun monitor(handler: Handler<AsyncResult<String>>): RedisTransaction

Listen for all requests received by the server in real time

move

open fun move(key: String, destdb: Int, handler: Handler<AsyncResult<String>>): RedisTransaction

Move a key to another database

mset

open fun mset(keyvals: JsonObject, handler: Handler<AsyncResult<String>>): RedisTransaction

Set multiple keys to multiple values

msetnx

open fun msetnx(keyvals: JsonObject, handler: Handler<AsyncResult<String>>): RedisTransaction

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

multi

open fun multi(handler: Handler<AsyncResult<String>>): RedisTransaction

Mark the start of a RedisTransaction block

newInstance

open static fun newInstance(arg: RedisTransaction): RedisTransaction

object

open fun object(key: String, cmd: ObjectCmd, handler: Handler<AsyncResult<String>>): RedisTransaction

Inspect the internals of Redis objects

persist

open fun persist(key: String, handler: Handler<AsyncResult<String>>): RedisTransaction

Remove the expiration from a key

pexpire

open fun pexpire(key: String, millis: Long, handler: Handler<AsyncResult<String>>): RedisTransaction

Set a key's time to live in milliseconds

pexpireat

open fun pexpireat(key: String, millis: Long, handler: Handler<AsyncResult<String>>): RedisTransaction

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

pfadd

open fun pfadd(key: String, element: String, handler: Handler<AsyncResult<String>>): RedisTransaction

Adds the specified element to the specified HyperLogLog.

pfaddMany

open fun pfaddMany(key: String, elements: MutableList<String>, handler: Handler<AsyncResult<String>>): RedisTransaction

Adds the specified elements to the specified HyperLogLog.

pfcount

open fun pfcount(key: String, handler: Handler<AsyncResult<String>>): RedisTransaction

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

pfcountMany

open fun pfcountMany(keys: MutableList<String>, handler: Handler<AsyncResult<String>>): RedisTransaction

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

Merge N different HyperLogLogs into a single one.

ping

open fun ping(handler: Handler<AsyncResult<String>>): RedisTransaction

Ping the server

psetex

open fun psetex(key: String, millis: Long, value: String, handler: Handler<AsyncResult<String>>): RedisTransaction

Set the value and expiration in milliseconds of a key

psubscribe

open fun psubscribe(pattern: String, handler: Handler<AsyncResult<String>>): RedisTransaction

Listen for messages published to channels matching the given pattern

psubscribeMany

open fun psubscribeMany(patterns: MutableList<String>, handler: Handler<AsyncResult<String>>): RedisTransaction

Listen for messages published to channels matching the given patterns

pttl

open fun pttl(key: String, handler: Handler<AsyncResult<String>>): RedisTransaction

Get the time to live for a key in milliseconds

publish

open fun publish(channel: String, message: String, handler: Handler<AsyncResult<String>>): RedisTransaction

Post a message to a channel

pubsubChannels

open fun pubsubChannels(pattern: String, handler: Handler<AsyncResult<String>>): RedisTransaction

Lists the currently active channels - only those matching the pattern

pubsubNumpat

open fun pubsubNumpat(handler: Handler<AsyncResult<String>>): RedisTransaction

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

pubsubNumsub

open fun pubsubNumsub(channels: MutableList<String>, handler: Handler<AsyncResult<String>>): RedisTransaction

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<String>>): RedisTransaction

Stop listening for messages posted to channels matching the given patterns

randomkey

open fun randomkey(handler: Handler<AsyncResult<String>>): RedisTransaction

Return a random key from the keyspace

rename

open fun rename(key: String, newkey: String, handler: Handler<AsyncResult<String>>): RedisTransaction

Rename a key

renamenx

open fun renamenx(key: String, newkey: String, handler: Handler<AsyncResult<String>>): RedisTransaction

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

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

role

open fun role(handler: Handler<AsyncResult<String>>): RedisTransaction

Return the role of the instance in the context of replication

rpop

open fun rpop(key: String, handler: Handler<AsyncResult<String>>): RedisTransaction

Remove and get the last element in a list

rpoplpush

open fun rpoplpush(key: String, destkey: String, handler: Handler<AsyncResult<String>>): RedisTransaction

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<String>>): RedisTransaction

Append one or multiple values to a list

rpushMany

open fun rpushMany(key: String, values: MutableList<String>, handler: Handler<AsyncResult<String>>): RedisTransaction

Append one or multiple values to a list

rpushx

open fun rpushx(key: String, value: String, handler: Handler<AsyncResult<String>>): RedisTransaction

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

rxAppend

open fun rxAppend(key: String, value: String): Single<String>

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<String>

Count set bits in a string

rxBitcountRange

open fun rxBitcountRange(key: String, start: Long, end: Long): Single<String>

Count set bits in a string

rxBitop

open fun rxBitop(operation: BitOperation, destkey: String, keys: MutableList<String>): Single<String>

Perform bitwise operations between strings

rxBitpos

open fun rxBitpos(key: String, bit: Int): Single<String>

Find first bit set or clear in a string

rxBitposFrom

open fun rxBitposFrom(key: String, bit: Int, start: Int): Single<String>

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<String>

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<String>

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<String>

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<String>

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<String>

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<String>

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

rxClientSetname

open fun rxClientSetname(name: String): Single<String>

Set the current connection name

rxClose

open fun rxClose(): Completable

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

rxClusterAddslots

open fun rxClusterAddslots(slots: MutableList<String>): Single<String>

Assign new hash slots to receiving node.

rxClusterCountFailureReports

open fun rxClusterCountFailureReports(nodeId: String): Single<String>

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

rxClusterCountkeysinslot

open fun rxClusterCountkeysinslot(slot: Long): Single<String>

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

rxClusterDelslots

open fun rxClusterDelslots(slot: Long): Single<String>

Set hash slots as unbound in receiving node.

rxClusterDelslotsMany

open fun rxClusterDelslotsMany(slots: MutableList<String>): Single<String>

Set hash slots as unbound in receiving node.

rxClusterFailOverWithOptions

open fun rxClusterFailOverWithOptions(options: FailoverOptions): Single<String>

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

rxClusterFailover

open fun rxClusterFailover(): Single<String>

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

rxClusterForget

open fun rxClusterForget(nodeId: String): Single<String>

Remove a node from the nodes table.

rxClusterGetkeysinslot

open fun rxClusterGetkeysinslot(slot: Long, count: Long): Single<String>

Return local key names in the specified hash slot.

rxClusterInfo

open fun rxClusterInfo(): Single<String>

Provides info about Redis Cluster node state.

rxClusterKeyslot

open fun rxClusterKeyslot(key: String): Single<String>

Returns the hash slot of the specified key.

rxClusterMeet

open fun rxClusterMeet(ip: String, port: Long): Single<String>

Force a node cluster to handshake with another node.

rxClusterNodes

open fun rxClusterNodes(): Single<String>

Get Cluster config for the node.

rxClusterReplicate

open fun rxClusterReplicate(nodeId: String): Single<String>

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

rxClusterReset

open fun rxClusterReset(): Single<String>

Reset a Redis Cluster node.

rxClusterResetWithOptions

open fun rxClusterResetWithOptions(options: ResetOptions): Single<String>

Reset a Redis Cluster node.

rxClusterSaveconfig

open fun rxClusterSaveconfig(): Single<String>

Forces the node to save cluster state on disk.

rxClusterSetConfigEpoch

open fun rxClusterSetConfigEpoch(epoch: Long): Single<String>

Set the configuration epoch in a new node.

rxClusterSetslot

open fun rxClusterSetslot(slot: Long, subcommand: SlotCmd): Single<String>

Bind an hash slot to a specific node.

rxClusterSetslotWithNode

open fun rxClusterSetslotWithNode(slot: Long, subcommand: SlotCmd, nodeId: String): Single<String>

Bind an hash slot to a specific node.

rxClusterSlaves

open fun rxClusterSlaves(nodeId: String): Single<String>

List slave nodes of the specified master node.

rxClusterSlots

open fun rxClusterSlots(): Single<String>

Get array of Cluster slot to node mappings

rxCommand

open fun rxCommand(): Single<String>

Get array of Redis command details

rxCommandCount

open fun rxCommandCount(): Single<String>

Get total number of Redis commands

rxCommandGetkeys

open fun rxCommandGetkeys(): Single<String>

Extract keys given a full Redis command

rxCommandInfo

open fun rxCommandInfo(commands: MutableList<String>): Single<String>

Get array of specific Redis command details

rxConfigGet

open fun rxConfigGet(parameter: String): Single<String>

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<String>

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<String>

Decrement the integer value of a key by one

rxDecrby

open fun rxDecrby(key: String, decrement: Long): Single<String>

Decrement the integer value of a key by the given number

rxDel

open fun rxDel(key: String): Single<String>

Delete a key

rxDelMany

open fun rxDelMany(keys: MutableList<String>): Single<String>

Delete many keys

rxDiscard

open fun rxDiscard(): Single<String>

Discard all commands issued after MULTI

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<String>

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.

rxEvalsha

open fun rxEvalsha(sha1: String, keys: MutableList<String>, values: MutableList<String>): Single<String>

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.

rxExec

open fun rxExec(): Single<JsonArray>

Execute all commands issued after MULTI

rxExists

open fun rxExists(key: String): Single<String>

Determine if a key exists

rxExistsMany

open fun rxExistsMany(keys: MutableList<String>): Single<String>

Determine if one or many keys exist

rxExpire

open fun rxExpire(key: String, seconds: Int): Single<String>

Set a key's time to live in seconds

rxExpireat

open fun rxExpireat(key: String, seconds: Long): Single<String>

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<String>

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<String>

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<String>

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<String>

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<String>

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<String>

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<String>

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<String>

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<String>

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<String>

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<String>

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<String>

Delete one or more hash fields

rxHdelMany

open fun rxHdelMany(key: String, fields: MutableList<String>): Single<String>

Delete one or more hash fields

rxHexists

open fun rxHexists(key: String, field: String): Single<String>

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<String>

Get all the fields and values in a hash

rxHincrby

open fun rxHincrby(key: String, field: String, increment: Long): Single<String>

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<String>

Get all the fields in a hash

rxHlen

open fun rxHlen(key: String): Single<String>

Get the number of fields in a hash

rxHmget

open fun rxHmget(key: String, fields: MutableList<String>): Single<String>

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<String>

Incrementally iterate hash fields and associated values

rxHset

open fun rxHset(key: String, field: String, value: String): Single<String>

Set the string value of a hash field

rxHsetnx

open fun rxHsetnx(key: String, field: String, value: String): Single<String>

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

rxHvals

open fun rxHvals(key: String): Single<String>

Get all the values in a hash

rxIncr

open fun rxIncr(key: String): Single<String>

Increment the integer value of a key by one

rxIncrby

open fun rxIncrby(key: String, increment: Long): Single<String>

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<String>

Get information and statistics about the server

rxInfoSection

open fun rxInfoSection(section: String): Single<String>

Get information and statistics about the server

rxKeys

open fun rxKeys(pattern: String): Single<String>

Find all keys matching the given pattern

rxLastsave

open fun rxLastsave(): Single<String>

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<String>

Insert an element before or after another element in a list

rxLlen

open fun rxLlen(key: String): Single<String>

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<String>

Prepend one value to a list

rxLpushMany

open fun rxLpushMany(key: String, values: MutableList<String>): Single<String>

Prepend one or multiple values to a list

rxLpushx

open fun rxLpushx(key: String, value: String): Single<String>

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

rxLrange

open fun rxLrange(key: String, from: Long, to: Long): Single<String>

Get a range of elements from a list

rxLrem

open fun rxLrem(key: String, count: Long, value: String): Single<String>

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<String>

Get the value of the given key

rxMgetMany

open fun rxMgetMany(keys: MutableList<String>): Single<String>

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<String>

Listen for all requests received by the server in real time

rxMove

open fun rxMove(key: String, destdb: Int): Single<String>

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<String>

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

rxMulti

open fun rxMulti(): Single<String>

Mark the start of a RedisTransaction block

rxObject

open fun rxObject(key: String, cmd: ObjectCmd): Single<String>

Inspect the internals of Redis objects

rxPersist

open fun rxPersist(key: String): Single<String>

Remove the expiration from a key

rxPexpire

open fun rxPexpire(key: String, millis: Long): Single<String>

Set a key's time to live in milliseconds

rxPexpireat

open fun rxPexpireat(key: String, millis: Long): Single<String>

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

rxPfadd

open fun rxPfadd(key: String, element: String): Single<String>

Adds the specified element to the specified HyperLogLog.

rxPfaddMany

open fun rxPfaddMany(key: String, elements: MutableList<String>): Single<String>

Adds the specified elements to the specified HyperLogLog.

rxPfcount

open fun rxPfcount(key: String): Single<String>

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

rxPfcountMany

open fun rxPfcountMany(keys: MutableList<String>): Single<String>

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<String>

Set the value and expiration in milliseconds of a key

rxPsubscribe

open fun rxPsubscribe(pattern: String): Single<String>

Listen for messages published to channels matching the given pattern

rxPsubscribeMany

open fun rxPsubscribeMany(patterns: MutableList<String>): Single<String>

Listen for messages published to channels matching the given patterns

rxPttl

open fun rxPttl(key: String): Single<String>

Get the time to live for a key in milliseconds

rxPublish

open fun rxPublish(channel: String, message: String): Single<String>

Post a message to a channel

rxPubsubChannels

open fun rxPubsubChannels(pattern: String): Single<String>

Lists the currently active channels - only those matching the pattern

rxPubsubNumpat

open fun rxPubsubNumpat(): Single<String>

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

rxPubsubNumsub

open fun rxPubsubNumsub(channels: MutableList<String>): Single<String>

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

rxPunsubscribe

open fun rxPunsubscribe(patterns: MutableList<String>): Single<String>

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<String>

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<String>

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<String>

Append one or multiple values to a list

rxRpushMany

open fun rxRpushMany(key: String, values: MutableList<String>): Single<String>

Append one or multiple values to a list

rxRpushx

open fun rxRpushx(key: String, value: String): Single<String>

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

rxSadd

open fun rxSadd(key: String, member: String): Single<String>

Add a member to a set

rxSaddMany

open fun rxSaddMany(key: String, members: MutableList<String>): Single<String>

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<String>

Incrementally iterate the keys space

rxScard

open fun rxScard(key: String): Single<String>

Get the number of members in a set

rxScriptExists

open fun rxScriptExists(script: String): Single<String>

Check existence of script in the script cache.

rxScriptExistsMany

open fun rxScriptExistsMany(scripts: MutableList<String>): Single<String>

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<String>

Subtract multiple sets

rxSdiffstore

open fun rxSdiffstore(destkey: String, key: String, cmpkeys: MutableList<String>): Single<String>

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<String>

Set the string value of a key

rxSetBinary

open fun rxSetBinary(key: String, value: Buffer): Single<String>

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

rxSetBinaryWithOptions

open fun rxSetBinaryWithOptions(key: String, value: Buffer, options: SetOptions): Single<String>

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<String>

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<String>

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

rxSetrange

open fun rxSetrange(key: String, offset: Int, value: String): Single<String>

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

rxSinter

open fun rxSinter(keys: MutableList<String>): Single<String>

Intersect multiple sets

rxSinterstore

open fun rxSinterstore(destkey: String, keys: MutableList<String>): Single<String>

Intersect multiple sets and store the resulting set in a key

rxSismember

open fun rxSismember(key: String, member: String): Single<String>

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<String>

Read the Redis slow queries log

rxSlowlogLen

open fun rxSlowlogLen(): Single<String>

Get the length of the Redis slow queries log

rxSlowlogReset

open fun rxSlowlogReset(): Single<String>

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<String>

Move a member from one set to another

rxSort

open fun rxSort(key: String, options: SortOptions): Single<String>

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<String>

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<String>

Get one or multiple random members from a set

rxSrem

open fun rxSrem(key: String, member: String): Single<String>

Remove one member from a set

rxSremMany

open fun rxSremMany(key: String, members: MutableList<String>): Single<String>

Remove one or more members from a set

rxSscan

open fun rxSscan(key: String, cursor: String, options: ScanOptions): Single<String>

Incrementally iterate Set elements

rxStrlen

open fun rxStrlen(key: String): Single<String>

Get the length of the value stored in a key

rxSubscribe

open fun rxSubscribe(channel: String): Single<String>

Listen for messages published to the given channels

rxSubscribeMany

open fun rxSubscribeMany(channels: MutableList<String>): Single<String>

Listen for messages published to the given channels

rxSunion

open fun rxSunion(keys: MutableList<String>): Single<String>

Add multiple sets

rxSunionstore

open fun rxSunionstore(destkey: String, keys: MutableList<String>): Single<String>

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<String>

Internal command used for replication

rxTime

open fun rxTime(): Single<String>

Return the current server time

rxTtl

open fun rxTtl(key: String): Single<String>

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<String>

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

rxUnlinkMany

open fun rxUnlinkMany(keys: MutableList<String>): Single<String>

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

rxUnsubscribe

open fun rxUnsubscribe(channels: MutableList<String>): Single<String>

Stop listening for messages posted to the given channels

rxUnwatch

open fun rxUnwatch(): Single<String>

Forget about all watched keys

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.

rxWatch

open fun rxWatch(key: String): Single<String>

Watch the given keys to determine execution of the MULTI/EXEC block

rxWatchMany

open fun rxWatchMany(keys: MutableList<String>): Single<String>

Watch the given keys to determine execution of the MULTI/EXEC block

rxZadd

open fun rxZadd(key: String, score: Double, member: String): Single<String>

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<String>

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

rxZcard

open fun rxZcard(key: String): Single<String>

Get the number of members in a sorted set

rxZcount

open fun rxZcount(key: String, min: Double, max: Double): Single<String>

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<String>

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<String>

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<String>

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<String>

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

rxZrangeWithOptions

open fun rxZrangeWithOptions(key: String, start: Long, stop: Long, options: RangeOptions): Single<String>

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

rxZrangebylex

open fun rxZrangebylex(key: String, min: String, max: String, options: LimitOptions): Single<String>

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<String>

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

rxZrank

open fun rxZrank(key: String, member: String): Single<String>

Determine the index of a member in a sorted set

rxZrem

open fun rxZrem(key: String, member: String): Single<String>

Remove one member from a sorted set

rxZremMany

open fun rxZremMany(key: String, members: MutableList<String>): Single<String>

Remove one or more members from a sorted set

rxZremrangebylex

open fun rxZremrangebylex(key: String, min: String, max: String): Single<String>

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

rxZremrangebyrank

open fun rxZremrangebyrank(key: String, start: Long, stop: Long): Single<String>

Remove all members in a sorted set within the given indexes

rxZremrangebyscore

open fun rxZremrangebyscore(key: String, min: String, max: String): Single<String>

Remove all members in a sorted set within the given scores

rxZrevrange

open fun rxZrevrange(key: String, start: Long, stop: Long, options: RangeOptions): Single<String>

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<String>

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<String>

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<String>

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<String>

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<String>

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<String>

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<String>>): RedisTransaction

Add a member to a set

saddMany

open fun saddMany(key: String, members: MutableList<String>, handler: Handler<AsyncResult<String>>): RedisTransaction

Add one or more members to a set

save

open fun save(handler: Handler<AsyncResult<String>>): RedisTransaction

Synchronously save the dataset to disk

scan

open fun scan(cursor: String, options: ScanOptions, handler: Handler<AsyncResult<String>>): RedisTransaction

Incrementally iterate the keys space

scard

open fun scard(key: String, handler: Handler<AsyncResult<String>>): RedisTransaction

Get the number of members in a set

scriptExists

open fun scriptExists(script: String, handler: Handler<AsyncResult<String>>): RedisTransaction

Check existence of script in the script cache.

scriptExistsMany

open fun scriptExistsMany(scripts: MutableList<String>, handler: Handler<AsyncResult<String>>): RedisTransaction

Check existence of scripts in the script cache.

scriptFlush

open fun scriptFlush(handler: Handler<AsyncResult<String>>): RedisTransaction

Remove all the scripts from the script cache.

scriptKill

open fun scriptKill(handler: Handler<AsyncResult<String>>): RedisTransaction

Kill the script currently in execution.

scriptLoad

open fun scriptLoad(script: String, handler: Handler<AsyncResult<String>>): RedisTransaction

Load the specified Lua script into the script cache.

sdiff

open fun sdiff(key: String, cmpkeys: MutableList<String>, handler: Handler<AsyncResult<String>>): RedisTransaction

Subtract multiple sets

sdiffstore

open fun sdiffstore(destkey: String, key: String, cmpkeys: MutableList<String>, handler: Handler<AsyncResult<String>>): RedisTransaction

Subtract multiple sets and store the resulting set in a key

select

open fun select(dbindex: Int, handler: Handler<AsyncResult<String>>): RedisTransaction

Change the selected database for the current connection

set

open fun set(key: String, value: String, handler: Handler<AsyncResult<String>>): RedisTransaction

Set the string value of a key

setBinary

open fun setBinary(key: String, value: Buffer, handler: Handler<AsyncResult<String>>): RedisTransaction

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<String>>): RedisTransaction

Set the string value of a key

setWithOptions

open fun setWithOptions(key: String, value: String, options: SetOptions, handler: Handler<AsyncResult<String>>): RedisTransaction

Set the string value of a key

setbit

open fun setbit(key: String, offset: Long, bit: Int, handler: Handler<AsyncResult<String>>): RedisTransaction

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

Set the value and expiration of a key

setnx

open fun setnx(key: String, value: String, handler: Handler<AsyncResult<String>>): RedisTransaction

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<String>>): RedisTransaction

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

sinter

open fun sinter(keys: MutableList<String>, handler: Handler<AsyncResult<String>>): RedisTransaction

Intersect multiple sets

sinterstore

open fun sinterstore(destkey: String, keys: MutableList<String>, handler: Handler<AsyncResult<String>>): RedisTransaction

Intersect multiple sets and store the resulting set in a key

sismember

open fun sismember(key: String, member: String, handler: Handler<AsyncResult<String>>): RedisTransaction

Determine if a given value is a member of a set

slaveof

open fun slaveof(host: String, port: Int, handler: Handler<AsyncResult<String>>): RedisTransaction

Make the server a slave of another instance

slaveofNoone

open fun slaveofNoone(handler: Handler<AsyncResult<String>>): RedisTransaction

Make this server a master

slowlogGet

open fun slowlogGet(limit: Int, handler: Handler<AsyncResult<String>>): RedisTransaction

Read the Redis slow queries log

slowlogLen

open fun slowlogLen(handler: Handler<AsyncResult<String>>): RedisTransaction

Get the length of the Redis slow queries log

slowlogReset

open fun slowlogReset(handler: Handler<AsyncResult<String>>): RedisTransaction

Reset the Redis slow queries log

smembers

open fun smembers(key: String, handler: Handler<AsyncResult<JsonArray>>): RedisTransaction

Get all the members in a set

smove

open fun smove(key: String, destkey: String, member: String, handler: Handler<AsyncResult<String>>): RedisTransaction

Move a member from one set to another

sort

open fun sort(key: String, options: SortOptions, handler: Handler<AsyncResult<String>>): RedisTransaction

Sort the elements in a list, set or sorted set

spop

open fun spop(key: String, handler: Handler<AsyncResult<String>>): RedisTransaction

Remove and return a random member from a set

spopMany

open fun spopMany(key: String, count: Int, handler: Handler<AsyncResult<String>>): RedisTransaction

Remove and return random members from a set

srandmember

open fun srandmember(key: String, handler: Handler<AsyncResult<String>>): RedisTransaction

Get one or multiple random members from a set

srandmemberCount

open fun srandmemberCount(key: String, count: Int, handler: Handler<AsyncResult<String>>): RedisTransaction

Get one or multiple random members from a set

srem

open fun srem(key: String, member: String, handler: Handler<AsyncResult<String>>): RedisTransaction

Remove one member from a set

sremMany

open fun sremMany(key: String, members: MutableList<String>, handler: Handler<AsyncResult<String>>): RedisTransaction

Remove one or more members from a set

sscan

open fun sscan(key: String, cursor: String, options: ScanOptions, handler: Handler<AsyncResult<String>>): RedisTransaction

Incrementally iterate Set elements

strlen

open fun strlen(key: String, handler: Handler<AsyncResult<String>>): RedisTransaction

Get the length of the value stored in a key

subscribe

open fun subscribe(channel: String, handler: Handler<AsyncResult<String>>): RedisTransaction

Listen for messages published to the given channels

subscribeMany

open fun subscribeMany(channels: MutableList<String>, handler: Handler<AsyncResult<String>>): RedisTransaction

Listen for messages published to the given channels

sunion

open fun sunion(keys: MutableList<String>, handler: Handler<AsyncResult<String>>): RedisTransaction

Add multiple sets

sunionstore

open fun sunionstore(destkey: String, keys: MutableList<String>, handler: Handler<AsyncResult<String>>): RedisTransaction

Add multiple sets and store the resulting set in a key

swapdb

open fun swapdb(index1: Int, index2: Int, handler: Handler<AsyncResult<String>>): RedisTransaction

Swaps two Redis databases

sync

open fun sync(handler: Handler<AsyncResult<String>>): RedisTransaction

Internal command used for replication

time

open fun time(handler: Handler<AsyncResult<String>>): RedisTransaction

Return the current server time

toString

open fun toString(): String

ttl

open fun ttl(key: String, handler: Handler<AsyncResult<String>>): RedisTransaction

Get the time to live for a key

type

open fun type(key: String, handler: Handler<AsyncResult<String>>): RedisTransaction

Determine the type stored at key

unlink

open fun unlink(key: String, handler: Handler<AsyncResult<String>>): RedisTransaction

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<String>>): RedisTransaction

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<String>>): RedisTransaction

Stop listening for messages posted to the given channels

unwatch

open fun unwatch(handler: Handler<AsyncResult<String>>): RedisTransaction

Forget about all watched keys

wait

open fun wait(numSlaves: Long, timeout: Long, handler: Handler<AsyncResult<String>>): RedisTransaction

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

watch

open fun watch(key: String, handler: Handler<AsyncResult<String>>): RedisTransaction

Watch the given keys to determine execution of the MULTI/EXEC block

watchMany

open fun watchMany(keys: MutableList<String>, handler: Handler<AsyncResult<String>>): RedisTransaction

Watch the given keys to determine execution of the MULTI/EXEC block

zadd

open fun zadd(key: String, score: Double, member: String, handler: Handler<AsyncResult<String>>): RedisTransaction

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<String>>): RedisTransaction

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<String>>): RedisTransaction

Get the number of members in a sorted set

zcount

open fun zcount(key: String, min: Double, max: Double, handler: Handler<AsyncResult<String>>): RedisTransaction

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

Increment the score of a member in a sorted set

zinterstore

open fun zinterstore(destkey: String, sets: MutableList<String>, options: AggregateOptions, handler: Handler<AsyncResult<String>>): RedisTransaction

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<String>>): RedisTransaction

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<String>>): RedisTransaction

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<String>>): RedisTransaction

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<String>>): RedisTransaction

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<String>>): RedisTransaction

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<String>>): RedisTransaction

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

zrank

open fun zrank(key: String, member: String, handler: Handler<AsyncResult<String>>): RedisTransaction

Determine the index of a member in a sorted set

zrem

open fun zrem(key: String, member: String, handler: Handler<AsyncResult<String>>): RedisTransaction

Remove one member from a sorted set

zremMany

open fun zremMany(key: String, members: MutableList<String>, handler: Handler<AsyncResult<String>>): RedisTransaction

Remove one or more members from a sorted set

zremrangebylex

open fun zremrangebylex(key: String, min: String, max: String, handler: Handler<AsyncResult<String>>): RedisTransaction

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<String>>): RedisTransaction

Remove all members in a sorted set within the given indexes

zremrangebyscore

open fun zremrangebyscore(key: String, min: String, max: String, handler: Handler<AsyncResult<String>>): RedisTransaction

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<String>>): RedisTransaction

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<String>>): RedisTransaction

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<String>>): RedisTransaction

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<String>>): RedisTransaction

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<String>>): RedisTransaction

Incrementally iterate sorted sets elements and associated scores

zscore

open fun zscore(key: String, member: String, handler: Handler<AsyncResult<String>>): RedisTransaction

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<String>>): RedisTransaction

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<String>>): RedisTransaction

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