Package redis.clients.jedis

Class PipelineBase

java.lang.Object

redis.clients.jedis.Queable

redis.clients.jedis.PipelineBase

All Implemented Interfaces:

BinaryRedisPipeline, RedisPipeline

Direct Known Subclasses:

MultiKeyPipelineBase, ShardedJedisPipeline

public abstract class PipelineBase
extends Queable
implements BinaryRedisPipeline, RedisPipeline

Constructor Summary

Constructors

Constructor	Description
PipelineBase()

Method Summary

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

Methods inherited from class redis.clients.jedis.Queable

clean, generateResponse, getPipelinedResponseLength, getResponse, hasPipelinedResponse

Methods inherited from class java.lang.Object

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

Constructor Detail

PipelineBase

public PipelineBase()

Method Detail

getClient

protected abstract Client getClient(String key)

getClient

protected abstract Client getClient(byte[] key)

append

public Response<Long> append(String key,
                             String value)

Specified by:

append in interface RedisPipeline

append

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

Specified by:

append in interface BinaryRedisPipeline

blpop

public Response<List<String>> blpop(String key)

Specified by:

blpop in interface RedisPipeline

brpop

public Response<List<String>> brpop(String key)

Specified by:

brpop in interface RedisPipeline

blpop

public Response<List<byte[]>> blpop(byte[] key)

Specified by:

blpop in interface BinaryRedisPipeline

brpop

public Response<List<byte[]>> brpop(byte[] key)

Specified by:

brpop in interface BinaryRedisPipeline

decr

public Response<Long> decr(String key)

Specified by:

decr in interface RedisPipeline

decr

public Response<Long> decr(byte[] key)

Specified by:

decr in interface BinaryRedisPipeline

decrBy

public Response<Long> decrBy(String key,
                             long decrement)

Specified by:

decrBy in interface RedisPipeline

decrBy

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

Specified by:

decrBy in interface BinaryRedisPipeline

del

public Response<Long> del(String key)

Specified by:

del in interface RedisPipeline

del

public Response<Long> del(byte[] key)

Specified by:

del in interface BinaryRedisPipeline

unlink

public Response<Long> unlink(String key)

Specified by:

unlink in interface RedisPipeline

unlink

public Response<Long> unlink(byte[] key)

Specified by:

unlink in interface BinaryRedisPipeline

echo

public Response<String> echo(String string)

Specified by:

echo in interface RedisPipeline

echo

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

Specified by:

echo in interface BinaryRedisPipeline

exists

public Response<Boolean> exists(String key)

Specified by:

exists in interface RedisPipeline

exists

public Response<Boolean> exists(byte[] key)

Specified by:

exists in interface BinaryRedisPipeline

expire

public Response<Long> expire(String key,
                             int seconds)

Specified by:

expire in interface RedisPipeline

expire

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

Specified by:

expire in interface BinaryRedisPipeline

expireAt

public Response<Long> expireAt(String key,
                               long unixTime)

Specified by:

expireAt in interface RedisPipeline

expireAt

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

Specified by:

expireAt in interface BinaryRedisPipeline

get

public Response<String> get(String key)

Specified by:

get in interface RedisPipeline

get

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

Specified by:

get in interface BinaryRedisPipeline

getbit

public Response<Boolean> getbit(String key,
                                long offset)

Specified by:

getbit in interface RedisPipeline

getbit

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

Specified by:

getbit in interface BinaryRedisPipeline

bitpos

public Response<Long> bitpos(String key,
                             boolean value)

Specified by:

bitpos in interface RedisPipeline

bitpos

public Response<Long> bitpos(String key,
                             boolean value,
                             BitPosParams params)

Specified by:

bitpos in interface RedisPipeline

bitpos

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

Specified by:

bitpos in interface BinaryRedisPipeline

bitpos

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

Specified by:

bitpos in interface BinaryRedisPipeline

getrange

public Response<String> getrange(String key,
                                 long startOffset,
                                 long endOffset)

Specified by:

getrange in interface RedisPipeline

getSet

public Response<String> getSet(String key,
                               String value)

Specified by:

getSet in interface RedisPipeline

getSet

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

Specified by:

getSet in interface BinaryRedisPipeline

getrange

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

Specified by:

getrange in interface BinaryRedisPipeline

hdel

public Response<Long> hdel(String key,
                           String... field)

Specified by:

hdel in interface RedisPipeline

hdel

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

Specified by:

hdel in interface BinaryRedisPipeline

hexists

public Response<Boolean> hexists(String key,
                                 String field)

Specified by:

hexists in interface RedisPipeline

hexists

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

Specified by:

hexists in interface BinaryRedisPipeline

hget

public Response<String> hget(String key,
                             String field)

Specified by:

hget in interface RedisPipeline

hget

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

Specified by:

hget in interface BinaryRedisPipeline

hgetAll

public Response<Map<String,String>> hgetAll(String key)

Specified by:

hgetAll in interface RedisPipeline

hgetAll

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

Specified by:

hgetAll in interface BinaryRedisPipeline

hincrBy

public Response<Long> hincrBy(String key,
                              String field,
                              long value)

Specified by:

hincrBy in interface RedisPipeline

hincrBy

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

Specified by:

hincrBy in interface BinaryRedisPipeline

hkeys

public Response<Set<String>> hkeys(String key)

Specified by:

hkeys in interface RedisPipeline

hkeys

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

Specified by:

hkeys in interface BinaryRedisPipeline

hlen

public Response<Long> hlen(String key)

Specified by:

hlen in interface RedisPipeline

hlen

public Response<Long> hlen(byte[] key)

Specified by:

hlen in interface BinaryRedisPipeline

hmget

public Response<List<String>> hmget(String key,
                                    String... fields)

Specified by:

hmget in interface RedisPipeline

hmget

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

Specified by:

hmget in interface BinaryRedisPipeline

hmset

public Response<String> hmset(String key,
                              Map<String,String> hash)

Specified by:

hmset in interface RedisPipeline

hmset

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

Specified by:

hmset in interface BinaryRedisPipeline

hset

public Response<Long> hset(String key,
                           String field,
                           String value)

Specified by:

hset in interface RedisPipeline

hset

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

Specified by:

hset in interface BinaryRedisPipeline

hset

public Response<Long> hset(String key,
                           Map<String,String> hash)

Specified by:

hset in interface RedisPipeline

hset

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

Specified by:

hset in interface BinaryRedisPipeline

hsetnx

public Response<Long> hsetnx(String key,
                             String field,
                             String value)

Specified by:

hsetnx in interface RedisPipeline

hsetnx

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

Specified by:

hsetnx in interface BinaryRedisPipeline

hvals

public Response<List<String>> hvals(String key)

Specified by:

hvals in interface RedisPipeline

hvals

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

Specified by:

hvals in interface BinaryRedisPipeline

incr

public Response<Long> incr(String key)

Specified by:

incr in interface RedisPipeline

incr

public Response<Long> incr(byte[] key)

Specified by:

incr in interface BinaryRedisPipeline

incrBy

public Response<Long> incrBy(String key,
                             long increment)

Specified by:

incrBy in interface RedisPipeline

incrBy

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

Specified by:

incrBy in interface BinaryRedisPipeline

lindex

public Response<String> lindex(String key,
                               long index)

Specified by:

lindex in interface RedisPipeline

lindex

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

Specified by:

lindex in interface BinaryRedisPipeline

linsert

public Response<Long> linsert(String key,
                              ListPosition where,
                              String pivot,
                              String value)

Specified by:

linsert in interface RedisPipeline

linsert

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

Specified by:

linsert in interface BinaryRedisPipeline

llen

public Response<Long> llen(String key)

Specified by:

llen in interface RedisPipeline

llen

public Response<Long> llen(byte[] key)

Specified by:

llen in interface BinaryRedisPipeline

lpop

public Response<String> lpop(String key)

Specified by:

lpop in interface RedisPipeline

lpop

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

Specified by:

lpop in interface BinaryRedisPipeline

lpos

public Response<Long> lpos(String key,
                           String element)

Specified by:

lpos in interface RedisPipeline

lpos

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

Specified by:

lpos in interface BinaryRedisPipeline

lpos

public Response<Long> lpos(String key,
                           String element,
                           LPosParams params)

Specified by:

lpos in interface RedisPipeline

lpos

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

Specified by:

lpos in interface BinaryRedisPipeline

lpos

public Response<List<Long>> lpos(String key,
                                 String element,
                                 LPosParams params,
                                 long count)

Specified by:

lpos in interface RedisPipeline

lpos

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

Specified by:

lpos in interface BinaryRedisPipeline

lpush

public Response<Long> lpush(String key,
                            String... string)

Specified by:

lpush in interface RedisPipeline

lpush

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

Specified by:

lpush in interface BinaryRedisPipeline

lpushx

public Response<Long> lpushx(String key,
                             String... string)

Specified by:

lpushx in interface RedisPipeline

lpushx

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

Specified by:

lpushx in interface BinaryRedisPipeline

lrange

public Response<List<String>> lrange(String key,
                                     long start,
                                     long stop)

Specified by:

lrange in interface RedisPipeline

lrange

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

Specified by:

lrange in interface BinaryRedisPipeline

lrem

public Response<Long> lrem(String key,
                           long count,
                           String value)

Specified by:

lrem in interface RedisPipeline

lrem

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

Specified by:

lrem in interface BinaryRedisPipeline

lset

public Response<String> lset(String key,
                             long index,
                             String value)

Specified by:

lset in interface RedisPipeline

lset

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

Specified by:

lset in interface BinaryRedisPipeline

ltrim

public Response<String> ltrim(String key,
                              long start,
                              long stop)

Specified by:

ltrim in interface RedisPipeline

ltrim

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

Specified by:

ltrim in interface BinaryRedisPipeline

move

public Response<Long> move(String key,
                           int dbIndex)

Specified by:

move in interface RedisPipeline

move

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

Specified by:

move in interface BinaryRedisPipeline

persist

public Response<Long> persist(String key)

Specified by:

persist in interface RedisPipeline

persist

public Response<Long> persist(byte[] key)

Specified by:

persist in interface BinaryRedisPipeline

rpop

public Response<String> rpop(String key)

Specified by:

rpop in interface RedisPipeline

rpop

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

Specified by:

rpop in interface BinaryRedisPipeline

rpush

public Response<Long> rpush(String key,
                            String... string)

Specified by:

rpush in interface RedisPipeline

rpush

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

Specified by:

rpush in interface BinaryRedisPipeline

rpushx

public Response<Long> rpushx(String key,
                             String... string)

Specified by:

rpushx in interface RedisPipeline

rpushx

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

Specified by:

rpushx in interface BinaryRedisPipeline

sadd

public Response<Long> sadd(String key,
                           String... member)

Specified by:

sadd in interface RedisPipeline

sadd

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

Specified by:

sadd in interface BinaryRedisPipeline

scard

public Response<Long> scard(String key)

Specified by:

scard in interface RedisPipeline

scard

public Response<Long> scard(byte[] key)

Specified by:

scard in interface BinaryRedisPipeline

set

public Response<String> set(String key,
                            String value)

Specified by:

set in interface RedisPipeline

set

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

Specified by:

set in interface BinaryRedisPipeline

set

public Response<String> set(String key,
                            String value,
                            SetParams params)

Specified by:

set in interface RedisPipeline

set

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

Specified by:

set in interface BinaryRedisPipeline

setbit

public Response<Boolean> setbit(String key,
                                long offset,
                                boolean value)

Specified by:

setbit in interface RedisPipeline

setbit

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

Specified by:

setbit in interface BinaryRedisPipeline

setex

public Response<String> setex(String key,
                              int seconds,
                              String value)

Specified by:

setex in interface RedisPipeline

setex

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

Specified by:

setex in interface BinaryRedisPipeline

setnx

public Response<Long> setnx(String key,
                            String value)

Specified by:

setnx in interface RedisPipeline

setnx

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

Specified by:

setnx in interface BinaryRedisPipeline

setrange

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

Specified by:

setrange in interface BinaryRedisPipeline

Specified by:

setrange in interface RedisPipeline

setrange

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

Specified by:

setrange in interface BinaryRedisPipeline

sismember

public Response<Boolean> sismember(String key,
                                   String member)

Specified by:

sismember in interface RedisPipeline

smismember

public Response<List<Boolean>> smismember(String key,
                                          String... members)

Specified by:

smismember in interface RedisPipeline

sismember

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

Specified by:

sismember in interface BinaryRedisPipeline

smismember

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

Specified by:

smismember in interface BinaryRedisPipeline

smembers

public Response<Set<String>> smembers(String key)

Specified by:

smembers in interface RedisPipeline

smembers

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

Specified by:

smembers in interface BinaryRedisPipeline

sort

public Response<List<String>> sort(String key)

Specified by:

sort in interface RedisPipeline

sort

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

Specified by:

sort in interface BinaryRedisPipeline

sort

public Response<List<String>> sort(String key,
                                   SortingParams sortingParameters)

Specified by:

sort in interface RedisPipeline

sort

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

Specified by:

sort in interface BinaryRedisPipeline

spop

public Response<String> spop(String key)

Specified by:

spop in interface RedisPipeline

spop

public Response<Set<String>> spop(String key,
                                  long count)

Specified by:

spop in interface RedisPipeline

spop

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

Specified by:

spop in interface BinaryRedisPipeline

spop

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

Specified by:

spop in interface BinaryRedisPipeline

srandmember

public Response<String> srandmember(String key)

Specified by:

srandmember in interface RedisPipeline

srandmember

public Response<List<String>> srandmember(String key,
                                          int count)

Specified by:

srandmember in interface RedisPipeline

srandmember

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

Specified by:

srandmember in interface BinaryRedisPipeline

srandmember

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

Specified by:

srandmember in interface BinaryRedisPipeline

srem

public Response<Long> srem(String key,
                           String... member)

Specified by:

srem in interface RedisPipeline

srem

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

Specified by:

srem in interface BinaryRedisPipeline

strlen

public Response<Long> strlen(String key)

Specified by:

strlen in interface RedisPipeline

strlen

public Response<Long> strlen(byte[] key)

Specified by:

strlen in interface BinaryRedisPipeline

substr

public Response<String> substr(String key,
                               int start,
                               int end)

Specified by:

substr in interface RedisPipeline

substr

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

Specified by:

substr in interface BinaryRedisPipeline

touch

public Response<Long> touch(String key)

Specified by:

touch in interface RedisPipeline

touch

public Response<Long> touch(byte[] key)

Specified by:

touch in interface BinaryRedisPipeline

ttl

public Response<Long> ttl(String key)

Specified by:

ttl in interface RedisPipeline

ttl

public Response<Long> ttl(byte[] key)

Specified by:

ttl in interface BinaryRedisPipeline

type

public Response<String> type(String key)

Specified by:

type in interface RedisPipeline

type

public Response<String> type(byte[] key)

Specified by:

type in interface BinaryRedisPipeline

zadd

public Response<Long> zadd(String key,
                           double score,
                           String member)

Specified by:

zadd in interface RedisPipeline

zadd

public Response<Long> zadd(String key,
                           double score,
                           String member,
                           ZAddParams params)

Specified by:

zadd in interface RedisPipeline

zadd

public Response<Long> zadd(String key,
                           Map<String,Double> scoreMembers)

Specified by:

zadd in interface RedisPipeline

zadd

public Response<Long> zadd(String key,
                           Map<String,Double> scoreMembers,
                           ZAddParams params)

Specified by:

zadd in interface RedisPipeline

zadd

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

Specified by:

zadd in interface BinaryRedisPipeline

zadd

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

Specified by:

zadd in interface BinaryRedisPipeline

zadd

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

Specified by:

zadd in interface BinaryRedisPipeline

zadd

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

Specified by:

zadd in interface BinaryRedisPipeline

zcard

public Response<Long> zcard(String key)

Specified by:

zcard in interface RedisPipeline

zcard

public Response<Long> zcard(byte[] key)

Specified by:

zcard in interface BinaryRedisPipeline

zcount

public Response<Long> zcount(String key,
                             double min,
                             double max)

Specified by:

zcount in interface RedisPipeline

zcount

public Response<Long> zcount(String key,
                             String min,
                             String max)

Specified by:

zcount in interface RedisPipeline

zcount

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

Specified by:

zcount in interface BinaryRedisPipeline

zcount

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

Specified by:

zcount in interface BinaryRedisPipeline

zincrby

public Response<Double> zincrby(String key,
                                double increment,
                                String member)

Specified by:

zincrby in interface RedisPipeline

zincrby

public Response<Double> zincrby(String key,
                                double increment,
                                String member,
                                ZIncrByParams params)

Specified by:

zincrby in interface RedisPipeline

zincrby

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

Specified by:

zincrby in interface BinaryRedisPipeline

zincrby

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

Specified by:

zincrby in interface BinaryRedisPipeline

zrange

public Response<Set<String>> zrange(String key,
                                    long start,
                                    long stop)

Specified by:

zrange in interface RedisPipeline

zrange

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

Specified by:

zrange in interface BinaryRedisPipeline

zrangeByScore

public Response<Set<String>> zrangeByScore(String key,
                                           double min,
                                           double max)

Specified by:

zrangeByScore in interface RedisPipeline

zrangeByScore

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

Specified by:

zrangeByScore in interface BinaryRedisPipeline

zrangeByScore

public Response<Set<String>> zrangeByScore(String key,
                                           String min,
                                           String max)

Specified by:

zrangeByScore in interface RedisPipeline

zrangeByScore

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

Specified by:

zrangeByScore in interface BinaryRedisPipeline

zrangeByScore

public Response<Set<String>> zrangeByScore(String key,
                                           double min,
                                           double max,
                                           int offset,
                                           int count)

Specified by:

zrangeByScore in interface RedisPipeline

zrangeByScore

public Response<Set<String>> zrangeByScore(String key,
                                           String min,
                                           String max,
                                           int offset,
                                           int count)

Specified by:

zrangeByScore in interface RedisPipeline

zrangeByScore

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

Specified by:

zrangeByScore in interface BinaryRedisPipeline

zrangeByScore

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

Specified by:

zrangeByScore in interface BinaryRedisPipeline

zrangeByScoreWithScores

public Response<Set<Tuple>> zrangeByScoreWithScores(String key,
                                                    double min,
                                                    double max)

Specified by:

zrangeByScoreWithScores in interface RedisPipeline

zrangeByScoreWithScores

public Response<Set<Tuple>> zrangeByScoreWithScores(String key,
                                                    String min,
                                                    String max)

Specified by:

zrangeByScoreWithScores in interface RedisPipeline

zrangeByScoreWithScores

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

Specified by:

zrangeByScoreWithScores in interface BinaryRedisPipeline

zrangeByScoreWithScores

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

Specified by:

zrangeByScoreWithScores in interface BinaryRedisPipeline

zrangeByScoreWithScores

public Response<Set<Tuple>> zrangeByScoreWithScores(String key,
                                                    double min,
                                                    double max,
                                                    int offset,
                                                    int count)

Specified by:

zrangeByScoreWithScores in interface RedisPipeline

zrangeByScoreWithScores

public Response<Set<Tuple>> zrangeByScoreWithScores(String key,
                                                    String min,
                                                    String max,
                                                    int offset,
                                                    int count)

Specified by:

zrangeByScoreWithScores in interface RedisPipeline

zrangeByScoreWithScores

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

Specified by:

zrangeByScoreWithScores in interface BinaryRedisPipeline

zrangeByScoreWithScores

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

Specified by:

zrangeByScoreWithScores in interface BinaryRedisPipeline

zrevrangeByScore

public Response<Set<String>> zrevrangeByScore(String key,
                                              double max,
                                              double min)

Specified by:

zrevrangeByScore in interface RedisPipeline

zrevrangeByScore

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

Specified by:

zrevrangeByScore in interface BinaryRedisPipeline

zrevrangeByScore

public Response<Set<String>> zrevrangeByScore(String key,
                                              String max,
                                              String min)

Specified by:

zrevrangeByScore in interface RedisPipeline

zrevrangeByScore

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

Specified by:

zrevrangeByScore in interface BinaryRedisPipeline

zrevrangeByScore

public Response<Set<String>> zrevrangeByScore(String key,
                                              double max,
                                              double min,
                                              int offset,
                                              int count)

Specified by:

zrevrangeByScore in interface RedisPipeline

zrevrangeByScore

public Response<Set<String>> zrevrangeByScore(String key,
                                              String max,
                                              String min,
                                              int offset,
                                              int count)

Specified by:

zrevrangeByScore in interface RedisPipeline

zrevrangeByScore

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

Specified by:

zrevrangeByScore in interface BinaryRedisPipeline

zrevrangeByScore

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

Specified by:

zrevrangeByScore in interface BinaryRedisPipeline

zrevrangeByScoreWithScores

public Response<Set<Tuple>> zrevrangeByScoreWithScores(String key,
                                                       double max,
                                                       double min)

Specified by:

zrevrangeByScoreWithScores in interface RedisPipeline

zrevrangeByScoreWithScores

public Response<Set<Tuple>> zrevrangeByScoreWithScores(String key,
                                                       String max,
                                                       String min)

Specified by:

zrevrangeByScoreWithScores in interface RedisPipeline

zrevrangeByScoreWithScores

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

Specified by:

zrevrangeByScoreWithScores in interface BinaryRedisPipeline

zrevrangeByScoreWithScores

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

Specified by:

zrevrangeByScoreWithScores in interface BinaryRedisPipeline

zrevrangeByScoreWithScores

public Response<Set<Tuple>> zrevrangeByScoreWithScores(String key,
                                                       double max,
                                                       double min,
                                                       int offset,
                                                       int count)

Specified by:

zrevrangeByScoreWithScores in interface RedisPipeline

zrevrangeByScoreWithScores

public Response<Set<Tuple>> zrevrangeByScoreWithScores(String key,
                                                       String max,
                                                       String min,
                                                       int offset,
                                                       int count)

Specified by:

zrevrangeByScoreWithScores in interface RedisPipeline

zrevrangeByScoreWithScores

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

Specified by:

zrevrangeByScoreWithScores in interface BinaryRedisPipeline

zrevrangeByScoreWithScores

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

Specified by:

zrevrangeByScoreWithScores in interface BinaryRedisPipeline

zrangeWithScores

public Response<Set<Tuple>> zrangeWithScores(String key,
                                             long start,
                                             long stop)

Specified by:

zrangeWithScores in interface RedisPipeline

zrangeWithScores

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

Specified by:

zrangeWithScores in interface BinaryRedisPipeline

zrank

public Response<Long> zrank(String key,
                            String member)

Specified by:

zrank in interface RedisPipeline

zrank

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

Specified by:

zrank in interface BinaryRedisPipeline

zrem

public Response<Long> zrem(String key,
                           String... members)

Specified by:

zrem in interface RedisPipeline

zrem

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

Specified by:

zrem in interface BinaryRedisPipeline

zremrangeByRank

public Response<Long> zremrangeByRank(String key,
                                      long start,
                                      long stop)

Specified by:

zremrangeByRank in interface RedisPipeline

zremrangeByRank

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

Specified by:

zremrangeByRank in interface BinaryRedisPipeline

zremrangeByScore

public Response<Long> zremrangeByScore(String key,
                                       double min,
                                       double max)

Specified by:

zremrangeByScore in interface RedisPipeline

zremrangeByScore

public Response<Long> zremrangeByScore(String key,
                                       String min,
                                       String max)

Specified by:

zremrangeByScore in interface RedisPipeline

zremrangeByScore

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

Specified by:

zremrangeByScore in interface BinaryRedisPipeline

zremrangeByScore

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

Specified by:

zremrangeByScore in interface BinaryRedisPipeline

zrevrange

public Response<Set<String>> zrevrange(String key,
                                       long start,
                                       long stop)

Specified by:

zrevrange in interface RedisPipeline

zrevrange

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

Specified by:

zrevrange in interface BinaryRedisPipeline

zrevrangeWithScores

public Response<Set<Tuple>> zrevrangeWithScores(String key,
                                                long start,
                                                long stop)

Specified by:

zrevrangeWithScores in interface RedisPipeline

zrevrangeWithScores

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

Specified by:

zrevrangeWithScores in interface BinaryRedisPipeline

zrevrank

public Response<Long> zrevrank(String key,
                               String member)

Specified by:

zrevrank in interface RedisPipeline

zrevrank

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

Specified by:

zrevrank in interface BinaryRedisPipeline

zscore

public Response<Double> zscore(String key,
                               String member)

Specified by:

zscore in interface RedisPipeline

zmscore

public Response<List<Double>> zmscore(String key,
                                      String... members)

Specified by:

zmscore in interface RedisPipeline

zscore

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

Specified by:

zscore in interface BinaryRedisPipeline

zmscore

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

Specified by:

zmscore in interface BinaryRedisPipeline

zpopmax

public Response<Tuple> zpopmax(String key)

Specified by:

zpopmax in interface RedisPipeline

zpopmax

public Response<Tuple> zpopmax(byte[] key)

Specified by:

zpopmax in interface BinaryRedisPipeline

zpopmax

public Response<Set<Tuple>> zpopmax(String key,
                                    int count)

Specified by:

zpopmax in interface RedisPipeline

zpopmax

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

Specified by:

zpopmax in interface BinaryRedisPipeline

zpopmin

public Response<Tuple> zpopmin(String key)

Specified by:

zpopmin in interface RedisPipeline

zpopmin

public Response<Tuple> zpopmin(byte[] key)

Specified by:

zpopmin in interface BinaryRedisPipeline

zpopmin

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

Specified by:

zpopmin in interface BinaryRedisPipeline

zpopmin

public Response<Set<Tuple>> zpopmin(String key,
                                    int count)

Specified by:

zpopmin in interface RedisPipeline

zlexcount

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

Specified by:

zlexcount in interface BinaryRedisPipeline

zlexcount

public Response<Long> zlexcount(String key,
                                String min,
                                String max)

Specified by:

zlexcount in interface RedisPipeline

zrangeByLex

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

Specified by:

zrangeByLex in interface BinaryRedisPipeline

zrangeByLex

public Response<Set<String>> zrangeByLex(String key,
                                         String min,
                                         String max)

Specified by:

zrangeByLex in interface RedisPipeline

zrangeByLex

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

Specified by:

zrangeByLex in interface BinaryRedisPipeline

zrangeByLex

public Response<Set<String>> zrangeByLex(String key,
                                         String min,
                                         String max,
                                         int offset,
                                         int count)

Specified by:

zrangeByLex in interface RedisPipeline

zrevrangeByLex

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

Specified by:

zrevrangeByLex in interface BinaryRedisPipeline

zrevrangeByLex

public Response<Set<String>> zrevrangeByLex(String key,
                                            String max,
                                            String min)

Specified by:

zrevrangeByLex in interface RedisPipeline

zrevrangeByLex

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

Specified by:

zrevrangeByLex in interface BinaryRedisPipeline

zrevrangeByLex

public Response<Set<String>> zrevrangeByLex(String key,
                                            String max,
                                            String min,
                                            int offset,
                                            int count)

Specified by:

zrevrangeByLex in interface RedisPipeline

zremrangeByLex

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

Specified by:

zremrangeByLex in interface BinaryRedisPipeline

zremrangeByLex

public Response<Long> zremrangeByLex(String key,
                                     String min,
                                     String max)

Specified by:

zremrangeByLex in interface RedisPipeline

bitcount

public Response<Long> bitcount(String key)

Specified by:

bitcount in interface RedisPipeline

bitcount

public Response<Long> bitcount(String key,
                               long start,
                               long end)

Specified by:

bitcount in interface RedisPipeline

bitcount

public Response<Long> bitcount(byte[] key)

Specified by:

bitcount in interface BinaryRedisPipeline

bitcount

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

Specified by:

bitcount in interface BinaryRedisPipeline

dump

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

Specified by:

dump in interface RedisPipeline

dump

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

Specified by:

dump in interface BinaryRedisPipeline

migrate

public Response<String> migrate(String host,
                                int port,
                                String key,
                                int destinationDb,
                                int timeout)

Specified by:

migrate in interface RedisPipeline

migrate

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

Specified by:

migrate in interface BinaryRedisPipeline

objectRefcount

public Response<Long> objectRefcount(String key)

Specified by:

objectRefcount in interface RedisPipeline

objectRefcount

public Response<Long> objectRefcount(byte[] key)

Specified by:

objectRefcount in interface BinaryRedisPipeline

objectEncoding

public Response<String> objectEncoding(String key)

Specified by:

objectEncoding in interface RedisPipeline

objectEncoding

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

Specified by:

objectEncoding in interface BinaryRedisPipeline

objectIdletime

public Response<Long> objectIdletime(String key)

Specified by:

objectIdletime in interface RedisPipeline

objectIdletime

public Response<Long> objectIdletime(byte[] key)

Specified by:

objectIdletime in interface BinaryRedisPipeline

objectFreq

public Response<Long> objectFreq(byte[] key)

Specified by:

objectFreq in interface BinaryRedisPipeline

objectFreq

public Response<Long> objectFreq(String key)

Specified by:

objectFreq in interface RedisPipeline

pexpire

public Response<Long> pexpire(String key,
                              long milliseconds)

Specified by:

pexpire in interface RedisPipeline

pexpire

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

Specified by:

pexpire in interface BinaryRedisPipeline

pexpireAt

public Response<Long> pexpireAt(String key,
                                long millisecondsTimestamp)

Specified by:

pexpireAt in interface RedisPipeline

pexpireAt

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

Specified by:

pexpireAt in interface BinaryRedisPipeline

pttl

public Response<Long> pttl(String key)

Specified by:

pttl in interface RedisPipeline

pttl

public Response<Long> pttl(byte[] key)

Specified by:

pttl in interface BinaryRedisPipeline

restore

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

Specified by:

restore in interface RedisPipeline

restore

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

Specified by:

restore in interface BinaryRedisPipeline

restoreReplace

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

Specified by:

restoreReplace in interface RedisPipeline

restoreReplace

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

Specified by:

restoreReplace in interface BinaryRedisPipeline

incrByFloat

public Response<Double> incrByFloat(String key,
                                    double increment)

Specified by:

incrByFloat in interface RedisPipeline

incrByFloat

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

Specified by:

incrByFloat in interface BinaryRedisPipeline

psetex

public Response<String> psetex(String key,
                               long milliseconds,
                               String value)

Specified by:

psetex in interface RedisPipeline

psetex

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

Specified by:

psetex in interface BinaryRedisPipeline

hincrByFloat

public Response<Double> hincrByFloat(String key,
                                     String field,
                                     double increment)

Specified by:

hincrByFloat in interface RedisPipeline

hincrByFloat

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

Specified by:

hincrByFloat in interface BinaryRedisPipeline

pfadd

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

Specified by:

pfadd in interface BinaryRedisPipeline

pfcount

public Response<Long> pfcount(byte[] key)

Specified by:

pfcount in interface BinaryRedisPipeline

pfadd

public Response<Long> pfadd(String key,
                            String... elements)

Specified by:

pfadd in interface RedisPipeline

pfcount

public Response<Long> pfcount(String key)

Specified by:

pfcount in interface RedisPipeline

geoadd

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

Specified by:

geoadd in interface BinaryRedisPipeline

geoadd

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

Specified by:

geoadd in interface BinaryRedisPipeline

geoadd

public Response<Long> geoadd(String key,
                             double longitude,
                             double latitude,
                             String member)

Specified by:

geoadd in interface RedisPipeline

geoadd

public Response<Long> geoadd(String key,
                             Map<String,GeoCoordinate> memberCoordinateMap)

Specified by:

geoadd in interface RedisPipeline

geodist

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

Specified by:

geodist in interface BinaryRedisPipeline

geodist

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

Specified by:

geodist in interface BinaryRedisPipeline

geodist

public Response<Double> geodist(String key,
                                String member1,
                                String member2)

Specified by:

geodist in interface RedisPipeline

geodist

public Response<Double> geodist(String key,
                                String member1,
                                String member2,
                                GeoUnit unit)

Specified by:

geodist in interface RedisPipeline

geohash

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

Specified by:

geohash in interface BinaryRedisPipeline

geohash

public Response<List<String>> geohash(String key,
                                      String... members)

Specified by:

geohash in interface RedisPipeline

geopos

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

Specified by:

geopos in interface BinaryRedisPipeline

geopos

public Response<List<GeoCoordinate>> geopos(String key,
                                            String... members)

Specified by:

geopos in interface RedisPipeline

georadius

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

Specified by:

georadius in interface BinaryRedisPipeline

georadiusReadonly

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

Specified by:

georadiusReadonly in interface BinaryRedisPipeline

georadius

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

Specified by:

georadius in interface BinaryRedisPipeline

georadiusReadonly

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

Specified by:

georadiusReadonly in interface BinaryRedisPipeline

georadius

public Response<List<GeoRadiusResponse>> georadius(String key,
                                                   double longitude,
                                                   double latitude,
                                                   double radius,
                                                   GeoUnit unit)

Specified by:

georadius in interface RedisPipeline

georadiusReadonly

public Response<List<GeoRadiusResponse>> georadiusReadonly(String key,
                                                           double longitude,
                                                           double latitude,
                                                           double radius,
                                                           GeoUnit unit)

Specified by:

georadiusReadonly in interface RedisPipeline

georadius

public Response<List<GeoRadiusResponse>> georadius(String key,
                                                   double longitude,
                                                   double latitude,
                                                   double radius,
                                                   GeoUnit unit,
                                                   GeoRadiusParam param)

Specified by:

georadius in interface RedisPipeline

georadiusReadonly

public Response<List<GeoRadiusResponse>> georadiusReadonly(String key,
                                                           double longitude,
                                                           double latitude,
                                                           double radius,
                                                           GeoUnit unit,
                                                           GeoRadiusParam param)

Specified by:

georadiusReadonly in interface RedisPipeline

georadiusByMember

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

Specified by:

georadiusByMember in interface BinaryRedisPipeline

georadiusByMemberReadonly

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

Specified by:

georadiusByMemberReadonly in interface BinaryRedisPipeline

georadiusByMember

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

Specified by:

georadiusByMember in interface BinaryRedisPipeline

georadiusByMemberReadonly

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

Specified by:

georadiusByMemberReadonly in interface BinaryRedisPipeline

georadiusByMember

public Response<List<GeoRadiusResponse>> georadiusByMember(String key,
                                                           String member,
                                                           double radius,
                                                           GeoUnit unit)

Specified by:

georadiusByMember in interface RedisPipeline

georadiusByMemberReadonly

public Response<List<GeoRadiusResponse>> georadiusByMemberReadonly(String key,
                                                                   String member,
                                                                   double radius,
                                                                   GeoUnit unit)

Specified by:

georadiusByMemberReadonly in interface RedisPipeline

georadiusByMember

public Response<List<GeoRadiusResponse>> georadiusByMember(String key,
                                                           String member,
                                                           double radius,
                                                           GeoUnit unit,
                                                           GeoRadiusParam param)

Specified by:

georadiusByMember in interface RedisPipeline

georadiusByMemberReadonly

public Response<List<GeoRadiusResponse>> georadiusByMemberReadonly(String key,
                                                                   String member,
                                                                   double radius,
                                                                   GeoUnit unit,
                                                                   GeoRadiusParam param)

Specified by:

georadiusByMemberReadonly in interface RedisPipeline

bitfield

public Response<List<Long>> bitfield(String key,
                                     String... elements)

Specified by:

bitfield in interface RedisPipeline

bitfield

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

Specified by:

bitfield in interface BinaryRedisPipeline

bitfieldReadonly

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

Specified by:

bitfieldReadonly in interface BinaryRedisPipeline

bitfieldReadonly

public Response<List<Long>> bitfieldReadonly(String key,
                                             String... arguments)

Specified by:

bitfieldReadonly in interface RedisPipeline

hstrlen

public Response<Long> hstrlen(String key,
                              String field)

Specified by:

hstrlen in interface RedisPipeline

hstrlen

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

Specified by:

hstrlen in interface BinaryRedisPipeline

xadd

public Response<StreamEntryID> xadd(String key,
                                    StreamEntryID id,
                                    Map<String,String> hash)

Specified by:

xadd in interface RedisPipeline

xadd

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

Specified by:

xadd in interface BinaryRedisPipeline

xadd

public Response<StreamEntryID> xadd(String key,
                                    StreamEntryID id,
                                    Map<String,String> hash,
                                    long maxLen,
                                    boolean approximateLength)

Specified by:

xadd in interface RedisPipeline

xadd

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

Specified by:

xadd in interface BinaryRedisPipeline

xlen

public Response<Long> xlen(String key)

Specified by:

xlen in interface RedisPipeline

xlen

public Response<Long> xlen(byte[] key)

Specified by:

xlen in interface BinaryRedisPipeline

xrange

public Response<List<StreamEntry>> xrange(String key,
                                          StreamEntryID start,
                                          StreamEntryID end,
                                          int count)

Specified by:

xrange in interface RedisPipeline

xrange

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

Specified by:

xrange in interface BinaryRedisPipeline

xrevrange

public Response<List<StreamEntry>> xrevrange(String key,
                                             StreamEntryID end,
                                             StreamEntryID start,
                                             int count)

Specified by:

xrevrange in interface RedisPipeline

xrevrange

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

Specified by:

xrevrange in interface BinaryRedisPipeline

xack

public Response<Long> xack(String key,
                           String group,
                           StreamEntryID... ids)

Specified by:

xack in interface RedisPipeline

xack

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

Specified by:

xack in interface BinaryRedisPipeline

xgroupCreate

public Response<String> xgroupCreate(String key,
                                     String groupname,
                                     StreamEntryID id,
                                     boolean makeStream)

Specified by:

xgroupCreate in interface RedisPipeline

xgroupCreate

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

Specified by:

xgroupCreate in interface BinaryRedisPipeline

xgroupSetID

public Response<String> xgroupSetID(String key,
                                    String groupname,
                                    StreamEntryID id)

Specified by:

xgroupSetID in interface RedisPipeline

xgroupSetID

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

Specified by:

xgroupSetID in interface BinaryRedisPipeline

xgroupDestroy

public Response<Long> xgroupDestroy(String key,
                                    String groupname)

Specified by:

xgroupDestroy in interface RedisPipeline

xgroupDestroy

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

Specified by:

xgroupDestroy in interface BinaryRedisPipeline

xgroupDelConsumer

public Response<Long> xgroupDelConsumer(String key,
                                        String groupname,
                                        String consumername)

Specified by:

xgroupDelConsumer in interface RedisPipeline

xgroupDelConsumer

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

Specified by:

xgroupDelConsumer in interface BinaryRedisPipeline

xpending

public Response<List<StreamPendingEntry>> xpending(String key,
                                                   String groupname,
                                                   StreamEntryID start,
                                                   StreamEntryID end,
                                                   int count,
                                                   String consumername)

Specified by:

xpending in interface RedisPipeline

xpending

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

Specified by:

xpending in interface BinaryRedisPipeline

xdel

public Response<Long> xdel(String key,
                           StreamEntryID... ids)

Specified by:

xdel in interface RedisPipeline

xdel

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

Specified by:

xdel in interface BinaryRedisPipeline

xtrim

public Response<Long> xtrim(String key,
                            long maxLen,
                            boolean approximateLength)

Specified by:

xtrim in interface RedisPipeline

xtrim

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

Specified by:

xtrim in interface BinaryRedisPipeline

xclaim

public Response<List<StreamEntry>> xclaim(String key,
                                          String group,
                                          String consumername,
                                          long minIdleTime,
                                          long newIdleTime,
                                          int retries,
                                          boolean force,
                                          StreamEntryID... ids)

Specified by:

xclaim in interface RedisPipeline

xclaim

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

Specified by:

xclaim in interface BinaryRedisPipeline

sendCommand

public Response<Object> sendCommand(String sampleKey,
                                    ProtocolCommand cmd,
                                    String... args)

sendCommand

public Response<Object> sendCommand(byte[] sampleKey,
                                    ProtocolCommand cmd,
                                    byte[]... args)