redis.clients.jedis

Interface BinaryJedisCommands

All Known Implementing Classes:

BinaryJedis, BinaryShardedJedis, Jedis, ShardedJedis

public interface BinaryJedisCommands

Common interface for sharded and non-sharded BinaryJedis

Method Summary

Methods

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<byte[]>	blpop(byte[] arg)
List<byte[]>	brpop(byte[] arg)
Long	decr(byte[] key)
Long	decrBy(byte[] key, long integer)
Long	del(byte[] key)
byte[]	echo(byte[] arg)
Boolean	exists(byte[] key)
Long	expire(byte[] key, int seconds)
Long	expireAt(byte[] key, long unixTime)
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)
Set<byte[]>	hkeys(byte[] key)
Long	hlen(byte[] key)
List<byte[]>	hmget(byte[] key, byte[]... fields)
String	hmset(byte[] key, Map<byte[],byte[]> hash)
Long	hset(byte[] key, byte[] field, byte[] value)
Long	hsetnx(byte[] key, byte[] field, byte[] value)
Collection<byte[]>	hvals(byte[] key)
Long	incr(byte[] key)
Long	incrBy(byte[] key, long integer)
byte[]	lindex(byte[] key, long index)
Long	linsert(byte[] key, BinaryClient.LIST_POSITION 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 end)
Long	lrem(byte[] key, long count, byte[] value)
String	lset(byte[] key, long index, byte[] value)
String	ltrim(byte[] key, long start, long end)
Long	move(byte[] key, int dbIndex)
Long	persist(byte[] key)
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)
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)
byte[]	srandmember(byte[] key)
Long	srem(byte[] key, byte[]... member)
Long	strlen(byte[] key)
byte[]	substr(byte[] key, int start, int end)
Long	ttl(byte[] key)
String	type(byte[] key)
Long	zadd(byte[] key, double score, byte[] member)
Long	zadd(byte[] key, Map<Double,byte[]> scoreMembers)
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 score, byte[] member)
Set<byte[]>	zrange(byte[] key, long start, long end)
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 end)
Long	zrank(byte[] key, byte[] member)
Long	zrem(byte[] key, byte[]... member)
Long	zremrangeByRank(byte[] key, long start, long end)
Long	zremrangeByScore(byte[] key, byte[] start, byte[] end)
Long	zremrangeByScore(byte[] key, double start, double end)
Set<byte[]>	zrevrange(byte[] key, long start, long end)
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 end)
Long	zrevrank(byte[] key, byte[] member)
Double	zscore(byte[] key, byte[] member)

Method Detail

set

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

get

byte[] get(byte[] key)

exists

Boolean exists(byte[] key)

persist

Long persist(byte[] key)

type

String type(byte[] key)

expire

Long expire(byte[] key,
          int seconds)

expireAt

Long expireAt(byte[] key,
            long unixTime)

ttl

Long ttl(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)

decrBy

Long decrBy(byte[] key,
          long integer)

decr

Long decr(byte[] key)

incrBy

Long incrBy(byte[] key,
          long integer)

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)

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)

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

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

ltrim

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

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)

scard

Long scard(byte[] key)

sismember

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

srandmember

byte[] srandmember(byte[] key)

strlen

Long strlen(byte[] key)

zadd

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

zadd

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

zrange

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

zrem

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

zincrby

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

zrank

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

zrevrank

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

zrevrange

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

zrangeWithScores

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

zrevrangeWithScores

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

zcard

Long zcard(byte[] key)

zscore

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

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

zremrangeByScore

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

zremrangeByScore

Long zremrangeByScore(byte[] key,
                    byte[] start,
                    byte[] end)

linsert

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

lpushx

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

rpushx

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

blpop

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

brpop

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

del

Long del(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)