redis.clients.jedis
Class ShardedJedisPipeline

java.lang.Object
  redis.clients.jedis.Queable
      redis.clients.jedis.ShardedJedisPipeline

All Implemented Interfaces:

BinaryRedisPipeline, RedisPipeline

public class ShardedJedisPipeline
extends Queable

Constructor Summary

ShardedJedisPipeline()

Method Summary

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<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 integer)
Response<Long>	decrBy(String key, long integer)
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<String>	eval(String script)
Response<String>	eval(String script, int numKeys, String[] argv)
Response<String>	eval(String script, List<String> keys, List<String> args)
Response<String>	evalsha(String script)
Response<String>	evalsha(String sha1, int numKeys, String[] argv)
Response<String>	evalsha(String sha1, List<String> keys, List<String> args)
void	execute() Deprecated.
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<byte[]>	get(byte[] key)
Response<String>	get(String key)
Response<Boolean>	getbit(byte[] key, long offset)
Response<Boolean>	getbit(String key, long offset)
protected Client	getClient(byte[] key)
protected Client	getClient(String key)
Response<Long>	getrange(byte[] key, long startOffset, long endOffset)
Response<String>	getrange(String key, long startOffset, long endOffset)
List<Object>	getResults()
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(String key, String field, String value)
Response<Long>	hsetnx(byte[] key, byte[] field, byte[] value)
Response<Long>	hsetnx(String key, String field, String value)
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 integer)
Response<Long>	incrBy(String key, long integer)
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, BinaryClient.LIST_POSITION where, byte[] pivot, byte[] value)
Response<Long>	linsert(String key, BinaryClient.LIST_POSITION 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>	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 end)
Response<List<String>>	lrange(String key, long start, long end)
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 end)
Response<String>	ltrim(String key, long start, long end)
Response<String>	migrate(byte[] 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>	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, int milliseconds) Deprecated.
Response<Long>	pexpire(byte[] key, long milliseconds)
Response<Long>	pexpire(String key, int milliseconds) Deprecated.
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, int milliseconds, byte[] value)
Response<String>	psetex(String key, int 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<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<String>	set(byte[] key, byte[] value)
Response<String>	set(byte[] key, byte[] value, byte[] nxxx)
Response<String>	set(byte[] key, byte[] value, byte[] nxxx, byte[] expx, int time)
Response<String>	set(String key, String value)
Response<String>	set(String key, String value, String nxxx)
Response<String>	set(String key, String value, String nxxx, String expx, int time)
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)
void	setShardedJedis(BinaryShardedJedis jedis)
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<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<String>	spop(String key)
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)
void	sync() Syncronize pipeline by reading all responses.
List<Object>	syncAndReturnAll() Syncronize pipeline by reading all responses.
Response<Long>	ttl(byte[] key)
Response<Long>	ttl(String key)
Response<String>	type(byte[] key)
Response<String>	type(String key)
Response<Long>	zadd(byte[] key, double score, byte[] member)
Response<Long>	zadd(String key, double score, String member)
Response<Long>	zadd(String key, Map<String,Double> scoreMembers)
Response<Long>	zcard(byte[] key)
Response<Long>	zcard(String key)
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 score, byte[] member)
Response<Double>	zincrby(String key, double score, String member)
Response<Long>	zlexcount(byte[] key, byte[] min, byte[] max)
Response<Long>	zlexcount(String key, String min, String max)
Response<Set<byte[]>>	zrange(byte[] key, long start, long end)
Response<Set<String>>	zrange(String key, long start, long end)
Response<Set<byte[]>>	zrangeByLex(byte[] key, byte[] max, byte[] min)
Response<Set<byte[]>>	zrangeByLex(byte[] key, byte[] max, byte[] min, int offset, int count)
Response<Set<String>>	zrangeByLex(String key, String max, String min)
Response<Set<String>>	zrangeByLex(String key, String max, String min, 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 end)
Response<Set<Tuple>>	zrangeWithScores(String key, long start, long end)
Response<Long>	zrank(byte[] key, byte[] member)
Response<Long>	zrank(String key, String member)
Response<Long>	zrem(byte[] key, byte[]... member)
Response<Long>	zrem(String key, String... member)
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 end)
Response<Long>	zremrangeByRank(String key, long start, long end)
Response<Long>	zremrangeByScore(byte[] key, byte[] start, byte[] end)
Response<Long>	zremrangeByScore(byte[] key, double start, double end)
Response<Long>	zremrangeByScore(String key, double start, double end)
Response<Long>	zremrangeByScore(String key, String start, String end)
Response<Set<byte[]>>	zrevrange(byte[] key, long start, long end)
Response<Set<String>>	zrevrange(String key, long start, long end)
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 end)
Response<Set<Tuple>>	zrevrangeWithScores(String key, long start, long end)
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, getResponse

Methods inherited from class java.lang.Object

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

Constructor Detail

ShardedJedisPipeline

public ShardedJedisPipeline()

Method Detail

setShardedJedis

public void setShardedJedis(BinaryShardedJedis jedis)

getResults

public List<Object> getResults()

sync

public void sync()

Syncronize pipeline by reading all responses. This operation closes the pipeline. In order to get return values from pipelined commands, capture the different Response<?> of the commands you execute.

syncAndReturnAll

public List<Object> syncAndReturnAll()

Syncronize pipeline by reading all responses. This operation closes the pipeline. Whenever possible try to avoid using this version and use ShardedJedisPipeline.sync() as it won't go through all the responses and generate the right response type (usually it is a waste of time).

Returns:

A list of all the responses in the order you executed them.

execute

@Deprecated
public void execute()

Deprecated.

This method will be removed in Jedis 3.0. Use the methods that return Response's and call sync().

getClient

protected Client getClient(String key)

getClient

protected 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 integer)

Specified by:

decrBy in interface RedisPipeline

decrBy

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

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

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)

bitpos

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

bitpos

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

bitpos

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

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<Long> 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

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 integer)

Specified by:

incrBy in interface RedisPipeline

incrBy

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

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,
                              BinaryClient.LIST_POSITION where,
                              String pivot,
                              String value)

Specified by:

linsert in interface RedisPipeline

linsert

public Response<Long> linsert(byte[] key,
                              BinaryClient.LIST_POSITION 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

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 end)

Specified by:

lrange in interface RedisPipeline

lrange

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

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 end)

Specified by:

ltrim in interface RedisPipeline

ltrim

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

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

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

sismember

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

Specified by:

sismember 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<byte[]> spop(byte[] key)

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)

srandmember

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

Specified by:

srandmember in interface BinaryRedisPipeline

srandmember

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

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

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,
                           Map<String,Double> scoreMembers)

zadd

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

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)

zcount

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

Specified by:

zcount in interface BinaryRedisPipeline

zincrby

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

Specified by:

zincrby in interface RedisPipeline

zincrby

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

Specified by:

zincrby in interface BinaryRedisPipeline

zrange

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

Specified by:

zrange in interface RedisPipeline

zrange

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

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)

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)

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)

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)

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)

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)

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 end)

Specified by:

zrangeWithScores in interface RedisPipeline

zrangeWithScores

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

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... member)

Specified by:

zrem in interface RedisPipeline

zrem

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

Specified by:

zrem in interface BinaryRedisPipeline

zremrangeByRank

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

Specified by:

zremrangeByRank in interface RedisPipeline

zremrangeByRank

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

Specified by:

zremrangeByRank in interface BinaryRedisPipeline

zremrangeByScore

public Response<Long> zremrangeByScore(String key,
                                       double start,
                                       double end)

Specified by:

zremrangeByScore in interface RedisPipeline

zremrangeByScore

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

zremrangeByScore

public Response<Long> zremrangeByScore(byte[] key,
                                       double start,
                                       double end)

Specified by:

zremrangeByScore in interface BinaryRedisPipeline

zremrangeByScore

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

Specified by:

zremrangeByScore in interface BinaryRedisPipeline

zrevrange

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

Specified by:

zrevrange in interface RedisPipeline

zrevrange

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

Specified by:

zrevrange in interface BinaryRedisPipeline

zrevrangeWithScores

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

Specified by:

zrevrangeWithScores in interface RedisPipeline

zrevrangeWithScores

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

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

zscore

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

Specified by:

zscore in interface BinaryRedisPipeline

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[] max,
                                         byte[] min)

Specified by:

zrangeByLex in interface BinaryRedisPipeline

zrangeByLex

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

Specified by:

zrangeByLex in interface RedisPipeline

zrangeByLex

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

Specified by:

zrangeByLex in interface BinaryRedisPipeline

zrangeByLex

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

Specified by:

zrangeByLex 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)

dump

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

migrate

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

migrate

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

objectRefcount

public Response<Long> objectRefcount(String key)

objectRefcount

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

objectEncoding

public Response<String> objectEncoding(String key)

objectEncoding

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

objectIdletime

public Response<Long> objectIdletime(String key)

objectIdletime

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

pexpire

@Deprecated
public Response<Long> pexpire(String key,
                                         int milliseconds)

Deprecated.

pexpire

@Deprecated
public Response<Long> pexpire(byte[] key,
                                         int milliseconds)

Deprecated.

pexpire

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

pexpire

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

pexpireAt

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

pexpireAt

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

pttl

public Response<Long> pttl(String key)

pttl

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

restore

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

restore

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

incrByFloat

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

incrByFloat

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

psetex

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

psetex

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

set

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

set

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

set

public Response<String> set(String key,
                            String value,
                            String nxxx,
                            String expx,
                            int time)

set

public Response<String> set(byte[] key,
                            byte[] value,
                            byte[] nxxx,
                            byte[] expx,
                            int time)

hincrByFloat

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

hincrByFloat

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

eval

public Response<String> eval(String script)

eval

public Response<String> eval(String script,
                             List<String> keys,
                             List<String> args)

eval

public Response<String> eval(String script,
                             int numKeys,
                             String[] argv)

evalsha

public Response<String> evalsha(String script)

evalsha

public Response<String> evalsha(String sha1,
                                List<String> keys,
                                List<String> args)

evalsha

public Response<String> evalsha(String sha1,
                                int numKeys,
                                String[] argv)

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