redis.clients.jedis
Class BinaryTransaction

java.lang.Object
  redis.clients.jedis.Queable
      redis.clients.jedis.BinaryTransaction

Direct Known Subclasses:

Transaction

public class BinaryTransaction
extends Queable

Field Summary

protected Client	client
protected boolean	inTransaction

Constructor Summary

BinaryTransaction()

BinaryTransaction(Client client)

Method Summary

Response<Long>	append(byte[] key, byte[] value)
Response<List<String>>	blpop(byte[]... args)
Response<List<String>>	brpop(byte[]... args)
Response<byte[]>	brpoplpush(byte[] source, byte[] destination, int timeout)
Response<List<byte[]>>	configGet(byte[] pattern)
Response<String>	configResetStat()
Response<byte[]>	configSet(byte[] parameter, byte[] value)
Response<Long>	dbSize()
Response<Long>	decr(byte[] key)
Response<Long>	decrBy(byte[] key, long integer)
Response<Long>	del(byte[]... keys)
String	discard()
Response<String>	echo(byte[] string)
List<Object>	exec()
List<Response<?>>	execGetResponse()
Response<Boolean>	exists(byte[] key)
Response<Long>	expire(byte[] key, int seconds)
Response<Long>	expireAt(byte[] key, long unixTime)
Response<String>	flushAll()
Response<String>	flushDB()
Response<byte[]>	get(byte[] key)
Response<Boolean>	getbit(byte[] key, long offset)
Response<String>	getSet(byte[] key, byte[] value)
Response<Long>	hdel(byte[] key, byte[] field)
Response<Boolean>	hexists(byte[] key, byte[] field)
Response<byte[]>	hget(byte[] key, byte[] field)
Response<Map<String,String>>	hgetAll(byte[] key)
Response<Long>	hincrBy(byte[] key, byte[] field, long value)
Response<Set<byte[]>>	hkeys(byte[] key)
Response<Long>	hlen(byte[] key)
Response<List<byte[]>>	hmget(byte[] key, byte[]... fields)
Response<byte[]>	hmset(byte[] key, Map<byte[],byte[]> hash)
Response<Long>	hset(byte[] key, byte[] field, byte[] value)
Response<Long>	hsetnx(byte[] key, byte[] field, byte[] value)
Response<List<byte[]>>	hvals(byte[] key)
Response<Long>	incr(byte[] key)
Response<Long>	incrBy(byte[] key, long integer)
Response<String>	info()
Response<Set<byte[]>>	keys(byte[] pattern)
Response<Long>	lastsave()
Response<byte[]>	lindex(byte[] key, long index)
Response<Long>	linsert(byte[] key, BinaryClient.LIST_POSITION where, byte[] pivot, byte[] value)
Response<Long>	llen(byte[] key)
Response<byte[]>	lpop(byte[] key)
Response<Long>	lpush(byte[] key, byte[] string)
Response<Long>	lpushx(byte[] key, byte[] bytes)
Response<List<byte[]>>	lrange(byte[] key, long start, long end)
Response<Long>	lrem(byte[] key, long count, byte[] value)
Response<String>	lset(byte[] key, long index, byte[] value)
Response<String>	ltrim(byte[] key, long start, long end)
Response<List<byte[]>>	mget(byte[]... keys)
Response<Long>	move(byte[] key, int dbIndex)
Response<String>	mset(byte[]... keysvalues)
Response<Long>	msetnx(byte[]... keysvalues)
Response<Long>	persist(byte[] key)
Response<String>	ping()
Response<Long>	publish(byte[] channel, byte[] message)
Response<String>	randomKey()
Response<String>	rename(byte[] oldkey, byte[] newkey)
Response<Long>	renamenx(byte[] oldkey, byte[] newkey)
Response<byte[]>	rpop(byte[] key)
Response<byte[]>	rpoplpush(byte[] srckey, byte[] dstkey)
Response<Long>	rpush(byte[] key, byte[] string)
Response<Long>	rpushx(byte[] key, byte[] string)
Response<Long>	sadd(byte[] key, byte[] member)
Response<String>	save()
Response<Long>	scard(byte[] key)
Response<Set<byte[]>>	sdiff(byte[]... keys)
Response<Long>	sdiffstore(byte[] dstkey, byte[]... keys)
Response<String>	select(int index)
Response<byte[]>	set(byte[] key, byte[] value)
Response<Boolean>	setbit(byte[] key, long offset, byte[] value)
Response<Boolean>	setbit(String key, long offset, boolean value)
Response<String>	setex(byte[] key, int seconds, byte[] value)
Response<Long>	setnx(byte[] key, byte[] value)
Response<Long>	setrange(byte[] key, long offset, byte[] value)
Response<String>	shutdown()
Response<Set<byte[]>>	sinter(byte[]... keys)
Response<Long>	sinterstore(byte[] dstkey, byte[]... keys)
Response<Boolean>	sismember(byte[] key, byte[] member)
Response<Set<byte[]>>	smembers(byte[] key)
Response<Long>	smove(byte[] srckey, byte[] dstkey, byte[] member)
Response<List<byte[]>>	sort(byte[] key)
Response<List<byte[]>>	sort(byte[] key, byte[] dstkey)
Response<List<byte[]>>	sort(byte[] key, SortingParams sortingParameters)
Response<List<byte[]>>	sort(byte[] key, SortingParams sortingParameters, byte[] dstkey)
Response<byte[]>	spop(byte[] key)
Response<byte[]>	srandmember(byte[] key)
Response<Long>	srem(byte[] key, byte[] member)
Response<Long>	strlen(byte[] key)
Response<String>	substr(byte[] key, int start, int end)
Response<Set<byte[]>>	sunion(byte[]... keys)
Response<Long>	sunionstore(byte[] dstkey, byte[]... keys)
Response<Long>	ttl(byte[] key)
Response<String>	type(byte[] key)
Response<Long>	zadd(byte[] key, double score, byte[] member)
Response<Long>	zcard(byte[] key)
Response<Long>	zcount(byte[] key, byte[] min, byte[] max)
Response<Long>	zcount(byte[] key, double min, double max)
Response<Double>	zincrby(byte[] key, double score, byte[] member)
Response<Long>	zinterstore(byte[] dstkey, byte[]... sets)
Response<Long>	zinterstore(byte[] dstkey, ZParams params, byte[]... sets)
Response<Set<byte[]>>	zrange(byte[] key, int start, int end)
Response<Set<byte[]>>	zrangeByScore(byte[] key, byte[] min, byte[] max)
Response<Set<byte[]>>	zrangeByScore(byte[] key, byte[] min, byte[] max, int offset, int count)
Response<Set<byte[]>>	zrangeByScore(byte[] key, double min, double max)
Response<Set<byte[]>>	zrangeByScore(byte[] key, double min, double max, int offset, int count)
Response<Set<Tuple>>	zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max)
Response<Set<Tuple>>	zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max, int offset, int count)
Response<Set<Tuple>>	zrangeByScoreWithScores(byte[] key, double min, double max)
Response<Set<Tuple>>	zrangeByScoreWithScores(byte[] key, double min, double max, int offset, int count)
Response<Set<Tuple>>	zrangeWithScores(byte[] key, int start, int end)
Response<Long>	zrank(byte[] key, byte[] member)
Response<Long>	zrem(byte[] key, byte[] member)
Response<Long>	zremrangeByRank(byte[] key, int start, int end)
Response<Long>	zremrangeByScore(byte[] key, byte[] start, byte[] end)
Response<Long>	zremrangeByScore(byte[] key, double start, double end)
Response<Set<byte[]>>	zrevrange(byte[] key, int start, int end)
Response<Set<Tuple>>	zrevrangeWithScores(byte[] key, int start, int end)
Response<Long>	zrevrank(byte[] key, byte[] member)
Response<Double>	zscore(byte[] key, byte[] member)
Response<Long>	zunionstore(byte[] dstkey, byte[]... sets)
Response<Long>	zunionstore(byte[] dstkey, ZParams params, byte[]... sets)

Methods inherited from class redis.clients.jedis.Queable

clean, generateResponse, getResponse

Methods inherited from class java.lang.Object

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

Field Detail

client

protected Client client

inTransaction

protected boolean inTransaction

Constructor Detail

BinaryTransaction

public BinaryTransaction()

BinaryTransaction

public BinaryTransaction(Client client)

Method Detail

exec

public List<Object> exec()

execGetResponse

public List<Response<?>> execGetResponse()

discard

public String discard()

append

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

blpop

public Response<List<String>> blpop(byte[]... args)

brpop

public Response<List<String>> brpop(byte[]... args)

decr

public Response<Long> decr(byte[] key)

decrBy

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

del

public Response<Long> del(byte[]... keys)

echo

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

exists

public Response<Boolean> exists(byte[] key)

expire

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

expireAt

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

get

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

getSet

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

hdel

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

hexists

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

hget

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

hgetAll

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

hincrBy

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

hkeys

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

hlen

public Response<Long> hlen(byte[] key)

hmget

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

hmset

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

hset

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

hsetnx

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

hvals

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

incr

public Response<Long> incr(byte[] key)

incrBy

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

keys

public Response<Set<byte[]>> keys(byte[] pattern)

lindex

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

linsert

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

llen

public Response<Long> llen(byte[] key)

lpop

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

lpush

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

lpushx

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

lrange

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

lrem

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

lset

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

ltrim

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

mget

public Response<List<byte[]>> mget(byte[]... keys)

move

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

mset

public Response<String> mset(byte[]... keysvalues)

msetnx

public Response<Long> msetnx(byte[]... keysvalues)

persist

public Response<Long> persist(byte[] key)

rename

public Response<String> rename(byte[] oldkey,
                               byte[] newkey)

renamenx

public Response<Long> renamenx(byte[] oldkey,
                               byte[] newkey)

rpop

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

rpoplpush

public Response<byte[]> rpoplpush(byte[] srckey,
                                  byte[] dstkey)

rpush

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

rpushx

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

sadd

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

scard

public Response<Long> scard(byte[] key)

sdiff

public Response<Set<byte[]>> sdiff(byte[]... keys)

sdiffstore

public Response<Long> sdiffstore(byte[] dstkey,
                                 byte[]... keys)

set

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

setbit

public Response<Boolean> setbit(String key,
                                long offset,
                                boolean value)

setex

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

setnx

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

sinter

public Response<Set<byte[]>> sinter(byte[]... keys)

sinterstore

public Response<Long> sinterstore(byte[] dstkey,
                                  byte[]... keys)

sismember

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

smembers

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

smove

public Response<Long> smove(byte[] srckey,
                            byte[] dstkey,
                            byte[] member)

sort

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

sort

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

sort

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

sort

public Response<List<byte[]>> sort(byte[] key,
                                   byte[] dstkey)

spop

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

srandmember

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

srem

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

strlen

public Response<Long> strlen(byte[] key)

substr

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

sunion

public Response<Set<byte[]>> sunion(byte[]... keys)

sunionstore

public Response<Long> sunionstore(byte[] dstkey,
                                  byte[]... keys)

ttl

public Response<Long> ttl(byte[] key)

type

public Response<String> type(byte[] key)

zadd

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

zcard

public Response<Long> zcard(byte[] key)

zcount

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

zcount

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

zincrby

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

zinterstore

public Response<Long> zinterstore(byte[] dstkey,
                                  byte[]... sets)

zinterstore

public Response<Long> zinterstore(byte[] dstkey,
                                  ZParams params,
                                  byte[]... sets)

zrange

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

zrangeByScore

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

zrangeByScore

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

zrangeByScore

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

zrangeByScore

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

zrangeByScoreWithScores

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

zrangeByScoreWithScores

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

zrangeByScoreWithScores

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

zrangeByScoreWithScores

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

zrangeWithScores

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

zrank

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

zrem

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

zremrangeByRank

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

zremrangeByScore

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

zremrangeByScore

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

zrevrange

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

zrevrangeWithScores

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

zrevrank

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

zscore

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

zunionstore

public Response<Long> zunionstore(byte[] dstkey,
                                  byte[]... sets)

zunionstore

public Response<Long> zunionstore(byte[] dstkey,
                                  ZParams params,
                                  byte[]... sets)

brpoplpush

public Response<byte[]> brpoplpush(byte[] source,
                                   byte[] destination,
                                   int timeout)

select

public Response<String> select(int index)

flushDB

public Response<String> flushDB()

flushAll

public Response<String> flushAll()

save

public Response<String> save()

info

public Response<String> info()

lastsave

public Response<Long> lastsave()

dbSize

public Response<Long> dbSize()

configGet

public Response<List<byte[]>> configGet(byte[] pattern)

configSet

public Response<byte[]> configSet(byte[] parameter,
                                  byte[] value)

configResetStat

public Response<String> configResetStat()

shutdown

public Response<String> shutdown()

getbit

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

setbit

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

ping

public Response<String> ping()

setrange

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

randomKey

public Response<String> randomKey()

publish

public Response<Long> publish(byte[] channel,
                              byte[] message)