redis.clients.jedis

Interface BinaryRedisPipeline

All Known Implementing Classes:

MultiKeyPipelineBase, Pipeline, PipelineBase, PipelineBlock, ShardedJedisPipeline, Transaction, TransactionBlock

public interface BinaryRedisPipeline

Method Summary

Modifier and Type	Method and Description
Response<java.lang.Long>	append(byte[] key, byte[] value)
Response<java.lang.Long>	bitcount(byte[] key)
Response<java.lang.Long>	bitcount(byte[] key, long start, long end)
Response<java.util.List<byte[]>>	blpop(byte[] arg)
Response<java.util.List<byte[]>>	brpop(byte[] arg)
Response<java.lang.Long>	decr(byte[] key)
Response<java.lang.Long>	decrBy(byte[] key, long integer)
Response<java.lang.Long>	del(byte[] keys)
Response<byte[]>	echo(byte[] string)
Response<java.lang.Boolean>	exists(byte[] key)
Response<java.lang.Long>	expire(byte[] key, int seconds)
Response<java.lang.Long>	expireAt(byte[] key, long unixTime)
Response<byte[]>	get(byte[] key)
Response<java.lang.Boolean>	getbit(byte[] key, long offset)
Response<java.lang.Long>	getrange(byte[] key, long startOffset, long endOffset)
Response<byte[]>	getSet(byte[] key, byte[] value)
Response<java.lang.Long>	hdel(byte[] key, byte[]... field)
Response<java.lang.Boolean>	hexists(byte[] key, byte[] field)
Response<byte[]>	hget(byte[] key, byte[] field)
Response<java.util.Map<byte[],byte[]>>	hgetAll(byte[] key)
Response<java.lang.Long>	hincrBy(byte[] key, byte[] field, long value)
Response<java.util.Set<byte[]>>	hkeys(byte[] key)
Response<java.lang.Long>	hlen(byte[] key)
Response<java.util.List<byte[]>>	hmget(byte[] key, byte[]... fields)
Response<java.lang.String>	hmset(byte[] key, java.util.Map<byte[],byte[]> hash)
Response<java.lang.Long>	hset(byte[] key, byte[] field, byte[] value)
Response<java.lang.Long>	hsetnx(byte[] key, byte[] field, byte[] value)
Response<java.util.List<byte[]>>	hvals(byte[] key)
Response<java.lang.Long>	incr(byte[] key)
Response<java.lang.Long>	incrBy(byte[] key, long integer)
Response<byte[]>	lindex(byte[] key, long index)
Response<java.lang.Long>	linsert(byte[] key, BinaryClient.LIST_POSITION where, byte[] pivot, byte[] value)
Response<java.lang.Long>	llen(byte[] key)
Response<byte[]>	lpop(byte[] key)
Response<java.lang.Long>	lpush(byte[] key, byte[]... string)
Response<java.lang.Long>	lpushx(byte[] key, byte[]... bytes)
Response<java.util.List<byte[]>>	lrange(byte[] key, long start, long end)
Response<java.lang.Long>	lrem(byte[] key, long count, byte[] value)
Response<java.lang.String>	lset(byte[] key, long index, byte[] value)
Response<java.lang.String>	ltrim(byte[] key, long start, long end)
Response<java.lang.Long>	move(byte[] key, int dbIndex)
Response<java.lang.Long>	persist(byte[] key)
Response<java.lang.Long>	pexpire(byte[] key, long milliseconds)
Response<java.lang.Long>	pexpireAt(byte[] key, long millisecondsTimestamp)
Response<java.lang.Long>	pfadd(byte[] key, byte[]... elements)
Response<java.lang.Long>	pfcount(byte[] key)
Response<byte[]>	rpop(byte[] key)
Response<java.lang.Long>	rpush(byte[] key, byte[]... string)
Response<java.lang.Long>	rpushx(byte[] key, byte[]... string)
Response<java.lang.Long>	sadd(byte[] key, byte[]... member)
Response<java.lang.Long>	scard(byte[] key)
Response<java.lang.String>	set(byte[] key, byte[] value)
Response<java.lang.Boolean>	setbit(byte[] key, long offset, byte[] value)
Response<java.lang.String>	setex(byte[] key, int seconds, byte[] value)
Response<java.lang.Long>	setnx(byte[] key, byte[] value)
Response<java.lang.Long>	setrange(byte[] key, long offset, byte[] value)
Response<java.lang.Long>	setrange(java.lang.String key, long offset, java.lang.String value)
Response<java.lang.Boolean>	sismember(byte[] key, byte[] member)
Response<java.util.Set<byte[]>>	smembers(byte[] key)
Response<java.util.List<byte[]>>	sort(byte[] key)
Response<java.util.List<byte[]>>	sort(byte[] key, SortingParams sortingParameters)
Response<byte[]>	spop(byte[] key)
Response<java.util.Set<byte[]>>	spop(byte[] key, long count)
Response<byte[]>	srandmember(byte[] key)
Response<java.lang.Long>	srem(byte[] key, byte[]... member)
Response<java.lang.Long>	strlen(byte[] key)
Response<java.lang.String>	substr(byte[] key, int start, int end)
Response<java.lang.Long>	ttl(byte[] key)
Response<java.lang.String>	type(byte[] key)
Response<java.lang.Long>	zadd(byte[] key, double score, byte[] member)
Response<java.lang.Long>	zcard(byte[] key)
Response<java.lang.Long>	zcount(byte[] key, double min, double max)
Response<java.lang.Double>	zincrby(byte[] key, double score, byte[] member)
Response<java.lang.Long>	zlexcount(byte[] key, byte[] min, byte[] max)
Response<java.util.Set<byte[]>>	zrange(byte[] key, long start, long end)
Response<java.util.Set<byte[]>>	zrangeByLex(byte[] key, byte[] min, byte[] max)
Response<java.util.Set<byte[]>>	zrangeByLex(byte[] key, byte[] min, byte[] max, int offset, int count)
Response<java.util.Set<byte[]>>	zrangeByScore(byte[] key, byte[] min, byte[] max)
Response<java.util.Set<byte[]>>	zrangeByScore(byte[] key, byte[] min, byte[] max, int offset, int count)
Response<java.util.Set<byte[]>>	zrangeByScore(byte[] key, double min, double max)
Response<java.util.Set<byte[]>>	zrangeByScore(byte[] key, double min, double max, int offset, int count)
Response<java.util.Set<Tuple>>	zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max)
Response<java.util.Set<Tuple>>	zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max, int offset, int count)
Response<java.util.Set<Tuple>>	zrangeByScoreWithScores(byte[] key, double min, double max)
Response<java.util.Set<Tuple>>	zrangeByScoreWithScores(byte[] key, double min, double max, int offset, int count)
Response<java.util.Set<Tuple>>	zrangeWithScores(byte[] key, long start, long end)
Response<java.lang.Long>	zrank(byte[] key, byte[] member)
Response<java.lang.Long>	zrem(byte[] key, byte[]... member)
Response<java.lang.Long>	zremrangeByLex(byte[] key, byte[] min, byte[] max)
Response<java.lang.Long>	zremrangeByRank(byte[] key, long start, long end)
Response<java.lang.Long>	zremrangeByScore(byte[] key, byte[] start, byte[] end)
Response<java.lang.Long>	zremrangeByScore(byte[] key, double start, double end)
Response<java.util.Set<byte[]>>	zrevrange(byte[] key, long start, long end)
Response<java.util.Set<byte[]>>	zrevrangeByLex(byte[] key, byte[] max, byte[] min)
Response<java.util.Set<byte[]>>	zrevrangeByLex(byte[] key, byte[] max, byte[] min, int offset, int count)
Response<java.util.Set<byte[]>>	zrevrangeByScore(byte[] key, byte[] max, byte[] min)
Response<java.util.Set<byte[]>>	zrevrangeByScore(byte[] key, byte[] max, byte[] min, int offset, int count)
Response<java.util.Set<byte[]>>	zrevrangeByScore(byte[] key, double max, double min)
Response<java.util.Set<byte[]>>	zrevrangeByScore(byte[] key, double max, double min, int offset, int count)
Response<java.util.Set<Tuple>>	zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min)
Response<java.util.Set<Tuple>>	zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min, int offset, int count)
Response<java.util.Set<Tuple>>	zrevrangeByScoreWithScores(byte[] key, double max, double min)
Response<java.util.Set<Tuple>>	zrevrangeByScoreWithScores(byte[] key, double max, double min, int offset, int count)
Response<java.util.Set<Tuple>>	zrevrangeWithScores(byte[] key, long start, long end)
Response<java.lang.Long>	zrevrank(byte[] key, byte[] member)
Response<java.lang.Double>	zscore(byte[] key, byte[] member)

Method Detail

append

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

blpop

Response<java.util.List<byte[]>> blpop(byte[] arg)

brpop

Response<java.util.List<byte[]>> brpop(byte[] arg)

decr

Response<java.lang.Long> decr(byte[] key)

decrBy

Response<java.lang.Long> decrBy(byte[] key,
                                long integer)

del

Response<java.lang.Long> del(byte[] keys)

echo

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

exists

Response<java.lang.Boolean> exists(byte[] key)

expire

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

pexpire

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

expireAt

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

pexpireAt

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

get

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

getbit

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

getSet

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

getrange

Response<java.lang.Long> getrange(byte[] key,
                                  long startOffset,
                                  long endOffset)

hdel

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

hexists

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

hget

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

hgetAll

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

hincrBy

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

hkeys

Response<java.util.Set<byte[]>> hkeys(byte[] key)

hlen

Response<java.lang.Long> hlen(byte[] key)

hmget

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

hmset

Response<java.lang.String> hmset(byte[] key,
                                 java.util.Map<byte[],byte[]> hash)

hset

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

hsetnx

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

hvals

Response<java.util.List<byte[]>> hvals(byte[] key)

incr

Response<java.lang.Long> incr(byte[] key)

incrBy

Response<java.lang.Long> incrBy(byte[] key,
                                long integer)

lindex

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

linsert

Response<java.lang.Long> linsert(byte[] key,
                                 BinaryClient.LIST_POSITION where,
                                 byte[] pivot,
                                 byte[] value)

llen

Response<java.lang.Long> llen(byte[] key)

lpop

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

lpush

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

lpushx

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

lrange

Response<java.util.List<byte[]>> lrange(byte[] key,
                                        long start,
                                        long end)

lrem

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

lset

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

ltrim

Response<java.lang.String> ltrim(byte[] key,
                                 long start,
                                 long end)

move

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

persist

Response<java.lang.Long> persist(byte[] key)

rpop

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

rpush

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

rpushx

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

sadd

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

scard

Response<java.lang.Long> scard(byte[] key)

set

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

setbit

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

setrange

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

setex

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

setnx

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

setrange

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

smembers

Response<java.util.Set<byte[]>> smembers(byte[] key)

sismember

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

sort

Response<java.util.List<byte[]>> sort(byte[] key)

sort

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

spop

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

spop

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

srandmember

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

srem

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

strlen

Response<java.lang.Long> strlen(byte[] key)

substr

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

ttl

Response<java.lang.Long> ttl(byte[] key)

type

Response<java.lang.String> type(byte[] key)

zadd

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

zcard

Response<java.lang.Long> zcard(byte[] key)

zcount

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

zincrby

Response<java.lang.Double> zincrby(byte[] key,
                                   double score,
                                   byte[] member)

zrange

Response<java.util.Set<byte[]>> zrange(byte[] key,
                                       long start,
                                       long end)

zrangeByScore

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

zrangeByScore

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

zrangeByScore

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

zrangeByScore

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

zrangeByScoreWithScores

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

zrangeByScoreWithScores

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

zrangeByScoreWithScores

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

zrangeByScoreWithScores

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

zrevrangeByScore

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

zrevrangeByScore

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

zrevrangeByScore

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

zrevrangeByScore

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

zrevrangeByScoreWithScores

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

zrevrangeByScoreWithScores

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

zrevrangeByScoreWithScores

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

zrevrangeByScoreWithScores

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

zrangeWithScores

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

zrank

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

zrem

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

zremrangeByRank

Response<java.lang.Long> zremrangeByRank(byte[] key,
                                         long start,
                                         long end)

zremrangeByScore

Response<java.lang.Long> zremrangeByScore(byte[] key,
                                          double start,
                                          double end)

zremrangeByScore

Response<java.lang.Long> zremrangeByScore(byte[] key,
                                          byte[] start,
                                          byte[] end)

zrevrange

Response<java.util.Set<byte[]>> zrevrange(byte[] key,
                                          long start,
                                          long end)

zrevrangeWithScores

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

zrevrank

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

zscore

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

zlexcount

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

zrangeByLex

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

zrangeByLex

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

zrevrangeByLex

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

zrevrangeByLex

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

zremrangeByLex

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

bitcount

Response<java.lang.Long> bitcount(byte[] key)

bitcount

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

pfadd

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

pfcount

Response<java.lang.Long> pfcount(byte[] key)