Package redis.clients.jedis.commands

Interface BinaryRedisPipeline

All Known Implementing Classes:

MultiKeyPipelineBase, Pipeline, PipelineBase, ShardedJedisPipeline, Transaction

public interface BinaryRedisPipeline

Method Summary

Modifier and Type	Method	Description
Response<Long>	append(byte[] key, byte[] value)
Response<Long>	bitcount(byte[] key)
Response<Long>	bitcount(byte[] key, long start, long end)
Response<List<Long>>	bitfield(byte[] key, byte[]... elements)
Response<List<Long>>	bitfieldReadonly(byte[] key, byte[]... elements)
Response<Long>	bitpos(byte[] key, boolean value)
Response<Long>	bitpos(byte[] key, boolean value, BitPosParams params)
Response<List<byte[]>>	blpop(byte[] arg)
Response<List<byte[]>>	brpop(byte[] arg)
Response<Long>	decr(byte[] key)
Response<Long>	decrBy(byte[] key, long decrement)
Response<Long>	del(byte[] keys)
Response<byte[]>	dump(byte[] key)
Response<byte[]>	echo(byte[] string)
Response<Boolean>	exists(byte[] key)
Response<Long>	expire(byte[] key, int seconds)
Response<Long>	expireAt(byte[] key, long unixTime)
Response<Long>	geoadd(byte[] key, double longitude, double latitude, byte[] member)
Response<Long>	geoadd(byte[] key, Map<byte[],GeoCoordinate> memberCoordinateMap)
Response<Double>	geodist(byte[] key, byte[] member1, byte[] member2)
Response<Double>	geodist(byte[] key, byte[] member1, byte[] member2, GeoUnit unit)
Response<List<byte[]>>	geohash(byte[] key, byte[]... members)
Response<List<GeoCoordinate>>	geopos(byte[] key, byte[]... members)
Response<List<GeoRadiusResponse>>	georadius(byte[] key, double longitude, double latitude, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	georadius(byte[] key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param)
Response<List<GeoRadiusResponse>>	georadiusByMember(byte[] key, byte[] member, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	georadiusByMember(byte[] key, byte[] member, double radius, GeoUnit unit, GeoRadiusParam param)
Response<List<GeoRadiusResponse>>	georadiusByMemberReadonly(byte[] key, byte[] member, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	georadiusByMemberReadonly(byte[] key, byte[] member, double radius, GeoUnit unit, GeoRadiusParam param)
Response<List<GeoRadiusResponse>>	georadiusReadonly(byte[] key, double longitude, double latitude, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	georadiusReadonly(byte[] key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param)
Response<byte[]>	get(byte[] key)
Response<Boolean>	getbit(byte[] key, long offset)
Response<byte[]>	getrange(byte[] key, long startOffset, long endOffset)
Response<byte[]>	getSet(byte[] key, byte[] value)
Response<Long>	hdel(byte[] key, byte[]... field)
Response<Boolean>	hexists(byte[] key, byte[] field)
Response<byte[]>	hget(byte[] key, byte[] field)
Response<Map<byte[],byte[]>>	hgetAll(byte[] key)
Response<Long>	hincrBy(byte[] key, byte[] field, long value)
Response<Double>	hincrByFloat(byte[] key, byte[] field, double increment)
Response<Set<byte[]>>	hkeys(byte[] key)
Response<Long>	hlen(byte[] key)
Response<List<byte[]>>	hmget(byte[] key, byte[]... fields)
Response<String>	hmset(byte[] key, Map<byte[],byte[]> hash)
Response<Long>	hset(byte[] key, byte[] field, byte[] value)
Response<Long>	hset(byte[] key, Map<byte[],byte[]> hash)
Response<Long>	hsetnx(byte[] key, byte[] field, byte[] value)
Response<Long>	hstrlen(byte[] key, byte[] field)
Response<List<byte[]>>	hvals(byte[] key)
Response<Long>	incr(byte[] key)
Response<Long>	incrBy(byte[] key, long increment)
Response<Double>	incrByFloat(byte[] key, double increment)
Response<byte[]>	lindex(byte[] key, long index)
Response<Long>	linsert(byte[] key, ListPosition where, byte[] pivot, byte[] value)
Response<Long>	llen(byte[] key)
Response<byte[]>	lpop(byte[] key)
Response<List<byte[]>>	lpop(byte[] key, int count)
Response<Long>	lpos(byte[] key, byte[] element)
Response<Long>	lpos(byte[] key, byte[] element, LPosParams params)
Response<List<Long>>	lpos(byte[] key, byte[] element, LPosParams params, long count)
Response<Long>	lpush(byte[] key, byte[]... string)
Response<Long>	lpushx(byte[] key, byte[]... bytes)
Response<List<byte[]>>	lrange(byte[] key, long start, long stop)
Response<Long>	lrem(byte[] key, long count, byte[] value)
Response<String>	lset(byte[] key, long index, byte[] value)
Response<String>	ltrim(byte[] key, long start, long stop)
Response<String>	migrate(String host, int port, byte[] key, int destinationDB, int timeout)
Response<Long>	move(byte[] key, int dbIndex)
Response<byte[]>	objectEncoding(byte[] key)
Response<Long>	objectFreq(byte[] key)
Response<Long>	objectIdletime(byte[] key)
Response<Long>	objectRefcount(byte[] key)
Response<Long>	persist(byte[] key)
Response<Long>	pexpire(byte[] key, long milliseconds)
Response<Long>	pexpireAt(byte[] key, long millisecondsTimestamp)
Response<Long>	pfadd(byte[] key, byte[]... elements)
Response<Long>	pfcount(byte[] key)
Response<String>	psetex(byte[] key, long milliseconds, byte[] value)
Response<Long>	pttl(byte[] key)
Response<String>	restore(byte[] key, int ttl, byte[] serializedValue)
Response<String>	restoreReplace(byte[] key, int ttl, byte[] serializedValue)
Response<byte[]>	rpop(byte[] key)
Response<List<byte[]>>	rpop(byte[] key, int count)
Response<Long>	rpush(byte[] key, byte[]... string)
Response<Long>	rpushx(byte[] key, byte[]... string)
Response<Long>	sadd(byte[] key, byte[]... member)
Response<Long>	scard(byte[] key)
Response<String>	set(byte[] key, byte[] value)
Response<String>	set(byte[] key, byte[] value, SetParams params)
Response<Boolean>	setbit(byte[] key, long offset, byte[] value)
Response<String>	setex(byte[] key, int seconds, byte[] value)
Response<Long>	setnx(byte[] key, byte[] value)
Response<Long>	setrange(byte[] key, long offset, byte[] value)
Response<Long>	setrange(String key, long offset, String value)
Response<Boolean>	sismember(byte[] key, byte[] member)
Response<Set<byte[]>>	smembers(byte[] key)
Response<List<Boolean>>	smismember(byte[] key, byte[]... members)
Response<List<byte[]>>	sort(byte[] key)
Response<List<byte[]>>	sort(byte[] key, SortingParams sortingParameters)
Response<byte[]>	spop(byte[] key)
Response<Set<byte[]>>	spop(byte[] key, long count)
Response<byte[]>	srandmember(byte[] key)
Response<List<byte[]>>	srandmember(byte[] key, int count)
Response<Long>	srem(byte[] key, byte[]... member)
Response<Long>	strlen(byte[] key)
Response<String>	substr(byte[] key, int start, int end)
Response<Long>	touch(byte[] keys)
Response<Long>	ttl(byte[] key)
Response<String>	type(byte[] key)
Response<Long>	unlink(byte[] keys)
Response<Long>	xack(byte[] key, byte[] group, byte[]... ids)
Response<byte[]>	xadd(byte[] key, byte[] id, Map<byte[],byte[]> hash)
Response<byte[]>	xadd(byte[] key, byte[] id, Map<byte[],byte[]> hash, long maxLen, boolean approximateLength)
Response<List<byte[]>>	xclaim(byte[] key, byte[] group, byte[] consumername, long minIdleTime, long newIdleTime, int retries, boolean force, byte[]... ids)
Response<Long>	xdel(byte[] key, byte[]... ids)
Response<String>	xgroupCreate(byte[] key, byte[] groupname, byte[] id, boolean makeStream)
Response<Long>	xgroupDelConsumer(byte[] key, byte[] groupname, byte[] consumername)
Response<Long>	xgroupDestroy(byte[] key, byte[] groupname)
Response<String>	xgroupSetID(byte[] key, byte[] groupname, byte[] id)
Response<Long>	xlen(byte[] key)
Response<List<StreamPendingEntry>>	xpending(byte[] key, byte[] groupname, byte[] start, byte[] end, int count, byte[] consumername)
Response<List<byte[]>>	xrange(byte[] key, byte[] start, byte[] end, int count)
Response<List<byte[]>>	xrevrange(byte[] key, byte[] end, byte[] start, int count)
Response<Long>	xtrim(byte[] key, long maxLen, boolean approximateLength)
Response<Long>	zadd(byte[] key, double score, byte[] member)
Response<Long>	zadd(byte[] key, double score, byte[] member, ZAddParams params)
Response<Long>	zadd(byte[] key, Map<byte[],Double> scoreMembers)
Response<Long>	zadd(byte[] key, Map<byte[],Double> scoreMembers, ZAddParams params)
Response<Long>	zcard(byte[] key)
Response<Long>	zcount(byte[] key, byte[] min, byte[] max)
Response<Long>	zcount(byte[] key, double min, double max)
Response<Double>	zincrby(byte[] key, double increment, byte[] member)
Response<Double>	zincrby(byte[] key, double increment, byte[] member, ZIncrByParams params)
Response<Long>	zlexcount(byte[] key, byte[] min, byte[] max)
Response<List<Double>>	zmscore(byte[] key, byte[]... members)
Response<Tuple>	zpopmax(byte[] key)
Response<Set<Tuple>>	zpopmax(byte[] key, int count)
Response<Tuple>	zpopmin(byte[] key)
Response<Set<Tuple>>	zpopmin(byte[] key, int count)
Response<Set<byte[]>>	zrange(byte[] key, long start, long stop)
Response<Set<byte[]>>	zrangeByLex(byte[] key, byte[] min, byte[] max)
Response<Set<byte[]>>	zrangeByLex(byte[] key, byte[] min, byte[] max, int offset, int count)
Response<Set<byte[]>>	zrangeByScore(byte[] key, byte[] min, byte[] max)
Response<Set<byte[]>>	zrangeByScore(byte[] key, byte[] min, byte[] max, int offset, int count)
Response<Set<byte[]>>	zrangeByScore(byte[] key, double min, double max)
Response<Set<byte[]>>	zrangeByScore(byte[] key, double min, double max, int offset, int count)
Response<Set<Tuple>>	zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max)
Response<Set<Tuple>>	zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max, int offset, int count)
Response<Set<Tuple>>	zrangeByScoreWithScores(byte[] key, double min, double max)
Response<Set<Tuple>>	zrangeByScoreWithScores(byte[] key, double min, double max, int offset, int count)
Response<Set<Tuple>>	zrangeWithScores(byte[] key, long start, long stop)
Response<Long>	zrank(byte[] key, byte[] member)
Response<Long>	zrem(byte[] key, byte[]... members)
Response<Long>	zremrangeByLex(byte[] key, byte[] min, byte[] max)
Response<Long>	zremrangeByRank(byte[] key, long start, long stop)
Response<Long>	zremrangeByScore(byte[] key, byte[] min, byte[] max)
Response<Long>	zremrangeByScore(byte[] key, double min, double max)
Response<Set<byte[]>>	zrevrange(byte[] key, long start, long stop)
Response<Set<byte[]>>	zrevrangeByLex(byte[] key, byte[] max, byte[] min)
Response<Set<byte[]>>	zrevrangeByLex(byte[] key, byte[] max, byte[] min, int offset, int count)
Response<Set<byte[]>>	zrevrangeByScore(byte[] key, byte[] max, byte[] min)
Response<Set<byte[]>>	zrevrangeByScore(byte[] key, byte[] max, byte[] min, int offset, int count)
Response<Set<byte[]>>	zrevrangeByScore(byte[] key, double max, double min)
Response<Set<byte[]>>	zrevrangeByScore(byte[] key, double max, double min, int offset, int count)
Response<Set<Tuple>>	zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min)
Response<Set<Tuple>>	zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min, int offset, int count)
Response<Set<Tuple>>	zrevrangeByScoreWithScores(byte[] key, double max, double min)
Response<Set<Tuple>>	zrevrangeByScoreWithScores(byte[] key, double max, double min, int offset, int count)
Response<Set<Tuple>>	zrevrangeWithScores(byte[] key, long start, long stop)
Response<Long>	zrevrank(byte[] key, byte[] member)
Response<Double>	zscore(byte[] key, byte[] member)

Method Detail

append

Response<Long> append(byte[] key,
                      byte[] value)

blpop

Response<List<byte[]>> blpop(byte[] arg)

brpop

Response<List<byte[]>> brpop(byte[] arg)

decr

Response<Long> decr(byte[] key)

decrBy

Response<Long> decrBy(byte[] key,
                      long decrement)

del

Response<Long> del(byte[] keys)

unlink

Response<Long> unlink(byte[] keys)

echo

Response<byte[]> echo(byte[] string)

exists

Response<Boolean> exists(byte[] key)

expire

Response<Long> expire(byte[] key,
                      int seconds)

pexpire

Response<Long> pexpire(byte[] key,
                       long milliseconds)

expireAt

Response<Long> expireAt(byte[] key,
                        long unixTime)

pexpireAt

Response<Long> pexpireAt(byte[] key,
                         long millisecondsTimestamp)

get

Response<byte[]> get(byte[] key)

getbit

Response<Boolean> getbit(byte[] key,
                         long offset)

getSet

Response<byte[]> getSet(byte[] key,
                        byte[] value)

getrange

Response<byte[]> getrange(byte[] key,
                          long startOffset,
                          long endOffset)

hdel

Response<Long> hdel(byte[] key,
                    byte[]... field)

hexists

Response<Boolean> hexists(byte[] key,
                          byte[] field)

hget

Response<byte[]> hget(byte[] key,
                      byte[] field)

hgetAll

Response<Map<byte[],byte[]>> hgetAll(byte[] key)

hincrBy

Response<Long> hincrBy(byte[] key,
                       byte[] field,
                       long value)

hkeys

Response<Set<byte[]>> hkeys(byte[] key)

hlen

Response<Long> hlen(byte[] key)

hmget

Response<List<byte[]>> hmget(byte[] key,
                             byte[]... fields)

hmset

Response<String> hmset(byte[] key,
                       Map<byte[],byte[]> hash)

hset

Response<Long> hset(byte[] key,
                    byte[] field,
                    byte[] value)

hset

Response<Long> hset(byte[] key,
                    Map<byte[],byte[]> hash)

hsetnx

Response<Long> hsetnx(byte[] key,
                      byte[] field,
                      byte[] value)

hvals

Response<List<byte[]>> hvals(byte[] key)

incr

Response<Long> incr(byte[] key)

incrBy

Response<Long> incrBy(byte[] key,
                      long increment)

lindex

Response<byte[]> lindex(byte[] key,
                        long index)

linsert

Response<Long> linsert(byte[] key,
                       ListPosition where,
                       byte[] pivot,
                       byte[] value)

llen

Response<Long> llen(byte[] key)

lpop

Response<byte[]> lpop(byte[] key)

lpop

Response<List<byte[]>> lpop(byte[] key,
                            int count)

lpos

Response<Long> lpos(byte[] key,
                    byte[] element)

lpos

Response<Long> lpos(byte[] key,
                    byte[] element,
                    LPosParams params)

lpos

Response<List<Long>> lpos(byte[] key,
                          byte[] element,
                          LPosParams params,
                          long count)

lpush

Response<Long> lpush(byte[] key,
                     byte[]... string)

lpushx

Response<Long> lpushx(byte[] key,
                      byte[]... bytes)

lrange

Response<List<byte[]>> lrange(byte[] key,
                              long start,
                              long stop)

lrem

Response<Long> lrem(byte[] key,
                    long count,
                    byte[] value)

lset

Response<String> lset(byte[] key,
                      long index,
                      byte[] value)

ltrim

Response<String> ltrim(byte[] key,
                       long start,
                       long stop)

move

Response<Long> move(byte[] key,
                    int dbIndex)

persist

Response<Long> persist(byte[] key)

rpop

Response<byte[]> rpop(byte[] key)

rpop

Response<List<byte[]>> rpop(byte[] key,
                            int count)

rpush

Response<Long> rpush(byte[] key,
                     byte[]... string)

rpushx

Response<Long> rpushx(byte[] key,
                      byte[]... string)

sadd

Response<Long> sadd(byte[] key,
                    byte[]... member)

scard

Response<Long> scard(byte[] key)

set

Response<String> set(byte[] key,
                     byte[] value)

setbit

Response<Boolean> setbit(byte[] key,
                         long offset,
                         byte[] value)

setrange

Response<Long> setrange(byte[] key,
                        long offset,
                        byte[] value)

setex

Response<String> setex(byte[] key,
                       int seconds,
                       byte[] value)

setnx

Response<Long> setnx(byte[] key,
                     byte[] value)

setrange

Response<Long> setrange(String key,
                        long offset,
                        String value)

smembers

Response<Set<byte[]>> smembers(byte[] key)

sismember

Response<Boolean> sismember(byte[] key,
                            byte[] member)

smismember

Response<List<Boolean>> smismember(byte[] key,
                                   byte[]... members)

sort

Response<List<byte[]>> sort(byte[] key)

sort

Response<List<byte[]>> sort(byte[] key,
                            SortingParams sortingParameters)

spop

Response<byte[]> spop(byte[] key)

spop

Response<Set<byte[]>> spop(byte[] key,
                           long count)

srandmember

Response<byte[]> srandmember(byte[] key)

srem

Response<Long> srem(byte[] key,
                    byte[]... member)

strlen

Response<Long> strlen(byte[] key)

substr

Response<String> substr(byte[] key,
                        int start,
                        int end)

touch

Response<Long> touch(byte[] keys)

ttl

Response<Long> ttl(byte[] key)

pttl

Response<Long> pttl(byte[] key)

type

Response<String> type(byte[] key)

zadd

Response<Long> zadd(byte[] key,
                    double score,
                    byte[] member)

zadd

Response<Long> zadd(byte[] key,
                    double score,
                    byte[] member,
                    ZAddParams params)

zadd

Response<Long> zadd(byte[] key,
                    Map<byte[],Double> scoreMembers)

zadd

Response<Long> zadd(byte[] key,
                    Map<byte[],Double> scoreMembers,
                    ZAddParams params)

zcard

Response<Long> zcard(byte[] key)

zcount

Response<Long> zcount(byte[] key,
                      double min,
                      double max)

zcount

Response<Long> zcount(byte[] key,
                      byte[] min,
                      byte[] max)

zincrby

Response<Double> zincrby(byte[] key,
                         double increment,
                         byte[] member)

zincrby

Response<Double> zincrby(byte[] key,
                         double increment,
                         byte[] member,
                         ZIncrByParams params)

zrange

Response<Set<byte[]>> zrange(byte[] key,
                             long start,
                             long stop)

zrangeByScore

Response<Set<byte[]>> zrangeByScore(byte[] key,
                                    double min,
                                    double max)

zrangeByScore

Response<Set<byte[]>> zrangeByScore(byte[] key,
                                    byte[] min,
                                    byte[] max)

zrangeByScore

Response<Set<byte[]>> zrangeByScore(byte[] key,
                                    double min,
                                    double max,
                                    int offset,
                                    int count)

zrangeByScore

Response<Set<byte[]>> zrangeByScore(byte[] key,
                                    byte[] min,
                                    byte[] max,
                                    int offset,
                                    int count)

zrangeByScoreWithScores

Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key,
                                             double min,
                                             double max)

zrangeByScoreWithScores

Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key,
                                             byte[] min,
                                             byte[] max)

zrangeByScoreWithScores

Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key,
                                             double min,
                                             double max,
                                             int offset,
                                             int count)

zrangeByScoreWithScores

Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key,
                                             byte[] min,
                                             byte[] max,
                                             int offset,
                                             int count)

zrevrangeByScore

Response<Set<byte[]>> zrevrangeByScore(byte[] key,
                                       double max,
                                       double min)

zrevrangeByScore

Response<Set<byte[]>> zrevrangeByScore(byte[] key,
                                       byte[] max,
                                       byte[] min)

zrevrangeByScore

Response<Set<byte[]>> zrevrangeByScore(byte[] key,
                                       double max,
                                       double min,
                                       int offset,
                                       int count)

zrevrangeByScore

Response<Set<byte[]>> zrevrangeByScore(byte[] key,
                                       byte[] max,
                                       byte[] min,
                                       int offset,
                                       int count)

zrevrangeByScoreWithScores

Response<Set<Tuple>> zrevrangeByScoreWithScores(byte[] key,
                                                double max,
                                                double min)

zrevrangeByScoreWithScores

Response<Set<Tuple>> zrevrangeByScoreWithScores(byte[] key,
                                                byte[] max,
                                                byte[] min)

zrevrangeByScoreWithScores

Response<Set<Tuple>> zrevrangeByScoreWithScores(byte[] key,
                                                double max,
                                                double min,
                                                int offset,
                                                int count)

zrevrangeByScoreWithScores

Response<Set<Tuple>> zrevrangeByScoreWithScores(byte[] key,
                                                byte[] max,
                                                byte[] min,
                                                int offset,
                                                int count)

zrangeWithScores

Response<Set<Tuple>> zrangeWithScores(byte[] key,
                                      long start,
                                      long stop)

zrank

Response<Long> zrank(byte[] key,
                     byte[] member)

zrem

Response<Long> zrem(byte[] key,
                    byte[]... members)

zremrangeByRank

Response<Long> zremrangeByRank(byte[] key,
                               long start,
                               long stop)

zremrangeByScore

Response<Long> zremrangeByScore(byte[] key,
                                double min,
                                double max)

zremrangeByScore

Response<Long> zremrangeByScore(byte[] key,
                                byte[] min,
                                byte[] max)

zrevrange

Response<Set<byte[]>> zrevrange(byte[] key,
                                long start,
                                long stop)

zrevrangeWithScores

Response<Set<Tuple>> zrevrangeWithScores(byte[] key,
                                         long start,
                                         long stop)

zrevrank

Response<Long> zrevrank(byte[] key,
                        byte[] member)

zscore

Response<Double> zscore(byte[] key,
                        byte[] member)

zmscore

Response<List<Double>> zmscore(byte[] key,
                               byte[]... members)

zpopmax

Response<Tuple> zpopmax(byte[] key)

zpopmax

Response<Set<Tuple>> zpopmax(byte[] key,
                             int count)

zpopmin

Response<Tuple> zpopmin(byte[] key)

zpopmin

Response<Set<Tuple>> zpopmin(byte[] key,
                             int count)

zlexcount

Response<Long> zlexcount(byte[] key,
                         byte[] min,
                         byte[] max)

zrangeByLex

Response<Set<byte[]>> zrangeByLex(byte[] key,
                                  byte[] min,
                                  byte[] max)

zrangeByLex

Response<Set<byte[]>> zrangeByLex(byte[] key,
                                  byte[] min,
                                  byte[] max,
                                  int offset,
                                  int count)

zrevrangeByLex

Response<Set<byte[]>> zrevrangeByLex(byte[] key,
                                     byte[] max,
                                     byte[] min)

zrevrangeByLex

Response<Set<byte[]>> zrevrangeByLex(byte[] key,
                                     byte[] max,
                                     byte[] min,
                                     int offset,
                                     int count)

zremrangeByLex

Response<Long> zremrangeByLex(byte[] key,
                              byte[] min,
                              byte[] max)

bitcount

Response<Long> bitcount(byte[] key)

bitcount

Response<Long> bitcount(byte[] key,
                        long start,
                        long end)

pfadd

Response<Long> pfadd(byte[] key,
                     byte[]... elements)

pfcount

Response<Long> pfcount(byte[] key)

dump

Response<byte[]> dump(byte[] key)

restore

Response<String> restore(byte[] key,
                         int ttl,
                         byte[] serializedValue)

restoreReplace

Response<String> restoreReplace(byte[] key,
                                int ttl,
                                byte[] serializedValue)

migrate

Response<String> migrate(String host,
                         int port,
                         byte[] key,
                         int destinationDB,
                         int timeout)

geoadd

Response<Long> geoadd(byte[] key,
                      double longitude,
                      double latitude,
                      byte[] member)

geoadd

Response<Long> geoadd(byte[] key,
                      Map<byte[],GeoCoordinate> memberCoordinateMap)

geodist

Response<Double> geodist(byte[] key,
                         byte[] member1,
                         byte[] member2)

geodist

Response<Double> geodist(byte[] key,
                         byte[] member1,
                         byte[] member2,
                         GeoUnit unit)

geohash

Response<List<byte[]>> geohash(byte[] key,
                               byte[]... members)

geopos

Response<List<GeoCoordinate>> geopos(byte[] key,
                                     byte[]... members)

georadius

Response<List<GeoRadiusResponse>> georadius(byte[] key,
                                            double longitude,
                                            double latitude,
                                            double radius,
                                            GeoUnit unit)

georadiusReadonly

Response<List<GeoRadiusResponse>> georadiusReadonly(byte[] key,
                                                    double longitude,
                                                    double latitude,
                                                    double radius,
                                                    GeoUnit unit)

georadius

Response<List<GeoRadiusResponse>> georadius(byte[] key,
                                            double longitude,
                                            double latitude,
                                            double radius,
                                            GeoUnit unit,
                                            GeoRadiusParam param)

georadiusReadonly

Response<List<GeoRadiusResponse>> georadiusReadonly(byte[] key,
                                                    double longitude,
                                                    double latitude,
                                                    double radius,
                                                    GeoUnit unit,
                                                    GeoRadiusParam param)

georadiusByMember

Response<List<GeoRadiusResponse>> georadiusByMember(byte[] key,
                                                    byte[] member,
                                                    double radius,
                                                    GeoUnit unit)

georadiusByMemberReadonly

Response<List<GeoRadiusResponse>> georadiusByMemberReadonly(byte[] key,
                                                            byte[] member,
                                                            double radius,
                                                            GeoUnit unit)

georadiusByMember

Response<List<GeoRadiusResponse>> georadiusByMember(byte[] key,
                                                    byte[] member,
                                                    double radius,
                                                    GeoUnit unit,
                                                    GeoRadiusParam param)

georadiusByMemberReadonly

Response<List<GeoRadiusResponse>> georadiusByMemberReadonly(byte[] key,
                                                            byte[] member,
                                                            double radius,
                                                            GeoUnit unit,
                                                            GeoRadiusParam param)

bitfield

Response<List<Long>> bitfield(byte[] key,
                              byte[]... elements)

bitfieldReadonly

Response<List<Long>> bitfieldReadonly(byte[] key,
                                      byte[]... elements)

hstrlen

Response<Long> hstrlen(byte[] key,
                       byte[] field)

xadd

Response<byte[]> xadd(byte[] key,
                      byte[] id,
                      Map<byte[],byte[]> hash)

xadd

Response<byte[]> xadd(byte[] key,
                      byte[] id,
                      Map<byte[],byte[]> hash,
                      long maxLen,
                      boolean approximateLength)

xlen

Response<Long> xlen(byte[] key)

xrange

Response<List<byte[]>> xrange(byte[] key,
                              byte[] start,
                              byte[] end,
                              int count)

xrevrange

Response<List<byte[]>> xrevrange(byte[] key,
                                 byte[] end,
                                 byte[] start,
                                 int count)

xack

Response<Long> xack(byte[] key,
                    byte[] group,
                    byte[]... ids)

xgroupCreate

Response<String> xgroupCreate(byte[] key,
                              byte[] groupname,
                              byte[] id,
                              boolean makeStream)

xgroupSetID

Response<String> xgroupSetID(byte[] key,
                             byte[] groupname,
                             byte[] id)

xgroupDestroy

Response<Long> xgroupDestroy(byte[] key,
                             byte[] groupname)

xgroupDelConsumer

Response<Long> xgroupDelConsumer(byte[] key,
                                 byte[] groupname,
                                 byte[] consumername)

xpending

Response<List<StreamPendingEntry>> xpending(byte[] key,
                                            byte[] groupname,
                                            byte[] start,
                                            byte[] end,
                                            int count,
                                            byte[] consumername)

xdel

Response<Long> xdel(byte[] key,
                    byte[]... ids)

xtrim

Response<Long> xtrim(byte[] key,
                     long maxLen,
                     boolean approximateLength)

xclaim

Response<List<byte[]>> xclaim(byte[] key,
                              byte[] group,
                              byte[] consumername,
                              long minIdleTime,
                              long newIdleTime,
                              int retries,
                              boolean force,
                              byte[]... ids)

bitpos

Response<Long> bitpos(byte[] key,
                      boolean value)

bitpos

Response<Long> bitpos(byte[] key,
                      boolean value,
                      BitPosParams params)

set

Response<String> set(byte[] key,
                     byte[] value,
                     SetParams params)

srandmember

Response<List<byte[]>> srandmember(byte[] key,
                                   int count)

objectRefcount

Response<Long> objectRefcount(byte[] key)

objectEncoding

Response<byte[]> objectEncoding(byte[] key)

objectIdletime

Response<Long> objectIdletime(byte[] key)

objectFreq

Response<Long> objectFreq(byte[] key)

incrByFloat

Response<Double> incrByFloat(byte[] key,
                             double increment)

psetex

Response<String> psetex(byte[] key,
                        long milliseconds,
                        byte[] value)

hincrByFloat

Response<Double> hincrByFloat(byte[] key,
                              byte[] field,
                              double increment)