Package redis.clients.jedis

Class BinaryShardedJedis

java.lang.Object

redis.clients.jedis.util.Sharded<Jedis,JedisShardInfo>

redis.clients.jedis.BinaryShardedJedis

All Implemented Interfaces:

BinaryJedisCommands

Direct Known Subclasses:

ShardedJedis

public class BinaryShardedJedis
extends Sharded<Jedis,JedisShardInfo>
implements BinaryJedisCommands

Field Summary

Fields inherited from class redis.clients.jedis.util.Sharded

DEFAULT_KEY_TAG_PATTERN, DEFAULT_WEIGHT

Constructor Summary

Constructors

Constructor	Description
BinaryShardedJedis(List<JedisShardInfo> shards)
BinaryShardedJedis(List<JedisShardInfo> shards, Pattern keyTagPattern)
BinaryShardedJedis(List<JedisShardInfo> shards, Hashing algo)
BinaryShardedJedis(List<JedisShardInfo> shards, Hashing algo, Pattern keyTagPattern)

Method Summary

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

Methods inherited from class redis.clients.jedis.util.Sharded

getAllShardInfo, getAllShards, getKeyTag, getShard, getShard, getShardInfo, getShardInfo

Methods inherited from class java.lang.Object

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

Constructor Detail

BinaryShardedJedis

public BinaryShardedJedis(List<JedisShardInfo> shards)

BinaryShardedJedis

public BinaryShardedJedis(List<JedisShardInfo> shards,
                          Hashing algo)

BinaryShardedJedis

public BinaryShardedJedis(List<JedisShardInfo> shards,
                          Pattern keyTagPattern)

BinaryShardedJedis

public BinaryShardedJedis(List<JedisShardInfo> shards,
                          Hashing algo,
                          Pattern keyTagPattern)

Method Detail

disconnect

public void disconnect()

create

protected Jedis create(JedisShardInfo shard)

set

public String set(byte[] key,
                  byte[] value)

Specified by:

set in interface BinaryJedisCommands

set

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

Specified by:

set in interface BinaryJedisCommands

get

public byte[] get(byte[] key)

Specified by:

get in interface BinaryJedisCommands

exists

public Boolean exists(byte[] key)

Specified by:

exists in interface BinaryJedisCommands

type

public String type(byte[] key)

Specified by:

type in interface BinaryJedisCommands

dump

public byte[] dump(byte[] key)

Specified by:

dump in interface BinaryJedisCommands

restore

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

Specified by:

restore in interface BinaryJedisCommands

restoreReplace

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

Specified by:

restoreReplace in interface BinaryJedisCommands

expire

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

Specified by:

expire in interface BinaryJedisCommands

pexpire

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

Specified by:

pexpire in interface BinaryJedisCommands

expireAt

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

Specified by:

expireAt in interface BinaryJedisCommands

pexpireAt

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

Specified by:

pexpireAt in interface BinaryJedisCommands

ttl

public Long ttl(byte[] key)

Specified by:

ttl in interface BinaryJedisCommands

pttl

public Long pttl(byte[] key)

Specified by:

pttl in interface BinaryJedisCommands

touch

public Long touch(byte[] key)

Specified by:

touch in interface BinaryJedisCommands

getSet

public byte[] getSet(byte[] key,
                     byte[] value)

Specified by:

getSet in interface BinaryJedisCommands

setnx

public Long setnx(byte[] key,
                  byte[] value)

Specified by:

setnx in interface BinaryJedisCommands

setex

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

Specified by:

setex in interface BinaryJedisCommands

psetex

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

Specified by:

psetex in interface BinaryJedisCommands

decrBy

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

Specified by:

decrBy in interface BinaryJedisCommands

decr

public Long decr(byte[] key)

Specified by:

decr in interface BinaryJedisCommands

del

public Long del(byte[] key)

Specified by:

del in interface BinaryJedisCommands

unlink

public Long unlink(byte[] key)

Specified by:

unlink in interface BinaryJedisCommands

incrBy

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

Specified by:

incrBy in interface BinaryJedisCommands

incrByFloat

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

Specified by:

incrByFloat in interface BinaryJedisCommands

incr

public Long incr(byte[] key)

Specified by:

incr in interface BinaryJedisCommands

append

public Long append(byte[] key,
                   byte[] value)

Specified by:

append in interface BinaryJedisCommands

substr

public byte[] substr(byte[] key,
                     int start,
                     int end)

Specified by:

substr in interface BinaryJedisCommands

hset

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

Specified by:

hset in interface BinaryJedisCommands

hset

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

Specified by:

hset in interface BinaryJedisCommands

hget

public byte[] hget(byte[] key,
                   byte[] field)

Specified by:

hget in interface BinaryJedisCommands

hsetnx

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

Specified by:

hsetnx in interface BinaryJedisCommands

hmset

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

Specified by:

hmset in interface BinaryJedisCommands

hmget

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

Specified by:

hmget in interface BinaryJedisCommands

hincrBy

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

Specified by:

hincrBy in interface BinaryJedisCommands

hincrByFloat

public Double hincrByFloat(byte[] key,
                           byte[] field,
                           double value)

Specified by:

hincrByFloat in interface BinaryJedisCommands

hexists

public Boolean hexists(byte[] key,
                       byte[] field)

Specified by:

hexists in interface BinaryJedisCommands

hdel

public Long hdel(byte[] key,
                 byte[]... fields)

Specified by:

hdel in interface BinaryJedisCommands

hlen

public Long hlen(byte[] key)

Specified by:

hlen in interface BinaryJedisCommands

hkeys

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

Specified by:

hkeys in interface BinaryJedisCommands

hvals

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

Specified by:

hvals in interface BinaryJedisCommands

hgetAll

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

Specified by:

hgetAll in interface BinaryJedisCommands

rpush

public Long rpush(byte[] key,
                  byte[]... strings)

Specified by:

rpush in interface BinaryJedisCommands

lpush

public Long lpush(byte[] key,
                  byte[]... strings)

Specified by:

lpush in interface BinaryJedisCommands

strlen

public Long strlen(byte[] key)

Specified by:

strlen in interface BinaryJedisCommands

lpushx

public Long lpushx(byte[] key,
                   byte[]... string)

Specified by:

lpushx in interface BinaryJedisCommands

persist

public Long persist(byte[] key)

Specified by:

persist in interface BinaryJedisCommands

rpushx

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

Specified by:

rpushx in interface BinaryJedisCommands

llen

public Long llen(byte[] key)

Specified by:

llen in interface BinaryJedisCommands

lrange

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

Specified by:

lrange in interface BinaryJedisCommands

ltrim

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

Specified by:

ltrim in interface BinaryJedisCommands

lindex

public byte[] lindex(byte[] key,
                     long index)

Specified by:

lindex in interface BinaryJedisCommands

lset

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

Specified by:

lset in interface BinaryJedisCommands

lrem

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

Specified by:

lrem in interface BinaryJedisCommands

lpop

public byte[] lpop(byte[] key)

Specified by:

lpop in interface BinaryJedisCommands

lpop

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

Specified by:

lpop in interface BinaryJedisCommands

lpos

public Long lpos(byte[] key,
                 byte[] element)

Specified by:

lpos in interface BinaryJedisCommands

lpos

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

Specified by:

lpos in interface BinaryJedisCommands

lpos

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

Specified by:

lpos in interface BinaryJedisCommands

rpop

public byte[] rpop(byte[] key)

Specified by:

rpop in interface BinaryJedisCommands

rpop

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

Specified by:

rpop in interface BinaryJedisCommands

sadd

public Long sadd(byte[] key,
                 byte[]... members)

Specified by:

sadd in interface BinaryJedisCommands

smembers

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

Specified by:

smembers in interface BinaryJedisCommands

srem

public Long srem(byte[] key,
                 byte[]... members)

Specified by:

srem in interface BinaryJedisCommands

spop

public byte[] spop(byte[] key)

Specified by:

spop in interface BinaryJedisCommands

spop

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

Specified by:

spop in interface BinaryJedisCommands

scard

public Long scard(byte[] key)

Specified by:

scard in interface BinaryJedisCommands

sismember

public Boolean sismember(byte[] key,
                         byte[] member)

Specified by:

sismember in interface BinaryJedisCommands

smismember

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

Specified by:

smismember in interface BinaryJedisCommands

srandmember

public byte[] srandmember(byte[] key)

Specified by:

srandmember in interface BinaryJedisCommands

srandmember

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

Specified by:

srandmember in interface BinaryJedisCommands

zadd

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

Specified by:

zadd in interface BinaryJedisCommands

zadd

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

Specified by:

zadd in interface BinaryJedisCommands

zadd

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

Specified by:

zadd in interface BinaryJedisCommands

zadd

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

Specified by:

zadd in interface BinaryJedisCommands

zrange

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

Specified by:

zrange in interface BinaryJedisCommands

zrem

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

Specified by:

zrem in interface BinaryJedisCommands

zincrby

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

Specified by:

zincrby in interface BinaryJedisCommands

zincrby

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

Specified by:

zincrby in interface BinaryJedisCommands

zrank

public Long zrank(byte[] key,
                  byte[] member)

Specified by:

zrank in interface BinaryJedisCommands

zrevrank

public Long zrevrank(byte[] key,
                     byte[] member)

Specified by:

zrevrank in interface BinaryJedisCommands

zrevrange

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

Specified by:

zrevrange in interface BinaryJedisCommands

zrangeWithScores

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

Specified by:

zrangeWithScores in interface BinaryJedisCommands

zrevrangeWithScores

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

Specified by:

zrevrangeWithScores in interface BinaryJedisCommands

zcard

public Long zcard(byte[] key)

Specified by:

zcard in interface BinaryJedisCommands

zscore

public Double zscore(byte[] key,
                     byte[] member)

Specified by:

zscore in interface BinaryJedisCommands

zmscore

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

Specified by:

zmscore in interface BinaryJedisCommands

zpopmax

public Tuple zpopmax(byte[] key)

Specified by:

zpopmax in interface BinaryJedisCommands

zpopmax

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

Specified by:

zpopmax in interface BinaryJedisCommands

zpopmin

public Tuple zpopmin(byte[] key)

Specified by:

zpopmin in interface BinaryJedisCommands

zpopmin

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

Specified by:

zpopmin in interface BinaryJedisCommands

sort

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

Specified by:

sort in interface BinaryJedisCommands

sort

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

Specified by:

sort in interface BinaryJedisCommands

zcount

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

Specified by:

zcount in interface BinaryJedisCommands

zcount

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

Specified by:

zcount in interface BinaryJedisCommands

zrangeByScore

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

Specified by:

zrangeByScore in interface BinaryJedisCommands

zrangeByScore

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

Specified by:

zrangeByScore in interface BinaryJedisCommands

zrangeByScoreWithScores

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

Specified by:

zrangeByScoreWithScores in interface BinaryJedisCommands

zrangeByScoreWithScores

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

Specified by:

zrangeByScoreWithScores in interface BinaryJedisCommands

zrangeByScore

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

Specified by:

zrangeByScore in interface BinaryJedisCommands

zrangeByScoreWithScores

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

Specified by:

zrangeByScoreWithScores in interface BinaryJedisCommands

zrangeByScoreWithScores

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

Specified by:

zrangeByScoreWithScores in interface BinaryJedisCommands

zrangeByScore

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

Specified by:

zrangeByScore in interface BinaryJedisCommands

zrevrangeByScore

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

Specified by:

zrevrangeByScore in interface BinaryJedisCommands

zrevrangeByScore

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

Specified by:

zrevrangeByScore in interface BinaryJedisCommands

zrevrangeByScoreWithScores

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

Specified by:

zrevrangeByScoreWithScores in interface BinaryJedisCommands

zrevrangeByScoreWithScores

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

Specified by:

zrevrangeByScoreWithScores in interface BinaryJedisCommands

zrevrangeByScore

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

Specified by:

zrevrangeByScore in interface BinaryJedisCommands

zrevrangeByScore

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

Specified by:

zrevrangeByScore in interface BinaryJedisCommands

zrevrangeByScoreWithScores

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

Specified by:

zrevrangeByScoreWithScores in interface BinaryJedisCommands

zrevrangeByScoreWithScores

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

Specified by:

zrevrangeByScoreWithScores in interface BinaryJedisCommands

zremrangeByRank

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

Specified by:

zremrangeByRank in interface BinaryJedisCommands

zremrangeByScore

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

Specified by:

zremrangeByScore in interface BinaryJedisCommands

zremrangeByScore

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

Specified by:

zremrangeByScore in interface BinaryJedisCommands

zlexcount

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

Specified by:

zlexcount in interface BinaryJedisCommands

zrangeByLex

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

Specified by:

zrangeByLex in interface BinaryJedisCommands

zrangeByLex

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

Specified by:

zrangeByLex in interface BinaryJedisCommands

zrevrangeByLex

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

Specified by:

zrevrangeByLex in interface BinaryJedisCommands

zrevrangeByLex

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

Specified by:

zrevrangeByLex in interface BinaryJedisCommands

zremrangeByLex

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

Specified by:

zremrangeByLex in interface BinaryJedisCommands

linsert

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

Specified by:

linsert in interface BinaryJedisCommands

pipelined

public ShardedJedisPipeline pipelined()

objectRefcount

public Long objectRefcount(byte[] key)

objectEncoding

public byte[] objectEncoding(byte[] key)

objectIdletime

public Long objectIdletime(byte[] key)

objectHelp

public List<String> objectHelp()

objectFreq

public Long objectFreq(byte[] key)

setbit

public Boolean setbit(byte[] key,
                      long offset,
                      boolean value)

Specified by:

setbit in interface BinaryJedisCommands

setbit

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

Specified by:

setbit in interface BinaryJedisCommands

getbit

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

Specified by:

getbit in interface BinaryJedisCommands

setrange

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

Specified by:

setrange in interface BinaryJedisCommands

getrange

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

Specified by:

getrange in interface BinaryJedisCommands

move

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

Specified by:

move in interface BinaryJedisCommands

echo

public byte[] echo(byte[] arg)

Specified by:

echo in interface BinaryJedisCommands

brpop

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

blpop

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

bitcount

public Long bitcount(byte[] key)

Specified by:

bitcount in interface BinaryJedisCommands

bitcount

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

Specified by:

bitcount in interface BinaryJedisCommands

pfadd

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

Specified by:

pfadd in interface BinaryJedisCommands

pfcount

public long pfcount(byte[] key)

Specified by:

pfcount in interface BinaryJedisCommands

geoadd

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

Specified by:

geoadd in interface BinaryJedisCommands

geoadd

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

Specified by:

geoadd in interface BinaryJedisCommands

geodist

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

Specified by:

geodist in interface BinaryJedisCommands

geodist

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

Specified by:

geodist in interface BinaryJedisCommands

geohash

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

Specified by:

geohash in interface BinaryJedisCommands

geopos

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

Specified by:

geopos in interface BinaryJedisCommands

georadius

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

Specified by:

georadius in interface BinaryJedisCommands

georadiusReadonly

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

Specified by:

georadiusReadonly in interface BinaryJedisCommands

georadius

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

Specified by:

georadius in interface BinaryJedisCommands

georadiusReadonly

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

Specified by:

georadiusReadonly in interface BinaryJedisCommands

georadiusByMember

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

Specified by:

georadiusByMember in interface BinaryJedisCommands

georadiusByMemberReadonly

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

Specified by:

georadiusByMemberReadonly in interface BinaryJedisCommands

georadiusByMember

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

Specified by:

georadiusByMember in interface BinaryJedisCommands

georadiusByMemberReadonly

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

Specified by:

georadiusByMemberReadonly in interface BinaryJedisCommands

hscan

public ScanResult<Map.Entry<byte[],byte[]>> hscan(byte[] key,
                                                        byte[] cursor)

Specified by:

hscan in interface BinaryJedisCommands

hscan

public ScanResult<Map.Entry<byte[],byte[]>> hscan(byte[] key,
                                                        byte[] cursor,
                                                        ScanParams params)

Specified by:

hscan in interface BinaryJedisCommands

sscan

public ScanResult<byte[]> sscan(byte[] key,
                                byte[] cursor)

Specified by:

sscan in interface BinaryJedisCommands

sscan

public ScanResult<byte[]> sscan(byte[] key,
                                byte[] cursor,
                                ScanParams params)

Specified by:

sscan in interface BinaryJedisCommands

zscan

public ScanResult<Tuple> zscan(byte[] key,
                               byte[] cursor)

Specified by:

zscan in interface BinaryJedisCommands

zscan

public ScanResult<Tuple> zscan(byte[] key,
                               byte[] cursor,
                               ScanParams params)

Specified by:

zscan in interface BinaryJedisCommands

bitfield

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

Description copied from interface: BinaryJedisCommands

Executes BITFIELD Redis command

Specified by:

bitfield in interface BinaryJedisCommands

Returns:

bitfieldReadonly

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

Specified by:

bitfieldReadonly in interface BinaryJedisCommands

hstrlen

public Long hstrlen(byte[] key,
                    byte[] field)

Description copied from interface: BinaryJedisCommands

Used for HSTRLEN Redis command

Specified by:

hstrlen in interface BinaryJedisCommands

Returns:

lenth of the value for key

xadd

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

Specified by:

xadd in interface BinaryJedisCommands

xlen

public Long xlen(byte[] key)

Specified by:

xlen in interface BinaryJedisCommands

xrange

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

Specified by:

xrange in interface BinaryJedisCommands

xrevrange

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

Specified by:

xrevrange in interface BinaryJedisCommands

xack

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

Specified by:

xack in interface BinaryJedisCommands

xgroupCreate

public String xgroupCreate(byte[] key,
                           byte[] consumer,
                           byte[] id,
                           boolean makeStream)

Specified by:

xgroupCreate in interface BinaryJedisCommands

xgroupSetID

public String xgroupSetID(byte[] key,
                          byte[] consumer,
                          byte[] id)

Specified by:

xgroupSetID in interface BinaryJedisCommands

xgroupDestroy

public Long xgroupDestroy(byte[] key,
                          byte[] consumer)

Specified by:

xgroupDestroy in interface BinaryJedisCommands

xgroupDelConsumer

public Long xgroupDelConsumer(byte[] key,
                              byte[] consumer,
                              byte[] consumerName)

Specified by:

xgroupDelConsumer in interface BinaryJedisCommands

xdel

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

Specified by:

xdel in interface BinaryJedisCommands

xtrim

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

Specified by:

xtrim in interface BinaryJedisCommands

xpending

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

Specified by:

xpending in interface BinaryJedisCommands

xclaim

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

Specified by:

xclaim in interface BinaryJedisCommands

xinfoStream

public StreamInfo xinfoStream(byte[] key)

Specified by:

xinfoStream in interface BinaryJedisCommands

xinfoGroup

public List<StreamGroupInfo> xinfoGroup(byte[] key)

Specified by:

xinfoGroup in interface BinaryJedisCommands

xinfoConsumers

public List<StreamConsumersInfo> xinfoConsumers(byte[] key,
                                                byte[] group)

Specified by:

xinfoConsumers in interface BinaryJedisCommands

sendCommand

public Object sendCommand(ProtocolCommand cmd,
                          byte[]... args)

sendBlockingCommand

public Object sendBlockingCommand(ProtocolCommand cmd,
                                  byte[]... args)

sendCommand

public Object sendCommand(ProtocolCommand cmd)