RedisAdvancedClusterAsyncCommandsImpl (Lettuce 7.0.0.RELEASE API)

java.lang.Object
- io.lettuce.core.AbstractRedisAsyncCommands<K,V>
- - io.lettuce.core.cluster.RedisAdvancedClusterAsyncCommandsImpl<K,V>

Type Parameters:

K - Key type.

V - Value type.

All Implemented Interfaces:

BaseRedisAsyncCommands<K,V>, RedisAclAsyncCommands<K,V>, RediSearchAsyncCommands<K,V>, RedisFunctionAsyncCommands<K,V>, RedisGeoAsyncCommands<K,V>, RedisHashAsyncCommands<K,V>, RedisHLLAsyncCommands<K,V>, RedisJsonAsyncCommands<K,V>, RedisKeyAsyncCommands<K,V>, RedisListAsyncCommands<K,V>, RedisScriptingAsyncCommands<K,V>, RedisServerAsyncCommands<K,V>, RedisSetAsyncCommands<K,V>, RedisSortedSetAsyncCommands<K,V>, RedisStreamAsyncCommands<K,V>, RedisStringAsyncCommands<K,V>, RedisTransactionalAsyncCommands<K,V>, RedisVectorSetAsyncCommands<K,V>, RedisAdvancedClusterAsyncCommands<K,V>, RedisClusterAsyncCommands<K,V>
```
public class RedisAdvancedClusterAsyncCommandsImpl<K,V>
extends AbstractRedisAsyncCommands<K,V>
implements RedisAdvancedClusterAsyncCommands<K,V>
```
An advanced asynchronous and thread-safe API for a Redis Cluster connection.

Since:

3.3

Author:

Mark Paluch, Jon Chambers, Tihomir Mateev

Constructor Summary

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

Method Summary

All Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`RedisFuture<String>`	`clientSetname(K name)` Set the current connection name.
`RedisFuture<Long>`	`clusterCountKeysInSlot(int slot)` Returns the number of keys in the specified Redis Cluster hash `slot`.
`RedisFuture<List<K>>`	`clusterGetKeysInSlot(int slot, int count)` Retrieve the list of keys within the `slot`.
`RedisFuture<Long>`	`dbsize()` Return the number of keys in the selected database.
`RedisFuture<Long>`	`del(Iterable<K> keys)`
`RedisFuture<Long>`	`del(K... keys)` Delete one or more keys.
`protected <T> Map<String,CompletableFuture<T>>`	`executeOnNodes(Function<RedisClusterAsyncCommands<K,V>,RedisFuture<T>> function, Function<RedisClusterNode,Boolean> filter)` Run a command on all available nodes that match `filter`.
`protected <T> Map<String,CompletableFuture<T>>`	`executeOnUpstream(Function<RedisClusterAsyncCommands<K,V>,RedisFuture<T>> function)` Run a command on all available masters,
`RedisFuture<Long>`	`exists(Iterable<K> keys)`
`RedisFuture<Long>`	`exists(K... keys)` Determine how many keys exist.
`RedisFuture<String>`	`flushall()` Remove all keys from all databases.
`RedisFuture<String>`	`flushall(FlushMode flushMode)` Remove all keys from all databases using the specified `FlushMode`.
`RedisFuture<String>`	`flushallAsync()` Remove all keys asynchronously from all databases.
`RedisFuture<String>`	`flushdb()` Remove all keys from the current database.
`RedisFuture<String>`	`flushdb(FlushMode flushMode)` Remove all keys from the current database using the specified `FlushMode`.
`RedisFuture<AggregationReply<K,V>>`	`ftAggregate(String index, V query)` Run a search query on an index and perform basic aggregate transformations using default options.
`RedisFuture<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.
`RedisFuture<String>`	`ftAliasadd(String alias, String index)` Add an alias to a search index.
`RedisFuture<String>`	`ftAliasdel(String alias)` Remove an alias from a search index.
`RedisFuture<String>`	`ftAliasupdate(String alias, String index)` Update an existing alias to point to a different search index.
`RedisFuture<String>`	`ftAlter(String index, boolean skipInitialScan, List<FieldArgs<K>> fieldArgs)` Add new attributes to an existing search index.
`RedisFuture<String>`	`ftAlter(String index, List<FieldArgs<K>> fieldArgs)` Add new attributes to an existing search index.
`RedisFuture<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.
`RedisFuture<String>`	`ftCreate(String index, List<FieldArgs<K>> fieldArgs)` Create a new search index with the given name and field definitions using default settings.
`RedisFuture<String>`	`ftCursordel(String index, AggregationReply.Cursor cursor)` Delete a cursor and free its associated resources.
`RedisFuture<AggregationReply<K,V>>`	`ftCursorread(String index, AggregationReply.Cursor cursor)` Read next results from an existing cursor using the default batch size.
`RedisFuture<AggregationReply<K,V>>`	`ftCursorread(String index, AggregationReply.Cursor cursor, int count)` Read next results from an existing cursor and optionally override the batch size.
`RedisFuture<Long>`	`ftDictadd(String dict, V... terms)` Add terms to a dictionary.
`RedisFuture<Long>`	`ftDictdel(String dict, V... terms)` Delete terms from a dictionary.
`RedisFuture<List<V>>`	`ftDictdump(String dict)` Dump all terms in a dictionary.
`RedisFuture<String>`	`ftDropindex(String index)` Drop a search index without deleting the associated documents.
`RedisFuture<String>`	`ftDropindex(String index, boolean deleteDocumentKeys)` Drop a search index with optional document deletion.
`RedisFuture<String>`	`ftExplain(String index, V query)` Return the execution plan for a complex query.
`RedisFuture<String>`	`ftExplain(String index, V query, ExplainArgs<K,V> args)` Return the execution plan for a complex query with additional options.
`RedisFuture<List<V>>`	`ftList()` Return a list of all existing indexes.
`RedisFuture<SearchReply<K,V>>`	`ftSearch(String index, V query)` Search the index with a textual query using default search options.
`RedisFuture<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.
`RedisFuture<SpellCheckResult<V>>`	`ftSpellcheck(String index, V query)` Perform spelling correction on a query, returning suggestions for misspelled terms.
`RedisFuture<SpellCheckResult<V>>`	`ftSpellcheck(String index, V query, SpellCheckArgs<K,V> args)` Perform spelling correction on a query with additional options.
`RedisFuture<Map<V,List<V>>>`	`ftSyndump(String index)` Dump synonym group contents.
`RedisFuture<String>`	`ftSynupdate(String index, V synonymGroupId, SynUpdateArgs<K,V> args, V... terms)` Update a synonym group with additional terms and options.
`RedisFuture<String>`	`ftSynupdate(String index, V synonymGroupId, V... terms)` Update a synonym group with additional terms.
`RedisFuture<List<V>>`	`ftTagvals(String index, String fieldName)` Return a distinct set of values indexed in a Tag field.
`RedisClusterAsyncCommands<K,V>`	`getConnection(String nodeId)` Retrieve a connection to the specified cluster node using the nodeId.
`RedisClusterAsyncCommands<K,V>`	`getConnection(String host, int port)` Retrieve a connection to the specified cluster node using host and port.
`StatefulRedisClusterConnection<K,V>`	`getStatefulConnection()`
`RedisFuture<List<JsonValue>>`	`jsonMGet(JsonPath jsonPath, K... keys)` Return the values at the specified path from multiple key arguments.
`RedisFuture<String>`	`jsonMSet(List<JsonMsetArgs<K,V>> arguments)` Set or update one or more JSON values according to the specified `JsonMsetArgs` JSON.MSET is atomic, hence, all given additions or updates are either applied or not.
`RedisFuture<Long>`	`keys(KeyStreamingChannel<K> channel, String pattern)` Find all keys matching the given pattern.
`RedisFuture<List<K>>`	`keys(String pattern)` Find all keys matching the given pattern.
`RedisFuture<List<K>>`	`keysLegacy(K pattern)` Deprecated. Use `keys(String)` instead. This legacy overload will be removed in a later version.
`RedisFuture<Long>`	`keysLegacy(KeyStreamingChannel<K> channel, K pattern)` Deprecated. Use `keys(KeyStreamingChannel, String)` instead. This legacy overload will be removed in a later version.
`RedisFuture<List<KeyValue<K,V>>>`	`mget(Iterable<K> keys)`
`RedisFuture<List<KeyValue<K,V>>>`	`mget(K... keys)` Get the values of all the given keys.
`RedisFuture<Long>`	`mget(KeyValueStreamingChannel<K,V> channel, Iterable<K> keys)`
`RedisFuture<Long>`	`mget(KeyValueStreamingChannel<K,V> channel, K... keys)` Stream over the values of all the given keys.
`RedisFuture<String>`	`mset(Map<K,V> map)` Set multiple keys to multiple values.
`RedisFuture<Boolean>`	`msetnx(Map<K,V> map)` Set multiple keys to multiple values, only if none of the keys exist.
`AsyncNodeSelection<K,V>`	`nodes(Predicate<RedisClusterNode> predicate)` Select nodes by a predicate and keeps a static selection.
`AsyncNodeSelection<K,V>`	`nodes(Predicate<RedisClusterNode> predicate, boolean dynamic)` Select nodes by a predicate
`protected AsyncNodeSelection<K,V>`	`nodes(Predicate<RedisClusterNode> predicate, ConnectionIntent connectionIntent, boolean dynamic)`
`RedisFuture<K>`	`randomkey()` Return a random key from the keyspace.
`AsyncNodeSelection<K,V>`	`readonly(Predicate<RedisClusterNode> predicate)` Select replica nodes by a predicate and keeps a static selection.
`RedisFuture<KeyScanCursor<K>>`	`scan()` Incrementally iterate the keys space.
`RedisFuture<StreamScanCursor>`	`scan(KeyStreamingChannel<K> channel)` Incrementally iterate the keys space.
`RedisFuture<StreamScanCursor>`	`scan(KeyStreamingChannel<K> channel, ScanArgs scanArgs)` Incrementally iterate the keys space.
`RedisFuture<StreamScanCursor>`	`scan(KeyStreamingChannel<K> channel, ScanCursor scanCursor)` Incrementally iterate the keys space.
`RedisFuture<StreamScanCursor>`	`scan(KeyStreamingChannel<K> channel, ScanCursor scanCursor, ScanArgs scanArgs)` Incrementally iterate the keys space.
`RedisFuture<KeyScanCursor<K>>`	`scan(ScanArgs scanArgs)` Incrementally iterate the keys space.
`RedisFuture<KeyScanCursor<K>>`	`scan(ScanCursor scanCursor)` Incrementally iterate the keys space.
`RedisFuture<KeyScanCursor<K>>`	`scan(ScanCursor scanCursor, ScanArgs scanArgs)` Incrementally iterate the keys space.
`RedisFuture<String>`	`scriptFlush()` Remove all the scripts from the script cache.
`RedisFuture<String>`	`scriptKill()` Kill the script currently in execution.
`RedisFuture<String>`	`scriptLoad(byte[] script)` Load the specified Lua script into the script cache.
`void`	`shutdown(boolean save)` Synchronously save the dataset to disk and then shut down the server.
`RedisFuture<Long>`	`touch(Iterable<K> keys)`
`RedisFuture<Long>`	`touch(K... keys)` Touch one or more keys.
`RedisFuture<Long>`	`unlink(Iterable<K> keys)`
`RedisFuture<Long>`	`unlink(K... keys)` Unlink one or more keys (non blocking DEL).

Methods inherited from class io.lettuce.core.AbstractRedisAsyncCommands
aclCat, aclCat, aclDeluser, aclDryRun, aclDryRun, aclGenpass, aclGenpass, aclGetuser, aclList, aclLoad, aclLog, aclLog, aclLogReset, aclSave, aclSetuser, aclUsers, aclWhoami, append, asking, auth, auth, 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, debugCrashAndRecover, debugHtstats, debugObject, debugOom, debugReload, debugRestart, debugSdslen, debugSegfault, decr, decrby, digest, digest, discard, dispatch, dispatch, dispatch, dispatch, dispatch, dump, echo, eval, eval, eval, eval, evalReadOnly, evalReadOnly, evalsha, evalsha, evalshaReadOnly, exec, 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, jsonMGetRaw, 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, migrate, migrate, move, multi, objectEncoding, objectFreq, objectIdletime, objectRefcount, persist, pexpire, pexpire, pexpire, pexpire, pexpireat, pexpireat, pexpireat, pexpireat, pexpireat, pexpireat, pexpiretime, pfadd, pfcount, 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.async.RedisAdvancedClusterAsyncCommands
all, masters, replicas, replicas, scriptLoad, slaves, slaves, upstream

Methods inherited from interface io.lettuce.core.cluster.api.async.RedisClusterAsyncCommands
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, getJsonParser, readOnly, readWrite, setTimeout

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

Methods inherited from interface io.lettuce.core.api.async.RedisAclAsyncCommands
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.async.RedisFunctionAsyncCommands
fcall, fcall, fcallReadOnly, fcallReadOnly, functionDump, functionFlush, functionKill, functionList, functionList, functionLoad, functionLoad, functionRestore, functionRestore

Methods inherited from interface io.lettuce.core.api.async.RedisGeoAsyncCommands
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.async.RedisHashAsyncCommands
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.async.RedisHLLAsyncCommands
pfadd, pfcount, pfmerge

Methods inherited from interface io.lettuce.core.api.async.RedisKeyAsyncCommands
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.async.RedisListAsyncCommands
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.async.RedisScriptingAsyncCommands
digest, digest, eval, eval, eval, eval, evalReadOnly, evalReadOnly, evalsha, evalsha, evalshaReadOnly, scriptExists, scriptFlush

Methods inherited from interface io.lettuce.core.api.async.RedisServerAsyncCommands
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.async.RedisSetAsyncCommands
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.async.RedisSortedSetAsyncCommands
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.async.RedisStreamAsyncCommands
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.async.RedisStringAsyncCommands
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.async.RedisJsonAsyncCommands
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, jsonMGetRaw, 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.async.RedisVectorSetAsyncCommands
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.async.RediSearchAsyncCommands
ftSugadd, ftSugadd, ftSugdel, ftSugget, ftSugget, ftSuglen

- Constructor Detail
  - RedisAdvancedClusterAsyncCommandsImpl
```
@Deprecated
public RedisAdvancedClusterAsyncCommandsImpl(StatefulRedisClusterConnectionImpl<K,V> connection,
                                                         RedisCodec<K,V> codec,
                                                         Supplier<JsonParser> parser)
```
    Deprecated. since 5.1, use RedisAdvancedClusterAsyncCommandsImpl(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
  - RedisAdvancedClusterAsyncCommandsImpl
```
@Deprecated
public RedisAdvancedClusterAsyncCommandsImpl(StatefulRedisClusterConnectionImpl<K,V> connection,
                                                         RedisCodec<K,V> codec)
```
    Deprecated. since 5.1, use RedisAdvancedClusterAsyncCommandsImpl(StatefulRedisClusterConnection, RedisCodec, Supplier).
    
    Initialize a new connection.
    
    Parameters:
    
    connection - the stateful connection
    
    codec - Codec used to encode/decode keys and values.
  - RedisAdvancedClusterAsyncCommandsImpl
```
public RedisAdvancedClusterAsyncCommandsImpl(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
  - RedisAdvancedClusterAsyncCommandsImpl
```
public RedisAdvancedClusterAsyncCommandsImpl(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 RedisFuture<String> clientSetname(K name)
```
    Description copied from interface: RedisServerAsyncCommands
    
    Set the current connection name.
    
    Specified by:
    
    clientSetname in interface RedisServerAsyncCommands<K,V>
    
    Specified by:
    
    clientSetname in interface RedisAdvancedClusterAsyncCommands<K,V>
    
    Overrides:
    
    clientSetname in class AbstractRedisAsyncCommands<K,V>
    
    Parameters:
    
    name - the client name.
    
    Returns:
    
    simple-string-reply OK if the connection name was successfully set.
    
    See Also:
    
    RedisServerAsyncCommands.clientSetname(Object)
  - clusterCountKeysInSlot
```
public RedisFuture<Long> clusterCountKeysInSlot(int slot)
```
    Description copied from interface: RedisClusterAsyncCommands
    
    Returns the number of keys in the specified Redis Cluster hash slot.
    
    Specified by:
    
    clusterCountKeysInSlot in interface RedisClusterAsyncCommands<K,V>
    
    Overrides:
    
    clusterCountKeysInSlot in class AbstractRedisAsyncCommands<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 RedisFuture<List<K>> clusterGetKeysInSlot(int slot,
                                                 int count)
```
    Description copied from interface: RedisClusterAsyncCommands
    
    Retrieve the list of keys within the slot.
    
    Specified by:
    
    clusterGetKeysInSlot in interface RedisClusterAsyncCommands<K,V>
    
    Overrides:
    
    clusterGetKeysInSlot in class AbstractRedisAsyncCommands<K,V>
    
    Parameters:
    
    slot - the slot
    
    count - maximal number of keys
    
    Returns:
    
    List<K> array-reply list of keys
  - dbsize
```
public RedisFuture<Long> dbsize()
```
    Description copied from interface: RedisServerAsyncCommands
    
    Return the number of keys in the selected database.
    
    Specified by:
    
    dbsize in interface RedisServerAsyncCommands<K,V>
    
    Specified by:
    
    dbsize in interface RedisAdvancedClusterAsyncCommands<K,V>
    
    Overrides:
    
    dbsize in class AbstractRedisAsyncCommands<K,V>
    
    Returns:
    
    Long integer-reply.
    
    See Also:
    
    RedisServerAsyncCommands.dbsize()
  - del
```
public RedisFuture<Long> del(K... keys)
```
    Description copied from interface: RedisKeyAsyncCommands
    
    Delete one or more keys.
    
    Specified by:
    
    del in interface RedisKeyAsyncCommands<K,V>
    
    Specified by:
    
    del in interface RedisAdvancedClusterAsyncCommands<K,V>
    
    Overrides:
    
    del in class AbstractRedisAsyncCommands<K,V>
    
    Parameters:
    
    keys - the keys.
    
    Returns:
    
    Long integer-reply The number of keys that were removed.
    
    See Also:
    
    RedisKeyAsyncCommands.del(Object[])
  - del
```
public RedisFuture<Long> del(Iterable<K> keys)
```
    Overrides:
    
    del in class AbstractRedisAsyncCommands<K,V>
  - exists
```
public RedisFuture<Long> exists(K... keys)
```
    Description copied from interface: RedisKeyAsyncCommands
    
    Determine how many keys exist.
    
    Specified by:
    
    exists in interface RedisKeyAsyncCommands<K,V>
    
    Specified by:
    
    exists in interface RedisAdvancedClusterAsyncCommands<K,V>
    
    Overrides:
    
    exists in class AbstractRedisAsyncCommands<K,V>
    
    Parameters:
    
    keys - the keys.
    
    Returns:
    
    Long integer-reply specifically: Number of existing keys.
  - exists
```
public RedisFuture<Long> exists(Iterable<K> keys)
```
    Overrides:
    
    exists in class AbstractRedisAsyncCommands<K,V>
  - flushall
```
public RedisFuture<String> flushall()
```
    Description copied from interface: RedisServerAsyncCommands
    
    Remove all keys from all databases.
    
    Specified by:
    
    flushall in interface RedisServerAsyncCommands<K,V>
    
    Specified by:
    
    flushall in interface RedisAdvancedClusterAsyncCommands<K,V>
    
    Overrides:
    
    flushall in class AbstractRedisAsyncCommands<K,V>
    
    Returns:
    
    String simple-string-reply.
    
    See Also:
    
    RedisServerAsyncCommands.flushall()
  - flushall
```
public RedisFuture<String> flushall(FlushMode flushMode)
```
    Description copied from interface: RedisServerAsyncCommands
    
    Remove all keys from all databases using the specified FlushMode.
    
    Specified by:
    
    flushall in interface RedisServerAsyncCommands<K,V>
    
    Overrides:
    
    flushall in class AbstractRedisAsyncCommands<K,V>
    
    Parameters:
    
    flushMode - the flush mode (sync/async).
    
    Returns:
    
    String simple-string-reply.
  - flushallAsync
```
public RedisFuture<String> flushallAsync()
```
    Description copied from interface: RedisServerAsyncCommands
    
    Remove all keys asynchronously from all databases.
    
    Specified by:
    
    flushallAsync in interface RedisServerAsyncCommands<K,V>
    
    Specified by:
    
    flushallAsync in interface RedisAdvancedClusterAsyncCommands<K,V>
    
    Overrides:
    
    flushallAsync in class AbstractRedisAsyncCommands<K,V>
    
    Returns:
    
    String simple-string-reply.
    
    See Also:
    
    RedisServerAsyncCommands.flushallAsync()
  - flushdb
```
public RedisFuture<String> flushdb()
```
    Description copied from interface: RedisServerAsyncCommands
    
    Remove all keys from the current database.
    
    Specified by:
    
    flushdb in interface RedisServerAsyncCommands<K,V>
    
    Specified by:
    
    flushdb in interface RedisAdvancedClusterAsyncCommands<K,V>
    
    Overrides:
    
    flushdb in class AbstractRedisAsyncCommands<K,V>
    
    Returns:
    
    String simple-string-reply.
    
    See Also:
    
    RedisServerAsyncCommands.flushdb()
  - flushdb
```
public RedisFuture<String> flushdb(FlushMode flushMode)
```
    Description copied from interface: RedisServerAsyncCommands
    
    Remove all keys from the current database using the specified FlushMode.
    
    Specified by:
    
    flushdb in interface RedisServerAsyncCommands<K,V>
    
    Overrides:
    
    flushdb in class AbstractRedisAsyncCommands<K,V>
    
    Parameters:
    
    flushMode - the flush mode (sync/async).
    
    Returns:
    
    String simple-string-reply.
  - keys
```
public RedisFuture<List<K>> keys(String pattern)
```
    Description copied from interface: RedisKeyAsyncCommands
    
    Find all keys matching the given pattern.
    
    Specified by:
    
    keys in interface RedisKeyAsyncCommands<K,V>
    
    Specified by:
    
    keys in interface RedisAdvancedClusterAsyncCommands<K,V>
    
    Overrides:
    
    keys in class AbstractRedisAsyncCommands<K,V>
    
    Parameters:
    
    pattern - the pattern type.
    
    Returns:
    
    List<K> array-reply list of keys matching pattern.
    
    See Also:
    
    RedisKeyAsyncCommands.keys(String)
  - keysLegacy
```
@Deprecated
public RedisFuture<List<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 RedisKeyAsyncCommands<K,V>
    
    Specified by:
    
    keysLegacy in interface RedisAdvancedClusterAsyncCommands<K,V>
    
    Overrides:
    
    keysLegacy in class AbstractRedisAsyncCommands<K,V>
    
    Parameters:
    
    pattern - the pattern type: patternkey (pattern).
    
    Returns:
    
    List<K> array-reply list of keys matching pattern.
  - keys
```
public RedisFuture<Long> keys(KeyStreamingChannel<K> channel,
                              String pattern)
```
    Description copied from interface: RedisKeyAsyncCommands
    
    Find all keys matching the given pattern.
    
    Specified by:
    
    keys in interface RedisKeyAsyncCommands<K,V>
    
    Specified by:
    
    keys in interface RedisAdvancedClusterAsyncCommands<K,V>
    
    Overrides:
    
    keys in class AbstractRedisAsyncCommands<K,V>
    
    Parameters:
    
    channel - the channel.
    
    pattern - the pattern type.
    
    Returns:
    
    Long array-reply list of keys matching pattern.
    
    See Also:
    
    RedisKeyAsyncCommands.keys(KeyStreamingChannel, String)
  - keysLegacy
```
@Deprecated
public RedisFuture<Long> keysLegacy(KeyStreamingChannel<K> channel,
                                                K pattern)
```
    Deprecated. Use keys(KeyStreamingChannel, 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 RedisKeyAsyncCommands<K,V>
    
    Specified by:
    
    keysLegacy in interface RedisAdvancedClusterAsyncCommands<K,V>
    
    Overrides:
    
    keysLegacy in class AbstractRedisAsyncCommands<K,V>
    
    Parameters:
    
    channel - the channel.
    
    pattern - the pattern.
    
    Returns:
    
    Long array-reply list of keys matching pattern.
  - jsonMGet
```
public RedisFuture<List<JsonValue>> jsonMGet(JsonPath jsonPath,
                                             K... keys)
```
    Description copied from interface: RedisJsonAsyncCommands
    
    Return the values at the specified path from multiple key arguments.
    
    Specified by:
    
    jsonMGet in interface RedisJsonAsyncCommands<K,V>
    
    Overrides:
    
    jsonMGet in class AbstractRedisAsyncCommands<K,V>
    
    Parameters:
    
    jsonPath - the JsonPath pointing to the value to fetch.
    
    keys - the keys holding the JsonValues to fetch.
    
    Returns:
    
    List the values at path, or null if the path does not exist.
  - mget
```
public RedisFuture<List<KeyValue<K,V>>> mget(K... keys)
```
    Description copied from interface: RedisStringAsyncCommands
    
    Get the values of all the given keys.
    
    Specified by:
    
    mget in interface RedisStringAsyncCommands<K,V>
    
    Specified by:
    
    mget in interface RedisAdvancedClusterAsyncCommands<K,V>
    
    Overrides:
    
    mget in class AbstractRedisAsyncCommands<K,V>
    
    Parameters:
    
    keys - the key.
    
    Returns:
    
    List<V> array-reply list of values at the specified keys.
    
    See Also:
    
    RedisStringAsyncCommands.mget(Object[])
  - mget
```
public RedisFuture<List<KeyValue<K,V>>> mget(Iterable<K> keys)
```
    Overrides:
    
    mget in class AbstractRedisAsyncCommands<K,V>
  - mget
```
public RedisFuture<Long> mget(KeyValueStreamingChannel<K,V> channel,
                              K... keys)
```
    Description copied from interface: RedisStringAsyncCommands
    
    Stream over the values of all the given keys.
    
    Specified by:
    
    mget in interface RedisStringAsyncCommands<K,V>
    
    Overrides:
    
    mget in class AbstractRedisAsyncCommands<K,V>
    
    Parameters:
    
    channel - the channel.
    
    keys - the keys.
    
    Returns:
    
    Long array-reply list of values at the specified keys.
  - mget
```
public RedisFuture<Long> mget(KeyValueStreamingChannel<K,V> channel,
                              Iterable<K> keys)
```
    Overrides:
    
    mget in class AbstractRedisAsyncCommands<K,V>
  - jsonMSet
```
public RedisFuture<String> jsonMSet(List<JsonMsetArgs<K,V>> arguments)
```
    Description copied from interface: RedisJsonAsyncCommands
    
    Set or update one or more JSON values according to the specified JsonMsetArgs
    JSON.MSET is atomic, hence, all given additions or updates are either applied or not. It is not possible for clients to see that some keys were updated while others are unchanged.
    A JSON value is a hierarchical structure. If you change a value in a specific path - nested values are affected.
    
    Specified by:
    
    jsonMSet in interface RedisJsonAsyncCommands<K,V>
    
    Overrides:
    
    jsonMSet in class AbstractRedisAsyncCommands<K,V>
    
    Parameters:
    
    arguments - the JsonMsetArgs specifying the values to change.
    
    Returns:
    
    "OK" if the operation was successful, error otherwise
  - mset
```
public RedisFuture<String> mset(Map<K,V> map)
```
    Description copied from interface: RedisStringAsyncCommands
    
    Set multiple keys to multiple values.
    
    Specified by:
    
    mset in interface RedisStringAsyncCommands<K,V>
    
    Specified by:
    
    mset in interface RedisAdvancedClusterAsyncCommands<K,V>
    
    Overrides:
    
    mset in class AbstractRedisAsyncCommands<K,V>
    
    Parameters:
    
    map - the map.
    
    Returns:
    
    String simple-string-reply always OK since MSET can't fail.
    
    See Also:
    
    RedisStringAsyncCommands.mset(Map)
  - msetnx
```
public RedisFuture<Boolean> msetnx(Map<K,V> map)
```
    Description copied from interface: RedisStringAsyncCommands
    
    Set multiple keys to multiple values, only if none of the keys exist.
    
    Specified by:
    
    msetnx in interface RedisStringAsyncCommands<K,V>
    
    Specified by:
    
    msetnx in interface RedisAdvancedClusterAsyncCommands<K,V>
    
    Specified by:
    
    msetnx in interface RedisClusterAsyncCommands<K,V>
    
    Overrides:
    
    msetnx in class AbstractRedisAsyncCommands<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:
    
    RedisStringAsyncCommands.msetnx(Map)
  - randomkey
```
public RedisFuture<K> randomkey()
```
    Description copied from interface: RedisKeyAsyncCommands
    
    Return a random key from the keyspace.
    
    Specified by:
    
    randomkey in interface RedisKeyAsyncCommands<K,V>
    
    Specified by:
    
    randomkey in interface RedisAdvancedClusterAsyncCommands<K,V>
    
    Overrides:
    
    randomkey in class AbstractRedisAsyncCommands<K,V>
    
    Returns:
    
    K bulk-string-reply the random key, or null when the database is empty.
    
    See Also:
    
    RedisKeyAsyncCommands.randomkey()
  - scriptFlush
```
public RedisFuture<String> scriptFlush()
```
    Description copied from interface: RedisScriptingAsyncCommands
    
    Remove all the scripts from the script cache.
    
    Specified by:
    
    scriptFlush in interface RedisScriptingAsyncCommands<K,V>
    
    Specified by:
    
    scriptFlush in interface RedisAdvancedClusterAsyncCommands<K,V>
    
    Overrides:
    
    scriptFlush in class AbstractRedisAsyncCommands<K,V>
    
    Returns:
    
    String simple-string-reply.
    
    See Also:
    
    RedisScriptingAsyncCommands.scriptFlush()
  - scriptKill
```
public RedisFuture<String> scriptKill()
```
    Description copied from interface: RedisScriptingAsyncCommands
    
    Kill the script currently in execution.
    
    Specified by:
    
    scriptKill in interface RedisScriptingAsyncCommands<K,V>
    
    Specified by:
    
    scriptKill in interface RedisAdvancedClusterAsyncCommands<K,V>
    
    Overrides:
    
    scriptKill in class AbstractRedisAsyncCommands<K,V>
    
    Returns:
    
    String simple-string-reply.
    
    See Also:
    
    RedisScriptingAsyncCommands.scriptKill()
  - scriptLoad
```
public RedisFuture<String> scriptLoad(byte[] script)
```
    Description copied from interface: RedisScriptingAsyncCommands
    
    Load the specified Lua script into the script cache.
    
    Specified by:
    
    scriptLoad in interface RedisScriptingAsyncCommands<K,V>
    
    Specified by:
    
    scriptLoad in interface RedisAdvancedClusterAsyncCommands<K,V>
    
    Overrides:
    
    scriptLoad in class AbstractRedisAsyncCommands<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 void shutdown(boolean save)
```
    Description copied from interface: RedisServerAsyncCommands
    
    Synchronously save the dataset to disk and then shut down the server.
    
    Specified by:
    
    shutdown in interface RedisServerAsyncCommands<K,V>
    
    Specified by:
    
    shutdown in interface RedisAdvancedClusterAsyncCommands<K,V>
    
    Overrides:
    
    shutdown in class AbstractRedisAsyncCommands<K,V>
    
    Parameters:
    
    save - true force save operation.
    
    See Also:
    
    RedisServerAsyncCommands.shutdown(boolean)
  - touch
```
public RedisFuture<Long> touch(K... keys)
```
    Description copied from interface: RedisKeyAsyncCommands
    
    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 RedisKeyAsyncCommands<K,V>
    
    Specified by:
    
    touch in interface RedisAdvancedClusterAsyncCommands<K,V>
    
    Overrides:
    
    touch in class AbstractRedisAsyncCommands<K,V>
    
    Parameters:
    
    keys - the keys.
    
    Returns:
    
    Long integer-reply the number of found keys.
  - touch
```
public RedisFuture<Long> touch(Iterable<K> keys)
```
    Overrides:
    
    touch in class AbstractRedisAsyncCommands<K,V>
  - unlink
```
public RedisFuture<Long> unlink(K... keys)
```
    Description copied from interface: RedisKeyAsyncCommands
    
    Unlink one or more keys (non blocking DEL).
    
    Specified by:
    
    unlink in interface RedisKeyAsyncCommands<K,V>
    
    Specified by:
    
    unlink in interface RedisAdvancedClusterAsyncCommands<K,V>
    
    Overrides:
    
    unlink in class AbstractRedisAsyncCommands<K,V>
    
    Parameters:
    
    keys - the keys.
    
    Returns:
    
    Long integer-reply The number of keys that were removed.
    
    See Also:
    
    RedisKeyAsyncCommands.unlink(Object[])
  - unlink
```
public RedisFuture<Long> unlink(Iterable<K> keys)
```
    Overrides:
    
    unlink in class AbstractRedisAsyncCommands<K,V>
  - getConnection
```
public RedisClusterAsyncCommands<K,V> getConnection(String nodeId)
```
    Description copied from interface: RedisAdvancedClusterAsyncCommands
    
    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 RedisAdvancedClusterAsyncCommands, node-connections do not route commands to other cluster nodes
    
    Specified by:
    
    getConnection in interface RedisAdvancedClusterAsyncCommands<K,V>
    
    Parameters:
    
    nodeId - the node Id
    
    Returns:
    
    a connection to the requested cluster node
  - getConnection
```
public RedisClusterAsyncCommands<K,V> getConnection(String host,
                                                    int port)
```
    Description copied from interface: RedisAdvancedClusterAsyncCommands
    
    Retrieve a connection to the specified cluster node using host and port. In contrast to the RedisAdvancedClusterAsyncCommands, 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 RedisAdvancedClusterAsyncCommands<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 RedisAdvancedClusterAsyncCommands<K,V>
    
    Returns:
    
    the underlying connection.
  - nodes
```
public AsyncNodeSelection<K,V> nodes(Predicate<RedisClusterNode> predicate)
```
    Description copied from interface: RedisAdvancedClusterAsyncCommands
    
    Select nodes by a predicate and keeps a static selection. The set of nodes within the NodeSelectionSupport does not change when the cluster view changes.
    
    Specified by:
    
    nodes in interface RedisAdvancedClusterAsyncCommands<K,V>
    
    Parameters:
    
    predicate - Predicate to filter nodes
    
    Returns:
    
    API with asynchronous executed commands on a selection of cluster nodes matching predicate
  - readonly
```
public AsyncNodeSelection<K,V> readonly(Predicate<RedisClusterNode> predicate)
```
    Description copied from interface: RedisAdvancedClusterAsyncCommands
    
    Select replica nodes by a predicate and keeps a static selection. Replica connections operate in READONLY mode. The set of nodes within the NodeSelectionSupport does not change when the cluster view changes.
    
    Specified by:
    
    readonly in interface RedisAdvancedClusterAsyncCommands<K,V>
    
    Parameters:
    
    predicate - Predicate to filter nodes
    
    Returns:
    
    API with asynchronous executed commands on a selection of cluster nodes matching predicate
  - nodes
```
public AsyncNodeSelection<K,V> nodes(Predicate<RedisClusterNode> predicate,
                                     boolean dynamic)
```
    Description copied from interface: RedisAdvancedClusterAsyncCommands
    
    Select nodes by a predicate
    
    Specified by:
    
    nodes in interface RedisAdvancedClusterAsyncCommands<K,V>
    
    Parameters:
    
    predicate - Predicate to filter nodes
    
    dynamic - Defines, whether the set of nodes within the NodeSelectionSupport can change when the cluster view changes.
    
    Returns:
    
    API with asynchronous executed commands on a selection of cluster nodes matching predicate
  - nodes
```
protected AsyncNodeSelection<K,V> nodes(Predicate<RedisClusterNode> predicate,
                                        ConnectionIntent connectionIntent,
                                        boolean dynamic)
```
  - scan
```
public RedisFuture<KeyScanCursor<K>> scan()
```
    Description copied from interface: RedisKeyAsyncCommands
    
    Incrementally iterate the keys space.
    
    Specified by:
    
    scan in interface RedisKeyAsyncCommands<K,V>
    
    Specified by:
    
    scan in interface RedisAdvancedClusterAsyncCommands<K,V>
    
    Overrides:
    
    scan in class AbstractRedisAsyncCommands<K,V>
    
    Returns:
    
    KeyScanCursor<K> scan cursor.
    
    See Also:
    
    RedisKeyAsyncCommands.scan()
  - scan
```
public RedisFuture<KeyScanCursor<K>> scan(ScanArgs scanArgs)
```
    Description copied from interface: RedisKeyAsyncCommands
    
    Incrementally iterate the keys space. Use KeyScanArgs to specify SCAN-specific arguments.
    
    Specified by:
    
    scan in interface RedisKeyAsyncCommands<K,V>
    
    Specified by:
    
    scan in interface RedisAdvancedClusterAsyncCommands<K,V>
    
    Overrides:
    
    scan in class AbstractRedisAsyncCommands<K,V>
    
    Parameters:
    
    scanArgs - scan arguments.
    
    Returns:
    
    KeyScanCursor<K> scan cursor.
    
    See Also:
    
    KeyScanArgs
  - scan
```
public RedisFuture<KeyScanCursor<K>> scan(ScanCursor scanCursor,
                                          ScanArgs scanArgs)
```
    Description copied from interface: RedisKeyAsyncCommands
    
    Incrementally iterate the keys space. Use KeyScanArgs to specify SCAN-specific arguments.
    
    Specified by:
    
    scan in interface RedisKeyAsyncCommands<K,V>
    
    Specified by:
    
    scan in interface RedisAdvancedClusterAsyncCommands<K,V>
    
    Overrides:
    
    scan in class AbstractRedisAsyncCommands<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 RedisFuture<KeyScanCursor<K>> scan(ScanCursor scanCursor)
```
    Description copied from interface: RedisKeyAsyncCommands
    
    Incrementally iterate the keys space.
    
    Specified by:
    
    scan in interface RedisKeyAsyncCommands<K,V>
    
    Specified by:
    
    scan in interface RedisAdvancedClusterAsyncCommands<K,V>
    
    Overrides:
    
    scan in class AbstractRedisAsyncCommands<K,V>
    
    Parameters:
    
    scanCursor - cursor to resume from a previous scan, must not be null.
    
    Returns:
    
    KeyScanCursor<K> scan cursor.
    
    See Also:
    
    RedisKeyAsyncCommands.scan(ScanCursor)
  - scan
```
public RedisFuture<StreamScanCursor> scan(KeyStreamingChannel<K> channel)
```
    Description copied from interface: RedisKeyAsyncCommands
    
    Incrementally iterate the keys space.
    
    Specified by:
    
    scan in interface RedisKeyAsyncCommands<K,V>
    
    Specified by:
    
    scan in interface RedisAdvancedClusterAsyncCommands<K,V>
    
    Overrides:
    
    scan in class AbstractRedisAsyncCommands<K,V>
    
    Parameters:
    
    channel - streaming channel that receives a call for every key.
    
    Returns:
    
    StreamScanCursor scan cursor.
    
    See Also:
    
    RedisKeyAsyncCommands.scan(KeyStreamingChannel)
  - scan
```
public RedisFuture<StreamScanCursor> scan(KeyStreamingChannel<K> channel,
                                          ScanArgs scanArgs)
```
    Description copied from interface: RedisKeyAsyncCommands
    
    Incrementally iterate the keys space. Use KeyScanArgs to specify SCAN-specific arguments.
    
    Specified by:
    
    scan in interface RedisKeyAsyncCommands<K,V>
    
    Specified by:
    
    scan in interface RedisAdvancedClusterAsyncCommands<K,V>
    
    Overrides:
    
    scan in class AbstractRedisAsyncCommands<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 RedisFuture<StreamScanCursor> scan(KeyStreamingChannel<K> channel,
                                          ScanCursor scanCursor,
                                          ScanArgs scanArgs)
```
    Description copied from interface: RedisKeyAsyncCommands
    
    Incrementally iterate the keys space. Use KeyScanArgs to specify SCAN-specific arguments.
    
    Specified by:
    
    scan in interface RedisKeyAsyncCommands<K,V>
    
    Specified by:
    
    scan in interface RedisAdvancedClusterAsyncCommands<K,V>
    
    Overrides:
    
    scan in class AbstractRedisAsyncCommands<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 RedisFuture<StreamScanCursor> scan(KeyStreamingChannel<K> channel,
                                          ScanCursor scanCursor)
```
    Description copied from interface: RedisKeyAsyncCommands
    
    Incrementally iterate the keys space.
    
    Specified by:
    
    scan in interface RedisKeyAsyncCommands<K,V>
    
    Specified by:
    
    scan in interface RedisAdvancedClusterAsyncCommands<K,V>
    
    Overrides:
    
    scan in class AbstractRedisAsyncCommands<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:
    
    RedisKeyAsyncCommands.scan(ScanCursor, ScanArgs)
  - ftAggregate
```
public RedisFuture<AggregationReply<K,V>> ftAggregate(String index,
                                                      V query,
                                                      AggregateArgs<K,V> args)
```
    Description copied from interface: RediSearchAsyncCommands
    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 RediSearchAsyncCommands<K,V>
    
    Overrides:
    
    ftAggregate in class AbstractRedisAsyncCommands<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, RediSearchAsyncCommands.ftAggregate(String, Object), #ftCursorread(String, Cursor)
  - ftAggregate
```
public RedisFuture<AggregationReply<K,V>> ftAggregate(String index,
                                                      V query)
```
    Description copied from interface: RediSearchAsyncCommands
    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 RediSearchAsyncCommands.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 RediSearchAsyncCommands.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 RediSearchAsyncCommands<K,V>
    
    Overrides:
    
    ftAggregate in class AbstractRedisAsyncCommands<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, RediSearchAsyncCommands.ftAggregate(String, Object, AggregateArgs)
  - ftSearch
```
public RedisFuture<SearchReply<K,V>> ftSearch(String index,
                                              V query,
                                              SearchArgs<K,V> args)
```
    Description copied from interface: RediSearchAsyncCommands
    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 RediSearchAsyncCommands<K,V>
    
    Overrides:
    
    ftSearch in class AbstractRedisAsyncCommands<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, RediSearchAsyncCommands.ftSearch(String, Object)
  - ftSearch
```
public RedisFuture<SearchReply<K,V>> ftSearch(String index,
                                              V query)
```
    Description copied from interface: RediSearchAsyncCommands
    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 RediSearchAsyncCommands<K,V>
    
    Overrides:
    
    ftSearch in class AbstractRedisAsyncCommands<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, RediSearchAsyncCommands.ftSearch(String, Object, SearchArgs)
  - ftExplain
```
public RedisFuture<String> ftExplain(String index,
                                     V query)
```
    Description copied from interface: RediSearchAsyncCommands
    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 RediSearchAsyncCommands<K,V>
    
    Overrides:
    
    ftExplain in class AbstractRedisAsyncCommands<K,V>
    
    Parameters:
    
    index - the index name
    
    query - the search query to explain
    
    Returns:
    
    the execution plan as a string
    
    See Also:
    
    FT.EXPLAIN, RediSearchAsyncCommands.ftExplain(String, Object, ExplainArgs), RediSearchAsyncCommands.ftSearch(String, Object)
  - ftExplain
```
public RedisFuture<String> ftExplain(String index,
                                     V query,
                                     ExplainArgs<K,V> args)
```
    Description copied from interface: RediSearchAsyncCommands
    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 RediSearchAsyncCommands<K,V>
    
    Overrides:
    
    ftExplain in class AbstractRedisAsyncCommands<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, RediSearchAsyncCommands.ftExplain(String, Object), RediSearchAsyncCommands.ftSearch(String, Object)
  - ftTagvals
```
public RedisFuture<List<V>> ftTagvals(String index,
                                      String fieldName)
```
    Description copied from interface: RediSearchAsyncCommands
    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 RediSearchAsyncCommands<K,V>
    
    Overrides:
    
    ftTagvals in class AbstractRedisAsyncCommands<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, RediSearchAsyncCommands.ftCreate(String, List), RediSearchAsyncCommands.ftCreate(String, CreateArgs, List)
  - ftSpellcheck
```
public RedisFuture<SpellCheckResult<V>> ftSpellcheck(String index,
                                                     V query)
```
    Description copied from interface: RediSearchAsyncCommands
    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 RediSearchAsyncCommands<K,V>
    
    Overrides:
    
    ftSpellcheck in class AbstractRedisAsyncCommands<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, RediSearchAsyncCommands.ftSpellcheck(String, Object, SpellCheckArgs), RediSearchAsyncCommands.ftDictadd(String, Object[]), RediSearchAsyncCommands.ftDictdel(String, Object[]), RediSearchAsyncCommands.ftDictdump(String)
  - ftSpellcheck
```
public RedisFuture<SpellCheckResult<V>> ftSpellcheck(String index,
                                                     V query,
                                                     SpellCheckArgs<K,V> args)
```
    Description copied from interface: RediSearchAsyncCommands
    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 RediSearchAsyncCommands<K,V>
    
    Overrides:
    
    ftSpellcheck in class AbstractRedisAsyncCommands<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, RediSearchAsyncCommands.ftSpellcheck(String, Object), RediSearchAsyncCommands.ftDictadd(String, Object[]), RediSearchAsyncCommands.ftDictdel(String, Object[]), RediSearchAsyncCommands.ftDictdump(String)
  - ftDictadd
```
public RedisFuture<Long> ftDictadd(String dict,
                                   V... terms)
```
    Description copied from interface: RediSearchAsyncCommands
    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 RediSearchAsyncCommands<K,V>
    
    Overrides:
    
    ftDictadd in class AbstractRedisAsyncCommands<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, RediSearchAsyncCommands.ftDictdel(String, Object[]), RediSearchAsyncCommands.ftDictdump(String)
  - ftDictdel
```
public RedisFuture<Long> ftDictdel(String dict,
                                   V... terms)
```
    Description copied from interface: RediSearchAsyncCommands
    
    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 RediSearchAsyncCommands<K,V>
    
    Overrides:
    
    ftDictdel in class AbstractRedisAsyncCommands<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, RediSearchAsyncCommands.ftDictadd(String, Object[]), RediSearchAsyncCommands.ftDictdump(String)
  - ftDictdump
```
public RedisFuture<List<V>> ftDictdump(String dict)
```
    Description copied from interface: RediSearchAsyncCommands
    
    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 RediSearchAsyncCommands<K,V>
    
    Overrides:
    
    ftDictdump in class AbstractRedisAsyncCommands<K,V>
    
    Parameters:
    
    dict - the dictionary name
    
    Returns:
    
    a list of all terms in the dictionary
    
    See Also:
    
    FT.DICTDUMP, RediSearchAsyncCommands.ftDictadd(String, Object[]), RediSearchAsyncCommands.ftDictdel(String, Object[])
  - ftAliasadd
```
public RedisFuture<String> ftAliasadd(String alias,
                                      String index)
```
    Description copied from interface: RediSearchAsyncCommands
    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 RediSearchAsyncCommands.ftAliasupdate(String, String) to reassign an existing alias
    Time complexity: O(1)
    Specified by:
    
    ftAliasadd in interface RediSearchAsyncCommands<K,V>
    
    Overrides:
    
    ftAliasadd in class AbstractRedisAsyncCommands<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, RediSearchAsyncCommands.ftAliasupdate(String, String), RediSearchAsyncCommands.ftAliasdel(String)
  - ftAliasupdate
```
public RedisFuture<String> ftAliasupdate(String alias,
                                         String index)
```
    Description copied from interface: RediSearchAsyncCommands
    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 RediSearchAsyncCommands.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 RediSearchAsyncCommands<K,V>
    
    Overrides:
    
    ftAliasupdate in class AbstractRedisAsyncCommands<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, RediSearchAsyncCommands.ftAliasadd(String, String), RediSearchAsyncCommands.ftAliasdel(String)
  - ftAliasdel
```
public RedisFuture<String> ftAliasdel(String alias)
```
    Description copied from interface: RediSearchAsyncCommands
    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 RediSearchAsyncCommands.ftAliasupdate(String, String) to redirect before deletion
    Time complexity: O(1)
    Specified by:
    
    ftAliasdel in interface RediSearchAsyncCommands<K,V>
    
    Overrides:
    
    ftAliasdel in class AbstractRedisAsyncCommands<K,V>
    
    Parameters:
    
    alias - the alias name to remove
    
    Returns:
    
    "OK" if the alias was successfully removed
    
    See Also:
    
    FT.ALIASDEL, RediSearchAsyncCommands.ftAliasadd(String, String), RediSearchAsyncCommands.ftAliasupdate(String, String)
  - ftList
```
public RedisFuture<List<V>> ftList()
```
    Description copied from interface: RediSearchAsyncCommands
    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 RediSearchAsyncCommands<K,V>
    
    Overrides:
    
    ftList in class AbstractRedisAsyncCommands<K,V>
    
    Returns:
    
    a list of index names
    
    See Also:
    
    FT._LIST, #ftCreate(String, CreateArgs, FieldArgs[]), RediSearchAsyncCommands.ftDropindex(String)
  - ftCreate
```
public RedisFuture<String> ftCreate(String index,
                                    List<FieldArgs<K>> fieldArgs)
```
    Description copied from interface: RediSearchAsyncCommands
    
    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 RediSearchAsyncCommands<K,V>
    
    Overrides:
    
    ftCreate in class AbstractRedisAsyncCommands<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, RediSearchAsyncCommands.ftCreate(String, CreateArgs, List), RediSearchAsyncCommands.ftDropindex(String)
  - ftCreate
```
public RedisFuture<String> ftCreate(String index,
                                    CreateArgs<K,V> arguments,
                                    List<FieldArgs<K>> fieldArgs)
```
    Description copied from interface: RediSearchAsyncCommands
    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 RediSearchAsyncCommands<K,V>
    
    Overrides:
    
    ftCreate in class AbstractRedisAsyncCommands<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, RediSearchAsyncCommands.ftCreate(String, List), RediSearchAsyncCommands.ftDropindex(String)
  - ftAlter
```
public RedisFuture<String> ftAlter(String index,
                                   boolean skipInitialScan,
                                   List<FieldArgs<K>> fieldArgs)
```
    Description copied from interface: RediSearchAsyncCommands
    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 RediSearchAsyncCommands<K,V>
    
    Overrides:
    
    ftAlter in class AbstractRedisAsyncCommands<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, RediSearchAsyncCommands.ftCreate(String, List), RediSearchAsyncCommands.ftCreate(String, CreateArgs, List)
  - ftAlter
```
public RedisFuture<String> ftAlter(String index,
                                   List<FieldArgs<K>> fieldArgs)
```
    Description copied from interface: RediSearchAsyncCommands
    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 RediSearchAsyncCommands<K,V>
    
    Overrides:
    
    ftAlter in class AbstractRedisAsyncCommands<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, RediSearchAsyncCommands.ftCreate(String, List), RediSearchAsyncCommands.ftCreate(String, CreateArgs, List)
  - ftDropindex
```
public RedisFuture<String> ftDropindex(String index,
                                       boolean deleteDocumentKeys)
```
    Description copied from interface: RediSearchAsyncCommands
    
    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 (RediSearchAsyncCommands.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 RediSearchAsyncCommands<K,V>
    
    Overrides:
    
    ftDropindex in class AbstractRedisAsyncCommands<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, RediSearchAsyncCommands.ftDropindex(String), RediSearchAsyncCommands.ftCreate(String, List)
  - ftDropindex
```
public RedisFuture<String> ftDropindex(String index)
```
    Description copied from interface: RediSearchAsyncCommands
    
    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 RediSearchAsyncCommands<K,V>
    
    Overrides:
    
    ftDropindex in class AbstractRedisAsyncCommands<K,V>
    
    Parameters:
    
    index - the index name, as a key
    
    Returns:
    
    "OK" if the index was successfully dropped
    
    See Also:
    
    FT.DROPINDEX, RediSearchAsyncCommands.ftDropindex(String, boolean), RediSearchAsyncCommands.ftCreate(String, List)
  - ftSyndump
```
public RedisFuture<Map<V,List<V>>> ftSyndump(String index)
```
    Description copied from interface: RediSearchAsyncCommands
    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 RediSearchAsyncCommands<K,V>
    
    Overrides:
    
    ftSyndump in class AbstractRedisAsyncCommands<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, RediSearchAsyncCommands.ftSynupdate(String, Object, Object[]), RediSearchAsyncCommands.ftSynupdate(String, Object, SynUpdateArgs, Object[])
  - ftSynupdate
```
public RedisFuture<String> ftSynupdate(String index,
                                       V synonymGroupId,
                                       V... terms)
```
    Description copied from interface: RediSearchAsyncCommands
    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 RediSearchAsyncCommands<K,V>
    
    Overrides:
    
    ftSynupdate in class AbstractRedisAsyncCommands<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, RediSearchAsyncCommands.ftSynupdate(String, Object, SynUpdateArgs, Object[]), RediSearchAsyncCommands.ftSyndump(String)
  - ftSynupdate
```
public RedisFuture<String> ftSynupdate(String index,
                                       V synonymGroupId,
                                       SynUpdateArgs<K,V> args,
                                       V... terms)
```
    Description copied from interface: RediSearchAsyncCommands
    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 RediSearchAsyncCommands<K,V>
    
    Overrides:
    
    ftSynupdate in class AbstractRedisAsyncCommands<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, RediSearchAsyncCommands.ftSynupdate(String, Object, Object[]), RediSearchAsyncCommands.ftSyndump(String)
  - ftCursorread
```
public RedisFuture<AggregationReply<K,V>> ftCursorread(String index,
                                                       AggregationReply.Cursor cursor,
                                                       int count)
```
    Description copied from interface: RediSearchAsyncCommands
    
    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 RediSearchAsyncCommands.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 RediSearchAsyncCommands<K,V>
    
    Overrides:
    
    ftCursorread in class AbstractRedisAsyncCommands<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:
    
    the next batch of results; see AggregationReply
    
    See Also:
    
    FT.CURSOR READ, Cursor API, AggregationReply, RediSearchAsyncCommands.ftAggregate(String, Object, AggregateArgs)
  - ftCursorread
```
public RedisFuture<AggregationReply<K,V>> ftCursorread(String index,
                                                       AggregationReply.Cursor cursor)
```
    Description copied from interface: RediSearchAsyncCommands
    
    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 RediSearchAsyncCommands.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 RediSearchAsyncCommands<K,V>
    
    Overrides:
    
    ftCursorread in class AbstractRedisAsyncCommands<K,V>
    
    Parameters:
    
    index - the index name
    
    cursor - the cursor obtained from a previous FT.AGGREGATE or FT.CURSOR READ command
    
    Returns:
    
    the next batch of results; see AggregationReply
    
    See Also:
    
    FT.CURSOR READ, Cursor API, AggregationReply, RediSearchAsyncCommands.ftAggregate(String, Object, AggregateArgs)
  - ftCursordel
```
public RedisFuture<String> ftCursordel(String index,
                                       AggregationReply.Cursor cursor)
```
    Description copied from interface: RediSearchAsyncCommands
    
    Delete a cursor and free its associated resources.
    This command is used to explicitly delete a cursor created by RediSearchAsyncCommands.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 RediSearchAsyncCommands<K,V>
    
    Overrides:
    
    ftCursordel in class AbstractRedisAsyncCommands<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:
    
    "OK" if the cursor was successfully deleted
    
    See Also:
    
    FT.CURSOR DEL, Cursor API, RediSearchAsyncCommands.ftAggregate(String, Object, AggregateArgs), #ftCursorread(String, Cursor), #ftCursorread(String, Cursor, int)
  - executeOnUpstream
```
protected <T> Map<String,CompletableFuture<T>> executeOnUpstream(Function<RedisClusterAsyncCommands<K,V>,RedisFuture<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,CompletableFuture<T>> executeOnNodes(Function<RedisClusterAsyncCommands<K,V>,RedisFuture<T>> function,
                                                              Function<RedisClusterNode,Boolean> 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 RedisAdvancedClusterAsyncCommandsImpl<K,V>

Constructor Summary

Method Summary

Methods inherited from class io.lettuce.core.AbstractRedisAsyncCommands

Methods inherited from class java.lang.Object

Methods inherited from interface io.lettuce.core.cluster.api.async.RedisAdvancedClusterAsyncCommands

Methods inherited from interface io.lettuce.core.cluster.api.async.RedisClusterAsyncCommands

Methods inherited from interface io.lettuce.core.api.async.BaseRedisAsyncCommands

Methods inherited from interface io.lettuce.core.api.async.RedisAclAsyncCommands

Methods inherited from interface io.lettuce.core.api.async.RedisFunctionAsyncCommands

Methods inherited from interface io.lettuce.core.api.async.RedisGeoAsyncCommands

Methods inherited from interface io.lettuce.core.api.async.RedisHashAsyncCommands

Methods inherited from interface io.lettuce.core.api.async.RedisHLLAsyncCommands

Methods inherited from interface io.lettuce.core.api.async.RedisKeyAsyncCommands

Methods inherited from interface io.lettuce.core.api.async.RedisListAsyncCommands

Methods inherited from interface io.lettuce.core.api.async.RedisScriptingAsyncCommands

Methods inherited from interface io.lettuce.core.api.async.RedisServerAsyncCommands

Methods inherited from interface io.lettuce.core.api.async.RedisSetAsyncCommands

Methods inherited from interface io.lettuce.core.api.async.RedisSortedSetAsyncCommands

Methods inherited from interface io.lettuce.core.api.async.RedisStreamAsyncCommands

Methods inherited from interface io.lettuce.core.api.async.RedisStringAsyncCommands

Methods inherited from interface io.lettuce.core.api.async.RedisJsonAsyncCommands

Methods inherited from interface io.lettuce.core.api.async.RedisVectorSetAsyncCommands

Methods inherited from interface io.lettuce.core.api.async.RediSearchAsyncCommands

Constructor Detail

RedisAdvancedClusterAsyncCommandsImpl

RedisAdvancedClusterAsyncCommandsImpl

RedisAdvancedClusterAsyncCommandsImpl

RedisAdvancedClusterAsyncCommandsImpl

Method Detail

clientSetname

clusterCountKeysInSlot

clusterGetKeysInSlot

dbsize

del

del

exists

exists

flushall

flushall

flushallAsync

flushdb

flushdb

keys

keysLegacy

keys

keysLegacy

jsonMGet

mget

mget

mget

mget

jsonMSet

mset

msetnx

randomkey

scriptFlush

scriptKill

scriptLoad

shutdown

touch

touch

unlink

unlink

getConnection

getConnection

getStatefulConnection

nodes

readonly

nodes

nodes

scan

scan

scan

scan

scan

scan

scan

scan

ftAggregate