redis.clients.jedis.commands

Interface BinaryJedisCommands

All Known Implementing Classes:

BinaryJedis, BinaryShardedJedis, Jedis, ShardedJedis

public interface BinaryJedisCommands

Common interface for sharded and non-sharded BinaryJedis

Method Summary

Modifier and Type	Method and 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)
Long	decr(byte[] key)
Long	decrBy(byte[] key, long decrement)
Long	del(byte[] key)
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[]... field)
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)
Long	lpush(byte[] key, byte[]... args)
Long	lpushx(byte[] key, byte[]... arg)
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)
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)
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)
Long	rpush(byte[] key, byte[]... args)
Long	rpushx(byte[] key, byte[]... arg)
Long	sadd(byte[] key, byte[]... member)
Long	scard(byte[] key)
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<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[]... member)
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)
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)

Method Detail

set

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

set

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

get

byte[] get(byte[] key)

exists

Boolean exists(byte[] key)

persist

Long persist(byte[] key)

type

String type(byte[] key)

dump

byte[] dump(byte[] key)

restore

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

restoreReplace

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

expire

Long expire(byte[] key,
            int seconds)

pexpire

Long pexpire(byte[] key,
             long milliseconds)

expireAt

Long expireAt(byte[] key,
              long unixTime)

pexpireAt

Long pexpireAt(byte[] key,
               long millisecondsTimestamp)

ttl

Long ttl(byte[] key)

pttl

Long pttl(byte[] key)

touch

Long touch(byte[] key)

setbit

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

setbit

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

getbit

Boolean getbit(byte[] key,
               long offset)

setrange

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

getrange

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

getSet

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

setnx

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

setex

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

psetex

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

decrBy

Long decrBy(byte[] key,
            long decrement)

decr

Long decr(byte[] key)

incrBy

Long incrBy(byte[] key,
            long increment)

incrByFloat

Double incrByFloat(byte[] key,
                   double increment)

incr

Long incr(byte[] key)

append

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

substr

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

hset

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

hset

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

hget

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

hsetnx

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

hmset

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

hmget

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

hincrBy

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

hincrByFloat

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

hexists

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

hdel

Long hdel(byte[] key,
          byte[]... field)

hlen

Long hlen(byte[] key)

hkeys

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

hvals

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

hgetAll

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

rpush

Long rpush(byte[] key,
           byte[]... args)

lpush

Long lpush(byte[] key,
           byte[]... args)

llen

Long llen(byte[] key)

lrange

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

ltrim

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

lindex

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

lset

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

lrem

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

lpop

byte[] lpop(byte[] key)

rpop

byte[] rpop(byte[] key)

sadd

Long sadd(byte[] key,
          byte[]... member)

smembers

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

srem

Long srem(byte[] key,
          byte[]... member)

spop

byte[] spop(byte[] key)

spop

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

scard

Long scard(byte[] key)

sismember

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

srandmember

byte[] srandmember(byte[] key)

srandmember

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

strlen

Long strlen(byte[] key)

zadd

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

zadd

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

zadd

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

zadd

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

zrange

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

zrem

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

zincrby

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

zincrby

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

zrank

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

zrevrank

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

zrevrange

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

zrangeWithScores

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

zrevrangeWithScores

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

zcard

Long zcard(byte[] key)

zscore

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

zpopmax

Tuple zpopmax(byte[] key)

zpopmax

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

zpopmin

Tuple zpopmin(byte[] key)

zpopmin

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

sort

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

sort

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

zcount

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

zcount

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

zrangeByScore

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

zrangeByScore

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

zrevrangeByScore

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

zrangeByScore

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

zrevrangeByScore

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

zrangeByScore

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

zrevrangeByScore

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

zrangeByScoreWithScores

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

zrevrangeByScoreWithScores

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

zrangeByScoreWithScores

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

zrevrangeByScore

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

zrangeByScoreWithScores

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

zrevrangeByScoreWithScores

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

zrangeByScoreWithScores

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

zrevrangeByScoreWithScores

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

zrevrangeByScoreWithScores

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

zremrangeByRank

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

zremrangeByScore

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

zremrangeByScore

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

zlexcount

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

zrangeByLex

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

zrangeByLex

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

zrevrangeByLex

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

zrevrangeByLex

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

zremrangeByLex

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

linsert

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

lpushx

Long lpushx(byte[] key,
            byte[]... arg)

rpushx

Long rpushx(byte[] key,
            byte[]... arg)

del

Long del(byte[] key)

unlink

Long unlink(byte[] key)

echo

byte[] echo(byte[] arg)

move

Long move(byte[] key,
          int dbIndex)

bitcount

Long bitcount(byte[] key)

bitcount

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

pfadd

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

pfcount

long pfcount(byte[] key)

geoadd

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

geoadd

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

geodist

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

geodist

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

geohash

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

geopos

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

georadius

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

georadiusReadonly

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

georadius

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

georadiusReadonly

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

georadiusByMember

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

georadiusByMemberReadonly

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

georadiusByMember

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

georadiusByMemberReadonly

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

hscan

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

hscan

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

sscan

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

sscan

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

zscan

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

zscan

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

bitfield

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

Executes BITFIELD Redis command

Parameters:

key -

arguments -

Returns:

bitfieldReadonly

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

hstrlen

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

Used for HSTRLEN Redis command

Parameters:

key -

field -

Returns:

lenth of the value for key

xadd

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

xlen

Long xlen(byte[] key)

xrange

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

xrevrange

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

xack

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

xgroupCreate

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

xgroupSetID

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

xgroupDestroy

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

xgroupDelConsumer

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

xdel

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

xtrim

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

xpending

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

xclaim

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

xinfoStream

StreamInfo xinfoStream(byte[] key)

xinfoGroup

List<StreamGroupInfo> xinfoGroup(byte[] key)

xinfoConsumers

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