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
 Long append(byte[] key, byte[] value)
           
 Long decr(byte[] key)
           
 Long decrBy(byte[] key, long integer)
           
 Boolean exists(byte[] key)
           
 Long expire(byte[] key, int seconds)
           
 Long expireAt(byte[] key, long unixTime)
           
 byte[] get(byte[] key)
           
 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, int 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[]... string)
           
 Long lpushx(byte[] key, byte[] string)
           
 List<byte[]> lrange(byte[] key, int start, int end)
           
 Long lrem(byte[] key, int count, byte[] value)
           
 String lset(byte[] key, int index, byte[] value)
           
 String ltrim(byte[] key, int start, int end)
           
 byte[] objectEncoding(byte[] key)
           
 Long objectIdletime(byte[] key)
           
 Long objectRefcount(byte[] key)
           
 byte[] rpop(byte[] key)
           
 Long rpush(byte[] key, byte[]... string)
           
 Long rpushx(byte[] key, byte[] string)
           
 Long sadd(byte[] key, byte[]... member)
           
 Long scard(byte[] key)
           
 String set(byte[] key, byte[] value)
           
 String setex(byte[] key, int seconds, byte[] value)
           
 Long setnx(byte[] key, 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)
           
 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, int start, int end)
           
 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, int start, int end)
           
 Long zrank(byte[] key, byte[] member)
           
 Long zrem(byte[] key, byte[]... member)
           
 Long zremrangeByRank(byte[] key, int start, int end)
           
 Long zremrangeByScore(byte[] key, byte[] start, byte[] end)
           
 Long zremrangeByScore(byte[] key, double start, double end)
           
 Set<byte[]> zrevrange(byte[] key, int start, int 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, int start, int 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)

type

String type(byte[] key)

expire

Long expire(byte[] key,
            int seconds)

expireAt

Long expireAt(byte[] key,
              long unixTime)

ttl

Long ttl(byte[] key)

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[]... string)

lpush

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

llen

Long llen(byte[] key)

lrange

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

ltrim

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

lindex

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

lset

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

lrem

Long lrem(byte[] key,
          int 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)

zadd

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

zadd

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

zrange

Set<byte[]> zrange(byte[] key,
                   int start,
                   int 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,
                      int start,
                      int end)

zrangeWithScores

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

zrevrangeWithScores

Set<Tuple> zrevrangeWithScores(byte[] key,
                               int start,
                               int 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,
                          double min,
                          double max,
                          int offset,
                          int count)

zrangeByScoreWithScores

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

zrangeByScoreWithScores

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

zrangeByScoreWithScores

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

zrangeByScoreWithScores

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

zrevrangeByScore

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

zrevrangeByScore

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

zrevrangeByScore

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

zrevrangeByScore

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

zrevrangeByScoreWithScores

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

zrevrangeByScoreWithScores

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

zrevrangeByScoreWithScores

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

zrevrangeByScoreWithScores

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

zremrangeByRank

Long zremrangeByRank(byte[] key,
                     int start,
                     int 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)

objectRefcount

Long objectRefcount(byte[] key)

objectIdletime

Long objectIdletime(byte[] key)

objectEncoding

byte[] objectEncoding(byte[] key)

lpushx

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

rpushx

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


Copyright © 2012. All Rights Reserved.