vertx / io.vertx.kotlin.redis / io.vertx.redis.RedisClient

### Extensions for io.vertx.redis.RedisClient

appendAwait | `suspend fun RedisClient.appendAwait(key: String, value: String): Long` Append a value to a key
authAwait | `suspend fun RedisClient.authAwait(password: String): String` Authenticate to the server
bgrewriteaofAwait | `suspend fun RedisClient.bgrewriteaofAwait(): String` Asynchronously rewrite the append-only file
bgsaveAwait | `suspend fun RedisClient.bgsaveAwait(): String` Asynchronously save the dataset to disk
bitcountAwait | `suspend fun RedisClient.bitcountAwait(key: String): Long` Count set bits in a string
bitcountRangeAwait | `suspend fun RedisClient.bitcountRangeAwait(key: String, start: Long, end: Long): Long` Count set bits in a string
bitfieldAwait | `suspend fun RedisClient.bitfieldAwait(key: String, bitFieldOptions: BitFieldOptions): JsonArray` Perform arbitrary bitfield integer operations on strings.
bitfieldWithOverflowAwait | `suspend fun RedisClient.bitfieldWithOverflowAwait(key: String, commands: BitFieldOptions, overflow: BitFieldOverflowOptions): JsonArray` Perform arbitrary bitfield integer operations on strings.
bitopAwait | `suspend fun RedisClient.bitopAwait(operation: BitOperation, destkey: String, keys: List<String>): Long` Perform bitwise operations between strings
bitposAwait | `suspend fun RedisClient.bitposAwait(key: String, bit: Int): Long` Find first bit set or clear in a string
bitposFromAwait | `suspend fun RedisClient.bitposFromAwait(key: String, bit: Int, start: Int): Long` Find first bit set or clear in a string
bitposRangeAwait | `suspend fun RedisClient.bitposRangeAwait(key: String, bit: Int, start: Int, stop: Int): Long` Find first bit set or clear in a string
blpopAwait | `suspend fun RedisClient.blpopAwait(key: String, seconds: Int): JsonArray` Remove and get the first element in a list, or block until one is available
blpopManyAwait | `suspend fun RedisClient.blpopManyAwait(keys: List<String>, seconds: Int): JsonArray` Remove and get the first element in any of the lists, or block until one is available
brpopAwait | `suspend fun RedisClient.brpopAwait(key: String, seconds: Int): JsonArray` Remove and get the last element in a list, or block until one is available
brpopManyAwait | `suspend fun RedisClient.brpopManyAwait(keys: List<String>, seconds: Int): JsonArray` Remove and get the last element in any of the lists, or block until one is available
brpoplpushAwait | `suspend fun RedisClient.brpoplpushAwait(key: String, destkey: String, seconds: Int): String` Pop a value from a list, push it to another list and return it; or block until one is available
clientGetnameAwait | `suspend fun RedisClient.clientGetnameAwait(): String` Get the current connection name
clientKillAwait | `suspend fun RedisClient.clientKillAwait(filter: KillFilter): Long` Kill the connection of a client
clientListAwait | `suspend fun RedisClient.clientListAwait(): String` Get the list of client connections
clientPauseAwait | `suspend fun RedisClient.clientPauseAwait(millis: Long): String` Stop processing commands from clients for some time
clientReplyAwait | `suspend fun RedisClient.clientReplyAwait(options: ClientReplyOptions): String` Instruct the server whether to reply to commands.
clientSetnameAwait | `suspend fun RedisClient.clientSetnameAwait(name: String): String` Set the current connection name
closeAwait | `suspend fun RedisClient.closeAwait(): Unit` Close the client - when it is fully closed the handler will be called.
clusterAddslotsAwait | `suspend fun RedisClient.clusterAddslotsAwait(slots: List<Long>): Unit` Assign new hash slots to receiving node.
clusterCountFailureReportsAwait | `suspend fun RedisClient.clusterCountFailureReportsAwait(nodeId: String): Long` Return the number of failure reports active for a given node.
clusterCountkeysinslotAwait | `suspend fun RedisClient.clusterCountkeysinslotAwait(slot: Long): Long` Return the number of local keys in the specified hash slot.
clusterDelslotsAwait | `suspend fun RedisClient.clusterDelslotsAwait(slot: Long): Unit` Set hash slots as unbound in receiving node.
clusterDelslotsManyAwait | `suspend fun RedisClient.clusterDelslotsManyAwait(slots: List<Long>): Unit` Set hash slots as unbound in receiving node.
clusterFailOverWithOptionsAwait | `suspend fun RedisClient.clusterFailOverWithOptionsAwait(options: FailoverOptions): Unit` Forces a slave to perform a manual failover of its master.
clusterFailoverAwait | `suspend fun RedisClient.clusterFailoverAwait(): Unit` Forces a slave to perform a manual failover of its master.
clusterForgetAwait | `suspend fun RedisClient.clusterForgetAwait(nodeId: String): Unit` Remove a node from the nodes table.
clusterGetkeysinslotAwait | `suspend fun RedisClient.clusterGetkeysinslotAwait(slot: Long, count: Long): JsonArray` Return local key names in the specified hash slot.
clusterInfoAwait | `suspend fun RedisClient.clusterInfoAwait(): JsonArray` Provides info about Redis Cluster node state.
clusterKeyslotAwait | `suspend fun RedisClient.clusterKeyslotAwait(key: String): Long` Returns the hash slot of the specified key.
clusterMeetAwait | `suspend fun RedisClient.clusterMeetAwait(ip: String, port: Long): Unit` Force a node cluster to handshake with another node.
clusterNodesAwait | `suspend fun RedisClient.clusterNodesAwait(): JsonArray` Get Cluster config for the node.
clusterReplicateAwait | `suspend fun RedisClient.clusterReplicateAwait(nodeId: String): Unit` Reconfigure a node as a slave of the specified master node.
clusterResetAwait | `suspend fun RedisClient.clusterResetAwait(): Unit` Reset a Redis Cluster node.
clusterResetWithOptionsAwait | `suspend fun RedisClient.clusterResetWithOptionsAwait(options: ResetOptions): Unit` Reset a Redis Cluster node.
clusterSaveconfigAwait | `suspend fun RedisClient.clusterSaveconfigAwait(): Unit` Forces the node to save cluster state on disk.
clusterSetConfigEpochAwait | `suspend fun RedisClient.clusterSetConfigEpochAwait(epoch: Long): Unit` Set the configuration epoch in a new node.
clusterSetslotAwait | `suspend fun RedisClient.clusterSetslotAwait(slot: Long, subcommand: SlotCmd): Unit` Bind an hash slot to a specific node.
clusterSetslotWithNodeAwait | `suspend fun RedisClient.clusterSetslotWithNodeAwait(slot: Long, subcommand: SlotCmd, nodeId: String): Unit` Bind an hash slot to a specific node.
clusterSlavesAwait | `suspend fun RedisClient.clusterSlavesAwait(nodeId: String): JsonArray` List slave nodes of the specified master node.
clusterSlotsAwait | `suspend fun RedisClient.clusterSlotsAwait(): JsonArray` Get array of Cluster slot to node mappings
commandAwait | `suspend fun RedisClient.commandAwait(): JsonArray` Get array of Redis command details
commandCountAwait | `suspend fun RedisClient.commandCountAwait(): Long` Get total number of Redis commands
commandGetkeysAwait | `suspend fun RedisClient.commandGetkeysAwait(): JsonArray` Extract keys given a full Redis command
commandInfoAwait | `suspend fun RedisClient.commandInfoAwait(commands: List<String>): JsonArray` Get array of specific Redis command details
configGetAwait | `suspend fun RedisClient.configGetAwait(parameter: String): JsonArray` Get the value of a configuration parameter
configResetstatAwait | `suspend fun RedisClient.configResetstatAwait(): String` Reset the stats returned by INFO
configRewriteAwait | `suspend fun RedisClient.configRewriteAwait(): String` Rewrite the configuration file with the in memory configuration
configSetAwait | `suspend fun RedisClient.configSetAwait(parameter: String, value: String): String` Set a configuration parameter to the given value
dbsizeAwait | `suspend fun RedisClient.dbsizeAwait(): Long` Return the number of keys in the selected database
debugObjectAwait | `suspend fun RedisClient.debugObjectAwait(key: String): String` Get debugging information about a key
debugSegfaultAwait | `suspend fun RedisClient.debugSegfaultAwait(): String` Make the server crash
decrAwait | `suspend fun RedisClient.decrAwait(key: String): Long` Decrement the integer value of a key by one
decrbyAwait | `suspend fun RedisClient.decrbyAwait(key: String, decrement: Long): Long` Decrement the integer value of a key by the given number
delAwait | `suspend fun RedisClient.delAwait(key: String): Long` Delete a key
delManyAwait | `suspend fun RedisClient.delManyAwait(keys: List<String>): Long` Delete many keys
dumpAwait | `suspend fun RedisClient.dumpAwait(key: String): String` Return a serialized version of the value stored at the specified key.
echoAwait | `suspend fun RedisClient.echoAwait(message: String): String` Echo the given string
evalAwait | `suspend fun RedisClient.evalAwait(script: String, keys: List<String>, args: List<String>): 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.
evalScriptAwait | `suspend fun RedisClient.evalScriptAwait(script: Script, keys: List<String>, args: List<String>): 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.
evalshaAwait | `suspend fun RedisClient.evalshaAwait(sha1: String, keys: List<String>, values: List<String>): 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.
existsAwait | `suspend fun RedisClient.existsAwait(key: String): Long` Determine if a key exists
existsManyAwait | `suspend fun RedisClient.existsManyAwait(keys: List<String>): Long` Determine if one or many keys exist
expireAwait | `suspend fun RedisClient.expireAwait(key: String, seconds: Long): Long` Set a key's time to live in seconds
expireatAwait | `suspend fun RedisClient.expireatAwait(key: String, seconds: Long): Long` Set the expiration for a key as a UNIX timestamp
flushallAwait | `suspend fun RedisClient.flushallAwait(): String` Remove all keys from all databases
flushdbAwait | `suspend fun RedisClient.flushdbAwait(): String` Remove all keys from the current database
geoaddAwait | `suspend fun RedisClient.geoaddAwait(key: String, longitude: Double, latitude: Double, member: String): Long` Add one or more geospatial items in the geospatial index represented using a sorted set.
geoaddManyAwait | `suspend fun RedisClient.geoaddManyAwait(key: String, members: List<GeoMember>): Long` Add one or more geospatial items in the geospatial index represented using a sorted set.
geodistAwait | `suspend fun RedisClient.geodistAwait(key: String, member1: String, member2: String): String` Return the distance between two members in the geospatial index represented by the sorted set.
geodistWithUnitAwait | `suspend fun RedisClient.geodistWithUnitAwait(key: String, member1: String, member2: String, unit: GeoUnit): String` Return the distance between two members in the geospatial index represented by the sorted set.
geohashAwait | `suspend fun RedisClient.geohashAwait(key: String, member: String): 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).
geohashManyAwait | `suspend fun RedisClient.geohashManyAwait(key: String, members: List<String>): 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).
geoposAwait | `suspend fun RedisClient.geoposAwait(key: String, member: String): JsonArray` Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.
geoposManyAwait | `suspend fun RedisClient.geoposManyAwait(key: String, members: List<String>): JsonArray` Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.
georadiusAwait | `suspend fun RedisClient.georadiusAwait(key: String, longitude: Double, latitude: Double, radius: Double, unit: GeoUnit): 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).
georadiusWithOptionsAwait | `suspend fun RedisClient.georadiusWithOptionsAwait(key: String, longitude: Double, latitude: Double, radius: Double, unit: GeoUnit, options: GeoRadiusOptions): 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).
georadiusbymemberAwait | `suspend fun RedisClient.georadiusbymemberAwait(key: String, member: String, radius: Double, unit: GeoUnit): 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.
georadiusbymemberWithOptionsAwait | `suspend fun RedisClient.georadiusbymemberWithOptionsAwait(key: String, member: String, radius: Double, unit: GeoUnit, options: GeoRadiusOptions): 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.
getAwait | `suspend fun RedisClient.getAwait(key: String): String?` Get the value of a key
getBinaryAwait | `suspend fun RedisClient.getBinaryAwait(key: String): Buffer?` Get the value of a key - without decoding as utf-8
getbitAwait | `suspend fun RedisClient.getbitAwait(key: String, offset: Long): Long` Returns the bit value at offset in the string value stored at key
getrangeAwait | `suspend fun RedisClient.getrangeAwait(key: String, start: Long, end: Long): String` Get a substring of the string stored at a key
getsetAwait | `suspend fun RedisClient.getsetAwait(key: String, value: String): String?` Set the string value of a key and return its old value
hdelAwait | `suspend fun RedisClient.hdelAwait(key: String, field: String): Long` Delete one or more hash fields
hdelManyAwait | `suspend fun RedisClient.hdelManyAwait(key: String, fields: List<String>): Long` Delete one or more hash fields
hexistsAwait | `suspend fun RedisClient.hexistsAwait(key: String, field: String): Long` Determine if a hash field exists
hgetAwait | `suspend fun RedisClient.hgetAwait(key: String, field: String): String?` Get the value of a hash field
hgetallAwait | `suspend fun RedisClient.hgetallAwait(key: String): JsonObject` Get all the fields and values in a hash
hincrbyAwait | `suspend fun RedisClient.hincrbyAwait(key: String, field: String, increment: Long): Long` Increment the integer value of a hash field by the given number
hincrbyfloatAwait | `suspend fun RedisClient.hincrbyfloatAwait(key: String, field: String, increment: Double): String` Increment the float value of a hash field by the given amount
hkeysAwait | `suspend fun RedisClient.hkeysAwait(key: String): JsonArray` Get all the fields in a hash
hlenAwait | `suspend fun RedisClient.hlenAwait(key: String): Long` Get the number of fields in a hash
hmgetAwait | `suspend fun RedisClient.hmgetAwait(key: String, fields: List<String>): JsonArray` Get the values of all the given hash fields
hmsetAwait | `suspend fun RedisClient.hmsetAwait(key: String, values: JsonObject): String` Set multiple hash fields to multiple values
hscanAwait | `suspend fun RedisClient.hscanAwait(key: String, cursor: String, options: ScanOptions): JsonArray` Incrementally iterate hash fields and associated values
hsetAwait | `suspend fun RedisClient.hsetAwait(key: String, field: String, value: String): Long` Set the string value of a hash field
hsetnxAwait | `suspend fun RedisClient.hsetnxAwait(key: String, field: String, value: String): Long` Set the value of a hash field, only if the field does not exist
hstrlenAwait | `suspend fun RedisClient.hstrlenAwait(key: String, field: String): Long` Get the length of the value of a hash field.
hvalsAwait | `suspend fun RedisClient.hvalsAwait(key: String): JsonArray` Get all the values in a hash
incrAwait | `suspend fun RedisClient.incrAwait(key: String): Long` Increment the integer value of a key by one
incrbyAwait | `suspend fun RedisClient.incrbyAwait(key: String, increment: Long): Long` Increment the integer value of a key by the given amount
incrbyfloatAwait | `suspend fun RedisClient.incrbyfloatAwait(key: String, increment: Double): String` Increment the float value of a key by the given amount
infoAwait | `suspend fun RedisClient.infoAwait(): JsonObject` Get information and statistics about the server
infoSectionAwait | `suspend fun RedisClient.infoSectionAwait(section: String): JsonObject` Get information and statistics about the server
keysAwait | `suspend fun RedisClient.keysAwait(pattern: String): JsonArray` Find all keys matching the given pattern
lastsaveAwait | `suspend fun RedisClient.lastsaveAwait(): Long` Get the UNIX time stamp of the last successful save to disk
lindexAwait | `suspend fun RedisClient.lindexAwait(key: String, index: Int): String` Get an element from a list by its index
linsertAwait | `suspend fun RedisClient.linsertAwait(key: String, option: InsertOptions, pivot: String, value: String): Long` Insert an element before or after another element in a list
llenAwait | `suspend fun RedisClient.llenAwait(key: String): Long` Get the length of a list
lpopAwait | `suspend fun RedisClient.lpopAwait(key: String): String?` Remove and get the first element in a list
lpushAwait | `suspend fun RedisClient.lpushAwait(key: String, value: String): Long` Prepend one value to a list
lpushManyAwait | `suspend fun RedisClient.lpushManyAwait(key: String, values: List<String>): Long` Prepend one or multiple values to a list
lpushxAwait | `suspend fun RedisClient.lpushxAwait(key: String, value: String): Long` Prepend a value to a list, only if the list exists
lrangeAwait | `suspend fun RedisClient.lrangeAwait(key: String, from: Long, to: Long): JsonArray` Get a range of elements from a list
lremAwait | `suspend fun RedisClient.lremAwait(key: String, count: Long, value: String): Long` Remove elements from a list
lsetAwait | `suspend fun RedisClient.lsetAwait(key: String, index: Long, value: String): String` Set the value of an element in a list by its index
ltrimAwait | `suspend fun RedisClient.ltrimAwait(key: String, from: Long, to: Long): String` Trim a list to the specified range
mgetAwait | `suspend fun RedisClient.mgetAwait(key: String): JsonArray` Get the value of the given key
mgetManyAwait | `suspend fun RedisClient.mgetManyAwait(keys: List<String>): JsonArray` Get the values of all the given keys
migrateAwait | `suspend fun RedisClient.migrateAwait(host: String, port: Int, key: String, destdb: Int, timeout: Long, options: MigrateOptions): String` Atomically transfer a key from a Redis instance to another one.
monitorAwait | `suspend fun RedisClient.monitorAwait(): Unit` Listen for all requests received by the server in real time
moveAwait | `suspend fun RedisClient.moveAwait(key: String, destdb: Int): Long` Move a key to another database
msetAwait | `suspend fun RedisClient.msetAwait(keyvals: JsonObject): String` Set multiple keys to multiple values
msetnxAwait | `suspend fun RedisClient.msetnxAwait(keyvals: JsonObject): Long` Set multiple keys to multiple values, only if none of the keys exist
objectAwait | `suspend fun RedisClient.objectAwait(key: String, cmd: ObjectCmd): Unit` Inspect the internals of Redis objects
persistAwait | `suspend fun RedisClient.persistAwait(key: String): Long` Remove the expiration from a key
pexpireAwait | `suspend fun RedisClient.pexpireAwait(key: String, millis: Long): Long` Set a key's time to live in milliseconds
pexpireatAwait | `suspend fun RedisClient.pexpireatAwait(key: String, millis: Long): Long` Set the expiration for a key as a UNIX timestamp specified in milliseconds
pfaddAwait | `suspend fun RedisClient.pfaddAwait(key: String, element: String): Long` Adds the specified element to the specified HyperLogLog.
pfaddManyAwait | `suspend fun RedisClient.pfaddManyAwait(key: String, elements: List<String>): Long` Adds the specified elements to the specified HyperLogLog.
pfcountAwait | `suspend fun RedisClient.pfcountAwait(key: String): Long` Return the approximated cardinality of the set observed by the HyperLogLog at key.
pfcountManyAwait | `suspend fun RedisClient.pfcountManyAwait(keys: List<String>): Long` Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).
pfmergeAwait | `suspend fun RedisClient.pfmergeAwait(destkey: String, keys: List<String>): String` Merge N different HyperLogLogs into a single one.
pingAwait | `suspend fun RedisClient.pingAwait(): String` Ping the server
psetexAwait | `suspend fun RedisClient.psetexAwait(key: String, millis: Long, value: String): Unit` Set the value and expiration in milliseconds of a key
psubscribeAwait | `suspend fun RedisClient.psubscribeAwait(pattern: String): JsonArray` Listen for messages published to channels matching the given pattern
psubscribeManyAwait | `suspend fun RedisClient.psubscribeManyAwait(patterns: List<String>): JsonArray` Listen for messages published to channels matching the given patterns
pttlAwait | `suspend fun RedisClient.pttlAwait(key: String): Long` Get the time to live for a key in milliseconds
publishAwait | `suspend fun RedisClient.publishAwait(channel: String, message: String): Long` Post a message to a channel
pubsubChannelsAwait | `suspend fun RedisClient.pubsubChannelsAwait(pattern: String): JsonArray` Lists the currently active channels - only those matching the pattern
pubsubNumpatAwait | `suspend fun RedisClient.pubsubNumpatAwait(): Long` Returns the number of subscriptions to patterns (that are performed using the PSUBSCRIBE command)
pubsubNumsubAwait | `suspend fun RedisClient.pubsubNumsubAwait(channels: List<String>): JsonArray` Returns the number of subscribers (not counting clients subscribed to patterns) for the specified channels
punsubscribeAwait | `suspend fun RedisClient.punsubscribeAwait(patterns: List<String>): Unit` Stop listening for messages posted to channels matching the given patterns
randomkeyAwait | `suspend fun RedisClient.randomkeyAwait(): String` Return a random key from the keyspace
renameAwait | `suspend fun RedisClient.renameAwait(key: String, newkey: String): String` Rename a key
renamenxAwait | `suspend fun RedisClient.renamenxAwait(key: String, newkey: String): Long` Rename a key, only if the new key does not exist
restoreAwait | `suspend fun RedisClient.restoreAwait(key: String, millis: Long, serialized: String): String` Create a key using the provided serialized value, previously obtained using DUMP.
roleAwait | `suspend fun RedisClient.roleAwait(): JsonArray` Return the role of the instance in the context of replication
rpopAwait | `suspend fun RedisClient.rpopAwait(key: String): String` Remove and get the last element in a list
rpoplpushAwait | `suspend fun RedisClient.rpoplpushAwait(key: String, destkey: String): String` Remove the last element in a list, append it to another list and return it
rpushAwait | `suspend fun RedisClient.rpushAwait(key: String, value: String): Long` Append one or multiple values to a list
rpushManyAwait | `suspend fun RedisClient.rpushManyAwait(key: String, values: List<String>): Long` Append one or multiple values to a list
rpushxAwait | `suspend fun RedisClient.rpushxAwait(key: String, value: String): Long` Append a value to a list, only if the list exists
saddAwait | `suspend fun RedisClient.saddAwait(key: String, member: String): Long` Add a member to a set
saddManyAwait | `suspend fun RedisClient.saddManyAwait(key: String, members: List<String>): Long` Add one or more members to a set
saveAwait | `suspend fun RedisClient.saveAwait(): String` Synchronously save the dataset to disk
scanAwait | `suspend fun RedisClient.scanAwait(cursor: String, options: ScanOptions): JsonArray` Incrementally iterate the keys space
scardAwait | `suspend fun RedisClient.scardAwait(key: String): Long` Get the number of members in a set
scriptDebugAwait | `suspend fun RedisClient.scriptDebugAwait(scriptDebugOptions: ScriptDebugOptions): String` Set the debug mode for executed scripts.
scriptExistsAwait | `suspend fun RedisClient.scriptExistsAwait(script: String): JsonArray` Check existence of script in the script cache.
scriptExistsManyAwait | `suspend fun RedisClient.scriptExistsManyAwait(scripts: List<String>): JsonArray` Check existence of scripts in the script cache.
scriptFlushAwait | `suspend fun RedisClient.scriptFlushAwait(): String` Remove all the scripts from the script cache.
scriptKillAwait | `suspend fun RedisClient.scriptKillAwait(): String` Kill the script currently in execution.
scriptLoadAwait | `suspend fun RedisClient.scriptLoadAwait(script: String): String` Load the specified Lua script into the script cache.
sdiffAwait | `suspend fun RedisClient.sdiffAwait(key: String, cmpkeys: List<String>): JsonArray` Subtract multiple sets
sdiffstoreAwait | `suspend fun RedisClient.sdiffstoreAwait(destkey: String, key: String, cmpkeys: List<String>): Long` Subtract multiple sets and store the resulting set in a key
selectAwait | `suspend fun RedisClient.selectAwait(dbindex: Int): String` Change the selected database for the current connection
setAwait | `suspend fun RedisClient.setAwait(key: String, value: String): Unit` Set the string value of a key
setBinaryAwait | `suspend fun RedisClient.setBinaryAwait(key: String, value: Buffer): Unit` Set the binary string value of a key - without encoding as utf-8
setBinaryWithOptionsAwait | `suspend fun RedisClient.setBinaryWithOptionsAwait(key: String, value: Buffer, options: SetOptions): Unit` Set the string value of a key
setWithOptionsAwait | `suspend fun RedisClient.setWithOptionsAwait(key: String, value: String, options: SetOptions): String` Set the string value of a key
setbitAwait | `suspend fun RedisClient.setbitAwait(key: String, offset: Long, bit: Int): Long` Sets or clears the bit at offset in the string value stored at key
setexAwait | `suspend fun RedisClient.setexAwait(key: String, seconds: Long, value: String): String` Set the value and expiration of a key
setnxAwait | `suspend fun RedisClient.setnxAwait(key: String, value: String): Long` Set the value of a key, only if the key does not exist
setrangeAwait | `suspend fun RedisClient.setrangeAwait(key: String, offset: Int, value: String): Long` Overwrite part of a string at key starting at the specified offset
sinterAwait | `suspend fun RedisClient.sinterAwait(keys: List<String>): JsonArray` Intersect multiple sets
sinterstoreAwait | `suspend fun RedisClient.sinterstoreAwait(destkey: String, keys: List<String>): Long` Intersect multiple sets and store the resulting set in a key
sismemberAwait | `suspend fun RedisClient.sismemberAwait(key: String, member: String): Long` Determine if a given value is a member of a set
slaveofAwait | `suspend fun RedisClient.slaveofAwait(host: String, port: Int): String` Make the server a slave of another instance
slaveofNooneAwait | `suspend fun RedisClient.slaveofNooneAwait(): String` Make this server a master
slowlogGetAwait | `suspend fun RedisClient.slowlogGetAwait(limit: Int): JsonArray` Read the Redis slow queries log
slowlogLenAwait | `suspend fun RedisClient.slowlogLenAwait(): Long` Get the length of the Redis slow queries log
slowlogResetAwait | `suspend fun RedisClient.slowlogResetAwait(): Unit` Reset the Redis slow queries log
smembersAwait | `suspend fun RedisClient.smembersAwait(key: String): JsonArray` Get all the members in a set
smoveAwait | `suspend fun RedisClient.smoveAwait(key: String, destkey: String, member: String): Long` Move a member from one set to another
sortAwait | `suspend fun RedisClient.sortAwait(key: String, options: SortOptions): JsonArray` Sort the elements in a list, set or sorted set
spopAwait | `suspend fun RedisClient.spopAwait(key: String): String?` Remove and return a random member from a set
spopManyAwait | `suspend fun RedisClient.spopManyAwait(key: String, count: Int): JsonArray` Remove and return random members from a set
srandmemberAwait | `suspend fun RedisClient.srandmemberAwait(key: String): String` Get one or multiple random members from a set
srandmemberCountAwait | `suspend fun RedisClient.srandmemberCountAwait(key: String, count: Int): JsonArray` Get one or multiple random members from a set
sremAwait | `suspend fun RedisClient.sremAwait(key: String, member: String): Long` Remove one member from a set
sremManyAwait | `suspend fun RedisClient.sremManyAwait(key: String, members: List<String>): Long` Remove one or more members from a set
sscanAwait | `suspend fun RedisClient.sscanAwait(key: String, cursor: String, options: ScanOptions): JsonArray` Incrementally iterate Set elements
strlenAwait | `suspend fun RedisClient.strlenAwait(key: String): Long` Get the length of the value stored in a key
subscribeAwait | `suspend fun RedisClient.subscribeAwait(channel: String): JsonArray` Listen for messages published to the given channels
subscribeManyAwait | `suspend fun RedisClient.subscribeManyAwait(channels: List<String>): JsonArray` Listen for messages published to the given channels
sunionAwait | `suspend fun RedisClient.sunionAwait(keys: List<String>): JsonArray` Add multiple sets
sunionstoreAwait | `suspend fun RedisClient.sunionstoreAwait(destkey: String, keys: List<String>): Long` Add multiple sets and store the resulting set in a key
swapdbAwait | `suspend fun RedisClient.swapdbAwait(index1: Int, index2: Int): String` Swaps two Redis databases
syncAwait | `suspend fun RedisClient.syncAwait(): Unit` Internal command used for replication
timeAwait | `suspend fun RedisClient.timeAwait(): JsonArray` Return the current server time
touchAwait | `suspend fun RedisClient.touchAwait(key: String): Long` Alters the last access time of a key(s). Returns the number of existing keys specified.
touchManyAwait | `suspend fun RedisClient.touchManyAwait(keys: List<String>): Long` Alters the last access time of a key(s). Returns the number of existing keys specified.
ttlAwait | `suspend fun RedisClient.ttlAwait(key: String): Long` Get the time to live for a key
typeAwait | `suspend fun RedisClient.typeAwait(key: String): String` Determine the type stored at key
unlinkAwait | `suspend fun RedisClient.unlinkAwait(key: String): Long` Delete a key asynchronously in another thread. Otherwise it is just as DEL, but non blocking.
unlinkManyAwait | `suspend fun RedisClient.unlinkManyAwait(keys: List<String>): Long` Delete multiple keys asynchronously in another thread. Otherwise it is just as DEL, but non blocking.
unsubscribeAwait | `suspend fun RedisClient.unsubscribeAwait(channels: List<String>): Unit` Stop listening for messages posted to the given channels
waitAwait | `suspend fun RedisClient.waitAwait(numSlaves: Long, timeout: Long): String` Wait for the synchronous replication of all the write commands sent in the context of the current connection.
zaddAwait | `suspend fun RedisClient.zaddAwait(key: String, score: Double, member: String): Long` Add one or more members to a sorted set, or update its score if it already exists
zaddManyAwait | `suspend fun RedisClient.zaddManyAwait(key: String, members: Map<String, Double>): Long` Add one or more members to a sorted set, or update its score if it already exists
zcardAwait | `suspend fun RedisClient.zcardAwait(key: String): Long` Get the number of members in a sorted set
zcountAwait | `suspend fun RedisClient.zcountAwait(key: String, min: Double, max: Double): Long` Count the members in a sorted set with scores within the given values
zincrbyAwait | `suspend fun RedisClient.zincrbyAwait(key: String, increment: Double, member: String): String` Increment the score of a member in a sorted set
zinterstoreAwait | `suspend fun RedisClient.zinterstoreAwait(destkey: String, sets: List<String>, options: AggregateOptions): Long` Intersect multiple sorted sets and store the resulting sorted set in a new key
zinterstoreWeighedAwait | `suspend fun RedisClient.zinterstoreWeighedAwait(destkey: String, sets: Map<String, Double>, options: AggregateOptions): Long` Intersect multiple sorted sets and store the resulting sorted set in a new key using weights for scoring
zlexcountAwait | `suspend fun RedisClient.zlexcountAwait(key: String, min: String, max: String): Long` Count the number of members in a sorted set between a given lexicographical range
zrangeAwait | `suspend fun RedisClient.zrangeAwait(key: String, start: Long, stop: Long): JsonArray` Return a range of members in a sorted set, by index
zrangeWithOptionsAwait | `suspend fun RedisClient.zrangeWithOptionsAwait(key: String, start: Long, stop: Long, options: RangeOptions): JsonArray` Return a range of members in a sorted set, by index
zrangebylexAwait | `suspend fun RedisClient.zrangebylexAwait(key: String, min: String, max: String, options: LimitOptions): JsonArray` Return a range of members in a sorted set, by lexicographical range
zrangebyscoreAwait | `suspend fun RedisClient.zrangebyscoreAwait(key: String, min: String, max: String, options: RangeLimitOptions): JsonArray` Return a range of members in a sorted set, by score
zrankAwait | `suspend fun RedisClient.zrankAwait(key: String, member: String): Long` Determine the index of a member in a sorted set
zremAwait | `suspend fun RedisClient.zremAwait(key: String, member: String): Long` Remove one member from a sorted set
zremManyAwait | `suspend fun RedisClient.zremManyAwait(key: String, members: List<String>): Long` Remove one or more members from a sorted set
zremrangebylexAwait | `suspend fun RedisClient.zremrangebylexAwait(key: String, min: String, max: String): Long` Remove all members in a sorted set between the given lexicographical range
zremrangebyrankAwait | `suspend fun RedisClient.zremrangebyrankAwait(key: String, start: Long, stop: Long): Long` Remove all members in a sorted set within the given indexes
zremrangebyscoreAwait | `suspend fun RedisClient.zremrangebyscoreAwait(key: String, min: String, max: String): Long` Remove all members in a sorted set within the given scores
zrevrangeAwait | `suspend fun RedisClient.zrevrangeAwait(key: String, start: Long, stop: Long, options: RangeOptions): JsonArray` Return a range of members in a sorted set, by index, with scores ordered from high to low
zrevrangebylexAwait | `suspend fun RedisClient.zrevrangebylexAwait(key: String, max: String, min: String, options: LimitOptions): JsonArray` Return a range of members in a sorted set, by score, between the given lexicographical range with scores ordered from high to low
zrevrangebyscoreAwait | `suspend fun RedisClient.zrevrangebyscoreAwait(key: String, max: String, min: String, options: RangeLimitOptions): JsonArray` Return a range of members in a sorted set, by score, with scores ordered from high to low
zrevrankAwait | `suspend fun RedisClient.zrevrankAwait(key: String, member: String): Long` Determine the index of a member in a sorted set, with scores ordered from high to low
zscanAwait | `suspend fun RedisClient.zscanAwait(key: String, cursor: String, options: ScanOptions): JsonArray` Incrementally iterate sorted sets elements and associated scores
zscoreAwait | `suspend fun RedisClient.zscoreAwait(key: String, member: String): String` Get the score associated with the given member in a sorted set
zunionstoreAwait | `suspend fun RedisClient.zunionstoreAwait(destkey: String, sets: List<String>, options: AggregateOptions): Long` Add multiple sorted sets and store the resulting sorted set in a new key
zunionstoreWeighedAwait | `suspend fun RedisClient.zunionstoreWeighedAwait(key: String, sets: Map<String, Double>, options: AggregateOptions): Long` Add multiple sorted sets using weights, and store the resulting sorted set in a new key