java.lang.Object

io.lettuce.core.AbstractRedisReactiveCommands<K,V>

Type Parameters:: K - Key type.; V - Value type.

All Implemented Interfaces:: BaseRedisReactiveCommands<K,V>, RedisAclReactiveCommands<K,V>, RedisGeoReactiveCommands<K,V>, RedisHashReactiveCommands<K,V>, RedisHLLReactiveCommands<K,V>, RedisKeyReactiveCommands<K,V>, RedisListReactiveCommands<K,V>, RedisScriptingReactiveCommands<K,V>, RedisServerReactiveCommands<K,V>, RedisSetReactiveCommands<K,V>, RedisSortedSetReactiveCommands<K,V>, RedisStreamReactiveCommands<K,V>, RedisStringReactiveCommands<K,V>, RedisTransactionalReactiveCommands<K,V>, RedisClusterReactiveCommands<K,V>

Direct Known Subclasses:: RedisAdvancedClusterReactiveCommandsImpl, RedisReactiveCommandsImpl, RedisSentinelReactiveCommandsImpl

public abstract class AbstractRedisReactiveCommands<K,V>
extends Object
implements RedisAclReactiveCommands<K,V>, RedisHashReactiveCommands<K,V>, RedisKeyReactiveCommands<K,V>, RedisStringReactiveCommands<K,V>, RedisListReactiveCommands<K,V>, RedisSetReactiveCommands<K,V>, RedisSortedSetReactiveCommands<K,V>, RedisScriptingReactiveCommands<K,V>, RedisServerReactiveCommands<K,V>, RedisHLLReactiveCommands<K,V>, BaseRedisReactiveCommands<K,V>, RedisTransactionalReactiveCommands<K,V>, RedisGeoReactiveCommands<K,V>, RedisClusterReactiveCommands<K,V>

A reactive and thread-safe API for a Redis connection.

Since:: 4.0
Author:: Mark Paluch, Nikolai Perevozchikov, Tugdual Grall, dengliming, Andrey Shlykov

Constructor Summary

Constructors

Constructor Description

AbstractRedisReactiveCommands(StatefulConnection<K,V> connection, RedisCodec<K,V> codec)
Initialize a new instance.

Method Summary

Modifier and Type	Method	Description
`Mono<Set<AclCategory>>`	`aclCat()`	The command shows the available ACL categories if called without arguments.
`Mono<Set<CommandType>>`	`aclCat(AclCategory category)`	The command shows all the Redis commands in the specified category.
`Mono<Long>`	`aclDeluser(String... usernames)`	Delete all the specified ACL users and terminate all the connections that are authenticated with such users.
`Mono<String>`	`aclGenpass()`	The command generates a password.
`Mono<String>`	`aclGenpass(int bits)`	The command generates a password.
`Mono<List<Object>>`	`aclGetuser(String username)`	The command returns all the rules defined for an existing ACL user.
`Flux<String>`	`aclList()`	The command shows the currently active ACL rules in the Redis server.
`Mono<String>`	`aclLoad()`	When Redis is configured to use an ACL file (with the aclfile configuration option), this command will reload the ACLs from the file, replacing all the current ACL rules with the ones defined in the file.
`Flux<Map<String,Object>>`	`aclLog()`	The command shows a list of recent ACL security events.
`Flux<Map<String,Object>>`	`aclLog(int count)`	The command shows a list of recent ACL security events.
`Mono<String>`	`aclLogReset()`	The command clears ACL security events.
`Mono<String>`	`aclSave()`	When Redis is configured to use an ACL file (with the aclfile configuration option), this command will save the currently defined ACLs from the server memory to the ACL file.
`Mono<String>`	`aclSetuser(String username, AclSetuserArgs args)`	Create an ACL user with the specified rules or modify the rules of an existing user.
`Flux<String>`	`aclUsers()`	The command shows a list of all the usernames of the currently configured users in the Redis ACL system.
`Mono<String>`	`aclWhoami()`	The command shows a list of all the usernames of the currently configured users in the Redis ACL system.
`Mono<Long>`	`append(K key, V value)`	Append a value to a key.
`Mono<String>`	`asking()`	The asking command is required after a `-ASK` redirection.
`Mono<String>`	`auth(CharSequence password)`	Authenticate to the server.
`Mono<String>`	`auth(String username, CharSequence password)`	Authenticate to the server with username and password.
`Mono<String>`	`bgrewriteaof()`	Asynchronously rewrite the append-only file.
`Mono<String>`	`bgsave()`	Asynchronously save the dataset to disk.
`Mono<Long>`	`bitcount(K key)`	Count set bits in a string.
`Mono<Long>`	`bitcount(K key, long start, long end)`	Count set bits in a string.
`Flux<Value<Long>>`	`bitfield(K key, BitFieldArgs args)`	Execute `BITFIELD` with its subcommands.
`Mono<Long>`	`bitopAnd(K destination, K... keys)`	Perform bitwise AND between strings.
`Mono<Long>`	`bitopNot(K destination, K source)`	Perform bitwise NOT between strings.
`Mono<Long>`	`bitopOr(K destination, K... keys)`	Perform bitwise OR between strings.
`Mono<Long>`	`bitopXor(K destination, K... keys)`	Perform bitwise XOR between strings.
`Mono<Long>`	`bitpos(K key, boolean state)`	Find first bit set or clear in a string.
`Mono<Long>`	`bitpos(K key, boolean state, long start)`	Find first bit set or clear in a string.
`Mono<Long>`	`bitpos(K key, boolean state, long start, long end)`	Find first bit set or clear in a string.
`Mono<V>`	`blmove(K source, K destination, LMoveArgs args, double timeout)`	Atomically returns and removes the first/last element (head/tail depending on the wherefrom argument) of the list stored at source, and pushes the element at the first/last element (head/tail depending on the whereto argument) of the list stored at destination.
`Mono<V>`	`blmove(K source, K destination, LMoveArgs args, long timeout)`	Atomically returns and removes the first/last element (head/tail depending on the wherefrom argument) of the list stored at source, and pushes the element at the first/last element (head/tail depending on the whereto argument) of the list stored at destination.
`Mono<KeyValue<K,V>>`	`blpop(double timeout, K... keys)`	Remove and get the first element in a list, or block until one is available.
`Mono<KeyValue<K,V>>`	`blpop(long timeout, K... keys)`	Remove and get the first element in a list, or block until one is available.
`Mono<KeyValue<K,V>>`	`brpop(double timeout, K... keys)`	Remove and get the last element in a list, or block until one is available.
`Mono<KeyValue<K,V>>`	`brpop(long timeout, K... keys)`	Remove and get the last element in a list, or block until one is available.
`Mono<V>`	`brpoplpush(double timeout, K source, K destination)`	Pop a value from a list, push it to another list and return it; or block until one is available.
`Mono<V>`	`brpoplpush(long timeout, K source, K destination)`	Pop a value from a list, push it to another list and return it; or block until one is available.
`Mono<KeyValue<K,ScoredValue<V>>>`	`bzpopmax(double timeout, K... keys)`	Removes and returns a member with the highest scores in the sorted set stored at one of the keys.
`Mono<KeyValue<K,ScoredValue<V>>>`	`bzpopmax(long timeout, K... keys)`	Removes and returns a member with the highest scores in the sorted set stored at one of the keys.
`Mono<KeyValue<K,ScoredValue<V>>>`	`bzpopmin(double timeout, K... keys)`	Removes and returns a member with the lowest scores in the sorted set stored at one of the keys.
`Mono<KeyValue<K,ScoredValue<V>>>`	`bzpopmin(long timeout, K... keys)`	Removes and returns a member with the lowest scores in the sorted set stored at one of the keys.
`Mono<String>`	`clientCaching(boolean enabled)`	Control tracking of keys in the context of server-assisted client cache invalidation.
`Mono<K>`	`clientGetname()`	Get the current connection name.
`Mono<Long>`	`clientGetredir()`	Returns the client ID we are redirecting our tracking notifications to.
`Mono<Long>`	`clientId()`	Get the id of the current connection.
`Mono<Long>`	`clientKill(KillArgs killArgs)`	Kill connections of clients which are filtered by `killArgs`.
`Mono<String>`	`clientKill(String addr)`	Kill the connection of a client identified by ip:port.
`Mono<String>`	`clientList()`	Get the list of client connections.
`Mono<String>`	`clientPause(long timeout)`	Stop processing commands from clients for some time.
`Mono<String>`	`clientSetname(K name)`	Set the current connection name.
`Mono<String>`	`clientTracking(TrackingArgs args)`	Enables the tracking feature of the Redis server, that is used for server assisted client side caching.
`Mono<Long>`	`clientUnblock(long id, UnblockType type)`	Unblock the specified blocked client.
`void`	`close()`
`Mono<String>`	`clusterAddSlots(int... slots)`	Adds slots to the cluster node.
`Mono<String>`	`clusterBumpepoch()`	Generate a new config epoch, incrementing the current epoch, assign the new epoch to this node, WITHOUT any consensus and persist the configuration on disk before sending packets with the new configuration.
`Mono<Long>`	`clusterCountFailureReports(String nodeId)`	Returns the number of failure reports for the specified node.
`Mono<Long>`	`clusterCountKeysInSlot(int slot)`	Returns the number of keys in the specified Redis Cluster hash `slot`.
`Mono<String>`	`clusterDelSlots(int... slots)`	Removes slots from the cluster node.
`Mono<String>`	`clusterFailover(boolean force)`	Failover a cluster node.
`Mono<String>`	`clusterFlushslots()`	Delete all the slots associated with the specified node.
`Mono<String>`	`clusterForget(String nodeId)`	Disallow connections and remove the cluster node from the cluster.
`Flux<K>`	`clusterGetKeysInSlot(int slot, int count)`	Retrieve the list of keys within the `slot`.
`Mono<String>`	`clusterInfo()`	Get information and statistics about the cluster viewed by the current node.
`Mono<Long>`	`clusterKeyslot(K key)`	Returns an integer identifying the hash slot the specified key hashes to.
`Mono<String>`	`clusterMeet(String ip, int port)`	Meet another cluster node to include the node into the cluster.
`Mono<String>`	`clusterMyId()`	Obtain the nodeId for the currently connected node.
`Mono<String>`	`clusterNodes()`	Obtain details about all cluster nodes.
`Mono<String>`	`clusterReplicate(String nodeId)`	Turn this node into a replica of the node with the id `nodeId`.
`Mono<String>`	`clusterReset(boolean hard)`	Reset a node performing a soft or hard reset: All other nodes are forgotten All the assigned / open slots are released If the node is a replica, it turns into a master Only for hard reset: a new Node ID is generated Only for hard reset: currentEpoch and configEpoch are set to 0 The new configuration is saved and the cluster state updated If the node was a replica, the whole data set is flushed away
`Mono<String>`	`clusterSaveconfig()`	Forces a node to save the nodes.conf configuration on disk.
`Mono<String>`	`clusterSetConfigEpoch(long configEpoch)`	This command sets a specific config epoch in a fresh node.
`Mono<String>`	`clusterSetSlotImporting(int slot, String nodeId)`	Flag a slot as IMPORTING (incoming) from the node specified in `nodeId`.
`Mono<String>`	`clusterSetSlotMigrating(int slot, String nodeId)`	Flag a slot as MIGRATING (outgoing) towards the node specified in `nodeId`.
`Mono<String>`	`clusterSetSlotNode(int slot, String nodeId)`	Assign a slot to a node.
`Mono<String>`	`clusterSetSlotStable(int slot)`	Clears migrating / importing state from the slot.
`Flux<String>`	`clusterSlaves(String nodeId)`	List replicas for a certain node identified by its `nodeId`.
`Flux<Object>`	`clusterSlots()`	Get array of cluster slots to node mappings.
`Flux<Object>`	`command()`	Returns an array reply of details about all Redis commands.
`Mono<Long>`	`commandCount()`	Get total number of Redis commands.
`Flux<Object>`	`commandInfo(CommandType... commands)`	Returns an array reply of details about the requested commands.
`Flux<Object>`	`commandInfo(String... commands)`	Returns an array reply of details about the requested commands.
`Mono<Map<String,String>>`	`configGet(String parameter)`	Get the value of a configuration parameter.
`Mono<String>`	`configResetstat()`	Reset the stats returned by INFO.
`Mono<String>`	`configRewrite()`	Rewrite the configuration file with the in memory configuration.
`Mono<String>`	`configSet(String parameter, String value)`	Set a configuration parameter to the given value.
`Mono<Boolean>`	`copy(K source, K destination)`	Copy the value stored at the source key to the destination key.
`Mono<Boolean>`	`copy(K source, K destination, CopyArgs copyArgs)`	Copy the value stored at the source key to the destination key.
`<T, R> Flux<R>`	`createDissolvingFlux(Supplier<RedisCommand<K,V,T>> commandSupplier)`
`<T> Flux<T>`	`createFlux(Supplier<RedisCommand<K,V,T>> commandSupplier)`
`protected <T> Mono<T>`	`createMono(CommandType type, CommandOutput<K,V,T> output, CommandArgs<K,V> args)`
`<T> Mono<T>`	`createMono(Supplier<RedisCommand<K,V,T>> commandSupplier)`
`Mono<Long>`	`dbsize()`	Return the number of keys in the selected database.
`Mono<String>`	`debugCrashAndRecover(Long delay)`	Crash and recover.
`Mono<String>`	`debugHtstats(int db)`	Get debugging information about the internal hash-table state.
`Mono<String>`	`debugObject(K key)`	Get debugging information about a key.
`Mono<Void>`	`debugOom()`	Make the server crash: Out of memory.
`Mono<String>`	`debugReload()`	Save RDB, clear the database and reload RDB.
`Mono<String>`	`debugRestart(Long delay)`	Restart the server gracefully.
`Mono<String>`	`debugSdslen(K key)`	Get debugging information about the internal SDS length.
`Mono<Void>`	`debugSegfault()`	Make the server crash: Invalid pointer access.
`Mono<Long>`	`decr(K key)`	Decrement the integer value of a key by one.
`Mono<Long>`	`decrby(K key, long amount)`	Decrement the integer value of a key by the given number.
`Mono<Long>`	`del(Iterable<K> keys)`
`Mono<Long>`	`del(K... keys)`	Delete one or more keys.
`String`	`digest(byte[] script)`	Create a SHA1 digest from a Lua script.
`String`	`digest(String script)`	Create a SHA1 digest from a Lua script.
`Mono<String>`	`discard()`	Discard all commands issued after MULTI.
`<T> Flux<T>`	`dispatch(ProtocolKeyword type, CommandOutput<K,V,?> output)`	Dispatch a command to the Redis Server.
`<T> Flux<T>`	`dispatch(ProtocolKeyword type, CommandOutput<K,V,?> output, CommandArgs<K,V> args)`	Dispatch a command to the Redis Server.
`Mono<byte[]>`	`dump(K key)`	Return a serialized version of the value stored at the specified key.
`Mono<V>`	`echo(V msg)`	Echo the given string.
`<T> Flux<T>`	`eval(byte[] script, ScriptOutputType type, K... keys)`	Execute a Lua script server side.
`<T> Flux<T>`	`eval(byte[] script, ScriptOutputType type, K[] keys, V... values)`	Execute a Lua script server side.
`<T> Flux<T>`	`eval(String script, ScriptOutputType type, K... keys)`	Execute a Lua script server side.
`<T> Flux<T>`	`eval(String script, ScriptOutputType type, K[] keys, V... values)`	Execute a Lua script server side.
`<T> Flux<T>`	`evalsha(String digest, ScriptOutputType type, K... keys)`	Evaluates a script cached on the server side by its SHA1 digest.
`<T> Flux<T>`	`evalsha(String digest, ScriptOutputType type, K[] keys, V... values)`	Execute a Lua script server side.
`Mono<TransactionResult>`	`exec()`	Execute all commands issued after MULTI.
`Mono<Long>`	`exists(Iterable<K> keys)`
`Mono<Boolean>`	`exists(K key)`
`Mono<Long>`	`exists(K... keys)`	Determine how many keys exist.
`Mono<Boolean>`	`expire(K key, long seconds)`	Set a key's time to live in seconds.
`Mono<Boolean>`	`expire(K key, Duration seconds)`	Set a key's time to live in seconds.
`Mono<Boolean>`	`expireat(K key, long timestamp)`	Set the expiration for a key as a UNIX timestamp.
`Mono<Boolean>`	`expireat(K key, Instant timestamp)`	Set the expiration for a key as a UNIX timestamp.
`Mono<Boolean>`	`expireat(K key, Date timestamp)`	Set the expiration for a key as a UNIX timestamp.
`Mono<String>`	`flushall()`	Remove all keys from all databases.
`Mono<String>`	`flushall(FlushMode flushMode)`	Remove all keys from all databases using the specified `FlushMode`.
`Mono<String>`	`flushallAsync()`	Remove all keys asynchronously from all databases.
`void`	`flushCommands()`	Flush pending commands.
`Mono<String>`	`flushdb()`	Remove all keys from the current database.
`Mono<String>`	`flushdb(FlushMode flushMode)`	Remove all keys from the current database using the specified `FlushMode`.
`Mono<String>`	`flushdbAsync()`	Remove all keys asynchronously from the current database.
`Mono<Long>`	`geoadd(K key, double longitude, double latitude, V member)`	Single geo add.
`Mono<Long>`	`geoadd(K key, double longitude, double latitude, V member, GeoAddArgs args)`	Single geo add.
`Mono<Long>`	`geoadd(K key, GeoAddArgs args, GeoValue<V>... values)`	Multi geo add.
`Mono<Long>`	`geoadd(K key, GeoAddArgs args, Object... lngLatMember)`	Multi geo add.
`Mono<Long>`	`geoadd(K key, GeoValue<V>... values)`	Multi geo add.
`Mono<Long>`	`geoadd(K key, Object... lngLatMember)`	Multi geo add.
`Mono<Double>`	`geodist(K key, V from, V to, GeoArgs.Unit unit)`	Retrieve distance between points `from` and `to`.
`Flux<Value<String>>`	`geohash(K key, V... members)`	Retrieve Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index.
`Flux<Value<GeoCoordinates>>`	`geopos(K key, V... members)`	Get geo coordinates for the `members`.
`Flux<V>`	`georadius(K key, double longitude, double latitude, double distance, GeoArgs.Unit unit)`	Retrieve members selected by distance with the center of `longitude` and `latitude`.
`Flux<GeoWithin<V>>`	`georadius(K key, double longitude, double latitude, double distance, GeoArgs.Unit unit, GeoArgs geoArgs)`	Retrieve members selected by distance with the center of `longitude` and `latitude`.
`Mono<Long>`	`georadius(K key, double longitude, double latitude, double distance, GeoArgs.Unit unit, GeoRadiusStoreArgs<K> geoRadiusStoreArgs)`	Perform a `RedisGeoReactiveCommands.georadius(Object, double, double, double, GeoArgs.Unit, GeoArgs)` query and store the results in a sorted set.
`protected Flux<V>`	`georadius_ro(K key, double longitude, double latitude, double distance, GeoArgs.Unit unit)`
`protected Flux<GeoWithin<V>>`	`georadius_ro(K key, double longitude, double latitude, double distance, GeoArgs.Unit unit, GeoArgs geoArgs)`
`Flux<V>`	`georadiusbymember(K key, V member, double distance, GeoArgs.Unit unit)`	Retrieve members selected by distance with the center of `member`.
`Flux<GeoWithin<V>>`	`georadiusbymember(K key, V member, double distance, GeoArgs.Unit unit, GeoArgs geoArgs)`	Retrieve members selected by distance with the center of `member`.
`Mono<Long>`	`georadiusbymember(K key, V member, double distance, GeoArgs.Unit unit, GeoRadiusStoreArgs<K> geoRadiusStoreArgs)`	Perform a `RedisGeoReactiveCommands.georadiusbymember(Object, Object, double, GeoArgs.Unit, GeoArgs)` query and store the results in a sorted set.
`protected Flux<V>`	`georadiusbymember_ro(K key, V member, double distance, GeoArgs.Unit unit)`
`protected Flux<GeoWithin<V>>`	`georadiusbymember_ro(K key, V member, double distance, GeoArgs.Unit unit, GeoArgs geoArgs)`
`Flux<V>`	`geosearch(K key, GeoSearch.GeoRef<K> reference, GeoSearch.GeoPredicate predicate)`	Retrieve members selected by distance with the center of `reference` the search `predicate`.
`Flux<GeoWithin<V>>`	`geosearch(K key, GeoSearch.GeoRef<K> reference, GeoSearch.GeoPredicate predicate, GeoArgs geoArgs)`	Retrieve members selected by distance with the center of `reference` the search `predicate`.
`Mono<Long>`	`geosearchstore(K destination, K key, GeoSearch.GeoRef<K> reference, GeoSearch.GeoPredicate predicate, GeoArgs geoArgs, boolean storeDist)`	Perform a `RedisGeoReactiveCommands.geosearch(Object, GeoSearch.GeoRef, GeoSearch.GeoPredicate, GeoArgs)` query and store the results in a sorted set.
`Mono<V>`	`get(K key)`	Get the value of a key.
`Mono<Long>`	`getbit(K key, long offset)`	Returns the bit value at offset in the string value stored at key.
`StatefulConnection<K,V>`	`getConnection()`
`Mono<V>`	`getdel(K key)`	Get the value of key and delete the key.
`Mono<V>`	`getex(K key, GetExArgs args)`	Get the value of key and optionally set its expiration.
`Mono<V>`	`getrange(K key, long start, long end)`	Get a substring of the string stored at a key.
`Mono<V>`	`getset(K key, V value)`	Set the string value of a key and return its old value.
`Mono<Long>`	`hdel(K key, K... fields)`	Delete one or more hash fields.
`Mono<Boolean>`	`hexists(K key, K field)`	Determine if a hash field exists.
`Mono<V>`	`hget(K key, K field)`	Get the value of a hash field.
`Mono<Long>`	`hgetall(KeyValueStreamingChannel<K,V> channel, K key)`	Stream over all the fields and values in a hash.
`Flux<KeyValue<K,V>>`	`hgetall(K key)`	Get all the fields and values in a hash.
`Mono<Long>`	`hincrby(K key, K field, long amount)`	Increment the integer value of a hash field by the given number.
`Mono<Double>`	`hincrbyfloat(K key, K field, double amount)`	Increment the float value of a hash field by the given amount.
`Mono<Long>`	`hkeys(KeyStreamingChannel<K> channel, K key)`	Stream over all the fields in a hash.
`Flux<K>`	`hkeys(K key)`	Get all the fields in a hash.
`Mono<Long>`	`hlen(K key)`	Get the number of fields in a hash.
`Mono<Long>`	`hmget(KeyValueStreamingChannel<K,V> channel, K key, K... fields)`	Stream over the values of all the given hash fields.
`Flux<KeyValue<K,V>>`	`hmget(K key, K... fields)`	Get the values of all the given hash fields.
`Mono<String>`	`hmset(K key, Map<K,V> map)`	Set multiple hash fields to multiple values.
`Mono<K>`	`hrandfield(K key)`	Return a random field from the hash stored at `key`.
`Flux<K>`	`hrandfield(K key, long count)`	Return `count` random fields from the hash stored at `key`.
`Mono<KeyValue<K,V>>`	`hrandfieldWithvalues(K key)`	Return a random field along its value from the hash stored at `key`.
`Flux<KeyValue<K,V>>`	`hrandfieldWithvalues(K key, long count)`	Return `count` random fields along their value from the hash stored at `key`.
`Mono<StreamScanCursor>`	`hscan(KeyValueStreamingChannel<K,V> channel, K key)`	Incrementally iterate hash fields and associated values.
`Mono<StreamScanCursor>`	`hscan(KeyValueStreamingChannel<K,V> channel, K key, ScanArgs scanArgs)`	Incrementally iterate hash fields and associated values.
`Mono<StreamScanCursor>`	`hscan(KeyValueStreamingChannel<K,V> channel, K key, ScanCursor scanCursor)`	Incrementally iterate hash fields and associated values.
`Mono<StreamScanCursor>`	`hscan(KeyValueStreamingChannel<K,V> channel, K key, ScanCursor scanCursor, ScanArgs scanArgs)`	Incrementally iterate hash fields and associated values.
`Mono<MapScanCursor<K,V>>`	`hscan(K key)`	Incrementally iterate hash fields and associated values.
`Mono<MapScanCursor<K,V>>`	`hscan(K key, ScanArgs scanArgs)`	Incrementally iterate hash fields and associated values.
`Mono<MapScanCursor<K,V>>`	`hscan(K key, ScanCursor scanCursor)`	Incrementally iterate hash fields and associated values.
`Mono<MapScanCursor<K,V>>`	`hscan(K key, ScanCursor scanCursor, ScanArgs scanArgs)`	Incrementally iterate hash fields and associated values.
`Mono<Long>`	`hset(K key, Map<K,V> map)`	Set multiple hash fields to multiple values.
`Mono<Boolean>`	`hset(K key, K field, V value)`	Set the string value of a hash field.
`Mono<Boolean>`	`hsetnx(K key, K field, V value)`	Set the value of a hash field, only if the field does not exist.
`Mono<Long>`	`hstrlen(K key, K field)`	Get the string length of the field value in a hash.
`Mono<Long>`	`hvals(ValueStreamingChannel<V> channel, K key)`	Stream over all the values in a hash.
`Flux<V>`	`hvals(K key)`	Get all the values in a hash.
`Mono<Long>`	`incr(K key)`	Increment the integer value of a key by one.
`Mono<Long>`	`incrby(K key, long amount)`	Increment the integer value of a key by the given amount.
`Mono<Double>`	`incrbyfloat(K key, double amount)`	Increment the float value of a key by the given amount.
`Mono<String>`	`info()`	Get information and statistics about the server.
`Mono<String>`	`info(String section)`	Get information and statistics about the server.
`boolean`	`isOpen()`
`Mono<Long>`	`keys(KeyStreamingChannel<K> channel, K pattern)`	Find all keys matching the given pattern.
`Flux<K>`	`keys(K pattern)`	Find all keys matching the given pattern.
`Mono<Date>`	`lastsave()`	Get the UNIX time stamp of the last successful save to disk.
`Mono<V>`	`lindex(K key, long index)`	Get an element from a list by its index.
`Mono<Long>`	`linsert(K key, boolean before, V pivot, V value)`	Insert an element before or after another element in a list.
`Mono<Long>`	`llen(K key)`	Get the length of a list.
`Mono<V>`	`lmove(K source, K destination, LMoveArgs args)`	Atomically returns and removes the first/last element (head/tail depending on the wherefrom argument) of the list stored at source, and pushes the element at the first/last element (head/tail depending on the whereto argument) of the list stored at destination.
`Mono<V>`	`lpop(K key)`	Remove and get the first element in a list.
`Flux<V>`	`lpop(K key, long count)`	Remove and get the first `count` elements in a list.
`Mono<Long>`	`lpos(K key, V value)`	Return the index of matching elements inside a Redis list.
`Flux<Long>`	`lpos(K key, V value, int count)`	Return the index of matching elements inside a Redis list using the `COUNT` option.
`Flux<Long>`	`lpos(K key, V value, int count, LPosArgs args)`	Return the index of matching elements inside a Redis list using the `COUNT` option.
`Mono<Long>`	`lpos(K key, V value, LPosArgs args)`	Return the index of matching elements inside a Redis list.
`Mono<Long>`	`lpush(K key, V... values)`	Prepend one or multiple values to a list.
`Mono<Long>`	`lpushx(K key, V... values)`	Prepend values to a list, only if the list exists.
`Mono<Long>`	`lrange(ValueStreamingChannel<V> channel, K key, long start, long stop)`	Get a range of elements from a list.
`Flux<V>`	`lrange(K key, long start, long stop)`	Get a range of elements from a list.
`Mono<Long>`	`lrem(K key, long count, V value)`	Remove elements from a list.
`Mono<String>`	`lset(K key, long index, V value)`	Set the value of an element in a list by its index.
`Mono<String>`	`ltrim(K key, long start, long stop)`	Trim a list to the specified range.
`Mono<Long>`	`memoryUsage(K key)`	Reports the number of bytes that a key and its value require to be stored in RAM.
`Mono<Long>`	`mget(KeyValueStreamingChannel<K,V> channel, Iterable<K> keys)`
`Mono<Long>`	`mget(KeyValueStreamingChannel<K,V> channel, K... keys)`	Stream over the values of all the given keys.
`Mono<Long>`	`mget(ValueStreamingChannel<V> channel, Iterable<K> keys)`
`Flux<KeyValue<K,V>>`	`mget(Iterable<K> keys)`
`Flux<KeyValue<K,V>>`	`mget(K... keys)`	Get the values of all the given keys.
`Mono<String>`	`migrate(String host, int port, int db, long timeout, MigrateArgs<K> migrateArgs)`	Atomically transfer one or more keys from a Redis instance to another one.
`Mono<String>`	`migrate(String host, int port, K key, int db, long timeout)`	Atomically transfer a key from a Redis instance to another one.
`Mono<Boolean>`	`move(K key, int db)`	Move a key to another database.
`Mono<String>`	`mset(Map<K,V> map)`	Set multiple keys to multiple values.
`Mono<Boolean>`	`msetnx(Map<K,V> map)`	Set multiple keys to multiple values, only if none of the keys exist.
`Mono<String>`	`multi()`	Mark the start of a transaction block.
`Mono<String>`	`objectEncoding(K key)`	Returns the kind of internal representation used in order to store the value associated with the `key`.
`Mono<Long>`	`objectFreq(K key)`	Returns the logarithmic access frequency counter of the object stored at the specified `key`.
`Mono<Long>`	`objectIdletime(K key)`	Returns the number of seconds since the object stored at the specified key is idle (not requested by read or write operations).
`Mono<Long>`	`objectRefcount(K key)`	Returns the number of references of the value associated with the specified key.
`Mono<Boolean>`	`persist(K key)`	Remove the expiration from a key.
`Mono<Boolean>`	`pexpire(K key, long milliseconds)`	Set a key's time to live in milliseconds.
`Mono<Boolean>`	`pexpire(K key, Duration milliseconds)`	Set a key's time to live in milliseconds.
`Mono<Boolean>`	`pexpireat(K key, long timestamp)`	Set the expiration for a key as a UNIX timestamp specified in milliseconds.
`Mono<Boolean>`	`pexpireat(K key, Instant timestamp)`	Set the expiration for a key as a UNIX timestamp specified in milliseconds.
`Mono<Boolean>`	`pexpireat(K key, Date timestamp)`	Set the expiration for a key as a UNIX timestamp specified in milliseconds.
`Mono<Long>`	`pfadd(K key, V... values)`	Adds the specified elements to the specified HyperLogLog.
`Mono<Long>`	`pfadd(K key, V value, V... values)`
`Mono<Long>`	`pfcount(K... keys)`	Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).
`Mono<Long>`	`pfcount(K key, K... keys)`
`Mono<String>`	`pfmerge(K destkey, K... sourcekeys)`	Merge N different HyperLogLogs into a single one.
`Mono<String>`	`pfmerge(K destkey, K sourceKey, K... sourcekeys)`
`Mono<String>`	`ping()`	Ping the server.
`Mono<String>`	`psetex(K key, long milliseconds, V value)`	Set the value and expiration in milliseconds of a key.
`Mono<Long>`	`pttl(K key)`	Get the time to live for a key in milliseconds.
`Mono<Long>`	`publish(K channel, V message)`	Post a message to a channel.
`Flux<K>`	`pubsubChannels()`	Lists the currently active channels.
`Flux<K>`	`pubsubChannels(K channel)`	Lists the currently active channels.
`Mono<Long>`	`pubsubNumpat()`	Returns the number of subscriptions to patterns.
`Mono<Map<K,Long>>`	`pubsubNumsub(K... channels)`	Returns the number of subscribers (not counting clients subscribed to patterns) for the specified channels.
`Mono<String>`	`quit()`	Instructs Redis to disconnect the connection.
`Mono<K>`	`randomkey()`	Return a random key from the keyspace.
`Mono<String>`	`readOnly()`	Switch connection to Read-Only mode when connecting to a cluster.
`Mono<String>`	`readWrite()`	Switch connection to Read-Write mode (default) when connecting to a cluster.
`Mono<String>`	`rename(K key, K newKey)`	Rename a key.
`Mono<Boolean>`	`renamenx(K key, K newKey)`	Rename a key, only if the new key does not exist.
`void`	`reset()`	Reset the command state.
`Mono<String>`	`restore(K key, byte[] value, RestoreArgs args)`	Create a key using the provided serialized value, previously obtained using DUMP.
`Mono<String>`	`restore(K key, long ttl, byte[] value)`	Create a key using the provided serialized value, previously obtained using DUMP.
`Flux<Object>`	`role()`	Return the role of the instance in the context of replication.
`Mono<V>`	`rpop(K key)`	Remove and get the last element in a list.
`Flux<V>`	`rpop(K key, long count)`	Remove and get the last `count` elements in a list.
`Mono<V>`	`rpoplpush(K source, K destination)`	Remove the last element in a list, append it to another list and return it.
`Mono<Long>`	`rpush(K key, V... values)`	Append one or multiple values to a list.
`Mono<Long>`	`rpushx(K key, V... values)`	Append values to a list, only if the list exists.
`Mono<Long>`	`sadd(K key, V... members)`	Add one or more members to a set.
`Mono<String>`	`save()`	Synchronously save the dataset to disk.
`Mono<KeyScanCursor<K>>`	`scan()`	Incrementally iterate the keys space.
`Mono<StreamScanCursor>`	`scan(KeyStreamingChannel<K> channel)`	Incrementally iterate the keys space.
`Mono<StreamScanCursor>`	`scan(KeyStreamingChannel<K> channel, ScanArgs scanArgs)`	Incrementally iterate the keys space.
`Mono<StreamScanCursor>`	`scan(KeyStreamingChannel<K> channel, ScanCursor scanCursor)`	Incrementally iterate the keys space.
`Mono<StreamScanCursor>`	`scan(KeyStreamingChannel<K> channel, ScanCursor scanCursor, ScanArgs scanArgs)`	Incrementally iterate the keys space.
`Mono<KeyScanCursor<K>>`	`scan(ScanArgs scanArgs)`	Incrementally iterate the keys space.
`Mono<KeyScanCursor<K>>`	`scan(ScanCursor scanCursor)`	Incrementally iterate the keys space.
`Mono<KeyScanCursor<K>>`	`scan(ScanCursor scanCursor, ScanArgs scanArgs)`	Incrementally iterate the keys space.
`Mono<Long>`	`scard(K key)`	Get the number of members in a set.
`Flux<Boolean>`	`scriptExists(String... digests)`	Check existence of scripts in the script cache.
`Mono<String>`	`scriptFlush()`	Remove all the scripts from the script cache.
`Mono<String>`	`scriptFlush(FlushMode flushMode)`	Remove all the scripts from the script cache using the specified `FlushMode`.
`Mono<String>`	`scriptKill()`	Kill the script currently in execution.
`Mono<String>`	`scriptLoad(byte[] script)`	Load the specified Lua script into the script cache.
`Mono<String>`	`scriptLoad(String script)`	Load the specified Lua script into the script cache.
`Mono<Long>`	`sdiff(ValueStreamingChannel<V> channel, K... keys)`	Subtract multiple sets.
`Flux<V>`	`sdiff(K... keys)`	Subtract multiple sets.
`Mono<Long>`	`sdiffstore(K destination, K... keys)`	Subtract multiple sets and store the resulting set in a key.
`Mono<String>`	`select(int db)`
`Mono<String>`	`set(K key, V value)`	Set the string value of a key.
`Mono<String>`	`set(K key, V value, SetArgs setArgs)`	Set the string value of a key.
`void`	`setAutoFlushCommands(boolean autoFlush)`	Disable or enable auto-flush behavior.
`Mono<Long>`	`setbit(K key, long offset, int value)`	Sets or clears the bit at offset in the string value stored at key.
`Mono<String>`	`setex(K key, long seconds, V value)`	Set the value and expiration of a key.
`Mono<V>`	`setGet(K key, V value)`	Set the string value of a key and return its old value.
`Mono<V>`	`setGet(K key, V value, SetArgs setArgs)`	Set the string value of a key and return its old value.
`Mono<Boolean>`	`setnx(K key, V value)`	Set the value of a key, only if the key does not exist.
`Mono<Long>`	`setrange(K key, long offset, V value)`	Overwrite part of a string at key starting at the specified offset.
`void`	`setTimeout(Duration timeout)`	Set the default timeout for operations.
`Mono<Void>`	`shutdown(boolean save)`	Synchronously save the dataset to disk and then shut down the server.
`Mono<Long>`	`sinter(ValueStreamingChannel<V> channel, K... keys)`	Intersect multiple sets.
`Flux<V>`	`sinter(K... keys)`	Intersect multiple sets.
`Mono<Long>`	`sinterstore(K destination, K... keys)`	Intersect multiple sets and store the resulting set in a key.
`Mono<Boolean>`	`sismember(K key, V member)`	Determine if a given value is a member of a set.
`Mono<String>`	`slaveof(String host, int port)`	Make the server a replica of another instance, or promote it as master.
`Mono<String>`	`slaveofNoOne()`	Promote server as master.
`Flux<Object>`	`slowlogGet()`	Read the slow log.
`Flux<Object>`	`slowlogGet(int count)`	Read the slow log.
`Mono<Long>`	`slowlogLen()`	Obtaining the current length of the slow log.
`Mono<String>`	`slowlogReset()`	Resetting the slow log.
`Mono<Long>`	`smembers(ValueStreamingChannel<V> channel, K key)`	Get all the members in a set.
`Flux<V>`	`smembers(K key)`	Get all the members in a set.
`Flux<Boolean>`	`smismember(K key, V... members)`	Returns whether each member is a member of the set stored at key.
`Mono<Boolean>`	`smove(K source, K destination, V member)`	Move a member from one set to another.
`Mono<Long>`	`sort(ValueStreamingChannel<V> channel, K key)`	Sort the elements in a list, set or sorted set.
`Mono<Long>`	`sort(ValueStreamingChannel<V> channel, K key, SortArgs sortArgs)`	Sort the elements in a list, set or sorted set.
`Flux<V>`	`sort(K key)`	Sort the elements in a list, set or sorted set.
`Flux<V>`	`sort(K key, SortArgs sortArgs)`	Sort the elements in a list, set or sorted set.
`Mono<Long>`	`sortStore(K key, SortArgs sortArgs, K destination)`	Sort the elements in a list, set or sorted set.
`Mono<V>`	`spop(K key)`	Remove and return a random member from a set.
`Flux<V>`	`spop(K key, long count)`	Remove and return one or multiple random members from a set.
`Mono<Long>`	`srandmember(ValueStreamingChannel<V> channel, K key, long count)`	Get one or multiple random members from a set.
`Mono<V>`	`srandmember(K key)`	Get one random member from a set.
`Flux<V>`	`srandmember(K key, long count)`	Get one or multiple random members from a set.
`Mono<Long>`	`srem(K key, V... members)`	Remove one or more members from a set.
`Mono<StreamScanCursor>`	`sscan(ValueStreamingChannel<V> channel, K key)`	Incrementally iterate Set elements.
`Mono<StreamScanCursor>`	`sscan(ValueStreamingChannel<V> channel, K key, ScanArgs scanArgs)`	Incrementally iterate Set elements.
`Mono<StreamScanCursor>`	`sscan(ValueStreamingChannel<V> channel, K key, ScanCursor scanCursor)`	Incrementally iterate Set elements.
`Mono<StreamScanCursor>`	`sscan(ValueStreamingChannel<V> channel, K key, ScanCursor scanCursor, ScanArgs scanArgs)`	Incrementally iterate Set elements.
`Mono<ValueScanCursor<V>>`	`sscan(K key)`	Incrementally iterate Set elements.
`Mono<ValueScanCursor<V>>`	`sscan(K key, ScanArgs scanArgs)`	Incrementally iterate Set elements.
`Mono<ValueScanCursor<V>>`	`sscan(K key, ScanCursor scanCursor)`	Incrementally iterate Set elements.
`Mono<ValueScanCursor<V>>`	`sscan(K key, ScanCursor scanCursor, ScanArgs scanArgs)`	Incrementally iterate Set elements.
`Mono<StringMatchResult>`	`stralgoLcs(StrAlgoArgs strAlgoArgs)`	The STRALGO command implements complex algorithms that operate on strings.
`Mono<Long>`	`strlen(K key)`	Get the length of the value stored in a key.
`Mono<Long>`	`sunion(ValueStreamingChannel<V> channel, K... keys)`	Add multiple sets.
`Flux<V>`	`sunion(K... keys)`	Add multiple sets.
`Mono<Long>`	`sunionstore(K destination, K... keys)`	Add multiple sets and store the resulting set in a key.
`Mono<String>`	`swapdb(int db1, int db2)`
`Flux<V>`	`time()`	Return the current server time.
`Mono<Long>`	`touch(Iterable<K> keys)`
`Mono<Long>`	`touch(K... keys)`	Touch one or more keys.
`Mono<Long>`	`ttl(K key)`	Get the time to live for a key.
`Mono<String>`	`type(K key)`	Determine the type stored at key.
`Mono<Long>`	`unlink(Iterable<K> keys)`
`Mono<Long>`	`unlink(K... keys)`	Unlink one or more keys (non blocking DEL).
`Mono<String>`	`unwatch()`	Forget about all watched keys.
`Mono<Long>`	`waitForReplication(int replicas, long timeout)`	Wait for replication.
`Mono<String>`	`watch(K... keys)`	Watch the given keys to determine execution of the MULTI/EXEC block.
`Mono<Long>`	`xack(K key, K group, String... messageIds)`	Acknowledge one or more messages as processed.
`Mono<String>`	`xadd(K key, XAddArgs args, Object... keysAndValues)`	Append a message to the stream `key`.
`Mono<String>`	`xadd(K key, XAddArgs args, Map<K,V> body)`	Append a message to the stream `key`.
`Mono<String>`	`xadd(K key, Object... keysAndValues)`	Append a message to the stream `key`.
`Mono<String>`	`xadd(K key, Map<K,V> body)`	Append a message to the stream `key`.
`Mono<ClaimedMessages<K,V>>`	`xautoclaim(K key, XAutoClaimArgs<K> args)`	Gets ownership of one or multiple messages in the Pending Entries List of a given stream consumer group.
`Flux<StreamMessage<K,V>>`	`xclaim(K key, Consumer<K> consumer, long minIdleTime, String... messageIds)`	Gets ownership of one or multiple messages in the Pending Entries List of a given stream consumer group.
`Flux<StreamMessage<K,V>>`	`xclaim(K key, Consumer<K> consumer, XClaimArgs args, String... messageIds)`	Gets ownership of one or multiple messages in the Pending Entries List of a given stream consumer group.
`Mono<Long>`	`xdel(K key, String... messageIds)`	Removes the specified entries from the stream.
`Mono<String>`	`xgroupCreate(XReadArgs.StreamOffset<K> streamOffset, K group)`	Create a consumer group.
`Mono<String>`	`xgroupCreate(XReadArgs.StreamOffset<K> streamOffset, K group, XGroupCreateArgs args)`	Create a consumer group.
`Mono<Boolean>`	`xgroupCreateconsumer(K key, Consumer<K> consumer)`	Create a consumer from a consumer group.
`Mono<Long>`	`xgroupDelconsumer(K key, Consumer<K> consumer)`	Delete a consumer from a consumer group.
`Mono<Boolean>`	`xgroupDestroy(K key, K group)`	Destroy a consumer group.
`Mono<String>`	`xgroupSetid(XReadArgs.StreamOffset<K> streamOffset, K group)`	Set the current `group` id.
`Flux<Object>`	`xinfoConsumers(K key, K group)`	Retrieve information about consumer groups of group `group` and stream at `key`.
`Flux<Object>`	`xinfoGroups(K key)`	Retrieve information about the stream consumer groups at `key`.
`Flux<Object>`	`xinfoStream(K key)`	Retrieve information about the stream at `key`.
`Mono<Long>`	`xlen(K key)`	Get the length of a steam.
`Flux<PendingMessage>`	`xpending(K key, Consumer<K> consumer, Range<String> range, Limit limit)`	Read pending messages from a stream within a specific `Range`.
`Flux<PendingMessage>`	`xpending(K key, XPendingArgs<K> args)`	Read pending messages from a stream within a specific `XPendingArgs`.
`Mono<PendingMessages>`	`xpending(K key, K group)`	Read pending messages from a stream for a `group`.
`Flux<PendingMessage>`	`xpending(K key, K group, Range<String> range, Limit limit)`	Read pending messages from a stream within a specific `Range`.
`Flux<StreamMessage<K,V>>`	`xrange(K key, Range<String> range)`	Read messages from a stream within a specific `Range`.
`Flux<StreamMessage<K,V>>`	`xrange(K key, Range<String> range, Limit limit)`	Read messages from a stream within a specific `Range` applying a `Limit`.
`Flux<StreamMessage<K,V>>`	`xread(XReadArgs.StreamOffset<K>... streams)`	Read messages from one or more `XReadArgs.StreamOffset`s.
`Flux<StreamMessage<K,V>>`	`xread(XReadArgs args, XReadArgs.StreamOffset<K>... streams)`	Read messages from one or more `XReadArgs.StreamOffset`s.
`Flux<StreamMessage<K,V>>`	`xreadgroup(Consumer<K> consumer, XReadArgs.StreamOffset<K>... streams)`	Read messages from one or more `XReadArgs.StreamOffset`s using a consumer group.
`Flux<StreamMessage<K,V>>`	`xreadgroup(Consumer<K> consumer, XReadArgs args, XReadArgs.StreamOffset<K>... streams)`	Read messages from one or more `XReadArgs.StreamOffset`s using a consumer group.
`Flux<StreamMessage<K,V>>`	`xrevrange(K key, Range<String> range)`	Read messages from a stream within a specific `Range` in reverse order.
`Flux<StreamMessage<K,V>>`	`xrevrange(K key, Range<String> range, Limit limit)`	Read messages from a stream within a specific `Range` applying a `Limit` in reverse order.
`Mono<Long>`	`xtrim(K key, boolean approximateTrimming, long count)`	Trims the stream to `count` elements.
`Mono<Long>`	`xtrim(K key, long count)`	Trims the stream to `count` elements.
`Mono<Long>`	`xtrim(K key, XTrimArgs args)`	Trims the stream within a specific `XTrimArgs`.
`Mono<Long>`	`zadd(K key, double score, V member)`	Add one or more members to a sorted set, or update its score if it already exists.
`Mono<Long>`	`zadd(K key, ScoredValue<V>... scoredValues)`	Add one or more members to a sorted set, or update its score if it already exists.
`Mono<Long>`	`zadd(K key, ZAddArgs zAddArgs, double score, V member)`	Add one or more members to a sorted set, or update its score if it already exists.
`Mono<Long>`	`zadd(K key, ZAddArgs zAddArgs, ScoredValue<V>... scoredValues)`	Add one or more members to a sorted set, or update its score if it already exists.
`Mono<Long>`	`zadd(K key, ZAddArgs zAddArgs, Object... scoresAndValues)`	Add one or more members to a sorted set, or update its score if it already exists.
`Mono<Long>`	`zadd(K key, Object... scoresAndValues)`	Add one or more members to a sorted set, or update its score if it already exists.
`Mono<Double>`	`zaddincr(K key, double score, V member)`	Add one or more members to a sorted set, or update its score if it already exists applying the `INCR` option.
`Mono<Double>`	`zaddincr(K key, ZAddArgs zAddArgs, double score, V member)`	Add one or more members to a sorted set, or update its score if it already exists applying the `INCR` option.
`Mono<Long>`	`zcard(K key)`	Get the number of members in a sorted set.
`Mono<Long>`	`zcount(K key, double min, double max)`	Count the members in a sorted set with scores within the given values.
`Mono<Long>`	`zcount(K key, Range<? extends Number> range)`	Count the members in a sorted set with scores within the given `Range`.
`Mono<Long>`	`zcount(K key, String min, String max)`	Count the members in a sorted set with scores within the given values.
`Flux<V>`	`zdiff(K... keys)`	Computes the difference between the first and all successive input sorted sets.
`Mono<Long>`	`zdiffstore(K destKey, K... srcKeys)`	Computes the difference between the first and all successive input sorted sets and stores the result in destination.
`Flux<ScoredValue<V>>`	`zdiffWithScores(K... keys)`	Computes the difference between the first and all successive input sorted sets.
`Mono<Double>`	`zincrby(K key, double amount, V member)`	Increment the score of a member in a sorted set.
`Flux<V>`	`zinter(ZAggregateArgs aggregateArgs, K... keys)`	Intersect multiple sorted sets and returns the resulting sorted.
`Flux<V>`	`zinter(K... keys)`	Intersect multiple sorted sets and returns the resulting sorted.
`Mono<Long>`	`zinterstore(K destination, ZStoreArgs zStoreArgs, K... keys)`	Intersect multiple sorted sets and store the resulting sorted set in a new key.
`Mono<Long>`	`zinterstore(K destination, K... keys)`	Intersect multiple sorted sets and store the resulting sorted set in a new key.
`Flux<ScoredValue<V>>`	`zinterWithScores(ZAggregateArgs aggregateArgs, K... keys)`	Intersect multiple sorted sets and returns the resulting sorted.
`Flux<ScoredValue<V>>`	`zinterWithScores(K... keys)`	Intersect multiple sorted sets and returns the resulting sorted.
`Mono<Long>`	`zlexcount(K key, Range<? extends V> range)`	Count the number of members in a sorted set between a given lexicographical range.
`Mono<Long>`	`zlexcount(K key, String min, String max)`	Count the number of members in a sorted set between a given lexicographical range.
`Mono<List<Double>>`	`zmscore(K key, V... members)`	Returns the scores associated with the specified members in the sorted set stored at key.
`Mono<ScoredValue<V>>`	`zpopmax(K key)`	Removes and returns up to count members with the highest scores in the sorted set stored at key.
`Flux<ScoredValue<V>>`	`zpopmax(K key, long count)`	Removes and returns up to count members with the highest scores in the sorted set stored at key.
`Mono<ScoredValue<V>>`	`zpopmin(K key)`	Removes and returns up to count members with the lowest scores in the sorted set stored at key.
`Flux<ScoredValue<V>>`	`zpopmin(K key, long count)`	Removes and returns up to count members with the lowest scores in the sorted set stored at key.
`Mono<V>`	`zrandmember(K key)`	Return a random member from the sorted set stored at `key`.
`Flux<V>`	`zrandmember(K key, long count)`	Return `count` random members from the sorted set stored at `key`.
`Mono<ScoredValue<V>>`	`zrandmemberWithScores(K key)`	Return a random member along its value from the sorted set stored at `key`.
`Flux<ScoredValue<V>>`	`zrandmemberWithScores(K key, long count)`	Return `count` random members along their value from the sorted set stored at `key`.
`Mono<Long>`	`zrange(ValueStreamingChannel<V> channel, K key, long start, long stop)`	Return a range of members in a sorted set, by index.
`Flux<V>`	`zrange(K key, long start, long stop)`	Return a range of members in a sorted set, by index.
`Flux<V>`	`zrangebylex(K key, Range<? extends V> range)`	Return a range of members in a sorted set, by lexicographical range.
`Flux<V>`	`zrangebylex(K key, Range<? extends V> range, Limit limit)`	Return a range of members in a sorted set, by lexicographical range.
`Flux<V>`	`zrangebylex(K key, String min, String max)`	Return a range of members in a sorted set, by lexicographical range.
`Flux<V>`	`zrangebylex(K key, String min, String max, long offset, long count)`	Return a range of members in a sorted set, by lexicographical range.
`Mono<Long>`	`zrangebyscore(ValueStreamingChannel<V> channel, K key, double min, double max)`	Stream over a range of members in a sorted set, by score.
`Mono<Long>`	`zrangebyscore(ValueStreamingChannel<V> channel, K key, double min, double max, long offset, long count)`	Stream over range of members in a sorted set, by score.
`Mono<Long>`	`zrangebyscore(ValueStreamingChannel<V> channel, K key, Range<? extends Number> range)`	Stream over a range of members in a sorted set, by score.
`Mono<Long>`	`zrangebyscore(ValueStreamingChannel<V> channel, K key, Range<? extends Number> range, Limit limit)`	Stream over a range of members in a sorted set, by score.
`Mono<Long>`	`zrangebyscore(ValueStreamingChannel<V> channel, K key, String min, String max)`	Stream over a range of members in a sorted set, by score.
`Mono<Long>`	`zrangebyscore(ValueStreamingChannel<V> channel, K key, String min, String max, long offset, long count)`	Stream over a range of members in a sorted set, by score.
`Flux<V>`	`zrangebyscore(K key, double min, double max)`	Return a range of members in a sorted set, by score.
`Flux<V>`	`zrangebyscore(K key, double min, double max, long offset, long count)`	Return a range of members in a sorted set, by score.
`Flux<V>`	`zrangebyscore(K key, Range<? extends Number> range)`	Return a range of members in a sorted set, by score.
`Flux<V>`	`zrangebyscore(K key, Range<? extends Number> range, Limit limit)`	Return a range of members in a sorted set, by score.
`Flux<V>`	`zrangebyscore(K key, String min, String max)`	Return a range of members in a sorted set, by score.
`Flux<V>`	`zrangebyscore(K key, String min, String max, long offset, long count)`	Return a range of members in a sorted set, by score.
`Mono<Long>`	`zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, double min, double max)`	Stream over a range of members with scores in a sorted set, by score.
`Mono<Long>`	`zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, double min, double max, long offset, long count)`	Stream over a range of members with scores in a sorted set, by score.
`Mono<Long>`	`zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, Range<? extends Number> range)`	Stream over a range of members with scores in a sorted set, by score.
`Mono<Long>`	`zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, Range<? extends Number> range, Limit limit)`	Stream over a range of members with scores in a sorted set, by score.
`Mono<Long>`	`zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, String min, String max)`	Stream over a range of members with scores in a sorted set, by score.
`Mono<Long>`	`zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, String min, String max, long offset, long count)`	Stream over a range of members with scores in a sorted set, by score.
`Flux<ScoredValue<V>>`	`zrangebyscoreWithScores(K key, double min, double max)`	Return a range of members with score in a sorted set, by score.
`Flux<ScoredValue<V>>`	`zrangebyscoreWithScores(K key, double min, double max, long offset, long count)`	Return a range of members with score in a sorted set, by score.
`Flux<ScoredValue<V>>`	`zrangebyscoreWithScores(K key, Range<? extends Number> range)`	Return a range of members with score in a sorted set, by score.
`Flux<ScoredValue<V>>`	`zrangebyscoreWithScores(K key, Range<? extends Number> range, Limit limit)`	Return a range of members with score in a sorted set, by score.
`Flux<ScoredValue<V>>`	`zrangebyscoreWithScores(K key, String min, String max)`	Return a range of members with score in a sorted set, by score.
`Flux<ScoredValue<V>>`	`zrangebyscoreWithScores(K key, String min, String max, long offset, long count)`	Return a range of members with score in a sorted set, by score.
`Mono<Long>`	`zrangestorebylex(K dstKey, K srcKey, Range<? extends V> range, Limit limit)`	Get the specified range of elements in the sorted set stored at `srcKey` and stores the result in the `dstKey` destination key.
`Mono<Long>`	`zrangestorebyscore(K dstKey, K srcKey, Range<? extends Number> range, Limit limit)`	Get the specified range of elements in the sorted set stored at `srcKey` and stores the result in the `dstKey` destination key.
`Mono<Long>`	`zrangeWithScores(ScoredValueStreamingChannel<V> channel, K key, long start, long stop)`	Stream over a range of members with scores in a sorted set, by index.
`Flux<ScoredValue<V>>`	`zrangeWithScores(K key, long start, long stop)`	Return a range of members with scores in a sorted set, by index.
`Mono<Long>`	`zrank(K key, V member)`	Determine the index of a member in a sorted set.
`Mono<Long>`	`zrem(K key, V... members)`	Remove one or more members from a sorted set.
`Mono<Long>`	`zremrangebylex(K key, Range<? extends V> range)`	Remove all members in a sorted set between the given lexicographical range.
`Mono<Long>`	`zremrangebylex(K key, String min, String max)`	Remove all members in a sorted set between the given lexicographical range.
`Mono<Long>`	`zremrangebyrank(K key, long start, long stop)`	Remove all members in a sorted set within the given indexes.
`Mono<Long>`	`zremrangebyscore(K key, double min, double max)`	Remove all members in a sorted set within the given scores.
`Mono<Long>`	`zremrangebyscore(K key, Range<? extends Number> range)`	Remove all members in a sorted set within the given scores.
`Mono<Long>`	`zremrangebyscore(K key, String min, String max)`	Remove all members in a sorted set within the given scores.
`Mono<Long>`	`zrevrange(ValueStreamingChannel<V> channel, K key, long start, long stop)`	Stream over a range of members in a sorted set, by index, with scores ordered from high to low.
`Flux<V>`	`zrevrange(K key, long start, long stop)`	Return a range of members in a sorted set, by index, with scores ordered from high to low.
`Flux<V>`	`zrevrangebylex(K key, Range<? extends V> range)`	Return a range of members in a sorted set, by lexicographical range ordered from high to low.
`Flux<V>`	`zrevrangebylex(K key, Range<? extends V> range, Limit limit)`	Return a range of members in a sorted set, by lexicographical range ordered from high to low.
`Mono<Long>`	`zrevrangebyscore(ValueStreamingChannel<V> channel, K key, double max, double min)`	Stream over a range of members in a sorted set, by score, with scores ordered from high to low.
`Mono<Long>`	`zrevrangebyscore(ValueStreamingChannel<V> channel, K key, double max, double min, long offset, long count)`	Stream over a range of members in a sorted set, by score, with scores ordered from high to low.
`Mono<Long>`	`zrevrangebyscore(ValueStreamingChannel<V> channel, K key, Range<? extends Number> range)`	Stream over a range of members in a sorted set, by score, with scores ordered from high to low.
`Mono<Long>`	`zrevrangebyscore(ValueStreamingChannel<V> channel, K key, Range<? extends Number> range, Limit limit)`	Stream over a range of members in a sorted set, by score, with scores ordered from high to low.
`Mono<Long>`	`zrevrangebyscore(ValueStreamingChannel<V> channel, K key, String max, String min)`	Stream over a range of members in a sorted set, by score, with scores ordered from high to low.
`Mono<Long>`	`zrevrangebyscore(ValueStreamingChannel<V> channel, K key, String max, String min, long offset, long count)`	Stream over a range of members in a sorted set, by score, with scores ordered from high to low.
`Flux<V>`	`zrevrangebyscore(K key, double max, double min)`	Return a range of members in a sorted set, by score, with scores ordered from high to low.
`Flux<V>`	`zrevrangebyscore(K key, double max, double min, long offset, long count)`	Return a range of members in a sorted set, by score, with scores ordered from high to low.
`Flux<V>`	`zrevrangebyscore(K key, Range<? extends Number> range)`	Return a range of members in a sorted set, by score, with scores ordered from high to low.
`Flux<V>`	`zrevrangebyscore(K key, Range<? extends Number> range, Limit limit)`	Return a range of members in a sorted set, by score, with scores ordered from high to low.
`Flux<V>`	`zrevrangebyscore(K key, String max, String min)`	Return a range of members in a sorted set, by score, with scores ordered from high to low.
`Flux<V>`	`zrevrangebyscore(K key, String max, String min, long offset, long count)`	Return a range of members in a sorted set, by score, with scores ordered from high to low.
`Mono<Long>`	`zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, double max, double min)`	Stream over a range of members with scores in a sorted set, by score, with scores ordered from high to low.
`Mono<Long>`	`zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, double max, double min, long offset, long count)`	Stream over a range of members with scores in a sorted set, by score, with scores ordered from high to low.
`Mono<Long>`	`zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, Range<? extends Number> range)`	Stream over a range of members with scores in a sorted set, by score, with scores ordered from high to low.
`Mono<Long>`	`zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, Range<? extends Number> range, Limit limit)`	Stream over a range of members with scores in a sorted set, by score, with scores ordered from high to low.
`Mono<Long>`	`zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, String max, String min)`	Stream over a range of members with scores in a sorted set, by score, with scores ordered from high to low.
`Mono<Long>`	`zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, String max, String min, long offset, long count)`	Stream over a range of members with scores in a sorted set, by score, with scores ordered from high to low.
`Flux<ScoredValue<V>>`	`zrevrangebyscoreWithScores(K key, double max, double min)`	Return a range of members with scores in a sorted set, by score, with scores ordered from high to low.
`Flux<ScoredValue<V>>`	`zrevrangebyscoreWithScores(K key, double max, double min, long offset, long count)`	Return a range of members with scores in a sorted set, by score, with scores ordered from high to low.
`Flux<ScoredValue<V>>`	`zrevrangebyscoreWithScores(K key, Range<? extends Number> range)`	Return a range of members with scores in a sorted set, by score, with scores ordered from high to low.
`Flux<ScoredValue<V>>`	`zrevrangebyscoreWithScores(K key, Range<? extends Number> range, Limit limit)`	Return a range of members with scores in a sorted set, by score, with scores ordered from high to low.
`Flux<ScoredValue<V>>`	`zrevrangebyscoreWithScores(K key, String max, String min)`	Return a range of members with scores in a sorted set, by score, with scores ordered from high to low.
`Flux<ScoredValue<V>>`	`zrevrangebyscoreWithScores(K key, String max, String min, long offset, long count)`	Return a range of members with scores in a sorted set, by score, with scores ordered from high to low.
`Mono<Long>`	`zrevrangestorebylex(K dstKey, K srcKey, Range<? extends V> range, Limit limit)`	Get the lexicographical range ordered from high to low of elements in the sorted set stored at `srcKey` and stores the result in the `dstKey` destination key.
`Mono<Long>`	`zrevrangestorebyscore(K dstKey, K srcKey, Range<? extends Number> range, Limit limit)`	Get the specified range of elements in the sorted set stored at {@code srcKey with scores ordered from high to low and stores the result in the {@code dstKey} destination key. @param dstKey the src key. @param srcKey the dst key. @param range the score range. @return The number of elements in the resulting sorted set. @since 6.1
`Mono<Long>`	`zrevrangeWithScores(ScoredValueStreamingChannel<V> channel, K key, long start, long stop)`	Stream over a range of members with scores in a sorted set, by index, with scores ordered from high to low.
`Flux<ScoredValue<V>>`	`zrevrangeWithScores(K key, long start, long stop)`	Return a range of members with scores in a sorted set, by index, with scores ordered from high to low.
`Mono<Long>`	`zrevrank(K key, V member)`	Determine the index of a member in a sorted set, with scores ordered from high to low.
`Mono<StreamScanCursor>`	`zscan(ScoredValueStreamingChannel<V> channel, K key)`	Incrementally iterate sorted sets elements and associated scores.
`Mono<StreamScanCursor>`	`zscan(ScoredValueStreamingChannel<V> channel, K key, ScanArgs scanArgs)`	Incrementally iterate sorted sets elements and associated scores.
`Mono<StreamScanCursor>`	`zscan(ScoredValueStreamingChannel<V> channel, K key, ScanCursor scanCursor)`	Incrementally iterate sorted sets elements and associated scores.
`Mono<StreamScanCursor>`	`zscan(ScoredValueStreamingChannel<V> channel, K key, ScanCursor scanCursor, ScanArgs scanArgs)`	Incrementally iterate sorted sets elements and associated scores.
`Mono<ScoredValueScanCursor<V>>`	`zscan(K key)`	Incrementally iterate sorted sets elements and associated scores.
`Mono<ScoredValueScanCursor<V>>`	`zscan(K key, ScanArgs scanArgs)`	Incrementally iterate sorted sets elements and associated scores.
`Mono<ScoredValueScanCursor<V>>`	`zscan(K key, ScanCursor scanCursor)`	Incrementally iterate sorted sets elements and associated scores.
`Mono<ScoredValueScanCursor<V>>`	`zscan(K key, ScanCursor scanCursor, ScanArgs scanArgs)`	Incrementally iterate sorted sets elements and associated scores.
`Mono<Double>`	`zscore(K key, V member)`	Get the score associated with the given member in a sorted set.
`Flux<V>`	`zunion(ZAggregateArgs aggregateArgs, K... keys)`	Add multiple sorted sets and returns the resulting sorted set.
`Flux<V>`	`zunion(K... keys)`	Add multiple sorted sets and returns the resulting sorted set.
`Mono<Long>`	`zunionstore(K destination, ZStoreArgs zStoreArgs, K... keys)`	Add multiple sorted sets and store the resulting sorted set in a new key.
`Mono<Long>`	`zunionstore(K destination, K... keys)`	Add multiple sorted sets and store the resulting sorted set in a new key.
`Flux<ScoredValue<V>>`	`zunionWithScores(ZAggregateArgs aggregateArgs, K... keys)`	Add multiple sorted sets and returns the resulting sorted set.
`Flux<ScoredValue<V>>`	`zunionWithScores(K... keys)`	Add multiple sorted sets and returns the resulting sorted set.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Details
- AbstractRedisReactiveCommands
  
  public AbstractRedisReactiveCommands(StatefulConnection<K,V> connection, RedisCodec<K,V> codec)
  
  Initialize a new instance.
  
  Parameters:
  
  connection - the connection to operate on.
  
  codec - the codec for command encoding.
Method Details
- aclCat
  
  public Mono<Set<AclCategory>> aclCat()
  
  Description copied from interface: RedisAclReactiveCommands
  
  The command shows the available ACL categories if called without arguments.
  
  Specified by:
  
  aclCat in interface RedisAclReactiveCommands<K,V>
  
  Returns:
  
  AclCategory a list of ACL categories or
- aclCat
  
  public Mono<Set<CommandType>> aclCat(AclCategory category)
  
  Description copied from interface: RedisAclReactiveCommands
  
  The command shows all the Redis commands in the specified category.
  
  Specified by:
  
  aclCat in interface RedisAclReactiveCommands<K,V>
  
  Parameters:
  
  category - the specified category
  
  Returns:
  
  CommandType a list of commands inside a given category
- aclDeluser
  
  public Mono<Long> aclDeluser(String... usernames)
  
  Description copied from interface: RedisAclReactiveCommands
  
  Delete all the specified ACL users and terminate all the connections that are authenticated with such users.
  
  Specified by:
  
  aclDeluser in interface RedisAclReactiveCommands<K,V>
  
  Parameters:
  
  usernames - the specified usernames
  
  Returns:
  
  Long The number of users that were deleted
- aclGenpass
  
  public Mono<String> aclGenpass()
  
  Description copied from interface: RedisAclReactiveCommands
  
  The command generates a password.
  
  Specified by:
  
  aclGenpass in interface RedisAclReactiveCommands<K,V>
  
  Returns:
  
  String bulk-string-reply 64 bytes string password representing 256 bits of pseudorandom data.
- aclGenpass
  
  public Mono<String> aclGenpass(int bits)
  
  Description copied from interface: RedisAclReactiveCommands
  
  The command generates a password.
  
  Specified by:
  
  aclGenpass in interface RedisAclReactiveCommands<K,V>
  
  Parameters:
  
  bits - amount of bits
  
  Returns:
  
  String bulk-string-reply N/4 bytes string password representing N bits of pseudorandom data.
- aclGetuser
  
  public Mono<List<Object>> aclGetuser(String username)
  
  Description copied from interface: RedisAclReactiveCommands
  
  The command returns all the rules defined for an existing ACL user.
  
  Specified by:
  
  aclGetuser in interface RedisAclReactiveCommands<K,V>
  
  Parameters:
  
  username - the specified username
  
  Returns:
  
  Map<String, Object> a map of ACL rule definitions for the user.
- aclList
  
  public Flux<String> aclList()
  
  Description copied from interface: RedisAclReactiveCommands
  
  The command shows the currently active ACL rules in the Redis server.
  
  Specified by:
  
  aclList in interface RedisAclReactiveCommands<K,V>
  
  Returns:
  
  String a list of strings.
- aclLoad
  
  public Mono<String> aclLoad()
  
  Description copied from interface: RedisAclReactiveCommands
  
  When Redis is configured to use an ACL file (with the aclfile configuration option), this command will reload the ACLs from the file, replacing all the current ACL rules with the ones defined in the file.
  
  Specified by:
  
  aclLoad in interface RedisAclReactiveCommands<K,V>
  
  Returns:
  
  String simple-string-reply OK or error message.
- aclLog
  
  public Flux<Map<String,Object>> aclLog()
  
  Description copied from interface: RedisAclReactiveCommands
  
  The command shows a list of recent ACL security events.
  
  Specified by:
  
  aclLog in interface RedisAclReactiveCommands<K,V>
  
  Returns:
  
  Map<K,Object> list of security events.
- aclLog
  
  public Flux<Map<String,Object>> aclLog(int count)
  
  Description copied from interface: RedisAclReactiveCommands
  
  The command shows a list of recent ACL security events.
  
  Specified by:
  
  aclLog in interface RedisAclReactiveCommands<K,V>
  
  Parameters:
  
  count - max count of events
  
  Returns:
  
  Map<K, Object> list of security events.
- aclLogReset
  
  public Mono<String> aclLogReset()
  
  Description copied from interface: RedisAclReactiveCommands
  
  The command clears ACL security events.
  
  Specified by:
  
  aclLogReset in interface RedisAclReactiveCommands<K,V>
  
  Returns:
  
  String simple-string-reply OK if the security log was cleared.
- aclSave
  
  public Mono<String> aclSave()
  
  Description copied from interface: RedisAclReactiveCommands
  
  When Redis is configured to use an ACL file (with the aclfile configuration option), this command will save the currently defined ACLs from the server memory to the ACL file.
  
  Specified by:
  
  aclSave in interface RedisAclReactiveCommands<K,V>
  
  Returns:
  
  String simple-string-reply OK or error message.
- aclSetuser
  
  public Mono<String> aclSetuser(String username, AclSetuserArgs args)
  
  Description copied from interface: RedisAclReactiveCommands
  
  Create an ACL user with the specified rules or modify the rules of an existing user.
  
  Specified by:
  
  aclSetuser in interface RedisAclReactiveCommands<K,V>
  
  Parameters:
  
  username - the specified username
  
  args - rules
  
  Returns:
  
  String simple-string-reply OK or error message.
- aclUsers
  
  public Flux<String> aclUsers()
  
  Description copied from interface: RedisAclReactiveCommands
  
  The command shows a list of all the usernames of the currently configured users in the Redis ACL system.
  
  Specified by:
  
  aclUsers in interface RedisAclReactiveCommands<K,V>
  
  Returns:
  
  K a list of usernames.
- aclWhoami
  
  public Mono<String> aclWhoami()
  
  Description copied from interface: RedisAclReactiveCommands
  
  The command shows a list of all the usernames of the currently configured users in the Redis ACL system.
  
  Specified by:
  
  aclWhoami in interface RedisAclReactiveCommands<K,V>
  
  Returns:
  
  K bulk-string-reply the username of the current connection.
- append
  
  public Mono<Long> append(K key, V value)
  
  Description copied from interface: RedisStringReactiveCommands
  
  Append a value to a key.
  
  Specified by:
  
  append in interface RedisStringReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  value - the value.
  
  Returns:
  
  Long integer-reply the length of the string after the append operation.
- asking
  
  public Mono<String> asking()
  
  Description copied from interface: RedisClusterReactiveCommands
  
  The asking command is required after a -ASK redirection. The client should issue ASKING before to actually send the command to the target instance. See the Redis Cluster specification for more information.
  
  Specified by:
  
  asking in interface RedisClusterReactiveCommands<K,V>
  
  Returns:
  
  String simple-string-reply
- auth
  
  public Mono<String> auth(CharSequence password)
  
  Description copied from interface: RedisClusterReactiveCommands
  
  Authenticate to the server.
  
  Specified by:
  
  auth in interface RedisClusterReactiveCommands<K,V>
  
  Parameters:
  
  password - the password
  
  Returns:
  
  String simple-string-reply
- auth
  
  public Mono<String> auth(String username, CharSequence password)
  
  Description copied from interface: RedisClusterReactiveCommands
  
  Authenticate to the server with username and password. Requires Redis 6 or newer.
  
  Specified by:
  
  auth in interface RedisClusterReactiveCommands<K,V>
  
  Parameters:
  
  username - the username
  
  password - the password
  
  Returns:
  
  String simple-string-reply
- bgrewriteaof
  
  public Mono<String> bgrewriteaof()
  
  Description copied from interface: RedisServerReactiveCommands
  
  Asynchronously rewrite the append-only file.
  
  Specified by:
  
  bgrewriteaof in interface RedisServerReactiveCommands<K,V>
  
  Returns:
  
  String simple-string-reply always OK.
- bgsave
  
  public Mono<String> bgsave()
  
  Description copied from interface: RedisServerReactiveCommands
  
  Asynchronously save the dataset to disk.
  
  Specified by:
  
  bgsave in interface RedisServerReactiveCommands<K,V>
  
  Returns:
  
  String simple-string-reply.
- bitcount
  
  public Mono<Long> bitcount(K key)
  
  Description copied from interface: RedisStringReactiveCommands
  
  Count set bits in a string.
  
  Specified by:
  
  bitcount in interface RedisStringReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  Returns:
  
  Long integer-reply The number of bits set to 1.
- bitcount
  
  public Mono<Long> bitcount(K key, long start, long end)
  
  Description copied from interface: RedisStringReactiveCommands
  
  Count set bits in a string.
  
  Specified by:
  
  bitcount in interface RedisStringReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  start - the start.
  
  end - the end.
  
  Returns:
  
  Long integer-reply The number of bits set to 1.
- bitfield
  
  public Flux<Value<Long>> bitfield(K key, BitFieldArgs args)
  
  Description copied from interface: RedisStringReactiveCommands
  
  Execute BITFIELD with its subcommands.
  
  Specified by:
  
  bitfield in interface RedisStringReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  args - the args containing subcommands, must not be null.
  
  Returns:
  
  Long bulk-reply the results from the bitfield commands.
- bitopAnd
  
  public Mono<Long> bitopAnd(K destination, K... keys)
  
  Description copied from interface: RedisStringReactiveCommands
  
  Perform bitwise AND between strings.
  
  Specified by:
  
  bitopAnd in interface RedisStringReactiveCommands<K,V>
  
  Parameters:
  
  destination - result key of the operation.
  
  keys - operation input key names.
  
  Returns:
  
  Long integer-reply The size of the string stored in the destination key, that is equal to the size of the longest input string.
- bitopNot
  
  public Mono<Long> bitopNot(K destination, K source)
  
  Description copied from interface: RedisStringReactiveCommands
  
  Perform bitwise NOT between strings.
  
  Specified by:
  
  bitopNot in interface RedisStringReactiveCommands<K,V>
  
  Parameters:
  
  destination - result key of the operation.
  
  source - operation input key names.
  
  Returns:
  
  Long integer-reply The size of the string stored in the destination key, that is equal to the size of the longest input string.
- bitopOr
  
  public Mono<Long> bitopOr(K destination, K... keys)
  
  Description copied from interface: RedisStringReactiveCommands
  
  Perform bitwise OR between strings.
  
  Specified by:
  
  bitopOr in interface RedisStringReactiveCommands<K,V>
  
  Parameters:
  
  destination - result key of the operation.
  
  keys - operation input key names.
  
  Returns:
  
  Long integer-reply The size of the string stored in the destination key, that is equal to the size of the longest input string.
- bitopXor
  
  public Mono<Long> bitopXor(K destination, K... keys)
  
  Description copied from interface: RedisStringReactiveCommands
  
  Perform bitwise XOR between strings.
  
  Specified by:
  
  bitopXor in interface RedisStringReactiveCommands<K,V>
  
  Parameters:
  
  destination - result key of the operation.
  
  keys - operation input key names.
  
  Returns:
  
  Long integer-reply The size of the string stored in the destination key, that is equal to the size of the longest input string.
- bitpos
  
  public Mono<Long> bitpos(K key, boolean state)
  
  Description copied from interface: RedisStringReactiveCommands
  
  Find first bit set or clear in a string.
  
  Specified by:
  
  bitpos in interface RedisStringReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  state - the state.
  
  Returns:
  
  Long integer-reply The command returns the position of the first bit set to 1 or 0 according to the request. If we look for set bits (the bit argument is 1) and the string is empty or composed of just zero bytes, -1 is returned. If we look for clear bits (the bit argument is 0) and the string only contains bit set to 1, the function returns the first bit not part of the string on the right. So if the string is three bytes set to the value 0xff the command BITPOS key 0 will return 24, since up to bit 23 all the bits are 1. Basically the function consider the right of the string as padded with zeros if you look for clear bits and specify no range or the start argument only.
- bitpos
  
  public Mono<Long> bitpos(K key, boolean state, long start)
  
  Description copied from interface: RedisStringReactiveCommands
  
  Find first bit set or clear in a string.
  
  Specified by:
  
  bitpos in interface RedisStringReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  state - the bit type: long.
  
  start - the start type: long.
  
  Returns:
  
  Long integer-reply The command returns the position of the first bit set to 1 or 0 according to the request. If we look for set bits (the bit argument is 1) and the string is empty or composed of just zero bytes, -1 is returned. If we look for clear bits (the bit argument is 0) and the string only contains bit set to 1, the function returns the first bit not part of the string on the right. So if the string is three bytes set to the value 0xff the command BITPOS key 0 will return 24, since up to bit 23 all the bits are 1. Basically the function consider the right of the string as padded with zeros if you look for clear bits and specify no range or the start argument only.
- bitpos
  
  public Mono<Long> bitpos(K key, boolean state, long start, long end)
  
  Description copied from interface: RedisStringReactiveCommands
  
  Find first bit set or clear in a string.
  
  Specified by:
  
  bitpos in interface RedisStringReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  state - the bit type: long.
  
  start - the start type: long.
  
  end - the end type: long.
  
  Returns:
  
  Long integer-reply The command returns the position of the first bit set to 1 or 0 according to the request. If we look for set bits (the bit argument is 1) and the string is empty or composed of just zero bytes, -1 is returned. If we look for clear bits (the bit argument is 0) and the string only contains bit set to 1, the function returns the first bit not part of the string on the right. So if the string is three bytes set to the value 0xff the command BITPOS key 0 will return 24, since up to bit 23 all the bits are 1. Basically the function consider the right of the string as padded with zeros if you look for clear bits and specify no range or the start argument only. However this behavior changes if you are looking for clear bits and specify a range with both start and end. If no clear bit is found in the specified range, the function returns -1 as the user specified a clear range and there are no 0 bits in that range.
- blmove
  
  public Mono<V> blmove(K source, K destination, LMoveArgs args, long timeout)
  
  Description copied from interface: RedisListReactiveCommands
  
  Atomically returns and removes the first/last element (head/tail depending on the wherefrom argument) of the list stored at source, and pushes the element at the first/last element (head/tail depending on the whereto argument) of the list stored at destination. When source is empty, Redis will block the connection until another client pushes to it or until timeout is reached.
  
  Specified by:
  
  blmove in interface RedisListReactiveCommands<K,V>
  
  Parameters:
  
  source - the source key.
  
  destination - the destination type: key.
  
  args - command arguments to configure source and destination directions.
  
  timeout - the timeout in seconds.
  
  Returns:
  
  V bulk-string-reply the element being popped and pushed.
- blmove
  
  public Mono<V> blmove(K source, K destination, LMoveArgs args, double timeout)
  
  Description copied from interface: RedisListReactiveCommands
  
  Atomically returns and removes the first/last element (head/tail depending on the wherefrom argument) of the list stored at source, and pushes the element at the first/last element (head/tail depending on the whereto argument) of the list stored at destination. When source is empty, Redis will block the connection until another client pushes to it or until timeout is reached.
  
  Specified by:
  
  blmove in interface RedisListReactiveCommands<K,V>
  
  Parameters:
  
  source - the source key.
  
  destination - the destination type: key.
  
  args - command arguments to configure source and destination directions.
  
  timeout - the timeout in seconds.
  
  Returns:
  
  V bulk-string-reply the element being popped and pushed.
- blpop
  
  public Mono<KeyValue<K,V>> blpop(long timeout, K... keys)
  
  Description copied from interface: RedisListReactiveCommands
  
  Remove and get the first element in a list, or block until one is available.
  
  Specified by:
  
  blpop in interface RedisListReactiveCommands<K,V>
  
  Parameters:
  
  timeout - the timeout in seconds.
  
  keys - the keys.
  
  Returns:
  
  KeyValue<K,V> array-reply specifically: A null multi-bulk when no element could be popped and the timeout expired. A two-element multi-bulk with the first element being the name of the key where an element was popped and the second element being the value of the popped element.
- blpop
  
  public Mono<KeyValue<K,V>> blpop(double timeout, K... keys)
  
  Description copied from interface: RedisListReactiveCommands
  
  Remove and get the first element in a list, or block until one is available.
  
  Specified by:
  
  blpop in interface RedisListReactiveCommands<K,V>
  
  Parameters:
  
  timeout - the timeout in seconds.
  
  keys - the keys.
  
  Returns:
  
  KeyValue<K,V> array-reply specifically: A null multi-bulk when no element could be popped and the timeout expired. A two-element multi-bulk with the first element being the name of the key where an element was popped and the second element being the value of the popped element.
- brpop
  
  public Mono<KeyValue<K,V>> brpop(long timeout, K... keys)
  
  Description copied from interface: RedisListReactiveCommands
  
  Remove and get the last element in a list, or block until one is available.
  
  Specified by:
  
  brpop in interface RedisListReactiveCommands<K,V>
  
  Parameters:
  
  timeout - the timeout in seconds.
  
  keys - the keys.
  
  Returns:
  
  KeyValue<K,V> array-reply specifically: A null multi-bulk when no element could be popped and the timeout expired. A two-element multi-bulk with the first element being the name of the key where an element was popped and the second element being the value of the popped element.
- brpop
  
  public Mono<KeyValue<K,V>> brpop(double timeout, K... keys)
  
  Description copied from interface: RedisListReactiveCommands
  
  Remove and get the last element in a list, or block until one is available.
  
  Specified by:
  
  brpop in interface RedisListReactiveCommands<K,V>
  
  Parameters:
  
  timeout - the timeout in seconds.
  
  keys - the keys.
  
  Returns:
  
  KeyValue<K,V> array-reply specifically: A null multi-bulk when no element could be popped and the timeout expired. A two-element multi-bulk with the first element being the name of the key where an element was popped and the second element being the value of the popped element.
- brpoplpush
  
  public Mono<V> brpoplpush(long timeout, K source, K destination)
  
  Description copied from interface: RedisListReactiveCommands
  
  Pop a value from a list, push it to another list and return it; or block until one is available.
  
  Specified by:
  
  brpoplpush in interface RedisListReactiveCommands<K,V>
  
  Parameters:
  
  timeout - the timeout in seconds.
  
  source - the source key.
  
  destination - the destination type: key.
  
  Returns:
  
  V bulk-string-reply the element being popped from source and pushed to destination. If timeout is reached, a.
- brpoplpush
  
  public Mono<V> brpoplpush(double timeout, K source, K destination)
  
  Description copied from interface: RedisListReactiveCommands
  
  Pop a value from a list, push it to another list and return it; or block until one is available.
  
  Specified by:
  
  brpoplpush in interface RedisListReactiveCommands<K,V>
  
  Parameters:
  
  timeout - the timeout in seconds.
  
  source - the source key.
  
  destination - the destination type: key.
  
  Returns:
  
  V bulk-string-reply the element being popped from source and pushed to destination. If timeout is reached, a.
- clientCaching
  
  public Mono<String> clientCaching(boolean enabled)
  
  Description copied from interface: RedisServerReactiveCommands
  
  Control tracking of keys in the context of server-assisted client cache invalidation.
  
  Specified by:
  
  clientCaching in interface RedisServerReactiveCommands<K,V>
  
  Parameters:
  
  enabled - true to enable key tracking.
  
  Returns:
  
  String simple-string-reply OK.
- clientGetname
  
  public Mono<K> clientGetname()
  
  Description copied from interface: RedisServerReactiveCommands
  
  Get the current connection name.
  
  Specified by:
  
  clientGetname in interface RedisServerReactiveCommands<K,V>
  
  Returns:
  
  K bulk-string-reply The connection name, or a null bulk reply if no name is set.
- clientGetredir
  
  public Mono<Long> clientGetredir()
  
  Description copied from interface: RedisServerReactiveCommands
  
  Returns the client ID we are redirecting our tracking notifications to.
  
  Specified by:
  
  clientGetredir in interface RedisServerReactiveCommands<K,V>
  
  Returns:
  
  the ID of the client we are redirecting the notifications to. The command returns -1 if client tracking is not enabled, or 0 if client tracking is enabled but we are not redirecting the notifications to any client.
- clientKill
  
  public Mono<String> clientKill(String addr)
  
  Description copied from interface: RedisServerReactiveCommands
  
  Kill the connection of a client identified by ip:port.
  
  Specified by:
  
  clientKill in interface RedisServerReactiveCommands<K,V>
  
  Parameters:
  
  addr - ip:port.
  
  Returns:
  
  String simple-string-reply OK if the connection exists and has been closed.
- clientKill
  
  public Mono<Long> clientKill(KillArgs killArgs)
  
  Description copied from interface: RedisServerReactiveCommands
  
  Kill connections of clients which are filtered by killArgs.
  
  Specified by:
  
  clientKill in interface RedisServerReactiveCommands<K,V>
  
  Parameters:
  
  killArgs - args for the kill operation.
  
  Returns:
  
  Long integer-reply number of killed connections.
- clientList
  
  public Mono<String> clientList()
  
  Description copied from interface: RedisServerReactiveCommands
  
  Get the list of client connections.
  
  Specified by:
  
  clientList in interface RedisServerReactiveCommands<K,V>
  
  Returns:
  
  String bulk-string-reply a unique string, formatted as follows: One client connection per line (separated by LF), each line is composed of a succession of property=value fields separated by a space character.
- clientId
  
  public Mono<Long> clientId()
  
  Description copied from interface: RedisServerReactiveCommands
  
  Get the id of the current connection.
  
  Specified by:
  
  clientId in interface RedisServerReactiveCommands<K,V>
  
  Returns:
  
  Long The command just returns the ID of the current connection.
- clientPause
  
  public Mono<String> clientPause(long timeout)
  
  Description copied from interface: RedisServerReactiveCommands
  
  Stop processing commands from clients for some time.
  
  Specified by:
  
  clientPause in interface RedisServerReactiveCommands<K,V>
  
  Parameters:
  
  timeout - the timeout value in milliseconds.
  
  Returns:
  
  String simple-string-reply The command returns OK or an error if the timeout is invalid.
- clientSetname
  
  public Mono<String> clientSetname(K name)
  
  Description copied from interface: RedisServerReactiveCommands
  
  Set the current connection name.
  
  Specified by:
  
  clientSetname in interface RedisServerReactiveCommands<K,V>
  
  Parameters:
  
  name - the client name.
  
  Returns:
  
  simple-string-reply OK if the connection name was successfully set.
- clientTracking
  
  public Mono<String> clientTracking(TrackingArgs args)
  
  Description copied from interface: RedisServerReactiveCommands
  
  Enables the tracking feature of the Redis server, that is used for server assisted client side caching. Tracking messages are either available when using the RESP3 protocol or through Pub/Sub notification when using RESP2.
  
  Specified by:
  
  clientTracking in interface RedisServerReactiveCommands<K,V>
  
  Parameters:
  
  args - for the CLIENT TRACKING operation.
  
  Returns:
  
  String simple-string-reply OK.
- clientUnblock
  
  public Mono<Long> clientUnblock(long id, UnblockType type)
  
  Description copied from interface: RedisServerReactiveCommands
  
  Unblock the specified blocked client.
  
  Specified by:
  
  clientUnblock in interface RedisServerReactiveCommands<K,V>
  
  Parameters:
  
  id - the client id.
  
  type - unblock type.
  
  Returns:
  
  Long integer-reply number of unblocked connections.
- close
  
  public void close()
- clusterAddSlots
  
  public Mono<String> clusterAddSlots(int... slots)
  
  Description copied from interface: RedisClusterReactiveCommands
  
  Adds slots to the cluster node. The current node will become the master for the specified slots.
  
  Specified by:
  
  clusterAddSlots in interface RedisClusterReactiveCommands<K,V>
  
  Parameters:
  
  slots - one or more slots from 0 to 16384
  
  Returns:
  
  String simple-string-reply
- clusterBumpepoch
  
  public Mono<String> clusterBumpepoch()
  
  Description copied from interface: RedisClusterReactiveCommands
  
  Generate a new config epoch, incrementing the current epoch, assign the new epoch to this node, WITHOUT any consensus and persist the configuration on disk before sending packets with the new configuration.
  
  Specified by:
  
  clusterBumpepoch in interface RedisClusterReactiveCommands<K,V>
  
  Returns:
  
  String simple-string-reply If the new config epoch is generated and assigned either BUMPED (epoch) or STILL (epoch) are returned.
- clusterCountFailureReports
  
  public Mono<Long> clusterCountFailureReports(String nodeId)
  
  Description copied from interface: RedisClusterReactiveCommands
  
  Returns the number of failure reports for the specified node. Failure reports are the way Redis Cluster uses in order to promote a PFAIL state, that means a node is not reachable, to a FAIL state, that means that the majority of masters in the cluster agreed within a window of time that the node is not reachable.
  
  Specified by:
  
  clusterCountFailureReports in interface RedisClusterReactiveCommands<K,V>
  
  Parameters:
  
  nodeId - the node id
  
  Returns:
  
  Integer reply: The number of active failure reports for the node.
- clusterCountKeysInSlot
  
  public Mono<Long> clusterCountKeysInSlot(int slot)
  
  Description copied from interface: RedisClusterReactiveCommands
  
  Returns the number of keys in the specified Redis Cluster hash slot.
  
  Specified by:
  
  clusterCountKeysInSlot in interface RedisClusterReactiveCommands<K,V>
  
  Parameters:
  
  slot - the slot
  
  Returns:
  
  Integer reply: The number of keys in the specified hash slot, or an error if the hash slot is invalid.
- clusterDelSlots
  
  public Mono<String> clusterDelSlots(int... slots)
  
  Description copied from interface: RedisClusterReactiveCommands
  
  Removes slots from the cluster node.
  
  Specified by:
  
  clusterDelSlots in interface RedisClusterReactiveCommands<K,V>
  
  Parameters:
  
  slots - one or more slots from 0 to 16384
  
  Returns:
  
  String simple-string-reply
- clusterFailover
  
  public Mono<String> clusterFailover(boolean force)
  
  Description copied from interface: RedisClusterReactiveCommands
  
  Failover a cluster node. Turns the currently connected node into a master and the master into its replica.
  
  Specified by:
  
  clusterFailover in interface RedisClusterReactiveCommands<K,V>
  
  Parameters:
  
  force - do not coordinate with master if true
  
  Returns:
  
  String simple-string-reply
- clusterFlushslots
  
  public Mono<String> clusterFlushslots()
  
  Description copied from interface: RedisClusterReactiveCommands
  
  Delete all the slots associated with the specified node. The number of deleted slots is returned.
  
  Specified by:
  
  clusterFlushslots in interface RedisClusterReactiveCommands<K,V>
  
  Returns:
  
  String simple-string-reply
- clusterForget
  
  public Mono<String> clusterForget(String nodeId)
  
  Description copied from interface: RedisClusterReactiveCommands
  
  Disallow connections and remove the cluster node from the cluster.
  
  Specified by:
  
  clusterForget in interface RedisClusterReactiveCommands<K,V>
  
  Parameters:
  
  nodeId - the node Id
  
  Returns:
  
  String simple-string-reply
- clusterGetKeysInSlot
  
  public Flux<K> clusterGetKeysInSlot(int slot, int count)
  
  Description copied from interface: RedisClusterReactiveCommands
  
  Retrieve the list of keys within the slot.
  
  Specified by:
  
  clusterGetKeysInSlot in interface RedisClusterReactiveCommands<K,V>
  
  Parameters:
  
  slot - the slot
  
  count - maximal number of keys
  
  Returns:
  
  List<K> array-reply list of keys
- clusterInfo
  
  public Mono<String> clusterInfo()
  
  Description copied from interface: RedisClusterReactiveCommands
  
  Get information and statistics about the cluster viewed by the current node.
  
  Specified by:
  
  clusterInfo in interface RedisClusterReactiveCommands<K,V>
  
  Returns:
  
  String bulk-string-reply as a collection of text lines.
- clusterKeyslot
  
  public Mono<Long> clusterKeyslot(K key)
  
  Description copied from interface: RedisClusterReactiveCommands
  
  Returns an integer identifying the hash slot the specified key hashes to. This command is mainly useful for debugging and testing, since it exposes via an API the underlying Redis implementation of the hashing algorithm. Basically the same as SlotHash.getSlot(byte[]). If not, call Houston and report that we've got a problem.
  
  Specified by:
  
  clusterKeyslot in interface RedisClusterReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  Returns:
  
  Integer reply: The hash slot number.
- clusterMeet
  
  public Mono<String> clusterMeet(String ip, int port)
  
  Description copied from interface: RedisClusterReactiveCommands
  
  Meet another cluster node to include the node into the cluster. The command starts the cluster handshake and returns with OK when the node was added to the cluster.
  
  Specified by:
  
  clusterMeet in interface RedisClusterReactiveCommands<K,V>
  
  Parameters:
  
  ip - IP address of the host
  
  port - port number.
  
  Returns:
  
  String simple-string-reply
- clusterMyId
  
  public Mono<String> clusterMyId()
  
  Description copied from interface: RedisClusterReactiveCommands
  
  Obtain the nodeId for the currently connected node.
  
  Specified by:
  
  clusterMyId in interface RedisClusterReactiveCommands<K,V>
  
  Returns:
  
  String simple-string-reply
- clusterNodes
  
  public Mono<String> clusterNodes()
  
  Description copied from interface: RedisClusterReactiveCommands
  
  Obtain details about all cluster nodes. Can be parsed using ClusterPartitionParser.parse(java.lang.String)
  
  Specified by:
  
  clusterNodes in interface RedisClusterReactiveCommands<K,V>
  
  Returns:
  
  String bulk-string-reply as a collection of text lines
- clusterReplicate
  
  public Mono<String> clusterReplicate(String nodeId)
  
  Description copied from interface: RedisClusterReactiveCommands
  
  Turn this node into a replica of the node with the id nodeId.
  
  Specified by:
  
  clusterReplicate in interface RedisClusterReactiveCommands<K,V>
  
  Parameters:
  
  nodeId - master node id
  
  Returns:
  
  String simple-string-reply
- clusterReset
  
  public Mono<String> clusterReset(boolean hard)
  
  Description copied from interface: RedisClusterReactiveCommands
  Reset a node performing a soft or hard reset:
  
  All other nodes are forgotten
  
  All the assigned / open slots are released
  
  If the node is a replica, it turns into a master
  
  Only for hard reset: a new Node ID is generated
  
  Only for hard reset: currentEpoch and configEpoch are set to 0
  
  The new configuration is saved and the cluster state updated
  
  If the node was a replica, the whole data set is flushed away
  Specified by:
  
  clusterReset in interface RedisClusterReactiveCommands<K,V>
  
  Parameters:
  
  hard - true for hard reset. Generates a new nodeId and currentEpoch/configEpoch are set to 0
  
  Returns:
  
  String simple-string-reply
- clusterSaveconfig
  
  public Mono<String> clusterSaveconfig()
  
  Description copied from interface: RedisClusterReactiveCommands
  
  Forces a node to save the nodes.conf configuration on disk.
  
  Specified by:
  
  clusterSaveconfig in interface RedisClusterReactiveCommands<K,V>
  
  Returns:
  
  String simple-string-reply: OK or an error if the operation fails.
- clusterSetConfigEpoch
  
  public Mono<String> clusterSetConfigEpoch(long configEpoch)
  
  Description copied from interface: RedisClusterReactiveCommands
  This command sets a specific config epoch in a fresh node. It only works when:
  
  The nodes table of the node is empty.
  
  The node current config epoch is zero.
  Specified by:
  
  clusterSetConfigEpoch in interface RedisClusterReactiveCommands<K,V>
  
  Parameters:
  
  configEpoch - the config epoch
  
  Returns:
  
  String simple-string-reply: OK or an error if the operation fails.
- clusterSetSlotImporting
  
  public Mono<String> clusterSetSlotImporting(int slot, String nodeId)
  
  Description copied from interface: RedisClusterReactiveCommands
  
  Flag a slot as IMPORTING (incoming) from the node specified in nodeId.
  
  Specified by:
  
  clusterSetSlotImporting in interface RedisClusterReactiveCommands<K,V>
  
  Parameters:
  
  slot - the slot
  
  nodeId - the id of the node is the master of the slot
  
  Returns:
  
  String simple-string-reply
- clusterSetSlotMigrating
  
  public Mono<String> clusterSetSlotMigrating(int slot, String nodeId)
  
  Description copied from interface: RedisClusterReactiveCommands
  
  Flag a slot as MIGRATING (outgoing) towards the node specified in nodeId. The slot must be handled by the current node in order to be migrated.
  
  Specified by:
  
  clusterSetSlotMigrating in interface RedisClusterReactiveCommands<K,V>
  
  Parameters:
  
  slot - the slot
  
  nodeId - the id of the node is targeted to become the master for the slot
  
  Returns:
  
  String simple-string-reply
- clusterSetSlotNode
  
  public Mono<String> clusterSetSlotNode(int slot, String nodeId)
  
  Description copied from interface: RedisClusterReactiveCommands
  
  Assign a slot to a node. The command migrates the specified slot from the current node to the specified node in nodeId
  
  Specified by:
  
  clusterSetSlotNode in interface RedisClusterReactiveCommands<K,V>
  
  Parameters:
  
  slot - the slot
  
  nodeId - the id of the node that will become the master for the slot
  
  Returns:
  
  String simple-string-reply
- clusterSetSlotStable
  
  public Mono<String> clusterSetSlotStable(int slot)
  
  Description copied from interface: RedisClusterReactiveCommands
  
  Clears migrating / importing state from the slot.
  
  Specified by:
  
  clusterSetSlotStable in interface RedisClusterReactiveCommands<K,V>
  
  Parameters:
  
  slot - the slot
  
  Returns:
  
  String simple-string-reply
- clusterSlaves
  
  public Flux<String> clusterSlaves(String nodeId)
  
  Description copied from interface: RedisClusterReactiveCommands
  
  List replicas for a certain node identified by its nodeId. Can be parsed using ClusterPartitionParser.parse(java.lang.String)
  
  Specified by:
  
  clusterSlaves in interface RedisClusterReactiveCommands<K,V>
  
  Parameters:
  
  nodeId - node id of the master node
  
  Returns:
  
  List<String> array-reply list of replicas. The command returns data in the same format as RedisClusterReactiveCommands.clusterNodes() but one line per replica.
- clusterSlots
  
  public Flux<Object> clusterSlots()
  
  Description copied from interface: RedisClusterReactiveCommands
  
  Get array of cluster slots to node mappings.
  
  Specified by:
  
  clusterSlots in interface RedisClusterReactiveCommands<K,V>
  
  Returns:
  
  List<Object> array-reply nested list of slot ranges with IP/Port mappings.
- command
  
  public Flux<Object> command()
  
  Description copied from interface: RedisServerReactiveCommands
  
  Returns an array reply of details about all Redis commands.
  
  Specified by:
  
  command in interface RedisServerReactiveCommands<K,V>
  
  Returns:
  
  Object array-reply.
- commandCount
  
  public Mono<Long> commandCount()
  
  Description copied from interface: RedisServerReactiveCommands
  
  Get total number of Redis commands.
  
  Specified by:
  
  commandCount in interface RedisServerReactiveCommands<K,V>
  
  Returns:
  
  Long integer-reply of number of total commands in this Redis server.
- commandInfo
  
  public Flux<Object> commandInfo(String... commands)
  
  Description copied from interface: RedisServerReactiveCommands
  
  Returns an array reply of details about the requested commands.
  
  Specified by:
  
  commandInfo in interface RedisServerReactiveCommands<K,V>
  
  Parameters:
  
  commands - the commands to query for.
  
  Returns:
  
  Object array-reply.
- commandInfo
  
  public Flux<Object> commandInfo(CommandType... commands)
  
  Description copied from interface: RedisServerReactiveCommands
  
  Returns an array reply of details about the requested commands.
  
  Specified by:
  
  commandInfo in interface RedisServerReactiveCommands<K,V>
  
  Parameters:
  
  commands - the commands to query for.
  
  Returns:
  
  Object array-reply.
- configGet
  
  public Mono<Map<String,String>> configGet(String parameter)
  
  Description copied from interface: RedisServerReactiveCommands
  
  Get the value of a configuration parameter.
  
  Specified by:
  
  configGet in interface RedisServerReactiveCommands<K,V>
  
  Parameters:
  
  parameter - name of the parameter.
  
  Returns:
  
  Map<String, String> bulk-string-reply.
- configResetstat
  
  public Mono<String> configResetstat()
  
  Description copied from interface: RedisServerReactiveCommands
  
  Reset the stats returned by INFO.
  
  Specified by:
  
  configResetstat in interface RedisServerReactiveCommands<K,V>
  
  Returns:
  
  String simple-string-reply always OK.
- configRewrite
  
  public Mono<String> configRewrite()
  
  Description copied from interface: RedisServerReactiveCommands
  
  Rewrite the configuration file with the in memory configuration.
  
  Specified by:
  
  configRewrite in interface RedisServerReactiveCommands<K,V>
  
  Returns:
  
  String simple-string-reply OK when the configuration was rewritten properly. Otherwise an error is returned.
- configSet
  
  public Mono<String> configSet(String parameter, String value)
  
  Description copied from interface: RedisServerReactiveCommands
  
  Set a configuration parameter to the given value.
  
  Specified by:
  
  configSet in interface RedisServerReactiveCommands<K,V>
  
  Parameters:
  
  parameter - the parameter name.
  
  value - the parameter value.
  
  Returns:
  
  String simple-string-reply: OK when the configuration was set properly. Otherwise an error is returned.
- createDissolvingFlux
  
  public <T, R> Flux<R> createDissolvingFlux(Supplier<RedisCommand<K,V,T>> commandSupplier)
- createFlux
  
  public <T> Flux<T> createFlux(Supplier<RedisCommand<K,V,T>> commandSupplier)
- createMono
  
  protected <T> Mono<T> createMono(CommandType type, CommandOutput<K,V,T> output, CommandArgs<K,V> args)
- createMono
  
  public <T> Mono<T> createMono(Supplier<RedisCommand<K,V,T>> commandSupplier)
- dbsize
  
  public Mono<Long> dbsize()
  
  Description copied from interface: RedisServerReactiveCommands
  
  Return the number of keys in the selected database.
  
  Specified by:
  
  dbsize in interface RedisServerReactiveCommands<K,V>
  
  Returns:
  
  Long integer-reply.
- debugCrashAndRecover
  
  public Mono<String> debugCrashAndRecover(Long delay)
  
  Description copied from interface: RedisServerReactiveCommands
  
  Crash and recover.
  
  Specified by:
  
  debugCrashAndRecover in interface RedisServerReactiveCommands<K,V>
  
  Parameters:
  
  delay - optional delay in milliseconds.
  
  Returns:
  
  String simple-string-reply.
- debugHtstats
  
  public Mono<String> debugHtstats(int db)
  
  Description copied from interface: RedisServerReactiveCommands
  
  Get debugging information about the internal hash-table state.
  
  Specified by:
  
  debugHtstats in interface RedisServerReactiveCommands<K,V>
  
  Parameters:
  
  db - the database number.
  
  Returns:
  
  String simple-string-reply.
- debugObject
  
  public Mono<String> debugObject(K key)
  
  Description copied from interface: RedisServerReactiveCommands
  
  Get debugging information about a key.
  
  Specified by:
  
  debugObject in interface RedisServerReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  Returns:
  
  String simple-string-reply.
- debugOom
  
  public Mono<Void> debugOom()
  
  Description copied from interface: RedisServerReactiveCommands
  
  Make the server crash: Out of memory.
  
  Specified by:
  
  debugOom in interface RedisServerReactiveCommands<K,V>
  
  Returns:
  
  nothing, because the server crashes before returning.
- debugReload
  
  public Mono<String> debugReload()
  
  Description copied from interface: RedisServerReactiveCommands
  
  Save RDB, clear the database and reload RDB.
  
  Specified by:
  
  debugReload in interface RedisServerReactiveCommands<K,V>
  
  Returns:
  
  String simple-string-reply The commands returns OK on success.
- debugRestart
  
  public Mono<String> debugRestart(Long delay)
  
  Description copied from interface: RedisServerReactiveCommands
  
  Restart the server gracefully.
  
  Specified by:
  
  debugRestart in interface RedisServerReactiveCommands<K,V>
  
  Parameters:
  
  delay - optional delay in milliseconds.
  
  Returns:
  
  String simple-string-reply.
- debugSdslen
  
  public Mono<String> debugSdslen(K key)
  
  Description copied from interface: RedisServerReactiveCommands
  
  Get debugging information about the internal SDS length.
  
  Specified by:
  
  debugSdslen in interface RedisServerReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  Returns:
  
  String simple-string-reply.
- debugSegfault
  
  public Mono<Void> debugSegfault()
  
  Description copied from interface: RedisServerReactiveCommands
  
  Make the server crash: Invalid pointer access.
  
  Specified by:
  
  debugSegfault in interface RedisServerReactiveCommands<K,V>
  
  Returns:
  
  nothing, because the server crashes before returning.
- decr
  
  public Mono<Long> decr(K key)
  
  Description copied from interface: RedisStringReactiveCommands
  
  Decrement the integer value of a key by one.
  
  Specified by:
  
  decr in interface RedisStringReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  Returns:
  
  Long integer-reply the value of key after the decrement.
- decrby
  
  public Mono<Long> decrby(K key, long amount)
  
  Description copied from interface: RedisStringReactiveCommands
  
  Decrement the integer value of a key by the given number.
  
  Specified by:
  
  decrby in interface RedisStringReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  amount - the decrement type: long.
  
  Returns:
  
  Long integer-reply the value of key after the decrement.
- del
  
  public Mono<Long> del(K... keys)
  
  Description copied from interface: RedisKeyReactiveCommands
  
  Delete one or more keys.
  
  Specified by:
  
  del in interface RedisClusterReactiveCommands<K,V>
  
  Specified by:
  
  del in interface RedisKeyReactiveCommands<K,V>
  
  Parameters:
  
  keys - the keys.
  
  Returns:
  
  Long integer-reply The number of keys that were removed.
- del
  
  public Mono<Long> del(Iterable<K> keys)
- digest
  
  public String digest(String script)
  
  Description copied from interface: RedisScriptingReactiveCommands
  
  Create a SHA1 digest from a Lua script.
  
  Specified by:
  
  digest in interface RedisScriptingReactiveCommands<K,V>
  
  Parameters:
  
  script - script content.
  
  Returns:
  
  the SHA1 value.
- digest
  
  public String digest(byte[] script)
  
  Description copied from interface: RedisScriptingReactiveCommands
  
  Create a SHA1 digest from a Lua script.
  
  Specified by:
  
  digest in interface RedisScriptingReactiveCommands<K,V>
  
  Parameters:
  
  script - script content.
  
  Returns:
  
  the SHA1 value.
- discard
  
  public Mono<String> discard()
  
  Description copied from interface: RedisTransactionalReactiveCommands
  
  Discard all commands issued after MULTI.
  
  Specified by:
  
  discard in interface RedisTransactionalReactiveCommands<K,V>
  
  Returns:
  
  String simple-string-reply always OK.
- dispatch
  
  public <T> Flux<T> dispatch(ProtocolKeyword type, CommandOutput<K,V,?> output)
  
  Description copied from interface: BaseRedisReactiveCommands
  
  Dispatch a command to the Redis Server. Please note the command output type must fit to the command response.
  
  Specified by:
  
  dispatch in interface BaseRedisReactiveCommands<K,V>
  
  Type Parameters:
  
  T - response type.
  
  Parameters:
  
  type - the command, must not be null.
  
  output - the command output, must not be null.
  
  Returns:
  
  the command response.
- dispatch
  
  public <T> Flux<T> dispatch(ProtocolKeyword type, CommandOutput<K,V,?> output, CommandArgs<K,V> args)
  
  Description copied from interface: BaseRedisReactiveCommands
  
  Dispatch a command to the Redis Server. Please note the command output type must fit to the command response.
  
  Specified by:
  
  dispatch in interface BaseRedisReactiveCommands<K,V>
  
  Type Parameters:
  
  T - response type.
  
  Parameters:
  
  type - the command, must not be null.
  
  output - the command output, must not be null.
  
  args - the command arguments, must not be null.
  
  Returns:
  
  the command response.
- dump
  
  public Mono<byte[]> dump(K key)
  
  Description copied from interface: RedisKeyReactiveCommands
  
  Return a serialized version of the value stored at the specified key.
  
  Specified by:
  
  dump in interface RedisKeyReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  Returns:
  
  byte[] bulk-string-reply the serialized value.
- echo
  
  public Mono<V> echo(V msg)
  
  Description copied from interface: BaseRedisReactiveCommands
  
  Echo the given string.
  
  Specified by:
  
  echo in interface BaseRedisReactiveCommands<K,V>
  
  Parameters:
  
  msg - the message type: value.
  
  Returns:
  
  V bulk-string-reply.
- eval
  
  public <T> Flux<T> eval(String script, ScriptOutputType type, K... keys)
  
  Description copied from interface: RedisScriptingReactiveCommands
  
  Execute a Lua script server side.
  
  Specified by:
  
  eval in interface RedisScriptingReactiveCommands<K,V>
  
  Type Parameters:
  
  T - expected return type.
  
  Parameters:
  
  script - Lua 5.1 script.
  
  type - output type.
  
  keys - key names.
  
  Returns:
  
  script result.
- eval
  
  public <T> Flux<T> eval(byte[] script, ScriptOutputType type, K... keys)
  
  Description copied from interface: RedisScriptingReactiveCommands
  
  Execute a Lua script server side.
  
  Specified by:
  
  eval in interface RedisScriptingReactiveCommands<K,V>
  
  Type Parameters:
  
  T - expected return type.
  
  Parameters:
  
  script - Lua 5.1 script.
  
  type - output type.
  
  keys - key names.
  
  Returns:
  
  script result.
- eval
  
  public <T> Flux<T> eval(String script, ScriptOutputType type, K[] keys, V... values)
  
  Description copied from interface: RedisScriptingReactiveCommands
  
  Execute a Lua script server side.
  
  Specified by:
  
  eval in interface RedisScriptingReactiveCommands<K,V>
  
  Type Parameters:
  
  T - expected return type.
  
  Parameters:
  
  script - Lua 5.1 script.
  
  type - the type.
  
  keys - the keys.
  
  values - the values.
  
  Returns:
  
  script result.
- eval
  
  public <T> Flux<T> eval(byte[] script, ScriptOutputType type, K[] keys, V... values)
  
  Description copied from interface: RedisScriptingReactiveCommands
  
  Execute a Lua script server side.
  
  Specified by:
  
  eval in interface RedisScriptingReactiveCommands<K,V>
  
  Type Parameters:
  
  T - expected return type.
  
  Parameters:
  
  script - Lua 5.1 script.
  
  type - the type.
  
  keys - the keys.
  
  values - the values.
  
  Returns:
  
  script result.
- evalsha
  
  public <T> Flux<T> evalsha(String digest, ScriptOutputType type, K... keys)
  
  Description copied from interface: RedisScriptingReactiveCommands
  
  Evaluates a script cached on the server side by its SHA1 digest.
  
  Specified by:
  
  evalsha in interface RedisScriptingReactiveCommands<K,V>
  
  Type Parameters:
  
  T - expected return type.
  
  Parameters:
  
  digest - SHA1 of the script.
  
  type - the type.
  
  keys - the keys.
  
  Returns:
  
  script result.
- evalsha
  
  public <T> Flux<T> evalsha(String digest, ScriptOutputType type, K[] keys, V... values)
  
  Description copied from interface: RedisScriptingReactiveCommands
  
  Execute a Lua script server side.
  
  Specified by:
  
  evalsha in interface RedisScriptingReactiveCommands<K,V>
  
  Type Parameters:
  
  T - expected return type.
  
  Parameters:
  
  digest - SHA1 of the script.
  
  type - the type.
  
  keys - the keys.
  
  values - the values.
  
  Returns:
  
  script result.
- exec
  
  public Mono<TransactionResult> exec()
  
  Description copied from interface: RedisTransactionalReactiveCommands
  
  Execute all commands issued after MULTI.
  
  Specified by:
  
  exec in interface RedisTransactionalReactiveCommands<K,V>
  
  Returns:
  
  Object array-reply each element being the reply to each of the commands in the atomic transaction. When using WATCH, EXEC can return a discarded TransactionResult.
  
  See Also:
  
  TransactionResult.wasDiscarded()
- exists
  
  public Mono<Boolean> exists(K key)
- exists
  
  public Mono<Long> exists(K... keys)
  
  Description copied from interface: RedisKeyReactiveCommands
  
  Determine how many keys exist.
  
  Specified by:
  
  exists in interface RedisKeyReactiveCommands<K,V>
  
  Parameters:
  
  keys - the keys.
  
  Returns:
  
  Long integer-reply specifically: Number of existing keys.
- exists
  
  public Mono<Long> exists(Iterable<K> keys)
- expire
  
  public Mono<Boolean> expire(K key, long seconds)
  
  Description copied from interface: RedisKeyReactiveCommands
  
  Set a key's time to live in seconds.
  
  Specified by:
  
  expire in interface RedisKeyReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  seconds - the seconds type: long.
  
  Returns:
  
  Boolean integer-reply specifically: true if the timeout was set. false if key does not exist or the timeout could not be set.
- expire
  
  public Mono<Boolean> expire(K key, Duration seconds)
  
  Description copied from interface: RedisKeyReactiveCommands
  
  Set a key's time to live in seconds.
  
  Specified by:
  
  expire in interface RedisKeyReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  seconds - the seconds.
  
  Returns:
  
  Boolean integer-reply specifically: true if the timeout was set. false if key does not exist or the timeout could not be set.
- expireat
  
  public Mono<Boolean> expireat(K key, long timestamp)
  
  Description copied from interface: RedisKeyReactiveCommands
  
  Set the expiration for a key as a UNIX timestamp.
  
  Specified by:
  
  expireat in interface RedisKeyReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  timestamp - the timestamp type: posix time.
  
  Returns:
  
  Boolean integer-reply specifically: true if the timeout was set. false if key does not exist or the timeout could not be set (see: EXPIRE).
- expireat
  
  public Mono<Boolean> expireat(K key, Date timestamp)
  
  Description copied from interface: RedisKeyReactiveCommands
  
  Set the expiration for a key as a UNIX timestamp.
  
  Specified by:
  
  expireat in interface RedisKeyReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  timestamp - the timestamp type: posix time.
  
  Returns:
  
  Boolean integer-reply specifically: true if the timeout was set. false if key does not exist or the timeout could not be set (see: EXPIRE).
- expireat
  
  public Mono<Boolean> expireat(K key, Instant timestamp)
  
  Description copied from interface: RedisKeyReactiveCommands
  
  Set the expiration for a key as a UNIX timestamp.
  
  Specified by:
  
  expireat in interface RedisKeyReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  timestamp - the timestamp type: posix time.
  
  Returns:
  
  Boolean integer-reply specifically: true if the timeout was set. false if key does not exist or the timeout could not be set (see: EXPIRE).
- flushCommands
  
  public void flushCommands()
  
  Description copied from interface: BaseRedisReactiveCommands
  
  Flush pending commands. This commands forces a flush on the channel and can be used to buffer ("pipeline") commands to achieve batching. No-op if channel is not connected.
  
  Specified by:
  
  flushCommands in interface BaseRedisReactiveCommands<K,V>
- flushall
  
  public Mono<String> flushall()
  
  Description copied from interface: RedisServerReactiveCommands
  
  Remove all keys from all databases.
  
  Specified by:
  
  flushall in interface RedisServerReactiveCommands<K,V>
  
  Returns:
  
  String simple-string-reply.
- flushall
  
  public Mono<String> flushall(FlushMode flushMode)
  
  Description copied from interface: RedisServerReactiveCommands
  
  Remove all keys from all databases using the specified FlushMode.
  
  Specified by:
  
  flushall in interface RedisServerReactiveCommands<K,V>
  
  Parameters:
  
  flushMode - the flush mode (sync/asnync).
  
  Returns:
  
  String simple-string-reply.
- flushallAsync
  
  public Mono<String> flushallAsync()
  
  Description copied from interface: RedisServerReactiveCommands
  
  Remove all keys asynchronously from all databases.
  
  Specified by:
  
  flushallAsync in interface RedisServerReactiveCommands<K,V>
  
  Returns:
  
  String simple-string-reply.
- flushdb
  
  public Mono<String> flushdb()
  
  Description copied from interface: RedisServerReactiveCommands
  
  Remove all keys from the current database.
  
  Specified by:
  
  flushdb in interface RedisServerReactiveCommands<K,V>
  
  Returns:
  
  String simple-string-reply.
- flushdb
  
  public Mono<String> flushdb(FlushMode flushMode)
  
  Description copied from interface: RedisServerReactiveCommands
  
  Remove all keys from the current database using the specified FlushMode.
  
  Specified by:
  
  flushdb in interface RedisServerReactiveCommands<K,V>
  
  Parameters:
  
  flushMode - the flush mode (sync/asnync).
  
  Returns:
  
  String simple-string-reply.
- flushdbAsync
  
  public Mono<String> flushdbAsync()
  
  Description copied from interface: RedisServerReactiveCommands
  
  Remove all keys asynchronously from the current database.
  
  Specified by:
  
  flushdbAsync in interface RedisServerReactiveCommands<K,V>
  
  Returns:
  
  String simple-string-reply.
- geoadd
  
  public Mono<Long> geoadd(K key, double longitude, double latitude, V member)
  
  Description copied from interface: RedisGeoReactiveCommands
  
  Single geo add.
  
  Specified by:
  
  geoadd in interface RedisGeoReactiveCommands<K,V>
  
  Parameters:
  
  key - the key of the geo set.
  
  longitude - the longitude coordinate according to WGS84.
  
  latitude - the latitude coordinate according to WGS84.
  
  member - the member to add.
  
  Returns:
  
  Long integer-reply the number of elements that were added to the set.
- geoadd
  
  public Mono<Long> geoadd(K key, double longitude, double latitude, V member, GeoAddArgs args)
  
  Description copied from interface: RedisGeoReactiveCommands
  
  Single geo add.
  
  Specified by:
  
  geoadd in interface RedisGeoReactiveCommands<K,V>
  
  Parameters:
  
  key - the key of the geo set.
  
  longitude - the longitude coordinate according to WGS84.
  
  latitude - the latitude coordinate according to WGS84.
  
  member - the member to add.
  
  args - additional arguments.
  
  Returns:
  
  Long integer-reply the number of elements that were added to the set.
- geoadd
  
  public Mono<Long> geoadd(K key, Object... lngLatMember)
  
  Description copied from interface: RedisGeoReactiveCommands
  
  Multi geo add.
  
  Specified by:
  
  geoadd in interface RedisGeoReactiveCommands<K,V>
  
  Parameters:
  
  key - the key of the geo set.
  
  lngLatMember - triplets of double longitude, double latitude and V member.
  
  Returns:
  
  Long integer-reply the number of elements that were added to the set.
- geoadd
  
  public Mono<Long> geoadd(K key, GeoValue<V>... values)
  
  Description copied from interface: RedisGeoReactiveCommands
  
  Multi geo add.
  
  Specified by:
  
  geoadd in interface RedisGeoReactiveCommands<K,V>
  
  Parameters:
  
  key - the key of the geo set.
  
  values - GeoValue values to add.
  
  Returns:
  
  Long integer-reply the number of elements that were added to the set.
- geoadd
  
  public Mono<Long> geoadd(K key, GeoAddArgs args, Object... lngLatMember)
  
  Description copied from interface: RedisGeoReactiveCommands
  
  Multi geo add.
  
  Specified by:
  
  geoadd in interface RedisGeoReactiveCommands<K,V>
  
  Parameters:
  
  key - the key of the geo set.
  
  args - additional arguments.
  
  lngLatMember - triplets of double longitude, double latitude and V member.
  
  Returns:
  
  Long integer-reply the number of elements that were added to the set.
- geoadd
  
  public Mono<Long> geoadd(K key, GeoAddArgs args, GeoValue<V>... values)
  
  Description copied from interface: RedisGeoReactiveCommands
  
  Multi geo add.
  
  Specified by:
  
  geoadd in interface RedisGeoReactiveCommands<K,V>
  
  Parameters:
  
  key - the key of the geo set.
  
  args - additional arguments.
  
  values - GeoValue values to add.
  
  Returns:
  
  Long integer-reply the number of elements that were added to the set.
- geodist
  
  public Mono<Double> geodist(K key, V from, V to, GeoArgs.Unit unit)
  
  Description copied from interface: RedisGeoReactiveCommands
  
  Retrieve distance between points from and to. If one or more elements are missing null is returned. Default in meters by, otherwise according to unit
  
  Specified by:
  
  geodist in interface RedisGeoReactiveCommands<K,V>
  
  Parameters:
  
  key - the key of the geo set.
  
  from - from member.
  
  to - to member.
  
  unit - distance unit.
  
  Returns:
  
  distance between points from and to. If one or more elements are missing null is returned.
- geohash
  
  public Flux<Value<String>> geohash(K key, V... members)
  
  Description copied from interface: RedisGeoReactiveCommands
  
  Retrieve Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index.
  
  Specified by:
  
  geohash in interface RedisGeoReactiveCommands<K,V>
  
  Parameters:
  
  key - the key of the geo set.
  
  members - the members.
  
  Returns:
  
  bulk reply Geohash strings in the order of members. Returns null if a member is not found.
- geopos
  
  public Flux<Value<GeoCoordinates>> geopos(K key, V... members)
  
  Description copied from interface: RedisGeoReactiveCommands
  
  Get geo coordinates for the members.
  
  Specified by:
  
  geopos in interface RedisGeoReactiveCommands<K,V>
  
  Parameters:
  
  key - the key of the geo set.
  
  members - the members.
  
  Returns:
  
  a list of GeoCoordinatess representing the x,y position of each element specified in the arguments. For missing elements null is returned.
- georadius
  
  public Flux<V> georadius(K key, double longitude, double latitude, double distance, GeoArgs.Unit unit)
  
  Description copied from interface: RedisGeoReactiveCommands
  
  Retrieve members selected by distance with the center of longitude and latitude.
  
  Specified by:
  
  georadius in interface RedisGeoReactiveCommands<K,V>
  
  Parameters:
  
  key - the key of the geo set.
  
  longitude - the longitude coordinate according to WGS84.
  
  latitude - the latitude coordinate according to WGS84.
  
  distance - radius distance.
  
  unit - distance unit.
  
  Returns:
  
  bulk reply.
- georadius
  
  public Flux<GeoWithin<V>> georadius(K key, double longitude, double latitude, double distance, GeoArgs.Unit unit, GeoArgs geoArgs)
  
  Description copied from interface: RedisGeoReactiveCommands
  
  Retrieve members selected by distance with the center of longitude and latitude.
  
  Specified by:
  
  georadius in interface RedisGeoReactiveCommands<K,V>
  
  Parameters:
  
  key - the key of the geo set.
  
  longitude - the longitude coordinate according to WGS84.
  
  latitude - the latitude coordinate according to WGS84.
  
  distance - radius distance.
  
  unit - distance unit.
  
  geoArgs - args to control the result.
  
  Returns:
  
  nested multi-bulk reply. The GeoWithin contains only fields which were requested by GeoArgs.
- georadius
  
  public Mono<Long> georadius(K key, double longitude, double latitude, double distance, GeoArgs.Unit unit, GeoRadiusStoreArgs<K> geoRadiusStoreArgs)
  
  Description copied from interface: RedisGeoReactiveCommands
  
  Perform a RedisGeoReactiveCommands.georadius(Object, double, double, double, GeoArgs.Unit, GeoArgs) query and store the results in a sorted set.
  
  Specified by:
  
  georadius in interface RedisGeoReactiveCommands<K,V>
  
  Parameters:
  
  key - the key of the geo set.
  
  longitude - the longitude coordinate according to WGS84.
  
  latitude - the latitude coordinate according to WGS84.
  
  distance - radius distance.
  
  unit - distance unit.
  
  geoRadiusStoreArgs - args to store either the resulting elements with their distance or the resulting elements with their locations a sorted set.
  
  Returns:
  
  Long integer-reply the number of elements in the result.
- georadius_ro
  
  protected Flux<V> georadius_ro(K key, double longitude, double latitude, double distance, GeoArgs.Unit unit)
- georadius_ro
  
  protected Flux<GeoWithin<V>> georadius_ro(K key, double longitude, double latitude, double distance, GeoArgs.Unit unit, GeoArgs geoArgs)
- georadiusbymember
  
  public Flux<V> georadiusbymember(K key, V member, double distance, GeoArgs.Unit unit)
  
  Description copied from interface: RedisGeoReactiveCommands
  
  Retrieve members selected by distance with the center of member. The member itself is always contained in the results.
  
  Specified by:
  
  georadiusbymember in interface RedisGeoReactiveCommands<K,V>
  
  Parameters:
  
  key - the key of the geo set.
  
  member - reference member.
  
  distance - radius distance.
  
  unit - distance unit.
  
  Returns:
  
  set of members.
- georadiusbymember
  
  public Flux<GeoWithin<V>> georadiusbymember(K key, V member, double distance, GeoArgs.Unit unit, GeoArgs geoArgs)
  
  Description copied from interface: RedisGeoReactiveCommands
  
  Retrieve members selected by distance with the center of member. The member itself is always contained in the results.
  
  Specified by:
  
  georadiusbymember in interface RedisGeoReactiveCommands<K,V>
  
  Parameters:
  
  key - the key of the geo set.
  
  member - reference member.
  
  distance - radius distance.
  
  unit - distance unit.
  
  geoArgs - args to control the result.
  
  Returns:
  
  nested multi-bulk reply. The GeoWithin contains only fields which were requested by GeoArgs.
- georadiusbymember
  
  public Mono<Long> georadiusbymember(K key, V member, double distance, GeoArgs.Unit unit, GeoRadiusStoreArgs<K> geoRadiusStoreArgs)
  
  Description copied from interface: RedisGeoReactiveCommands
  
  Perform a RedisGeoReactiveCommands.georadiusbymember(Object, Object, double, GeoArgs.Unit, GeoArgs) query and store the results in a sorted set.
  
  Specified by:
  
  georadiusbymember in interface RedisGeoReactiveCommands<K,V>
  
  Parameters:
  
  key - the key of the geo set.
  
  member - reference member.
  
  distance - radius distance.
  
  unit - distance unit.
  
  geoRadiusStoreArgs - args to store either the resulting elements with their distance or the resulting elements with their locations a sorted set.
  
  Returns:
  
  Long integer-reply the number of elements in the result.
- georadiusbymember_ro
  
  protected Flux<V> georadiusbymember_ro(K key, V member, double distance, GeoArgs.Unit unit)
- georadiusbymember_ro
  
  protected Flux<GeoWithin<V>> georadiusbymember_ro(K key, V member, double distance, GeoArgs.Unit unit, GeoArgs geoArgs)
- geosearch
  
  public Flux<V> geosearch(K key, GeoSearch.GeoRef<K> reference, GeoSearch.GeoPredicate predicate)
  
  Description copied from interface: RedisGeoReactiveCommands
  
  Retrieve members selected by distance with the center of reference the search predicate. Use GeoSearch to create reference and predicate objects.
  
  Specified by:
  
  geosearch in interface RedisGeoReactiveCommands<K,V>
  
  Parameters:
  
  key - the key of the geo set.
  
  reference - the reference member or longitude/latitude coordinates.
  
  predicate - the bounding box or radius to search in.
  
  Returns:
  
  bulk reply.
- geosearch
  
  public Flux<GeoWithin<V>> geosearch(K key, GeoSearch.GeoRef<K> reference, GeoSearch.GeoPredicate predicate, GeoArgs geoArgs)
  
  Description copied from interface: RedisGeoReactiveCommands
  
  Retrieve members selected by distance with the center of reference the search predicate. Use GeoSearch to create reference and predicate objects.
  
  Specified by:
  
  geosearch in interface RedisGeoReactiveCommands<K,V>
  
  Parameters:
  
  key - the key of the geo set.
  
  reference - the reference member or longitude/latitude coordinates.
  
  predicate - the bounding box or radius to search in.
  
  geoArgs - args to control the result.
  
  Returns:
  
  nested multi-bulk reply. The GeoWithin contains only fields which were requested by GeoArgs.
- geosearchstore
  
  public Mono<Long> geosearchstore(K destination, K key, GeoSearch.GeoRef<K> reference, GeoSearch.GeoPredicate predicate, GeoArgs geoArgs, boolean storeDist)
  
  Description copied from interface: RedisGeoReactiveCommands
  
  Perform a RedisGeoReactiveCommands.geosearch(Object, GeoSearch.GeoRef, GeoSearch.GeoPredicate, GeoArgs) query and store the results in a sorted set.
  
  Specified by:
  
  geosearchstore in interface RedisGeoReactiveCommands<K,V>
  
  Parameters:
  
  destination - the destination where to store results.
  
  key - the key of the geo set.
  
  reference - the reference member or longitude/latitude coordinates.
  
  predicate - the bounding box or radius to search in.
  
  geoArgs - args to control the result.
  
  storeDist - stores the items in a sorted set populated with their distance from the center of the circle or box, as a floating-point number, in the same unit specified for that shape.
  
  Returns:
  
  Long integer-reply the number of elements in the result.
- get
  
  public Mono<V> get(K key)
  
  Description copied from interface: RedisStringReactiveCommands
  
  Get the value of a key.
  
  Specified by:
  
  get in interface RedisStringReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  Returns:
  
  V bulk-string-reply the value of key, or null when key does not exist.
- getConnection
  
  public StatefulConnection<K,V> getConnection()
- getbit
  
  public Mono<Long> getbit(K key, long offset)
  
  Description copied from interface: RedisStringReactiveCommands
  
  Returns the bit value at offset in the string value stored at key.
  
  Specified by:
  
  getbit in interface RedisStringReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  offset - the offset type: long.
  
  Returns:
  
  Long integer-reply the bit value stored at offset.
- getdel
  
  public Mono<V> getdel(K key)
  
  Description copied from interface: RedisStringReactiveCommands
  
  Get the value of key and delete the key.
  
  Specified by:
  
  getdel in interface RedisStringReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  Returns:
  
  V bulk-string-reply the value of key, or null when key does not exist.
- getex
  
  public Mono<V> getex(K key, GetExArgs args)
  
  Description copied from interface: RedisStringReactiveCommands
  
  Get the value of key and optionally set its expiration.
  
  Specified by:
  
  getex in interface RedisStringReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  args - the arguments for GETEX.
  
  Returns:
  
  V bulk-string-reply the value of key, or null when key does not exist.
- getrange
  
  public Mono<V> getrange(K key, long start, long end)
  
  Description copied from interface: RedisStringReactiveCommands
  
  Get a substring of the string stored at a key.
  
  Specified by:
  
  getrange in interface RedisStringReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  start - the start type: long.
  
  end - the end type: long.
  
  Returns:
  
  V bulk-string-reply.
- getset
  
  public Mono<V> getset(K key, V value)
  
  Description copied from interface: RedisStringReactiveCommands
  
  Set the string value of a key and return its old value.
  
  Specified by:
  
  getset in interface RedisStringReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  value - the value.
  
  Returns:
  
  V bulk-string-reply the old value stored at key, or null when key did not exist.
- hdel
  
  public Mono<Long> hdel(K key, K... fields)
  
  Description copied from interface: RedisHashReactiveCommands
  
  Delete one or more hash fields.
  
  Specified by:
  
  hdel in interface RedisHashReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  fields - the field type: key.
  
  Returns:
  
  Long integer-reply the number of fields that were removed from the hash, not including specified but non existing fields.
- hexists
  
  public Mono<Boolean> hexists(K key, K field)
  
  Description copied from interface: RedisHashReactiveCommands
  
  Determine if a hash field exists.
  
  Specified by:
  
  hexists in interface RedisHashReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  field - the field type: key.
  
  Returns:
  
  Boolean integer-reply specifically: true if the hash contains field. false if the hash does not contain field, or key does not exist.
- hget
  
  public Mono<V> hget(K key, K field)
  
  Description copied from interface: RedisHashReactiveCommands
  
  Get the value of a hash field.
  
  Specified by:
  
  hget in interface RedisHashReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  field - the field type: key.
  
  Returns:
  
  V bulk-string-reply the value associated with field, or null when field is not present in the hash or key does not exist.
- hgetall
  
  public Flux<KeyValue<K,V>> hgetall(K key)
  
  Description copied from interface: RedisHashReactiveCommands
  
  Get all the fields and values in a hash.
  
  Specified by:
  
  hgetall in interface RedisHashReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  Returns:
  
  Map<K,V> array-reply list of fields and their values stored in the hash, or an empty list when key does not exist.
- hgetall
  
  public Mono<Long> hgetall(KeyValueStreamingChannel<K,V> channel, K key)
  
  Description copied from interface: RedisHashReactiveCommands
  
  Stream over all the fields and values in a hash.
  
  Specified by:
  
  hgetall in interface RedisHashReactiveCommands<K,V>
  
  Parameters:
  
  channel - the channel.
  
  key - the key.
  
  Returns:
  
  Long count of the keys.
- hincrby
  
  public Mono<Long> hincrby(K key, K field, long amount)
  
  Description copied from interface: RedisHashReactiveCommands
  
  Increment the integer value of a hash field by the given number.
  
  Specified by:
  
  hincrby in interface RedisHashReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  field - the field type: key.
  
  amount - the increment type: long.
  
  Returns:
  
  Long integer-reply the value at field after the increment operation.
- hincrbyfloat
  
  public Mono<Double> hincrbyfloat(K key, K field, double amount)
  
  Description copied from interface: RedisHashReactiveCommands
  
  Increment the float value of a hash field by the given amount.
  
  Specified by:
  
  hincrbyfloat in interface RedisHashReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  field - the field type: key.
  
  amount - the increment type: double.
  
  Returns:
  
  Double bulk-string-reply the value of field after the increment.
- hkeys
  
  public Flux<K> hkeys(K key)
  
  Description copied from interface: RedisHashReactiveCommands
  
  Get all the fields in a hash.
  
  Specified by:
  
  hkeys in interface RedisHashReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  Returns:
  
  K array-reply list of fields in the hash, or an empty list when key does not exist.
- hkeys
  
  public Mono<Long> hkeys(KeyStreamingChannel<K> channel, K key)
  
  Description copied from interface: RedisHashReactiveCommands
  
  Stream over all the fields in a hash.
  
  Specified by:
  
  hkeys in interface RedisHashReactiveCommands<K,V>
  
  Parameters:
  
  channel - the channel.
  
  key - the key.
  
  Returns:
  
  Long count of the keys.
- hlen
  
  public Mono<Long> hlen(K key)
  
  Description copied from interface: RedisHashReactiveCommands
  
  Get the number of fields in a hash.
  
  Specified by:
  
  hlen in interface RedisHashReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  Returns:
  
  Long integer-reply number of fields in the hash, or 0 when key does not exist.
- hmget
  
  public Flux<KeyValue<K,V>> hmget(K key, K... fields)
  
  Description copied from interface: RedisHashReactiveCommands
  
  Get the values of all the given hash fields.
  
  Specified by:
  
  hmget in interface RedisHashReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  fields - the field type: key.
  
  Returns:
  
  V array-reply list of values associated with the given fields, in the same.
- hmget
  
  public Mono<Long> hmget(KeyValueStreamingChannel<K,V> channel, K key, K... fields)
  
  Description copied from interface: RedisHashReactiveCommands
  
  Stream over the values of all the given hash fields.
  
  Specified by:
  
  hmget in interface RedisHashReactiveCommands<K,V>
  
  Parameters:
  
  channel - the channel.
  
  key - the key.
  
  fields - the fields.
  
  Returns:
  
  Long count of the keys.
- hrandfield
  
  public Mono<K> hrandfield(K key)
  
  Description copied from interface: RedisHashReactiveCommands
  
  Return a random field from the hash stored at key.
  
  Specified by:
  
  hrandfield in interface RedisHashReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  Returns:
  
  hash field name.
- hrandfield
  
  public Flux<K> hrandfield(K key, long count)
  
  Description copied from interface: RedisHashReactiveCommands
  
  Return count random fields from the hash stored at key.
  
  Specified by:
  
  hrandfield in interface RedisHashReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  count - the number of fields to return. If the provided count argument is positive, return an array of distinct fields.
  
  Returns:
  
  array-reply list of field names.
- hrandfieldWithvalues
  
  public Mono<KeyValue<K,V>> hrandfieldWithvalues(K key)
  
  Description copied from interface: RedisHashReactiveCommands
  
  Return a random field along its value from the hash stored at key.
  
  Specified by:
  
  hrandfieldWithvalues in interface RedisHashReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  Returns:
  
  array-reply the key and value.
- hrandfieldWithvalues
  
  public Flux<KeyValue<K,V>> hrandfieldWithvalues(K key, long count)
  
  Description copied from interface: RedisHashReactiveCommands
  
  Return count random fields along their value from the hash stored at key.
  
  Specified by:
  
  hrandfieldWithvalues in interface RedisHashReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  count - the number of fields to return. If the provided count argument is positive, return an array of distinct fields.
  
  Returns:
  
  array-reply the keys and values.
- hmset
  
  public Mono<String> hmset(K key, Map<K,V> map)
  
  Description copied from interface: RedisHashReactiveCommands
  
  Set multiple hash fields to multiple values.
  
  Specified by:
  
  hmset in interface RedisHashReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  map - the hash to apply.
  
  Returns:
  
  String simple-string-reply.
- hscan
  
  public Mono<MapScanCursor<K,V>> hscan(K key)
  
  Description copied from interface: RedisHashReactiveCommands
  
  Incrementally iterate hash fields and associated values.
  
  Specified by:
  
  hscan in interface RedisHashReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  Returns:
  
  MapScanCursor<K, V> map scan cursor.
- hscan
  
  public Mono<MapScanCursor<K,V>> hscan(K key, ScanArgs scanArgs)
  
  Description copied from interface: RedisHashReactiveCommands
  
  Incrementally iterate hash fields and associated values.
  
  Specified by:
  
  hscan in interface RedisHashReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  scanArgs - scan arguments.
  
  Returns:
  
  MapScanCursor<K, V> map scan cursor.
- hscan
  
  public Mono<MapScanCursor<K,V>> hscan(K key, ScanCursor scanCursor, ScanArgs scanArgs)
  
  Description copied from interface: RedisHashReactiveCommands
  
  Incrementally iterate hash fields and associated values.
  
  Specified by:
  
  hscan in interface RedisHashReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  scanCursor - cursor to resume from a previous scan, must not be null.
  
  scanArgs - scan arguments.
  
  Returns:
  
  MapScanCursor<K, V> map scan cursor.
- hscan
  
  public Mono<MapScanCursor<K,V>> hscan(K key, ScanCursor scanCursor)
  
  Description copied from interface: RedisHashReactiveCommands
  
  Incrementally iterate hash fields and associated values.
  
  Specified by:
  
  hscan in interface RedisHashReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  scanCursor - cursor to resume from a previous scan, must not be null.
  
  Returns:
  
  MapScanCursor<K, V> map scan cursor.
- hscan
  
  public Mono<StreamScanCursor> hscan(KeyValueStreamingChannel<K,V> channel, K key)
  
  Description copied from interface: RedisHashReactiveCommands
  
  Incrementally iterate hash fields and associated values.
  
  Specified by:
  
  hscan in interface RedisHashReactiveCommands<K,V>
  
  Parameters:
  
  channel - streaming channel that receives a call for every key-value pair.
  
  key - the key.
  
  Returns:
  
  StreamScanCursor scan cursor.
- hscan
  
  public Mono<StreamScanCursor> hscan(KeyValueStreamingChannel<K,V> channel, K key, ScanArgs scanArgs)
  
  Description copied from interface: RedisHashReactiveCommands
  
  Incrementally iterate hash fields and associated values.
  
  Specified by:
  
  hscan in interface RedisHashReactiveCommands<K,V>
  
  Parameters:
  
  channel - streaming channel that receives a call for every key-value pair.
  
  key - the key.
  
  scanArgs - scan arguments.
  
  Returns:
  
  StreamScanCursor scan cursor.
- hscan
  
  public Mono<StreamScanCursor> hscan(KeyValueStreamingChannel<K,V> channel, K key, ScanCursor scanCursor, ScanArgs scanArgs)
  
  Description copied from interface: RedisHashReactiveCommands
  
  Incrementally iterate hash fields and associated values.
  
  Specified by:
  
  hscan in interface RedisHashReactiveCommands<K,V>
  
  Parameters:
  
  channel - streaming channel that receives a call for every key-value pair.
  
  key - the key.
  
  scanCursor - cursor to resume from a previous scan, must not be null.
  
  scanArgs - scan arguments.
  
  Returns:
  
  StreamScanCursor scan cursor.
- hscan
  
  public Mono<StreamScanCursor> hscan(KeyValueStreamingChannel<K,V> channel, K key, ScanCursor scanCursor)
  
  Description copied from interface: RedisHashReactiveCommands
  
  Incrementally iterate hash fields and associated values.
  
  Specified by:
  
  hscan in interface RedisHashReactiveCommands<K,V>
  
  Parameters:
  
  channel - streaming channel that receives a call for every key-value pair.
  
  key - the key.
  
  scanCursor - cursor to resume from a previous scan, must not be null.
  
  Returns:
  
  StreamScanCursor scan cursor.
- hset
  
  public Mono<Boolean> hset(K key, K field, V value)
  
  Description copied from interface: RedisHashReactiveCommands
  
  Set the string value of a hash field.
  
  Specified by:
  
  hset in interface RedisHashReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  field - the field type: key.
  
  value - the value.
  
  Returns:
  
  Boolean integer-reply specifically: true if field is a new field in the hash and value was set. false if field already exists in the hash and the value was updated.
- hset
  
  public Mono<Long> hset(K key, Map<K,V> map)
  
  Description copied from interface: RedisHashReactiveCommands
  
  Set multiple hash fields to multiple values.
  
  Specified by:
  
  hset in interface RedisHashReactiveCommands<K,V>
  
  Parameters:
  
  key - the key of the hash.
  
  map - the field/value pairs to update.
  
  Returns:
  
  Long integer-reply: the number of fields that were added.
- hsetnx
  
  public Mono<Boolean> hsetnx(K key, K field, V value)
  
  Description copied from interface: RedisHashReactiveCommands
  
  Set the value of a hash field, only if the field does not exist.
  
  Specified by:
  
  hsetnx in interface RedisHashReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  field - the field type: key.
  
  value - the value.
  
  Returns:
  
  Boolean integer-reply specifically: 1 if field is a new field in the hash and value was set. 0 if field already exists in the hash and no operation was performed.
- hstrlen
  
  public Mono<Long> hstrlen(K key, K field)
  
  Description copied from interface: RedisHashReactiveCommands
  
  Get the string length of the field value in a hash.
  
  Specified by:
  
  hstrlen in interface RedisHashReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  field - the field type: key.
  
  Returns:
  
  Long integer-reply the string length of the field value, or 0 when field is not present in the hash or key does not exist at all.
- hvals
  
  public Flux<V> hvals(K key)
  
  Description copied from interface: RedisHashReactiveCommands
  
  Get all the values in a hash.
  
  Specified by:
  
  hvals in interface RedisHashReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  Returns:
  
  V array-reply list of values in the hash, or an empty list when key does not exist.
- hvals
  
  public Mono<Long> hvals(ValueStreamingChannel<V> channel, K key)
  
  Description copied from interface: RedisHashReactiveCommands
  
  Stream over all the values in a hash.
  
  Specified by:
  
  hvals in interface RedisHashReactiveCommands<K,V>
  
  Parameters:
  
  channel - streaming channel that receives a call for every value.
  
  key - the key.
  
  Returns:
  
  Long count of the keys.
- incr
  
  public Mono<Long> incr(K key)
  
  Description copied from interface: RedisStringReactiveCommands
  
  Increment the integer value of a key by one.
  
  Specified by:
  
  incr in interface RedisStringReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  Returns:
  
  Long integer-reply the value of key after the increment.
- incrby
  
  public Mono<Long> incrby(K key, long amount)
  
  Description copied from interface: RedisStringReactiveCommands
  
  Increment the integer value of a key by the given amount.
  
  Specified by:
  
  incrby in interface RedisStringReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  amount - the increment type: long.
  
  Returns:
  
  Long integer-reply the value of key after the increment.
- incrbyfloat
  
  public Mono<Double> incrbyfloat(K key, double amount)
  
  Description copied from interface: RedisStringReactiveCommands
  
  Increment the float value of a key by the given amount.
  
  Specified by:
  
  incrbyfloat in interface RedisStringReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  amount - the increment type: double.
  
  Returns:
  
  Double bulk-string-reply the value of key after the increment.
- info
  
  public Mono<String> info()
  
  Description copied from interface: RedisServerReactiveCommands
  
  Get information and statistics about the server.
  
  Specified by:
  
  info in interface RedisServerReactiveCommands<K,V>
  
  Returns:
  
  String bulk-string-reply as a collection of text lines.
- info
  
  public Mono<String> info(String section)
  
  Description copied from interface: RedisServerReactiveCommands
  
  Get information and statistics about the server.
  
  Specified by:
  
  info in interface RedisServerReactiveCommands<K,V>
  
  Parameters:
  
  section - the section type: string.
  
  Returns:
  
  String bulk-string-reply as a collection of text lines.
- isOpen
  
  public boolean isOpen()
  
  Specified by:
  
  isOpen in interface BaseRedisReactiveCommands<K,V>
  
  Returns:
  
  true if the connection is open (connected and not closed).
- keys
  
  public Flux<K> keys(K pattern)
  
  Description copied from interface: RedisKeyReactiveCommands
  
  Find all keys matching the given pattern.
  
  Specified by:
  
  keys in interface RedisKeyReactiveCommands<K,V>
  
  Parameters:
  
  pattern - the pattern type: patternkey (pattern).
  
  Returns:
  
  K array-reply list of keys matching pattern.
- keys
  
  public Mono<Long> keys(KeyStreamingChannel<K> channel, K pattern)
  
  Description copied from interface: RedisKeyReactiveCommands
  
  Find all keys matching the given pattern.
  
  Specified by:
  
  keys in interface RedisKeyReactiveCommands<K,V>
  
  Parameters:
  
  channel - the channel.
  
  pattern - the pattern.
  
  Returns:
  
  Long array-reply list of keys matching pattern.
- lastsave
  
  public Mono<Date> lastsave()
  
  Description copied from interface: RedisServerReactiveCommands
  
  Get the UNIX time stamp of the last successful save to disk.
  
  Specified by:
  
  lastsave in interface RedisServerReactiveCommands<K,V>
  
  Returns:
  
  Date integer-reply an UNIX time stamp.
- lindex
  
  public Mono<V> lindex(K key, long index)
  
  Description copied from interface: RedisListReactiveCommands
  
  Get an element from a list by its index.
  
  Specified by:
  
  lindex in interface RedisListReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  index - the index type: long.
  
  Returns:
  
  V bulk-string-reply the requested element, or null when index is out of range.
- linsert
  
  public Mono<Long> linsert(K key, boolean before, V pivot, V value)
  
  Description copied from interface: RedisListReactiveCommands
  
  Insert an element before or after another element in a list.
  
  Specified by:
  
  linsert in interface RedisListReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  before - the before.
  
  pivot - the pivot.
  
  value - the value.
  
  Returns:
  
  Long integer-reply the length of the list after the insert operation, or -1 when the value pivot was not found.
- llen
  
  public Mono<Long> llen(K key)
  
  Description copied from interface: RedisListReactiveCommands
  
  Get the length of a list.
  
  Specified by:
  
  llen in interface RedisListReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  Returns:
  
  Long integer-reply the length of the list at key.
- lmove
  
  public Mono<V> lmove(K source, K destination, LMoveArgs args)
  
  Description copied from interface: RedisListReactiveCommands
  
  Atomically returns and removes the first/last element (head/tail depending on the wherefrom argument) of the list stored at source, and pushes the element at the first/last element (head/tail depending on the whereto argument) of the list stored at destination.
  
  Specified by:
  
  lmove in interface RedisListReactiveCommands<K,V>
  
  Parameters:
  
  source - the source key.
  
  destination - the destination type: key.
  
  args - command arguments to configure source and destination directions.
  
  Returns:
  
  V bulk-string-reply the element being popped and pushed.
- lpop
  
  public Mono<V> lpop(K key)
  
  Description copied from interface: RedisListReactiveCommands
  
  Remove and get the first element in a list.
  
  Specified by:
  
  lpop in interface RedisListReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  Returns:
  
  V bulk-string-reply the value of the first element, or null when key does not exist.
- lpop
  
  public Flux<V> lpop(K key, long count)
  
  Description copied from interface: RedisListReactiveCommands
  
  Remove and get the first count elements in a list.
  
  Specified by:
  
  lpop in interface RedisListReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  count - the number of elements to return.
  
  Returns:
- lpos
  
  public Mono<Long> lpos(K key, V value)
  
  Description copied from interface: RedisListReactiveCommands
  
  Return the index of matching elements inside a Redis list. By default, when no options are given, it will scan the list from head to tail, looking for the first match of "element". If the element is found, its index (the zero-based position in the list) is returned. Otherwise, if no match is found, null is returned. The returned elements indexes are always referring to what RedisListReactiveCommands.lindex(java.lang.Object, long) would return. So first element from head is 0, and so forth.
  
  Specified by:
  
  lpos in interface RedisListReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  value - the element to search for.
  
  Returns:
  
  V integer-reply representing the matching element, or null if there is no match.
- lpos
  
  public Mono<Long> lpos(K key, V value, LPosArgs args)
  
  Description copied from interface: RedisListReactiveCommands
  
  Return the index of matching elements inside a Redis list. By default, when no options are given, it will scan the list from head to tail, looking for the first match of "element". If the element is found, its index (the zero-based position in the list) is returned. Otherwise, if no match is found, null is returned. The returned elements indexes are always referring to what RedisListReactiveCommands.lindex(java.lang.Object, long) would return. So first element from head is 0, and so forth.
  
  Specified by:
  
  lpos in interface RedisListReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  value - the element to search for.
  
  args - command arguments to configureFIRST and MAXLEN options.
  
  Returns:
  
  V integer-reply representing the matching element, or null if there is no match.
- lpos
  
  public Flux<Long> lpos(K key, V value, int count)
  
  Description copied from interface: RedisListReactiveCommands
  
  Return the index of matching elements inside a Redis list using the COUNT option. By default, when no options are given, it will scan the list from head to tail, looking for the first match of "element". The returned elements indexes are always referring to what RedisListReactiveCommands.lindex(java.lang.Object, long) would return. So first element from head is 0, and so forth.
  
  Specified by:
  
  lpos in interface RedisListReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  value - the element to search for.
  
  count - limit the number of matches.
  
  Returns:
  
  V integer-reply representing the matching elements, or empty if there is no match.
- lpos
  
  public Flux<Long> lpos(K key, V value, int count, LPosArgs args)
  
  Description copied from interface: RedisListReactiveCommands
  
  Return the index of matching elements inside a Redis list using the COUNT option. By default, when no options are given, it will scan the list from head to tail, looking for the first match of "element". The returned elements indexes are always referring to what RedisListReactiveCommands.lindex(java.lang.Object, long) would return. So first element from head is 0, and so forth.
  
  Specified by:
  
  lpos in interface RedisListReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  value - the element to search for.
  
  count - limit the number of matches.
  
  args - command arguments to configureFIRST and MAXLEN options.
  
  Returns:
  
  V integer-reply representing the matching elements, or empty if there is no match.
- lpush
  
  public Mono<Long> lpush(K key, V... values)
  
  Description copied from interface: RedisListReactiveCommands
  
  Prepend one or multiple values to a list.
  
  Specified by:
  
  lpush in interface RedisListReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  values - the value.
  
  Returns:
  
  Long integer-reply the length of the list after the push operations.
- lpushx
  
  public Mono<Long> lpushx(K key, V... values)
  
  Description copied from interface: RedisListReactiveCommands
  
  Prepend values to a list, only if the list exists.
  
  Specified by:
  
  lpushx in interface RedisListReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  values - the values.
  
  Returns:
  
  Long integer-reply the length of the list after the push operation.
- lrange
  
  public Flux<V> lrange(K key, long start, long stop)
  
  Description copied from interface: RedisListReactiveCommands
  
  Get a range of elements from a list.
  
  Specified by:
  
  lrange in interface RedisListReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  start - the start type: long.
  
  stop - the stop type: long.
  
  Returns:
  
  V array-reply list of elements in the specified range.
- lrange
  
  public Mono<Long> lrange(ValueStreamingChannel<V> channel, K key, long start, long stop)
  
  Description copied from interface: RedisListReactiveCommands
  
  Get a range of elements from a list.
  
  Specified by:
  
  lrange in interface RedisListReactiveCommands<K,V>
  
  Parameters:
  
  channel - the channel.
  
  key - the key.
  
  start - the start type: long.
  
  stop - the stop type: long.
  
  Returns:
  
  Long count of elements in the specified range.
- lrem
  
  public Mono<Long> lrem(K key, long count, V value)
  
  Description copied from interface: RedisListReactiveCommands
  
  Remove elements from a list.
  
  Specified by:
  
  lrem in interface RedisListReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  count - the count type: long.
  
  value - the value.
  
  Returns:
  
  Long integer-reply the number of removed elements.
- lset
  
  public Mono<String> lset(K key, long index, V value)
  
  Description copied from interface: RedisListReactiveCommands
  
  Set the value of an element in a list by its index.
  
  Specified by:
  
  lset in interface RedisListReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  index - the index type: long.
  
  value - the value.
  
  Returns:
  
  String simple-string-reply.
- ltrim
  
  public Mono<String> ltrim(K key, long start, long stop)
  
  Description copied from interface: RedisListReactiveCommands
  
  Trim a list to the specified range.
  
  Specified by:
  
  ltrim in interface RedisListReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  start - the start type: long.
  
  stop - the stop type: long.
  
  Returns:
  
  String simple-string-reply.
- memoryUsage
  
  public Mono<Long> memoryUsage(K key)
  
  Description copied from interface: RedisServerReactiveCommands
  
  Reports the number of bytes that a key and its value require to be stored in RAM.
  
  Specified by:
  
  memoryUsage in interface RedisServerReactiveCommands<K,V>
  
  Returns:
  
  memory usage in bytes.
- mget
  
  public Flux<KeyValue<K,V>> mget(K... keys)
  
  Description copied from interface: RedisStringReactiveCommands
  
  Get the values of all the given keys.
  
  Specified by:
  
  mget in interface RedisClusterReactiveCommands<K,V>
  
  Specified by:
  
  mget in interface RedisStringReactiveCommands<K,V>
  
  Parameters:
  
  keys - the key.
  
  Returns:
  
  V array-reply list of values at the specified keys.
- mget
  
  public Flux<KeyValue<K,V>> mget(Iterable<K> keys)
- mget
  
  public Mono<Long> mget(KeyValueStreamingChannel<K,V> channel, K... keys)
  
  Description copied from interface: RedisStringReactiveCommands
  
  Stream over the values of all the given keys.
  
  Specified by:
  
  mget in interface RedisStringReactiveCommands<K,V>
  
  Parameters:
  
  channel - the channel.
  
  keys - the keys.
  
  Returns:
  
  Long array-reply list of values at the specified keys.
- mget
  
  public Mono<Long> mget(ValueStreamingChannel<V> channel, Iterable<K> keys)
- mget
  
  public Mono<Long> mget(KeyValueStreamingChannel<K,V> channel, Iterable<K> keys)
- migrate
  
  public Mono<String> migrate(String host, int port, K key, int db, long timeout)
  
  Description copied from interface: RedisKeyReactiveCommands
  
  Atomically transfer a key from a Redis instance to another one.
  
  Specified by:
  
  migrate in interface RedisKeyReactiveCommands<K,V>
  
  Parameters:
  
  host - the host.
  
  port - the port.
  
  key - the key.
  
  db - the database.
  
  timeout - the timeout in milliseconds.
  
  Returns:
  
  String simple-string-reply The command returns OK on success.
- migrate
  
  public Mono<String> migrate(String host, int port, int db, long timeout, MigrateArgs<K> migrateArgs)
  
  Description copied from interface: RedisKeyReactiveCommands
  
  Atomically transfer one or more keys from a Redis instance to another one.
  
  Specified by:
  
  migrate in interface RedisKeyReactiveCommands<K,V>
  
  Parameters:
  
  host - the host.
  
  port - the port.
  
  db - the database.
  
  timeout - the timeout in milliseconds.
  
  migrateArgs - migrate args that allow to configure further options.
  
  Returns:
  
  String simple-string-reply The command returns OK on success.
- move
  
  public Mono<Boolean> move(K key, int db)
  
  Description copied from interface: RedisKeyReactiveCommands
  
  Move a key to another database.
  
  Specified by:
  
  move in interface RedisKeyReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  db - the db type: long.
  
  Returns:
  
  Boolean integer-reply specifically:.
- mset
  
  public Mono<String> mset(Map<K,V> map)
  
  Description copied from interface: RedisStringReactiveCommands
  
  Set multiple keys to multiple values.
  
  Specified by:
  
  mset in interface RedisClusterReactiveCommands<K,V>
  
  Specified by:
  
  mset in interface RedisStringReactiveCommands<K,V>
  
  Parameters:
  
  map - the null.
  
  Returns:
  
  String simple-string-reply always OK since MSET can't fail.
- msetnx
  
  public Mono<Boolean> msetnx(Map<K,V> map)
  
  Description copied from interface: RedisStringReactiveCommands
  
  Set multiple keys to multiple values, only if none of the keys exist.
  
  Specified by:
  
  msetnx in interface RedisClusterReactiveCommands<K,V>
  
  Specified by:
  
  msetnx in interface RedisStringReactiveCommands<K,V>
  
  Parameters:
  
  map - the null.
  
  Returns:
  
  Boolean integer-reply specifically: 1 if the all the keys were set. 0 if no key was set (at least one key already existed).
- multi
  
  public Mono<String> multi()
  
  Description copied from interface: RedisTransactionalReactiveCommands
  
  Mark the start of a transaction block.
  
  Specified by:
  
  multi in interface RedisTransactionalReactiveCommands<K,V>
  
  Returns:
  
  String simple-string-reply always OK.
- objectEncoding
  
  public Mono<String> objectEncoding(K key)
  
  Description copied from interface: RedisKeyReactiveCommands
  
  Returns the kind of internal representation used in order to store the value associated with the key.
  
  Specified by:
  
  objectEncoding in interface RedisKeyReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  Returns:
  
  String.
- objectFreq
  
  public Mono<Long> objectFreq(K key)
  
  Description copied from interface: RedisKeyReactiveCommands
  
  Returns the logarithmic access frequency counter of the object stored at the specified key.
  
  Specified by:
  
  objectFreq in interface RedisKeyReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  Returns:
  
  Long.
- objectIdletime
  
  public Mono<Long> objectIdletime(K key)
  
  Description copied from interface: RedisKeyReactiveCommands
  
  Returns the number of seconds since the object stored at the specified key is idle (not requested by read or write operations).
  
  Specified by:
  
  objectIdletime in interface RedisKeyReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  Returns:
  
  number of seconds since the object stored at the specified key is idle.
- objectRefcount
  
  public Mono<Long> objectRefcount(K key)
  
  Description copied from interface: RedisKeyReactiveCommands
  
  Returns the number of references of the value associated with the specified key.
  
  Specified by:
  
  objectRefcount in interface RedisKeyReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  Returns:
  
  Long.
- persist
  
  public Mono<Boolean> persist(K key)
  
  Description copied from interface: RedisKeyReactiveCommands
  
  Remove the expiration from a key.
  
  Specified by:
  
  persist in interface RedisKeyReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  Returns:
  
  Boolean integer-reply specifically: true if the timeout was removed. false if key does not exist or does not have an associated timeout.
- pexpire
  
  public Mono<Boolean> pexpire(K key, long milliseconds)
  
  Description copied from interface: RedisKeyReactiveCommands
  
  Set a key's time to live in milliseconds.
  
  Specified by:
  
  pexpire in interface RedisKeyReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  milliseconds - the milliseconds type: long.
  
  Returns:
  
  integer-reply, specifically: true if the timeout was set. false if key does not exist or the timeout could not be set.
- pexpire
  
  public Mono<Boolean> pexpire(K key, Duration milliseconds)
  
  Description copied from interface: RedisKeyReactiveCommands
  
  Set a key's time to live in milliseconds.
  
  Specified by:
  
  pexpire in interface RedisKeyReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  milliseconds - the milliseconds.
  
  Returns:
  
  integer-reply, specifically: true if the timeout was set. false if key does not exist or the timeout could not be set.
- pexpireat
  
  public Mono<Boolean> pexpireat(K key, long timestamp)
  
  Description copied from interface: RedisKeyReactiveCommands
  
  Set the expiration for a key as a UNIX timestamp specified in milliseconds.
  
  Specified by:
  
  pexpireat in interface RedisKeyReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  timestamp - the milliseconds-timestamp type: posix time.
  
  Returns:
  
  Boolean integer-reply specifically: true if the timeout was set. false if key does not exist or the timeout could not be set (see: EXPIRE).
- pexpireat
  
  public Mono<Boolean> pexpireat(K key, Date timestamp)
  
  Description copied from interface: RedisKeyReactiveCommands
  
  Set the expiration for a key as a UNIX timestamp specified in milliseconds.
  
  Specified by:
  
  pexpireat in interface RedisKeyReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  timestamp - the milliseconds-timestamp type: posix time.
  
  Returns:
  
  Boolean integer-reply specifically: true if the timeout was set. false if key does not exist or the timeout could not be set (see: EXPIRE).
- pexpireat
  
  public Mono<Boolean> pexpireat(K key, Instant timestamp)
  
  Description copied from interface: RedisKeyReactiveCommands
  
  Set the expiration for a key as a UNIX timestamp specified in milliseconds.
  
  Specified by:
  
  pexpireat in interface RedisKeyReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  timestamp - the milliseconds-timestamp type: posix time.
  
  Returns:
  
  Boolean integer-reply specifically: true if the timeout was set. false if key does not exist or the timeout could not be set (see: EXPIRE).
- pfadd
  
  public Mono<Long> pfadd(K key, V... values)
  
  Description copied from interface: RedisHLLReactiveCommands
  
  Adds the specified elements to the specified HyperLogLog.
  
  Specified by:
  
  pfadd in interface RedisHLLReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  values - the values.
  
  Returns:
  
  Long integer-reply specifically: 1 if at least 1 HyperLogLog internal register was altered. 0 otherwise.
- pfadd
  
  public Mono<Long> pfadd(K key, V value, V... values)
- pfcount
  
  public Mono<Long> pfcount(K... keys)
  
  Description copied from interface: RedisHLLReactiveCommands
  
  Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).
  
  Specified by:
  
  pfcount in interface RedisHLLReactiveCommands<K,V>
  
  Parameters:
  
  keys - the keys.
  
  Returns:
  
  Long integer-reply specifically: The approximated number of unique elements observed via PFADD.
- pfcount
  
  public Mono<Long> pfcount(K key, K... keys)
- pfmerge
  
  public Mono<String> pfmerge(K destkey, K... sourcekeys)
  
  Description copied from interface: RedisHLLReactiveCommands
  
  Merge N different HyperLogLogs into a single one.
  
  Specified by:
  
  pfmerge in interface RedisHLLReactiveCommands<K,V>
  
  Parameters:
  
  destkey - the destination key.
  
  sourcekeys - the source key.
  
  Returns:
  
  String simple-string-reply The command just returns OK.
- pfmerge
  
  public Mono<String> pfmerge(K destkey, K sourceKey, K... sourcekeys)
- ping
  
  public Mono<String> ping()
  
  Description copied from interface: BaseRedisReactiveCommands
  
  Ping the server.
  
  Specified by:
  
  ping in interface BaseRedisReactiveCommands<K,V>
  
  Returns:
  
  String simple-string-reply.
- psetex
  
  public Mono<String> psetex(K key, long milliseconds, V value)
  
  Description copied from interface: RedisStringReactiveCommands
  
  Set the value and expiration in milliseconds of a key.
  
  Specified by:
  
  psetex in interface RedisStringReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  milliseconds - the milliseconds type: long.
  
  value - the value.
  
  Returns:
  
  String simple-string-reply.
- pttl
  
  public Mono<Long> pttl(K key)
  
  Description copied from interface: RedisKeyReactiveCommands
  
  Get the time to live for a key in milliseconds.
  
  Specified by:
  
  pttl in interface RedisKeyReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  Returns:
  
  Long integer-reply TTL in milliseconds, or a negative value in order to signal an error (see the description above).
- publish
  
  public Mono<Long> publish(K channel, V message)
  
  Description copied from interface: BaseRedisReactiveCommands
  
  Post a message to a channel.
  
  Specified by:
  
  publish in interface BaseRedisReactiveCommands<K,V>
  
  Parameters:
  
  channel - the channel type: key.
  
  message - the message type: value.
  
  Returns:
  
  Long integer-reply the number of clients that received the message.
- pubsubChannels
  
  public Flux<K> pubsubChannels()
  
  Description copied from interface: BaseRedisReactiveCommands
  
  Lists the currently *active channels*.
  
  Specified by:
  
  pubsubChannels in interface BaseRedisReactiveCommands<K,V>
  
  Returns:
  
  K array-reply a list of active channels, optionally matching the specified pattern.
- pubsubChannels
  
  public Flux<K> pubsubChannels(K channel)
  
  Description copied from interface: BaseRedisReactiveCommands
  
  Lists the currently *active channels*.
  
  Specified by:
  
  pubsubChannels in interface BaseRedisReactiveCommands<K,V>
  
  Parameters:
  
  channel - the key.
  
  Returns:
  
  K array-reply a list of active channels, optionally matching the specified pattern.
- pubsubNumpat
  
  public Mono<Long> pubsubNumpat()
  
  Description copied from interface: BaseRedisReactiveCommands
  
  Returns the number of subscriptions to patterns.
  
  Specified by:
  
  pubsubNumpat in interface BaseRedisReactiveCommands<K,V>
  
  Returns:
  
  Long integer-reply the number of patterns all the clients are subscribed to.
- pubsubNumsub
  
  public Mono<Map<K,Long>> pubsubNumsub(K... channels)
  
  Description copied from interface: BaseRedisReactiveCommands
  
  Returns the number of subscribers (not counting clients subscribed to patterns) for the specified channels.
  
  Specified by:
  
  pubsubNumsub in interface BaseRedisReactiveCommands<K,V>
  
  Parameters:
  
  channels - channel keys.
  
  Returns:
  
  array-reply a list of channels and number of subscribers for every channel.
- quit
  
  public Mono<String> quit()
  
  Description copied from interface: BaseRedisReactiveCommands
  
  Instructs Redis to disconnect the connection. Note that if auto-reconnect is enabled then Lettuce will auto-reconnect if the connection was disconnected. Use StatefulConnection.close() to close connections and release resources.
  
  Specified by:
  
  quit in interface BaseRedisReactiveCommands<K,V>
  
  Returns:
  
  String simple-string-reply always OK.
- randomkey
  
  public Mono<K> randomkey()
  
  Description copied from interface: RedisKeyReactiveCommands
  
  Return a random key from the keyspace.
  
  Specified by:
  
  randomkey in interface RedisKeyReactiveCommands<K,V>
  
  Returns:
  
  K bulk-string-reply the random key, or null when the database is empty.
- readOnly
  
  public Mono<String> readOnly()
  
  Description copied from interface: BaseRedisReactiveCommands
  
  Switch connection to Read-Only mode when connecting to a cluster.
  
  Specified by:
  
  readOnly in interface BaseRedisReactiveCommands<K,V>
  
  Specified by:
  
  readOnly in interface RedisClusterReactiveCommands<K,V>
  
  Returns:
  
  String simple-string-reply.
- readWrite
  
  public Mono<String> readWrite()
  
  Description copied from interface: BaseRedisReactiveCommands
  
  Switch connection to Read-Write mode (default) when connecting to a cluster.
  
  Specified by:
  
  readWrite in interface BaseRedisReactiveCommands<K,V>
  
  Specified by:
  
  readWrite in interface RedisClusterReactiveCommands<K,V>
  
  Returns:
  
  String simple-string-reply.
- rename
  
  public Mono<String> rename(K key, K newKey)
  
  Description copied from interface: RedisKeyReactiveCommands
  
  Rename a key.
  
  Specified by:
  
  rename in interface RedisKeyReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  newKey - the newkey type: key.
  
  Returns:
  
  String simple-string-reply.
- renamenx
  
  public Mono<Boolean> renamenx(K key, K newKey)
  
  Description copied from interface: RedisKeyReactiveCommands
  
  Rename a key, only if the new key does not exist.
  
  Specified by:
  
  renamenx in interface RedisKeyReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  newKey - the newkey type: key.
  
  Returns:
  
  Boolean integer-reply specifically: true if key was renamed to newkey. false if newkey already exists.
- reset
  
  public void reset()
  
  Description copied from interface: BaseRedisReactiveCommands
  
  Reset the command state. Queued commands will be canceled and the internal state will be reset. This is useful when the internal state machine gets out of sync with the connection.
  
  Specified by:
  
  reset in interface BaseRedisReactiveCommands<K,V>
- restore
  
  public Mono<String> restore(K key, long ttl, byte[] value)
  
  Description copied from interface: RedisKeyReactiveCommands
  
  Create a key using the provided serialized value, previously obtained using DUMP.
  
  Specified by:
  
  restore in interface RedisKeyReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  ttl - the ttl type: long.
  
  value - the serialized-value type: string.
  
  Returns:
  
  String simple-string-reply The command returns OK on success.
- restore
  
  public Mono<String> restore(K key, byte[] value, RestoreArgs args)
  
  Description copied from interface: RedisKeyReactiveCommands
  
  Create a key using the provided serialized value, previously obtained using DUMP.
  
  Specified by:
  
  restore in interface RedisKeyReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  value - the serialized-value type: string.
  
  args - the RestoreArgs, must not be null.
  
  Returns:
  
  String simple-string-reply The command returns OK on success.
- role
  
  public Flux<Object> role()
  
  Description copied from interface: BaseRedisReactiveCommands
  
  Return the role of the instance in the context of replication.
  
  Specified by:
  
  role in interface BaseRedisReactiveCommands<K,V>
  
  Returns:
  
  Object array-reply where the first element is one of master, slave, sentinel and the additional elements are role-specific.
- rpop
  
  public Mono<V> rpop(K key)
  
  Description copied from interface: RedisListReactiveCommands
  
  Remove and get the last element in a list.
  
  Specified by:
  
  rpop in interface RedisListReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  Returns:
  
  V bulk-string-reply the value of the last element, or null when key does not exist.
- rpop
  
  public Flux<V> rpop(K key, long count)
  
  Description copied from interface: RedisListReactiveCommands
  
  Remove and get the last count elements in a list.
  
  Specified by:
  
  rpop in interface RedisListReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  count - the number of elements to return.
  
  Returns:
  
  V array-reply list of the last count elements, or null when key does not exist.
- rpoplpush
  
  public Mono<V> rpoplpush(K source, K destination)
  
  Description copied from interface: RedisListReactiveCommands
  
  Remove the last element in a list, append it to another list and return it.
  
  Specified by:
  
  rpoplpush in interface RedisListReactiveCommands<K,V>
  
  Parameters:
  
  source - the source key.
  
  destination - the destination type: key.
  
  Returns:
  
  V bulk-string-reply the element being popped and pushed.
- rpush
  
  public Mono<Long> rpush(K key, V... values)
  
  Description copied from interface: RedisListReactiveCommands
  
  Append one or multiple values to a list.
  
  Specified by:
  
  rpush in interface RedisListReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  values - the value.
  
  Returns:
  
  Long integer-reply the length of the list after the push operation.
- rpushx
  
  public Mono<Long> rpushx(K key, V... values)
  
  Description copied from interface: RedisListReactiveCommands
  
  Append values to a list, only if the list exists.
  
  Specified by:
  
  rpushx in interface RedisListReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  values - the values.
  
  Returns:
  
  Long integer-reply the length of the list after the push operation.
- sadd
  
  public Mono<Long> sadd(K key, V... members)
  
  Description copied from interface: RedisSetReactiveCommands
  
  Add one or more members to a set.
  
  Specified by:
  
  sadd in interface RedisSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  members - the member type: value.
  
  Returns:
  
  Long integer-reply the number of elements that were added to the set, not including all the elements already present into the set.
- save
  
  public Mono<String> save()
  
  Description copied from interface: RedisServerReactiveCommands
  
  Synchronously save the dataset to disk.
  
  Specified by:
  
  save in interface RedisServerReactiveCommands<K,V>
  
  Returns:
  
  String simple-string-reply The commands returns OK on success.
- scan
  
  public Mono<KeyScanCursor<K>> scan()
  
  Description copied from interface: RedisKeyReactiveCommands
  
  Incrementally iterate the keys space.
  
  Specified by:
  
  scan in interface RedisKeyReactiveCommands<K,V>
  
  Returns:
  
  KeyScanCursor<K> scan cursor.
- scan
  
  public Mono<KeyScanCursor<K>> scan(ScanArgs scanArgs)
  
  Description copied from interface: RedisKeyReactiveCommands
  
  Incrementally iterate the keys space. Use KeyScanArgs to specify SCAN-specific arguments.
  
  Specified by:
  
  scan in interface RedisKeyReactiveCommands<K,V>
  
  Parameters:
  
  scanArgs - scan arguments.
  
  Returns:
  
  KeyScanCursor<K> scan cursor.
  
  See Also:
  
  KeyScanArgs
- scan
  
  public Mono<KeyScanCursor<K>> scan(ScanCursor scanCursor, ScanArgs scanArgs)
  
  Description copied from interface: RedisKeyReactiveCommands
  
  Incrementally iterate the keys space. Use KeyScanArgs to specify SCAN-specific arguments.
  
  Specified by:
  
  scan in interface RedisKeyReactiveCommands<K,V>
  
  Parameters:
  
  scanCursor - cursor to resume from a previous scan, must not be null.
  
  scanArgs - scan arguments.
  
  Returns:
  
  KeyScanCursor<K> scan cursor.
  
  See Also:
  
  KeyScanArgs
- scan
  
  public Mono<KeyScanCursor<K>> scan(ScanCursor scanCursor)
  
  Description copied from interface: RedisKeyReactiveCommands
  
  Incrementally iterate the keys space.
  
  Specified by:
  
  scan in interface RedisKeyReactiveCommands<K,V>
  
  Parameters:
  
  scanCursor - cursor to resume from a previous scan, must not be null.
  
  Returns:
  
  KeyScanCursor<K> scan cursor.
- scan
  
  public Mono<StreamScanCursor> scan(KeyStreamingChannel<K> channel)
  
  Description copied from interface: RedisKeyReactiveCommands
  
  Incrementally iterate the keys space.
  
  Specified by:
  
  scan in interface RedisKeyReactiveCommands<K,V>
  
  Parameters:
  
  channel - streaming channel that receives a call for every key.
  
  Returns:
  
  StreamScanCursor scan cursor.
- scan
  
  public Mono<StreamScanCursor> scan(KeyStreamingChannel<K> channel, ScanArgs scanArgs)
  
  Description copied from interface: RedisKeyReactiveCommands
  
  Incrementally iterate the keys space. Use KeyScanArgs to specify SCAN-specific arguments.
  
  Specified by:
  
  scan in interface RedisKeyReactiveCommands<K,V>
  
  Parameters:
  
  channel - streaming channel that receives a call for every key.
  
  scanArgs - scan arguments.
  
  Returns:
  
  StreamScanCursor scan cursor.
  
  See Also:
  
  KeyScanArgs
- scan
  
  public Mono<StreamScanCursor> scan(KeyStreamingChannel<K> channel, ScanCursor scanCursor, ScanArgs scanArgs)
  
  Description copied from interface: RedisKeyReactiveCommands
  
  Incrementally iterate the keys space. Use KeyScanArgs to specify SCAN-specific arguments.
  
  Specified by:
  
  scan in interface RedisKeyReactiveCommands<K,V>
  
  Parameters:
  
  channel - streaming channel that receives a call for every key.
  
  scanCursor - cursor to resume from a previous scan, must not be null.
  
  scanArgs - scan arguments.
  
  Returns:
  
  StreamScanCursor scan cursor.
  
  See Also:
  
  KeyScanArgs
- scan
  
  public Mono<StreamScanCursor> scan(KeyStreamingChannel<K> channel, ScanCursor scanCursor)
  
  Description copied from interface: RedisKeyReactiveCommands
  
  Incrementally iterate the keys space.
  
  Specified by:
  
  scan in interface RedisKeyReactiveCommands<K,V>
  
  Parameters:
  
  channel - streaming channel that receives a call for every key.
  
  scanCursor - cursor to resume from a previous scan, must not be null.
  
  Returns:
  
  StreamScanCursor scan cursor.
- scard
  
  public Mono<Long> scard(K key)
  
  Description copied from interface: RedisSetReactiveCommands
  
  Get the number of members in a set.
  
  Specified by:
  
  scard in interface RedisSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  Returns:
  
  Long integer-reply the cardinality (number of elements) of the set, or false if key does not exist.
- scriptExists
  
  public Flux<Boolean> scriptExists(String... digests)
  
  Description copied from interface: RedisScriptingReactiveCommands
  
  Check existence of scripts in the script cache.
  
  Specified by:
  
  scriptExists in interface RedisScriptingReactiveCommands<K,V>
  
  Parameters:
  
  digests - script digests.
  
  Returns:
  
  Boolean array-reply The command returns an array of integers that correspond to the specified SHA1 digest arguments. For every corresponding SHA1 digest of a script that actually exists in the script cache, an 1 is returned, otherwise 0 is returned.
- scriptFlush
  
  public Mono<String> scriptFlush()
  
  Description copied from interface: RedisScriptingReactiveCommands
  
  Remove all the scripts from the script cache.
  
  Specified by:
  
  scriptFlush in interface RedisScriptingReactiveCommands<K,V>
  
  Returns:
  
  String simple-string-reply.
- scriptFlush
  
  public Mono<String> scriptFlush(FlushMode flushMode)
  
  Description copied from interface: RedisScriptingReactiveCommands
  
  Remove all the scripts from the script cache using the specified FlushMode.
  
  Specified by:
  
  scriptFlush in interface RedisScriptingReactiveCommands<K,V>
  
  Parameters:
  
  flushMode - the flush mode (sync/asnync).
  
  Returns:
  
  String simple-string-reply.
- scriptKill
  
  public Mono<String> scriptKill()
  
  Description copied from interface: RedisScriptingReactiveCommands
  
  Kill the script currently in execution.
  
  Specified by:
  
  scriptKill in interface RedisScriptingReactiveCommands<K,V>
  
  Returns:
  
  String simple-string-reply.
- scriptLoad
  
  public Mono<String> scriptLoad(String script)
  
  Description copied from interface: RedisScriptingReactiveCommands
  
  Load the specified Lua script into the script cache.
  
  Specified by:
  
  scriptLoad in interface RedisScriptingReactiveCommands<K,V>
  
  Parameters:
  
  script - script content.
  
  Returns:
  
  String bulk-string-reply This command returns the SHA1 digest of the script added into the script cache.
- scriptLoad
  
  public Mono<String> scriptLoad(byte[] script)
  
  Description copied from interface: RedisScriptingReactiveCommands
  
  Load the specified Lua script into the script cache.
  
  Specified by:
  
  scriptLoad in interface RedisScriptingReactiveCommands<K,V>
  
  Parameters:
  
  script - script content.
  
  Returns:
  
  String bulk-string-reply This command returns the SHA1 digest of the script added into the script cache.
- sdiff
  
  public Flux<V> sdiff(K... keys)
  
  Description copied from interface: RedisSetReactiveCommands
  
  Subtract multiple sets.
  
  Specified by:
  
  sdiff in interface RedisSetReactiveCommands<K,V>
  
  Parameters:
  
  keys - the key.
  
  Returns:
  
  V array-reply list with members of the resulting set.
- sdiff
  
  public Mono<Long> sdiff(ValueStreamingChannel<V> channel, K... keys)
  
  Description copied from interface: RedisSetReactiveCommands
  
  Subtract multiple sets.
  
  Specified by:
  
  sdiff in interface RedisSetReactiveCommands<K,V>
  
  Parameters:
  
  channel - the channel.
  
  keys - the keys.
  
  Returns:
  
  Long count of members of the resulting set.
- sdiffstore
  
  public Mono<Long> sdiffstore(K destination, K... keys)
  
  Description copied from interface: RedisSetReactiveCommands
  
  Subtract multiple sets and store the resulting set in a key.
  
  Specified by:
  
  sdiffstore in interface RedisSetReactiveCommands<K,V>
  
  Parameters:
  
  destination - the destination type: key.
  
  keys - the key.
  
  Returns:
  
  Long integer-reply the number of elements in the resulting set.
- select
  
  public Mono<String> select(int db)
- set
  
  public Mono<String> set(K key, V value)
  
  Description copied from interface: RedisStringReactiveCommands
  
  Set the string value of a key.
  
  Specified by:
  
  set in interface RedisStringReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  value - the value.
  
  Returns:
  
  String simple-string-reply OK if SET was executed correctly.
- set
  
  public Mono<String> set(K key, V value, SetArgs setArgs)
  
  Description copied from interface: RedisStringReactiveCommands
  
  Set the string value of a key.
  
  Specified by:
  
  set in interface RedisStringReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  value - the value.
  
  setArgs - the setArgs.
  
  Returns:
  
  String simple-string-reply OK if SET was executed correctly.
- setGet
  
  public Mono<V> setGet(K key, V value)
  
  Description copied from interface: RedisStringReactiveCommands
  
  Set the string value of a key and return its old value.
  
  Specified by:
  
  setGet in interface RedisStringReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  value - the value.
  
  Returns:
  
  V bulk-string-reply the old value stored at key, or null when key did not exist.
- setGet
  
  public Mono<V> setGet(K key, V value, SetArgs setArgs)
  
  Description copied from interface: RedisStringReactiveCommands
  
  Set the string value of a key and return its old value.
  
  Specified by:
  
  setGet in interface RedisStringReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  value - the value.
  
  setArgs - the command arguments.
  
  Returns:
  
  V bulk-string-reply the old value stored at key, or null when key did not exist.
- setAutoFlushCommands
  
  public void setAutoFlushCommands(boolean autoFlush)
  
  Description copied from interface: BaseRedisReactiveCommands
  
  Disable or enable auto-flush behavior. Default is true. If autoFlushCommands is disabled, multiple commands can be issued without writing them actually to the transport. Commands are buffered until a BaseRedisReactiveCommands.flushCommands() is issued. After calling BaseRedisReactiveCommands.flushCommands() commands are sent to the transport and executed by Redis.
  
  Specified by:
  
  setAutoFlushCommands in interface BaseRedisReactiveCommands<K,V>
  
  Parameters:
  
  autoFlush - state of autoFlush.
- setTimeout
  
  public void setTimeout(Duration timeout)
  
  Description copied from interface: RedisClusterReactiveCommands
  
  Set the default timeout for operations. A zero timeout value indicates to not time out.
  
  Specified by:
  
  setTimeout in interface RedisClusterReactiveCommands<K,V>
  
  Parameters:
  
  timeout - the timeout value
- setbit
  
  public Mono<Long> setbit(K key, long offset, int value)
  
  Description copied from interface: RedisStringReactiveCommands
  
  Sets or clears the bit at offset in the string value stored at key.
  
  Specified by:
  
  setbit in interface RedisStringReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  offset - the offset type: long.
  
  value - the value type: string.
  
  Returns:
  
  Long integer-reply the original bit value stored at offset.
- setex
  
  public Mono<String> setex(K key, long seconds, V value)
  
  Description copied from interface: RedisStringReactiveCommands
  
  Set the value and expiration of a key.
  
  Specified by:
  
  setex in interface RedisStringReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  seconds - the seconds type: long.
  
  value - the value.
  
  Returns:
  
  String simple-string-reply.
- setnx
  
  public Mono<Boolean> setnx(K key, V value)
  
  Description copied from interface: RedisStringReactiveCommands
  
  Set the value of a key, only if the key does not exist.
  
  Specified by:
  
  setnx in interface RedisStringReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  value - the value.
  
  Returns:
  
  Boolean integer-reply specifically: 1 if the key was set 0 if the key was not set.
- setrange
  
  public Mono<Long> setrange(K key, long offset, V value)
  
  Description copied from interface: RedisStringReactiveCommands
  
  Overwrite part of a string at key starting at the specified offset.
  
  Specified by:
  
  setrange in interface RedisStringReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  offset - the offset type: long.
  
  value - the value.
  
  Returns:
  
  Long integer-reply the length of the string after it was modified by the command.
- shutdown
  
  public Mono<Void> shutdown(boolean save)
  
  Description copied from interface: RedisServerReactiveCommands
  
  Synchronously save the dataset to disk and then shut down the server.
  
  Specified by:
  
  shutdown in interface RedisServerReactiveCommands<K,V>
  
  Parameters:
  
  save - true force save operation.
- sinter
  
  public Flux<V> sinter(K... keys)
  
  Description copied from interface: RedisSetReactiveCommands
  
  Intersect multiple sets.
  
  Specified by:
  
  sinter in interface RedisSetReactiveCommands<K,V>
  
  Parameters:
  
  keys - the key.
  
  Returns:
  
  V array-reply list with members of the resulting set.
- sinter
  
  public Mono<Long> sinter(ValueStreamingChannel<V> channel, K... keys)
  
  Description copied from interface: RedisSetReactiveCommands
  
  Intersect multiple sets.
  
  Specified by:
  
  sinter in interface RedisSetReactiveCommands<K,V>
  
  Parameters:
  
  channel - the channel.
  
  keys - the keys.
  
  Returns:
  
  Long count of members of the resulting set.
- sinterstore
  
  public Mono<Long> sinterstore(K destination, K... keys)
  
  Description copied from interface: RedisSetReactiveCommands
  
  Intersect multiple sets and store the resulting set in a key.
  
  Specified by:
  
  sinterstore in interface RedisSetReactiveCommands<K,V>
  
  Parameters:
  
  destination - the destination type: key.
  
  keys - the key.
  
  Returns:
  
  Long integer-reply the number of elements in the resulting set.
- sismember
  
  public Mono<Boolean> sismember(K key, V member)
  
  Description copied from interface: RedisSetReactiveCommands
  
  Determine if a given value is a member of a set.
  
  Specified by:
  
  sismember in interface RedisSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  member - the member type: value.
  
  Returns:
  
  Boolean integer-reply specifically: true if the element is a member of the set. false if the element is not a member of the set, or if key does not exist.
- slaveof
  
  public Mono<String> slaveof(String host, int port)
  
  Description copied from interface: RedisServerReactiveCommands
  
  Make the server a replica of another instance, or promote it as master.
  
  Specified by:
  
  slaveof in interface RedisServerReactiveCommands<K,V>
  
  Parameters:
  
  host - the host type: string.
  
  port - the port type: string.
  
  Returns:
  
  String simple-string-reply.
- slaveofNoOne
  
  public Mono<String> slaveofNoOne()
  
  Description copied from interface: RedisServerReactiveCommands
  
  Promote server as master.
  
  Specified by:
  
  slaveofNoOne in interface RedisServerReactiveCommands<K,V>
  
  Returns:
  
  String simple-string-reply.
- slowlogGet
  
  public Flux<Object> slowlogGet()
  
  Description copied from interface: RedisServerReactiveCommands
  
  Read the slow log.
  
  Specified by:
  
  slowlogGet in interface RedisServerReactiveCommands<K,V>
  
  Returns:
  
  Object deeply nested multi bulk replies.
- slowlogGet
  
  public Flux<Object> slowlogGet(int count)
  
  Description copied from interface: RedisServerReactiveCommands
  
  Read the slow log.
  
  Specified by:
  
  slowlogGet in interface RedisServerReactiveCommands<K,V>
  
  Parameters:
  
  count - the count.
  
  Returns:
  
  Object deeply nested multi bulk replies.
- slowlogLen
  
  public Mono<Long> slowlogLen()
  
  Description copied from interface: RedisServerReactiveCommands
  
  Obtaining the current length of the slow log.
  
  Specified by:
  
  slowlogLen in interface RedisServerReactiveCommands<K,V>
  
  Returns:
  
  Long length of the slow log.
- slowlogReset
  
  public Mono<String> slowlogReset()
  
  Description copied from interface: RedisServerReactiveCommands
  
  Resetting the slow log.
  
  Specified by:
  
  slowlogReset in interface RedisServerReactiveCommands<K,V>
  
  Returns:
  
  String simple-string-reply The commands returns OK on success.
- smembers
  
  public Flux<V> smembers(K key)
  
  Description copied from interface: RedisSetReactiveCommands
  
  Get all the members in a set.
  
  Specified by:
  
  smembers in interface RedisSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  Returns:
  
  V array-reply all elements of the set.
- smembers
  
  public Mono<Long> smembers(ValueStreamingChannel<V> channel, K key)
  
  Description copied from interface: RedisSetReactiveCommands
  
  Get all the members in a set.
  
  Specified by:
  
  smembers in interface RedisSetReactiveCommands<K,V>
  
  Parameters:
  
  channel - the channel.
  
  key - the keys.
  
  Returns:
  
  Long count of members of the resulting set.
- smismember
  
  public Flux<Boolean> smismember(K key, V... members)
  
  Description copied from interface: RedisSetReactiveCommands
  
  Returns whether each member is a member of the set stored at key.
  
  Specified by:
  
  smismember in interface RedisSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  members - the member type: value.
  
  Returns:
  
  Boolean array-reply list representing the membership of the given elements, in the same order as they are requested.
- smove
  
  public Mono<Boolean> smove(K source, K destination, V member)
  
  Description copied from interface: RedisSetReactiveCommands
  
  Move a member from one set to another.
  
  Specified by:
  
  smove in interface RedisSetReactiveCommands<K,V>
  
  Parameters:
  
  source - the source key.
  
  destination - the destination type: key.
  
  member - the member type: value.
  
  Returns:
  
  Boolean integer-reply specifically: true if the element is moved. false if the element is not a member of source and no operation was performed.
- sort
  
  public Flux<V> sort(K key)
  
  Description copied from interface: RedisKeyReactiveCommands
  
  Sort the elements in a list, set or sorted set.
  
  Specified by:
  
  sort in interface RedisKeyReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  Returns:
  
  V array-reply list of sorted elements.
- sort
  
  public Mono<Long> sort(ValueStreamingChannel<V> channel, K key)
  
  Description copied from interface: RedisKeyReactiveCommands
  
  Sort the elements in a list, set or sorted set.
  
  Specified by:
  
  sort in interface RedisKeyReactiveCommands<K,V>
  
  Parameters:
  
  channel - streaming channel that receives a call for every value.
  
  key - the key.
  
  Returns:
  
  Long number of values.
- sort
  
  public Flux<V> sort(K key, SortArgs sortArgs)
  
  Description copied from interface: RedisKeyReactiveCommands
  
  Sort the elements in a list, set or sorted set.
  
  Specified by:
  
  sort in interface RedisKeyReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  sortArgs - sort arguments.
  
  Returns:
  
  V array-reply list of sorted elements.
- sort
  
  public Mono<Long> sort(ValueStreamingChannel<V> channel, K key, SortArgs sortArgs)
  
  Description copied from interface: RedisKeyReactiveCommands
  
  Sort the elements in a list, set or sorted set.
  
  Specified by:
  
  sort in interface RedisKeyReactiveCommands<K,V>
  
  Parameters:
  
  channel - streaming channel that receives a call for every value.
  
  key - the key.
  
  sortArgs - sort arguments.
  
  Returns:
  
  Long number of values.
- sortStore
  
  public Mono<Long> sortStore(K key, SortArgs sortArgs, K destination)
  
  Description copied from interface: RedisKeyReactiveCommands
  
  Sort the elements in a list, set or sorted set.
  
  Specified by:
  
  sortStore in interface RedisKeyReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  sortArgs - sort arguments.
  
  destination - the destination key to store sort results.
  
  Returns:
  
  Long number of values.
- spop
  
  public Mono<V> spop(K key)
  
  Description copied from interface: RedisSetReactiveCommands
  
  Remove and return a random member from a set.
  
  Specified by:
  
  spop in interface RedisSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  Returns:
  
  V bulk-string-reply the removed element, or null when key does not exist.
- spop
  
  public Flux<V> spop(K key, long count)
  
  Description copied from interface: RedisSetReactiveCommands
  
  Remove and return one or multiple random members from a set.
  
  Specified by:
  
  spop in interface RedisSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  count - number of members to pop.
  
  Returns:
  
  V bulk-string-reply the removed element, or null when key does not exist.
- srandmember
  
  public Mono<V> srandmember(K key)
  
  Description copied from interface: RedisSetReactiveCommands
  
  Get one random member from a set.
  
  Specified by:
  
  srandmember in interface RedisSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  Returns:
  
  V bulk-string-reply without the additional count argument the command returns a Bulk Reply with the randomly selected element, or null when key does not exist.
- srandmember
  
  public Flux<V> srandmember(K key, long count)
  
  Description copied from interface: RedisSetReactiveCommands
  
  Get one or multiple random members from a set.
  
  Specified by:
  
  srandmember in interface RedisSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  count - the count type: long.
  
  Returns:
  
  V bulk-string-reply without the additional count argument the command returns a Bulk Reply with the randomly selected element, or null when key does not exist.
- srandmember
  
  public Mono<Long> srandmember(ValueStreamingChannel<V> channel, K key, long count)
  
  Description copied from interface: RedisSetReactiveCommands
  
  Get one or multiple random members from a set.
  
  Specified by:
  
  srandmember in interface RedisSetReactiveCommands<K,V>
  
  Parameters:
  
  channel - streaming channel that receives a call for every value.
  
  key - the key.
  
  count - the count.
  
  Returns:
  
  Long count of members of the resulting set.
- srem
  
  public Mono<Long> srem(K key, V... members)
  
  Description copied from interface: RedisSetReactiveCommands
  
  Remove one or more members from a set.
  
  Specified by:
  
  srem in interface RedisSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  members - the member type: value.
  
  Returns:
  
  Long integer-reply the number of members that were removed from the set, not including non existing members.
- sscan
  
  public Mono<ValueScanCursor<V>> sscan(K key)
  
  Description copied from interface: RedisSetReactiveCommands
  
  Incrementally iterate Set elements.
  
  Specified by:
  
  sscan in interface RedisSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  Returns:
  
  ValueScanCursor<V> scan cursor.
- sscan
  
  public Mono<ValueScanCursor<V>> sscan(K key, ScanArgs scanArgs)
  
  Description copied from interface: RedisSetReactiveCommands
  
  Incrementally iterate Set elements.
  
  Specified by:
  
  sscan in interface RedisSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  scanArgs - scan arguments.
  
  Returns:
  
  ValueScanCursor<V> scan cursor.
- sscan
  
  public Mono<ValueScanCursor<V>> sscan(K key, ScanCursor scanCursor, ScanArgs scanArgs)
  
  Description copied from interface: RedisSetReactiveCommands
  
  Incrementally iterate Set elements.
  
  Specified by:
  
  sscan in interface RedisSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  scanCursor - cursor to resume from a previous scan, must not be null.
  
  scanArgs - scan arguments.
  
  Returns:
  
  ValueScanCursor<V> scan cursor.
- sscan
  
  public Mono<ValueScanCursor<V>> sscan(K key, ScanCursor scanCursor)
  
  Description copied from interface: RedisSetReactiveCommands
  
  Incrementally iterate Set elements.
  
  Specified by:
  
  sscan in interface RedisSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  scanCursor - cursor to resume from a previous scan, must not be null.
  
  Returns:
  
  ValueScanCursor<V> scan cursor.
- sscan
  
  public Mono<StreamScanCursor> sscan(ValueStreamingChannel<V> channel, K key)
  
  Description copied from interface: RedisSetReactiveCommands
  
  Incrementally iterate Set elements.
  
  Specified by:
  
  sscan in interface RedisSetReactiveCommands<K,V>
  
  Parameters:
  
  channel - streaming channel that receives a call for every value.
  
  key - the key.
  
  Returns:
  
  StreamScanCursor scan cursor.
- sscan
  
  public Mono<StreamScanCursor> sscan(ValueStreamingChannel<V> channel, K key, ScanArgs scanArgs)
  
  Description copied from interface: RedisSetReactiveCommands
  
  Incrementally iterate Set elements.
  
  Specified by:
  
  sscan in interface RedisSetReactiveCommands<K,V>
  
  Parameters:
  
  channel - streaming channel that receives a call for every value.
  
  key - the key.
  
  scanArgs - scan arguments.
  
  Returns:
  
  StreamScanCursor scan cursor.
- sscan
  
  public Mono<StreamScanCursor> sscan(ValueStreamingChannel<V> channel, K key, ScanCursor scanCursor, ScanArgs scanArgs)
  
  Description copied from interface: RedisSetReactiveCommands
  
  Incrementally iterate Set elements.
  
  Specified by:
  
  sscan in interface RedisSetReactiveCommands<K,V>
  
  Parameters:
  
  channel - streaming channel that receives a call for every value.
  
  key - the key.
  
  scanCursor - cursor to resume from a previous scan, must not be null.
  
  scanArgs - scan arguments.
  
  Returns:
  
  StreamScanCursor scan cursor.
- sscan
  
  public Mono<StreamScanCursor> sscan(ValueStreamingChannel<V> channel, K key, ScanCursor scanCursor)
  
  Description copied from interface: RedisSetReactiveCommands
  
  Incrementally iterate Set elements.
  
  Specified by:
  
  sscan in interface RedisSetReactiveCommands<K,V>
  
  Parameters:
  
  channel - streaming channel that receives a call for every value.
  
  key - the key.
  
  scanCursor - cursor to resume from a previous scan, must not be null.
  
  Returns:
  
  StreamScanCursor scan cursor.
- strlen
  
  public Mono<Long> strlen(K key)
  
  Description copied from interface: RedisStringReactiveCommands
  
  Get the length of the value stored in a key.
  
  Specified by:
  
  strlen in interface RedisStringReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  Returns:
  
  Long integer-reply the length of the string at key, or 0 when key does not exist.
- stralgoLcs
  
  public Mono<StringMatchResult> stralgoLcs(StrAlgoArgs strAlgoArgs)
  
  Description copied from interface: RedisStringReactiveCommands
  The STRALGO command implements complex algorithms that operate on strings. This method uses the LCS algorithm (longest common substring).
  
  Without modifiers the string representing the longest common substring is returned.
  
  When LEN is given the command returns the length of the longest common substring.
  
  When IDX is given the command returns an array with the LCS length and all the ranges in both the strings, start and end offset for each string, where there are matches. When WITHMATCHLEN is given each array representing a match will also have the length of the match.
  Specified by:
  
  stralgoLcs in interface RedisStringReactiveCommands<K,V>
  
  Parameters:
  
  strAlgoArgs - command arguments.
  
  Returns:
  
  StringMatchResult.
- sunion
  
  public Flux<V> sunion(K... keys)
  
  Description copied from interface: RedisSetReactiveCommands
  
  Add multiple sets.
  
  Specified by:
  
  sunion in interface RedisSetReactiveCommands<K,V>
  
  Parameters:
  
  keys - the key.
  
  Returns:
  
  V array-reply list with members of the resulting set.
- sunion
  
  public Mono<Long> sunion(ValueStreamingChannel<V> channel, K... keys)
  
  Description copied from interface: RedisSetReactiveCommands
  
  Add multiple sets.
  
  Specified by:
  
  sunion in interface RedisSetReactiveCommands<K,V>
  
  Parameters:
  
  channel - streaming channel that receives a call for every value.
  
  keys - the keys.
  
  Returns:
  
  Long count of members of the resulting set.
- sunionstore
  
  public Mono<Long> sunionstore(K destination, K... keys)
  
  Description copied from interface: RedisSetReactiveCommands
  
  Add multiple sets and store the resulting set in a key.
  
  Specified by:
  
  sunionstore in interface RedisSetReactiveCommands<K,V>
  
  Parameters:
  
  destination - the destination type: key.
  
  keys - the key.
  
  Returns:
  
  Long integer-reply the number of elements in the resulting set.
- swapdb
  
  public Mono<String> swapdb(int db1, int db2)
- time
  
  public Flux<V> time()
  
  Description copied from interface: RedisServerReactiveCommands
  
  Return the current server time.
  
  Specified by:
  
  time in interface RedisServerReactiveCommands<K,V>
  
  Returns:
  
  V array-reply specifically: A multi bulk reply containing two elements: unix time in seconds. microseconds.
- touch
  
  public Mono<Long> touch(K... keys)
  
  Description copied from interface: RedisKeyReactiveCommands
  
  Touch one or more keys. Touch sets the last accessed time for a key. Non-exsitent keys wont get created.
  
  Specified by:
  
  touch in interface RedisKeyReactiveCommands<K,V>
  
  Parameters:
  
  keys - the keys.
  
  Returns:
  
  Long integer-reply the number of found keys.
- touch
  
  public Mono<Long> touch(Iterable<K> keys)
- ttl
  
  public Mono<Long> ttl(K key)
  
  Description copied from interface: RedisKeyReactiveCommands
  
  Get the time to live for a key.
  
  Specified by:
  
  ttl in interface RedisKeyReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  Returns:
  
  Long integer-reply TTL in seconds, or a negative value in order to signal an error (see the description above).
- type
  
  public Mono<String> type(K key)
  
  Description copied from interface: RedisKeyReactiveCommands
  
  Determine the type stored at key.
  
  Specified by:
  
  type in interface RedisKeyReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  Returns:
  
  String simple-string-reply type of key, or none when key does not exist.
- unlink
  
  public Mono<Long> unlink(K... keys)
  
  Description copied from interface: RedisKeyReactiveCommands
  
  Unlink one or more keys (non blocking DEL).
  
  Specified by:
  
  unlink in interface RedisKeyReactiveCommands<K,V>
  
  Parameters:
  
  keys - the keys.
  
  Returns:
  
  Long integer-reply The number of keys that were removed.
- unlink
  
  public Mono<Long> unlink(Iterable<K> keys)
- copy
  
  public Mono<Boolean> copy(K source, K destination)
  
  Description copied from interface: RedisKeyReactiveCommands
  
  Copy the value stored at the source key to the destination key.
  
  Specified by:
  
  copy in interface RedisKeyReactiveCommands<K,V>
  
  Parameters:
  
  source - the source.
  
  destination - the destination.
  
  Returns:
  
  Boolean integer-reply specifically: true if source was copied. false if source was not copied.
- copy
  
  public Mono<Boolean> copy(K source, K destination, CopyArgs copyArgs)
  
  Description copied from interface: RedisKeyReactiveCommands
  
  Copy the value stored at the source key to the destination key.
  
  Specified by:
  
  copy in interface RedisKeyReactiveCommands<K,V>
  
  Parameters:
  
  source - the source.
  
  destination - the destination.
  
  copyArgs - the copyArgs.
  
  Returns:
  
  Boolean integer-reply specifically: true if source was copied. false if source was not copied.
- unwatch
  
  public Mono<String> unwatch()
  
  Description copied from interface: RedisTransactionalReactiveCommands
  
  Forget about all watched keys.
  
  Specified by:
  
  unwatch in interface RedisTransactionalReactiveCommands<K,V>
  
  Returns:
  
  String simple-string-reply always OK.
- waitForReplication
  
  public Mono<Long> waitForReplication(int replicas, long timeout)
  
  Description copied from interface: BaseRedisReactiveCommands
  
  Wait for replication.
  
  Specified by:
  
  waitForReplication in interface BaseRedisReactiveCommands<K,V>
  
  Parameters:
  
  replicas - minimum number of replicas.
  
  timeout - timeout in milliseconds.
  
  Returns:
  
  number of replicas.
- watch
  
  public Mono<String> watch(K... keys)
  
  Description copied from interface: RedisTransactionalReactiveCommands
  
  Watch the given keys to determine execution of the MULTI/EXEC block.
  
  Specified by:
  
  watch in interface RedisTransactionalReactiveCommands<K,V>
  
  Parameters:
  
  keys - the key.
  
  Returns:
  
  String simple-string-reply always OK.
- xack
  
  public Mono<Long> xack(K key, K group, String... messageIds)
  
  Description copied from interface: RedisStreamReactiveCommands
  
  Acknowledge one or more messages as processed.
  
  Specified by:
  
  xack in interface RedisStreamReactiveCommands<K,V>
  
  Parameters:
  
  key - the stream key.
  
  group - name of the consumer group.
  
  messageIds - message Id's to acknowledge.
  
  Returns:
  
  simple-reply the lenght of acknowledged messages.
- xadd
  
  public Mono<String> xadd(K key, Map<K,V> body)
  
  Description copied from interface: RedisStreamReactiveCommands
  
  Append a message to the stream key.
  
  Specified by:
  
  xadd in interface RedisStreamReactiveCommands<K,V>
  
  Parameters:
  
  key - the stream key.
  
  body - message body.
  
  Returns:
  
  simple-reply the message Id.
- xadd
  
  public Mono<String> xadd(K key, XAddArgs args, Map<K,V> body)
  
  Description copied from interface: RedisStreamReactiveCommands
  
  Append a message to the stream key.
  
  Specified by:
  
  xadd in interface RedisStreamReactiveCommands<K,V>
  
  Parameters:
  
  key - the stream key.
  
  body - message body.
  
  Returns:
  
  simple-reply the message Id.
- xadd
  
  public Mono<String> xadd(K key, Object... keysAndValues)
  
  Description copied from interface: RedisStreamReactiveCommands
  
  Append a message to the stream key.
  
  Specified by:
  
  xadd in interface RedisStreamReactiveCommands<K,V>
  
  Parameters:
  
  key - the stream key.
  
  keysAndValues - message body.
  
  Returns:
  
  simple-reply the message Id.
- xadd
  
  public Mono<String> xadd(K key, XAddArgs args, Object... keysAndValues)
  
  Description copied from interface: RedisStreamReactiveCommands
  
  Append a message to the stream key.
  
  Specified by:
  
  xadd in interface RedisStreamReactiveCommands<K,V>
  
  Parameters:
  
  key - the stream key.
  
  keysAndValues - message body.
  
  Returns:
  
  simple-reply the message Id.
- xautoclaim
  
  public Mono<ClaimedMessages<K,V>> xautoclaim(K key, XAutoClaimArgs<K> args)
  
  Description copied from interface: RedisStreamReactiveCommands
  
  Gets ownership of one or multiple messages in the Pending Entries List of a given stream consumer group.
  
  Specified by:
  
  xautoclaim in interface RedisStreamReactiveCommands<K,V>
  
  Parameters:
  
  key - the stream key.
  
  Returns:
  
  simple-reply the claimed stream messages.
- xclaim
  
  public Flux<StreamMessage<K,V>> xclaim(K key, Consumer<K> consumer, long minIdleTime, String... messageIds)
  
  Description copied from interface: RedisStreamReactiveCommands
  
  Gets ownership of one or multiple messages in the Pending Entries List of a given stream consumer group.
  
  Specified by:
  
  xclaim in interface RedisStreamReactiveCommands<K,V>
  
  Parameters:
  
  key - the stream key.
  
  consumer - consumer identified by group name and consumer key.
  
  messageIds - message Id's to claim.
  
  Returns:
  
  simple-reply the StreamMessage.
- xclaim
  
  public Flux<StreamMessage<K,V>> xclaim(K key, Consumer<K> consumer, XClaimArgs args, String... messageIds)
  
  Description copied from interface: RedisStreamReactiveCommands
  
  Gets ownership of one or multiple messages in the Pending Entries List of a given stream consumer group.
  Note that setting the JUSTID flag (calling this method with XClaimArgs.justid()) suppresses the message bode and StreamMessage.getBody() is null.
  
  Specified by:
  
  xclaim in interface RedisStreamReactiveCommands<K,V>
  
  Parameters:
  
  key - the stream key.
  
  consumer - consumer identified by group name and consumer key.
  
  messageIds - message Id's to claim.
  
  Returns:
  
  simple-reply the StreamMessage.
- xdel
  
  public Mono<Long> xdel(K key, String... messageIds)
  
  Description copied from interface: RedisStreamReactiveCommands
  
  Removes the specified entries from the stream. Returns the number of items deleted, that may be different from the number of IDs passed in case certain IDs do not exist.
  
  Specified by:
  
  xdel in interface RedisStreamReactiveCommands<K,V>
  
  Parameters:
  
  key - the stream key.
  
  messageIds - stream message Id's.
  
  Returns:
  
  simple-reply number of removed entries.
- xgroupCreate
  
  public Mono<String> xgroupCreate(XReadArgs.StreamOffset<K> streamOffset, K group)
  
  Description copied from interface: RedisStreamReactiveCommands
  
  Create a consumer group.
  
  Specified by:
  
  xgroupCreate in interface RedisStreamReactiveCommands<K,V>
  
  Parameters:
  
  streamOffset - name of the stream containing the offset to set.
  
  group - name of the consumer group.
  
  Returns:
  
  simple-reply true if successful.
- xgroupCreate
  
  public Mono<String> xgroupCreate(XReadArgs.StreamOffset<K> streamOffset, K group, XGroupCreateArgs args)
  
  Description copied from interface: RedisStreamReactiveCommands
  
  Create a consumer group.
  
  Specified by:
  
  xgroupCreate in interface RedisStreamReactiveCommands<K,V>
  
  Parameters:
  
  streamOffset - name of the stream containing the offset to set.
  
  group - name of the consumer group.
  
  Returns:
  
  simple-reply true if successful.
- xgroupCreateconsumer
  
  public Mono<Boolean> xgroupCreateconsumer(K key, Consumer<K> consumer)
  
  Description copied from interface: RedisStreamReactiveCommands
  
  Create a consumer from a consumer group.
  
  Specified by:
  
  xgroupCreateconsumer in interface RedisStreamReactiveCommands<K,V>
  
  Parameters:
  
  key - the stream key.
  
  consumer - consumer identified by group name and consumer key.
  
  Returns:
  
  simple-reply true if successful.
- xgroupDelconsumer
  
  public Mono<Long> xgroupDelconsumer(K key, Consumer<K> consumer)
  
  Description copied from interface: RedisStreamReactiveCommands
  
  Delete a consumer from a consumer group.
  
  Specified by:
  
  xgroupDelconsumer in interface RedisStreamReactiveCommands<K,V>
  
  Parameters:
  
  key - the stream key.
  
  consumer - consumer identified by group name and consumer key.
  
  Returns:
  
  Long integer-reply number of pending messages.
- xgroupDestroy
  
  public Mono<Boolean> xgroupDestroy(K key, K group)
  
  Description copied from interface: RedisStreamReactiveCommands
  
  Destroy a consumer group.
  
  Specified by:
  
  xgroupDestroy in interface RedisStreamReactiveCommands<K,V>
  
  Parameters:
  
  key - the stream key.
  
  group - name of the consumer group.
  
  Returns:
  
  simple-reply true if successful.
- xgroupSetid
  
  public Mono<String> xgroupSetid(XReadArgs.StreamOffset<K> streamOffset, K group)
  
  Description copied from interface: RedisStreamReactiveCommands
  
  Set the current group id.
  
  Specified by:
  
  xgroupSetid in interface RedisStreamReactiveCommands<K,V>
  
  Parameters:
  
  streamOffset - name of the stream containing the offset to set.
  
  group - name of the consumer group.
  
  Returns:
  
  simple-reply OK.
- xinfoStream
  
  public Flux<Object> xinfoStream(K key)
  
  Description copied from interface: RedisStreamReactiveCommands
  
  Retrieve information about the stream at key.
  
  Specified by:
  
  xinfoStream in interface RedisStreamReactiveCommands<K,V>
  
  Parameters:
  
  key - the stream key.
  
  Returns:
  
  Object array-reply.
- xinfoGroups
  
  public Flux<Object> xinfoGroups(K key)
  
  Description copied from interface: RedisStreamReactiveCommands
  
  Retrieve information about the stream consumer groups at key.
  
  Specified by:
  
  xinfoGroups in interface RedisStreamReactiveCommands<K,V>
  
  Parameters:
  
  key - the stream key.
  
  Returns:
  
  Object array-reply.
- xinfoConsumers
  
  public Flux<Object> xinfoConsumers(K key, K group)
  
  Description copied from interface: RedisStreamReactiveCommands
  
  Retrieve information about consumer groups of group group and stream at key.
  
  Specified by:
  
  xinfoConsumers in interface RedisStreamReactiveCommands<K,V>
  
  Parameters:
  
  key - the stream key.
  
  group - name of the consumer group.
  
  Returns:
  
  Object array-reply.
- xlen
  
  public Mono<Long> xlen(K key)
  
  Description copied from interface: RedisStreamReactiveCommands
  
  Get the length of a steam.
  
  Specified by:
  
  xlen in interface RedisStreamReactiveCommands<K,V>
  
  Parameters:
  
  key - the stream key.
  
  Returns:
  
  simple-reply the lenght of the stream.
- xpending
  
  public Mono<PendingMessages> xpending(K key, K group)
  
  Description copied from interface: RedisStreamReactiveCommands
  
  Read pending messages from a stream for a group.
  
  Specified by:
  
  xpending in interface RedisStreamReactiveCommands<K,V>
  
  Parameters:
  
  key - the stream key.
  
  group - name of the consumer group.
  
  Returns:
  
  Object array-reply list pending entries.
- xpending
  
  public Flux<PendingMessage> xpending(K key, K group, Range<String> range, Limit limit)
  
  Description copied from interface: RedisStreamReactiveCommands
  
  Read pending messages from a stream within a specific Range.
  
  Specified by:
  
  xpending in interface RedisStreamReactiveCommands<K,V>
  
  Parameters:
  
  key - the stream key.
  
  group - name of the consumer group.
  
  range - must not be null.
  
  limit - must not be null.
  
  Returns:
  
  Object array-reply list with members of the resulting stream.
- xpending
  
  public Flux<PendingMessage> xpending(K key, Consumer<K> consumer, Range<String> range, Limit limit)
  
  Description copied from interface: RedisStreamReactiveCommands
  
  Read pending messages from a stream within a specific Range.
  
  Specified by:
  
  xpending in interface RedisStreamReactiveCommands<K,V>
  
  Parameters:
  
  key - the stream key.
  
  consumer - consumer identified by group name and consumer key.
  
  range - must not be null.
  
  limit - must not be null.
  
  Returns:
  
  Object array-reply list with members of the resulting stream.
- xpending
  
  public Flux<PendingMessage> xpending(K key, XPendingArgs<K> args)
  
  Description copied from interface: RedisStreamReactiveCommands
  
  Read pending messages from a stream within a specific XPendingArgs.
  
  Specified by:
  
  xpending in interface RedisStreamReactiveCommands<K,V>
  
  Parameters:
  
  key - the stream key.
  
  Returns:
  
  Object array-reply list with members of the resulting stream.
- xrange
  
  public Flux<StreamMessage<K,V>> xrange(K key, Range<String> range)
  
  Description copied from interface: RedisStreamReactiveCommands
  
  Read messages from a stream within a specific Range.
  
  Specified by:
  
  xrange in interface RedisStreamReactiveCommands<K,V>
  
  Parameters:
  
  key - the stream key.
  
  range - must not be null.
  
  Returns:
  
  StreamMessage array-reply list with members of the resulting stream.
- xrange
  
  public Flux<StreamMessage<K,V>> xrange(K key, Range<String> range, Limit limit)
  
  Description copied from interface: RedisStreamReactiveCommands
  
  Read messages from a stream within a specific Range applying a Limit.
  
  Specified by:
  
  xrange in interface RedisStreamReactiveCommands<K,V>
  
  Parameters:
  
  key - the stream key.
  
  range - must not be null.
  
  limit - must not be null.
  
  Returns:
  
  StreamMessage array-reply list with members of the resulting stream.
- xread
  
  public Flux<StreamMessage<K,V>> xread(XReadArgs.StreamOffset<K>... streams)
  
  Description copied from interface: RedisStreamReactiveCommands
  
  Read messages from one or more XReadArgs.StreamOffsets.
  
  Specified by:
  
  xread in interface RedisStreamReactiveCommands<K,V>
  
  Parameters:
  
  streams - the streams to read from.
  
  Returns:
  
  StreamMessage array-reply list with members of the resulting stream.
- xread
  
  public Flux<StreamMessage<K,V>> xread(XReadArgs args, XReadArgs.StreamOffset<K>... streams)
  
  Description copied from interface: RedisStreamReactiveCommands
  
  Read messages from one or more XReadArgs.StreamOffsets.
  
  Specified by:
  
  xread in interface RedisStreamReactiveCommands<K,V>
  
  Parameters:
  
  args - read arguments.
  
  streams - the streams to read from.
  
  Returns:
  
  StreamMessage array-reply list with members of the resulting stream.
- xreadgroup
  
  public Flux<StreamMessage<K,V>> xreadgroup(Consumer<K> consumer, XReadArgs.StreamOffset<K>... streams)
  
  Description copied from interface: RedisStreamReactiveCommands
  
  Read messages from one or more XReadArgs.StreamOffsets using a consumer group.
  
  Specified by:
  
  xreadgroup in interface RedisStreamReactiveCommands<K,V>
  
  Parameters:
  
  consumer - consumer/group.
  
  streams - the streams to read from.
  
  Returns:
  
  StreamMessage array-reply list with members of the resulting stream.
- xreadgroup
  
  public Flux<StreamMessage<K,V>> xreadgroup(Consumer<K> consumer, XReadArgs args, XReadArgs.StreamOffset<K>... streams)
  
  Description copied from interface: RedisStreamReactiveCommands
  
  Read messages from one or more XReadArgs.StreamOffsets using a consumer group.
  
  Specified by:
  
  xreadgroup in interface RedisStreamReactiveCommands<K,V>
  
  Parameters:
  
  consumer - consumer/group.
  
  args - read arguments.
  
  streams - the streams to read from.
  
  Returns:
  
  StreamMessage array-reply list with members of the resulting stream.
- xrevrange
  
  public Flux<StreamMessage<K,V>> xrevrange(K key, Range<String> range)
  
  Description copied from interface: RedisStreamReactiveCommands
  
  Read messages from a stream within a specific Range in reverse order.
  
  Specified by:
  
  xrevrange in interface RedisStreamReactiveCommands<K,V>
  
  Parameters:
  
  key - the stream key.
  
  range - must not be null.
  
  Returns:
  
  StreamMessage array-reply list with members of the resulting stream.
- xrevrange
  
  public Flux<StreamMessage<K,V>> xrevrange(K key, Range<String> range, Limit limit)
  
  Description copied from interface: RedisStreamReactiveCommands
  
  Read messages from a stream within a specific Range applying a Limit in reverse order.
  
  Specified by:
  
  xrevrange in interface RedisStreamReactiveCommands<K,V>
  
  Parameters:
  
  key - the stream key.
  
  range - must not be null.
  
  limit - must not be null.
  
  Returns:
  
  StreamMessage array-reply list with members of the resulting stream.
- xtrim
  
  public Mono<Long> xtrim(K key, long count)
  
  Description copied from interface: RedisStreamReactiveCommands
  
  Trims the stream to count elements.
  
  Specified by:
  
  xtrim in interface RedisStreamReactiveCommands<K,V>
  
  Parameters:
  
  key - the stream key.
  
  count - length of the stream.
  
  Returns:
  
  simple-reply number of removed entries.
- xtrim
  
  public Mono<Long> xtrim(K key, boolean approximateTrimming, long count)
  
  Description copied from interface: RedisStreamReactiveCommands
  
  Trims the stream to count elements.
  
  Specified by:
  
  xtrim in interface RedisStreamReactiveCommands<K,V>
  
  Parameters:
  
  key - the stream key.
  
  approximateTrimming - true to trim approximately using the ~ flag.
  
  count - length of the stream.
  
  Returns:
  
  simple-reply number of removed entries.
- xtrim
  
  public Mono<Long> xtrim(K key, XTrimArgs args)
  
  Description copied from interface: RedisStreamReactiveCommands
  
  Trims the stream within a specific XTrimArgs.
  
  Specified by:
  
  xtrim in interface RedisStreamReactiveCommands<K,V>
  
  Parameters:
  
  key - the stream key.
  
  Returns:
  
  simple-reply number of removed entries.
- bzpopmin
  
  public Mono<KeyValue<K,ScoredValue<V>>> bzpopmin(long timeout, K... keys)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Removes and returns a member with the lowest scores in the sorted set stored at one of the keys.
  
  Specified by:
  
  bzpopmin in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  timeout - the timeout in seconds.
  
  keys - the keys.
  
  Returns:
  
  KeyValue<K, ScoredValue<V>> multi-bulk containing the name of the key, the score and the popped member.
- bzpopmin
  
  public Mono<KeyValue<K,ScoredValue<V>>> bzpopmin(double timeout, K... keys)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Removes and returns a member with the lowest scores in the sorted set stored at one of the keys.
  
  Specified by:
  
  bzpopmin in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  timeout - the timeout in seconds.
  
  keys - the keys.
  
  Returns:
  
  KeyValue<K, ScoredValue<V>> multi-bulk containing the name of the key, the score and the popped member.
- bzpopmax
  
  public Mono<KeyValue<K,ScoredValue<V>>> bzpopmax(long timeout, K... keys)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Removes and returns a member with the highest scores in the sorted set stored at one of the keys.
  
  Specified by:
  
  bzpopmax in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  timeout - the timeout in seconds.
  
  keys - the keys.
  
  Returns:
  
  KeyValue<K, ScoredValue<V>> multi-bulk containing the name of the key, the score and the popped member.
- bzpopmax
  
  public Mono<KeyValue<K,ScoredValue<V>>> bzpopmax(double timeout, K... keys)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Removes and returns a member with the highest scores in the sorted set stored at one of the keys.
  
  Specified by:
  
  bzpopmax in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  timeout - the timeout in seconds.
  
  keys - the keys.
  
  Returns:
  
  KeyValue<K, ScoredValue<V>> multi-bulk containing the name of the key, the score and the popped member.
- zadd
  
  public Mono<Long> zadd(K key, double score, V member)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Add one or more members to a sorted set, or update its score if it already exists.
  
  Specified by:
  
  zadd in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  score - the score.
  
  member - the member.
  
  Returns:
  
  Long integer-reply specifically: The number of elements added to the sorted sets, not including elements already existing for which the score was updated.
- zadd
  
  public Mono<Long> zadd(K key, Object... scoresAndValues)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Add one or more members to a sorted set, or update its score if it already exists.
  
  Specified by:
  
  zadd in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  scoresAndValues - the scoresAndValue tuples (score,value,score,value,...).
  
  Returns:
  
  Long integer-reply specifically: The number of elements added to the sorted sets, not including elements already existing for which the score was updated.
- zadd
  
  public Mono<Long> zadd(K key, ScoredValue<V>... scoredValues)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Add one or more members to a sorted set, or update its score if it already exists.
  
  Specified by:
  
  zadd in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  scoredValues - the scored values.
  
  Returns:
  
  Long integer-reply specifically: The number of elements added to the sorted sets, not including elements already existing for which the score was updated.
- zadd
  
  public Mono<Long> zadd(K key, ZAddArgs zAddArgs, double score, V member)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Add one or more members to a sorted set, or update its score if it already exists.
  
  Specified by:
  
  zadd in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  zAddArgs - arguments for zadd.
  
  score - the score.
  
  member - the member.
  
  Returns:
  
  Long integer-reply specifically: The number of elements added to the sorted sets, not including elements already existing for which the score was updated.
- zadd
  
  public Mono<Long> zadd(K key, ZAddArgs zAddArgs, Object... scoresAndValues)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Add one or more members to a sorted set, or update its score if it already exists.
  
  Specified by:
  
  zadd in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  zAddArgs - arguments for zadd.
  
  scoresAndValues - the scoresAndValue tuples (score,value,score,value,...).
  
  Returns:
  
  Long integer-reply specifically: The number of elements added to the sorted sets, not including elements already existing for which the score was updated.
- zadd
  
  public Mono<Long> zadd(K key, ZAddArgs zAddArgs, ScoredValue<V>... scoredValues)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Add one or more members to a sorted set, or update its score if it already exists.
  
  Specified by:
  
  zadd in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the ke.
  
  zAddArgs - arguments for zadd.
  
  scoredValues - the scored values.
  
  Returns:
  
  Long integer-reply specifically: The number of elements added to the sorted sets, not including elements already existing for which the score was updated.
- zaddincr
  
  public Mono<Double> zaddincr(K key, double score, V member)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Add one or more members to a sorted set, or update its score if it already exists applying the INCR option. ZADD acts like ZINCRBY.
  
  Specified by:
  
  zaddincr in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  score - the score.
  
  member - the member.
  
  Returns:
  
  Long integer-reply specifically: The total number of elements changed.
- zaddincr
  
  public Mono<Double> zaddincr(K key, ZAddArgs zAddArgs, double score, V member)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Add one or more members to a sorted set, or update its score if it already exists applying the INCR option. ZADD acts like ZINCRBY.
  
  Specified by:
  
  zaddincr in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  zAddArgs - arguments for zadd.
  
  score - the score.
  
  member - the member.
  
  Returns:
  
  Long integer-reply specifically: The total number of elements changed.
- zcard
  
  public Mono<Long> zcard(K key)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Get the number of members in a sorted set.
  
  Specified by:
  
  zcard in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  Returns:
  
  Long integer-reply the cardinality (number of elements) of the sorted set, or false if key does not exist.
- zcount
  
  public Mono<Long> zcount(K key, double min, double max)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Count the members in a sorted set with scores within the given values.
  
  Specified by:
  
  zcount in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  min - min score.
  
  max - max score.
  
  Returns:
  
  Long integer-reply the number of elements in the specified score range.
- zcount
  
  public Mono<Long> zcount(K key, String min, String max)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Count the members in a sorted set with scores within the given values.
  
  Specified by:
  
  zcount in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  min - min score.
  
  max - max score.
  
  Returns:
  
  Long integer-reply the number of elements in the specified score range.
- zcount
  
  public Mono<Long> zcount(K key, Range<? extends Number> range)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Count the members in a sorted set with scores within the given Range.
  
  Specified by:
  
  zcount in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  range - the range.
  
  Returns:
  
  Long integer-reply the number of elements in the specified score range.
- zdiff
  
  public Flux<V> zdiff(K... keys)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Computes the difference between the first and all successive input sorted sets.
  
  Specified by:
  
  zdiff in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  keys - the keys.
  
  Returns:
  
  V array-reply list of elements.
- zdiffstore
  
  public Mono<Long> zdiffstore(K destKey, K... srcKeys)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Computes the difference between the first and all successive input sorted sets and stores the result in destination.
  
  Specified by:
  
  zdiffstore in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  destKey - the dest key.
  
  srcKeys - the src keys.
  
  Returns:
  
  Long the number of elements in the resulting sorted set at destination.
- zdiffWithScores
  
  public Flux<ScoredValue<V>> zdiffWithScores(K... keys)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Computes the difference between the first and all successive input sorted sets.
  
  Specified by:
  
  zdiffWithScores in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  keys - the keys.
  
  Returns:
  
  V array-reply list of scored values.
- zincrby
  
  public Mono<Double> zincrby(K key, double amount, V member)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Increment the score of a member in a sorted set.
  
  Specified by:
  
  zincrby in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  amount - the increment type: long.
  
  member - the member type: value.
  
  Returns:
  
  Double bulk-string-reply the new score of member (a double precision floating point number), represented as string.
- zinter
  
  public Flux<V> zinter(K... keys)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Intersect multiple sorted sets and returns the resulting sorted.
  
  Specified by:
  
  zinter in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  keys - the keys.
  
  Returns:
  
  V array-reply list of elements.
- zinter
  
  public Flux<V> zinter(ZAggregateArgs aggregateArgs, K... keys)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Intersect multiple sorted sets and returns the resulting sorted.
  
  Specified by:
  
  zinter in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  aggregateArgs - arguments to define aggregation and weights.
  
  keys - the keys.
  
  Returns:
  
  V array-reply list of elements.
- zinterWithScores
  
  public Flux<ScoredValue<V>> zinterWithScores(K... keys)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Intersect multiple sorted sets and returns the resulting sorted.
  
  Specified by:
  
  zinterWithScores in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  keys - the keys.
  
  Returns:
  
  V array-reply list of scored values.
- zinterWithScores
  
  public Flux<ScoredValue<V>> zinterWithScores(ZAggregateArgs aggregateArgs, K... keys)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Intersect multiple sorted sets and returns the resulting sorted.
  
  Specified by:
  
  zinterWithScores in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  aggregateArgs - arguments to define aggregation and weights.
  
  keys - the keys.
  
  Returns:
  
  V array-reply list of scored values.
- zinterstore
  
  public Mono<Long> zinterstore(K destination, K... keys)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Intersect multiple sorted sets and store the resulting sorted set in a new key.
  
  Specified by:
  
  zinterstore in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  destination - the destination.
  
  keys - the keys.
  
  Returns:
  
  Long integer-reply the number of elements in the resulting sorted set at destination.
- zinterstore
  
  public Mono<Long> zinterstore(K destination, ZStoreArgs zStoreArgs, K... keys)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Intersect multiple sorted sets and store the resulting sorted set in a new key.
  
  Specified by:
  
  zinterstore in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  destination - the destination.
  
  zStoreArgs - arguments to define aggregation and weights.
  
  keys - the keys.
  
  Returns:
  
  Long integer-reply the number of elements in the resulting sorted set at destination.
- zlexcount
  
  public Mono<Long> zlexcount(K key, String min, String max)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Count the number of members in a sorted set between a given lexicographical range.
  
  Specified by:
  
  zlexcount in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  min - min score.
  
  max - max score.
  
  Returns:
  
  Long integer-reply the number of elements in the specified score range.
- zlexcount
  
  public Mono<Long> zlexcount(K key, Range<? extends V> range)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Count the number of members in a sorted set between a given lexicographical range.
  
  Specified by:
  
  zlexcount in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  range - the range.
  
  Returns:
  
  Long integer-reply the number of elements in the specified score range.
- zmscore
  
  public Mono<List<Double>> zmscore(K key, V... members)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Returns the scores associated with the specified members in the sorted set stored at key.
  
  Specified by:
  
  zmscore in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  members - the member type: value.
  
  Returns:
  
  Double array-reply list of scores or nil associated with the specified member values.
- zpopmin
  
  public Mono<ScoredValue<V>> zpopmin(K key)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Removes and returns up to count members with the lowest scores in the sorted set stored at key.
  
  Specified by:
  
  zpopmin in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  Returns:
  
  ScoredValue<V> the removed element.
- zpopmin
  
  public Flux<ScoredValue<V>> zpopmin(K key, long count)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Removes and returns up to count members with the lowest scores in the sorted set stored at key.
  
  Specified by:
  
  zpopmin in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  count - the number of elements to return.
  
  Returns:
  
  ScoredValue<V> array-reply list of popped scores and elements.
- zpopmax
  
  public Mono<ScoredValue<V>> zpopmax(K key)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Removes and returns up to count members with the highest scores in the sorted set stored at key.
  
  Specified by:
  
  zpopmax in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  Returns:
  
  ScoredValue<V> the removed element.
- zpopmax
  
  public Flux<ScoredValue<V>> zpopmax(K key, long count)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Removes and returns up to count members with the highest scores in the sorted set stored at key.
  
  Specified by:
  
  zpopmax in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  count - the number of elements to return.
  
  Returns:
  
  ScoredValue<V> array-reply list of popped scores and elements.
- zrandmember
  
  public Mono<V> zrandmember(K key)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Return a random member from the sorted set stored at key.
  
  Specified by:
  
  zrandmember in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  Returns:
  
  element.
- zrandmember
  
  public Flux<V> zrandmember(K key, long count)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Return count random members from the sorted set stored at key.
  
  Specified by:
  
  zrandmember in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  count - the number of members to return. If the provided count argument is positive, return an array of distinct fields.
  
  Returns:
  
  ScoredValue<V> array-reply list of scores and elements.
- zrandmemberWithScores
  
  public Mono<ScoredValue<V>> zrandmemberWithScores(K key)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Return a random member along its value from the sorted set stored at key.
  
  Specified by:
  
  zrandmemberWithScores in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  Returns:
  
  the score and element.
- zrandmemberWithScores
  
  public Flux<ScoredValue<V>> zrandmemberWithScores(K key, long count)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Return count random members along their value from the sorted set stored at key.
  
  Specified by:
  
  zrandmemberWithScores in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  count - the number of members to return. If the provided count argument is positive, return an array of distinct fields.
  
  Returns:
  
  ScoredValue<V> array-reply list of scores and elements.
- zrange
  
  public Flux<V> zrange(K key, long start, long stop)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Return a range of members in a sorted set, by index.
  
  Specified by:
  
  zrange in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  start - the start.
  
  stop - the stop.
  
  Returns:
  
  V array-reply list of elements in the specified range.
- zrange
  
  public Mono<Long> zrange(ValueStreamingChannel<V> channel, K key, long start, long stop)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Return a range of members in a sorted set, by index.
  
  Specified by:
  
  zrange in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  channel - streaming channel that receives a call for every value.
  
  key - the key.
  
  start - the start.
  
  stop - the stop.
  
  Returns:
  
  Long count of elements in the specified range.
- zrangeWithScores
  
  public Flux<ScoredValue<V>> zrangeWithScores(K key, long start, long stop)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Return a range of members with scores in a sorted set, by index.
  
  Specified by:
  
  zrangeWithScores in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  start - the start.
  
  stop - the stop.
  
  Returns:
  
  V array-reply list of elements in the specified range.
- zrangeWithScores
  
  public Mono<Long> zrangeWithScores(ScoredValueStreamingChannel<V> channel, K key, long start, long stop)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Stream over a range of members with scores in a sorted set, by index.
  
  Specified by:
  
  zrangeWithScores in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  channel - streaming channel that receives a call for every value.
  
  key - the key.
  
  start - the start.
  
  stop - the stop.
  
  Returns:
  
  Long count of elements in the specified range.
- zrangebylex
  
  public Flux<V> zrangebylex(K key, String min, String max)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Return a range of members in a sorted set, by lexicographical range.
  
  Specified by:
  
  zrangebylex in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  min - min score.
  
  max - max score.
  
  Returns:
  
  V array-reply list of elements in the specified range.
- zrangebylex
  
  public Flux<V> zrangebylex(K key, Range<? extends V> range)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Return a range of members in a sorted set, by lexicographical range.
  
  Specified by:
  
  zrangebylex in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  range - the range.
  
  Returns:
  
  V array-reply list of elements in the specified range.
- zrangebylex
  
  public Flux<V> zrangebylex(K key, String min, String max, long offset, long count)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Return a range of members in a sorted set, by lexicographical range.
  
  Specified by:
  
  zrangebylex in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  min - min score.
  
  max - max score.
  
  offset - the offset.
  
  count - the count.
  
  Returns:
  
  V array-reply list of elements in the specified range.
- zrangebylex
  
  public Flux<V> zrangebylex(K key, Range<? extends V> range, Limit limit)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Return a range of members in a sorted set, by lexicographical range.
  
  Specified by:
  
  zrangebylex in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  range - the range.
  
  limit - the limit.
  
  Returns:
  
  V array-reply list of elements in the specified range.
- zrangebyscore
  
  public Flux<V> zrangebyscore(K key, double min, double max)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Return a range of members in a sorted set, by score.
  
  Specified by:
  
  zrangebyscore in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  min - min score.
  
  max - max score.
  
  Returns:
  
  V array-reply list of elements in the specified score range.
- zrangebyscore
  
  public Flux<V> zrangebyscore(K key, String min, String max)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Return a range of members in a sorted set, by score.
  
  Specified by:
  
  zrangebyscore in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  min - min score.
  
  max - max score.
  
  Returns:
  
  V array-reply list of elements in the specified score range.
- zrangebyscore
  
  public Flux<V> zrangebyscore(K key, double min, double max, long offset, long count)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Return a range of members in a sorted set, by score.
  
  Specified by:
  
  zrangebyscore in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  min - min score.
  
  max - max score.
  
  offset - the offset.
  
  count - the count.
  
  Returns:
  
  V array-reply list of elements in the specified score range.
- zrangebyscore
  
  public Flux<V> zrangebyscore(K key, String min, String max, long offset, long count)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Return a range of members in a sorted set, by score.
  
  Specified by:
  
  zrangebyscore in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  min - min score.
  
  max - max score.
  
  offset - the offset.
  
  count - the count.
  
  Returns:
  
  V array-reply list of elements in the specified score range.
- zrangebyscore
  
  public Flux<V> zrangebyscore(K key, Range<? extends Number> range)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Return a range of members in a sorted set, by score.
  
  Specified by:
  
  zrangebyscore in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  range - the range.
  
  Returns:
  
  V array-reply list of elements in the specified score range.
- zrangebyscore
  
  public Flux<V> zrangebyscore(K key, Range<? extends Number> range, Limit limit)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Return a range of members in a sorted set, by score.
  
  Specified by:
  
  zrangebyscore in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  range - the range.
  
  limit - the limit.
  
  Returns:
  
  V array-reply list of elements in the specified score range.
- zrangebyscore
  
  public Mono<Long> zrangebyscore(ValueStreamingChannel<V> channel, K key, double min, double max)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Stream over a range of members in a sorted set, by score.
  
  Specified by:
  
  zrangebyscore in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  channel - streaming channel that receives a call for every value.
  
  key - the key.
  
  min - min score.
  
  max - max score.
  
  Returns:
  
  Long count of elements in the specified score range.
- zrangebyscore
  
  public Mono<Long> zrangebyscore(ValueStreamingChannel<V> channel, K key, String min, String max)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Stream over a range of members in a sorted set, by score.
  
  Specified by:
  
  zrangebyscore in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  channel - streaming channel that receives a call for every value.
  
  key - the key.
  
  min - min score.
  
  max - max score.
  
  Returns:
  
  Long count of elements in the specified score range.
- zrangebyscore
  
  public Mono<Long> zrangebyscore(ValueStreamingChannel<V> channel, K key, double min, double max, long offset, long count)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Stream over range of members in a sorted set, by score.
  
  Specified by:
  
  zrangebyscore in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  channel - streaming channel that receives a call for every value.
  
  key - the key.
  
  min - min score.
  
  max - max score.
  
  offset - the offset.
  
  count - the count.
  
  Returns:
  
  Long count of elements in the specified score range.
- zrangebyscore
  
  public Mono<Long> zrangebyscore(ValueStreamingChannel<V> channel, K key, Range<? extends Number> range)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Stream over a range of members in a sorted set, by score.
  
  Specified by:
  
  zrangebyscore in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  channel - streaming channel that receives a call for every value.
  
  key - the key.
  
  range - the range.
  
  Returns:
  
  Long count of elements in the specified score range.
- zrangebyscore
  
  public Mono<Long> zrangebyscore(ValueStreamingChannel<V> channel, K key, String min, String max, long offset, long count)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Stream over a range of members in a sorted set, by score.
  
  Specified by:
  
  zrangebyscore in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  channel - streaming channel that receives a call for every value.
  
  key - the key.
  
  min - min score.
  
  max - max score.
  
  offset - the offset.
  
  count - the count.
  
  Returns:
  
  Long count of elements in the specified score range.
- zrangebyscore
  
  public Mono<Long> zrangebyscore(ValueStreamingChannel<V> channel, K key, Range<? extends Number> range, Limit limit)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Stream over a range of members in a sorted set, by score.
  
  Specified by:
  
  zrangebyscore in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  channel - streaming channel that receives a call for every value.
  
  key - the key.
  
  range - the range.
  
  limit - the limit.
  
  Returns:
  
  Long count of elements in the specified score range.
- zrangebyscoreWithScores
  
  public Flux<ScoredValue<V>> zrangebyscoreWithScores(K key, double min, double max)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Return a range of members with score in a sorted set, by score.
  
  Specified by:
  
  zrangebyscoreWithScores in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  min - min score.
  
  max - max score.
  
  Returns:
  
  ScoredValue<V> array-reply list of elements in the specified score range.
- zrangebyscoreWithScores
  
  public Flux<ScoredValue<V>> zrangebyscoreWithScores(K key, String min, String max)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Return a range of members with score in a sorted set, by score.
  
  Specified by:
  
  zrangebyscoreWithScores in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  min - min score.
  
  max - max score.
  
  Returns:
  
  ScoredValue<V> array-reply list of elements in the specified score range.
- zrangebyscoreWithScores
  
  public Flux<ScoredValue<V>> zrangebyscoreWithScores(K key, double min, double max, long offset, long count)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Return a range of members with score in a sorted set, by score.
  
  Specified by:
  
  zrangebyscoreWithScores in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  min - min score.
  
  max - max score.
  
  offset - the offset.
  
  count - the count.
  
  Returns:
  
  ScoredValue<V> array-reply list of elements in the specified score range.
- zrangebyscoreWithScores
  
  public Flux<ScoredValue<V>> zrangebyscoreWithScores(K key, String min, String max, long offset, long count)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Return a range of members with score in a sorted set, by score.
  
  Specified by:
  
  zrangebyscoreWithScores in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  min - min score.
  
  max - max score.
  
  offset - the offset.
  
  count - the count.
  
  Returns:
  
  ScoredValue<V> array-reply list of elements in the specified score range.
- zrangebyscoreWithScores
  
  public Flux<ScoredValue<V>> zrangebyscoreWithScores(K key, Range<? extends Number> range)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Return a range of members with score in a sorted set, by score.
  
  Specified by:
  
  zrangebyscoreWithScores in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  range - the range.
  
  Returns:
  
  ScoredValue<V> array-reply list of elements in the specified score range.
- zrangebyscoreWithScores
  
  public Flux<ScoredValue<V>> zrangebyscoreWithScores(K key, Range<? extends Number> range, Limit limit)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Return a range of members with score in a sorted set, by score.
  
  Specified by:
  
  zrangebyscoreWithScores in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  range - the range.
  
  limit - the limit.
  
  Returns:
  
  ScoredValue<V> array-reply list of elements in the specified score range.
- zrangebyscoreWithScores
  
  public Mono<Long> zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, double min, double max)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Stream over a range of members with scores in a sorted set, by score.
  
  Specified by:
  
  zrangebyscoreWithScores in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  channel - streaming channel that receives a call for every scored value.
  
  key - the key.
  
  min - min score.
  
  max - max score.
  
  Returns:
  
  Long count of elements in the specified score range.
- zrangebyscoreWithScores
  
  public Mono<Long> zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, String min, String max)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Stream over a range of members with scores in a sorted set, by score.
  
  Specified by:
  
  zrangebyscoreWithScores in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  channel - streaming channel that receives a call for every scored value.
  
  key - the key.
  
  min - min score.
  
  max - max score.
  
  Returns:
  
  Long count of elements in the specified score range.
- zrangebyscoreWithScores
  
  public Mono<Long> zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, Range<? extends Number> range)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Stream over a range of members with scores in a sorted set, by score.
  
  Specified by:
  
  zrangebyscoreWithScores in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  channel - streaming channel that receives a call for every scored value.
  
  key - the key.
  
  range - the range.
  
  Returns:
  
  Long count of elements in the specified score range.
- zrangebyscoreWithScores
  
  public Mono<Long> zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, double min, double max, long offset, long count)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Stream over a range of members with scores in a sorted set, by score.
  
  Specified by:
  
  zrangebyscoreWithScores in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  channel - streaming channel that receives a call for every scored value.
  
  key - the key.
  
  min - min score.
  
  max - max score.
  
  offset - the offset.
  
  count - the count.
  
  Returns:
  
  Long count of elements in the specified score range.
- zrangebyscoreWithScores
  
  public Mono<Long> zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, String min, String max, long offset, long count)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Stream over a range of members with scores in a sorted set, by score.
  
  Specified by:
  
  zrangebyscoreWithScores in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  channel - streaming channel that receives a call for every scored value.
  
  key - the key.
  
  min - min score.
  
  max - max score.
  
  offset - the offset.
  
  count - the count.
  
  Returns:
  
  Long count of elements in the specified score range.
- zrangebyscoreWithScores
  
  public Mono<Long> zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, Range<? extends Number> range, Limit limit)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Stream over a range of members with scores in a sorted set, by score.
  
  Specified by:
  
  zrangebyscoreWithScores in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  channel - streaming channel that receives a call for every scored value.
  
  key - the key.
  
  range - the range.
  
  limit - the limit.
  
  Returns:
  
  Long count of elements in the specified score range.
- zrangestorebylex
  
  public Mono<Long> zrangestorebylex(K dstKey, K srcKey, Range<? extends V> range, Limit limit)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Get the specified range of elements in the sorted set stored at srcKey and stores the result in the dstKey destination key.
  
  Specified by:
  
  zrangestorebylex in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  dstKey - the dst key.
  
  srcKey - the src key.
  
  range - the lexicographical range.
  
  Returns:
  
  The number of elements in the resulting sorted set.
- zrangestorebyscore
  
  public Mono<Long> zrangestorebyscore(K dstKey, K srcKey, Range<? extends Number> range, Limit limit)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Get the specified range of elements in the sorted set stored at srcKey and stores the result in the dstKey destination key.
  
  Specified by:
  
  zrangestorebyscore in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  dstKey - the dst key.
  
  srcKey - the src key.
  
  range - the score range.
  
  Returns:
  
  The number of elements in the resulting sorted set.
- zrank
  
  public Mono<Long> zrank(K key, V member)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Determine the index of a member in a sorted set.
  
  Specified by:
  
  zrank in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  member - the member type: value.
  
  Returns:
  
  Long integer-reply the rank of member. If member does not exist in the sorted set or key does not exist,.
- zrem
  
  public Mono<Long> zrem(K key, V... members)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Remove one or more members from a sorted set.
  
  Specified by:
  
  zrem in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  members - the member type: value.
  
  Returns:
  
  Long integer-reply specifically: The number of members removed from the sorted set, not including non existing members.
- zremrangebylex
  
  public Mono<Long> zremrangebylex(K key, String min, String max)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Remove all members in a sorted set between the given lexicographical range.
  
  Specified by:
  
  zremrangebylex in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  min - min score.
  
  max - max score.
  
  Returns:
  
  Long integer-reply the number of elements removed.
- zremrangebylex
  
  public Mono<Long> zremrangebylex(K key, Range<? extends V> range)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Remove all members in a sorted set between the given lexicographical range.
  
  Specified by:
  
  zremrangebylex in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  range - the range.
  
  Returns:
  
  Long integer-reply the number of elements removed.
- zremrangebyrank
  
  public Mono<Long> zremrangebyrank(K key, long start, long stop)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Remove all members in a sorted set within the given indexes.
  
  Specified by:
  
  zremrangebyrank in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  start - the start type: long.
  
  stop - the stop type: long.
  
  Returns:
  
  Long integer-reply the number of elements removed.
- zremrangebyscore
  
  public Mono<Long> zremrangebyscore(K key, double min, double max)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Remove all members in a sorted set within the given scores.
  
  Specified by:
  
  zremrangebyscore in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  min - min score.
  
  max - max score.
  
  Returns:
  
  Long integer-reply the number of elements removed.
- zremrangebyscore
  
  public Mono<Long> zremrangebyscore(K key, String min, String max)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Remove all members in a sorted set within the given scores.
  
  Specified by:
  
  zremrangebyscore in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  min - min score.
  
  max - max score.
  
  Returns:
  
  Long integer-reply the number of elements removed.
- zremrangebyscore
  
  public Mono<Long> zremrangebyscore(K key, Range<? extends Number> range)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Remove all members in a sorted set within the given scores.
  
  Specified by:
  
  zremrangebyscore in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  range - the range.
  
  Returns:
  
  Long integer-reply the number of elements removed.
- zrevrange
  
  public Flux<V> zrevrange(K key, long start, long stop)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Return a range of members in a sorted set, by index, with scores ordered from high to low.
  
  Specified by:
  
  zrevrange in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  start - the start.
  
  stop - the stop.
  
  Returns:
  
  V array-reply list of elements in the specified range.
- zrevrange
  
  public Mono<Long> zrevrange(ValueStreamingChannel<V> channel, K key, long start, long stop)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Stream over a range of members in a sorted set, by index, with scores ordered from high to low.
  
  Specified by:
  
  zrevrange in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  channel - streaming channel that receives a call for every scored value.
  
  key - the key.
  
  start - the start.
  
  stop - the stop.
  
  Returns:
  
  Long count of elements in the specified range.
- zrevrangeWithScores
  
  public Flux<ScoredValue<V>> zrevrangeWithScores(K key, long start, long stop)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Return a range of members with scores in a sorted set, by index, with scores ordered from high to low.
  
  Specified by:
  
  zrevrangeWithScores in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  start - the start.
  
  stop - the stop.
  
  Returns:
  
  V array-reply list of elements in the specified range.
- zrevrangeWithScores
  
  public Mono<Long> zrevrangeWithScores(ScoredValueStreamingChannel<V> channel, K key, long start, long stop)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Stream over a range of members with scores in a sorted set, by index, with scores ordered from high to low.
  
  Specified by:
  
  zrevrangeWithScores in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  channel - streaming channel that receives a call for every scored value.
  
  key - the key.
  
  start - the start.
  
  stop - the stop.
  
  Returns:
  
  Long count of elements in the specified range.
- zrevrangebylex
  
  public Flux<V> zrevrangebylex(K key, Range<? extends V> range)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Return a range of members in a sorted set, by lexicographical range ordered from high to low.
  
  Specified by:
  
  zrevrangebylex in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  range - the range.
  
  Returns:
  
  V array-reply list of elements in the specified score range.
- zrevrangebylex
  
  public Flux<V> zrevrangebylex(K key, Range<? extends V> range, Limit limit)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Return a range of members in a sorted set, by lexicographical range ordered from high to low.
  
  Specified by:
  
  zrevrangebylex in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  range - the range.
  
  limit - the limit.
  
  Returns:
  
  V array-reply list of elements in the specified score range.
- zrevrangebyscore
  
  public Flux<V> zrevrangebyscore(K key, double max, double min)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Return a range of members in a sorted set, by score, with scores ordered from high to low.
  
  Specified by:
  
  zrevrangebyscore in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  max - max score.
  
  min - min score.
  
  Returns:
  
  V array-reply list of elements in the specified score range.
- zrevrangebyscore
  
  public Flux<V> zrevrangebyscore(K key, String max, String min)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Return a range of members in a sorted set, by score, with scores ordered from high to low.
  
  Specified by:
  
  zrevrangebyscore in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  max - max score.
  
  min - min score.
  
  Returns:
  
  V array-reply list of elements in the specified score range.
- zrevrangebyscore
  
  public Flux<V> zrevrangebyscore(K key, Range<? extends Number> range)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Return a range of members in a sorted set, by score, with scores ordered from high to low.
  
  Specified by:
  
  zrevrangebyscore in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  range - the range.
  
  Returns:
  
  V array-reply list of elements in the specified score range.
- zrevrangebyscore
  
  public Flux<V> zrevrangebyscore(K key, double max, double min, long offset, long count)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Return a range of members in a sorted set, by score, with scores ordered from high to low.
  
  Specified by:
  
  zrevrangebyscore in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  max - max score.
  
  min - min score.
  
  offset - the withscores.
  
  count - the null.
  
  Returns:
  
  V array-reply list of elements in the specified score range.
- zrevrangebyscore
  
  public Flux<V> zrevrangebyscore(K key, String max, String min, long offset, long count)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Return a range of members in a sorted set, by score, with scores ordered from high to low.
  
  Specified by:
  
  zrevrangebyscore in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  max - max score.
  
  min - min score.
  
  offset - the offset.
  
  count - the count.
  
  Returns:
  
  V array-reply list of elements in the specified score range.
- zrevrangebyscore
  
  public Flux<V> zrevrangebyscore(K key, Range<? extends Number> range, Limit limit)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Return a range of members in a sorted set, by score, with scores ordered from high to low.
  
  Specified by:
  
  zrevrangebyscore in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  range - the range.
  
  limit - the limit.
  
  Returns:
  
  V array-reply list of elements in the specified score range.
- zrevrangebyscore
  
  public Mono<Long> zrevrangebyscore(ValueStreamingChannel<V> channel, K key, double max, double min)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Stream over a range of members in a sorted set, by score, with scores ordered from high to low.
  
  Specified by:
  
  zrevrangebyscore in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  channel - streaming channel that receives a call for every value.
  
  key - the key.
  
  max - max score.
  
  min - min score.
  
  Returns:
  
  Long count of elements in the specified range.
- zrevrangebyscore
  
  public Mono<Long> zrevrangebyscore(ValueStreamingChannel<V> channel, K key, String max, String min)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Stream over a range of members in a sorted set, by score, with scores ordered from high to low.
  
  Specified by:
  
  zrevrangebyscore in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  channel - streaming channel that receives a call for every value.
  
  key - the key.
  
  max - max score.
  
  min - min score.
  
  Returns:
  
  Long count of elements in the specified range.
- zrevrangebyscore
  
  public Mono<Long> zrevrangebyscore(ValueStreamingChannel<V> channel, K key, Range<? extends Number> range)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Stream over a range of members in a sorted set, by score, with scores ordered from high to low.
  
  Specified by:
  
  zrevrangebyscore in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  channel - streaming channel that receives a call for every value.
  
  key - the key.
  
  range - the range.
  
  Returns:
  
  Long count of elements in the specified range.
- zrevrangebyscore
  
  public Mono<Long> zrevrangebyscore(ValueStreamingChannel<V> channel, K key, double max, double min, long offset, long count)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Stream over a range of members in a sorted set, by score, with scores ordered from high to low.
  
  Specified by:
  
  zrevrangebyscore in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  channel - streaming channel that receives a call for every value.
  
  key - the key.
  
  max - max score.
  
  min - min score.
  
  offset - the offset.
  
  count - the count.
  
  Returns:
  
  Long count of elements in the specified range.
- zrevrangebyscore
  
  public Mono<Long> zrevrangebyscore(ValueStreamingChannel<V> channel, K key, String max, String min, long offset, long count)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Stream over a range of members in a sorted set, by score, with scores ordered from high to low.
  
  Specified by:
  
  zrevrangebyscore in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  channel - streaming channel that receives a call for every value.
  
  key - the key.
  
  max - max score.
  
  min - min score.
  
  offset - the offset.
  
  count - the count.
  
  Returns:
  
  Long count of elements in the specified range.
- zrevrangebyscore
  
  public Mono<Long> zrevrangebyscore(ValueStreamingChannel<V> channel, K key, Range<? extends Number> range, Limit limit)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Stream over a range of members in a sorted set, by score, with scores ordered from high to low.
  
  Specified by:
  
  zrevrangebyscore in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  channel - streaming channel that receives a call for every value.
  
  key - the key.
  
  range - the range.
  
  limit - the limit.
  
  Returns:
  
  Long count of elements in the specified range.
- zrevrangebyscoreWithScores
  
  public Flux<ScoredValue<V>> zrevrangebyscoreWithScores(K key, double max, double min)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Return a range of members with scores in a sorted set, by score, with scores ordered from high to low.
  
  Specified by:
  
  zrevrangebyscoreWithScores in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  max - max score.
  
  min - min score.
  
  Returns:
  
  V array-reply list of elements in the specified score range.
- zrevrangebyscoreWithScores
  
  public Flux<ScoredValue<V>> zrevrangebyscoreWithScores(K key, String max, String min)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Return a range of members with scores in a sorted set, by score, with scores ordered from high to low.
  
  Specified by:
  
  zrevrangebyscoreWithScores in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  max - max score.
  
  min - min score.
  
  Returns:
  
  ScoredValue<V> array-reply list of elements in the specified score range.
- zrevrangebyscoreWithScores
  
  public Flux<ScoredValue<V>> zrevrangebyscoreWithScores(K key, Range<? extends Number> range)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Return a range of members with scores in a sorted set, by score, with scores ordered from high to low.
  
  Specified by:
  
  zrevrangebyscoreWithScores in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  range - the range.
  
  Returns:
  
  ScoredValue<V> array-reply list of elements in the specified score range.
- zrevrangebyscoreWithScores
  
  public Flux<ScoredValue<V>> zrevrangebyscoreWithScores(K key, double max, double min, long offset, long count)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Return a range of members with scores in a sorted set, by score, with scores ordered from high to low.
  
  Specified by:
  
  zrevrangebyscoreWithScores in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  max - max score.
  
  min - min score.
  
  offset - the offset.
  
  count - the count.
  
  Returns:
  
  ScoredValue<V> array-reply list of elements in the specified score range.
- zrevrangebyscoreWithScores
  
  public Flux<ScoredValue<V>> zrevrangebyscoreWithScores(K key, String max, String min, long offset, long count)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Return a range of members with scores in a sorted set, by score, with scores ordered from high to low.
  
  Specified by:
  
  zrevrangebyscoreWithScores in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  max - max score.
  
  min - min score.
  
  offset - the offset.
  
  count - the count.
  
  Returns:
  
  V array-reply list of elements in the specified score range.
- zrevrangebyscoreWithScores
  
  public Flux<ScoredValue<V>> zrevrangebyscoreWithScores(K key, Range<? extends Number> range, Limit limit)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Return a range of members with scores in a sorted set, by score, with scores ordered from high to low.
  
  Specified by:
  
  zrevrangebyscoreWithScores in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  range - the range.
  
  limit - limit.
  
  Returns:
  
  V array-reply list of elements in the specified score range.
- zrevrangebyscoreWithScores
  
  public Mono<Long> zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, double max, double min)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Stream over a range of members with scores in a sorted set, by score, with scores ordered from high to low.
  
  Specified by:
  
  zrevrangebyscoreWithScores in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  channel - streaming channel that receives a call for every scored value.
  
  key - the key.
  
  max - max score.
  
  min - min score.
  
  Returns:
  
  Long count of elements in the specified range.
- zrevrangebyscoreWithScores
  
  public Mono<Long> zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, String max, String min)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Stream over a range of members with scores in a sorted set, by score, with scores ordered from high to low.
  
  Specified by:
  
  zrevrangebyscoreWithScores in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  channel - streaming channel that receives a call for every scored value.
  
  key - the key.
  
  max - max score.
  
  min - min score.
  
  Returns:
  
  Long count of elements in the specified range.
- zrevrangebyscoreWithScores
  
  public Mono<Long> zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, Range<? extends Number> range)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Stream over a range of members with scores in a sorted set, by score, with scores ordered from high to low.
  
  Specified by:
  
  zrevrangebyscoreWithScores in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  channel - streaming channel that receives a call for every scored value.
  
  key - the key.
  
  range - the range.
  
  Returns:
  
  Long count of elements in the specified range.
- zrevrangebyscoreWithScores
  
  public Mono<Long> zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, double max, double min, long offset, long count)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Stream over a range of members with scores in a sorted set, by score, with scores ordered from high to low.
  
  Specified by:
  
  zrevrangebyscoreWithScores in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  channel - streaming channel that receives a call for every scored value.
  
  key - the key.
  
  max - max score.
  
  min - min score.
  
  offset - the offset.
  
  count - the count.
  
  Returns:
  
  Long count of elements in the specified range.
- zrevrangebyscoreWithScores
  
  public Mono<Long> zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, String max, String min, long offset, long count)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Stream over a range of members with scores in a sorted set, by score, with scores ordered from high to low.
  
  Specified by:
  
  zrevrangebyscoreWithScores in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  channel - streaming channel that receives a call for every scored value.
  
  key - the key.
  
  max - max score.
  
  min - min score.
  
  offset - the offset.
  
  count - the count.
  
  Returns:
  
  Long count of elements in the specified range.
- zrevrangebyscoreWithScores
  
  public Mono<Long> zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, Range<? extends Number> range, Limit limit)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Stream over a range of members with scores in a sorted set, by score, with scores ordered from high to low.
  
  Specified by:
  
  zrevrangebyscoreWithScores in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  channel - streaming channel that receives a call for every scored value.
  
  key - the key.
  
  range - the range.
  
  limit - the limit.
  
  Returns:
  
  Long count of elements in the specified range.
- zrevrangestorebylex
  
  public Mono<Long> zrevrangestorebylex(K dstKey, K srcKey, Range<? extends V> range, Limit limit)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Get the lexicographical range ordered from high to low of elements in the sorted set stored at srcKey and stores the result in the dstKey destination key.
  
  Specified by:
  
  zrevrangestorebylex in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  dstKey - the src key.
  
  srcKey - the dst key.
  
  range - the lexicographical range.
  
  Returns:
  
  The number of elements in the resulting sorted set.
- zrevrangestorebyscore
  
  public Mono<Long> zrevrangestorebyscore(K dstKey, K srcKey, Range<? extends Number> range, Limit limit)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Get the specified range of elements in the sorted set stored at {@code srcKey with scores ordered from high to low and stores the result in the {@code dstKey} destination key. @param dstKey the src key. @param srcKey the dst key. @param range the score range. @return The number of elements in the resulting sorted set. @since 6.1
  
  Specified by:
  
  zrevrangestorebyscore in interface RedisSortedSetReactiveCommands<K,V>
- zrevrank
  
  public Mono<Long> zrevrank(K key, V member)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Determine the index of a member in a sorted set, with scores ordered from high to low.
  
  Specified by:
  
  zrevrank in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  member - the member type: value.
  
  Returns:
  
  Long integer-reply the rank of member. If member does not exist in the sorted set or key does not exist,.
- zscan
  
  public Mono<ScoredValueScanCursor<V>> zscan(K key)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Incrementally iterate sorted sets elements and associated scores.
  
  Specified by:
  
  zscan in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  Returns:
  
  ScoredValueScanCursor<V> scan cursor.
- zscan
  
  public Mono<ScoredValueScanCursor<V>> zscan(K key, ScanArgs scanArgs)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Incrementally iterate sorted sets elements and associated scores.
  
  Specified by:
  
  zscan in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  scanArgs - scan arguments.
  
  Returns:
  
  ScoredValueScanCursor<V> scan cursor.
- zscan
  
  public Mono<ScoredValueScanCursor<V>> zscan(K key, ScanCursor scanCursor, ScanArgs scanArgs)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Incrementally iterate sorted sets elements and associated scores.
  
  Specified by:
  
  zscan in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  scanCursor - cursor to resume from a previous scan, must not be null.
  
  scanArgs - scan arguments.
  
  Returns:
  
  ScoredValueScanCursor<V> scan cursor.
- zscan
  
  public Mono<ScoredValueScanCursor<V>> zscan(K key, ScanCursor scanCursor)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Incrementally iterate sorted sets elements and associated scores.
  
  Specified by:
  
  zscan in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  scanCursor - cursor to resume from a previous scan, must not be null.
  
  Returns:
  
  ScoredValueScanCursor<V> scan cursor.
- zscan
  
  public Mono<StreamScanCursor> zscan(ScoredValueStreamingChannel<V> channel, K key)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Incrementally iterate sorted sets elements and associated scores.
  
  Specified by:
  
  zscan in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  channel - streaming channel that receives a call for every scored value.
  
  key - the key.
  
  Returns:
  
  StreamScanCursor scan cursor.
- zscan
  
  public Mono<StreamScanCursor> zscan(ScoredValueStreamingChannel<V> channel, K key, ScanArgs scanArgs)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Incrementally iterate sorted sets elements and associated scores.
  
  Specified by:
  
  zscan in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  channel - streaming channel that receives a call for every scored value.
  
  key - the key.
  
  scanArgs - scan arguments.
  
  Returns:
  
  StreamScanCursor scan cursor.
- zscan
  
  public Mono<StreamScanCursor> zscan(ScoredValueStreamingChannel<V> channel, K key, ScanCursor scanCursor, ScanArgs scanArgs)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Incrementally iterate sorted sets elements and associated scores.
  
  Specified by:
  
  zscan in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  channel - streaming channel that receives a call for every scored value.
  
  key - the key.
  
  scanCursor - cursor to resume from a previous scan, must not be null.
  
  scanArgs - scan arguments.
  
  Returns:
  
  StreamScanCursor scan cursor.
- zscan
  
  public Mono<StreamScanCursor> zscan(ScoredValueStreamingChannel<V> channel, K key, ScanCursor scanCursor)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Incrementally iterate sorted sets elements and associated scores.
  
  Specified by:
  
  zscan in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  channel - streaming channel that receives a call for every scored value.
  
  key - the key.
  
  scanCursor - cursor to resume from a previous scan, must not be null.
  
  Returns:
  
  StreamScanCursor scan cursor.
- zscore
  
  public Mono<Double> zscore(K key, V member)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Get the score associated with the given member in a sorted set.
  
  Specified by:
  
  zscore in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  key - the key.
  
  member - the member type: value.
  
  Returns:
  
  Double bulk-string-reply the score of member (a double precision floating point number), represented as string.
- zunion
  
  public Flux<V> zunion(K... keys)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Add multiple sorted sets and returns the resulting sorted set.
  
  Specified by:
  
  zunion in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  keys - the keys.
  
  Returns:
  
  V array-reply list of elements.
- zunion
  
  public Flux<V> zunion(ZAggregateArgs aggregateArgs, K... keys)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Add multiple sorted sets and returns the resulting sorted set.
  
  Specified by:
  
  zunion in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  aggregateArgs - arguments to define aggregation and weights.
  
  keys - the keys.
  
  Returns:
  
  V array-reply list of elements.
- zunionWithScores
  
  public Flux<ScoredValue<V>> zunionWithScores(K... keys)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Add multiple sorted sets and returns the resulting sorted set.
  
  Specified by:
  
  zunionWithScores in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  keys - the keys.
  
  Returns:
  
  V array-reply list of scored values.
- zunionWithScores
  
  public Flux<ScoredValue<V>> zunionWithScores(ZAggregateArgs aggregateArgs, K... keys)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Add multiple sorted sets and returns the resulting sorted set.
  
  Specified by:
  
  zunionWithScores in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  aggregateArgs - arguments to define aggregation and weights.
  
  keys - the keys.
  
  Returns:
  
  V array-reply list of scored values.
- zunionstore
  
  public Mono<Long> zunionstore(K destination, K... keys)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Add multiple sorted sets and store the resulting sorted set in a new key.
  
  Specified by:
  
  zunionstore in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  destination - destination key.
  
  keys - source keys.
  
  Returns:
  
  Long integer-reply the number of elements in the resulting sorted set at destination.
- zunionstore
  
  public Mono<Long> zunionstore(K destination, ZStoreArgs zStoreArgs, K... keys)
  
  Description copied from interface: RedisSortedSetReactiveCommands
  
  Add multiple sorted sets and store the resulting sorted set in a new key.
  
  Specified by:
  
  zunionstore in interface RedisSortedSetReactiveCommands<K,V>
  
  Parameters:
  
  destination - the destination.
  
  zStoreArgs - arguments to define aggregation and weights.
  
  keys - the keys.
  
  Returns:
  
  Long integer-reply the number of elements in the resulting sorted set at destination.

Class AbstractRedisReactiveCommands<K,​V>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Details

AbstractRedisReactiveCommands

Method Details

aclCat

aclCat

aclDeluser

aclGenpass

aclGenpass

aclGetuser

aclList

aclLoad

aclLog

aclLog

aclLogReset

aclSave

aclSetuser

aclUsers

aclWhoami

append

asking

auth

auth

bgrewriteaof

bgsave

bitcount

bitcount

bitfield

bitopAnd

bitopNot

bitopOr

bitopXor

bitpos

bitpos

bitpos

blmove

blmove

blpop

blpop

brpop

brpop

brpoplpush

brpoplpush

clientCaching

clientGetname

clientGetredir

clientKill

clientKill

clientList

clientId

clientPause

clientSetname

clientTracking

clientUnblock

close

clusterAddSlots

clusterBumpepoch

clusterCountFailureReports

clusterCountKeysInSlot

clusterDelSlots

clusterFailover

clusterFlushslots

clusterForget

clusterGetKeysInSlot

clusterInfo

clusterKeyslot

clusterMeet

clusterMyId

clusterNodes

clusterReplicate

clusterReset

clusterSaveconfig

clusterSetConfigEpoch

clusterSetSlotImporting

clusterSetSlotMigrating

clusterSetSlotNode

clusterSetSlotStable

Class AbstractRedisReactiveCommands<K,V>