redis.clients.jedis

Interface BinaryRedisPipeline

All Known Implementing Classes:

Pipeline, PipelineBlock, ShardedJedisPipeline, Transaction, TransactionBlock

public interface BinaryRedisPipeline

Author:

guy

Method Summary

Methods

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

Method Detail

append

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

blpop

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

brpop

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

decr

Response<Long> decr(byte[] key)

decrBy

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

del

Response<Long> del(byte[] keys)

echo

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

exists

Response<Boolean> exists(byte[] key)

expire

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

expireAt

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

get

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

getbit

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

getSet

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

getrange

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

hdel

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

hexists

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

hget

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

hgetAll

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

hincrBy

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

hkeys

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

hlen

Response<Long> hlen(byte[] key)

hmget

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

hmset

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

hset

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

hsetnx

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

hvals

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

incr

Response<Long> incr(byte[] key)

incrBy

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

lindex

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

linsert

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

llen

Response<Long> llen(byte[] key)

lpop

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

lpush

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

lpushx

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

lrange

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

lrem

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

lset

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

ltrim

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

move

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

persist

Response<Long> persist(byte[] key)

rpop

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

rpush

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

rpushx

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

sadd

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

scard

Response<Long> scard(byte[] key)

set

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

setbit

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

setrange

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

setex

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

setnx

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

setrange

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

smembers

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

sismember

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

sort

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

sort

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

spop

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

srandmember

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

srem

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

strlen

Response<Long> strlen(byte[] key)

substr

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

ttl

Response<Long> ttl(byte[] key)

type

Response<String> type(byte[] key)

zadd

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

zcard

Response<Long> zcard(byte[] key)

zcount

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

zincrby

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

zrange

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

zrangeByScore

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

zrangeByScore

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

zrangeByScore

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

zrangeByScore

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

zrangeByScoreWithScores

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

zrangeByScoreWithScores

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

zrangeByScoreWithScores

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

zrangeByScoreWithScores

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

zrevrangeByScore

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

zrevrangeByScore

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

zrevrangeByScore

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

zrevrangeByScore

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

zrevrangeByScoreWithScores

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

zrevrangeByScoreWithScores

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

zrevrangeByScoreWithScores

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

zrevrangeByScoreWithScores

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

zrangeWithScores

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

zrank

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

zrem

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

zremrangeByRank

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

zremrangeByScore

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

zremrangeByScore

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

zrevrange

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

zrevrangeWithScores

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

zrevrank

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

zscore

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

zlexcount

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

zrangeByLex

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

zrangeByLex

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

zremrangeByLex

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

bitcount

Response<Long> bitcount(byte[] key)

bitcount

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

pfadd

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

pfcount

Response<Long> pfcount(byte[] key)