RedisAdvancedClusterReactiveCommandsImpl (Lettuce 7.0.0.RELEASE API)

java.lang.Object
- io.lettuce.core.AbstractRedisReactiveCommands<K,V>
- - io.lettuce.core.cluster.RedisAdvancedClusterReactiveCommandsImpl<K,V>

Type Parameters:

K - Key type.

V - Value type.

All Implemented Interfaces:

BaseRedisReactiveCommands<K,V>, RedisAclReactiveCommands<K,V>, RediSearchReactiveCommands<K,V>, RedisFunctionReactiveCommands<K,V>, RedisGeoReactiveCommands<K,V>, RedisHashReactiveCommands<K,V>, RedisHLLReactiveCommands<K,V>, RedisJsonReactiveCommands<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>, RedisVectorSetReactiveCommands<K,V>, RedisAdvancedClusterReactiveCommands<K,V>, RedisClusterReactiveCommands<K,V>
```
public class RedisAdvancedClusterReactiveCommandsImpl<K,V>
extends AbstractRedisReactiveCommands<K,V>
implements RedisAdvancedClusterReactiveCommands<K,V>
```
An advanced reactive and thread-safe API to a Redis Cluster connection.

Since:

4.0

Author:

Mark Paluch, Jon Chambers

Constructor Summary

Constructors
Constructor and Description
`RedisAdvancedClusterReactiveCommandsImpl(StatefulRedisClusterConnection<K,V> connection, RedisCodec<K,V> codec)` Initialize a new connection.
`RedisAdvancedClusterReactiveCommandsImpl(StatefulRedisClusterConnection<K,V> connection, RedisCodec<K,V> codec, Supplier<JsonParser> parser)` Initialize a new connection.
`RedisAdvancedClusterReactiveCommandsImpl(StatefulRedisClusterConnectionImpl<K,V> connection, RedisCodec<K,V> codec)` Deprecated. since 5.2, use `RedisAdvancedClusterReactiveCommandsImpl(StatefulRedisClusterConnection, RedisCodec, Supplier)`.
`RedisAdvancedClusterReactiveCommandsImpl(StatefulRedisClusterConnectionImpl<K,V> connection, RedisCodec<K,V> codec, Supplier<JsonParser> parser)` Deprecated. since 5.2, use `RedisAdvancedClusterReactiveCommandsImpl(StatefulRedisClusterConnection, RedisCodec, Supplier)`.

Method Summary

All Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`Mono<String>`	`clientSetname(K name)` Set the current connection name.
`Mono<Long>`	`clusterCountKeysInSlot(int slot)` Returns the number of keys in the specified Redis Cluster hash `slot`.
`Flux<K>`	`clusterGetKeysInSlot(int slot, int count)` Retrieve the list of keys within the `slot`.
`Mono<Long>`	`dbsize()` Return the number of keys in the selected database.
`Mono<Long>`	`del(Iterable<K> keys)`
`Mono<Long>`	`del(K... keys)` Delete one or more keys.
`protected <T> Map<String,org.reactivestreams.Publisher<T>>`	`executeOnNodes(Function<RedisClusterReactiveCommands<K,V>,? extends org.reactivestreams.Publisher<T>> function, Predicate<RedisClusterNode> filter)` Run a command on all available nodes that match `filter`.
`protected <T> Map<String,org.reactivestreams.Publisher<T>>`	`executeOnUpstream(Function<RedisClusterReactiveCommands<K,V>,? extends org.reactivestreams.Publisher<T>> function)` Run a command on all available masters,
`Mono<Long>`	`exists(Iterable<K> keys)`
`Mono<Long>`	`exists(K... keys)` Determine how many keys exist.
`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.
`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<AggregationReply<K,V>>`	`ftAggregate(String index, V query)` Run a search query on an index and perform basic aggregate transformations using default options.
`Mono<AggregationReply<K,V>>`	`ftAggregate(String index, V query, AggregateArgs<K,V> args)` Run a search query on an index and perform advanced aggregate transformations with a processing pipeline.
`Mono<String>`	`ftAliasadd(String alias, String index)` Add an alias to a search index.
`Mono<String>`	`ftAliasdel(String alias)` Remove an alias from a search index.
`Mono<String>`	`ftAliasupdate(String alias, String index)` Update an existing alias to point to a different search index.
`Mono<String>`	`ftAlter(String index, boolean skipInitialScan, List<FieldArgs<K>> fieldArgs)` Add new attributes to an existing search index.
`Mono<String>`	`ftAlter(String index, List<FieldArgs<K>> fieldArgs)` Add new attributes to an existing search index.
`Mono<String>`	`ftCreate(String index, CreateArgs<K,V> arguments, List<FieldArgs<K>> fieldArgs)` Create a new search index with the given name, custom configuration, and field definitions.
`Mono<String>`	`ftCreate(String index, List<FieldArgs<K>> fieldArgs)` Create a new search index with the given name and field definitions using default settings.
`Mono<String>`	`ftCursordel(String index, AggregationReply.Cursor cursor)` Delete a cursor and free its associated resources.
`Mono<AggregationReply<K,V>>`	`ftCursorread(String index, AggregationReply.Cursor cursor)` Read next results from an existing cursor using the default batch size.
`Mono<AggregationReply<K,V>>`	`ftCursorread(String index, AggregationReply.Cursor cursor, int count)` Read next results from an existing cursor and optionally override the batch size.
`Mono<Long>`	`ftDictadd(String dict, V... terms)` Add terms to a dictionary.
`Mono<Long>`	`ftDictdel(String dict, V... terms)` Delete terms from a dictionary.
`Flux<V>`	`ftDictdump(String dict)` Dump all terms in a dictionary.
`Mono<String>`	`ftDropindex(String index)` Drop a search index without deleting the associated documents.
`Mono<String>`	`ftDropindex(String index, boolean deleteDocumentKeys)` Drop a search index with optional document deletion.
`Mono<String>`	`ftExplain(String index, V query)` Return the execution plan for a complex query.
`Mono<String>`	`ftExplain(String index, V query, ExplainArgs<K,V> args)` Return the execution plan for a complex query with additional options.
`Flux<V>`	`ftList()` Return a list of all existing indexes.
`Mono<SearchReply<K,V>>`	`ftSearch(String index, V query)` Search the index with a textual query using default search options.
`Mono<SearchReply<K,V>>`	`ftSearch(String index, V query, SearchArgs<K,V> args)` Search the index with a textual query using advanced search options and filters.
`Mono<SpellCheckResult<V>>`	`ftSpellcheck(String index, V query)` Perform spelling correction on a query, returning suggestions for misspelled terms.
`Mono<SpellCheckResult<V>>`	`ftSpellcheck(String index, V query, SpellCheckArgs<K,V> args)` Perform spelling correction on a query with additional options.
`Mono<Map<V,List<V>>>`	`ftSyndump(String index)` Dump synonym group contents.
`Mono<String>`	`ftSynupdate(String index, V synonymGroupId, SynUpdateArgs<K,V> args, V... terms)` Update a synonym group with additional terms and options.
`Mono<String>`	`ftSynupdate(String index, V synonymGroupId, V... terms)` Update a synonym group with additional terms.
`Flux<V>`	`ftTagvals(String index, String fieldName)` Return a distinct set of values indexed in a Tag field.
`RedisClusterReactiveCommands<K,V>`	`getConnection(String nodeId)` Retrieve a connection to the specified cluster node using the nodeId.
`RedisClusterReactiveCommands<K,V>`	`getConnection(String host, int port)` Retrieve a connection to the specified cluster node using host and port.
`StatefulRedisClusterConnection<K,V>`	`getStatefulConnection()`
`Mono<Long>`	`keys(KeyStreamingChannel<K> channel, String pattern)` Find all keys matching the given pattern.
`Flux<K>`	`keys(String pattern)` Find all keys matching the given pattern.
`Flux<K>`	`keysLegacy(K pattern)` Deprecated. Use `keys(String)` instead. This legacy overload will be removed in a later version.
`Mono<Long>`	`keysLegacy(KeyStreamingChannel<K> channel, K pattern)` Deprecated. Use `keys(String)` instead. This legacy overload will be removed in a later version.
`Flux<KeyValue<K,V>>`	`mget(Iterable<K> keys)`
`Flux<KeyValue<K,V>>`	`mget(K... keys)` Get the values of all the given keys.
`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<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<K>`	`randomkey()` Return a random key from the keyspace.
`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<String>`	`scriptFlush()` Remove all the scripts from the script cache.
`Mono<String>`	`scriptKill()` Kill the script currently in execution.
`Mono<String>`	`scriptLoad(byte[] script)` Load the specified Lua script into the script cache.
`Mono<Void>`	`shutdown(boolean save)` Synchronously save the dataset to disk and then shut down the server.
`Mono<Long>`	`touch(Iterable<K> keys)`
`Mono<Long>`	`touch(K... keys)` Touch one or more keys.
`Mono<Long>`	`unlink(Iterable<K> keys)`
`Mono<Long>`	`unlink(K... keys)` Unlink one or more keys (non blocking DEL).

Methods inherited from class io.lettuce.core.AbstractRedisReactiveCommands
aclCat, aclCat, aclDeluser, aclDryRun, aclDryRun, aclGenpass, aclGenpass, aclGetuser, aclList, aclLoad, aclLog, aclLog, aclLogReset, aclSave, aclSetuser, aclUsers, aclWhoami, append, asking, auth, auth, bgrewriteaof, bgsave, bitcount, bitcount, bitfield, bitopAnd, bitopAndor, bitopDiff, bitopDiff1, bitopNot, bitopOne, bitopOr, bitopXor, bitpos, bitpos, bitpos, blmove, blmove, blmpop, blmpop, blpop, blpop, brpop, brpop, brpoplpush, brpoplpush, bzmpop, bzmpop, bzmpop, bzmpop, bzpopmax, bzpopmax, bzpopmin, bzpopmin, clientCaching, clientGetname, clientGetredir, clientId, clientInfo, clientKill, clientKill, clientList, clientList, clientNoEvict, clientPause, clientSetinfo, clientTracking, clientTrackinginfo, clientUnblock, clusterAddSlots, clusterAddSlotsRange, clusterBumpepoch, clusterCountFailureReports, clusterDelSlots, clusterDelSlotsRange, clusterFailover, clusterFailover, clusterFlushslots, clusterForget, clusterInfo, clusterKeyslot, clusterLinks, clusterMeet, clusterMyId, clusterMyShardId, clusterNodes, clusterReplicas, clusterReplicate, clusterReset, clusterSaveconfig, clusterSetConfigEpoch, clusterSetSlotImporting, clusterSetSlotMigrating, clusterSetSlotNode, clusterSetSlotStable, clusterShards, clusterSlaves, clusterSlots, command, commandCount, commandInfo, commandInfo, configGet, configGet, configResetstat, configRewrite, configSet, configSet, copy, copy, createDissolvingFlux, createFlux, createMono, createMono, debugCrashAndRecover, debugHtstats, debugObject, debugOom, debugReload, debugRestart, debugSdslen, debugSegfault, decr, decrby, digest, digest, discard, dispatch, dispatch, dump, echo, eval, eval, eval, eval, evalReadOnly, evalReadOnly, evalsha, evalsha, evalshaReadOnly, exec, exists, expire, expire, expire, expire, expireat, expireat, expireat, expireat, expireat, expireat, expiretime, fcall, fcall, fcallReadOnly, fcallReadOnly, flushdbAsync, ftSugadd, ftSugadd, ftSugdel, ftSugget, ftSugget, ftSuglen, functionDump, functionFlush, functionKill, functionList, functionList, functionLoad, functionLoad, functionRestore, functionRestore, geoadd, geoadd, geoadd, geoadd, geoadd, geoadd, geodist, geohash, geopos, georadius_ro, georadius_ro, georadius, georadius, georadius, georadiusbymember_ro, georadiusbymember_ro, georadiusbymember, georadiusbymember, georadiusbymember, geosearch, geosearch, geosearchstore, get, getbit, getConnection, getdel, getex, getJsonParser, getrange, getset, hdel, hexists, hexpire, hexpire, hexpire, hexpire, hexpireat, hexpireat, hexpireat, hexpireat, hexpireat, hexpireat, hexpiretime, hget, hgetall, hgetall, hgetdel, hgetdel, hgetex, hgetex, hgetex, hincrby, hincrbyfloat, hkeys, hkeys, hlen, hmget, hmget, hmset, hpersist, hpexpire, hpexpire, hpexpire, hpexpire, hpexpireat, hpexpireat, hpexpireat, hpexpireat, hpexpireat, hpexpireat, hpexpiretime, hpttl, hrandfield, hrandfield, hrandfieldWithvalues, hrandfieldWithvalues, hscan, hscan, hscan, hscan, hscan, hscan, hscan, hscan, hscanNovalues, hscanNovalues, hscanNovalues, hscanNovalues, hscanNovalues, hscanNovalues, hscanNovalues, hscanNovalues, hset, hset, hsetex, hsetex, hsetnx, hstrlen, httl, hvals, hvals, incr, incrby, incrbyfloat, info, info, jsonArrappend, jsonArrappend, jsonArrappend, jsonArrappend, jsonArrindex, jsonArrindex, jsonArrindex, jsonArrindex, jsonArrinsert, jsonArrinsert, jsonArrlen, jsonArrlen, jsonArrpop, jsonArrpop, jsonArrpop, jsonArrpopRaw, jsonArrpopRaw, jsonArrpopRaw, jsonArrtrim, jsonClear, jsonClear, jsonDel, jsonDel, jsonGet, jsonGet, jsonGetRaw, jsonGetRaw, jsonMerge, jsonMerge, jsonMGet, jsonMGetRaw, jsonMSet, jsonNumincrby, jsonObjkeys, jsonObjkeys, jsonObjlen, jsonObjlen, jsonSet, jsonSet, jsonSet, jsonSet, jsonStrappend, jsonStrappend, jsonStrappend, jsonStrappend, jsonStrlen, jsonStrlen, jsonToggle, jsonType, jsonType, lastsave, lcs, lindex, linsert, llen, lmove, lmpop, lpop, lpop, lpos, lpos, lpos, lpos, lpush, lpushx, lrange, lrange, lrem, lset, ltrim, memoryUsage, mget, migrate, migrate, move, multi, objectEncoding, objectFreq, objectIdletime, objectRefcount, persist, pexpire, pexpire, pexpire, pexpire, pexpireat, pexpireat, pexpireat, pexpireat, pexpireat, pexpireat, pexpiretime, pfadd, pfadd, pfcount, pfcount, pfmerge, pfmerge, ping, psetex, pttl, publish, pubsubChannels, pubsubChannels, pubsubNumpat, pubsubNumsub, pubsubShardChannels, pubsubShardChannels, pubsubShardNumsub, quit, readOnly, readWrite, rename, renamenx, replicaof, replicaofNoOne, restore, restore, role, rpop, rpop, rpoplpush, rpush, rpushx, sadd, save, scard, scriptExists, scriptFlush, scriptLoad, sdiff, sdiff, sdiffstore, select, set, set, setbit, setex, setGet, setGet, setnx, setrange, setTimeout, shutdown, sinter, sinter, sintercard, sintercard, sinterstore, sismember, slaveof, slaveofNoOne, slowlogGet, slowlogGet, slowlogLen, slowlogReset, smembers, smembers, smismember, smove, sort, sort, sort, sort, sortReadOnly, sortReadOnly, sortReadOnly, sortReadOnly, sortStore, spop, spop, spublish, srandmember, srandmember, srandmember, srem, sscan, sscan, sscan, sscan, sscan, sscan, sscan, sscan, stralgoLcs, strlen, sunion, sunion, sunionstore, swapdb, time, ttl, type, unwatch, vadd, vadd, vadd, vadd, vcard, vClearAttributes, vdim, vemb, vembRaw, vgetattr, vgetattrAsJsonValue, vinfo, vlinks, vlinksWithScores, vrandmember, vrandmember, vrem, vsetattr, vsetattr, vsim, vsim, vsim, vsim, vsimWithScore, vsimWithScore, vsimWithScore, vsimWithScore, vsimWithScoreWithAttribs, vsimWithScoreWithAttribs, vsimWithScoreWithAttribs, vsimWithScoreWithAttribs, waitForReplication, watch, xack, xackdel, xackdel, xadd, xadd, xadd, xadd, xautoclaim, xclaim, xclaim, xdel, xdelex, xdelex, xgroupCreate, xgroupCreate, xgroupCreateconsumer, xgroupDelconsumer, xgroupDestroy, xgroupSetid, xinfoConsumers, xinfoGroups, xinfoStream, xlen, xpending, xpending, xpending, xpending, xrange, xrange, xread, xread, xreadgroup, xreadgroup, xrevrange, xrevrange, xtrim, xtrim, xtrim, zadd, zadd, zadd, zadd, zadd, zadd, zaddincr, zaddincr, zcard, zcount, zcount, zcount, zdiff, zdiffstore, zdiffWithScores, zincrby, zinter, zinter, zintercard, zintercard, zinterstore, zinterstore, zinterWithScores, zinterWithScores, zlexcount, zlexcount, zmpop, zmpop, zmscore, zpopmax, zpopmax, zpopmin, zpopmin, zrandmember, zrandmember, zrandmemberWithScores, zrandmemberWithScores, zrange, zrange, zrangebylex, zrangebylex, zrangebylex, zrangebylex, zrangebyscore, zrangebyscore, zrangebyscore, zrangebyscore, zrangebyscore, zrangebyscore, zrangebyscore, zrangebyscore, zrangebyscore, zrangebyscore, zrangebyscore, zrangebyscore, zrangebyscoreWithScores, zrangebyscoreWithScores, zrangebyscoreWithScores, zrangebyscoreWithScores, zrangebyscoreWithScores, zrangebyscoreWithScores, zrangebyscoreWithScores, zrangebyscoreWithScores, zrangebyscoreWithScores, zrangebyscoreWithScores, zrangebyscoreWithScores, zrangebyscoreWithScores, zrangestore, zrangestorebylex, zrangestorebyscore, zrangeWithScores, zrangeWithScores, zrank, zrankWithScore, zrem, zremrangebylex, zremrangebylex, zremrangebyrank, zremrangebyscore, zremrangebyscore, zremrangebyscore, zrevrange, zrevrange, zrevrangebylex, zrevrangebylex, zrevrangebyscore, zrevrangebyscore, zrevrangebyscore, zrevrangebyscore, zrevrangebyscore, zrevrangebyscore, zrevrangebyscore, zrevrangebyscore, zrevrangebyscore, zrevrangebyscore, zrevrangebyscore, zrevrangebyscore, zrevrangebyscoreWithScores, zrevrangebyscoreWithScores, zrevrangebyscoreWithScores, zrevrangebyscoreWithScores, zrevrangebyscoreWithScores, zrevrangebyscoreWithScores, zrevrangebyscoreWithScores, zrevrangebyscoreWithScores, zrevrangebyscoreWithScores, zrevrangebyscoreWithScores, zrevrangebyscoreWithScores, zrevrangebyscoreWithScores, zrevrangestore, zrevrangestorebylex, zrevrangestorebyscore, zrevrangeWithScores, zrevrangeWithScores, zrevrank, zrevrankWithScore, zscan, zscan, zscan, zscan, zscan, zscan, zscan, zscan, zscore, zunion, zunion, zunionstore, zunionstore, zunionWithScores, zunionWithScores

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface io.lettuce.core.cluster.api.reactive.RedisAdvancedClusterReactiveCommands
scriptLoad

Methods inherited from interface io.lettuce.core.cluster.api.reactive.RedisClusterReactiveCommands
asking, auth, auth, clusterAddSlots, clusterAddSlotsRange, clusterBumpepoch, clusterCountFailureReports, clusterDelSlots, clusterDelSlotsRange, clusterFailover, clusterFailover, clusterFlushslots, clusterForget, clusterInfo, clusterKeyslot, clusterLinks, clusterMeet, clusterMyId, clusterMyShardId, clusterNodes, clusterReplicas, clusterReplicate, clusterReset, clusterSaveconfig, clusterSetConfigEpoch, clusterSetSlotImporting, clusterSetSlotMigrating, clusterSetSlotNode, clusterSetSlotStable, clusterShards, clusterSlaves, clusterSlots, readOnly, readWrite, setTimeout

Methods inherited from interface io.lettuce.core.api.reactive.BaseRedisReactiveCommands
dispatch, dispatch, echo, getJsonParser, ping, publish, pubsubChannels, pubsubChannels, pubsubNumpat, pubsubNumsub, pubsubShardChannels, pubsubShardChannels, pubsubShardNumsub, quit, role, spublish, waitForReplication

Methods inherited from interface io.lettuce.core.api.reactive.RedisAclReactiveCommands
aclCat, aclCat, aclDeluser, aclDryRun, aclDryRun, aclGenpass, aclGenpass, aclGetuser, aclList, aclLoad, aclLog, aclLog, aclLogReset, aclSave, aclSetuser, aclUsers, aclWhoami

Methods inherited from interface io.lettuce.core.api.reactive.RedisFunctionReactiveCommands
fcall, fcall, fcallReadOnly, fcallReadOnly, functionDump, functionFlush, functionKill, functionList, functionList, functionLoad, functionLoad, functionRestore, functionRestore

Methods inherited from interface io.lettuce.core.api.reactive.RedisGeoReactiveCommands
geoadd, geoadd, geoadd, geoadd, geoadd, geoadd, geodist, geohash, geopos, georadius, georadius, georadius, georadiusbymember, georadiusbymember, georadiusbymember, geosearch, geosearch, geosearchstore

Methods inherited from interface io.lettuce.core.api.reactive.RedisHashReactiveCommands
hdel, hexists, hexpire, hexpire, hexpire, hexpire, hexpireat, hexpireat, hexpireat, hexpireat, hexpireat, hexpireat, hexpiretime, hget, hgetall, hgetall, hgetdel, hgetdel, hgetex, hgetex, hgetex, hincrby, hincrbyfloat, hkeys, hkeys, hlen, hmget, hmget, hmset, hpersist, hpexpire, hpexpire, hpexpire, hpexpire, hpexpireat, hpexpireat, hpexpireat, hpexpireat, hpexpireat, hpexpireat, hpexpiretime, hpttl, hrandfield, hrandfield, hrandfieldWithvalues, hrandfieldWithvalues, hscan, hscan, hscan, hscan, hscan, hscan, hscan, hscan, hscanNovalues, hscanNovalues, hscanNovalues, hscanNovalues, hscanNovalues, hscanNovalues, hscanNovalues, hscanNovalues, hset, hset, hsetex, hsetex, hsetnx, hstrlen, httl, hvals, hvals

Methods inherited from interface io.lettuce.core.api.reactive.RedisHLLReactiveCommands
pfadd, pfcount, pfmerge

Methods inherited from interface io.lettuce.core.api.reactive.RedisKeyReactiveCommands
copy, copy, dump, expire, expire, expire, expire, expireat, expireat, expireat, expireat, expireat, expireat, expiretime, migrate, migrate, move, objectEncoding, objectFreq, objectIdletime, objectRefcount, persist, pexpire, pexpire, pexpire, pexpire, pexpireat, pexpireat, pexpireat, pexpireat, pexpireat, pexpireat, pexpiretime, pttl, rename, renamenx, restore, restore, sort, sort, sort, sort, sortReadOnly, sortReadOnly, sortReadOnly, sortReadOnly, sortStore, ttl, type

Methods inherited from interface io.lettuce.core.api.reactive.RedisListReactiveCommands
blmove, blmove, blmpop, blmpop, blpop, blpop, brpop, brpop, brpoplpush, brpoplpush, lindex, linsert, llen, lmove, lmpop, lpop, lpop, lpos, lpos, lpos, lpos, lpush, lpushx, lrange, lrange, lrem, lset, ltrim, rpop, rpop, rpoplpush, rpush, rpushx

Methods inherited from interface io.lettuce.core.api.reactive.RedisScriptingReactiveCommands
digest, digest, eval, eval, eval, eval, evalReadOnly, evalReadOnly, evalsha, evalsha, evalshaReadOnly, scriptExists, scriptFlush

Methods inherited from interface io.lettuce.core.api.reactive.RedisServerReactiveCommands
bgrewriteaof, bgsave, clientCaching, clientGetname, clientGetredir, clientId, clientInfo, clientKill, clientKill, clientList, clientList, clientNoEvict, clientPause, clientSetinfo, clientTracking, clientTrackinginfo, clientUnblock, command, commandCount, commandInfo, commandInfo, configGet, configGet, configResetstat, configRewrite, configSet, configSet, debugCrashAndRecover, debugHtstats, debugObject, debugOom, debugReload, debugRestart, debugSdslen, debugSegfault, flushdbAsync, info, info, lastsave, memoryUsage, replicaof, replicaofNoOne, save, shutdown, slaveof, slaveofNoOne, slowlogGet, slowlogGet, slowlogLen, slowlogReset, time

Methods inherited from interface io.lettuce.core.api.reactive.RedisSetReactiveCommands
sadd, scard, sdiff, sdiff, sdiffstore, sinter, sinter, sintercard, sintercard, sinterstore, sismember, smembers, smembers, smismember, smove, spop, spop, srandmember, srandmember, srandmember, srem, sscan, sscan, sscan, sscan, sscan, sscan, sscan, sscan, sunion, sunion, sunionstore

Methods inherited from interface io.lettuce.core.api.reactive.RedisSortedSetReactiveCommands
bzmpop, bzmpop, bzmpop, bzmpop, bzpopmax, bzpopmax, bzpopmin, bzpopmin, zadd, zadd, zadd, zadd, zadd, zadd, zaddincr, zaddincr, zcard, zcount, zcount, zcount, zdiff, zdiffstore, zdiffWithScores, zincrby, zinter, zinter, zintercard, zintercard, zinterstore, zinterstore, zinterWithScores, zinterWithScores, zlexcount, zlexcount, zmpop, zmpop, zmscore, zpopmax, zpopmax, zpopmin, zpopmin, zrandmember, zrandmember, zrandmemberWithScores, zrandmemberWithScores, zrange, zrange, zrangebylex, zrangebylex, zrangebylex, zrangebylex, zrangebyscore, zrangebyscore, zrangebyscore, zrangebyscore, zrangebyscore, zrangebyscore, zrangebyscore, zrangebyscore, zrangebyscore, zrangebyscore, zrangebyscore, zrangebyscore, zrangebyscoreWithScores, zrangebyscoreWithScores, zrangebyscoreWithScores, zrangebyscoreWithScores, zrangebyscoreWithScores, zrangebyscoreWithScores, zrangebyscoreWithScores, zrangebyscoreWithScores, zrangebyscoreWithScores, zrangebyscoreWithScores, zrangebyscoreWithScores, zrangebyscoreWithScores, zrangestore, zrangestorebylex, zrangestorebyscore, zrangeWithScores, zrangeWithScores, zrank, zrankWithScore, zrem, zremrangebylex, zremrangebylex, zremrangebyrank, zremrangebyscore, zremrangebyscore, zremrangebyscore, zrevrange, zrevrange, zrevrangebylex, zrevrangebylex, zrevrangebyscore, zrevrangebyscore, zrevrangebyscore, zrevrangebyscore, zrevrangebyscore, zrevrangebyscore, zrevrangebyscore, zrevrangebyscore, zrevrangebyscore, zrevrangebyscore, zrevrangebyscore, zrevrangebyscore, zrevrangebyscoreWithScores, zrevrangebyscoreWithScores, zrevrangebyscoreWithScores, zrevrangebyscoreWithScores, zrevrangebyscoreWithScores, zrevrangebyscoreWithScores, zrevrangebyscoreWithScores, zrevrangebyscoreWithScores, zrevrangebyscoreWithScores, zrevrangebyscoreWithScores, zrevrangebyscoreWithScores, zrevrangebyscoreWithScores, zrevrangestore, zrevrangestorebylex, zrevrangestorebyscore, zrevrangeWithScores, zrevrangeWithScores, zrevrank, zrevrankWithScore, zscan, zscan, zscan, zscan, zscan, zscan, zscan, zscan, zscore, zunion, zunion, zunionstore, zunionstore, zunionWithScores, zunionWithScores

Methods inherited from interface io.lettuce.core.api.reactive.RedisStreamReactiveCommands
xack, xackdel, xackdel, xadd, xadd, xadd, xadd, xautoclaim, xclaim, xclaim, xdel, xdelex, xdelex, xgroupCreate, xgroupCreate, xgroupCreateconsumer, xgroupDelconsumer, xgroupDestroy, xgroupSetid, xinfoConsumers, xinfoGroups, xinfoStream, xlen, xpending, xpending, xpending, xpending, xrange, xrange, xread, xread, xreadgroup, xreadgroup, xrevrange, xrevrange, xtrim, xtrim, xtrim

Methods inherited from interface io.lettuce.core.api.reactive.RedisStringReactiveCommands
append, bitcount, bitcount, bitfield, bitopAnd, bitopAndor, bitopDiff, bitopDiff1, bitopNot, bitopOne, bitopOr, bitopXor, bitpos, bitpos, bitpos, decr, decrby, get, getbit, getdel, getex, getrange, getset, incr, incrby, incrbyfloat, lcs, psetex, set, set, setbit, setex, setGet, setGet, setnx, setrange, stralgoLcs, strlen

Methods inherited from interface io.lettuce.core.api.reactive.RedisJsonReactiveCommands
jsonArrappend, jsonArrappend, jsonArrappend, jsonArrappend, jsonArrindex, jsonArrindex, jsonArrindex, jsonArrindex, jsonArrinsert, jsonArrinsert, jsonArrlen, jsonArrlen, jsonArrpop, jsonArrpop, jsonArrpop, jsonArrpopRaw, jsonArrpopRaw, jsonArrpopRaw, jsonArrtrim, jsonClear, jsonClear, jsonDel, jsonDel, jsonGet, jsonGet, jsonGetRaw, jsonGetRaw, jsonMerge, jsonMerge, jsonMGet, jsonMGetRaw, jsonMSet, jsonNumincrby, jsonObjkeys, jsonObjkeys, jsonObjlen, jsonObjlen, jsonSet, jsonSet, jsonSet, jsonSet, jsonStrappend, jsonStrappend, jsonStrappend, jsonStrappend, jsonStrlen, jsonStrlen, jsonToggle, jsonType, jsonType

Methods inherited from interface io.lettuce.core.api.reactive.RedisVectorSetReactiveCommands
vadd, vadd, vadd, vadd, vcard, vClearAttributes, vdim, vemb, vembRaw, vgetattr, vgetattrAsJsonValue, vinfo, vlinks, vlinksWithScores, vrandmember, vrandmember, vrem, vsetattr, vsetattr, vsim, vsim, vsim, vsim, vsimWithScore, vsimWithScore, vsimWithScore, vsimWithScore, vsimWithScoreWithAttribs, vsimWithScoreWithAttribs, vsimWithScoreWithAttribs, vsimWithScoreWithAttribs

Methods inherited from interface io.lettuce.core.api.reactive.RediSearchReactiveCommands
ftSugadd, ftSugadd, ftSugdel, ftSugget, ftSugget, ftSuglen

- Constructor Detail
  - RedisAdvancedClusterReactiveCommandsImpl
```
@Deprecated
public RedisAdvancedClusterReactiveCommandsImpl(StatefulRedisClusterConnectionImpl<K,V> connection,
                                                            RedisCodec<K,V> codec,
                                                            Supplier<JsonParser> parser)
```
    Deprecated. since 5.2, use RedisAdvancedClusterReactiveCommandsImpl(StatefulRedisClusterConnection, RedisCodec, Supplier).
    
    Initialize a new connection.
    
    Parameters:
    
    connection - the stateful connection.
    
    codec - Codec used to encode/decode keys and values.
    
    parser - the implementation of the JsonParser to use
  - RedisAdvancedClusterReactiveCommandsImpl
```
@Deprecated
public RedisAdvancedClusterReactiveCommandsImpl(StatefulRedisClusterConnectionImpl<K,V> connection,
                                                            RedisCodec<K,V> codec)
```
    Deprecated. since 5.2, use RedisAdvancedClusterReactiveCommandsImpl(StatefulRedisClusterConnection, RedisCodec, Supplier).
    
    Initialize a new connection.
    
    Parameters:
    
    connection - the stateful connection.
    
    codec - Codec used to encode/decode keys and values.
  - RedisAdvancedClusterReactiveCommandsImpl
```
public RedisAdvancedClusterReactiveCommandsImpl(StatefulRedisClusterConnection<K,V> connection,
                                                RedisCodec<K,V> codec,
                                                Supplier<JsonParser> parser)
```
    Initialize a new connection.
    
    Parameters:
    
    connection - the stateful connection.
    
    codec - Codec used to encode/decode keys and values.
    
    parser - the implementation of the JsonParser to use
  - RedisAdvancedClusterReactiveCommandsImpl
```
public RedisAdvancedClusterReactiveCommandsImpl(StatefulRedisClusterConnection<K,V> connection,
                                                RedisCodec<K,V> codec)
```
    Initialize a new connection.
    
    Parameters:
    
    connection - the stateful connection.
    
    codec - Codec used to encode/decode keys and values.
- Method Detail
  - 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>
    
    Specified by:
    
    clientSetname in interface RedisAdvancedClusterReactiveCommands<K,V>
    
    Overrides:
    
    clientSetname in class AbstractRedisReactiveCommands<K,V>
    
    Parameters:
    
    name - the client name.
    
    Returns:
    
    simple-string-reply OK if the connection name was successfully set.
    
    See Also:
    
    RedisServerReactiveCommands.clientSetname(Object)
  - 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>
    
    Overrides:
    
    clusterCountKeysInSlot in class AbstractRedisReactiveCommands<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.
  - 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>
    
    Overrides:
    
    clusterGetKeysInSlot in class AbstractRedisReactiveCommands<K,V>
    
    Parameters:
    
    slot - the slot
    
    count - maximal number of keys
    
    Returns:
    
    List<K> array-reply list of keys
  - 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>
    
    Specified by:
    
    dbsize in interface RedisAdvancedClusterReactiveCommands<K,V>
    
    Overrides:
    
    dbsize in class AbstractRedisReactiveCommands<K,V>
    
    Returns:
    
    Long integer-reply.
    
    See Also:
    
    RedisServerReactiveCommands.dbsize()
  - del
```
public Mono<Long> del(K... keys)
```
    Description copied from interface: RedisKeyReactiveCommands
    
    Delete one or more keys.
    
    Specified by:
    
    del in interface RedisKeyReactiveCommands<K,V>
    
    Specified by:
    
    del in interface RedisAdvancedClusterReactiveCommands<K,V>
    
    Overrides:
    
    del in class AbstractRedisReactiveCommands<K,V>
    
    Parameters:
    
    keys - the keys.
    
    Returns:
    
    Long integer-reply The number of keys that were removed.
    
    See Also:
    
    RedisKeyReactiveCommands.del(Object[])
  - del
```
public Mono<Long> del(Iterable<K> keys)
```
    Overrides:
    
    del in class AbstractRedisReactiveCommands<K,V>
  - 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>
    
    Specified by:
    
    exists in interface RedisAdvancedClusterReactiveCommands<K,V>
    
    Overrides:
    
    exists in class AbstractRedisReactiveCommands<K,V>
    
    Parameters:
    
    keys - the keys.
    
    Returns:
    
    Long integer-reply specifically: Number of existing keys.
  - exists
```
public Mono<Long> exists(Iterable<K> keys)
```
    Overrides:
    
    exists in class AbstractRedisReactiveCommands<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>
    
    Specified by:
    
    flushall in interface RedisAdvancedClusterReactiveCommands<K,V>
    
    Overrides:
    
    flushall in class AbstractRedisReactiveCommands<K,V>
    
    Returns:
    
    String simple-string-reply.
    
    See Also:
    
    RedisServerReactiveCommands.flushall()
  - 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>
    
    Overrides:
    
    flushall in class AbstractRedisReactiveCommands<K,V>
    
    Parameters:
    
    flushMode - the flush mode (sync/async).
    
    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>
    
    Specified by:
    
    flushallAsync in interface RedisAdvancedClusterReactiveCommands<K,V>
    
    Overrides:
    
    flushallAsync in class AbstractRedisReactiveCommands<K,V>
    
    Returns:
    
    String simple-string-reply.
    
    See Also:
    
    RedisServerReactiveCommands.flushallAsync()
  - 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>
    
    Specified by:
    
    flushdb in interface RedisAdvancedClusterReactiveCommands<K,V>
    
    Overrides:
    
    flushdb in class AbstractRedisReactiveCommands<K,V>
    
    Returns:
    
    String simple-string-reply.
    
    See Also:
    
    RedisServerReactiveCommands.flushdb()
  - 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>
    
    Overrides:
    
    flushdb in class AbstractRedisReactiveCommands<K,V>
    
    Parameters:
    
    flushMode - the flush mode (sync/async).
    
    Returns:
    
    String simple-string-reply.
  - keys
```
public Flux<K> keys(String pattern)
```
    Description copied from interface: RedisKeyReactiveCommands
    
    Find all keys matching the given pattern.
    
    Specified by:
    
    keys in interface RedisKeyReactiveCommands<K,V>
    
    Specified by:
    
    keys in interface RedisAdvancedClusterReactiveCommands<K,V>
    
    Overrides:
    
    keys in class AbstractRedisReactiveCommands<K,V>
    
    Parameters:
    
    pattern - the pattern type.
    
    Returns:
    
    K flux of keys matching pattern.
  - keysLegacy
```
@Deprecated
public Flux<K> keysLegacy(K pattern)
```
    Deprecated. Use keys(String) instead. This legacy overload will be removed in a later version.
    
    Find all keys matching the given pattern (legacy overload).
    
    Specified by:
    
    keysLegacy in interface RedisKeyReactiveCommands<K,V>
    
    Specified by:
    
    keysLegacy in interface RedisAdvancedClusterReactiveCommands<K,V>
    
    Overrides:
    
    keysLegacy in class AbstractRedisReactiveCommands<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,
                       String pattern)
```
    Description copied from interface: RedisKeyReactiveCommands
    
    Find all keys matching the given pattern.
    
    Specified by:
    
    keys in interface RedisKeyReactiveCommands<K,V>
    
    Specified by:
    
    keys in interface RedisAdvancedClusterReactiveCommands<K,V>
    
    Overrides:
    
    keys in class AbstractRedisReactiveCommands<K,V>
    
    Parameters:
    
    channel - the channel.
    
    pattern - the pattern type.
    
    Returns:
    
    Long array-reply list of keys matching pattern.
  - keysLegacy
```
@Deprecated
public Mono<Long> keysLegacy(KeyStreamingChannel<K> channel,
                                         K pattern)
```
    Deprecated. Use keys(String) instead. This legacy overload will be removed in a later version.
    
    Find all keys matching the given pattern (legacy overload).
    
    Specified by:
    
    keysLegacy in interface RedisKeyReactiveCommands<K,V>
    
    Specified by:
    
    keysLegacy in interface RedisAdvancedClusterReactiveCommands<K,V>
    
    Overrides:
    
    keysLegacy in class AbstractRedisReactiveCommands<K,V>
    
    Parameters:
    
    channel - the channel.
    
    pattern - the pattern.
    
    Returns:
    
    Long array-reply list of keys matching pattern.
  - 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 RedisStringReactiveCommands<K,V>
    
    Specified by:
    
    mget in interface RedisAdvancedClusterReactiveCommands<K,V>
    
    Overrides:
    
    mget in class AbstractRedisReactiveCommands<K,V>
    
    Parameters:
    
    keys - the key.
    
    Returns:
    
    V array-reply list of values at the specified keys.
    
    See Also:
    
    RedisStringReactiveCommands.mget(Object[])
  - mget
```
public Flux<KeyValue<K,V>> mget(Iterable<K> keys)
```
    Overrides:
    
    mget in class AbstractRedisReactiveCommands<K,V>
  - 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>
    
    Overrides:
    
    mget in class AbstractRedisReactiveCommands<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(KeyValueStreamingChannel<K,V> channel,
                       Iterable<K> keys)
```
    Overrides:
    
    mget in class AbstractRedisReactiveCommands<K,V>
  - 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 RedisStringReactiveCommands<K,V>
    
    Specified by:
    
    msetnx in interface RedisAdvancedClusterReactiveCommands<K,V>
    
    Overrides:
    
    msetnx in class AbstractRedisReactiveCommands<K,V>
    
    Parameters:
    
    map - the map.
    
    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).
    
    See Also:
    
    RedisStringReactiveCommands.msetnx(Map)
  - 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 RedisStringReactiveCommands<K,V>
    
    Specified by:
    
    mset in interface RedisAdvancedClusterReactiveCommands<K,V>
    
    Overrides:
    
    mset in class AbstractRedisReactiveCommands<K,V>
    
    Parameters:
    
    map - the map.
    
    Returns:
    
    String simple-string-reply always OK since MSET can't fail.
    
    See Also:
    
    RedisStringReactiveCommands.mset(Map)
  - 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>
    
    Specified by:
    
    randomkey in interface RedisAdvancedClusterReactiveCommands<K,V>
    
    Overrides:
    
    randomkey in class AbstractRedisReactiveCommands<K,V>
    
    Returns:
    
    K bulk-string-reply the random key, or null when the database is empty.
    
    See Also:
    
    RedisKeyReactiveCommands.randomkey()
  - 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>
    
    Specified by:
    
    scriptFlush in interface RedisAdvancedClusterReactiveCommands<K,V>
    
    Overrides:
    
    scriptFlush in class AbstractRedisReactiveCommands<K,V>
    
    Returns:
    
    String simple-string-reply.
    
    See Also:
    
    RedisScriptingReactiveCommands.scriptFlush()
  - scriptKill
```
public Mono<String> scriptKill()
```
    Description copied from interface: RedisScriptingReactiveCommands
    
    Kill the script currently in execution.
    
    Specified by:
    
    scriptKill in interface RedisScriptingReactiveCommands<K,V>
    
    Specified by:
    
    scriptKill in interface RedisAdvancedClusterReactiveCommands<K,V>
    
    Overrides:
    
    scriptKill in class AbstractRedisReactiveCommands<K,V>
    
    Returns:
    
    String simple-string-reply.
    
    See Also:
    
    RedisScriptingReactiveCommands.scriptKill()
  - 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>
    
    Specified by:
    
    scriptLoad in interface RedisAdvancedClusterReactiveCommands<K,V>
    
    Overrides:
    
    scriptLoad in class AbstractRedisReactiveCommands<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.
  - 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>
    
    Specified by:
    
    shutdown in interface RedisAdvancedClusterReactiveCommands<K,V>
    
    Overrides:
    
    shutdown in class AbstractRedisReactiveCommands<K,V>
    
    Parameters:
    
    save - true force save operation.
    
    See Also:
    
    RedisServerReactiveCommands.shutdown(boolean)
  - 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>
    
    Specified by:
    
    touch in interface RedisAdvancedClusterReactiveCommands<K,V>
    
    Overrides:
    
    touch in class AbstractRedisReactiveCommands<K,V>
    
    Parameters:
    
    keys - the keys.
    
    Returns:
    
    Long integer-reply the number of found keys.
  - touch
```
public Mono<Long> touch(Iterable<K> keys)
```
    Overrides:
    
    touch in class AbstractRedisReactiveCommands<K,V>
  - 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>
    
    Specified by:
    
    unlink in interface RedisAdvancedClusterReactiveCommands<K,V>
    
    Overrides:
    
    unlink in class AbstractRedisReactiveCommands<K,V>
    
    Parameters:
    
    keys - the keys.
    
    Returns:
    
    Long integer-reply The number of keys that were removed.
    
    See Also:
    
    RedisKeyReactiveCommands.unlink(Object[])
  - unlink
```
public Mono<Long> unlink(Iterable<K> keys)
```
    Overrides:
    
    unlink in class AbstractRedisReactiveCommands<K,V>
  - getConnection
```
public RedisClusterReactiveCommands<K,V> getConnection(String nodeId)
```
    Description copied from interface: RedisAdvancedClusterReactiveCommands
    
    Retrieve a connection to the specified cluster node using the nodeId. Host and port are looked up in the node list. In contrast to the RedisAdvancedClusterReactiveCommands, node-connections do not route commands to other cluster nodes
    
    Specified by:
    
    getConnection in interface RedisAdvancedClusterReactiveCommands<K,V>
    
    Parameters:
    
    nodeId - the node Id
    
    Returns:
    
    a connection to the requested cluster node
  - getConnection
```
public RedisClusterReactiveCommands<K,V> getConnection(String host,
                                                       int port)
```
    Description copied from interface: RedisAdvancedClusterReactiveCommands
    
    Retrieve a connection to the specified cluster node using host and port. In contrast to the RedisAdvancedClusterReactiveCommands, node-connections do not route commands to other cluster nodes. Host and port connections are verified by default for cluster membership, see ClusterClientOptions.isValidateClusterNodeMembership().
    
    Specified by:
    
    getConnection in interface RedisAdvancedClusterReactiveCommands<K,V>
    
    Parameters:
    
    host - the host
    
    port - the port
    
    Returns:
    
    a connection to the requested cluster node
  - getStatefulConnection
```
public StatefulRedisClusterConnection<K,V> getStatefulConnection()
```
    Specified by:
    
    getStatefulConnection in interface RedisAdvancedClusterReactiveCommands<K,V>
    
    Returns:
    
    the underlying connection.
  - scan
```
public Mono<KeyScanCursor<K>> scan()
```
    Description copied from interface: RedisKeyReactiveCommands
    
    Incrementally iterate the keys space.
    
    Specified by:
    
    scan in interface RedisKeyReactiveCommands<K,V>
    
    Specified by:
    
    scan in interface RedisAdvancedClusterReactiveCommands<K,V>
    
    Overrides:
    
    scan in class AbstractRedisReactiveCommands<K,V>
    
    Returns:
    
    KeyScanCursor<K> scan cursor.
    
    See Also:
    
    RedisKeyReactiveCommands.scan(ScanArgs)
  - 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>
    
    Specified by:
    
    scan in interface RedisAdvancedClusterReactiveCommands<K,V>
    
    Overrides:
    
    scan in class AbstractRedisReactiveCommands<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>
    
    Specified by:
    
    scan in interface RedisAdvancedClusterReactiveCommands<K,V>
    
    Overrides:
    
    scan in class AbstractRedisReactiveCommands<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>
    
    Specified by:
    
    scan in interface RedisAdvancedClusterReactiveCommands<K,V>
    
    Overrides:
    
    scan in class AbstractRedisReactiveCommands<K,V>
    
    Parameters:
    
    scanCursor - cursor to resume from a previous scan, must not be null.
    
    Returns:
    
    KeyScanCursor<K> scan cursor.
    
    See Also:
    
    RedisKeyReactiveCommands.scan(ScanCursor)
  - 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>
    
    Specified by:
    
    scan in interface RedisAdvancedClusterReactiveCommands<K,V>
    
    Overrides:
    
    scan in class AbstractRedisReactiveCommands<K,V>
    
    Parameters:
    
    channel - streaming channel that receives a call for every key.
    
    Returns:
    
    StreamScanCursor scan cursor.
    
    See Also:
    
    RedisKeyReactiveCommands.scan(KeyStreamingChannel)
  - 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>
    
    Specified by:
    
    scan in interface RedisAdvancedClusterReactiveCommands<K,V>
    
    Overrides:
    
    scan in class AbstractRedisReactiveCommands<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>
    
    Specified by:
    
    scan in interface RedisAdvancedClusterReactiveCommands<K,V>
    
    Overrides:
    
    scan in class AbstractRedisReactiveCommands<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>
    
    Specified by:
    
    scan in interface RedisAdvancedClusterReactiveCommands<K,V>
    
    Overrides:
    
    scan in class AbstractRedisReactiveCommands<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.
    
    See Also:
    
    RedisKeyReactiveCommands.scan(ScanCursor, ScanArgs)
  - ftAggregate
```
public Mono<AggregationReply<K,V>> ftAggregate(String index,
                                               V query,
                                               AggregateArgs<K,V> args)
```
    Description copied from interface: RediSearchReactiveCommands
    Run a search query on an index and perform advanced aggregate transformations with a processing pipeline.
    This command executes a search query and applies a sophisticated aggregation pipeline to transform, group, sort, and analyze the results. The AggregateArgs parameter defines a series of operations that process the data server-side, enabling powerful analytics and data transformation capabilities directly within Redis.
    
    The aggregation pipeline supports the following operations:
    - LOAD: Load specific document attributes for processing
    - GROUPBY: Group results by one or more properties
    - REDUCE: Apply reduction functions (COUNT, SUM, AVG, MIN, MAX, etc.)
    - SORTBY: Sort results by specified properties
    - APPLY: Apply mathematical expressions and transformations
    - FILTER: Filter results based on computed values
    - LIMIT: Paginate results efficiently
    - WITHCURSOR: Enable cursor-based pagination for large result sets
    Performance Considerations:
    - Use SORTABLE fields for efficient grouping and sorting operations
    - Apply filters early in the pipeline to reduce processing overhead
    - Use WITHCURSOR for large result sets to avoid memory issues
    - Load only necessary attributes to minimize data transfer
    - Consider using LIMIT to restrict result set size
    Time complexity: Non-deterministic, depends on the query and aggregation operations performed. Generally linear to the number of results processed through the pipeline.
    Specified by:
    
    ftAggregate in interface RediSearchReactiveCommands<K,V>
    
    Overrides:
    
    ftAggregate in class AbstractRedisReactiveCommands<K,V>
    
    Parameters:
    
    index - the index name, as a key
    
    query - the base filtering query that retrieves documents for aggregation
    
    args - the aggregate arguments defining the processing pipeline and operations
    
    Returns:
    
    the result of the aggregate command containing processed and transformed results, see SearchReply
    
    See Also:
    
    FT.AGGREGATE, Aggregations, Cursor API, SearchReply, AggregateArgs, RediSearchReactiveCommands.ftAggregate(String, Object), #ftCursorread(String, Cursor)
  - ftAggregate
```
public Mono<AggregationReply<K,V>> ftAggregate(String index,
                                               V query)
```
    Description copied from interface: RediSearchReactiveCommands
    Run a search query on an index and perform basic aggregate transformations using default options.
    This command executes a search query and applies aggregation operations to transform and analyze the results. Unlike RediSearchReactiveCommands.ftSearch(String, Object), which returns individual documents, FT.AGGREGATE processes the result set through a pipeline of transformations to produce analytical insights, summaries, and computed values.
    
    This basic variant uses default aggregation behavior without additional pipeline operations. For advanced aggregations with grouping, sorting, filtering, and custom transformations, use RediSearchReactiveCommands.ftAggregate(String, Object, AggregateArgs).
    
    Common use cases for aggregations include:
    - Analytics: Count documents, calculate averages, find min/max values
    - Reporting: Group data by categories, time periods, or geographic regions
    - Data transformation: Apply mathematical functions, format dates, extract values
    - Performance optimization: Process large datasets server-side instead of client-side
    Time complexity: O(1) base complexity, but depends on the query and number of results processed
    Specified by:
    
    ftAggregate in interface RediSearchReactiveCommands<K,V>
    
    Overrides:
    
    ftAggregate in class AbstractRedisReactiveCommands<K,V>
    
    Parameters:
    
    index - the index name, as a key
    
    query - the base filtering query that retrieves documents for aggregation
    
    Returns:
    
    the result of the aggregate command containing processed results, see SearchReply
    
    See Also:
    
    FT.AGGREGATE, Aggregations, SearchReply, AggregateArgs, RediSearchReactiveCommands.ftAggregate(String, Object, AggregateArgs)
  - ftSearch
```
public Mono<SearchReply<K,V>> ftSearch(String index,
                                       V query,
                                       SearchArgs<K,V> args)
```
    Description copied from interface: RediSearchReactiveCommands
    Search the index with a textual query using advanced search options and filters.
    This command performs a full-text search on the specified index with advanced configuration options provided through SearchArgs. This variant allows fine-grained control over search behavior, result formatting, filtering, sorting, and pagination.
    
    The SearchArgs parameter enables you to specify:
    - Result options: NOCONTENT, WITHSCORES, WITHPAYLOADS, WITHSORTKEYS
    - Query behavior: VERBATIM (no stemming), NOSTOPWORDS
    - Filtering: Numeric filters, geo filters, field filters
    - Result customization: RETURN specific fields, SUMMARIZE, HIGHLIGHT
    - Sorting and pagination: SORTBY, LIMIT offset and count
    - Performance options: TIMEOUT, SLOP, INORDER
    - Language and scoring: LANGUAGE, SCORER, EXPLAINSCORE
    Performance Considerations:
    - Use NOCONTENT when you only need document IDs
    - Specify RETURN fields to limit data transfer
    - Use SORTABLE fields for efficient sorting
    - Apply filters to reduce result set size
    - Use LIMIT for pagination to avoid large result sets
    Time complexity: O(N) where N is the number of results in the result set. Complexity varies based on query type, filters, and sorting requirements.
    Specified by:
    
    ftSearch in interface RediSearchReactiveCommands<K,V>
    
    Overrides:
    
    ftSearch in class AbstractRedisReactiveCommands<K,V>
    
    Parameters:
    
    index - the index name, as a key
    
    query - the query string following RediSearch query syntax
    
    args - the search arguments containing advanced options and filters
    
    Returns:
    
    the result of the search command containing matching documents and metadata, see SearchReply
    
    See Also:
    
    FT.SEARCH, Query syntax, Advanced concepts, SearchReply, SearchArgs, RediSearchReactiveCommands.ftSearch(String, Object)
  - ftSearch
```
public Mono<SearchReply<K,V>> ftSearch(String index,
                                       V query)
```
    Description copied from interface: RediSearchReactiveCommands
    Search the index with a textual query using default search options.
    This command performs a full-text search on the specified index using the provided query string. It returns matching documents with their content and metadata. This is the basic search variant that uses default search behavior without additional filtering, sorting, or result customization.
    
    The query follows RediSearch query syntax, supporting:
    - Simple text search: "hello world" - searches for documents containing both terms
    - Field-specific search: "@title:redis" - searches within specific fields
    - Boolean operators: "redis AND search" or "redis | search"
    - Phrase search: "\"exact phrase\"" - searches for exact phrase matches
    - Wildcard search: "redi*" - prefix matching
    - Numeric ranges: "@price:[100 200]" - numeric field filtering
    - Geographic search: "@location:[lon lat radius unit]" - geo-spatial queries
    Time complexity: O(N) where N is the number of results in the result set
    Specified by:
    
    ftSearch in interface RediSearchReactiveCommands<K,V>
    
    Overrides:
    
    ftSearch in class AbstractRedisReactiveCommands<K,V>
    
    Parameters:
    
    index - the index name, as a key
    
    query - the query string following RediSearch query syntax
    
    Returns:
    
    the result of the search command containing matching documents, see SearchReply
    
    See Also:
    
    FT.SEARCH, Query syntax, SearchReply, SearchArgs, RediSearchReactiveCommands.ftSearch(String, Object, SearchArgs)
  - ftExplain
```
public Mono<String> ftExplain(String index,
                              V query)
```
    Description copied from interface: RediSearchReactiveCommands
    Return the execution plan for a complex query.
    This command returns a string representing the execution plan that Redis Search will use to execute the given query. This is useful for understanding how the query will be processed and for optimizing query performance.
    
    Key features and use cases:
    - Query optimization: Understand how queries are executed
    - Performance analysis: Identify potential bottlenecks
    - Debugging: Troubleshoot complex query behavior
    - Learning: Understand Redis Search query processing
    Time complexity: O(1)
    Specified by:
    
    ftExplain in interface RediSearchReactiveCommands<K,V>
    
    Overrides:
    
    ftExplain in class AbstractRedisReactiveCommands<K,V>
    
    Parameters:
    
    index - the index name
    
    query - the search query to explain
    
    Returns:
    
    the execution plan as a string
    
    See Also:
    
    FT.EXPLAIN, RediSearchReactiveCommands.ftExplain(String, Object, ExplainArgs), RediSearchReactiveCommands.ftSearch(String, Object)
  - ftExplain
```
public Mono<String> ftExplain(String index,
                              V query,
                              ExplainArgs<K,V> args)
```
    Description copied from interface: RediSearchReactiveCommands
    Return the execution plan for a complex query with additional options.
    This command returns a string representing the execution plan that Redis Search will use to execute the given query under the specified dialect version.
    
    Available options:
    - DIALECT: Specify dialect version for query execution
    Time complexity: O(1)
    Specified by:
    
    ftExplain in interface RediSearchReactiveCommands<K,V>
    
    Overrides:
    
    ftExplain in class AbstractRedisReactiveCommands<K,V>
    
    Parameters:
    
    index - the index name
    
    query - the search query to explain
    
    args - the explain arguments (dialect)
    
    Returns:
    
    the execution plan as a string
    
    See Also:
    
    FT.EXPLAIN, RediSearchReactiveCommands.ftExplain(String, Object), RediSearchReactiveCommands.ftSearch(String, Object)
  - ftTagvals
```
public Flux<V> ftTagvals(String index,
                         String fieldName)
```
    Description copied from interface: RediSearchReactiveCommands
    Return a distinct set of values indexed in a Tag field.
    This command retrieves all unique values that have been indexed in a specific Tag field within a search index. It's particularly useful for discovering the range of values available in categorical fields such as cities, categories, status values, or any other enumerated data.
    
    Key features and use cases:
    - Data exploration: Discover all possible values in a tag field
    - Filter building: Populate dropdown lists or filter options in applications
    - Data validation: Verify expected values are present in the index
    - Analytics: Understand the distribution of categorical data
    Important limitations:
    - Only works with Tag fields defined in the index schema
    - No paging or sorting is provided - all values are returned at once
    - Tags are not alphabetically sorted in the response
    - Returned strings are lowercase with whitespaces removed
    - Performance scales with the number of unique values (O(N) complexity)
    Example usage scenarios:
    - Retrieving all available product categories for an e-commerce filter
    - Getting all city names indexed for location-based searches
    - Listing all status values (active, inactive, pending) for administrative interfaces
    - Discovering all tags or labels applied to content
    Time complexity: O(N) where N is the number of distinct values in the tag field
    Specified by:
    
    ftTagvals in interface RediSearchReactiveCommands<K,V>
    
    Overrides:
    
    ftTagvals in class AbstractRedisReactiveCommands<K,V>
    
    Parameters:
    
    index - the index name containing the tag field
    
    fieldName - the name of the Tag field defined in the index schema
    
    Returns:
    
    a list of all distinct values indexed in the specified tag field. The list contains the raw tag values as they were indexed (lowercase, whitespace removed).
    
    See Also:
    
    FT.TAGVALS, RediSearchReactiveCommands.ftCreate(String, List), RediSearchReactiveCommands.ftCreate(String, CreateArgs, List)
  - ftSpellcheck
```
public Mono<SpellCheckResult<V>> ftSpellcheck(String index,
                                              V query)
```
    Description copied from interface: RediSearchReactiveCommands
    Perform spelling correction on a query, returning suggestions for misspelled terms.
    This command analyzes the query for misspelled terms and provides spelling suggestions based on the indexed terms and optionally custom dictionaries. A misspelled term is a full text term (word) that is:
    - Not a stop word
    - Not in the index
    - At least 3 characters long
    Key features and use cases:
    - Query correction: Improve search experience by suggesting corrections
    - Typo handling: Handle common typing mistakes and misspellings
    - Search enhancement: Increase search success rates
    - User experience: Provide "did you mean" functionality
    Time complexity: O(1)
    Specified by:
    
    ftSpellcheck in interface RediSearchReactiveCommands<K,V>
    
    Overrides:
    
    ftSpellcheck in class AbstractRedisReactiveCommands<K,V>
    
    Parameters:
    
    index - the index with the indexed terms
    
    query - the search query to check for spelling errors
    
    Returns:
    
    spell check result containing misspelled terms and their suggestions
    
    See Also:
    
    FT.SPELLCHECK, Spellchecking, RediSearchReactiveCommands.ftSpellcheck(String, Object, SpellCheckArgs), RediSearchReactiveCommands.ftDictadd(String, Object[]), RediSearchReactiveCommands.ftDictdel(String, Object[]), RediSearchReactiveCommands.ftDictdump(String)
  - ftSpellcheck
```
public Mono<SpellCheckResult<V>> ftSpellcheck(String index,
                                              V query,
                                              SpellCheckArgs<K,V> args)
```
    Description copied from interface: RediSearchReactiveCommands
    Perform spelling correction on a query with additional options.
    This command analyzes the query for misspelled terms and provides spelling suggestions with configurable options for distance, custom dictionaries, and dialect.
    
    Available options:
    - DISTANCE: Maximum Levenshtein distance for suggestions (default: 1, max: 4)
    - TERMS INCLUDE: Include terms from custom dictionaries as suggestions
    - TERMS EXCLUDE: Exclude terms from custom dictionaries from suggestions
    - DIALECT: Specify dialect version for query execution
    Time complexity: O(1)
    Specified by:
    
    ftSpellcheck in interface RediSearchReactiveCommands<K,V>
    
    Overrides:
    
    ftSpellcheck in class AbstractRedisReactiveCommands<K,V>
    
    Parameters:
    
    index - the index with the indexed terms
    
    query - the search query to check for spelling errors
    
    args - the spellcheck arguments (distance, terms, dialect)
    
    Returns:
    
    spell check result containing misspelled terms and their suggestions
    
    See Also:
    
    FT.SPELLCHECK, Spellchecking, RediSearchReactiveCommands.ftSpellcheck(String, Object), RediSearchReactiveCommands.ftDictadd(String, Object[]), RediSearchReactiveCommands.ftDictdel(String, Object[]), RediSearchReactiveCommands.ftDictdump(String)
  - ftDictadd
```
public Mono<Long> ftDictadd(String dict,
                            V... terms)
```
    Description copied from interface: RediSearchReactiveCommands
    Add terms to a dictionary.
    This command adds one or more terms to a dictionary. Dictionaries are used for storing custom stopwords, synonyms, and other term lists that can be referenced in search operations. The dictionary is created if it doesn't exist.
    
    Key features and use cases:
    - Stopwords: Create custom stopword lists for filtering
    - Synonyms: Build synonym dictionaries for query expansion
    - Custom terms: Store domain-specific terminology
    - Blacklists: Maintain lists of prohibited terms
    Time complexity: O(1)
    Specified by:
    
    ftDictadd in interface RediSearchReactiveCommands<K,V>
    
    Overrides:
    
    ftDictadd in class AbstractRedisReactiveCommands<K,V>
    
    Parameters:
    
    dict - the dictionary name
    
    terms - the terms to add to the dictionary
    
    Returns:
    
    the number of new terms that were added
    
    See Also:
    
    FT.DICTADD, Spellchecking, RediSearchReactiveCommands.ftDictdel(String, Object[]), RediSearchReactiveCommands.ftDictdump(String)
  - ftDictdel
```
public Mono<Long> ftDictdel(String dict,
                            V... terms)
```
    Description copied from interface: RediSearchReactiveCommands
    
    Delete terms from a dictionary.
    This command removes one or more terms from a dictionary. Only exact matches will be removed from the dictionary. Non-existent terms are ignored.
    
    Time complexity: O(1)
    
    Specified by:
    
    ftDictdel in interface RediSearchReactiveCommands<K,V>
    
    Overrides:
    
    ftDictdel in class AbstractRedisReactiveCommands<K,V>
    
    Parameters:
    
    dict - the dictionary name
    
    terms - the terms to delete from the dictionary
    
    Returns:
    
    the number of terms that were deleted
    
    See Also:
    
    FT.DICTDEL, RediSearchReactiveCommands.ftDictadd(String, Object[]), RediSearchReactiveCommands.ftDictdump(String)
  - ftDictdump
```
public Flux<V> ftDictdump(String dict)
```
    Description copied from interface: RediSearchReactiveCommands
    
    Dump all terms in a dictionary.
    This command returns all terms stored in the specified dictionary. The terms are returned in no particular order.
    
    Time complexity: O(N), where N is the size of the dictionary
    
    Specified by:
    
    ftDictdump in interface RediSearchReactiveCommands<K,V>
    
    Overrides:
    
    ftDictdump in class AbstractRedisReactiveCommands<K,V>
    
    Parameters:
    
    dict - the dictionary name
    
    Returns:
    
    a list of all terms in the dictionary
    
    See Also:
    
    FT.DICTDUMP, RediSearchReactiveCommands.ftDictadd(String, Object[]), RediSearchReactiveCommands.ftDictdel(String, Object[])
  - ftAliasadd
```
public Mono<String> ftAliasadd(String alias,
                               String index)
```
    Description copied from interface: RediSearchReactiveCommands
    Add an alias to a search index.
    This command creates an alias that points to an existing search index, allowing applications to reference the index by an alternative name. Aliases provide a level of indirection that enables transparent index management and migration strategies.
    
    Key features and use cases:
    - Index abstraction: Applications can use stable alias names while underlying indexes change
    - Blue-green deployments: Switch traffic between old and new indexes seamlessly
    - A/B testing: Route different application instances to different indexes
    - Maintenance windows: Redirect queries during index rebuilds or migrations
    Important notes:
    - An index can have multiple aliases, but an alias can only point to one index
    - Aliases cannot reference other aliases (no alias chaining)
    - If the alias already exists, this command will fail with an error
    - Use RediSearchReactiveCommands.ftAliasupdate(String, String) to reassign an existing alias
    Time complexity: O(1)
    Specified by:
    
    ftAliasadd in interface RediSearchReactiveCommands<K,V>
    
    Overrides:
    
    ftAliasadd in class AbstractRedisReactiveCommands<K,V>
    
    Parameters:
    
    alias - the alias name to create
    
    index - the target index name that the alias will point to
    
    Returns:
    
    "OK" if the alias was successfully created
    
    See Also:
    
    FT.ALIASADD, RediSearchReactiveCommands.ftAliasupdate(String, String), RediSearchReactiveCommands.ftAliasdel(String)
  - ftAliasupdate
```
public Mono<String> ftAliasupdate(String alias,
                                  String index)
```
    Description copied from interface: RediSearchReactiveCommands
    Update an existing alias to point to a different search index.
    This command updates an existing alias to point to a different index, or creates the alias if it doesn't exist. Unlike RediSearchReactiveCommands.ftAliasadd(String, String), this command will succeed even if the alias already exists, making it useful for atomic alias updates during index migrations.
    
    Key features and use cases:
    - Atomic updates: Change alias target without downtime
    - Index migration: Seamlessly switch from old to new index versions
    - Rollback capability: Quickly revert to previous index if issues arise
    - Blue-green deployments: Switch production traffic between index versions
    Important notes:
    - If the alias doesn't exist, it will be created (same as ftAliasadd)
    - If the alias exists, it will be updated to point to the new index
    - The previous index association is removed automatically
    - This operation is atomic - no intermediate state where alias is undefined
    Time complexity: O(1)
    Specified by:
    
    ftAliasupdate in interface RediSearchReactiveCommands<K,V>
    
    Overrides:
    
    ftAliasupdate in class AbstractRedisReactiveCommands<K,V>
    
    Parameters:
    
    alias - the alias name to update or create
    
    index - the target index name that the alias will point to
    
    Returns:
    
    "OK" if the alias was successfully updated
    
    See Also:
    
    FT.ALIASUPDATE, RediSearchReactiveCommands.ftAliasadd(String, String), RediSearchReactiveCommands.ftAliasdel(String)
  - ftAliasdel
```
public Mono<String> ftAliasdel(String alias)
```
    Description copied from interface: RediSearchReactiveCommands
    Remove an alias from a search index.
    This command removes an existing alias, breaking the association between the alias name and its target index. The underlying index remains unchanged and accessible by its original name.
    
    Key features and use cases:
    - Cleanup: Remove unused or obsolete aliases
    - Security: Revoke access to indexes through specific alias names
    - Maintenance: Temporarily disable access during maintenance windows
    - Resource management: Clean up aliases before index deletion
    Important notes:
    - Only the alias is removed - the target index is not affected
    - If the alias doesn't exist, this command will fail with an error
    - Applications using the alias will receive errors after deletion
    - Consider using RediSearchReactiveCommands.ftAliasupdate(String, String) to redirect before deletion
    Time complexity: O(1)
    Specified by:
    
    ftAliasdel in interface RediSearchReactiveCommands<K,V>
    
    Overrides:
    
    ftAliasdel in class AbstractRedisReactiveCommands<K,V>
    
    Parameters:
    
    alias - the alias name to remove
    
    Returns:
    
    "OK" if the alias was successfully removed
    
    See Also:
    
    FT.ALIASDEL, RediSearchReactiveCommands.ftAliasadd(String, String), RediSearchReactiveCommands.ftAliasupdate(String, String)
  - ftCreate
```
public Mono<String> ftCreate(String index,
                             List<FieldArgs<K>> fieldArgs)
```
    Description copied from interface: RediSearchReactiveCommands
    
    Create a new search index with the given name and field definitions using default settings.
    This command creates a new search index that enables full-text search, filtering, and aggregation capabilities on Redis data structures. The index will use default settings for data type (HASH), key prefixes (all keys), and other configuration options.
    
    Time complexity: O(K) at creation where K is the number of fields, O(N) if scanning the keyspace is triggered, where N is the number of keys in the keyspace
    
    Specified by:
    
    ftCreate in interface RediSearchReactiveCommands<K,V>
    
    Overrides:
    
    ftCreate in class AbstractRedisReactiveCommands<K,V>
    
    Parameters:
    
    index - the index name
    
    fieldArgs - the FieldArgs list defining the searchable fields and their types
    
    Returns:
    
    "OK" if the index was created successfully
    
    See Also:
    
    FT.CREATE, CreateArgs, FieldArgs, RediSearchReactiveCommands.ftCreate(String, CreateArgs, List), RediSearchReactiveCommands.ftDropindex(String)
  - ftCreate
```
public Mono<String> ftCreate(String index,
                             CreateArgs<K,V> arguments,
                             List<FieldArgs<K>> fieldArgs)
```
    Description copied from interface: RediSearchReactiveCommands
    Create a new search index with the given name, custom configuration, and field definitions.
    This command creates a new search index with advanced configuration options that control how the index behaves, what data it indexes, and how it processes documents. This variant provides full control over index creation parameters.
    
    The CreateArgs parameter allows you to specify:
    - Data type: HASH (default) or JSON documents
    - Key prefixes: Which keys to index based on prefix patterns
    - Filters: Conditional indexing based on field values
    - Language settings: Default language and language field for stemming
    - Performance options: NOOFFSETS, NOHL, NOFIELDS, NOFREQS for memory optimization
    - Temporary indexes: Auto-expiring indexes for short-term use
    Time complexity: O(K) at creation where K is the number of fields, O(N) if scanning the keyspace is triggered, where N is the number of keys in the keyspace
    Specified by:
    
    ftCreate in interface RediSearchReactiveCommands<K,V>
    
    Overrides:
    
    ftCreate in class AbstractRedisReactiveCommands<K,V>
    
    Parameters:
    
    index - the index name
    
    arguments - the index CreateArgs containing configuration options
    
    fieldArgs - the FieldArgs list defining the searchable fields and their types
    
    Returns:
    
    "OK" if the index was created successfully
    
    See Also:
    
    FT.CREATE, CreateArgs, FieldArgs, RediSearchReactiveCommands.ftCreate(String, List), RediSearchReactiveCommands.ftDropindex(String)
  - ftAlter
```
public Mono<String> ftAlter(String index,
                            boolean skipInitialScan,
                            List<FieldArgs<K>> fieldArgs)
```
    Description copied from interface: RediSearchReactiveCommands
    Add new attributes to an existing search index.
    This command allows you to extend an existing search index by adding new searchable fields without recreating the entire index. The new attributes will be applied to future document updates and can optionally be applied to existing documents through reindexing.
    
    Key features and considerations:
    - Non-destructive: Existing index structure and data remain intact
    - Incremental indexing: New fields are indexed as documents are updated
    - Reindexing control: Option to skip initial scan for performance
    - Field limitations: Text field limits may apply based on index creation options
    Important notes:
    - If the index was created without MAXTEXTFIELDS, you may be limited to 32 total text attributes
    - New attributes are only indexed for documents that are updated after the ALTER command
    - Use SKIPINITIALSCAN to avoid scanning existing documents if immediate indexing is not required
    Time complexity: O(N) where N is the number of keys in the keyspace if initial scan is performed, O(1) if SKIPINITIALSCAN is used
    Specified by:
    
    ftAlter in interface RediSearchReactiveCommands<K,V>
    
    Overrides:
    
    ftAlter in class AbstractRedisReactiveCommands<K,V>
    
    Parameters:
    
    index - the index name, as a key
    
    skipInitialScan - if true, skip scanning and indexing existing documents; if false, scan and index existing documents with the new attributes
    
    fieldArgs - the FieldArgs list defining the new searchable fields and their types to add
    
    Returns:
    
    "OK" if the index was successfully altered
    
    See Also:
    
    FT.ALTER, FieldArgs, RediSearchReactiveCommands.ftCreate(String, List), RediSearchReactiveCommands.ftCreate(String, CreateArgs, List)
  - ftAlter
```
public Mono<String> ftAlter(String index,
                            List<FieldArgs<K>> fieldArgs)
```
    Description copied from interface: RediSearchReactiveCommands
    Add new attributes to an existing search index.
    This command allows you to extend an existing search index by adding new searchable fields without recreating the entire index. The new attributes will be applied to future document updates and can optionally be applied to existing documents through reindexing.
    
    Key features and considerations:
    - Non-destructive: Existing index structure and data remain intact
    - Incremental indexing: New fields are indexed as documents are updated
    - Reindexing control: Option to skip initial scan for performance
    - Field limitations: Text field limits may apply based on index creation options
    Time complexity: O(N) where N is the number of keys in the keyspace if initial scan is performed
    Specified by:
    
    ftAlter in interface RediSearchReactiveCommands<K,V>
    
    Overrides:
    
    ftAlter in class AbstractRedisReactiveCommands<K,V>
    
    Parameters:
    
    index - the index name, as a key
    
    fieldArgs - the FieldArgs list defining the new searchable fields and their types to add
    
    Returns:
    
    "OK" if the index was successfully altered
    
    See Also:
    
    FT.ALTER, FieldArgs, RediSearchReactiveCommands.ftCreate(String, List), RediSearchReactiveCommands.ftCreate(String, CreateArgs, List)
  - ftDropindex
```
public Mono<String> ftDropindex(String index,
                                boolean deleteDocumentKeys)
```
    Description copied from interface: RediSearchReactiveCommands
    
    Drop a search index with optional document deletion.
    This command removes the search index and optionally deletes all associated documents. When deleteDocuments is true, this operation becomes destructive and will permanently remove both the index and all indexed documents from Redis.
    
    Asynchronous Behavior: If an index creation is still running (RediSearchReactiveCommands.ftCreate(String, List) is running asynchronously), only the document hashes that have already been indexed are deleted. Documents that are queued for indexing but not yet processed will remain in the database.
    
    Time complexity: O(1) or O(N) if documents are deleted, where N is the number of keys in the keyspace
    
    Specified by:
    
    ftDropindex in interface RediSearchReactiveCommands<K,V>
    
    Overrides:
    
    ftDropindex in class AbstractRedisReactiveCommands<K,V>
    
    Parameters:
    
    index - the index name, as a key
    
    deleteDocumentKeys - if true, delete the indexed documents as well; if false, preserve documents
    
    Returns:
    
    "OK" if the index was successfully dropped
    
    See Also:
    
    FT.DROPINDEX, RediSearchReactiveCommands.ftDropindex(String), RediSearchReactiveCommands.ftCreate(String, List)
  - ftDropindex
```
public Mono<String> ftDropindex(String index)
```
    Description copied from interface: RediSearchReactiveCommands
    
    Drop a search index without deleting the associated documents.
    This command removes the search index and all its associated metadata, but preserves the original documents (hashes or JSON objects) that were indexed. This is the safe default behavior that allows you to recreate the index later without losing data.
    
    Time complexity: O(1)
    
    Specified by:
    
    ftDropindex in interface RediSearchReactiveCommands<K,V>
    
    Overrides:
    
    ftDropindex in class AbstractRedisReactiveCommands<K,V>
    
    Parameters:
    
    index - the index name, as a key
    
    Returns:
    
    "OK" if the index was successfully dropped
    
    See Also:
    
    FT.DROPINDEX, RediSearchReactiveCommands.ftDropindex(String, boolean), RediSearchReactiveCommands.ftCreate(String, List)
  - ftSyndump
```
public Mono<Map<V,List<V>>> ftSyndump(String index)
```
    Description copied from interface: RediSearchReactiveCommands
    Dump synonym group contents.
    This command returns the contents of a synonym group. Synonym groups are used to define terms that should be treated as equivalent during search operations.
    
    Key features and use cases:
    - Synonym management: View current synonym definitions
    - Query expansion: Understand how terms are expanded
    - Debugging: Verify synonym group contents
    - Administration: Audit synonym configurations
    Time complexity: O(1)
    Specified by:
    
    ftSyndump in interface RediSearchReactiveCommands<K,V>
    
    Overrides:
    
    ftSyndump in class AbstractRedisReactiveCommands<K,V>
    
    Parameters:
    
    index - the index name
    
    Returns:
    
    a map where keys are synonym terms and values are lists of group IDs containing that synonym
    
    See Also:
    
    FT.SYNDUMP, RediSearchReactiveCommands.ftSynupdate(String, Object, Object[]), RediSearchReactiveCommands.ftSynupdate(String, Object, SynUpdateArgs, Object[])
  - ftSynupdate
```
public Mono<String> ftSynupdate(String index,
                                V synonymGroupId,
                                V... terms)
```
    Description copied from interface: RediSearchReactiveCommands
    Update a synonym group with additional terms.
    This command creates or updates a synonym group with the specified terms. All terms in a synonym group are treated as equivalent during search operations. The command triggers a scan of all documents by default.
    
    Key features and use cases:
    - Synonym creation: Define equivalent terms for search
    - Query expansion: Improve search recall with synonyms
    - Language support: Handle different languages and dialects
    - Domain terminology: Map technical terms to common language
    Time complexity: O(1)
    Specified by:
    
    ftSynupdate in interface RediSearchReactiveCommands<K,V>
    
    Overrides:
    
    ftSynupdate in class AbstractRedisReactiveCommands<K,V>
    
    Parameters:
    
    index - the index name
    
    synonymGroupId - the synonym group identifier
    
    terms - the terms to add to the synonym group
    
    Returns:
    
    OK if executed correctly
    
    See Also:
    
    FT.SYNUPDATE, RediSearchReactiveCommands.ftSynupdate(String, Object, SynUpdateArgs, Object[]), RediSearchReactiveCommands.ftSyndump(String)
  - ftSynupdate
```
public Mono<String> ftSynupdate(String index,
                                V synonymGroupId,
                                SynUpdateArgs<K,V> args,
                                V... terms)
```
    Description copied from interface: RediSearchReactiveCommands
    Update a synonym group with additional terms and options.
    This command creates or updates a synonym group with the specified terms and options. The SKIPINITIALSCAN option can be used to avoid scanning existing documents, affecting only documents indexed after the update.
    
    Available options:
    - SKIPINITIALSCAN: Skip scanning existing documents
    Time complexity: O(1)
    Specified by:
    
    ftSynupdate in interface RediSearchReactiveCommands<K,V>
    
    Overrides:
    
    ftSynupdate in class AbstractRedisReactiveCommands<K,V>
    
    Parameters:
    
    index - the index name
    
    synonymGroupId - the synonym group identifier
    
    args - the synupdate arguments (skipInitialScan)
    
    terms - the terms to add to the synonym group
    
    Returns:
    
    OK if executed correctly
    
    See Also:
    
    FT.SYNUPDATE, RediSearchReactiveCommands.ftSynupdate(String, Object, Object[]), RediSearchReactiveCommands.ftSyndump(String)
  - ftList
```
public Flux<V> ftList()
```
    Description copied from interface: RediSearchReactiveCommands
    Return a list of all existing indexes.
    This command returns an array with the names of all existing indexes in the database. This is useful for discovering available indexes and managing index lifecycle.
    
    Key features and use cases:
    - Index discovery: Find all available search indexes
    - Management: List indexes for administrative operations
    - Monitoring: Track index creation and deletion
    - Debugging: Verify index existence
    Time complexity: O(1)
    
    Note: This is a temporary command (indicated by the underscore prefix). In the future, a SCAN-type command will be added for use when a database contains a large number of indices.
    Specified by:
    
    ftList in interface RediSearchReactiveCommands<K,V>
    
    Overrides:
    
    ftList in class AbstractRedisReactiveCommands<K,V>
    
    Returns:
    
    a list of index names
    
    See Also:
    
    FT._LIST, #ftCreate(String, CreateArgs, FieldArgs[]), RediSearchReactiveCommands.ftDropindex(String)
  - ftCursorread
```
public Mono<AggregationReply<K,V>> ftCursorread(String index,
                                                AggregationReply.Cursor cursor,
                                                int count)
```
    Description copied from interface: RediSearchReactiveCommands
    
    Read next results from an existing cursor and optionally override the batch size.
    This command is used to read the next batch of results from a cursor that was created by RediSearchReactiveCommands.ftAggregate(String, Object, AggregateArgs) with the WITHCURSOR option. Cursors provide an efficient way to iterate through large result sets without loading all results into memory at once.
    
    The count parameter overrides the COUNT value specified in the original FT.AGGREGATE command, allowing you to control the batch size for this specific read operation.
    
    Time complexity: O(1)
    
    Specified by:
    
    ftCursorread in interface RediSearchReactiveCommands<K,V>
    
    Overrides:
    
    ftCursorread in class AbstractRedisReactiveCommands<K,V>
    
    Parameters:
    
    index - the index name
    
    cursor - the cursor obtained from a previous FT.AGGREGATE or FT.CURSOR READ command
    
    count - the number of results to read; overrides the COUNT from FT.AGGREGATE
    
    Returns:
    
    a Mono emitting the next batch of results; see AggregationReply
    
    See Also:
    
    FT.CURSOR READ, Cursor API, AggregationReply, RediSearchReactiveCommands.ftAggregate(String, Object, AggregateArgs)
  - ftCursorread
```
public Mono<AggregationReply<K,V>> ftCursorread(String index,
                                                AggregationReply.Cursor cursor)
```
    Description copied from interface: RediSearchReactiveCommands
    
    Read next results from an existing cursor using the default batch size.
    This command is used to read the next batch of results from a cursor created by RediSearchReactiveCommands.ftAggregate(String, Object, AggregateArgs) with the WITHCURSOR option. This variant uses the default batch size that was specified in the original FT.AGGREGATE command's WITHCURSOR clause.
    
    Cursors provide an efficient way to iterate through large result sets without loading all results into memory at once. When the cursor is exhausted (no more results), the returned SearchReply will have a cursor id of 0.
    
    Time complexity: O(1)
    
    Specified by:
    
    ftCursorread in interface RediSearchReactiveCommands<K,V>
    
    Overrides:
    
    ftCursorread in class AbstractRedisReactiveCommands<K,V>
    
    Parameters:
    
    index - the index name
    
    cursor - the cursor obtained from a previous FT.AGGREGATE or FT.CURSOR READ command
    
    Returns:
    
    a Mono emitting the next batch of results; see AggregationReply
    
    See Also:
    
    FT.CURSOR READ, Cursor API, AggregationReply, RediSearchReactiveCommands.ftAggregate(String, Object, AggregateArgs)
  - ftCursordel
```
public Mono<String> ftCursordel(String index,
                                AggregationReply.Cursor cursor)
```
    Description copied from interface: RediSearchReactiveCommands
    
    Delete a cursor and free its associated resources.
    This command is used to explicitly delete a cursor created by RediSearchReactiveCommands.ftAggregate(String, Object, AggregateArgs) with the WITHCURSOR option. Deleting a cursor frees up server resources and should be done when you no longer need to read more results from the cursor.
    
    Important: Cursors have a default timeout and may be automatically deleted by Redis if not accessed within the timeout period. However, it's good practice to explicitly delete cursors when you're finished with them to free up resources immediately.
    
    Once a cursor is deleted, any subsequent attempts to read from it using #ftCursorread(String, Cursor) or #ftCursorread(String, Cursor, int) will result in an error.
    
    Time complexity: O(1)
    
    Specified by:
    
    ftCursordel in interface RediSearchReactiveCommands<K,V>
    
    Overrides:
    
    ftCursordel in class AbstractRedisReactiveCommands<K,V>
    
    Parameters:
    
    index - the index name, as a key
    
    cursor - the cursor obtained from a previous FT.AGGREGATE or FT.CURSOR READ command
    
    Returns:
    
    a Mono emitting "OK" if the cursor was successfully deleted
    
    See Also:
    
    FT.CURSOR DEL, Cursor API, RediSearchReactiveCommands.ftAggregate(String, Object, AggregateArgs), #ftCursorread(String, Cursor), #ftCursorread(String, Cursor, int)
  - executeOnUpstream
```
protected <T> Map<String,org.reactivestreams.Publisher<T>> executeOnUpstream(Function<RedisClusterReactiveCommands<K,V>,? extends org.reactivestreams.Publisher<T>> function)
```
    Run a command on all available masters,
    
    Type Parameters:
    
    T - result type
    
    Parameters:
    
    function - function producing the command
    
    Returns:
    
    map of a key (counter) and commands.
  - executeOnNodes
```
protected <T> Map<String,org.reactivestreams.Publisher<T>> executeOnNodes(Function<RedisClusterReactiveCommands<K,V>,? extends org.reactivestreams.Publisher<T>> function,
                                                                          Predicate<RedisClusterNode> filter)
```
    Run a command on all available nodes that match filter.
    
    Type Parameters:
    
    T - result type
    
    Parameters:
    
    function - function producing the command
    
    filter - filter function for the node selection
    
    Returns:
    
    map of a key (counter) and commands.

Class RedisAdvancedClusterReactiveCommandsImpl<K,V>

Constructor Summary

Method Summary

Methods inherited from class io.lettuce.core.AbstractRedisReactiveCommands

Methods inherited from class java.lang.Object

Methods inherited from interface io.lettuce.core.cluster.api.reactive.RedisAdvancedClusterReactiveCommands

Methods inherited from interface io.lettuce.core.cluster.api.reactive.RedisClusterReactiveCommands

Methods inherited from interface io.lettuce.core.api.reactive.BaseRedisReactiveCommands

Methods inherited from interface io.lettuce.core.api.reactive.RedisAclReactiveCommands

Methods inherited from interface io.lettuce.core.api.reactive.RedisFunctionReactiveCommands

Methods inherited from interface io.lettuce.core.api.reactive.RedisGeoReactiveCommands

Methods inherited from interface io.lettuce.core.api.reactive.RedisHashReactiveCommands

Methods inherited from interface io.lettuce.core.api.reactive.RedisHLLReactiveCommands

Methods inherited from interface io.lettuce.core.api.reactive.RedisKeyReactiveCommands

Methods inherited from interface io.lettuce.core.api.reactive.RedisListReactiveCommands

Methods inherited from interface io.lettuce.core.api.reactive.RedisScriptingReactiveCommands

Methods inherited from interface io.lettuce.core.api.reactive.RedisServerReactiveCommands

Methods inherited from interface io.lettuce.core.api.reactive.RedisSetReactiveCommands

Methods inherited from interface io.lettuce.core.api.reactive.RedisSortedSetReactiveCommands

Methods inherited from interface io.lettuce.core.api.reactive.RedisStreamReactiveCommands

Methods inherited from interface io.lettuce.core.api.reactive.RedisStringReactiveCommands

Methods inherited from interface io.lettuce.core.api.reactive.RedisJsonReactiveCommands

Methods inherited from interface io.lettuce.core.api.reactive.RedisVectorSetReactiveCommands

Methods inherited from interface io.lettuce.core.api.reactive.RediSearchReactiveCommands

Constructor Detail

RedisAdvancedClusterReactiveCommandsImpl

RedisAdvancedClusterReactiveCommandsImpl

RedisAdvancedClusterReactiveCommandsImpl

RedisAdvancedClusterReactiveCommandsImpl

Method Detail

clientSetname

clusterCountKeysInSlot

clusterGetKeysInSlot

dbsize

del

del

exists

exists

flushall

flushall

flushallAsync

flushdb

flushdb

keys

keysLegacy

keys

keysLegacy

mget

mget

mget

mget

msetnx

mset

randomkey

scriptFlush

scriptKill

scriptLoad

shutdown

touch

touch

unlink

unlink

getConnection

getConnection

getStatefulConnection

scan

scan

scan

scan

scan

scan

scan

scan

ftAggregate

Performance Considerations:

ftAggregate

ftSearch

Performance Considerations:

ftSearch

ftExplain