Package | Description |
---|---|
io.lettuce.core |
The Redis client package containing
RedisClient for Redis Standalone and Redis Sentinel operations. |
io.lettuce.core.api.async |
Standalone Redis API for asynchronous executed commands.
|
io.lettuce.core.cluster |
Client for Redis Cluster, see
RedisClusterClient . |
io.lettuce.core.cluster.api.async |
Redis Cluster API for asynchronous executed commands.
|
io.lettuce.core.internal |
Contains internal API.
|
io.lettuce.core.protocol |
Redis protocol layer abstraction.
|
io.lettuce.core.pubsub |
Pub/Sub connection classes.
|
io.lettuce.core.pubsub.api.async |
Pub/Sub Redis API for asynchronous executed commands.
|
io.lettuce.core.sentinel |
Redis Sentinel connection classes.
|
io.lettuce.core.sentinel.api.async |
Redis Sentinel API for asynchronous executed commands.
|
Modifier and Type | Method and Description |
---|---|
RedisFuture<Long> |
AbstractRedisAsyncCommands.append(K key,
V value) |
RedisFuture<String> |
AbstractRedisAsyncCommands.asking() |
RedisFuture<String> |
AbstractRedisAsyncCommands.auth(char[] password) |
RedisFuture<String> |
AbstractRedisAsyncCommands.auth(CharSequence password) |
RedisFuture<String> |
AbstractRedisAsyncCommands.auth(String username,
char[] password) |
RedisFuture<String> |
AbstractRedisAsyncCommands.auth(String username,
CharSequence password) |
RedisFuture<String> |
AbstractRedisAsyncCommands.bgrewriteaof() |
RedisFuture<String> |
AbstractRedisAsyncCommands.bgsave() |
RedisFuture<Long> |
AbstractRedisAsyncCommands.bitcount(K key) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.bitcount(K key,
long start,
long end) |
RedisFuture<List<Long>> |
AbstractRedisAsyncCommands.bitfield(K key,
BitFieldArgs bitFieldArgs) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.bitopAnd(K destination,
K... keys) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.bitopNot(K destination,
K source) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.bitopOr(K destination,
K... keys) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.bitopXor(K destination,
K... keys) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.bitpos(K key,
boolean state) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.bitpos(K key,
boolean state,
long start) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.bitpos(K key,
boolean state,
long start,
long end) |
RedisFuture<KeyValue<K,V>> |
AbstractRedisAsyncCommands.blpop(long timeout,
K... keys) |
RedisFuture<KeyValue<K,V>> |
AbstractRedisAsyncCommands.brpop(long timeout,
K... keys) |
RedisFuture<V> |
AbstractRedisAsyncCommands.brpoplpush(long timeout,
K source,
K destination) |
RedisFuture<KeyValue<K,ScoredValue<V>>> |
AbstractRedisAsyncCommands.bzpopmax(long timeout,
K... keys) |
RedisFuture<KeyValue<K,ScoredValue<V>>> |
AbstractRedisAsyncCommands.bzpopmin(long timeout,
K... keys) |
RedisFuture<String> |
AbstractRedisAsyncCommands.clientCaching(boolean enabled) |
RedisFuture<K> |
AbstractRedisAsyncCommands.clientGetname() |
RedisFuture<Long> |
AbstractRedisAsyncCommands.clientGetredir() |
RedisFuture<Long> |
AbstractRedisAsyncCommands.clientId() |
RedisFuture<Long> |
AbstractRedisAsyncCommands.clientKill(KillArgs killArgs) |
RedisFuture<String> |
AbstractRedisAsyncCommands.clientKill(String addr) |
RedisFuture<String> |
AbstractRedisAsyncCommands.clientList() |
RedisFuture<String> |
AbstractRedisAsyncCommands.clientPause(long timeout) |
RedisFuture<String> |
AbstractRedisAsyncCommands.clientSetname(K name) |
RedisFuture<String> |
AbstractRedisAsyncCommands.clientTracking(TrackingArgs args) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.clientUnblock(long id,
UnblockType type) |
RedisFuture<String> |
AbstractRedisAsyncCommands.clusterAddSlots(int... slots) |
RedisFuture<String> |
AbstractRedisAsyncCommands.clusterBumpepoch() |
RedisFuture<Long> |
AbstractRedisAsyncCommands.clusterCountFailureReports(String nodeId) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.clusterCountKeysInSlot(int slot) |
RedisFuture<String> |
AbstractRedisAsyncCommands.clusterDelSlots(int... slots) |
RedisFuture<String> |
AbstractRedisAsyncCommands.clusterFailover(boolean force) |
RedisFuture<String> |
AbstractRedisAsyncCommands.clusterFlushslots() |
RedisFuture<String> |
AbstractRedisAsyncCommands.clusterForget(String nodeId) |
RedisFuture<List<K>> |
AbstractRedisAsyncCommands.clusterGetKeysInSlot(int slot,
int count) |
RedisFuture<String> |
AbstractRedisAsyncCommands.clusterInfo() |
RedisFuture<Long> |
AbstractRedisAsyncCommands.clusterKeyslot(K key) |
RedisFuture<String> |
AbstractRedisAsyncCommands.clusterMeet(String ip,
int port) |
RedisFuture<String> |
AbstractRedisAsyncCommands.clusterMyId() |
RedisFuture<String> |
AbstractRedisAsyncCommands.clusterNodes() |
RedisFuture<String> |
AbstractRedisAsyncCommands.clusterReplicate(String nodeId) |
RedisFuture<String> |
AbstractRedisAsyncCommands.clusterReset(boolean hard) |
RedisFuture<String> |
AbstractRedisAsyncCommands.clusterSaveconfig() |
RedisFuture<String> |
AbstractRedisAsyncCommands.clusterSetConfigEpoch(long configEpoch) |
RedisFuture<String> |
AbstractRedisAsyncCommands.clusterSetSlotImporting(int slot,
String nodeId) |
RedisFuture<String> |
AbstractRedisAsyncCommands.clusterSetSlotMigrating(int slot,
String nodeId) |
RedisFuture<String> |
AbstractRedisAsyncCommands.clusterSetSlotNode(int slot,
String nodeId) |
RedisFuture<String> |
AbstractRedisAsyncCommands.clusterSetSlotStable(int slot) |
RedisFuture<List<String>> |
AbstractRedisAsyncCommands.clusterSlaves(String nodeId) |
RedisFuture<List<Object>> |
AbstractRedisAsyncCommands.clusterSlots() |
RedisFuture<List<Object>> |
AbstractRedisAsyncCommands.command() |
RedisFuture<Long> |
AbstractRedisAsyncCommands.commandCount() |
RedisFuture<List<Object>> |
AbstractRedisAsyncCommands.commandInfo(CommandType... commands) |
RedisFuture<List<Object>> |
AbstractRedisAsyncCommands.commandInfo(String... commands) |
RedisFuture<Map<String,String>> |
AbstractRedisAsyncCommands.configGet(String parameter) |
RedisFuture<String> |
AbstractRedisAsyncCommands.configResetstat() |
RedisFuture<String> |
AbstractRedisAsyncCommands.configRewrite() |
RedisFuture<String> |
AbstractRedisAsyncCommands.configSet(String parameter,
String value) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.dbsize() |
RedisFuture<String> |
AbstractRedisAsyncCommands.debugCrashAndRecover(Long delay) |
RedisFuture<String> |
AbstractRedisAsyncCommands.debugHtstats(int db) |
RedisFuture<String> |
AbstractRedisAsyncCommands.debugObject(K key) |
RedisFuture<String> |
AbstractRedisAsyncCommands.debugReload() |
RedisFuture<String> |
AbstractRedisAsyncCommands.debugRestart(Long delay) |
RedisFuture<String> |
AbstractRedisAsyncCommands.debugSdslen(K key) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.decr(K key) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.decrby(K key,
long amount) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.del(Iterable<K> keys) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.del(K... keys) |
RedisFuture<String> |
AbstractRedisAsyncCommands.discard() |
protected <T> RedisFuture<T> |
AbstractRedisAsyncCommands.dispatch(CommandType type,
CommandOutput<K,V,T> output) |
protected <T> RedisFuture<T> |
AbstractRedisAsyncCommands.dispatch(CommandType type,
CommandOutput<K,V,T> output,
CommandArgs<K,V> args) |
<T> RedisFuture<T> |
AbstractRedisAsyncCommands.dispatch(ProtocolKeyword type,
CommandOutput<K,V,T> output) |
<T> RedisFuture<T> |
AbstractRedisAsyncCommands.dispatch(ProtocolKeyword type,
CommandOutput<K,V,T> output,
CommandArgs<K,V> args) |
RedisFuture<byte[]> |
AbstractRedisAsyncCommands.dump(K key) |
RedisFuture<V> |
AbstractRedisAsyncCommands.echo(V msg) |
<T> RedisFuture<T> |
AbstractRedisAsyncCommands.eval(byte[] script,
ScriptOutputType type,
K... keys) |
<T> RedisFuture<T> |
AbstractRedisAsyncCommands.eval(byte[] script,
ScriptOutputType type,
K[] keys,
V... values) |
<T> RedisFuture<T> |
AbstractRedisAsyncCommands.eval(String script,
ScriptOutputType type,
K... keys) |
<T> RedisFuture<T> |
AbstractRedisAsyncCommands.eval(String script,
ScriptOutputType type,
K[] keys,
V... values) |
<T> RedisFuture<T> |
AbstractRedisAsyncCommands.evalsha(String digest,
ScriptOutputType type,
K... keys) |
<T> RedisFuture<T> |
AbstractRedisAsyncCommands.evalsha(String digest,
ScriptOutputType type,
K[] keys,
V... values) |
RedisFuture<TransactionResult> |
AbstractRedisAsyncCommands.exec() |
RedisFuture<Long> |
AbstractRedisAsyncCommands.exists(Iterable<K> keys) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.exists(K... keys) |
RedisFuture<Boolean> |
AbstractRedisAsyncCommands.expire(K key,
long seconds) |
RedisFuture<Boolean> |
AbstractRedisAsyncCommands.expireat(K key,
Date timestamp) |
RedisFuture<Boolean> |
AbstractRedisAsyncCommands.expireat(K key,
long timestamp) |
RedisFuture<String> |
AbstractRedisAsyncCommands.flushall() |
RedisFuture<String> |
AbstractRedisAsyncCommands.flushallAsync() |
RedisFuture<String> |
AbstractRedisAsyncCommands.flushdb() |
RedisFuture<String> |
AbstractRedisAsyncCommands.flushdbAsync() |
RedisFuture<Long> |
AbstractRedisAsyncCommands.geoadd(K key,
double longitude,
double latitude,
V member) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.geoadd(K key,
Object... lngLatMember) |
RedisFuture<Double> |
AbstractRedisAsyncCommands.geodist(K key,
V from,
V to,
GeoArgs.Unit unit) |
RedisFuture<List<Value<String>>> |
AbstractRedisAsyncCommands.geohash(K key,
V... members) |
RedisFuture<List<GeoCoordinates>> |
AbstractRedisAsyncCommands.geopos(K key,
V... members) |
protected RedisFuture<Set<V>> |
AbstractRedisAsyncCommands.georadius_ro(K key,
double longitude,
double latitude,
double distance,
GeoArgs.Unit unit) |
protected RedisFuture<List<GeoWithin<V>>> |
AbstractRedisAsyncCommands.georadius_ro(K key,
double longitude,
double latitude,
double distance,
GeoArgs.Unit unit,
GeoArgs geoArgs) |
RedisFuture<Set<V>> |
AbstractRedisAsyncCommands.georadius(K key,
double longitude,
double latitude,
double distance,
GeoArgs.Unit unit) |
RedisFuture<List<GeoWithin<V>>> |
AbstractRedisAsyncCommands.georadius(K key,
double longitude,
double latitude,
double distance,
GeoArgs.Unit unit,
GeoArgs geoArgs) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.georadius(K key,
double longitude,
double latitude,
double distance,
GeoArgs.Unit unit,
GeoRadiusStoreArgs<K> geoRadiusStoreArgs) |
protected RedisFuture<Set<V>> |
AbstractRedisAsyncCommands.georadiusbymember_ro(K key,
V member,
double distance,
GeoArgs.Unit unit) |
protected RedisFuture<List<GeoWithin<V>>> |
AbstractRedisAsyncCommands.georadiusbymember_ro(K key,
V member,
double distance,
GeoArgs.Unit unit,
GeoArgs geoArgs) |
RedisFuture<Set<V>> |
AbstractRedisAsyncCommands.georadiusbymember(K key,
V member,
double distance,
GeoArgs.Unit unit) |
RedisFuture<List<GeoWithin<V>>> |
AbstractRedisAsyncCommands.georadiusbymember(K key,
V member,
double distance,
GeoArgs.Unit unit,
GeoArgs geoArgs) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.georadiusbymember(K key,
V member,
double distance,
GeoArgs.Unit unit,
GeoRadiusStoreArgs<K> geoRadiusStoreArgs) |
RedisFuture<V> |
AbstractRedisAsyncCommands.get(K key) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.getbit(K key,
long offset) |
RedisFuture<V> |
AbstractRedisAsyncCommands.getrange(K key,
long start,
long end) |
RedisFuture<V> |
AbstractRedisAsyncCommands.getset(K key,
V value) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.hdel(K key,
K... fields) |
RedisFuture<Boolean> |
AbstractRedisAsyncCommands.hexists(K key,
K field) |
RedisFuture<V> |
AbstractRedisAsyncCommands.hget(K key,
K field) |
RedisFuture<Map<K,V>> |
AbstractRedisAsyncCommands.hgetall(K key) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.hgetall(KeyValueStreamingChannel<K,V> channel,
K key) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.hincrby(K key,
K field,
long amount) |
RedisFuture<Double> |
AbstractRedisAsyncCommands.hincrbyfloat(K key,
K field,
double amount) |
RedisFuture<List<K>> |
AbstractRedisAsyncCommands.hkeys(K key) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.hkeys(KeyStreamingChannel<K> channel,
K key) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.hlen(K key) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.hmget(KeyValueStreamingChannel<K,V> channel,
K key,
K... fields) |
RedisFuture<List<KeyValue<K,V>>> |
AbstractRedisAsyncCommands.hmget(K key,
K... fields) |
RedisFuture<String> |
AbstractRedisAsyncCommands.hmset(K key,
Map<K,V> map) |
RedisFuture<MapScanCursor<K,V>> |
AbstractRedisAsyncCommands.hscan(K key) |
RedisFuture<StreamScanCursor> |
AbstractRedisAsyncCommands.hscan(KeyValueStreamingChannel<K,V> channel,
K key) |
RedisFuture<StreamScanCursor> |
AbstractRedisAsyncCommands.hscan(KeyValueStreamingChannel<K,V> channel,
K key,
ScanArgs scanArgs) |
RedisFuture<StreamScanCursor> |
AbstractRedisAsyncCommands.hscan(KeyValueStreamingChannel<K,V> channel,
K key,
ScanCursor scanCursor) |
RedisFuture<StreamScanCursor> |
AbstractRedisAsyncCommands.hscan(KeyValueStreamingChannel<K,V> channel,
K key,
ScanCursor scanCursor,
ScanArgs scanArgs) |
RedisFuture<MapScanCursor<K,V>> |
AbstractRedisAsyncCommands.hscan(K key,
ScanArgs scanArgs) |
RedisFuture<MapScanCursor<K,V>> |
AbstractRedisAsyncCommands.hscan(K key,
ScanCursor scanCursor) |
RedisFuture<MapScanCursor<K,V>> |
AbstractRedisAsyncCommands.hscan(K key,
ScanCursor scanCursor,
ScanArgs scanArgs) |
RedisFuture<Boolean> |
AbstractRedisAsyncCommands.hset(K key,
K field,
V value) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.hset(K key,
Map<K,V> map) |
RedisFuture<Boolean> |
AbstractRedisAsyncCommands.hsetnx(K key,
K field,
V value) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.hstrlen(K key,
K field) |
RedisFuture<List<V>> |
AbstractRedisAsyncCommands.hvals(K key) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.hvals(ValueStreamingChannel<V> channel,
K key) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.incr(K key) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.incrby(K key,
long amount) |
RedisFuture<Double> |
AbstractRedisAsyncCommands.incrbyfloat(K key,
double amount) |
RedisFuture<String> |
AbstractRedisAsyncCommands.info() |
RedisFuture<String> |
AbstractRedisAsyncCommands.info(String section) |
RedisFuture<List<K>> |
AbstractRedisAsyncCommands.keys(K pattern) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.keys(KeyStreamingChannel<K> channel,
K pattern) |
RedisFuture<Date> |
AbstractRedisAsyncCommands.lastsave() |
RedisFuture<V> |
AbstractRedisAsyncCommands.lindex(K key,
long index) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.linsert(K key,
boolean before,
V pivot,
V value) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.llen(K key) |
RedisFuture<V> |
AbstractRedisAsyncCommands.lpop(K key) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.lpos(K key,
V value) |
RedisFuture<List<Long>> |
AbstractRedisAsyncCommands.lpos(K key,
V value,
int count) |
RedisFuture<List<Long>> |
AbstractRedisAsyncCommands.lpos(K key,
V value,
int count,
LPosArgs args) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.lpos(K key,
V value,
LPosArgs args) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.lpush(K key,
V... values) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.lpushx(K key,
V... values) |
RedisFuture<List<V>> |
AbstractRedisAsyncCommands.lrange(K key,
long start,
long stop) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.lrange(ValueStreamingChannel<V> channel,
K key,
long start,
long stop) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.lrem(K key,
long count,
V value) |
RedisFuture<String> |
AbstractRedisAsyncCommands.lset(K key,
long index,
V value) |
RedisFuture<String> |
AbstractRedisAsyncCommands.ltrim(K key,
long start,
long stop) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.memoryUsage(K key) |
RedisFuture<List<KeyValue<K,V>>> |
AbstractRedisAsyncCommands.mget(Iterable<K> keys) |
RedisFuture<List<KeyValue<K,V>>> |
AbstractRedisAsyncCommands.mget(K... keys) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.mget(KeyValueStreamingChannel<K,V> channel,
Iterable<K> keys) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.mget(KeyValueStreamingChannel<K,V> channel,
K... keys) |
RedisFuture<String> |
AbstractRedisAsyncCommands.migrate(String host,
int port,
int db,
long timeout,
MigrateArgs<K> migrateArgs) |
RedisFuture<String> |
AbstractRedisAsyncCommands.migrate(String host,
int port,
K key,
int db,
long timeout) |
RedisFuture<Boolean> |
AbstractRedisAsyncCommands.move(K key,
int db) |
RedisFuture<String> |
AbstractRedisAsyncCommands.mset(Map<K,V> map) |
RedisFuture<Boolean> |
AbstractRedisAsyncCommands.msetnx(Map<K,V> map) |
RedisFuture<String> |
AbstractRedisAsyncCommands.multi() |
RedisFuture<String> |
AbstractRedisAsyncCommands.objectEncoding(K key) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.objectIdletime(K key) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.objectRefcount(K key) |
RedisFuture<Boolean> |
AbstractRedisAsyncCommands.persist(K key) |
RedisFuture<Boolean> |
AbstractRedisAsyncCommands.pexpire(K key,
long milliseconds) |
RedisFuture<Boolean> |
AbstractRedisAsyncCommands.pexpireat(K key,
Date timestamp) |
RedisFuture<Boolean> |
AbstractRedisAsyncCommands.pexpireat(K key,
long timestamp) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.pfadd(K key,
V... values) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.pfcount(K... keys) |
RedisFuture<String> |
AbstractRedisAsyncCommands.pfmerge(K destkey,
K... sourcekeys) |
RedisFuture<String> |
AbstractRedisAsyncCommands.ping() |
RedisFuture<String> |
AbstractRedisAsyncCommands.psetex(K key,
long milliseconds,
V value) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.pttl(K key) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.publish(K channel,
V message) |
RedisFuture<List<K>> |
AbstractRedisAsyncCommands.pubsubChannels() |
RedisFuture<List<K>> |
AbstractRedisAsyncCommands.pubsubChannels(K channel) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.pubsubNumpat() |
RedisFuture<Map<K,Long>> |
AbstractRedisAsyncCommands.pubsubNumsub(K... channels) |
RedisFuture<String> |
AbstractRedisAsyncCommands.quit() |
RedisFuture<K> |
AbstractRedisAsyncCommands.randomkey() |
RedisFuture<String> |
AbstractRedisAsyncCommands.readOnly() |
RedisFuture<String> |
AbstractRedisAsyncCommands.readWrite() |
RedisFuture<String> |
AbstractRedisAsyncCommands.rename(K key,
K newKey) |
RedisFuture<Boolean> |
AbstractRedisAsyncCommands.renamenx(K key,
K newKey) |
RedisFuture<String> |
AbstractRedisAsyncCommands.restore(K key,
byte[] value,
RestoreArgs args) |
RedisFuture<String> |
AbstractRedisAsyncCommands.restore(K key,
long ttl,
byte[] value) |
RedisFuture<List<Object>> |
AbstractRedisAsyncCommands.role() |
RedisFuture<V> |
AbstractRedisAsyncCommands.rpop(K key) |
RedisFuture<V> |
AbstractRedisAsyncCommands.rpoplpush(K source,
K destination) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.rpush(K key,
V... values) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.rpushx(K key,
V... values) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.sadd(K key,
V... members) |
RedisFuture<String> |
AbstractRedisAsyncCommands.save() |
RedisFuture<KeyScanCursor<K>> |
AbstractRedisAsyncCommands.scan() |
RedisFuture<StreamScanCursor> |
AbstractRedisAsyncCommands.scan(KeyStreamingChannel<K> channel) |
RedisFuture<StreamScanCursor> |
AbstractRedisAsyncCommands.scan(KeyStreamingChannel<K> channel,
ScanArgs scanArgs) |
RedisFuture<StreamScanCursor> |
AbstractRedisAsyncCommands.scan(KeyStreamingChannel<K> channel,
ScanCursor scanCursor) |
RedisFuture<StreamScanCursor> |
AbstractRedisAsyncCommands.scan(KeyStreamingChannel<K> channel,
ScanCursor scanCursor,
ScanArgs scanArgs) |
RedisFuture<KeyScanCursor<K>> |
AbstractRedisAsyncCommands.scan(ScanArgs scanArgs) |
RedisFuture<KeyScanCursor<K>> |
AbstractRedisAsyncCommands.scan(ScanCursor scanCursor) |
RedisFuture<KeyScanCursor<K>> |
AbstractRedisAsyncCommands.scan(ScanCursor scanCursor,
ScanArgs scanArgs) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.scard(K key) |
RedisFuture<List<Boolean>> |
AbstractRedisAsyncCommands.scriptExists(String... digests) |
RedisFuture<String> |
AbstractRedisAsyncCommands.scriptFlush() |
RedisFuture<String> |
AbstractRedisAsyncCommands.scriptKill() |
RedisFuture<String> |
AbstractRedisAsyncCommands.scriptLoad(byte[] script) |
RedisFuture<String> |
AbstractRedisAsyncCommands.scriptLoad(String script) |
RedisFuture<Set<V>> |
AbstractRedisAsyncCommands.sdiff(K... keys) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.sdiff(ValueStreamingChannel<V> channel,
K... keys) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.sdiffstore(K destination,
K... keys) |
RedisFuture<String> |
AbstractRedisAsyncCommands.select(int db) |
RedisFuture<String> |
AbstractRedisAsyncCommands.set(K key,
V value) |
RedisFuture<String> |
AbstractRedisAsyncCommands.set(K key,
V value,
SetArgs setArgs) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.setbit(K key,
long offset,
int value) |
RedisFuture<String> |
AbstractRedisAsyncCommands.setex(K key,
long seconds,
V value) |
RedisFuture<Boolean> |
AbstractRedisAsyncCommands.setnx(K key,
V value) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.setrange(K key,
long offset,
V value) |
RedisFuture<Set<V>> |
AbstractRedisAsyncCommands.sinter(K... keys) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.sinter(ValueStreamingChannel<V> channel,
K... keys) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.sinterstore(K destination,
K... keys) |
RedisFuture<Boolean> |
AbstractRedisAsyncCommands.sismember(K key,
V member) |
RedisFuture<String> |
AbstractRedisAsyncCommands.slaveof(String host,
int port) |
RedisFuture<String> |
AbstractRedisAsyncCommands.slaveofNoOne() |
RedisFuture<List<Object>> |
AbstractRedisAsyncCommands.slowlogGet() |
RedisFuture<List<Object>> |
AbstractRedisAsyncCommands.slowlogGet(int count) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.slowlogLen() |
RedisFuture<String> |
AbstractRedisAsyncCommands.slowlogReset() |
RedisFuture<Set<V>> |
AbstractRedisAsyncCommands.smembers(K key) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.smembers(ValueStreamingChannel<V> channel,
K key) |
RedisFuture<Boolean> |
AbstractRedisAsyncCommands.smove(K source,
K destination,
V member) |
RedisFuture<List<V>> |
AbstractRedisAsyncCommands.sort(K key) |
RedisFuture<List<V>> |
AbstractRedisAsyncCommands.sort(K key,
SortArgs sortArgs) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.sort(ValueStreamingChannel<V> channel,
K key) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.sort(ValueStreamingChannel<V> channel,
K key,
SortArgs sortArgs) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.sortStore(K key,
SortArgs sortArgs,
K destination) |
RedisFuture<V> |
AbstractRedisAsyncCommands.spop(K key) |
RedisFuture<Set<V>> |
AbstractRedisAsyncCommands.spop(K key,
long count) |
RedisFuture<V> |
AbstractRedisAsyncCommands.srandmember(K key) |
RedisFuture<List<V>> |
AbstractRedisAsyncCommands.srandmember(K key,
long count) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.srandmember(ValueStreamingChannel<V> channel,
K key,
long count) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.srem(K key,
V... members) |
RedisFuture<ValueScanCursor<V>> |
AbstractRedisAsyncCommands.sscan(K key) |
RedisFuture<ValueScanCursor<V>> |
AbstractRedisAsyncCommands.sscan(K key,
ScanArgs scanArgs) |
RedisFuture<ValueScanCursor<V>> |
AbstractRedisAsyncCommands.sscan(K key,
ScanCursor scanCursor) |
RedisFuture<ValueScanCursor<V>> |
AbstractRedisAsyncCommands.sscan(K key,
ScanCursor scanCursor,
ScanArgs scanArgs) |
RedisFuture<StreamScanCursor> |
AbstractRedisAsyncCommands.sscan(ValueStreamingChannel<V> channel,
K key) |
RedisFuture<StreamScanCursor> |
AbstractRedisAsyncCommands.sscan(ValueStreamingChannel<V> channel,
K key,
ScanArgs scanArgs) |
RedisFuture<StreamScanCursor> |
AbstractRedisAsyncCommands.sscan(ValueStreamingChannel<V> channel,
K key,
ScanCursor scanCursor) |
RedisFuture<StreamScanCursor> |
AbstractRedisAsyncCommands.sscan(ValueStreamingChannel<V> channel,
K key,
ScanCursor scanCursor,
ScanArgs scanArgs) |
RedisFuture<StringMatchResult> |
AbstractRedisAsyncCommands.stralgoLcs(StrAlgoArgs args) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.strlen(K key) |
RedisFuture<Set<V>> |
AbstractRedisAsyncCommands.sunion(K... keys) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.sunion(ValueStreamingChannel<V> channel,
K... keys) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.sunionstore(K destination,
K... keys) |
RedisFuture<String> |
AbstractRedisAsyncCommands.swapdb(int db1,
int db2) |
RedisFuture<List<V>> |
AbstractRedisAsyncCommands.time() |
RedisFuture<Long> |
AbstractRedisAsyncCommands.touch(Iterable<K> keys) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.touch(K... keys) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.ttl(K key) |
RedisFuture<String> |
AbstractRedisAsyncCommands.type(K key) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.unlink(Iterable<K> keys) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.unlink(K... keys) |
RedisFuture<String> |
AbstractRedisAsyncCommands.unwatch() |
RedisFuture<Long> |
AbstractRedisAsyncCommands.waitForReplication(int replicas,
long timeout) |
RedisFuture<String> |
AbstractRedisAsyncCommands.watch(K... keys) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.xack(K key,
K group,
String... messageIds) |
RedisFuture<String> |
AbstractRedisAsyncCommands.xadd(K key,
Map<K,V> body) |
RedisFuture<String> |
AbstractRedisAsyncCommands.xadd(K key,
Object... keysAndValues) |
RedisFuture<String> |
AbstractRedisAsyncCommands.xadd(K key,
XAddArgs args,
Map<K,V> body) |
RedisFuture<String> |
AbstractRedisAsyncCommands.xadd(K key,
XAddArgs args,
Object... keysAndValues) |
RedisFuture<List<StreamMessage<K,V>>> |
AbstractRedisAsyncCommands.xclaim(K key,
Consumer<K> consumer,
long minIdleTime,
String... messageIds) |
RedisFuture<List<StreamMessage<K,V>>> |
AbstractRedisAsyncCommands.xclaim(K key,
Consumer<K> consumer,
XClaimArgs args,
String... messageIds) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.xdel(K key,
String... messageIds) |
RedisFuture<String> |
AbstractRedisAsyncCommands.xgroupCreate(XReadArgs.StreamOffset<K> offset,
K group) |
RedisFuture<String> |
AbstractRedisAsyncCommands.xgroupCreate(XReadArgs.StreamOffset<K> offset,
K group,
XGroupCreateArgs args) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.xgroupDelconsumer(K key,
Consumer<K> consumer) |
RedisFuture<Boolean> |
AbstractRedisAsyncCommands.xgroupDestroy(K key,
K group) |
RedisFuture<String> |
AbstractRedisAsyncCommands.xgroupSetid(XReadArgs.StreamOffset<K> offset,
K group) |
RedisFuture<List<Object>> |
AbstractRedisAsyncCommands.xinfoConsumers(K key,
K group) |
RedisFuture<List<Object>> |
AbstractRedisAsyncCommands.xinfoGroups(K key) |
RedisFuture<List<Object>> |
AbstractRedisAsyncCommands.xinfoStream(K key) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.xlen(K key) |
RedisFuture<List<PendingMessage>> |
AbstractRedisAsyncCommands.xpending(K key,
Consumer<K> consumer,
Range<String> range,
Limit limit) |
RedisFuture<PendingMessages> |
AbstractRedisAsyncCommands.xpending(K key,
K group) |
RedisFuture<List<PendingMessage>> |
AbstractRedisAsyncCommands.xpending(K key,
K group,
Range<String> range,
Limit limit) |
RedisFuture<List<StreamMessage<K,V>>> |
AbstractRedisAsyncCommands.xrange(K key,
Range<String> range) |
RedisFuture<List<StreamMessage<K,V>>> |
AbstractRedisAsyncCommands.xrange(K key,
Range<String> range,
Limit limit) |
RedisFuture<List<StreamMessage<K,V>>> |
AbstractRedisAsyncCommands.xread(XReadArgs.StreamOffset<K>... streams) |
RedisFuture<List<StreamMessage<K,V>>> |
AbstractRedisAsyncCommands.xread(XReadArgs args,
XReadArgs.StreamOffset<K>... streams) |
RedisFuture<List<StreamMessage<K,V>>> |
AbstractRedisAsyncCommands.xreadgroup(Consumer<K> consumer,
XReadArgs.StreamOffset<K>... streams) |
RedisFuture<List<StreamMessage<K,V>>> |
AbstractRedisAsyncCommands.xreadgroup(Consumer<K> consumer,
XReadArgs args,
XReadArgs.StreamOffset<K>... streams) |
RedisFuture<List<StreamMessage<K,V>>> |
AbstractRedisAsyncCommands.xrevrange(K key,
Range<String> range) |
RedisFuture<List<StreamMessage<K,V>>> |
AbstractRedisAsyncCommands.xrevrange(K key,
Range<String> range,
Limit limit) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.xtrim(K key,
boolean approximateTrimming,
long count) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.xtrim(K key,
long count) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.zadd(K key,
double score,
V member) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.zadd(K key,
Object... scoresAndValues) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.zadd(K key,
ScoredValue<V>... scoredValues) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.zadd(K key,
ZAddArgs zAddArgs,
double score,
V member) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.zadd(K key,
ZAddArgs zAddArgs,
Object... scoresAndValues) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.zadd(K key,
ZAddArgs zAddArgs,
ScoredValue<V>... scoredValues) |
RedisFuture<Double> |
AbstractRedisAsyncCommands.zaddincr(K key,
double score,
V member) |
RedisFuture<Double> |
AbstractRedisAsyncCommands.zaddincr(K key,
ZAddArgs zAddArgs,
double score,
V member) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.zcard(K key) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.zcount(K key,
double min,
double max) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.zcount(K key,
Range<? extends Number> range) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.zcount(K key,
String min,
String max) |
RedisFuture<Double> |
AbstractRedisAsyncCommands.zincrby(K key,
double amount,
V member) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.zinterstore(K destination,
K... keys) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.zinterstore(K destination,
ZStoreArgs storeArgs,
K... keys) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.zlexcount(K key,
Range<? extends V> range) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.zlexcount(K key,
String min,
String max) |
RedisFuture<ScoredValue<V>> |
AbstractRedisAsyncCommands.zpopmax(K key) |
RedisFuture<List<ScoredValue<V>>> |
AbstractRedisAsyncCommands.zpopmax(K key,
long count) |
RedisFuture<ScoredValue<V>> |
AbstractRedisAsyncCommands.zpopmin(K key) |
RedisFuture<List<ScoredValue<V>>> |
AbstractRedisAsyncCommands.zpopmin(K key,
long count) |
RedisFuture<List<V>> |
AbstractRedisAsyncCommands.zrange(K key,
long start,
long stop) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.zrange(ValueStreamingChannel<V> channel,
K key,
long start,
long stop) |
RedisFuture<List<V>> |
AbstractRedisAsyncCommands.zrangebylex(K key,
Range<? extends V> range) |
RedisFuture<List<V>> |
AbstractRedisAsyncCommands.zrangebylex(K key,
Range<? extends V> range,
Limit limit) |
RedisFuture<List<V>> |
AbstractRedisAsyncCommands.zrangebylex(K key,
String min,
String max) |
RedisFuture<List<V>> |
AbstractRedisAsyncCommands.zrangebylex(K key,
String min,
String max,
long offset,
long count) |
RedisFuture<List<V>> |
AbstractRedisAsyncCommands.zrangebyscore(K key,
double min,
double max) |
RedisFuture<List<V>> |
AbstractRedisAsyncCommands.zrangebyscore(K key,
double min,
double max,
long offset,
long count) |
RedisFuture<List<V>> |
AbstractRedisAsyncCommands.zrangebyscore(K key,
Range<? extends Number> range) |
RedisFuture<List<V>> |
AbstractRedisAsyncCommands.zrangebyscore(K key,
Range<? extends Number> range,
Limit limit) |
RedisFuture<List<V>> |
AbstractRedisAsyncCommands.zrangebyscore(K key,
String min,
String max) |
RedisFuture<List<V>> |
AbstractRedisAsyncCommands.zrangebyscore(K key,
String min,
String max,
long offset,
long count) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.zrangebyscore(ValueStreamingChannel<V> channel,
K key,
double min,
double max) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.zrangebyscore(ValueStreamingChannel<V> channel,
K key,
double min,
double max,
long offset,
long count) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.zrangebyscore(ValueStreamingChannel<V> channel,
K key,
Range<? extends Number> range) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.zrangebyscore(ValueStreamingChannel<V> channel,
K key,
Range<? extends Number> range,
Limit limit) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.zrangebyscore(ValueStreamingChannel<V> channel,
K key,
String min,
String max) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.zrangebyscore(ValueStreamingChannel<V> channel,
K key,
String min,
String max,
long offset,
long count) |
RedisFuture<List<ScoredValue<V>>> |
AbstractRedisAsyncCommands.zrangebyscoreWithScores(K key,
double min,
double max) |
RedisFuture<List<ScoredValue<V>>> |
AbstractRedisAsyncCommands.zrangebyscoreWithScores(K key,
double min,
double max,
long offset,
long count) |
RedisFuture<List<ScoredValue<V>>> |
AbstractRedisAsyncCommands.zrangebyscoreWithScores(K key,
Range<? extends Number> range) |
RedisFuture<List<ScoredValue<V>>> |
AbstractRedisAsyncCommands.zrangebyscoreWithScores(K key,
Range<? extends Number> range,
Limit limit) |
RedisFuture<List<ScoredValue<V>>> |
AbstractRedisAsyncCommands.zrangebyscoreWithScores(K key,
String min,
String max) |
RedisFuture<List<ScoredValue<V>>> |
AbstractRedisAsyncCommands.zrangebyscoreWithScores(K key,
String min,
String max,
long offset,
long count) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel,
K key,
double min,
double max) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel,
K key,
double min,
double max,
long offset,
long count) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel,
K key,
Range<? extends Number> range) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel,
K key,
Range<? extends Number> range,
Limit limit) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel,
K key,
String min,
String max) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel,
K key,
String min,
String max,
long offset,
long count) |
RedisFuture<List<ScoredValue<V>>> |
AbstractRedisAsyncCommands.zrangeWithScores(K key,
long start,
long stop) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.zrangeWithScores(ScoredValueStreamingChannel<V> channel,
K key,
long start,
long stop) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.zrank(K key,
V member) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.zrem(K key,
V... members) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.zremrangebylex(K key,
Range<? extends V> range) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.zremrangebylex(K key,
String min,
String max) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.zremrangebyrank(K key,
long start,
long stop) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.zremrangebyscore(K key,
double min,
double max) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.zremrangebyscore(K key,
Range<? extends Number> range) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.zremrangebyscore(K key,
String min,
String max) |
RedisFuture<List<V>> |
AbstractRedisAsyncCommands.zrevrange(K key,
long start,
long stop) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.zrevrange(ValueStreamingChannel<V> channel,
K key,
long start,
long stop) |
RedisFuture<List<V>> |
AbstractRedisAsyncCommands.zrevrangebylex(K key,
Range<? extends V> range) |
RedisFuture<List<V>> |
AbstractRedisAsyncCommands.zrevrangebylex(K key,
Range<? extends V> range,
Limit limit) |
RedisFuture<List<V>> |
AbstractRedisAsyncCommands.zrevrangebyscore(K key,
double max,
double min) |
RedisFuture<List<V>> |
AbstractRedisAsyncCommands.zrevrangebyscore(K key,
double max,
double min,
long offset,
long count) |
RedisFuture<List<V>> |
AbstractRedisAsyncCommands.zrevrangebyscore(K key,
Range<? extends Number> range) |
RedisFuture<List<V>> |
AbstractRedisAsyncCommands.zrevrangebyscore(K key,
Range<? extends Number> range,
Limit limit) |
RedisFuture<List<V>> |
AbstractRedisAsyncCommands.zrevrangebyscore(K key,
String max,
String min) |
RedisFuture<List<V>> |
AbstractRedisAsyncCommands.zrevrangebyscore(K key,
String max,
String min,
long offset,
long count) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.zrevrangebyscore(ValueStreamingChannel<V> channel,
K key,
double max,
double min) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.zrevrangebyscore(ValueStreamingChannel<V> channel,
K key,
double max,
double min,
long offset,
long count) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.zrevrangebyscore(ValueStreamingChannel<V> channel,
K key,
Range<? extends Number> range) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.zrevrangebyscore(ValueStreamingChannel<V> channel,
K key,
Range<? extends Number> range,
Limit limit) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.zrevrangebyscore(ValueStreamingChannel<V> channel,
K key,
String max,
String min) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.zrevrangebyscore(ValueStreamingChannel<V> channel,
K key,
String max,
String min,
long offset,
long count) |
RedisFuture<List<ScoredValue<V>>> |
AbstractRedisAsyncCommands.zrevrangebyscoreWithScores(K key,
double max,
double min) |
RedisFuture<List<ScoredValue<V>>> |
AbstractRedisAsyncCommands.zrevrangebyscoreWithScores(K key,
double max,
double min,
long offset,
long count) |
RedisFuture<List<ScoredValue<V>>> |
AbstractRedisAsyncCommands.zrevrangebyscoreWithScores(K key,
Range<? extends Number> range) |
RedisFuture<List<ScoredValue<V>>> |
AbstractRedisAsyncCommands.zrevrangebyscoreWithScores(K key,
Range<? extends Number> range,
Limit limit) |
RedisFuture<List<ScoredValue<V>>> |
AbstractRedisAsyncCommands.zrevrangebyscoreWithScores(K key,
String max,
String min) |
RedisFuture<List<ScoredValue<V>>> |
AbstractRedisAsyncCommands.zrevrangebyscoreWithScores(K key,
String max,
String min,
long offset,
long count) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel,
K key,
double max,
double min) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel,
K key,
double max,
double min,
long offset,
long count) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel,
K key,
Range<? extends Number> range) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel,
K key,
Range<? extends Number> range,
Limit limit) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel,
K key,
String max,
String min) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel,
K key,
String max,
String min,
long offset,
long count) |
RedisFuture<List<ScoredValue<V>>> |
AbstractRedisAsyncCommands.zrevrangeWithScores(K key,
long start,
long stop) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.zrevrangeWithScores(ScoredValueStreamingChannel<V> channel,
K key,
long start,
long stop) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.zrevrank(K key,
V member) |
RedisFuture<ScoredValueScanCursor<V>> |
AbstractRedisAsyncCommands.zscan(K key) |
RedisFuture<ScoredValueScanCursor<V>> |
AbstractRedisAsyncCommands.zscan(K key,
ScanArgs scanArgs) |
RedisFuture<ScoredValueScanCursor<V>> |
AbstractRedisAsyncCommands.zscan(K key,
ScanCursor scanCursor) |
RedisFuture<ScoredValueScanCursor<V>> |
AbstractRedisAsyncCommands.zscan(K key,
ScanCursor scanCursor,
ScanArgs scanArgs) |
RedisFuture<StreamScanCursor> |
AbstractRedisAsyncCommands.zscan(ScoredValueStreamingChannel<V> channel,
K key) |
RedisFuture<StreamScanCursor> |
AbstractRedisAsyncCommands.zscan(ScoredValueStreamingChannel<V> channel,
K key,
ScanArgs scanArgs) |
RedisFuture<StreamScanCursor> |
AbstractRedisAsyncCommands.zscan(ScoredValueStreamingChannel<V> channel,
K key,
ScanCursor scanCursor) |
RedisFuture<StreamScanCursor> |
AbstractRedisAsyncCommands.zscan(ScoredValueStreamingChannel<V> channel,
K key,
ScanCursor scanCursor,
ScanArgs scanArgs) |
RedisFuture<Double> |
AbstractRedisAsyncCommands.zscore(K key,
V member) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.zunionstore(K destination,
K... keys) |
RedisFuture<Long> |
AbstractRedisAsyncCommands.zunionstore(K destination,
ZStoreArgs storeArgs,
K... keys) |
Modifier and Type | Method and Description |
---|---|
static <T> T |
LettuceFutures.awaitOrCancel(RedisFuture<T> cmd,
long timeout,
TimeUnit unit)
Wait until futures are complete or the supplied timeout is reached.
|
Modifier and Type | Method and Description |
---|---|
RedisFuture<Long> |
RedisStringAsyncCommands.append(K key,
V value)
Append a value to a key.
|
RedisFuture<String> |
RedisAsyncCommands.auth(CharSequence password)
Authenticate to the server.
|
RedisFuture<String> |
RedisAsyncCommands.auth(String username,
CharSequence password)
Authenticate to the server with username and password.
|
RedisFuture<String> |
RedisServerAsyncCommands.bgrewriteaof()
Asynchronously rewrite the append-only file.
|
RedisFuture<String> |
RedisServerAsyncCommands.bgsave()
Asynchronously save the dataset to disk.
|
RedisFuture<Long> |
RedisStringAsyncCommands.bitcount(K key)
Count set bits in a string.
|
RedisFuture<Long> |
RedisStringAsyncCommands.bitcount(K key,
long start,
long end)
Count set bits in a string.
|
RedisFuture<List<Long>> |
RedisStringAsyncCommands.bitfield(K key,
BitFieldArgs bitFieldArgs)
Execute
BITFIELD with its subcommands. |
RedisFuture<Long> |
RedisStringAsyncCommands.bitopAnd(K destination,
K... keys)
Perform bitwise AND between strings.
|
RedisFuture<Long> |
RedisStringAsyncCommands.bitopNot(K destination,
K source)
Perform bitwise NOT between strings.
|
RedisFuture<Long> |
RedisStringAsyncCommands.bitopOr(K destination,
K... keys)
Perform bitwise OR between strings.
|
RedisFuture<Long> |
RedisStringAsyncCommands.bitopXor(K destination,
K... keys)
Perform bitwise XOR between strings.
|
RedisFuture<Long> |
RedisStringAsyncCommands.bitpos(K key,
boolean state)
Find first bit set or clear in a string.
|
RedisFuture<Long> |
RedisStringAsyncCommands.bitpos(K key,
boolean state,
long start)
Find first bit set or clear in a string.
|
RedisFuture<Long> |
RedisStringAsyncCommands.bitpos(K key,
boolean state,
long start,
long end)
Find first bit set or clear in a string.
|
RedisFuture<KeyValue<K,V>> |
RedisListAsyncCommands.blpop(long timeout,
K... keys)
Remove and get the first element in a list, or block until one is available.
|
RedisFuture<KeyValue<K,V>> |
RedisListAsyncCommands.brpop(long timeout,
K... keys)
Remove and get the last element in a list, or block until one is available.
|
RedisFuture<V> |
RedisListAsyncCommands.brpoplpush(long timeout,
K source,
K destination)
Pop a value from a list, push it to another list and return it; or block until one is available.
|
RedisFuture<KeyValue<K,ScoredValue<V>>> |
RedisSortedSetAsyncCommands.bzpopmax(long timeout,
K... keys)
Removes and returns a member with the highest scores in the sorted set stored at one of the keys.
|
RedisFuture<KeyValue<K,ScoredValue<V>>> |
RedisSortedSetAsyncCommands.bzpopmin(long timeout,
K... keys)
Removes and returns a member with the lowest scores in the sorted set stored at one of the keys.
|
RedisFuture<String> |
RedisServerAsyncCommands.clientCaching(boolean enabled)
Control tracking of keys in the context of server-assisted client cache invalidation.
|
RedisFuture<K> |
RedisServerAsyncCommands.clientGetname()
Get the current connection name.
|
RedisFuture<Long> |
RedisServerAsyncCommands.clientGetredir()
Returns the client ID we are redirecting our tracking notifications to
|
RedisFuture<Long> |
RedisServerAsyncCommands.clientId()
Get the id of the current connection.
|
RedisFuture<Long> |
RedisServerAsyncCommands.clientKill(KillArgs killArgs)
Kill connections of clients which are filtered by
killArgs |
RedisFuture<String> |
RedisServerAsyncCommands.clientKill(String addr)
Kill the connection of a client identified by ip:port.
|
RedisFuture<String> |
RedisServerAsyncCommands.clientList()
Get the list of client connections.
|
RedisFuture<String> |
RedisServerAsyncCommands.clientPause(long timeout)
Stop processing commands from clients for some time.
|
RedisFuture<String> |
RedisServerAsyncCommands.clientSetname(K name)
Set the current connection name.
|
RedisFuture<String> |
RedisServerAsyncCommands.clientTracking(TrackingArgs args)
Enables the tracking feature of the Redis server, that is used for server assisted client side caching.
|
RedisFuture<Long> |
RedisServerAsyncCommands.clientUnblock(long id,
UnblockType type)
Unblock the specified blocked client.
|
RedisFuture<List<Object>> |
RedisServerAsyncCommands.command()
Returns an array reply of details about all Redis commands.
|
RedisFuture<Long> |
RedisServerAsyncCommands.commandCount()
Get total number of Redis commands.
|
RedisFuture<List<Object>> |
RedisServerAsyncCommands.commandInfo(CommandType... commands)
Returns an array reply of details about the requested commands.
|
RedisFuture<List<Object>> |
RedisServerAsyncCommands.commandInfo(String... commands)
Returns an array reply of details about the requested commands.
|
RedisFuture<Map<String,String>> |
RedisServerAsyncCommands.configGet(String parameter)
Get the value of a configuration parameter.
|
RedisFuture<String> |
RedisServerAsyncCommands.configResetstat()
Reset the stats returned by INFO.
|
RedisFuture<String> |
RedisServerAsyncCommands.configRewrite()
Rewrite the configuration file with the in memory configuration.
|
RedisFuture<String> |
RedisServerAsyncCommands.configSet(String parameter,
String value)
Set a configuration parameter to the given value.
|
RedisFuture<Long> |
RedisServerAsyncCommands.dbsize()
Return the number of keys in the selected database.
|
RedisFuture<String> |
RedisServerAsyncCommands.debugCrashAndRecover(Long delay)
Crash and recover
|
RedisFuture<String> |
RedisServerAsyncCommands.debugHtstats(int db)
Get debugging information about the internal hash-table state.
|
RedisFuture<String> |
RedisServerAsyncCommands.debugObject(K key)
Get debugging information about a key.
|
RedisFuture<String> |
RedisServerAsyncCommands.debugReload()
Save RDB, clear the database and reload RDB.
|
RedisFuture<String> |
RedisServerAsyncCommands.debugRestart(Long delay)
Restart the server gracefully.
|
RedisFuture<String> |
RedisServerAsyncCommands.debugSdslen(K key)
Get debugging information about the internal SDS length.
|
RedisFuture<Long> |
RedisStringAsyncCommands.decr(K key)
Decrement the integer value of a key by one.
|
RedisFuture<Long> |
RedisStringAsyncCommands.decrby(K key,
long amount)
Decrement the integer value of a key by the given number.
|
RedisFuture<Long> |
RedisKeyAsyncCommands.del(K... keys)
Delete one or more keys.
|
RedisFuture<String> |
RedisTransactionalAsyncCommands.discard()
Discard all commands issued after MULTI.
|
<T> RedisFuture<T> |
BaseRedisAsyncCommands.dispatch(ProtocolKeyword type,
CommandOutput<K,V,T> output)
Dispatch a command to the Redis Server.
|
<T> RedisFuture<T> |
BaseRedisAsyncCommands.dispatch(ProtocolKeyword type,
CommandOutput<K,V,T> output,
CommandArgs<K,V> args)
Dispatch a command to the Redis Server.
|
RedisFuture<byte[]> |
RedisKeyAsyncCommands.dump(K key)
Return a serialized version of the value stored at the specified key.
|
RedisFuture<V> |
BaseRedisAsyncCommands.echo(V msg)
Echo the given string.
|
<T> RedisFuture<T> |
RedisScriptingAsyncCommands.eval(byte[] script,
ScriptOutputType type,
K... keys)
Execute a Lua script server side.
|
<T> RedisFuture<T> |
RedisScriptingAsyncCommands.eval(byte[] script,
ScriptOutputType type,
K[] keys,
V... values)
Execute a Lua script server side.
|
<T> RedisFuture<T> |
RedisScriptingAsyncCommands.eval(String script,
ScriptOutputType type,
K... keys)
Execute a Lua script server side.
|
<T> RedisFuture<T> |
RedisScriptingAsyncCommands.eval(String script,
ScriptOutputType type,
K[] keys,
V... values)
Execute a Lua script server side.
|
<T> RedisFuture<T> |
RedisScriptingAsyncCommands.evalsha(String digest,
ScriptOutputType type,
K... keys)
Evaluates a script cached on the server side by its SHA1 digest
|
<T> RedisFuture<T> |
RedisScriptingAsyncCommands.evalsha(String digest,
ScriptOutputType type,
K[] keys,
V... values)
Execute a Lua script server side.
|
RedisFuture<TransactionResult> |
RedisTransactionalAsyncCommands.exec()
Execute all commands issued after MULTI.
|
RedisFuture<Long> |
RedisKeyAsyncCommands.exists(K... keys)
Determine how many keys exist.
|
RedisFuture<Boolean> |
RedisKeyAsyncCommands.expire(K key,
long seconds)
Set a key's time to live in seconds.
|
RedisFuture<Boolean> |
RedisKeyAsyncCommands.expireat(K key,
Date timestamp)
Set the expiration for a key as a UNIX timestamp.
|
RedisFuture<Boolean> |
RedisKeyAsyncCommands.expireat(K key,
long timestamp)
Set the expiration for a key as a UNIX timestamp.
|
RedisFuture<String> |
RedisServerAsyncCommands.flushall()
Remove all keys from all databases.
|
RedisFuture<String> |
RedisServerAsyncCommands.flushallAsync()
Remove all keys asynchronously from all databases.
|
RedisFuture<String> |
RedisServerAsyncCommands.flushdb()
Remove all keys from the current database.
|
RedisFuture<String> |
RedisServerAsyncCommands.flushdbAsync()
Remove all keys asynchronously from the current database.
|
RedisFuture<Long> |
RedisGeoAsyncCommands.geoadd(K key,
double longitude,
double latitude,
V member)
Single geo add.
|
RedisFuture<Long> |
RedisGeoAsyncCommands.geoadd(K key,
Object... lngLatMember)
Multi geo add.
|
RedisFuture<Double> |
RedisGeoAsyncCommands.geodist(K key,
V from,
V to,
GeoArgs.Unit unit)
Retrieve distance between points
from and to . |
RedisFuture<List<Value<String>>> |
RedisGeoAsyncCommands.geohash(K key,
V... members)
Retrieve Geohash strings representing the position of one or more elements in a sorted set value representing a
geospatial index.
|
RedisFuture<List<GeoCoordinates>> |
RedisGeoAsyncCommands.geopos(K key,
V... members)
Get geo coordinates for the
members . |
RedisFuture<Set<V>> |
RedisGeoAsyncCommands.georadius(K key,
double longitude,
double latitude,
double distance,
GeoArgs.Unit unit)
Retrieve members selected by distance with the center of
longitude and latitude . |
RedisFuture<List<GeoWithin<V>>> |
RedisGeoAsyncCommands.georadius(K key,
double longitude,
double latitude,
double distance,
GeoArgs.Unit unit,
GeoArgs geoArgs)
Retrieve members selected by distance with the center of
longitude and latitude . |
RedisFuture<Long> |
RedisGeoAsyncCommands.georadius(K key,
double longitude,
double latitude,
double distance,
GeoArgs.Unit unit,
GeoRadiusStoreArgs<K> geoRadiusStoreArgs)
Perform a
RedisGeoAsyncCommands.georadius(Object, double, double, double, GeoArgs.Unit, GeoArgs) query and store the results in a
sorted set. |
RedisFuture<Set<V>> |
RedisGeoAsyncCommands.georadiusbymember(K key,
V member,
double distance,
GeoArgs.Unit unit)
Retrieve members selected by distance with the center of
member . |
RedisFuture<List<GeoWithin<V>>> |
RedisGeoAsyncCommands.georadiusbymember(K key,
V member,
double distance,
GeoArgs.Unit unit,
GeoArgs geoArgs)
Retrieve members selected by distance with the center of
member . |
RedisFuture<Long> |
RedisGeoAsyncCommands.georadiusbymember(K key,
V member,
double distance,
GeoArgs.Unit unit,
GeoRadiusStoreArgs<K> geoRadiusStoreArgs)
Perform a
RedisGeoAsyncCommands.georadiusbymember(Object, Object, double, GeoArgs.Unit, GeoArgs) query and store the results in a
sorted set. |
RedisFuture<V> |
RedisStringAsyncCommands.get(K key)
Get the value of a key.
|
RedisFuture<Long> |
RedisStringAsyncCommands.getbit(K key,
long offset)
Returns the bit value at offset in the string value stored at key.
|
RedisFuture<V> |
RedisStringAsyncCommands.getrange(K key,
long start,
long end)
Get a substring of the string stored at a key.
|
RedisFuture<V> |
RedisStringAsyncCommands.getset(K key,
V value)
Set the string value of a key and return its old value.
|
RedisFuture<Long> |
RedisHashAsyncCommands.hdel(K key,
K... fields)
Delete one or more hash fields.
|
RedisFuture<Boolean> |
RedisHashAsyncCommands.hexists(K key,
K field)
Determine if a hash field exists.
|
RedisFuture<V> |
RedisHashAsyncCommands.hget(K key,
K field)
Get the value of a hash field.
|
RedisFuture<Map<K,V>> |
RedisHashAsyncCommands.hgetall(K key)
Get all the fields and values in a hash.
|
RedisFuture<Long> |
RedisHashAsyncCommands.hgetall(KeyValueStreamingChannel<K,V> channel,
K key)
Stream over all the fields and values in a hash.
|
RedisFuture<Long> |
RedisHashAsyncCommands.hincrby(K key,
K field,
long amount)
Increment the integer value of a hash field by the given number.
|
RedisFuture<Double> |
RedisHashAsyncCommands.hincrbyfloat(K key,
K field,
double amount)
Increment the float value of a hash field by the given amount.
|
RedisFuture<List<K>> |
RedisHashAsyncCommands.hkeys(K key)
Get all the fields in a hash.
|
RedisFuture<Long> |
RedisHashAsyncCommands.hkeys(KeyStreamingChannel<K> channel,
K key)
Stream over all the fields in a hash.
|
RedisFuture<Long> |
RedisHashAsyncCommands.hlen(K key)
Get the number of fields in a hash.
|
RedisFuture<Long> |
RedisHashAsyncCommands.hmget(KeyValueStreamingChannel<K,V> channel,
K key,
K... fields)
Stream over the values of all the given hash fields.
|
RedisFuture<List<KeyValue<K,V>>> |
RedisHashAsyncCommands.hmget(K key,
K... fields)
Get the values of all the given hash fields.
|
RedisFuture<String> |
RedisHashAsyncCommands.hmset(K key,
Map<K,V> map)
Set multiple hash fields to multiple values.
|
RedisFuture<MapScanCursor<K,V>> |
RedisHashAsyncCommands.hscan(K key)
Incrementally iterate hash fields and associated values.
|
RedisFuture<StreamScanCursor> |
RedisHashAsyncCommands.hscan(KeyValueStreamingChannel<K,V> channel,
K key)
Incrementally iterate hash fields and associated values.
|
RedisFuture<StreamScanCursor> |
RedisHashAsyncCommands.hscan(KeyValueStreamingChannel<K,V> channel,
K key,
ScanArgs scanArgs)
Incrementally iterate hash fields and associated values.
|
RedisFuture<StreamScanCursor> |
RedisHashAsyncCommands.hscan(KeyValueStreamingChannel<K,V> channel,
K key,
ScanCursor scanCursor)
Incrementally iterate hash fields and associated values.
|
RedisFuture<StreamScanCursor> |
RedisHashAsyncCommands.hscan(KeyValueStreamingChannel<K,V> channel,
K key,
ScanCursor scanCursor,
ScanArgs scanArgs)
Incrementally iterate hash fields and associated values.
|
RedisFuture<MapScanCursor<K,V>> |
RedisHashAsyncCommands.hscan(K key,
ScanArgs scanArgs)
Incrementally iterate hash fields and associated values.
|
RedisFuture<MapScanCursor<K,V>> |
RedisHashAsyncCommands.hscan(K key,
ScanCursor scanCursor)
Incrementally iterate hash fields and associated values.
|
RedisFuture<MapScanCursor<K,V>> |
RedisHashAsyncCommands.hscan(K key,
ScanCursor scanCursor,
ScanArgs scanArgs)
Incrementally iterate hash fields and associated values.
|
RedisFuture<Boolean> |
RedisHashAsyncCommands.hset(K key,
K field,
V value)
Set the string value of a hash field.
|
RedisFuture<Long> |
RedisHashAsyncCommands.hset(K key,
Map<K,V> map)
Set multiple hash fields to multiple values.
|
RedisFuture<Boolean> |
RedisHashAsyncCommands.hsetnx(K key,
K field,
V value)
Set the value of a hash field, only if the field does not exist.
|
RedisFuture<Long> |
RedisHashAsyncCommands.hstrlen(K key,
K field)
Get the string length of the field value in a hash.
|
RedisFuture<List<V>> |
RedisHashAsyncCommands.hvals(K key)
Get all the values in a hash.
|
RedisFuture<Long> |
RedisHashAsyncCommands.hvals(ValueStreamingChannel<V> channel,
K key)
Stream over all the values in a hash.
|
RedisFuture<Long> |
RedisStringAsyncCommands.incr(K key)
Increment the integer value of a key by one.
|
RedisFuture<Long> |
RedisStringAsyncCommands.incrby(K key,
long amount)
Increment the integer value of a key by the given amount.
|
RedisFuture<Double> |
RedisStringAsyncCommands.incrbyfloat(K key,
double amount)
Increment the float value of a key by the given amount.
|
RedisFuture<String> |
RedisServerAsyncCommands.info()
Get information and statistics about the server.
|
RedisFuture<String> |
RedisServerAsyncCommands.info(String section)
Get information and statistics about the server.
|
RedisFuture<List<K>> |
RedisKeyAsyncCommands.keys(K pattern)
Find all keys matching the given pattern.
|
RedisFuture<Long> |
RedisKeyAsyncCommands.keys(KeyStreamingChannel<K> channel,
K pattern)
Find all keys matching the given pattern.
|
RedisFuture<Date> |
RedisServerAsyncCommands.lastsave()
Get the UNIX time stamp of the last successful save to disk.
|
RedisFuture<V> |
RedisListAsyncCommands.lindex(K key,
long index)
Get an element from a list by its index.
|
RedisFuture<Long> |
RedisListAsyncCommands.linsert(K key,
boolean before,
V pivot,
V value)
Insert an element before or after another element in a list.
|
RedisFuture<Long> |
RedisListAsyncCommands.llen(K key)
Get the length of a list.
|
RedisFuture<V> |
RedisListAsyncCommands.lpop(K key)
Remove and get the first element in a list.
|
RedisFuture<Long> |
RedisListAsyncCommands.lpos(K key,
V value)
Return the index of matching elements inside a Redis list.
|
RedisFuture<List<Long>> |
RedisListAsyncCommands.lpos(K key,
V value,
int count)
Return the index of matching elements inside a Redis list using the
COUNT option. |
RedisFuture<List<Long>> |
RedisListAsyncCommands.lpos(K key,
V value,
int count,
LPosArgs args)
Return the index of matching elements inside a Redis list using the
COUNT option. |
RedisFuture<Long> |
RedisListAsyncCommands.lpos(K key,
V value,
LPosArgs args)
Return the index of matching elements inside a Redis list.
|
RedisFuture<Long> |
RedisListAsyncCommands.lpush(K key,
V... values)
Prepend one or multiple values to a list.
|
RedisFuture<Long> |
RedisListAsyncCommands.lpushx(K key,
V... values)
Prepend values to a list, only if the list exists.
|
RedisFuture<List<V>> |
RedisListAsyncCommands.lrange(K key,
long start,
long stop)
Get a range of elements from a list.
|
RedisFuture<Long> |
RedisListAsyncCommands.lrange(ValueStreamingChannel<V> channel,
K key,
long start,
long stop)
Get a range of elements from a list.
|
RedisFuture<Long> |
RedisListAsyncCommands.lrem(K key,
long count,
V value)
Remove elements from a list.
|
RedisFuture<String> |
RedisListAsyncCommands.lset(K key,
long index,
V value)
Set the value of an element in a list by its index.
|
RedisFuture<String> |
RedisListAsyncCommands.ltrim(K key,
long start,
long stop)
Trim a list to the specified range.
|
RedisFuture<Long> |
RedisServerAsyncCommands.memoryUsage(K key)
Reports the number of bytes that a key and its value require to be stored in RAM.
|
RedisFuture<List<KeyValue<K,V>>> |
RedisStringAsyncCommands.mget(K... keys)
Get the values of all the given keys.
|
RedisFuture<Long> |
RedisStringAsyncCommands.mget(KeyValueStreamingChannel<K,V> channel,
K... keys)
Stream over the values of all the given keys.
|
RedisFuture<String> |
RedisKeyAsyncCommands.migrate(String host,
int port,
int db,
long timeout,
MigrateArgs<K> migrateArgs)
Atomically transfer one or more keys from a Redis instance to another one.
|
RedisFuture<String> |
RedisKeyAsyncCommands.migrate(String host,
int port,
K key,
int db,
long timeout)
Atomically transfer a key from a Redis instance to another one.
|
RedisFuture<Boolean> |
RedisKeyAsyncCommands.move(K key,
int db)
Move a key to another database.
|
RedisFuture<String> |
RedisStringAsyncCommands.mset(Map<K,V> map)
Set multiple keys to multiple values.
|
RedisFuture<Boolean> |
RedisStringAsyncCommands.msetnx(Map<K,V> map)
Set multiple keys to multiple values, only if none of the keys exist.
|
RedisFuture<String> |
RedisTransactionalAsyncCommands.multi()
Mark the start of a transaction block.
|
RedisFuture<String> |
RedisKeyAsyncCommands.objectEncoding(K key)
returns the kind of internal representation used in order to store the value associated with a key.
|
RedisFuture<Long> |
RedisKeyAsyncCommands.objectIdletime(K key)
returns the number of seconds since the object stored at the specified key is idle (not requested by read or write
operations).
|
RedisFuture<Long> |
RedisKeyAsyncCommands.objectRefcount(K key)
returns the number of references of the value associated with the specified key.
|
RedisFuture<Boolean> |
RedisKeyAsyncCommands.persist(K key)
Remove the expiration from a key.
|
RedisFuture<Boolean> |
RedisKeyAsyncCommands.pexpire(K key,
long milliseconds)
Set a key's time to live in milliseconds.
|
RedisFuture<Boolean> |
RedisKeyAsyncCommands.pexpireat(K key,
Date timestamp)
Set the expiration for a key as a UNIX timestamp specified in milliseconds.
|
RedisFuture<Boolean> |
RedisKeyAsyncCommands.pexpireat(K key,
long timestamp)
Set the expiration for a key as a UNIX timestamp specified in milliseconds.
|
RedisFuture<Long> |
RedisHLLAsyncCommands.pfadd(K key,
V... values)
Adds the specified elements to the specified HyperLogLog.
|
RedisFuture<Long> |
RedisHLLAsyncCommands.pfcount(K... keys)
Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).
|
RedisFuture<String> |
RedisHLLAsyncCommands.pfmerge(K destkey,
K... sourcekeys)
Merge N different HyperLogLogs into a single one.
|
RedisFuture<String> |
BaseRedisAsyncCommands.ping()
Ping the server.
|
RedisFuture<String> |
RedisStringAsyncCommands.psetex(K key,
long milliseconds,
V value)
Set the value and expiration in milliseconds of a key.
|
RedisFuture<Long> |
RedisKeyAsyncCommands.pttl(K key)
Get the time to live for a key in milliseconds.
|
RedisFuture<Long> |
BaseRedisAsyncCommands.publish(K channel,
V message)
Post a message to a channel.
|
RedisFuture<List<K>> |
BaseRedisAsyncCommands.pubsubChannels()
Lists the currently *active channels*.
|
RedisFuture<List<K>> |
BaseRedisAsyncCommands.pubsubChannels(K channel)
Lists the currently *active channels*.
|
RedisFuture<Long> |
BaseRedisAsyncCommands.pubsubNumpat()
Returns the number of subscriptions to patterns.
|
RedisFuture<Map<K,Long>> |
BaseRedisAsyncCommands.pubsubNumsub(K... channels)
Returns the number of subscribers (not counting clients subscribed to patterns) for the specified channels.
|
RedisFuture<String> |
BaseRedisAsyncCommands.quit()
Instructs Redis to disconnect the connection.
|
RedisFuture<K> |
RedisKeyAsyncCommands.randomkey()
Return a random key from the keyspace.
|
RedisFuture<String> |
BaseRedisAsyncCommands.readOnly()
Switch connection to Read-Only mode when connecting to a cluster.
|
RedisFuture<String> |
BaseRedisAsyncCommands.readWrite()
Switch connection to Read-Write mode (default) when connecting to a cluster.
|
RedisFuture<String> |
RedisKeyAsyncCommands.rename(K key,
K newKey)
Rename a key.
|
RedisFuture<Boolean> |
RedisKeyAsyncCommands.renamenx(K key,
K newKey)
Rename a key, only if the new key does not exist.
|
RedisFuture<String> |
RedisKeyAsyncCommands.restore(K key,
byte[] value,
RestoreArgs args)
Create a key using the provided serialized value, previously obtained using DUMP.
|
RedisFuture<String> |
RedisKeyAsyncCommands.restore(K key,
long ttl,
byte[] value)
Create a key using the provided serialized value, previously obtained using DUMP.
|
RedisFuture<List<Object>> |
BaseRedisAsyncCommands.role()
Return the role of the instance in the context of replication.
|
RedisFuture<V> |
RedisListAsyncCommands.rpop(K key)
Remove and get the last element in a list.
|
RedisFuture<V> |
RedisListAsyncCommands.rpoplpush(K source,
K destination)
Remove the last element in a list, append it to another list and return it.
|
RedisFuture<Long> |
RedisListAsyncCommands.rpush(K key,
V... values)
Append one or multiple values to a list.
|
RedisFuture<Long> |
RedisListAsyncCommands.rpushx(K key,
V... values)
Append values to a list, only if the list exists.
|
RedisFuture<Long> |
RedisSetAsyncCommands.sadd(K key,
V... members)
Add one or more members to a set.
|
RedisFuture<String> |
RedisServerAsyncCommands.save()
Synchronously save the dataset to disk.
|
RedisFuture<KeyScanCursor<K>> |
RedisKeyAsyncCommands.scan()
Incrementally iterate the keys space.
|
RedisFuture<StreamScanCursor> |
RedisKeyAsyncCommands.scan(KeyStreamingChannel<K> channel)
Incrementally iterate the keys space.
|
RedisFuture<StreamScanCursor> |
RedisKeyAsyncCommands.scan(KeyStreamingChannel<K> channel,
ScanArgs scanArgs)
Incrementally iterate the keys space.
|
RedisFuture<StreamScanCursor> |
RedisKeyAsyncCommands.scan(KeyStreamingChannel<K> channel,
ScanCursor scanCursor)
Incrementally iterate the keys space.
|
RedisFuture<StreamScanCursor> |
RedisKeyAsyncCommands.scan(KeyStreamingChannel<K> channel,
ScanCursor scanCursor,
ScanArgs scanArgs)
Incrementally iterate the keys space.
|
RedisFuture<KeyScanCursor<K>> |
RedisKeyAsyncCommands.scan(ScanArgs scanArgs)
Incrementally iterate the keys space.
|
RedisFuture<KeyScanCursor<K>> |
RedisKeyAsyncCommands.scan(ScanCursor scanCursor)
Incrementally iterate the keys space.
|
RedisFuture<KeyScanCursor<K>> |
RedisKeyAsyncCommands.scan(ScanCursor scanCursor,
ScanArgs scanArgs)
Incrementally iterate the keys space.
|
RedisFuture<Long> |
RedisSetAsyncCommands.scard(K key)
Get the number of members in a set.
|
RedisFuture<List<Boolean>> |
RedisScriptingAsyncCommands.scriptExists(String... digests)
Check existence of scripts in the script cache.
|
RedisFuture<String> |
RedisScriptingAsyncCommands.scriptFlush()
Remove all the scripts from the script cache.
|
RedisFuture<String> |
RedisScriptingAsyncCommands.scriptKill()
Kill the script currently in execution.
|
RedisFuture<String> |
RedisScriptingAsyncCommands.scriptLoad(byte[] script)
Load the specified Lua script into the script cache.
|
RedisFuture<String> |
RedisScriptingAsyncCommands.scriptLoad(String script)
Load the specified Lua script into the script cache.
|
RedisFuture<Set<V>> |
RedisSetAsyncCommands.sdiff(K... keys)
Subtract multiple sets.
|
RedisFuture<Long> |
RedisSetAsyncCommands.sdiff(ValueStreamingChannel<V> channel,
K... keys)
Subtract multiple sets.
|
RedisFuture<Long> |
RedisSetAsyncCommands.sdiffstore(K destination,
K... keys)
Subtract multiple sets and store the resulting set in a key.
|
RedisFuture<String> |
RedisAsyncCommands.select(int db)
Change the selected database for the current connection.
|
RedisFuture<String> |
RedisStringAsyncCommands.set(K key,
V value)
Set the string value of a key.
|
RedisFuture<String> |
RedisStringAsyncCommands.set(K key,
V value,
SetArgs setArgs)
Set the string value of a key.
|
RedisFuture<Long> |
RedisStringAsyncCommands.setbit(K key,
long offset,
int value)
Sets or clears the bit at offset in the string value stored at key.
|
RedisFuture<String> |
RedisStringAsyncCommands.setex(K key,
long seconds,
V value)
Set the value and expiration of a key.
|
RedisFuture<Boolean> |
RedisStringAsyncCommands.setnx(K key,
V value)
Set the value of a key, only if the key does not exist.
|
RedisFuture<Long> |
RedisStringAsyncCommands.setrange(K key,
long offset,
V value)
Overwrite part of a string at key starting at the specified offset.
|
RedisFuture<Set<V>> |
RedisSetAsyncCommands.sinter(K... keys)
Intersect multiple sets.
|
RedisFuture<Long> |
RedisSetAsyncCommands.sinter(ValueStreamingChannel<V> channel,
K... keys)
Intersect multiple sets.
|
RedisFuture<Long> |
RedisSetAsyncCommands.sinterstore(K destination,
K... keys)
Intersect multiple sets and store the resulting set in a key.
|
RedisFuture<Boolean> |
RedisSetAsyncCommands.sismember(K key,
V member)
Determine if a given value is a member of a set.
|
RedisFuture<String> |
RedisServerAsyncCommands.slaveof(String host,
int port)
Make the server a replica of another instance, or promote it as master.
|
RedisFuture<String> |
RedisServerAsyncCommands.slaveofNoOne()
Promote server as master.
|
RedisFuture<List<Object>> |
RedisServerAsyncCommands.slowlogGet()
Read the slow log.
|
RedisFuture<List<Object>> |
RedisServerAsyncCommands.slowlogGet(int count)
Read the slow log.
|
RedisFuture<Long> |
RedisServerAsyncCommands.slowlogLen()
Obtaining the current length of the slow log.
|
RedisFuture<String> |
RedisServerAsyncCommands.slowlogReset()
Resetting the slow log.
|
RedisFuture<Set<V>> |
RedisSetAsyncCommands.smembers(K key)
Get all the members in a set.
|
RedisFuture<Long> |
RedisSetAsyncCommands.smembers(ValueStreamingChannel<V> channel,
K key)
Get all the members in a set.
|
RedisFuture<Boolean> |
RedisSetAsyncCommands.smove(K source,
K destination,
V member)
Move a member from one set to another.
|
RedisFuture<List<V>> |
RedisKeyAsyncCommands.sort(K key)
Sort the elements in a list, set or sorted set.
|
RedisFuture<List<V>> |
RedisKeyAsyncCommands.sort(K key,
SortArgs sortArgs)
Sort the elements in a list, set or sorted set.
|
RedisFuture<Long> |
RedisKeyAsyncCommands.sort(ValueStreamingChannel<V> channel,
K key)
Sort the elements in a list, set or sorted set.
|
RedisFuture<Long> |
RedisKeyAsyncCommands.sort(ValueStreamingChannel<V> channel,
K key,
SortArgs sortArgs)
Sort the elements in a list, set or sorted set.
|
RedisFuture<Long> |
RedisKeyAsyncCommands.sortStore(K key,
SortArgs sortArgs,
K destination)
Sort the elements in a list, set or sorted set.
|
RedisFuture<V> |
RedisSetAsyncCommands.spop(K key)
Remove and return a random member from a set.
|
RedisFuture<Set<V>> |
RedisSetAsyncCommands.spop(K key,
long count)
Remove and return one or multiple random members from a set.
|
RedisFuture<V> |
RedisSetAsyncCommands.srandmember(K key)
Get one random member from a set.
|
RedisFuture<List<V>> |
RedisSetAsyncCommands.srandmember(K key,
long count)
Get one or multiple random members from a set.
|
RedisFuture<Long> |
RedisSetAsyncCommands.srandmember(ValueStreamingChannel<V> channel,
K key,
long count)
Get one or multiple random members from a set.
|
RedisFuture<Long> |
RedisSetAsyncCommands.srem(K key,
V... members)
Remove one or more members from a set.
|
RedisFuture<ValueScanCursor<V>> |
RedisSetAsyncCommands.sscan(K key)
Incrementally iterate Set elements.
|
RedisFuture<ValueScanCursor<V>> |
RedisSetAsyncCommands.sscan(K key,
ScanArgs scanArgs)
Incrementally iterate Set elements.
|
RedisFuture<ValueScanCursor<V>> |
RedisSetAsyncCommands.sscan(K key,
ScanCursor scanCursor)
Incrementally iterate Set elements.
|
RedisFuture<ValueScanCursor<V>> |
RedisSetAsyncCommands.sscan(K key,
ScanCursor scanCursor,
ScanArgs scanArgs)
Incrementally iterate Set elements.
|
RedisFuture<StreamScanCursor> |
RedisSetAsyncCommands.sscan(ValueStreamingChannel<V> channel,
K key)
Incrementally iterate Set elements.
|
RedisFuture<StreamScanCursor> |
RedisSetAsyncCommands.sscan(ValueStreamingChannel<V> channel,
K key,
ScanArgs scanArgs)
Incrementally iterate Set elements.
|
RedisFuture<StreamScanCursor> |
RedisSetAsyncCommands.sscan(ValueStreamingChannel<V> channel,
K key,
ScanCursor scanCursor)
Incrementally iterate Set elements.
|
RedisFuture<StreamScanCursor> |
RedisSetAsyncCommands.sscan(ValueStreamingChannel<V> channel,
K key,
ScanCursor scanCursor,
ScanArgs scanArgs)
Incrementally iterate Set elements.
|
RedisFuture<StringMatchResult> |
RedisStringAsyncCommands.stralgoLcs(StrAlgoArgs strAlgoArgs)
The STRALGO command implements complex algorithms that operate on strings.
|
RedisFuture<Long> |
RedisStringAsyncCommands.strlen(K key)
Get the length of the value stored in a key.
|
RedisFuture<Set<V>> |
RedisSetAsyncCommands.sunion(K... keys)
Add multiple sets.
|
RedisFuture<Long> |
RedisSetAsyncCommands.sunion(ValueStreamingChannel<V> channel,
K... keys)
Add multiple sets.
|
RedisFuture<Long> |
RedisSetAsyncCommands.sunionstore(K destination,
K... keys)
Add multiple sets and store the resulting set in a key.
|
RedisFuture<String> |
RedisAsyncCommands.swapdb(int db1,
int db2)
Swap two Redis databases, so that immediately all the clients connected to a given DB will see the data of the other DB,
and the other way around
|
RedisFuture<List<V>> |
RedisServerAsyncCommands.time()
Return the current server time.
|
RedisFuture<Long> |
RedisKeyAsyncCommands.touch(K... keys)
Touch one or more keys.
|
RedisFuture<Long> |
RedisKeyAsyncCommands.ttl(K key)
Get the time to live for a key.
|
RedisFuture<String> |
RedisKeyAsyncCommands.type(K key)
Determine the type stored at key.
|
RedisFuture<Long> |
RedisKeyAsyncCommands.unlink(K... keys)
Unlink one or more keys (non blocking DEL).
|
RedisFuture<String> |
RedisTransactionalAsyncCommands.unwatch()
Forget about all watched keys.
|
RedisFuture<Long> |
BaseRedisAsyncCommands.waitForReplication(int replicas,
long timeout)
Wait for replication.
|
RedisFuture<String> |
RedisTransactionalAsyncCommands.watch(K... keys)
Watch the given keys to determine execution of the MULTI/EXEC block.
|
RedisFuture<Long> |
RedisStreamAsyncCommands.xack(K key,
K group,
String... messageIds)
Acknowledge one or more messages as processed.
|
RedisFuture<String> |
RedisStreamAsyncCommands.xadd(K key,
Map<K,V> body)
Append a message to the stream
key . |
RedisFuture<String> |
RedisStreamAsyncCommands.xadd(K key,
Object... keysAndValues)
Append a message to the stream
key . |
RedisFuture<String> |
RedisStreamAsyncCommands.xadd(K key,
XAddArgs args,
Map<K,V> body)
Append a message to the stream
key . |
RedisFuture<String> |
RedisStreamAsyncCommands.xadd(K key,
XAddArgs args,
Object... keysAndValues)
Append a message to the stream
key . |
RedisFuture<List<StreamMessage<K,V>>> |
RedisStreamAsyncCommands.xclaim(K key,
Consumer<K> consumer,
long minIdleTime,
String... messageIds)
Gets ownership of one or multiple messages in the Pending Entries List of a given stream consumer group.
|
RedisFuture<List<StreamMessage<K,V>>> |
RedisStreamAsyncCommands.xclaim(K key,
Consumer<K> consumer,
XClaimArgs args,
String... messageIds)
Gets ownership of one or multiple messages in the Pending Entries List of a given stream consumer group.
|
RedisFuture<Long> |
RedisStreamAsyncCommands.xdel(K key,
String... messageIds)
Removes the specified entries from the stream.
|
RedisFuture<String> |
RedisStreamAsyncCommands.xgroupCreate(XReadArgs.StreamOffset<K> streamOffset,
K group)
Create a consumer group.
|
RedisFuture<String> |
RedisStreamAsyncCommands.xgroupCreate(XReadArgs.StreamOffset<K> streamOffset,
K group,
XGroupCreateArgs args)
Create a consumer group.
|
RedisFuture<Long> |
RedisStreamAsyncCommands.xgroupDelconsumer(K key,
Consumer<K> consumer)
Delete a consumer from a consumer group.
|
RedisFuture<Boolean> |
RedisStreamAsyncCommands.xgroupDestroy(K key,
K group)
Destroy a consumer group.
|
RedisFuture<String> |
RedisStreamAsyncCommands.xgroupSetid(XReadArgs.StreamOffset<K> streamOffset,
K group)
Set the current
group id. |
RedisFuture<List<Object>> |
RedisStreamAsyncCommands.xinfoConsumers(K key,
K group)
Retrieve information about consumer groups of group
group and stream at key . |
RedisFuture<List<Object>> |
RedisStreamAsyncCommands.xinfoGroups(K key)
Retrieve information about the stream consumer groups at
key . |
RedisFuture<List<Object>> |
RedisStreamAsyncCommands.xinfoStream(K key)
Retrieve information about the stream at
key . |
RedisFuture<Long> |
RedisStreamAsyncCommands.xlen(K key)
Get the length of a steam.
|
RedisFuture<List<PendingMessage>> |
RedisStreamAsyncCommands.xpending(K key,
Consumer<K> consumer,
Range<String> range,
Limit limit)
Read pending messages from a stream within a specific
Range . |
RedisFuture<PendingMessages> |
RedisStreamAsyncCommands.xpending(K key,
K group)
Read pending messages from a stream for a
group . |
RedisFuture<List<PendingMessage>> |
RedisStreamAsyncCommands.xpending(K key,
K group,
Range<String> range,
Limit limit)
Read pending messages from a stream within a specific
Range . |
RedisFuture<List<StreamMessage<K,V>>> |
RedisStreamAsyncCommands.xrange(K key,
Range<String> range)
Read messages from a stream within a specific
Range . |
RedisFuture<List<StreamMessage<K,V>>> |
RedisStreamAsyncCommands.xrange(K key,
Range<String> range,
Limit limit)
|
RedisFuture<List<StreamMessage<K,V>>> |
RedisStreamAsyncCommands.xread(XReadArgs.StreamOffset<K>... streams)
Read messages from one or more
XReadArgs.StreamOffset s. |
RedisFuture<List<StreamMessage<K,V>>> |
RedisStreamAsyncCommands.xread(XReadArgs args,
XReadArgs.StreamOffset<K>... streams)
Read messages from one or more
XReadArgs.StreamOffset s. |
RedisFuture<List<StreamMessage<K,V>>> |
RedisStreamAsyncCommands.xreadgroup(Consumer<K> consumer,
XReadArgs.StreamOffset<K>... streams)
Read messages from one or more
XReadArgs.StreamOffset s using a consumer group. |
RedisFuture<List<StreamMessage<K,V>>> |
RedisStreamAsyncCommands.xreadgroup(Consumer<K> consumer,
XReadArgs args,
XReadArgs.StreamOffset<K>... streams)
Read messages from one or more
XReadArgs.StreamOffset s using a consumer group. |
RedisFuture<List<StreamMessage<K,V>>> |
RedisStreamAsyncCommands.xrevrange(K key,
Range<String> range)
Read messages from a stream within a specific
Range in reverse order. |
RedisFuture<List<StreamMessage<K,V>>> |
RedisStreamAsyncCommands.xrevrange(K key,
Range<String> range,
Limit limit)
|
RedisFuture<Long> |
RedisStreamAsyncCommands.xtrim(K key,
boolean approximateTrimming,
long count)
Trims the stream to
count elements. |
RedisFuture<Long> |
RedisStreamAsyncCommands.xtrim(K key,
long count)
Trims the stream to
count elements. |
RedisFuture<Long> |
RedisSortedSetAsyncCommands.zadd(K key,
double score,
V member)
Add one or more members to a sorted set, or update its score if it already exists.
|
RedisFuture<Long> |
RedisSortedSetAsyncCommands.zadd(K key,
Object... scoresAndValues)
Add one or more members to a sorted set, or update its score if it already exists.
|
RedisFuture<Long> |
RedisSortedSetAsyncCommands.zadd(K key,
ScoredValue<V>... scoredValues)
Add one or more members to a sorted set, or update its score if it already exists.
|
RedisFuture<Long> |
RedisSortedSetAsyncCommands.zadd(K key,
ZAddArgs zAddArgs,
double score,
V member)
Add one or more members to a sorted set, or update its score if it already exists.
|
RedisFuture<Long> |
RedisSortedSetAsyncCommands.zadd(K key,
ZAddArgs zAddArgs,
Object... scoresAndValues)
Add one or more members to a sorted set, or update its score if it already exists.
|
RedisFuture<Long> |
RedisSortedSetAsyncCommands.zadd(K key,
ZAddArgs zAddArgs,
ScoredValue<V>... scoredValues)
Add one or more members to a sorted set, or update its score if it already exists.
|
RedisFuture<Double> |
RedisSortedSetAsyncCommands.zaddincr(K key,
double score,
V member)
Add one or more members to a sorted set, or update its score if it already exists applying the
INCR option. |
RedisFuture<Double> |
RedisSortedSetAsyncCommands.zaddincr(K key,
ZAddArgs zAddArgs,
double score,
V member)
Add one or more members to a sorted set, or update its score if it already exists applying the
INCR option. |
RedisFuture<Long> |
RedisSortedSetAsyncCommands.zcard(K key)
Get the number of members in a sorted set.
|
RedisFuture<Long> |
RedisSortedSetAsyncCommands.zcount(K key,
double min,
double max)
Deprecated.
|
RedisFuture<Long> |
RedisSortedSetAsyncCommands.zcount(K key,
Range<? extends Number> range)
Count the members in a sorted set with scores within the given
Range . |
RedisFuture<Long> |
RedisSortedSetAsyncCommands.zcount(K key,
String min,
String max)
Deprecated.
|
RedisFuture<Double> |
RedisSortedSetAsyncCommands.zincrby(K key,
double amount,
V member)
Increment the score of a member in a sorted set.
|
RedisFuture<Long> |
RedisSortedSetAsyncCommands.zinterstore(K destination,
K... keys)
Intersect multiple sorted sets and store the resulting sorted set in a new key.
|
RedisFuture<Long> |
RedisSortedSetAsyncCommands.zinterstore(K destination,
ZStoreArgs storeArgs,
K... keys)
Intersect multiple sorted sets and store the resulting sorted set in a new key.
|
RedisFuture<Long> |
RedisSortedSetAsyncCommands.zlexcount(K key,
Range<? extends V> range)
Count the number of members in a sorted set between a given lexicographical range.
|
RedisFuture<Long> |
RedisSortedSetAsyncCommands.zlexcount(K key,
String min,
String max)
Deprecated.
|
RedisFuture<ScoredValue<V>> |
RedisSortedSetAsyncCommands.zpopmax(K key)
Removes and returns up to count members with the highest scores in the sorted set stored at key.
|
RedisFuture<List<ScoredValue<V>>> |
RedisSortedSetAsyncCommands.zpopmax(K key,
long count)
Removes and returns up to count members with the highest scores in the sorted set stored at key.
|
RedisFuture<ScoredValue<V>> |
RedisSortedSetAsyncCommands.zpopmin(K key)
Removes and returns up to count members with the lowest scores in the sorted set stored at key.
|
RedisFuture<List<ScoredValue<V>>> |
RedisSortedSetAsyncCommands.zpopmin(K key,
long count)
Removes and returns up to count members with the lowest scores in the sorted set stored at key.
|
RedisFuture<List<V>> |
RedisSortedSetAsyncCommands.zrange(K key,
long start,
long stop)
Return a range of members in a sorted set, by index.
|
RedisFuture<Long> |
RedisSortedSetAsyncCommands.zrange(ValueStreamingChannel<V> channel,
K key,
long start,
long stop)
Return a range of members in a sorted set, by index.
|
RedisFuture<List<V>> |
RedisSortedSetAsyncCommands.zrangebylex(K key,
Range<? extends V> range)
Return a range of members in a sorted set, by lexicographical range.
|
RedisFuture<List<V>> |
RedisSortedSetAsyncCommands.zrangebylex(K key,
Range<? extends V> range,
Limit limit)
Return a range of members in a sorted set, by lexicographical range.
|
RedisFuture<List<V>> |
RedisSortedSetAsyncCommands.zrangebylex(K key,
String min,
String max)
Deprecated.
|
RedisFuture<List<V>> |
RedisSortedSetAsyncCommands.zrangebylex(K key,
String min,
String max,
long offset,
long count)
Deprecated.
|
RedisFuture<List<V>> |
RedisSortedSetAsyncCommands.zrangebyscore(K key,
double min,
double max)
|
RedisFuture<List<V>> |
RedisSortedSetAsyncCommands.zrangebyscore(K key,
double min,
double max,
long offset,
long count)
|
RedisFuture<List<V>> |
RedisSortedSetAsyncCommands.zrangebyscore(K key,
Range<? extends Number> range)
Return a range of members in a sorted set, by score.
|
RedisFuture<List<V>> |
RedisSortedSetAsyncCommands.zrangebyscore(K key,
Range<? extends Number> range,
Limit limit)
Return a range of members in a sorted set, by score.
|
RedisFuture<List<V>> |
RedisSortedSetAsyncCommands.zrangebyscore(K key,
String min,
String max)
|
RedisFuture<List<V>> |
RedisSortedSetAsyncCommands.zrangebyscore(K key,
String min,
String max,
long offset,
long count)
|
RedisFuture<Long> |
RedisSortedSetAsyncCommands.zrangebyscore(ValueStreamingChannel<V> channel,
K key,
double min,
double max)
|
RedisFuture<Long> |
RedisSortedSetAsyncCommands.zrangebyscore(ValueStreamingChannel<V> channel,
K key,
double min,
double max,
long offset,
long count)
|
RedisFuture<Long> |
RedisSortedSetAsyncCommands.zrangebyscore(ValueStreamingChannel<V> channel,
K key,
Range<? extends Number> range)
Stream over a range of members in a sorted set, by score.
|
RedisFuture<Long> |
RedisSortedSetAsyncCommands.zrangebyscore(ValueStreamingChannel<V> channel,
K key,
Range<? extends Number> range,
Limit limit)
Stream over a range of members in a sorted set, by score.
|
RedisFuture<Long> |
RedisSortedSetAsyncCommands.zrangebyscore(ValueStreamingChannel<V> channel,
K key,
String min,
String max)
|
RedisFuture<Long> |
RedisSortedSetAsyncCommands.zrangebyscore(ValueStreamingChannel<V> channel,
K key,
String min,
String max,
long offset,
long count)
|
RedisFuture<List<ScoredValue<V>>> |
RedisSortedSetAsyncCommands.zrangebyscoreWithScores(K key,
double min,
double max)
|
RedisFuture<List<ScoredValue<V>>> |
RedisSortedSetAsyncCommands.zrangebyscoreWithScores(K key,
double min,
double max,
long offset,
long count)
|
RedisFuture<List<ScoredValue<V>>> |
RedisSortedSetAsyncCommands.zrangebyscoreWithScores(K key,
Range<? extends Number> range)
Return a range of members with score in a sorted set, by score.
|
RedisFuture<List<ScoredValue<V>>> |
RedisSortedSetAsyncCommands.zrangebyscoreWithScores(K key,
Range<? extends Number> range,
Limit limit)
Return a range of members with score in a sorted set, by score.
|
RedisFuture<List<ScoredValue<V>>> |
RedisSortedSetAsyncCommands.zrangebyscoreWithScores(K key,
String min,
String max)
|
RedisFuture<List<ScoredValue<V>>> |
RedisSortedSetAsyncCommands.zrangebyscoreWithScores(K key,
String min,
String max,
long offset,
long count)
|
RedisFuture<Long> |
RedisSortedSetAsyncCommands.zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel,
K key,
double min,
double max)
|
RedisFuture<Long> |
RedisSortedSetAsyncCommands.zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel,
K key,
double min,
double max,
long offset,
long count)
|
RedisFuture<Long> |
RedisSortedSetAsyncCommands.zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel,
K key,
Range<? extends Number> range)
Stream over a range of members with scores in a sorted set, by score.
|
RedisFuture<Long> |
RedisSortedSetAsyncCommands.zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel,
K key,
Range<? extends Number> range,
Limit limit)
Stream over a range of members with scores in a sorted set, by score.
|
RedisFuture<Long> |
RedisSortedSetAsyncCommands.zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel,
K key,
String min,
String max)
|
RedisFuture<Long> |
RedisSortedSetAsyncCommands.zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel,
K key,
String min,
String max,
long offset,
long count)
|
RedisFuture<List<ScoredValue<V>>> |
RedisSortedSetAsyncCommands.zrangeWithScores(K key,
long start,
long stop)
Return a range of members with scores in a sorted set, by index.
|
RedisFuture<Long> |
RedisSortedSetAsyncCommands.zrangeWithScores(ScoredValueStreamingChannel<V> channel,
K key,
long start,
long stop)
Stream over a range of members with scores in a sorted set, by index.
|
RedisFuture<Long> |
RedisSortedSetAsyncCommands.zrank(K key,
V member)
Determine the index of a member in a sorted set.
|
RedisFuture<Long> |
RedisSortedSetAsyncCommands.zrem(K key,
V... members)
Remove one or more members from a sorted set.
|
RedisFuture<Long> |
RedisSortedSetAsyncCommands.zremrangebylex(K key,
Range<? extends V> range)
Remove all members in a sorted set between the given lexicographical range.
|
RedisFuture<Long> |
RedisSortedSetAsyncCommands.zremrangebylex(K key,
String min,
String max)
|
RedisFuture<Long> |
RedisSortedSetAsyncCommands.zremrangebyrank(K key,
long start,
long stop)
Remove all members in a sorted set within the given indexes.
|
RedisFuture<Long> |
RedisSortedSetAsyncCommands.zremrangebyscore(K key,
double min,
double max)
|
RedisFuture<Long> |
RedisSortedSetAsyncCommands.zremrangebyscore(K key,
Range<? extends Number> range)
Remove all members in a sorted set within the given scores.
|
RedisFuture<Long> |
RedisSortedSetAsyncCommands.zremrangebyscore(K key,
String min,
String max)
|
RedisFuture<List<V>> |
RedisSortedSetAsyncCommands.zrevrange(K key,
long start,
long stop)
Return a range of members in a sorted set, by index, with scores ordered from high to low.
|
RedisFuture<Long> |
RedisSortedSetAsyncCommands.zrevrange(ValueStreamingChannel<V> channel,
K key,
long start,
long stop)
Stream over a range of members in a sorted set, by index, with scores ordered from high to low.
|
RedisFuture<List<V>> |
RedisSortedSetAsyncCommands.zrevrangebylex(K key,
Range<? extends V> range)
Return a range of members in a sorted set, by lexicographical range ordered from high to low.
|
RedisFuture<List<V>> |
RedisSortedSetAsyncCommands.zrevrangebylex(K key,
Range<? extends V> range,
Limit limit)
Return a range of members in a sorted set, by lexicographical range ordered from high to low.
|
RedisFuture<List<V>> |
RedisSortedSetAsyncCommands.zrevrangebyscore(K key,
double max,
double min)
|
RedisFuture<List<V>> |
RedisSortedSetAsyncCommands.zrevrangebyscore(K key,
double max,
double min,
long offset,
long count)
|
RedisFuture<List<V>> |
RedisSortedSetAsyncCommands.zrevrangebyscore(K key,
Range<? extends Number> range)
Return a range of members in a sorted set, by score, with scores ordered from high to low.
|
RedisFuture<List<V>> |
RedisSortedSetAsyncCommands.zrevrangebyscore(K key,
Range<? extends Number> range,
Limit limit)
Return a range of members in a sorted set, by score, with scores ordered from high to low.
|
RedisFuture<List<V>> |
RedisSortedSetAsyncCommands.zrevrangebyscore(K key,
String max,
String min)
|
RedisFuture<List<V>> |
RedisSortedSetAsyncCommands.zrevrangebyscore(K key,
String max,
String min,
long offset,
long count)
|
RedisFuture<Long> |
RedisSortedSetAsyncCommands.zrevrangebyscore(ValueStreamingChannel<V> channel,
K key,
double max,
double min)
|
RedisFuture<Long> |
RedisSortedSetAsyncCommands.zrevrangebyscore(ValueStreamingChannel<V> channel,
K key,
double max,
double min,
long offset,
long count)
|
RedisFuture<Long> |
RedisSortedSetAsyncCommands.zrevrangebyscore(ValueStreamingChannel<V> channel,
K key,
Range<? extends Number> range)
Stream over a range of members in a sorted set, by score, with scores ordered from high to low.
|
RedisFuture<Long> |
RedisSortedSetAsyncCommands.zrevrangebyscore(ValueStreamingChannel<V> channel,
K key,
Range<? extends Number> range,
Limit limit)
Stream over a range of members in a sorted set, by score, with scores ordered from high to low.
|
RedisFuture<Long> |
RedisSortedSetAsyncCommands.zrevrangebyscore(ValueStreamingChannel<V> channel,
K key,
String max,
String min)
|
RedisFuture<Long> |
RedisSortedSetAsyncCommands.zrevrangebyscore(ValueStreamingChannel<V> channel,
K key,
String max,
String min,
long offset,
long count)
|
RedisFuture<List<ScoredValue<V>>> |
RedisSortedSetAsyncCommands.zrevrangebyscoreWithScores(K key,
double max,
double min)
|
RedisFuture<List<ScoredValue<V>>> |
RedisSortedSetAsyncCommands.zrevrangebyscoreWithScores(K key,
double max,
double min,
long offset,
long count)
|
RedisFuture<List<ScoredValue<V>>> |
RedisSortedSetAsyncCommands.zrevrangebyscoreWithScores(K key,
Range<? extends Number> range)
Return a range of members with scores in a sorted set, by score, with scores ordered from high to low.
|
RedisFuture<List<ScoredValue<V>>> |
RedisSortedSetAsyncCommands.zrevrangebyscoreWithScores(K key,
Range<? extends Number> range,
Limit limit)
Return a range of members with scores in a sorted set, by score, with scores ordered from high to low.
|
RedisFuture<List<ScoredValue<V>>> |
RedisSortedSetAsyncCommands.zrevrangebyscoreWithScores(K key,
String max,
String min)
|
RedisFuture<List<ScoredValue<V>>> |
RedisSortedSetAsyncCommands.zrevrangebyscoreWithScores(K key,
String max,
String min,
long offset,
long count)
|
RedisFuture<Long> |
RedisSortedSetAsyncCommands.zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel,
K key,
double max,
double min)
|
RedisFuture<Long> |
RedisSortedSetAsyncCommands.zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel,
K key,
double max,
double min,
long offset,
long count)
|
RedisFuture<Long> |
RedisSortedSetAsyncCommands.zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel,
K key,
Range<? extends Number> range)
Stream over a range of members with scores in a sorted set, by score, with scores ordered from high to low.
|
RedisFuture<Long> |
RedisSortedSetAsyncCommands.zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel,
K key,
Range<? extends Number> range,
Limit limit)
Stream over a range of members with scores in a sorted set, by score, with scores ordered from high to low.
|
RedisFuture<Long> |
RedisSortedSetAsyncCommands.zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel,
K key,
String max,
String min)
|
RedisFuture<Long> |
RedisSortedSetAsyncCommands.zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel,
K key,
String max,
String min,
long offset,
long count)
|
RedisFuture<List<ScoredValue<V>>> |
RedisSortedSetAsyncCommands.zrevrangeWithScores(K key,
long start,
long stop)
Return a range of members with scores in a sorted set, by index, with scores ordered from high to low.
|
RedisFuture<Long> |
RedisSortedSetAsyncCommands.zrevrangeWithScores(ScoredValueStreamingChannel<V> channel,
K key,
long start,
long stop)
Stream over a range of members with scores in a sorted set, by index, with scores ordered from high to low.
|
RedisFuture<Long> |
RedisSortedSetAsyncCommands.zrevrank(K key,
V member)
Determine the index of a member in a sorted set, with scores ordered from high to low.
|
RedisFuture<ScoredValueScanCursor<V>> |
RedisSortedSetAsyncCommands.zscan(K key)
Incrementally iterate sorted sets elements and associated scores.
|
RedisFuture<ScoredValueScanCursor<V>> |
RedisSortedSetAsyncCommands.zscan(K key,
ScanArgs scanArgs)
Incrementally iterate sorted sets elements and associated scores.
|
RedisFuture<ScoredValueScanCursor<V>> |
RedisSortedSetAsyncCommands.zscan(K key,
ScanCursor scanCursor)
Incrementally iterate sorted sets elements and associated scores.
|
RedisFuture<ScoredValueScanCursor<V>> |
RedisSortedSetAsyncCommands.zscan(K key,
ScanCursor scanCursor,
ScanArgs scanArgs)
Incrementally iterate sorted sets elements and associated scores.
|
RedisFuture<StreamScanCursor> |
RedisSortedSetAsyncCommands.zscan(ScoredValueStreamingChannel<V> channel,
K key)
Incrementally iterate sorted sets elements and associated scores.
|
RedisFuture<StreamScanCursor> |
RedisSortedSetAsyncCommands.zscan(ScoredValueStreamingChannel<V> channel,
K key,
ScanArgs scanArgs)
Incrementally iterate sorted sets elements and associated scores.
|
RedisFuture<StreamScanCursor> |
RedisSortedSetAsyncCommands.zscan(ScoredValueStreamingChannel<V> channel,
K key,
ScanCursor scanCursor)
Incrementally iterate sorted sets elements and associated scores.
|
RedisFuture<StreamScanCursor> |
RedisSortedSetAsyncCommands.zscan(ScoredValueStreamingChannel<V> channel,
K key,
ScanCursor scanCursor,
ScanArgs scanArgs)
Incrementally iterate sorted sets elements and associated scores.
|
RedisFuture<Double> |
RedisSortedSetAsyncCommands.zscore(K key,
V member)
Get the score associated with the given member in a sorted set.
|
RedisFuture<Long> |
RedisSortedSetAsyncCommands.zunionstore(K destination,
K... keys)
Add multiple sorted sets and store the resulting sorted set in a new key.
|
RedisFuture<Long> |
RedisSortedSetAsyncCommands.zunionstore(K destination,
ZStoreArgs storeArgs,
K... keys)
Add multiple sorted sets and store the resulting sorted set in a new key.
|
Modifier and Type | Method and Description |
---|---|
RedisFuture<String> |
RedisAdvancedClusterAsyncCommandsImpl.clientSetname(K name) |
RedisFuture<Long> |
RedisAdvancedClusterAsyncCommandsImpl.clusterCountKeysInSlot(int slot) |
RedisFuture<List<K>> |
RedisAdvancedClusterAsyncCommandsImpl.clusterGetKeysInSlot(int slot,
int count) |
RedisFuture<Long> |
RedisAdvancedClusterAsyncCommandsImpl.dbsize() |
RedisFuture<Long> |
RedisAdvancedClusterAsyncCommandsImpl.del(Iterable<K> keys) |
RedisFuture<Long> |
RedisAdvancedClusterAsyncCommandsImpl.del(K... keys) |
RedisFuture<Long> |
RedisAdvancedClusterAsyncCommandsImpl.exists(Iterable<K> keys) |
RedisFuture<Long> |
RedisAdvancedClusterAsyncCommandsImpl.exists(K... keys) |
RedisFuture<String> |
RedisAdvancedClusterAsyncCommandsImpl.flushall() |
RedisFuture<String> |
RedisAdvancedClusterAsyncCommandsImpl.flushallAsync() |
RedisFuture<String> |
RedisAdvancedClusterAsyncCommandsImpl.flushdb() |
RedisFuture<Set<V>> |
RedisAdvancedClusterAsyncCommandsImpl.georadius(K key,
double longitude,
double latitude,
double distance,
GeoArgs.Unit unit) |
RedisFuture<Set<V>> |
RedisClusterPubSubAsyncCommandsImpl.georadius(K key,
double longitude,
double latitude,
double distance,
GeoArgs.Unit unit) |
RedisFuture<List<GeoWithin<V>>> |
RedisAdvancedClusterAsyncCommandsImpl.georadius(K key,
double longitude,
double latitude,
double distance,
GeoArgs.Unit unit,
GeoArgs geoArgs) |
RedisFuture<List<GeoWithin<V>>> |
RedisClusterPubSubAsyncCommandsImpl.georadius(K key,
double longitude,
double latitude,
double distance,
GeoArgs.Unit unit,
GeoArgs geoArgs) |
RedisFuture<Set<V>> |
RedisAdvancedClusterAsyncCommandsImpl.georadiusbymember(K key,
V member,
double distance,
GeoArgs.Unit unit) |
RedisFuture<Set<V>> |
RedisClusterPubSubAsyncCommandsImpl.georadiusbymember(K key,
V member,
double distance,
GeoArgs.Unit unit) |
RedisFuture<List<GeoWithin<V>>> |
RedisAdvancedClusterAsyncCommandsImpl.georadiusbymember(K key,
V member,
double distance,
GeoArgs.Unit unit,
GeoArgs geoArgs) |
RedisFuture<List<GeoWithin<V>>> |
RedisClusterPubSubAsyncCommandsImpl.georadiusbymember(K key,
V member,
double distance,
GeoArgs.Unit unit,
GeoArgs geoArgs) |
RedisFuture<List<K>> |
RedisAdvancedClusterAsyncCommandsImpl.keys(K pattern) |
RedisFuture<Long> |
RedisAdvancedClusterAsyncCommandsImpl.keys(KeyStreamingChannel<K> channel,
K pattern) |
RedisFuture<List<KeyValue<K,V>>> |
RedisAdvancedClusterAsyncCommandsImpl.mget(Iterable<K> keys) |
RedisFuture<List<KeyValue<K,V>>> |
RedisAdvancedClusterAsyncCommandsImpl.mget(K... keys) |
RedisFuture<Long> |
RedisAdvancedClusterAsyncCommandsImpl.mget(KeyValueStreamingChannel<K,V> channel,
Iterable<K> keys) |
RedisFuture<Long> |
RedisAdvancedClusterAsyncCommandsImpl.mget(KeyValueStreamingChannel<K,V> channel,
K... keys) |
RedisFuture<String> |
RedisAdvancedClusterAsyncCommandsImpl.mset(Map<K,V> map) |
RedisFuture<Boolean> |
RedisAdvancedClusterAsyncCommandsImpl.msetnx(Map<K,V> map) |
RedisFuture<K> |
RedisAdvancedClusterAsyncCommandsImpl.randomkey() |
RedisFuture<KeyScanCursor<K>> |
RedisAdvancedClusterAsyncCommandsImpl.scan() |
RedisFuture<StreamScanCursor> |
RedisAdvancedClusterAsyncCommandsImpl.scan(KeyStreamingChannel<K> channel) |
RedisFuture<StreamScanCursor> |
RedisAdvancedClusterAsyncCommandsImpl.scan(KeyStreamingChannel<K> channel,
ScanArgs scanArgs) |
RedisFuture<StreamScanCursor> |
RedisAdvancedClusterAsyncCommandsImpl.scan(KeyStreamingChannel<K> channel,
ScanCursor scanCursor) |
RedisFuture<StreamScanCursor> |
RedisAdvancedClusterAsyncCommandsImpl.scan(KeyStreamingChannel<K> channel,
ScanCursor scanCursor,
ScanArgs scanArgs) |
RedisFuture<KeyScanCursor<K>> |
RedisAdvancedClusterAsyncCommandsImpl.scan(ScanArgs scanArgs) |
RedisFuture<KeyScanCursor<K>> |
RedisAdvancedClusterAsyncCommandsImpl.scan(ScanCursor scanCursor) |
RedisFuture<KeyScanCursor<K>> |
RedisAdvancedClusterAsyncCommandsImpl.scan(ScanCursor scanCursor,
ScanArgs scanArgs) |
RedisFuture<String> |
RedisAdvancedClusterAsyncCommandsImpl.scriptFlush() |
RedisFuture<String> |
RedisAdvancedClusterAsyncCommandsImpl.scriptKill() |
RedisFuture<String> |
RedisAdvancedClusterAsyncCommandsImpl.scriptLoad(byte[] script) |
RedisFuture<Long> |
RedisAdvancedClusterAsyncCommandsImpl.touch(Iterable<K> keys) |
RedisFuture<Long> |
RedisAdvancedClusterAsyncCommandsImpl.touch(K... keys) |
RedisFuture<Long> |
RedisAdvancedClusterAsyncCommandsImpl.unlink(Iterable<K> keys) |
RedisFuture<Long> |
RedisAdvancedClusterAsyncCommandsImpl.unlink(K... keys) |
Modifier and Type | Method and Description |
---|---|
protected <T> Map<String,CompletableFuture<T>> |
RedisAdvancedClusterAsyncCommandsImpl.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>> |
RedisAdvancedClusterAsyncCommandsImpl.executeOnUpstream(Function<RedisClusterAsyncCommands<K,V>,RedisFuture<T>> function)
Run a command on all available masters,
|
Modifier and Type | Method and Description |
---|---|
RedisFuture<String> |
RedisClusterAsyncCommands.asking()
The asking command is required after a
-ASK redirection. |
RedisFuture<String> |
RedisClusterAsyncCommands.auth(CharSequence password)
Authenticate to the server.
|
RedisFuture<String> |
RedisClusterAsyncCommands.auth(String username,
CharSequence password)
Authenticate to the server with username and password.
|
RedisFuture<String> |
RedisAdvancedClusterAsyncCommands.clientSetname(K name)
Set the current connection name on all cluster nodes with pipelining.
|
RedisFuture<String> |
RedisClusterAsyncCommands.clusterAddSlots(int... slots)
Adds slots to the cluster node.
|
RedisFuture<String> |
RedisClusterAsyncCommands.clusterBumpepoch()
Generate a new config epoch, incrementing the current epoch, assign the new epoch to this node, WITHOUT any consensus and
persist the configuration on disk before sending packets with the new configuration.
|
RedisFuture<Long> |
RedisClusterAsyncCommands.clusterCountFailureReports(String nodeId)
Returns the number of failure reports for the specified node.
|
RedisFuture<Long> |
RedisClusterAsyncCommands.clusterCountKeysInSlot(int slot)
Returns the number of keys in the specified Redis Cluster hash
slot . |
RedisFuture<String> |
RedisClusterAsyncCommands.clusterDelSlots(int... slots)
Removes slots from the cluster node.
|
RedisFuture<String> |
RedisClusterAsyncCommands.clusterFailover(boolean force)
Failover a cluster node.
|
RedisFuture<String> |
RedisClusterAsyncCommands.clusterFlushslots()
Delete all the slots associated with the specified node.
|
RedisFuture<String> |
RedisClusterAsyncCommands.clusterForget(String nodeId)
Disallow connections and remove the cluster node from the cluster.
|
RedisFuture<List<K>> |
RedisClusterAsyncCommands.clusterGetKeysInSlot(int slot,
int count)
Retrieve the list of keys within the
slot . |
RedisFuture<String> |
RedisClusterAsyncCommands.clusterInfo()
Get information and statistics about the cluster viewed by the current node.
|
RedisFuture<Long> |
RedisClusterAsyncCommands.clusterKeyslot(K key)
Returns an integer identifying the hash slot the specified key hashes to.
|
RedisFuture<String> |
RedisClusterAsyncCommands.clusterMeet(String ip,
int port)
Meet another cluster node to include the node into the cluster.
|
RedisFuture<String> |
RedisClusterAsyncCommands.clusterMyId()
Obtain the nodeId for the currently connected node.
|
RedisFuture<String> |
RedisClusterAsyncCommands.clusterNodes()
Obtain details about all cluster nodes.
|
RedisFuture<String> |
RedisClusterAsyncCommands.clusterReplicate(String nodeId)
Turn this node into a replica of the node with the id
nodeId . |
RedisFuture<String> |
RedisClusterAsyncCommands.clusterReset(boolean hard)
Reset a node performing a soft or hard reset:
All other nodes are forgotten
All the assigned / open slots are released
If the node is a replica, it turns into a master
Only for hard reset: a new Node ID is generated
Only for hard reset: currentEpoch and configEpoch are set to 0
The new configuration is saved and the cluster state updated
If the node was a replica, the whole data set is flushed away
|
RedisFuture<String> |
RedisClusterAsyncCommands.clusterSaveconfig()
Forces a node to save the nodes.conf configuration on disk.
|
RedisFuture<String> |
RedisClusterAsyncCommands.clusterSetConfigEpoch(long configEpoch)
This command sets a specific config epoch in a fresh node.
|
RedisFuture<String> |
RedisClusterAsyncCommands.clusterSetSlotImporting(int slot,
String nodeId)
Flag a slot as IMPORTING (incoming) from the node specified in
nodeId . |
RedisFuture<String> |
RedisClusterAsyncCommands.clusterSetSlotMigrating(int slot,
String nodeId)
Flag a slot as MIGRATING (outgoing) towards the node specified in
nodeId . |
RedisFuture<String> |
RedisClusterAsyncCommands.clusterSetSlotNode(int slot,
String nodeId)
Assign a slot to a node.
|
RedisFuture<String> |
RedisClusterAsyncCommands.clusterSetSlotStable(int slot)
Clears migrating / importing state from the slot.
|
RedisFuture<List<String>> |
RedisClusterAsyncCommands.clusterSlaves(String nodeId)
List replicas for a certain node identified by its
nodeId . |
RedisFuture<List<Object>> |
RedisClusterAsyncCommands.clusterSlots()
Get array of cluster slots to node mappings.
|
RedisFuture<Long> |
RedisAdvancedClusterAsyncCommands.dbsize()
Return the number of keys in the selected database on all cluster upstream nodes.
|
RedisFuture<Long> |
RedisClusterAsyncCommands.del(K... keys)
Delete a key with pipelining.
|
RedisFuture<Long> |
RedisAdvancedClusterAsyncCommands.del(K... keys)
Delete one or more keys with pipelining.
|
RedisFuture<Long> |
RedisAdvancedClusterAsyncCommands.exists(K... keys)
Determine how many keys exist with pipelining.
|
RedisFuture<String> |
RedisAdvancedClusterAsyncCommands.flushall()
Remove all keys from all databases on all cluster upstream nodes with pipelining.
|
RedisFuture<String> |
RedisAdvancedClusterAsyncCommands.flushallAsync()
Remove all keys asynchronously from all databases on all cluster upstream nodes with pipelining.
|
RedisFuture<String> |
RedisAdvancedClusterAsyncCommands.flushdb()
Remove all keys from the current database on all cluster upstream nodes with pipelining.
|
RedisFuture<List<K>> |
RedisAdvancedClusterAsyncCommands.keys(K pattern)
Find all keys matching the given pattern on all cluster upstream nodes.
|
RedisFuture<Long> |
RedisAdvancedClusterAsyncCommands.keys(KeyStreamingChannel<K> channel,
K pattern)
Find all keys matching the given pattern on all cluster upstream nodes.
|
RedisFuture<List<KeyValue<K,V>>> |
RedisClusterAsyncCommands.mget(K... keys)
Get the values of all the given keys with pipelining.
|
RedisFuture<List<KeyValue<K,V>>> |
RedisAdvancedClusterAsyncCommands.mget(K... keys)
Get the values of all the given keys with pipelining.
|
RedisFuture<String> |
RedisClusterAsyncCommands.mset(Map<K,V> map)
Set multiple keys to multiple values with pipelining.
|
RedisFuture<String> |
RedisAdvancedClusterAsyncCommands.mset(Map<K,V> map)
Set multiple keys to multiple values with pipelining.
|
RedisFuture<Boolean> |
RedisClusterAsyncCommands.msetnx(Map<K,V> map)
Set multiple keys to multiple values, only if none of the keys exist with pipelining.
|
RedisFuture<Boolean> |
RedisAdvancedClusterAsyncCommands.msetnx(Map<K,V> map)
Set multiple keys to multiple values, only if none of the keys exist with pipelining.
|
RedisFuture<K> |
RedisAdvancedClusterAsyncCommands.randomkey()
Return a random key from the keyspace on a random master.
|
RedisFuture<String> |
RedisClusterAsyncCommands.readOnly()
Tells a Redis cluster replica node that the client is ok reading possibly stale data and is not interested in running
write queries.
|
RedisFuture<String> |
RedisClusterAsyncCommands.readWrite()
Resets readOnly flag.
|
RedisFuture<KeyScanCursor<K>> |
RedisAdvancedClusterAsyncCommands.scan()
Incrementally iterate the keys space over the whole Cluster.
|
RedisFuture<StreamScanCursor> |
RedisAdvancedClusterAsyncCommands.scan(KeyStreamingChannel<K> channel)
Incrementally iterate the keys space over the whole Cluster.
|
RedisFuture<StreamScanCursor> |
RedisAdvancedClusterAsyncCommands.scan(KeyStreamingChannel<K> channel,
ScanArgs scanArgs)
Incrementally iterate the keys space over the whole Cluster.
|
RedisFuture<StreamScanCursor> |
RedisAdvancedClusterAsyncCommands.scan(KeyStreamingChannel<K> channel,
ScanCursor scanCursor)
Incrementally iterate the keys space over the whole Cluster.
|
RedisFuture<StreamScanCursor> |
RedisAdvancedClusterAsyncCommands.scan(KeyStreamingChannel<K> channel,
ScanCursor scanCursor,
ScanArgs scanArgs)
Incrementally iterate the keys space over the whole Cluster.
|
RedisFuture<KeyScanCursor<K>> |
RedisAdvancedClusterAsyncCommands.scan(ScanArgs scanArgs)
Incrementally iterate the keys space over the whole Cluster.
|
RedisFuture<KeyScanCursor<K>> |
RedisAdvancedClusterAsyncCommands.scan(ScanCursor scanCursor)
Incrementally iterate the keys space over the whole Cluster.
|
RedisFuture<KeyScanCursor<K>> |
RedisAdvancedClusterAsyncCommands.scan(ScanCursor scanCursor,
ScanArgs scanArgs)
Incrementally iterate the keys space over the whole Cluster.
|
RedisFuture<String> |
RedisAdvancedClusterAsyncCommands.scriptFlush()
Remove all the scripts from the script cache on all cluster nodes.
|
RedisFuture<String> |
RedisAdvancedClusterAsyncCommands.scriptKill()
Kill the script currently in execution on all cluster nodes.
|
RedisFuture<String> |
RedisAdvancedClusterAsyncCommands.scriptLoad(byte[] script)
Load the specified Lua script into the script cache on all cluster nodes.
|
RedisFuture<String> |
RedisAdvancedClusterAsyncCommands.scriptLoad(String script)
Load the specified Lua script into the script cache on all cluster nodes.
|
RedisFuture<Long> |
RedisAdvancedClusterAsyncCommands.touch(K... keys)
Touch one or more keys with pipelining.
|
RedisFuture<Long> |
RedisAdvancedClusterAsyncCommands.unlink(K... keys)
Unlink one or more keys with pipelining.
|
Modifier and Type | Method and Description |
---|---|
static <T> T |
Futures.awaitOrCancel(RedisFuture<T> cmd,
long timeout,
TimeUnit unit)
Wait until futures are complete or the supplied timeout is reached.
|
Modifier and Type | Class and Description |
---|---|
class |
AsyncCommand<K,V,T>
An asynchronous redis command and its result.
|
class |
TransactionalCommand<K,V,T>
A wrapper for commands within a MULTI transaction.
|
Modifier and Type | Method and Description |
---|---|
RedisFuture<Void> |
RedisPubSubAsyncCommandsImpl.psubscribe(K... patterns) |
RedisFuture<Long> |
RedisPubSubAsyncCommandsImpl.publish(K channel,
V message) |
RedisFuture<List<K>> |
RedisPubSubAsyncCommandsImpl.pubsubChannels(K channel) |
RedisFuture<Map<K,Long>> |
RedisPubSubAsyncCommandsImpl.pubsubNumsub(K... channels) |
RedisFuture<Void> |
RedisPubSubAsyncCommandsImpl.punsubscribe(K... patterns) |
RedisFuture<Void> |
RedisPubSubAsyncCommandsImpl.subscribe(K... channels) |
RedisFuture<Void> |
RedisPubSubAsyncCommandsImpl.unsubscribe(K... channels) |
Modifier and Type | Method and Description |
---|---|
protected List<RedisFuture<Void>> |
StatefulRedisPubSubConnectionImpl.resubscribe()
Re-subscribe to all previously subscribed channels and patterns.
|
Modifier and Type | Method and Description |
---|---|
RedisFuture<Void> |
RedisPubSubAsyncCommands.psubscribe(K... patterns)
Listen for messages published to channels matching the given patterns.
|
RedisFuture<Void> |
RedisPubSubAsyncCommands.punsubscribe(K... patterns)
Stop listening for messages posted to channels matching the given patterns.
|
RedisFuture<Void> |
RedisPubSubAsyncCommands.subscribe(K... channels)
Listen for messages published to the given channels.
|
RedisFuture<Void> |
RedisPubSubAsyncCommands.unsubscribe(K... channels)
Stop listening for messages posted to the given channels.
|
Modifier and Type | Method and Description |
---|---|
RedisFuture<K> |
RedisSentinelAsyncCommandsImpl.clientGetname() |
RedisFuture<Long> |
RedisSentinelAsyncCommandsImpl.clientKill(KillArgs killArgs) |
RedisFuture<String> |
RedisSentinelAsyncCommandsImpl.clientKill(String addr) |
RedisFuture<String> |
RedisSentinelAsyncCommandsImpl.clientList() |
RedisFuture<String> |
RedisSentinelAsyncCommandsImpl.clientPause(long timeout) |
RedisFuture<String> |
RedisSentinelAsyncCommandsImpl.clientSetname(K name) |
<T> RedisFuture<T> |
RedisSentinelAsyncCommandsImpl.dispatch(ProtocolKeyword type,
CommandOutput<K,V,T> output) |
<T> RedisFuture<T> |
RedisSentinelAsyncCommandsImpl.dispatch(ProtocolKeyword type,
CommandOutput<K,V,T> output,
CommandArgs<K,V> args) |
RedisFuture<String> |
RedisSentinelAsyncCommandsImpl.failover(K key) |
RedisFuture<SocketAddress> |
RedisSentinelAsyncCommandsImpl.getMasterAddrByName(K key) |
RedisFuture<String> |
RedisSentinelAsyncCommandsImpl.info() |
RedisFuture<String> |
RedisSentinelAsyncCommandsImpl.info(String section) |
RedisFuture<Map<K,V>> |
RedisSentinelAsyncCommandsImpl.master(K key) |
RedisFuture<List<Map<K,V>>> |
RedisSentinelAsyncCommandsImpl.masters() |
RedisFuture<String> |
RedisSentinelAsyncCommandsImpl.monitor(K key,
String ip,
int port,
int quorum) |
RedisFuture<String> |
RedisSentinelAsyncCommandsImpl.ping() |
RedisFuture<String> |
RedisSentinelAsyncCommandsImpl.remove(K key) |
RedisFuture<Long> |
RedisSentinelAsyncCommandsImpl.reset(K key) |
RedisFuture<String> |
RedisSentinelAsyncCommandsImpl.set(K key,
String option,
V value) |
RedisFuture<List<Map<K,V>>> |
RedisSentinelAsyncCommandsImpl.slaves(K key) |
Modifier and Type | Method and Description |
---|---|
RedisFuture<K> |
RedisSentinelAsyncCommands.clientGetname()
Get the current connection name.
|
RedisFuture<Long> |
RedisSentinelAsyncCommands.clientKill(KillArgs killArgs)
Kill connections of clients which are filtered by
killArgs |
RedisFuture<String> |
RedisSentinelAsyncCommands.clientKill(String addr)
Kill the connection of a client identified by ip:port.
|
RedisFuture<String> |
RedisSentinelAsyncCommands.clientList()
Get the list of client connections.
|
RedisFuture<String> |
RedisSentinelAsyncCommands.clientPause(long timeout)
Stop processing commands from clients for some time.
|
RedisFuture<String> |
RedisSentinelAsyncCommands.clientSetname(K name)
Set the current connection name.
|
<T> RedisFuture<T> |
RedisSentinelAsyncCommands.dispatch(ProtocolKeyword type,
CommandOutput<K,V,T> output)
Dispatch a command to the Redis Server.
|
<T> RedisFuture<T> |
RedisSentinelAsyncCommands.dispatch(ProtocolKeyword type,
CommandOutput<K,V,T> output,
CommandArgs<K,V> args)
Dispatch a command to the Redis Server.
|
RedisFuture<String> |
RedisSentinelAsyncCommands.failover(K key)
Perform a failover.
|
RedisFuture<SocketAddress> |
RedisSentinelAsyncCommands.getMasterAddrByName(K key)
Return the ip and port number of the master with that name.
|
RedisFuture<String> |
RedisSentinelAsyncCommands.info()
Get information and statistics about the server.
|
RedisFuture<String> |
RedisSentinelAsyncCommands.info(String section)
Get information and statistics about the server.
|
RedisFuture<Map<K,V>> |
RedisSentinelAsyncCommands.master(K key)
Show the state and info of the specified master.
|
RedisFuture<List<Map<K,V>>> |
RedisSentinelAsyncCommands.masters()
Enumerates all the monitored masters and their states.
|
RedisFuture<String> |
RedisSentinelAsyncCommands.monitor(K key,
String ip,
int port,
int quorum)
This command tells the Sentinel to start monitoring a new master with the specified name, ip, port, and quorum.
|
RedisFuture<String> |
RedisSentinelAsyncCommands.ping()
Ping the server.
|
RedisFuture<String> |
RedisSentinelAsyncCommands.remove(K key)
remove the specified master.
|
RedisFuture<Long> |
RedisSentinelAsyncCommands.reset(K key)
This command will reset all the masters with matching name.
|
RedisFuture<String> |
RedisSentinelAsyncCommands.set(K key,
String option,
V value)
Multiple option / value pairs can be specified (or none at all).
|
RedisFuture<List<Map<K,V>>> |
RedisSentinelAsyncCommands.slaves(K key)
Provides a list of replicas for the master with the specified name.
|
Copyright © 2021 lettuce.io. All rights reserved.