redis.clients.jedis

Class TransactionBase

java.lang.Object

redis.clients.jedis.Queable

redis.clients.jedis.TransactionBase

All Implemented Interfaces:

Closeable, AutoCloseable, BloomFilterPipelineCommands, CountMinSketchPipelineCommands, CuckooFilterPipelineCommands, RedisBloomPipelineCommands, TopKFilterPipelineCommands, FunctionPipelineBinaryCommands, FunctionPipelineCommands, GeoPipelineBinaryCommands, GeoPipelineCommands, HashPipelineBinaryCommands, HashPipelineCommands, HyperLogLogPipelineBinaryCommands, HyperLogLogPipelineCommands, KeyPipelineBinaryCommands, KeyPipelineCommands, ListPipelineBinaryCommands, ListPipelineCommands, PipelineBinaryCommands, PipelineCommands, RedisModulePipelineCommands, SampleBinaryKeyedPipelineCommands, SampleKeyedPipelineCommands, ScriptingKeyPipelineBinaryCommands, ScriptingKeyPipelineCommands, SetPipelineBinaryCommands, SetPipelineCommands, SortedSetPipelineBinaryCommands, SortedSetPipelineCommands, StreamPipelineBinaryCommands, StreamPipelineCommands, StringPipelineBinaryCommands, StringPipelineCommands, RedisGraphPipelineCommands, RedisJsonPipelineCommands, RediSearchPipelineCommands, RedisTimeSeriesPipelineCommands

Direct Known Subclasses:

ReliableTransaction, Transaction

public abstract class TransactionBase
extends Queable
implements PipelineCommands, PipelineBinaryCommands, RedisModulePipelineCommands, Closeable

Field Summary

Fields

Modifier and Type	Field and Description
protected Connection	connection

Constructor Summary

Constructors

Constructor and Description
TransactionBase(Connection connection)
TransactionBase(Connection connection, boolean doMulti) If you want to WATCH/UNWATCH keys before MULTI command you should do doMulti = true.

Method Summary

Modifier and Type	Method and Description
Response<Long>	append(byte[] key, byte[] value)
Response<Long>	append(String key, String value)
protected <T> Response<T>	appendCommand(CommandObject<T> commandObject)
Response<Boolean>	bfAdd(String key, String item)
Response<Boolean>	bfExists(String key, String item)
Response<Map<String,Object>>	bfInfo(String key)
Response<List<Boolean>>	bfInsert(String key, BFInsertParams insertParams, String... items)
Response<List<Boolean>>	bfInsert(String key, String... items)
Response<List<Boolean>>	bfMAdd(String key, String... items)
Response<List<Boolean>>	bfMExists(String key, String... items)
Response<String>	bfReserve(String key, double errorRate, long capacity)
Response<String>	bfReserve(String key, double errorRate, long capacity, BFReserveParams reserveParams)
Response<Long>	bitcount(byte[] key)
Response<Long>	bitcount(byte[] key, long start, long end)
Response<Long>	bitcount(byte[] key, long start, long end, BitCountOption option)
Response<Long>	bitcount(String key)
Response<Long>	bitcount(String key, long start, long end)
Response<Long>	bitcount(String key, long start, long end, BitCountOption option)
Response<List<Long>>	bitfield(byte[] key, byte[]... arguments)
Response<List<Long>>	bitfield(String key, String... arguments)
Response<List<Long>>	bitfieldReadonly(byte[] key, byte[]... arguments)
Response<List<Long>>	bitfieldReadonly(String key, String... arguments)
Response<Long>	bitop(BitOP op, byte[] destKey, byte[]... srcKeys)
Response<Long>	bitop(BitOP op, String destKey, String... srcKeys)
Response<Long>	bitpos(byte[] key, boolean value)
Response<Long>	bitpos(byte[] key, boolean value, BitPosParams params)
Response<Long>	bitpos(String key, boolean value)
Response<Long>	bitpos(String key, boolean value, BitPosParams params)
Response<byte[]>	blmove(byte[] srcKey, byte[] dstKey, ListDirection from, ListDirection to, double timeout)
Response<String>	blmove(String srcKey, String dstKey, ListDirection from, ListDirection to, double timeout)
Response<KeyValue<byte[],List<byte[]>>>	blmpop(long timeout, ListDirection direction, byte[]... keys)
Response<KeyValue<byte[],List<byte[]>>>	blmpop(long timeout, ListDirection direction, int count, byte[]... keys)
Response<KeyValue<String,List<String>>>	blmpop(long timeout, ListDirection direction, int count, String... keys)
Response<KeyValue<String,List<String>>>	blmpop(long timeout, ListDirection direction, String... keys)
Response<List<byte[]>>	blpop(double timeout, byte[]... keys)
Response<KeyedListElement>	blpop(double timeout, String... keys)
Response<KeyedListElement>	blpop(double timeout, String key)
Response<List<byte[]>>	blpop(int timeout, byte[]... keys)
Response<List<String>>	blpop(int timeout, String... keys)
Response<List<String>>	blpop(int timeout, String key)
Response<List<byte[]>>	brpop(double timeout, byte[]... keys)
Response<KeyedListElement>	brpop(double timeout, String... keys)
Response<KeyedListElement>	brpop(double timeout, String key)
Response<List<byte[]>>	brpop(int timeout, byte[]... keys)
Response<List<String>>	brpop(int timeout, String... keys)
Response<List<String>>	brpop(int timeout, String key)
Response<byte[]>	brpoplpush(byte[] source, byte[] destination, int timeout)
Response<String>	brpoplpush(String source, String destination, int timeout)
Response<KeyValue<byte[],List<Tuple>>>	bzmpop(long timeout, SortedSetOption option, byte[]... keys)
Response<KeyValue<byte[],List<Tuple>>>	bzmpop(long timeout, SortedSetOption option, int count, byte[]... keys)
Response<KeyValue<String,List<Tuple>>>	bzmpop(long timeout, SortedSetOption option, int count, String... keys)
Response<KeyValue<String,List<Tuple>>>	bzmpop(long timeout, SortedSetOption option, String... keys)
Response<List<byte[]>>	bzpopmax(double timeout, byte[]... keys)
Response<KeyedZSetElement>	bzpopmax(double timeout, String... keys)
Response<List<byte[]>>	bzpopmin(double timeout, byte[]... keys)
Response<KeyedZSetElement>	bzpopmin(double timeout, String... keys)
Response<Boolean>	cfAdd(String key, String item)
Response<Boolean>	cfAddNx(String key, String item)
Response<Long>	cfCount(String key, String item)
Response<Boolean>	cfDel(String key, String item)
Response<Boolean>	cfExists(String key, String item)
Response<Map<String,Object>>	cfInfo(String key)
Response<List<Boolean>>	cfInsert(String key, CFInsertParams insertParams, String... items)
Response<List<Boolean>>	cfInsert(String key, String... items)
Response<List<Boolean>>	cfInsertNx(String key, CFInsertParams insertParams, String... items)
Response<List<Boolean>>	cfInsertNx(String key, String... items)
Response<String>	cfReserve(String key, long capacity)
Response<String>	cfReserve(String key, long capacity, CFReserveParams reserveParams)
void	clear()
void	close()
Response<List<Long>>	cmsIncrBy(String key, Map<String,Long> itemIncrements)
Response<Map<String,Object>>	cmsInfo(String key)
Response<String>	cmsInitByDim(String key, long width, long depth)
Response<String>	cmsInitByProb(String key, double error, double probability)
Response<String>	cmsMerge(String destKey, Map<String,Long> keysAndWeights)
Response<String>	cmsMerge(String destKey, String... keys)
Response<List<Long>>	cmsQuery(String key, String... items)
Response<Boolean>	copy(byte[] srcKey, byte[] dstKey, boolean replace)
Response<Boolean>	copy(String srcKey, String dstKey, boolean replace)
Response<Long>	decr(byte[] key)
Response<Long>	decr(String key)
Response<Long>	decrBy(byte[] key, long decrement)
Response<Long>	decrBy(String key, long decrement)
Response<Long>	del(byte[]... keys)
Response<Long>	del(byte[] key)
Response<Long>	del(String... keys)
Response<Long>	del(String key)
String	discard()
Response<byte[]>	dump(byte[] key)
Response<byte[]>	dump(String key)
Response<Object>	eval(byte[] script)
Response<Object>	eval(byte[] script, byte[] sampleKey)
Response<Object>	eval(byte[] script, int keyCount, byte[]... params)
Response<Object>	eval(byte[] script, List<byte[]> keys, List<byte[]> args)
Response<Object>	eval(String script)
Response<Object>	eval(String script, int keyCount, String... params)
Response<Object>	eval(String script, List<String> keys, List<String> args)
Response<Object>	eval(String script, String sampleKey)
Response<Object>	evalReadonly(byte[] script, List<byte[]> keys, List<byte[]> args)
Response<Object>	evalReadonly(String script, List<String> keys, List<String> args)
Response<Object>	evalsha(byte[] sha1)
Response<Object>	evalsha(byte[] sha1, byte[] sampleKey)
Response<Object>	evalsha(byte[] sha1, int keyCount, byte[]... params)
Response<Object>	evalsha(byte[] sha1, List<byte[]> keys, List<byte[]> args)
Response<Object>	evalsha(String sha1)
Response<Object>	evalsha(String sha1, int keyCount, String... params)
Response<Object>	evalsha(String sha1, List<String> keys, List<String> args)
Response<Object>	evalsha(String sha1, String sampleKey)
Response<Object>	evalshaReadonly(byte[] sha1, List<byte[]> keys, List<byte[]> args)
Response<Object>	evalshaReadonly(String sha1, List<String> keys, List<String> args)
List<Object>	exec()
<T> Response<T>	executeCommand(CommandObject<T> command)
Response<Long>	exists(byte[]... keys)
Response<Boolean>	exists(byte[] key)
Response<Long>	exists(String... keys)
Response<Boolean>	exists(String key)
Response<Long>	expire(byte[] key, long seconds)
Response<Long>	expire(byte[] key, long seconds, ExpiryOption expiryOption)
Response<Long>	expire(String key, long seconds)
Response<Long>	expire(String key, long seconds, ExpiryOption expiryOption)
Response<Long>	expireAt(byte[] key, long unixTime)
Response<Long>	expireAt(byte[] key, long unixTime, ExpiryOption expiryOption)
Response<Long>	expireAt(String key, long unixTime)
Response<Long>	expireAt(String key, long unixTime, ExpiryOption expiryOption)
Response<Long>	expireTime(byte[] key)
Response<Long>	expireTime(String key)
Response<Object>	fcall(byte[] name, List<byte[]> keys, List<byte[]> args)
Response<Object>	fcall(String name, List<String> keys, List<String> args)
Response<Object>	fcallReadonly(byte[] name, List<byte[]> keys, List<byte[]> args)
Response<Object>	fcallReadonly(String name, List<String> keys, List<String> args)
Response<AggregationResult>	ftAggregate(String indexName, AggregationBuilder aggr)
Response<String>	ftAliasAdd(String aliasName, String indexName)
Response<String>	ftAliasDel(String aliasName)
Response<String>	ftAliasUpdate(String aliasName, String indexName)
Response<String>	ftAlter(String indexName, Schema schema)
Response<Map<String,String>>	ftConfigGet(String option)
Response<Map<String,String>>	ftConfigGet(String indexName, String option)
Response<String>	ftConfigSet(String option, String value)
Response<String>	ftConfigSet(String indexName, String option, String value)
Response<String>	ftCreate(String indexName, IndexOptions indexOptions, Schema schema)
Response<String>	ftCursorDel(String indexName, long cursorId)
Response<AggregationResult>	ftCursorRead(String indexName, long cursorId, int count)
Response<String>	ftDropIndex(String indexName)
Response<String>	ftDropIndexDD(String indexName)
Response<String>	ftExplain(String indexName, Query query)
Response<List<String>>	ftExplainCLI(String indexName, Query query)
Response<Map<String,Object>>	ftInfo(String indexName)
Response<SearchResult>	ftSearch(byte[] indexName, Query query)
Response<SearchResult>	ftSearch(String indexName, Query query)
Response<Map<String,List<String>>>	ftSynDump(String indexName)
Response<String>	ftSynUpdate(String indexName, String synonymGroupId, String... terms)
Response<String>	functionDelete(byte[] libraryName)
Response<String>	functionDelete(String libraryName)
Response<byte[]>	functionDump()
Response<String>	functionFlush()
Response<String>	functionFlush(FlushMode mode)
Response<String>	functionKill()
Response<List<LibraryInfo>>	functionList()
Response<List<Object>>	functionList(byte[] libraryNamePattern)
Response<List<LibraryInfo>>	functionList(String libraryNamePattern)
Response<List<Object>>	functionListBinary()
Response<List<LibraryInfo>>	functionListWithCode()
Response<List<Object>>	functionListWithCode(byte[] libraryNamePattern)
Response<List<LibraryInfo>>	functionListWithCode(String libraryNamePattern)
Response<List<Object>>	functionListWithCodeBinary()
Response<String>	functionLoad(byte[] functionCode)
Response<String>	functionLoad(String functionCode)
Response<String>	functionLoadReplace(byte[] functionCode)
Response<String>	functionLoadReplace(String functionCode)
Response<String>	functionRestore(byte[] serializedValue)
Response<String>	functionRestore(byte[] serializedValue, FunctionRestorePolicy policy)
Response<FunctionStats>	functionStats()
Response<Object>	functionStatsBinary()
Response<Long>	geoadd(byte[] key, double longitude, double latitude, byte[] member)
Response<Long>	geoadd(byte[] key, GeoAddParams params, Map<byte[],GeoCoordinate> memberCoordinateMap)
Response<Long>	geoadd(byte[] key, Map<byte[],GeoCoordinate> memberCoordinateMap)
Response<Long>	geoadd(String key, double longitude, double latitude, String member)
Response<Long>	geoadd(String key, GeoAddParams params, Map<String,GeoCoordinate> memberCoordinateMap)
Response<Long>	geoadd(String key, Map<String,GeoCoordinate> memberCoordinateMap)
Response<Double>	geodist(byte[] key, byte[] member1, byte[] member2)
Response<Double>	geodist(byte[] key, byte[] member1, byte[] member2, GeoUnit unit)
Response<Double>	geodist(String key, String member1, String member2)
Response<Double>	geodist(String key, String member1, String member2, GeoUnit unit)
Response<List<byte[]>>	geohash(byte[] key, byte[]... members)
Response<List<String>>	geohash(String key, String... members)
Response<List<GeoCoordinate>>	geopos(byte[] key, byte[]... members)
Response<List<GeoCoordinate>>	geopos(String key, String... members)
Response<List<GeoRadiusResponse>>	georadius(byte[] key, double longitude, double latitude, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	georadius(byte[] key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param)
Response<List<GeoRadiusResponse>>	georadius(String key, double longitude, double latitude, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	georadius(String key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param)
Response<List<GeoRadiusResponse>>	georadiusByMember(byte[] key, byte[] member, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	georadiusByMember(byte[] key, byte[] member, double radius, GeoUnit unit, GeoRadiusParam param)
Response<List<GeoRadiusResponse>>	georadiusByMember(String key, String member, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	georadiusByMember(String key, String member, double radius, GeoUnit unit, GeoRadiusParam param)
Response<List<GeoRadiusResponse>>	georadiusByMemberReadonly(byte[] key, byte[] member, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	georadiusByMemberReadonly(byte[] key, byte[] member, double radius, GeoUnit unit, GeoRadiusParam param)
Response<List<GeoRadiusResponse>>	georadiusByMemberReadonly(String key, String member, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	georadiusByMemberReadonly(String key, String member, double radius, GeoUnit unit, GeoRadiusParam param)
Response<Long>	georadiusByMemberStore(byte[] key, byte[] member, double radius, GeoUnit unit, GeoRadiusParam param, GeoRadiusStoreParam storeParam)
Response<Long>	georadiusByMemberStore(String key, String member, double radius, GeoUnit unit, GeoRadiusParam param, GeoRadiusStoreParam storeParam)
Response<List<GeoRadiusResponse>>	georadiusReadonly(byte[] key, double longitude, double latitude, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	georadiusReadonly(byte[] key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param)
Response<List<GeoRadiusResponse>>	georadiusReadonly(String key, double longitude, double latitude, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	georadiusReadonly(String key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param)
Response<Long>	georadiusStore(byte[] key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param, GeoRadiusStoreParam storeParam)
Response<Long>	georadiusStore(String key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param, GeoRadiusStoreParam storeParam)
Response<List<GeoRadiusResponse>>	geosearch(byte[] key, byte[] member, double width, double height, GeoUnit unit)
Response<List<GeoRadiusResponse>>	geosearch(byte[] key, byte[] member, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	geosearch(byte[] key, GeoCoordinate coord, double width, double height, GeoUnit unit)
Response<List<GeoRadiusResponse>>	geosearch(byte[] key, GeoCoordinate coord, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	geosearch(byte[] key, GeoSearchParam params)
Response<List<GeoRadiusResponse>>	geosearch(String key, GeoCoordinate coord, double width, double height, GeoUnit unit)
Response<List<GeoRadiusResponse>>	geosearch(String key, GeoCoordinate coord, double radius, GeoUnit unit)
Response<List<GeoRadiusResponse>>	geosearch(String key, GeoSearchParam params)
Response<List<GeoRadiusResponse>>	geosearch(String key, String member, double width, double height, GeoUnit unit)
Response<List<GeoRadiusResponse>>	geosearch(String key, String member, double radius, GeoUnit unit)
Response<Long>	geosearchStore(byte[] dest, byte[] src, byte[] member, double width, double height, GeoUnit unit)
Response<Long>	geosearchStore(byte[] dest, byte[] src, byte[] member, double radius, GeoUnit unit)
Response<Long>	geosearchStore(byte[] dest, byte[] src, GeoCoordinate coord, double width, double height, GeoUnit unit)
Response<Long>	geosearchStore(byte[] dest, byte[] src, GeoCoordinate coord, double radius, GeoUnit unit)
Response<Long>	geosearchStore(byte[] dest, byte[] src, GeoSearchParam params)
Response<Long>	geosearchStore(String dest, String src, GeoCoordinate coord, double width, double height, GeoUnit unit)
Response<Long>	geosearchStore(String dest, String src, GeoCoordinate coord, double radius, GeoUnit unit)
Response<Long>	geosearchStore(String dest, String src, GeoSearchParam params)
Response<Long>	geosearchStore(String dest, String src, String member, double width, double height, GeoUnit unit)
Response<Long>	geosearchStore(String dest, String src, String member, double radius, GeoUnit unit)
Response<Long>	geosearchStoreStoreDist(byte[] dest, byte[] src, GeoSearchParam params)
Response<Long>	geosearchStoreStoreDist(String dest, String src, GeoSearchParam params)
Response<byte[]>	get(byte[] key)
Response<String>	get(String key)
Response<Boolean>	getbit(byte[] key, long offset)
Response<Boolean>	getbit(String key, long offset)
Response<byte[]>	getDel(byte[] key)
Response<String>	getDel(String key)
Response<byte[]>	getEx(byte[] key, GetExParams params)
Response<String>	getEx(String key, GetExParams params)
Response<byte[]>	getrange(byte[] key, long startOffset, long endOffset)
Response<String>	getrange(String key, long startOffset, long endOffset)
Response<byte[]>	getSet(byte[] key, byte[] value)
Response<String>	getSet(String key, String value)
Response<String>	graphDelete(String name)
Response<ResultSet>	graphQuery(String name, String query)
Response<ResultSet>	graphQuery(String name, String query, long timeout)
Response<ResultSet>	graphQuery(String name, String query, Map<String,Object> params)
Response<ResultSet>	graphQuery(String name, String query, Map<String,Object> params, long timeout)
Response<ResultSet>	graphReadonlyQuery(String name, String query)
Response<ResultSet>	graphReadonlyQuery(String name, String query, long timeout)
Response<ResultSet>	graphReadonlyQuery(String name, String query, Map<String,Object> params)
Response<ResultSet>	graphReadonlyQuery(String name, String query, Map<String,Object> params, long timeout)
Response<Long>	hdel(byte[] key, byte[]... field)
Response<Long>	hdel(String key, String... field)
Response<Boolean>	hexists(byte[] key, byte[] field)
Response<Boolean>	hexists(String key, String field)
Response<byte[]>	hget(byte[] key, byte[] field)
Response<String>	hget(String key, String field)
Response<Map<byte[],byte[]>>	hgetAll(byte[] key)
Response<Map<String,String>>	hgetAll(String key)
Response<Long>	hincrBy(byte[] key, byte[] field, long value)
Response<Long>	hincrBy(String key, String field, long value)
Response<Double>	hincrByFloat(byte[] key, byte[] field, double value)
Response<Double>	hincrByFloat(String key, String field, double value)
Response<Set<byte[]>>	hkeys(byte[] key)
Response<Set<String>>	hkeys(String key)
Response<Long>	hlen(byte[] key)
Response<Long>	hlen(String key)
Response<List<byte[]>>	hmget(byte[] key, byte[]... fields)
Response<List<String>>	hmget(String key, String... fields)
Response<String>	hmset(byte[] key, Map<byte[],byte[]> hash)
Response<String>	hmset(String key, Map<String,String> hash)
Response<byte[]>	hrandfield(byte[] key)
Response<List<byte[]>>	hrandfield(byte[] key, long count)
Response<String>	hrandfield(String key)
Response<List<String>>	hrandfield(String key, long count)
Response<Map<byte[],byte[]>>	hrandfieldWithValues(byte[] key, long count)
Response<Map<String,String>>	hrandfieldWithValues(String key, long count)
Response<ScanResult<Map.Entry<byte[],byte[]>>>	hscan(byte[] key, byte[] cursor, ScanParams params)
Response<ScanResult<Map.Entry<String,String>>>	hscan(String key, String cursor, ScanParams params)
Response<Long>	hset(byte[] key, byte[] field, byte[] value)
Response<Long>	hset(byte[] key, Map<byte[],byte[]> hash)
Response<Long>	hset(String key, Map<String,String> hash)
Response<Long>	hset(String key, String field, String value)
Response<Long>	hsetnx(byte[] key, byte[] field, byte[] value)
Response<Long>	hsetnx(String key, String field, String value)
Response<Long>	hstrlen(byte[] key, byte[] field)
Response<Long>	hstrlen(String key, String field)
Response<List<byte[]>>	hvals(byte[] key)
Response<List<String>>	hvals(String key)
Response<Long>	incr(byte[] key)
Response<Long>	incr(String key)
Response<Long>	incrBy(byte[] key, long increment)
Response<Long>	incrBy(String key, long increment)
Response<Double>	incrByFloat(byte[] key, double increment)
Response<Double>	incrByFloat(String key, double increment)
Response<List<Long>>	jsonArrAppend(String key, Path2 path, Object... objects)
Response<Long>	jsonArrAppend(String key, Path path, Object... objects)
Response<List<Long>>	jsonArrAppendWithEscape(String key, Path2 path, Object... objects)
Response<List<Long>>	jsonArrIndex(String key, Path2 path, Object scalar)
Response<Long>	jsonArrIndex(String key, Path path, Object scalar)
Response<List<Long>>	jsonArrIndexWithEscape(String key, Path2 path, Object scalar)
Response<List<Long>>	jsonArrInsert(String key, Path2 path, int index, Object... objects)
Response<Long>	jsonArrInsert(String key, Path path, int index, Object... pojos)
Response<List<Long>>	jsonArrInsertWithEscape(String key, Path2 path, int index, Object... objects)
Response<Long>	jsonArrLen(String key)
Response<Long>	jsonArrLen(String key, Path path)
Response<List<Long>>	jsonArrLen(String key, Path2 path)
Response<Object>	jsonArrPop(String key)
<T> Response<T>	jsonArrPop(String key, Class<T> clazz)
<T> Response<T>	jsonArrPop(String key, Class<T> clazz, Path path)
<T> Response<T>	jsonArrPop(String key, Class<T> clazz, Path path, int index)
Response<Object>	jsonArrPop(String key, Path path)
Response<List<Object>>	jsonArrPop(String key, Path2 path)
Response<List<Object>>	jsonArrPop(String key, Path2 path, int index)
Response<Object>	jsonArrPop(String key, Path path, int index)
Response<List<Long>>	jsonArrTrim(String key, Path2 path, int start, int stop)
Response<Long>	jsonArrTrim(String key, Path path, int start, int stop)
Response<Long>	jsonClear(String key)
Response<Long>	jsonClear(String key, Path path)
Response<Long>	jsonClear(String key, Path2 path)
Response<Long>	jsonDel(String key)
Response<Long>	jsonDel(String key, Path path)
Response<Long>	jsonDel(String key, Path2 path)
Response<Object>	jsonGet(String key)
<T> Response<T>	jsonGet(String key, Class<T> clazz)
<T> Response<T>	jsonGet(String key, Class<T> clazz, Path... paths)
Response<Object>	jsonGet(String key, Path... paths)
Response<Object>	jsonGet(String key, Path2... paths)
Response<List<org.json.JSONArray>>	jsonMGet(Path2 path, String... keys)
<T> Response<List<T>>	jsonMGet(Path path, Class<T> clazz, String... keys)
Response<String>	jsonSet(String key, Path2 path, Object object)
Response<String>	jsonSet(String key, Path2 path, Object object, JsonSetParams params)
Response<String>	jsonSet(String key, Path path, Object object)
Response<String>	jsonSet(String key, Path path, Object object, JsonSetParams params)
Response<String>	jsonSetWithEscape(String key, Path2 path, Object object)
Response<String>	jsonSetWithEscape(String key, Path2 path, Object object, JsonSetParams params)
Response<Long>	jsonStrAppend(String key, Object string)
Response<List<Long>>	jsonStrAppend(String key, Path2 path, Object string)
Response<Long>	jsonStrAppend(String key, Path path, Object string)
Response<Long>	jsonStrLen(String key)
Response<Long>	jsonStrLen(String key, Path path)
Response<List<Long>>	jsonStrLen(String key, Path2 path)
Response<String>	jsonToggle(String key, Path path)
Response<List<Boolean>>	jsonToggle(String key, Path2 path)
Response<Class<?>>	jsonType(String key)
Response<Class<?>>	jsonType(String key, Path path)
Response<List<Class<?>>>	jsonType(String key, Path2 path)
Response<Set<byte[]>>	keys(byte[] pattern)
Response<Set<String>>	keys(String pattern)
Response<LCSMatchResult>	lcs(byte[] keyA, byte[] keyB, LCSParams params)
Response<LCSMatchResult>	lcs(String keyA, String keyB, LCSParams params)
Response<byte[]>	lindex(byte[] key, long index)
Response<String>	lindex(String key, long index)
Response<Long>	linsert(byte[] key, ListPosition where, byte[] pivot, byte[] value)
Response<Long>	linsert(String key, ListPosition where, String pivot, String value)
Response<Long>	llen(byte[] key)
Response<Long>	llen(String key)
Response<byte[]>	lmove(byte[] srcKey, byte[] dstKey, ListDirection from, ListDirection to)
Response<String>	lmove(String srcKey, String dstKey, ListDirection from, ListDirection to)
Response<KeyValue<byte[],List<byte[]>>>	lmpop(ListDirection direction, byte[]... keys)
Response<KeyValue<byte[],List<byte[]>>>	lmpop(ListDirection direction, int count, byte[]... keys)
Response<KeyValue<String,List<String>>>	lmpop(ListDirection direction, int count, String... keys)
Response<KeyValue<String,List<String>>>	lmpop(ListDirection direction, String... keys)
Response<byte[]>	lpop(byte[] key)
Response<List<byte[]>>	lpop(byte[] key, int count)
Response<String>	lpop(String key)
Response<List<String>>	lpop(String key, int count)
Response<Long>	lpos(byte[] key, byte[] element)
Response<Long>	lpos(byte[] key, byte[] element, LPosParams params)
Response<List<Long>>	lpos(byte[] key, byte[] element, LPosParams params, long count)
Response<Long>	lpos(String key, String element)
Response<Long>	lpos(String key, String element, LPosParams params)
Response<List<Long>>	lpos(String key, String element, LPosParams params, long count)
Response<Long>	lpush(byte[] key, byte[]... args)
Response<Long>	lpush(String key, String... string)
Response<Long>	lpushx(byte[] key, byte[]... args)
Response<Long>	lpushx(String key, String... strings)
Response<List<byte[]>>	lrange(byte[] key, long start, long stop)
Response<List<String>>	lrange(String key, long start, long stop)
Response<Long>	lrem(byte[] key, long count, byte[] value)
Response<Long>	lrem(String key, long count, String value)
Response<String>	lset(byte[] key, long index, byte[] value)
Response<String>	lset(String key, long index, String value)
Response<String>	ltrim(byte[] key, long start, long stop)
Response<String>	ltrim(String key, long start, long stop)
Response<Long>	memoryUsage(byte[] key)
Response<Long>	memoryUsage(byte[] key, int samples)
Response<Long>	memoryUsage(String key)
Response<Long>	memoryUsage(String key, int samples)
Response<List<byte[]>>	mget(byte[]... keys)
Response<List<String>>	mget(String... keys)
Response<String>	migrate(String host, int port, byte[] key, int timeout)
Response<String>	migrate(String host, int port, int timeout, MigrateParams params, byte[]... keys)
Response<String>	migrate(String host, int port, int timeout, MigrateParams params, String... keys)
Response<String>	migrate(String host, int port, String key, int timeout)
Response<String>	mset(byte[]... keysvalues)
Response<String>	mset(String... keysvalues)
Response<Long>	msetnx(byte[]... keysvalues)
Response<Long>	msetnx(String... keysvalues)
void	multi()
Response<byte[]>	objectEncoding(byte[] key)
Response<String>	objectEncoding(String key)
Response<Long>	objectFreq(byte[] key)
Response<Long>	objectFreq(String key)
Response<Long>	objectIdletime(byte[] key)
Response<Long>	objectIdletime(String key)
Response<Long>	objectRefcount(byte[] key)
Response<Long>	objectRefcount(String key)
Response<Long>	persist(byte[] key)
Response<Long>	persist(String key)
Response<Long>	pexpire(byte[] key, long milliseconds)
Response<Long>	pexpire(byte[] key, long milliseconds, ExpiryOption expiryOption)
Response<Long>	pexpire(String key, long milliseconds)
Response<Long>	pexpire(String key, long milliseconds, ExpiryOption expiryOption)
Response<Long>	pexpireAt(byte[] key, long millisecondsTimestamp)
Response<Long>	pexpireAt(byte[] key, long millisecondsTimestamp, ExpiryOption expiryOption)
Response<Long>	pexpireAt(String key, long millisecondsTimestamp)
Response<Long>	pexpireAt(String key, long millisecondsTimestamp, ExpiryOption expiryOption)
Response<Long>	pexpireTime(byte[] key)
Response<Long>	pexpireTime(String key)
Response<Long>	pfadd(byte[] key, byte[]... elements)
Response<Long>	pfadd(String key, String... elements)
Response<Long>	pfcount(byte[]... keys)
Response<Long>	pfcount(byte[] key)
Response<Long>	pfcount(String... keys)
Response<Long>	pfcount(String key)
Response<String>	pfmerge(byte[] destkey, byte[]... sourcekeys)
Response<String>	pfmerge(String destkey, String... sourcekeys)
protected abstract void	processAppendStatus()
protected abstract void	processMultiResponse()
protected abstract void	processPipelinedResponses()
Response<String>	psetex(byte[] key, long milliseconds, byte[] value)
Response<String>	psetex(String key, long milliseconds, String value)
Response<Long>	pttl(byte[] key)
Response<Long>	pttl(String key)
Response<Long>	publish(byte[] channel, byte[] message)
Response<Long>	publish(String channel, String message)
Response<byte[]>	randomBinaryKey()
Response<String>	randomKey()
Response<String>	rename(byte[] oldkey, byte[] newkey)
Response<String>	rename(String oldkey, String newkey)
Response<Long>	renamenx(byte[] oldkey, byte[] newkey)
Response<Long>	renamenx(String oldkey, String newkey)
Response<String>	restore(byte[] key, long ttl, byte[] serializedValue)
Response<String>	restore(byte[] key, long ttl, byte[] serializedValue, RestoreParams params)
Response<String>	restore(String key, long ttl, byte[] serializedValue)
Response<String>	restore(String key, long ttl, byte[] serializedValue, RestoreParams params)
Response<byte[]>	rpop(byte[] key)
Response<List<byte[]>>	rpop(byte[] key, int count)
Response<String>	rpop(String key)
Response<List<String>>	rpop(String key, int count)
Response<byte[]>	rpoplpush(byte[] srckey, byte[] dstkey)
Response<String>	rpoplpush(String srcKey, String dstKey)
Response<Long>	rpush(byte[] key, byte[]... args)
Response<Long>	rpush(String key, String... string)
Response<Long>	rpushx(byte[] key, byte[]... args)
Response<Long>	rpushx(String key, String... strings)
Response<Long>	sadd(byte[] key, byte[]... members)
Response<Long>	sadd(String key, String... members)
Response<ScanResult<byte[]>>	scan(byte[] cursor)
Response<ScanResult<byte[]>>	scan(byte[] cursor, ScanParams params)
Response<ScanResult<byte[]>>	scan(byte[] cursor, ScanParams params, byte[] type)
Response<ScanResult<String>>	scan(String cursor)
Response<ScanResult<String>>	scan(String cursor, ScanParams params)
Response<ScanResult<String>>	scan(String cursor, ScanParams params, String type)
Response<Long>	scard(byte[] key)
Response<Long>	scard(String key)
Response<List<Boolean>>	scriptExists(byte[] sampleKey, byte[]... sha1s)
Response<List<Boolean>>	scriptExists(String sampleKey, String... sha1)
Response<String>	scriptFlush(byte[] sampleKey)
Response<String>	scriptFlush(byte[] sampleKey, FlushMode flushMode)
Response<String>	scriptFlush(String sampleKey)
Response<String>	scriptFlush(String sampleKey, FlushMode flushMode)
Response<String>	scriptKill(byte[] sampleKey)
Response<String>	scriptKill(String sampleKey)
Response<byte[]>	scriptLoad(byte[] script, byte[] sampleKey)
Response<String>	scriptLoad(String script, String sampleKey)
Response<Set<byte[]>>	sdiff(byte[]... keys)
Response<Set<String>>	sdiff(String... keys)
Response<Long>	sdiffstore(byte[] dstkey, byte[]... keys)
Response<Long>	sdiffstore(String dstKey, String... keys)
Response<Object>	sendCommand(CommandArguments args)
Response<Object>	sendCommand(ProtocolCommand cmd, byte[]... args)
Response<Object>	sendCommand(ProtocolCommand cmd, String... args)
Response<String>	set(byte[] key, byte[] value)
Response<String>	set(byte[] key, byte[] value, SetParams params)
Response<String>	set(String key, String value)
Response<String>	set(String key, String value, SetParams params)
Response<Boolean>	setbit(byte[] key, long offset, boolean value)
Response<Boolean>	setbit(String key, long offset, boolean value)
Response<String>	setex(byte[] key, long seconds, byte[] value)
Response<String>	setex(String key, long seconds, String value)
Response<Long>	setnx(byte[] key, byte[] value)
Response<Long>	setnx(String key, String value)
Response<Long>	setrange(byte[] key, long offset, byte[] value)
Response<Long>	setrange(String key, long offset, String value)
Response<Set<byte[]>>	sinter(byte[]... keys)
Response<Set<String>>	sinter(String... keys)
Response<Long>	sintercard(byte[]... keys)
Response<Long>	sintercard(int limit, byte[]... keys)
Response<Long>	sintercard(int limit, String... keys)
Response<Long>	sintercard(String... keys)
Response<Long>	sinterstore(byte[] dstkey, byte[]... keys)
Response<Long>	sinterstore(String dstKey, String... keys)
Response<Boolean>	sismember(byte[] key, byte[] member)
Response<Boolean>	sismember(String key, String member)
Response<Set<byte[]>>	smembers(byte[] key)
Response<Set<String>>	smembers(String key)
Response<List<Boolean>>	smismember(byte[] key, byte[]... members)
Response<List<Boolean>>	smismember(String key, String... members)
Response<Long>	smove(byte[] srckey, byte[] dstkey, byte[] member)
Response<Long>	smove(String srcKey, String dstKey, String member)
Response<List<byte[]>>	sort(byte[] key)
Response<Long>	sort(byte[] key, byte[] dstkey)
Response<List<byte[]>>	sort(byte[] key, SortingParams sortingParams)
Response<Long>	sort(byte[] key, SortingParams sortingParams, byte[] dstkey)
Response<List<String>>	sort(String key)
Response<List<String>>	sort(String key, SortingParams sortingParams)
Response<Long>	sort(String key, SortingParams sortingParams, String dstKey)
Response<Long>	sort(String key, String dstKey)
Response<List<byte[]>>	sortReadonly(byte[] key, SortingParams sortingParams)
Response<List<String>>	sortReadonly(String key, SortingParams sortingParams)
Response<byte[]>	spop(byte[] key)
Response<Set<byte[]>>	spop(byte[] key, long count)
Response<String>	spop(String key)
Response<Set<String>>	spop(String key, long count)
Response<byte[]>	srandmember(byte[] key)
Response<List<byte[]>>	srandmember(byte[] key, int count)
Response<String>	srandmember(String key)
Response<List<String>>	srandmember(String key, int count)
Response<Long>	srem(byte[] key, byte[]... members)
Response<Long>	srem(String key, String... members)
Response<ScanResult<byte[]>>	sscan(byte[] key, byte[] cursor, ScanParams params)
Response<ScanResult<String>>	sscan(String key, String cursor, ScanParams params)
Response<LCSMatchResult>	strAlgoLCSKeys(byte[] keyA, byte[] keyB, StrAlgoLCSParams params)
Response<LCSMatchResult>	strAlgoLCSKeys(String keyA, String keyB, StrAlgoLCSParams params)
Response<LCSMatchResult>	strAlgoLCSStrings(byte[] strA, byte[] strB, StrAlgoLCSParams params)
Response<LCSMatchResult>	strAlgoLCSStrings(String strA, String strB, StrAlgoLCSParams params)
Response<Long>	strlen(byte[] key)
Response<Long>	strlen(String key)
Response<byte[]>	substr(byte[] key, int start, int end)
Response<String>	substr(String key, int start, int end)
Response<Set<byte[]>>	sunion(byte[]... keys)
Response<Set<String>>	sunion(String... keys)
Response<Long>	sunionstore(byte[] dstkey, byte[]... keys)
Response<Long>	sunionstore(String dstKey, String... keys)
Response<List<String>>	topkAdd(String key, String... items)
Response<List<Long>>	topkCount(String key, String... items)
Response<List<String>>	topkIncrBy(String key, Map<String,Long> itemIncrements)
Response<Map<String,Object>>	topkInfo(String key)
Response<List<String>>	topkList(String key)
Response<List<Boolean>>	topkQuery(String key, String... items)
Response<String>	topkReserve(String key, long topk)
Response<String>	topkReserve(String key, long topk, long width, long depth, double decay)
Response<Long>	touch(byte[]... keys)
Response<Long>	touch(byte[] key)
Response<Long>	touch(String... keys)
Response<Long>	touch(String key)
Response<Long>	tsAdd(String key, double value)
Response<Long>	tsAdd(String key, long timestamp, double value)
Response<Long>	tsAdd(String key, long timestamp, double value, TSCreateParams createParams)
Response<String>	tsAlter(String key, TSAlterParams alterParams)
Response<String>	tsCreate(String key)
Response<String>	tsCreate(String key, TSCreateParams createParams)
Response<String>	tsCreateRule(String sourceKey, String destKey, AggregationType aggregationType, long timeBucket)
Response<Long>	tsDel(String key, long fromTimestamp, long toTimestamp)
Response<String>	tsDeleteRule(String sourceKey, String destKey)
Response<TSElement>	tsGet(String key)
Response<List<TSKeyValue<TSElement>>>	tsMGet(TSMGetParams multiGetParams, String... filters)
Response<List<TSKeyedElements>>	tsMRange(long fromTimestamp, long toTimestamp, String... filters)
Response<List<TSKeyedElements>>	tsMRange(TSMRangeParams multiRangeParams)
Response<List<TSKeyedElements>>	tsMRevRange(long fromTimestamp, long toTimestamp, String... filters)
Response<List<TSKeyedElements>>	tsMRevRange(TSMRangeParams multiRangeParams)
Response<List<String>>	tsQueryIndex(String... filters)
Response<List<TSElement>>	tsRange(String key, long fromTimestamp, long toTimestamp)
Response<List<TSElement>>	tsRange(String key, TSRangeParams rangeParams)
Response<List<TSElement>>	tsRevRange(String key, long fromTimestamp, long toTimestamp)
Response<List<TSElement>>	tsRevRange(String key, TSRangeParams rangeParams)
Response<Long>	ttl(byte[] key)
Response<Long>	ttl(String key)
Response<String>	type(byte[] key)
Response<String>	type(String key)
Response<Long>	unlink(byte[]... keys)
Response<Long>	unlink(byte[] key)
Response<Long>	unlink(String... keys)
Response<Long>	unlink(String key)
String	unwatch()
Response<Long>	waitReplicas(byte[] sampleKey, int replicas, long timeout)
Response<Long>	waitReplicas(int replicas, long timeout)
Response<Long>	waitReplicas(String sampleKey, int replicas, long timeout)
String	watch(byte[]... keys)
String	watch(String... keys)
Response<Long>	xack(byte[] key, byte[] group, byte[]... ids)
Response<Long>	xack(String key, String group, StreamEntryID... ids) XACK key group ID [ID ...]
Response<byte[]>	xadd(byte[] key, XAddParams params, Map<byte[],byte[]> hash)
Response<StreamEntryID>	xadd(String key, StreamEntryID id, Map<String,String> hash) XADD key ID field string [field string ...]
Response<StreamEntryID>	xadd(String key, XAddParams params, Map<String,String> hash)
Response<List<Object>>	xautoclaim(byte[] key, byte[] groupName, byte[] consumerName, long minIdleTime, byte[] start, XAutoClaimParams params)
Response<Map.Entry<StreamEntryID,List<StreamEntry>>>	xautoclaim(String key, String group, String consumerName, long minIdleTime, StreamEntryID start, XAutoClaimParams params) XAUTOCLAIM key group consumer min-idle-time start [COUNT count]
Response<List<Object>>	xautoclaimJustId(byte[] key, byte[] groupName, byte[] consumerName, long minIdleTime, byte[] start, XAutoClaimParams params)
Response<Map.Entry<StreamEntryID,List<StreamEntryID>>>	xautoclaimJustId(String key, String group, String consumerName, long minIdleTime, StreamEntryID start, XAutoClaimParams params) XAUTOCLAIM key group consumer min-idle-time start [COUNT count] JUSTID
Response<List<byte[]>>	xclaim(byte[] key, byte[] group, byte[] consumerName, long minIdleTime, XClaimParams params, byte[]... ids)
Response<List<StreamEntry>>	xclaim(String key, String group, String consumerName, long minIdleTime, XClaimParams params, StreamEntryID... ids) XCLAIM ...
Response<List<byte[]>>	xclaimJustId(byte[] key, byte[] group, byte[] consumerName, long minIdleTime, XClaimParams params, byte[]... ids)
Response<List<StreamEntryID>>	xclaimJustId(String key, String group, String consumerName, long minIdleTime, XClaimParams params, StreamEntryID... ids) XCLAIM ...
Response<Long>	xdel(byte[] key, byte[]... ids)
Response<Long>	xdel(String key, StreamEntryID... ids) XDEL key ID [ID ...]
Response<String>	xgroupCreate(byte[] key, byte[] groupName, byte[] id, boolean makeStream)
Response<String>	xgroupCreate(String key, String groupName, StreamEntryID id, boolean makeStream) XGROUP CREATE
Response<Boolean>	xgroupCreateConsumer(byte[] key, byte[] groupName, byte[] consumerName)
Response<Boolean>	xgroupCreateConsumer(String key, String groupName, String consumerName) XGROUP CREATECONSUMER
Response<Long>	xgroupDelConsumer(byte[] key, byte[] groupName, byte[] consumerName)
Response<Long>	xgroupDelConsumer(String key, String groupName, String consumerName) XGROUP DELCONSUMER
Response<Long>	xgroupDestroy(byte[] key, byte[] groupName)
Response<Long>	xgroupDestroy(String key, String groupName) XGROUP DESTROY
Response<String>	xgroupSetID(byte[] key, byte[] groupName, byte[] id)
Response<String>	xgroupSetID(String key, String groupName, StreamEntryID id) XGROUP SETID
Response<List<Object>>	xinfoConsumers(byte[] key, byte[] group)
Response<List<StreamConsumersInfo>>	xinfoConsumers(String key, String group) Introspection command used in order to retrieve different information about consumers in the group
Response<List<Object>>	xinfoGroup(byte[] key) Deprecated.
Response<List<StreamGroupInfo>>	xinfoGroup(String key) Deprecated.
Response<List<Object>>	xinfoGroups(byte[] key)
Response<List<StreamGroupInfo>>	xinfoGroups(String key) Introspection command used in order to retrieve different information about groups in the stream
Response<Object>	xinfoStream(byte[] key)
Response<StreamInfo>	xinfoStream(String key) Introspection command used in order to retrieve different information about the stream
Response<Object>	xinfoStreamFull(byte[] key) Introspection command used in order to retrieve all information about the stream
Response<Object>	xinfoStreamFull(byte[] key, int count) Introspection command used in order to retrieve all information about the stream
Response<StreamFullInfo>	xinfoStreamFull(String key) Introspection command used in order to retrieve all information about the stream
Response<StreamFullInfo>	xinfoStreamFull(String key, int count) Introspection command used in order to retrieve all information about the stream
Response<Long>	xlen(byte[] key)
Response<Long>	xlen(String key) XLEN key
Response<Object>	xpending(byte[] key, byte[] groupName)
Response<List<Object>>	xpending(byte[] key, byte[] groupName, byte[] start, byte[] end, int count, byte[] consumerName)
Response<List<Object>>	xpending(byte[] key, byte[] groupName, XPendingParams params)
Response<StreamPendingSummary>	xpending(String key, String groupName) XPENDING key group
Response<List<StreamPendingEntry>>	xpending(String key, String groupName, StreamEntryID start, StreamEntryID end, int count, String consumerName) XPENDING key group [start end count] [consumer]
Response<List<StreamPendingEntry>>	xpending(String key, String groupName, XPendingParams params) XPENDING key group [[IDLE min-idle-time] start end count [consumer]]
Response<List<byte[]>>	xrange(byte[] key, byte[] start, byte[] end)
Response<List<byte[]>>	xrange(byte[] key, byte[] start, byte[] end, int count)
Response<List<StreamEntry>>	xrange(String key, StreamEntryID start, StreamEntryID end) XRANGE key start end
Response<List<StreamEntry>>	xrange(String key, StreamEntryID start, StreamEntryID end, int count) XRANGE key start end COUNT count
Response<List<StreamEntry>>	xrange(String key, String start, String end)
Response<List<StreamEntry>>	xrange(String key, String start, String end, int count)
Response<List<byte[]>>	xread(XReadParams xReadParams, Map.Entry<byte[],byte[]>... streams)
Response<List<Map.Entry<String,List<StreamEntry>>>>	xread(XReadParams xReadParams, Map<String,StreamEntryID> streams) XREAD [COUNT count] [BLOCK milliseconds] STREAMS key [key ...] ID [ID ...]
Response<List<byte[]>>	xreadGroup(byte[] groupName, byte[] consumer, XReadGroupParams xReadGroupParams, Map.Entry<byte[],byte[]>... streams)
Response<List<Map.Entry<String,List<StreamEntry>>>>	xreadGroup(String groupName, String consumer, XReadGroupParams xReadGroupParams, Map<String,StreamEntryID> streams) XREAD [COUNT count] [BLOCK milliseconds] STREAMS key [key ...] ID [ID ...]
Response<List<byte[]>>	xrevrange(byte[] key, byte[] end, byte[] start)
Response<List<byte[]>>	xrevrange(byte[] key, byte[] end, byte[] start, int count)
Response<List<StreamEntry>>	xrevrange(String key, StreamEntryID end, StreamEntryID start) XREVRANGE key end start
Response<List<StreamEntry>>	xrevrange(String key, StreamEntryID end, StreamEntryID start, int count) XREVRANGE key end start COUNT count
Response<List<StreamEntry>>	xrevrange(String key, String end, String start)
Response<List<StreamEntry>>	xrevrange(String key, String end, String start, int count)
Response<Long>	xtrim(byte[] key, long maxLen, boolean approximateLength)
Response<Long>	xtrim(byte[] key, XTrimParams params)
Response<Long>	xtrim(String key, long maxLen, boolean approximate) XTRIM key MAXLEN [~] count
Response<Long>	xtrim(String key, XTrimParams params) XTRIM key MAXLEN|MINID [=|~] threshold [LIMIT count]
Response<Long>	zadd(byte[] key, double score, byte[] member)
Response<Long>	zadd(byte[] key, double score, byte[] member, ZAddParams params)
Response<Long>	zadd(byte[] key, Map<byte[],Double> scoreMembers)
Response<Long>	zadd(byte[] key, Map<byte[],Double> scoreMembers, ZAddParams params)
Response<Long>	zadd(String key, double score, String member)
Response<Long>	zadd(String key, double score, String member, ZAddParams params)
Response<Long>	zadd(String key, Map<String,Double> scoreMembers)
Response<Long>	zadd(String key, Map<String,Double> scoreMembers, ZAddParams params)
Response<Double>	zaddIncr(byte[] key, double score, byte[] member, ZAddParams params)
Response<Double>	zaddIncr(String key, double score, String member, ZAddParams params)
Response<Long>	zcard(byte[] key)
Response<Long>	zcard(String key)
Response<Long>	zcount(byte[] key, byte[] min, byte[] max)
Response<Long>	zcount(byte[] key, double min, double max)
Response<Long>	zcount(String key, double min, double max)
Response<Long>	zcount(String key, String min, String max)
Response<Set<byte[]>>	zdiff(byte[]... keys)
Response<Set<String>>	zdiff(String... keys)
Response<Long>	zdiffStore(byte[] dstkey, byte[]... keys)
Response<Long>	zdiffStore(String dstKey, String... keys)
Response<Set<Tuple>>	zdiffWithScores(byte[]... keys)
Response<Set<Tuple>>	zdiffWithScores(String... keys)
Response<Double>	zincrby(byte[] key, double increment, byte[] member)
Response<Double>	zincrby(byte[] key, double increment, byte[] member, ZIncrByParams params)
Response<Double>	zincrby(String key, double increment, String member)
Response<Double>	zincrby(String key, double increment, String member, ZIncrByParams params)
Response<Set<byte[]>>	zinter(ZParams params, byte[]... keys)
Response<Set<String>>	zinter(ZParams params, String... keys)
Response<Long>	zintercard(byte[]... keys)
Response<Long>	zintercard(long limit, byte[]... keys)
Response<Long>	zintercard(long limit, String... keys)
Response<Long>	zintercard(String... keys)
Response<Long>	zinterstore(byte[] dstkey, byte[]... sets)
Response<Long>	zinterstore(byte[] dstkey, ZParams params, byte[]... sets)
Response<Long>	zinterstore(String dstKey, String... sets)
Response<Long>	zinterstore(String dstKey, ZParams params, String... sets)
Response<Set<Tuple>>	zinterWithScores(ZParams params, byte[]... keys)
Response<Set<Tuple>>	zinterWithScores(ZParams params, String... keys)
Response<Long>	zlexcount(byte[] key, byte[] min, byte[] max)
Response<Long>	zlexcount(String key, String min, String max)
Response<KeyValue<byte[],List<Tuple>>>	zmpop(SortedSetOption option, byte[]... keys)
Response<KeyValue<byte[],List<Tuple>>>	zmpop(SortedSetOption option, int count, byte[]... keys)
Response<KeyValue<String,List<Tuple>>>	zmpop(SortedSetOption option, int count, String... keys)
Response<KeyValue<String,List<Tuple>>>	zmpop(SortedSetOption option, String... keys)
Response<List<Double>>	zmscore(byte[] key, byte[]... members)
Response<List<Double>>	zmscore(String key, String... members)
Response<Tuple>	zpopmax(byte[] key)
Response<List<Tuple>>	zpopmax(byte[] key, int count)
Response<Tuple>	zpopmax(String key)
Response<List<Tuple>>	zpopmax(String key, int count)
Response<Tuple>	zpopmin(byte[] key)
Response<List<Tuple>>	zpopmin(byte[] key, int count)
Response<Tuple>	zpopmin(String key)
Response<List<Tuple>>	zpopmin(String key, int count)
Response<byte[]>	zrandmember(byte[] key)
Response<List<byte[]>>	zrandmember(byte[] key, long count)
Response<String>	zrandmember(String key)
Response<List<String>>	zrandmember(String key, long count)
Response<List<Tuple>>	zrandmemberWithScores(byte[] key, long count)
Response<List<Tuple>>	zrandmemberWithScores(String key, long count)
Response<List<byte[]>>	zrange(byte[] key, long start, long stop)
Response<List<byte[]>>	zrange(byte[] key, ZRangeParams zRangeParams)
Response<List<String>>	zrange(String key, long start, long stop)
Response<List<String>>	zrange(String key, ZRangeParams zRangeParams)
Response<List<byte[]>>	zrangeByLex(byte[] key, byte[] min, byte[] max)
Response<List<byte[]>>	zrangeByLex(byte[] key, byte[] min, byte[] max, int offset, int count)
Response<List<String>>	zrangeByLex(String key, String min, String max)
Response<List<String>>	zrangeByLex(String key, String min, String max, int offset, int count)
Response<List<byte[]>>	zrangeByScore(byte[] key, byte[] min, byte[] max)
Response<List<byte[]>>	zrangeByScore(byte[] key, byte[] min, byte[] max, int offset, int count)
Response<List<byte[]>>	zrangeByScore(byte[] key, double min, double max)
Response<List<byte[]>>	zrangeByScore(byte[] key, double min, double max, int offset, int count)
Response<List<String>>	zrangeByScore(String key, double min, double max)
Response<List<String>>	zrangeByScore(String key, double min, double max, int offset, int count)
Response<List<String>>	zrangeByScore(String key, String min, String max)
Response<List<String>>	zrangeByScore(String key, String min, String max, int offset, int count)
Response<List<Tuple>>	zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max)
Response<List<Tuple>>	zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max, int offset, int count)
Response<List<Tuple>>	zrangeByScoreWithScores(byte[] key, double min, double max)
Response<List<Tuple>>	zrangeByScoreWithScores(byte[] key, double min, double max, int offset, int count)
Response<List<Tuple>>	zrangeByScoreWithScores(String key, double min, double max)
Response<List<Tuple>>	zrangeByScoreWithScores(String key, double min, double max, int offset, int count)
Response<List<Tuple>>	zrangeByScoreWithScores(String key, String min, String max)
Response<List<Tuple>>	zrangeByScoreWithScores(String key, String min, String max, int offset, int count)
Response<Long>	zrangestore(byte[] dest, byte[] src, ZRangeParams zRangeParams)
Response<Long>	zrangestore(String dest, String src, ZRangeParams zRangeParams)
Response<List<Tuple>>	zrangeWithScores(byte[] key, long start, long stop)
Response<List<Tuple>>	zrangeWithScores(byte[] key, ZRangeParams zRangeParams)
Response<List<Tuple>>	zrangeWithScores(String key, long start, long stop)
Response<List<Tuple>>	zrangeWithScores(String key, ZRangeParams zRangeParams)
Response<Long>	zrank(byte[] key, byte[] member)
Response<Long>	zrank(String key, String member)
Response<Long>	zrem(byte[] key, byte[]... members)
Response<Long>	zrem(String key, String... members)
Response<Long>	zremrangeByLex(byte[] key, byte[] min, byte[] max)
Response<Long>	zremrangeByLex(String key, String min, String max)
Response<Long>	zremrangeByRank(byte[] key, long start, long stop)
Response<Long>	zremrangeByRank(String key, long start, long stop)
Response<Long>	zremrangeByScore(byte[] key, byte[] min, byte[] max)
Response<Long>	zremrangeByScore(byte[] key, double min, double max)
Response<Long>	zremrangeByScore(String key, double min, double max)
Response<Long>	zremrangeByScore(String key, String min, String max)
Response<List<byte[]>>	zrevrange(byte[] key, long start, long stop)
Response<List<String>>	zrevrange(String key, long start, long stop)
Response<List<byte[]>>	zrevrangeByLex(byte[] key, byte[] max, byte[] min)
Response<List<byte[]>>	zrevrangeByLex(byte[] key, byte[] max, byte[] min, int offset, int count)
Response<List<String>>	zrevrangeByLex(String key, String max, String min)
Response<List<String>>	zrevrangeByLex(String key, String max, String min, int offset, int count)
Response<List<byte[]>>	zrevrangeByScore(byte[] key, byte[] max, byte[] min)
Response<List<byte[]>>	zrevrangeByScore(byte[] key, byte[] max, byte[] min, int offset, int count)
Response<List<byte[]>>	zrevrangeByScore(byte[] key, double max, double min)
Response<List<byte[]>>	zrevrangeByScore(byte[] key, double max, double min, int offset, int count)
Response<List<String>>	zrevrangeByScore(String key, double max, double min)
Response<List<String>>	zrevrangeByScore(String key, double max, double min, int offset, int count)
Response<List<String>>	zrevrangeByScore(String key, String max, String min)
Response<List<String>>	zrevrangeByScore(String key, String max, String min, int offset, int count)
Response<List<Tuple>>	zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min)
Response<List<Tuple>>	zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min, int offset, int count)
Response<List<Tuple>>	zrevrangeByScoreWithScores(byte[] key, double max, double min)
Response<List<Tuple>>	zrevrangeByScoreWithScores(byte[] key, double max, double min, int offset, int count)
Response<List<Tuple>>	zrevrangeByScoreWithScores(String key, double max, double min)
Response<List<Tuple>>	zrevrangeByScoreWithScores(String key, double max, double min, int offset, int count)
Response<List<Tuple>>	zrevrangeByScoreWithScores(String key, String max, String min)
Response<List<Tuple>>	zrevrangeByScoreWithScores(String key, String max, String min, int offset, int count)
Response<List<Tuple>>	zrevrangeWithScores(byte[] key, long start, long stop)
Response<List<Tuple>>	zrevrangeWithScores(String key, long start, long stop)
Response<Long>	zrevrank(byte[] key, byte[] member)
Response<Long>	zrevrank(String key, String member)
Response<ScanResult<Tuple>>	zscan(byte[] key, byte[] cursor, ScanParams params)
Response<ScanResult<Tuple>>	zscan(String key, String cursor, ScanParams params)
Response<Double>	zscore(byte[] key, byte[] member)
Response<Double>	zscore(String key, String member)
Response<Set<byte[]>>	zunion(ZParams params, byte[]... keys)
Response<Set<String>>	zunion(ZParams params, String... keys)
Response<Long>	zunionstore(byte[] dstkey, byte[]... sets)
Response<Long>	zunionstore(byte[] dstkey, ZParams params, byte[]... sets)
Response<Long>	zunionstore(String dstKey, String... sets)
Response<Long>	zunionstore(String dstKey, ZParams params, String... sets)
Response<Set<Tuple>>	zunionWithScores(ZParams params, byte[]... keys)
Response<Set<Tuple>>	zunionWithScores(ZParams params, String... keys)

Methods inherited from class redis.clients.jedis.Queable

clean, enqueResponse, generateResponse, getPipelinedResponseLength

Methods inherited from class java.lang.Object

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

Methods inherited from interface redis.clients.jedis.commands.HashPipelineCommands

hscan

Methods inherited from interface redis.clients.jedis.commands.SetPipelineCommands

sscan

Methods inherited from interface redis.clients.jedis.commands.SortedSetPipelineCommands

zscan

Methods inherited from interface redis.clients.jedis.commands.StreamPipelineCommands

xadd

Methods inherited from interface redis.clients.jedis.commands.HashPipelineBinaryCommands

hscan

Methods inherited from interface redis.clients.jedis.commands.SetPipelineBinaryCommands

sscan

Methods inherited from interface redis.clients.jedis.commands.SortedSetPipelineBinaryCommands

zscan

Methods inherited from interface redis.clients.jedis.commands.StreamPipelineBinaryCommands

xadd

Methods inherited from interface redis.clients.jedis.search.RediSearchPipelineCommands

ftAlter

Methods inherited from interface redis.clients.jedis.json.RedisJsonPipelineCommands

jsonMGet, jsonMGet, jsonSet, jsonSet, jsonSetLegacy, jsonSetLegacy, jsonSetWithEscape, jsonSetWithEscape

Field Detail

connection

protected final Connection connection

Constructor Detail

TransactionBase

public TransactionBase(Connection connection)

TransactionBase

public TransactionBase(Connection connection,
                       boolean doMulti)

If you want to WATCH/UNWATCH keys before MULTI command you should do doMulti = true.

Method Detail

multi

public final void multi()

watch

public String watch(String... keys)

watch

public String watch(byte[]... keys)

unwatch

public String unwatch()

processMultiResponse

protected abstract void processMultiResponse()

processAppendStatus

protected abstract void processAppendStatus()

appendCommand

protected final <T> Response<T> appendCommand(CommandObject<T> commandObject)

close

public final void close()

Specified by:

close in interface Closeable

Specified by:

close in interface AutoCloseable

clear

public final void clear()

processPipelinedResponses

protected abstract void processPipelinedResponses()

exec

public List<Object> exec()

discard

public String discard()

exists

public Response<Boolean> exists(String key)

Specified by:

exists in interface KeyPipelineCommands

exists

public Response<Long> exists(String... keys)

Specified by:

exists in interface KeyPipelineCommands

persist

public Response<Long> persist(String key)

Specified by:

persist in interface KeyPipelineCommands

type

public Response<String> type(String key)

Specified by:

type in interface KeyPipelineCommands

dump

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

Specified by:

dump in interface KeyPipelineCommands

restore

public Response<String> restore(String key,
                                long ttl,
                                byte[] serializedValue)

Specified by:

restore in interface KeyPipelineCommands

restore

public Response<String> restore(String key,
                                long ttl,
                                byte[] serializedValue,
                                RestoreParams params)

Specified by:

restore in interface KeyPipelineCommands

expire

public Response<Long> expire(String key,
                             long seconds)

Specified by:

expire in interface KeyPipelineCommands

expire

public Response<Long> expire(String key,
                             long seconds,
                             ExpiryOption expiryOption)

Specified by:

expire in interface KeyPipelineCommands

pexpire

public Response<Long> pexpire(String key,
                              long milliseconds)

Specified by:

pexpire in interface KeyPipelineCommands

pexpire

public Response<Long> pexpire(String key,
                              long milliseconds,
                              ExpiryOption expiryOption)

Specified by:

pexpire in interface KeyPipelineCommands

expireTime

public Response<Long> expireTime(String key)

Specified by:

expireTime in interface KeyPipelineCommands

pexpireTime

public Response<Long> pexpireTime(String key)

Specified by:

pexpireTime in interface KeyPipelineCommands

expireAt

public Response<Long> expireAt(String key,
                               long unixTime)

Specified by:

expireAt in interface KeyPipelineCommands

expireAt

public Response<Long> expireAt(String key,
                               long unixTime,
                               ExpiryOption expiryOption)

Specified by:

expireAt in interface KeyPipelineCommands

pexpireAt

public Response<Long> pexpireAt(String key,
                                long millisecondsTimestamp)

Specified by:

pexpireAt in interface KeyPipelineCommands

pexpireAt

public Response<Long> pexpireAt(String key,
                                long millisecondsTimestamp,
                                ExpiryOption expiryOption)

Specified by:

pexpireAt in interface KeyPipelineCommands

ttl

public Response<Long> ttl(String key)

Specified by:

ttl in interface KeyPipelineCommands

pttl

public Response<Long> pttl(String key)

Specified by:

pttl in interface KeyPipelineCommands

touch

public Response<Long> touch(String key)

Specified by:

touch in interface KeyPipelineCommands

touch

public Response<Long> touch(String... keys)

Specified by:

touch in interface KeyPipelineCommands

sort

public Response<List<String>> sort(String key)

Specified by:

sort in interface KeyPipelineCommands

sort

public Response<Long> sort(String key,
                           String dstKey)

Specified by:

sort in interface KeyPipelineCommands

sort

public Response<List<String>> sort(String key,
                                   SortingParams sortingParams)

Specified by:

sort in interface KeyPipelineCommands

sort

public Response<Long> sort(String key,
                           SortingParams sortingParams,
                           String dstKey)

Specified by:

sort in interface KeyPipelineCommands

sortReadonly

public Response<List<String>> sortReadonly(String key,
                                           SortingParams sortingParams)

Specified by:

sortReadonly in interface KeyPipelineCommands

del

public Response<Long> del(String key)

Specified by:

del in interface KeyPipelineCommands

del

public Response<Long> del(String... keys)

Specified by:

del in interface KeyPipelineCommands

unlink

public Response<Long> unlink(String key)

Specified by:

unlink in interface KeyPipelineCommands

unlink

public Response<Long> unlink(String... keys)

Specified by:

unlink in interface KeyPipelineCommands

copy

public Response<Boolean> copy(String srcKey,
                              String dstKey,
                              boolean replace)

Specified by:

copy in interface KeyPipelineCommands

rename

public Response<String> rename(String oldkey,
                               String newkey)

Specified by:

rename in interface KeyPipelineCommands

renamenx

public Response<Long> renamenx(String oldkey,
                               String newkey)

Specified by:

renamenx in interface KeyPipelineCommands

memoryUsage

public Response<Long> memoryUsage(String key)

Specified by:

memoryUsage in interface KeyPipelineCommands

memoryUsage

public Response<Long> memoryUsage(String key,
                                  int samples)

Specified by:

memoryUsage in interface KeyPipelineCommands

objectRefcount

public Response<Long> objectRefcount(String key)

Specified by:

objectRefcount in interface KeyPipelineCommands

objectEncoding

public Response<String> objectEncoding(String key)

Specified by:

objectEncoding in interface KeyPipelineCommands

objectIdletime

public Response<Long> objectIdletime(String key)

Specified by:

objectIdletime in interface KeyPipelineCommands

objectFreq

public Response<Long> objectFreq(String key)

Specified by:

objectFreq in interface KeyPipelineCommands

migrate

public Response<String> migrate(String host,
                                int port,
                                String key,
                                int timeout)

Specified by:

migrate in interface KeyPipelineCommands

migrate

public Response<String> migrate(String host,
                                int port,
                                int timeout,
                                MigrateParams params,
                                String... keys)

Specified by:

migrate in interface KeyPipelineCommands

keys

public Response<Set<String>> keys(String pattern)

Specified by:

keys in interface KeyPipelineCommands

scan

public Response<ScanResult<String>> scan(String cursor)

Specified by:

scan in interface KeyPipelineCommands

scan

public Response<ScanResult<String>> scan(String cursor,
                                         ScanParams params)

Specified by:

scan in interface KeyPipelineCommands

scan

public Response<ScanResult<String>> scan(String cursor,
                                         ScanParams params,
                                         String type)

Specified by:

scan in interface KeyPipelineCommands

randomKey

public Response<String> randomKey()

Specified by:

randomKey in interface KeyPipelineCommands

get

public Response<String> get(String key)

Specified by:

get in interface StringPipelineCommands

getDel

public Response<String> getDel(String key)

Specified by:

getDel in interface StringPipelineCommands

getEx

public Response<String> getEx(String key,
                              GetExParams params)

Specified by:

getEx in interface StringPipelineCommands

setbit

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

Specified by:

setbit in interface StringPipelineCommands

getbit

public Response<Boolean> getbit(String key,
                                long offset)

Specified by:

getbit in interface StringPipelineCommands

setrange

public Response<Long> setrange(String key,
                               long offset,
                               String value)

Specified by:

setrange in interface StringPipelineCommands

getrange

public Response<String> getrange(String key,
                                 long startOffset,
                                 long endOffset)

Specified by:

getrange in interface StringPipelineCommands

getSet

public Response<String> getSet(String key,
                               String value)

Specified by:

getSet in interface StringPipelineCommands

setnx

public Response<Long> setnx(String key,
                            String value)

Specified by:

setnx in interface StringPipelineCommands

setex

public Response<String> setex(String key,
                              long seconds,
                              String value)

Specified by:

setex in interface StringPipelineCommands

psetex

public Response<String> psetex(String key,
                               long milliseconds,
                               String value)

Specified by:

psetex in interface StringPipelineCommands

mget

public Response<List<String>> mget(String... keys)

Specified by:

mget in interface StringPipelineCommands

mset

public Response<String> mset(String... keysvalues)

Specified by:

mset in interface StringPipelineCommands

msetnx

public Response<Long> msetnx(String... keysvalues)

Specified by:

msetnx in interface StringPipelineCommands

incr

public Response<Long> incr(String key)

Specified by:

incr in interface StringPipelineCommands

incrBy

public Response<Long> incrBy(String key,
                             long increment)

Specified by:

incrBy in interface StringPipelineCommands

incrByFloat

public Response<Double> incrByFloat(String key,
                                    double increment)

Specified by:

incrByFloat in interface StringPipelineCommands

decr

public Response<Long> decr(String key)

Specified by:

decr in interface StringPipelineCommands

decrBy

public Response<Long> decrBy(String key,
                             long decrement)

Specified by:

decrBy in interface StringPipelineCommands

append

public Response<Long> append(String key,
                             String value)

Specified by:

append in interface StringPipelineCommands

substr

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

Specified by:

substr in interface StringPipelineCommands

strlen

public Response<Long> strlen(String key)

Specified by:

strlen in interface StringPipelineCommands

bitcount

public Response<Long> bitcount(String key)

Specified by:

bitcount in interface StringPipelineCommands

bitcount

public Response<Long> bitcount(String key,
                               long start,
                               long end)

Specified by:

bitcount in interface StringPipelineCommands

bitcount

public Response<Long> bitcount(String key,
                               long start,
                               long end,
                               BitCountOption option)

Specified by:

bitcount in interface StringPipelineCommands

bitpos

public Response<Long> bitpos(String key,
                             boolean value)

Specified by:

bitpos in interface StringPipelineCommands

bitpos

public Response<Long> bitpos(String key,
                             boolean value,
                             BitPosParams params)

Specified by:

bitpos in interface StringPipelineCommands

bitfield

public Response<List<Long>> bitfield(String key,
                                     String... arguments)

Specified by:

bitfield in interface StringPipelineCommands

bitfieldReadonly

public Response<List<Long>> bitfieldReadonly(String key,
                                             String... arguments)

Specified by:

bitfieldReadonly in interface StringPipelineCommands

bitop

public Response<Long> bitop(BitOP op,
                            String destKey,
                            String... srcKeys)

Specified by:

bitop in interface StringPipelineCommands

strAlgoLCSKeys

public Response<LCSMatchResult> strAlgoLCSKeys(String keyA,
                                               String keyB,
                                               StrAlgoLCSParams params)

Specified by:

strAlgoLCSKeys in interface StringPipelineCommands

lcs

public Response<LCSMatchResult> lcs(String keyA,
                                    String keyB,
                                    LCSParams params)

Specified by:

lcs in interface StringPipelineCommands

set

public Response<String> set(String key,
                            String value)

Specified by:

set in interface StringPipelineCommands

set

public Response<String> set(String key,
                            String value,
                            SetParams params)

Specified by:

set in interface StringPipelineCommands

rpush

public Response<Long> rpush(String key,
                            String... string)

Specified by:

rpush in interface ListPipelineCommands

lpush

public Response<Long> lpush(String key,
                            String... string)

Specified by:

lpush in interface ListPipelineCommands

llen

public Response<Long> llen(String key)

Specified by:

llen in interface ListPipelineCommands

lrange

public Response<List<String>> lrange(String key,
                                     long start,
                                     long stop)

Specified by:

lrange in interface ListPipelineCommands

ltrim

public Response<String> ltrim(String key,
                              long start,
                              long stop)

Specified by:

ltrim in interface ListPipelineCommands

lindex

public Response<String> lindex(String key,
                               long index)

Specified by:

lindex in interface ListPipelineCommands

lset

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

Specified by:

lset in interface ListPipelineCommands

lrem

public Response<Long> lrem(String key,
                           long count,
                           String value)

Specified by:

lrem in interface ListPipelineCommands

lpop

public Response<String> lpop(String key)

Specified by:

lpop in interface ListPipelineCommands

lpop

public Response<List<String>> lpop(String key,
                                   int count)

Specified by:

lpop in interface ListPipelineCommands

lpos

public Response<Long> lpos(String key,
                           String element)

Specified by:

lpos in interface ListPipelineCommands

lpos

public Response<Long> lpos(String key,
                           String element,
                           LPosParams params)

Specified by:

lpos in interface ListPipelineCommands

lpos

public Response<List<Long>> lpos(String key,
                                 String element,
                                 LPosParams params,
                                 long count)

Specified by:

lpos in interface ListPipelineCommands

rpop

public Response<String> rpop(String key)

Specified by:

rpop in interface ListPipelineCommands

rpop

public Response<List<String>> rpop(String key,
                                   int count)

Specified by:

rpop in interface ListPipelineCommands

linsert

public Response<Long> linsert(String key,
                              ListPosition where,
                              String pivot,
                              String value)

Specified by:

linsert in interface ListPipelineCommands

lpushx

public Response<Long> lpushx(String key,
                             String... strings)

Specified by:

lpushx in interface ListPipelineCommands

rpushx

public Response<Long> rpushx(String key,
                             String... strings)

Specified by:

rpushx in interface ListPipelineCommands

blpop

public Response<List<String>> blpop(int timeout,
                                    String key)

Specified by:

blpop in interface ListPipelineCommands

blpop

public Response<KeyedListElement> blpop(double timeout,
                                        String key)

Specified by:

blpop in interface ListPipelineCommands

brpop

public Response<List<String>> brpop(int timeout,
                                    String key)

Specified by:

brpop in interface ListPipelineCommands

brpop

public Response<KeyedListElement> brpop(double timeout,
                                        String key)

Specified by:

brpop in interface ListPipelineCommands

blpop

public Response<List<String>> blpop(int timeout,
                                    String... keys)

Specified by:

blpop in interface ListPipelineCommands

blpop

public Response<KeyedListElement> blpop(double timeout,
                                        String... keys)

Specified by:

blpop in interface ListPipelineCommands

brpop

public Response<List<String>> brpop(int timeout,
                                    String... keys)

Specified by:

brpop in interface ListPipelineCommands

brpop

public Response<KeyedListElement> brpop(double timeout,
                                        String... keys)

Specified by:

brpop in interface ListPipelineCommands

rpoplpush

public Response<String> rpoplpush(String srcKey,
                                  String dstKey)

Specified by:

rpoplpush in interface ListPipelineCommands

brpoplpush

public Response<String> brpoplpush(String source,
                                   String destination,
                                   int timeout)

Specified by:

brpoplpush in interface ListPipelineCommands

lmove

public Response<String> lmove(String srcKey,
                              String dstKey,
                              ListDirection from,
                              ListDirection to)

Specified by:

lmove in interface ListPipelineCommands

blmove

public Response<String> blmove(String srcKey,
                               String dstKey,
                               ListDirection from,
                               ListDirection to,
                               double timeout)

Specified by:

blmove in interface ListPipelineCommands

lmpop

public Response<KeyValue<String,List<String>>> lmpop(ListDirection direction,
                                                     String... keys)

Specified by:

lmpop in interface ListPipelineCommands

lmpop

public Response<KeyValue<String,List<String>>> lmpop(ListDirection direction,
                                                     int count,
                                                     String... keys)

Specified by:

lmpop in interface ListPipelineCommands

blmpop

public Response<KeyValue<String,List<String>>> blmpop(long timeout,
                                                      ListDirection direction,
                                                      String... keys)

Specified by:

blmpop in interface ListPipelineCommands

blmpop

public Response<KeyValue<String,List<String>>> blmpop(long timeout,
                                                      ListDirection direction,
                                                      int count,
                                                      String... keys)

Specified by:

blmpop in interface ListPipelineCommands

hset

public Response<Long> hset(String key,
                           String field,
                           String value)

Specified by:

hset in interface HashPipelineCommands

hset

public Response<Long> hset(String key,
                           Map<String,String> hash)

Specified by:

hset in interface HashPipelineCommands

hget

public Response<String> hget(String key,
                             String field)

Specified by:

hget in interface HashPipelineCommands

hsetnx

public Response<Long> hsetnx(String key,
                             String field,
                             String value)

Specified by:

hsetnx in interface HashPipelineCommands

hmset

public Response<String> hmset(String key,
                              Map<String,String> hash)

Specified by:

hmset in interface HashPipelineCommands

hmget

public Response<List<String>> hmget(String key,
                                    String... fields)

Specified by:

hmget in interface HashPipelineCommands

hincrBy

public Response<Long> hincrBy(String key,
                              String field,
                              long value)

Specified by:

hincrBy in interface HashPipelineCommands

hincrByFloat

public Response<Double> hincrByFloat(String key,
                                     String field,
                                     double value)

Specified by:

hincrByFloat in interface HashPipelineCommands

hexists

public Response<Boolean> hexists(String key,
                                 String field)

Specified by:

hexists in interface HashPipelineCommands

hdel

public Response<Long> hdel(String key,
                           String... field)

Specified by:

hdel in interface HashPipelineCommands

hlen

public Response<Long> hlen(String key)

Specified by:

hlen in interface HashPipelineCommands

hkeys

public Response<Set<String>> hkeys(String key)

Specified by:

hkeys in interface HashPipelineCommands

hvals

public Response<List<String>> hvals(String key)

Specified by:

hvals in interface HashPipelineCommands

hgetAll

public Response<Map<String,String>> hgetAll(String key)

Specified by:

hgetAll in interface HashPipelineCommands

hrandfield

public Response<String> hrandfield(String key)

Specified by:

hrandfield in interface HashPipelineCommands

hrandfield

public Response<List<String>> hrandfield(String key,
                                         long count)

Specified by:

hrandfield in interface HashPipelineCommands

hrandfieldWithValues

public Response<Map<String,String>> hrandfieldWithValues(String key,
                                                         long count)

Specified by:

hrandfieldWithValues in interface HashPipelineCommands

hscan

public Response<ScanResult<Map.Entry<String,String>>> hscan(String key,
                                                            String cursor,
                                                            ScanParams params)

Specified by:

hscan in interface HashPipelineCommands

hstrlen

public Response<Long> hstrlen(String key,
                              String field)

Specified by:

hstrlen in interface HashPipelineCommands

sadd

public Response<Long> sadd(String key,
                           String... members)

Specified by:

sadd in interface SetPipelineCommands

smembers

public Response<Set<String>> smembers(String key)

Specified by:

smembers in interface SetPipelineCommands

srem

public Response<Long> srem(String key,
                           String... members)

Specified by:

srem in interface SetPipelineCommands

spop

public Response<String> spop(String key)

Specified by:

spop in interface SetPipelineCommands

spop

public Response<Set<String>> spop(String key,
                                  long count)

Specified by:

spop in interface SetPipelineCommands

scard

public Response<Long> scard(String key)

Specified by:

scard in interface SetPipelineCommands

sismember

public Response<Boolean> sismember(String key,
                                   String member)

Specified by:

sismember in interface SetPipelineCommands

smismember

public Response<List<Boolean>> smismember(String key,
                                          String... members)

Specified by:

smismember in interface SetPipelineCommands

srandmember

public Response<String> srandmember(String key)

Specified by:

srandmember in interface SetPipelineCommands

srandmember

public Response<List<String>> srandmember(String key,
                                          int count)

Specified by:

srandmember in interface SetPipelineCommands

sscan

public Response<ScanResult<String>> sscan(String key,
                                          String cursor,
                                          ScanParams params)

Specified by:

sscan in interface SetPipelineCommands

sdiff

public Response<Set<String>> sdiff(String... keys)

Specified by:

sdiff in interface SetPipelineCommands

sdiffstore

public Response<Long> sdiffstore(String dstKey,
                                 String... keys)

Specified by:

sdiffstore in interface SetPipelineCommands

sinter

public Response<Set<String>> sinter(String... keys)

Specified by:

sinter in interface SetPipelineCommands

sinterstore

public Response<Long> sinterstore(String dstKey,
                                  String... keys)

Specified by:

sinterstore in interface SetPipelineCommands

sintercard

public Response<Long> sintercard(String... keys)

Specified by:

sintercard in interface SetPipelineCommands

sintercard

public Response<Long> sintercard(int limit,
                                 String... keys)

Specified by:

sintercard in interface SetPipelineCommands

sunion

public Response<Set<String>> sunion(String... keys)

Specified by:

sunion in interface SetPipelineCommands

sunionstore

public Response<Long> sunionstore(String dstKey,
                                  String... keys)

Specified by:

sunionstore in interface SetPipelineCommands

smove

public Response<Long> smove(String srcKey,
                            String dstKey,
                            String member)

Specified by:

smove in interface SetPipelineCommands

zadd

public Response<Long> zadd(String key,
                           double score,
                           String member)

Specified by:

zadd in interface SortedSetPipelineCommands

zadd

public Response<Long> zadd(String key,
                           double score,
                           String member,
                           ZAddParams params)

Specified by:

zadd in interface SortedSetPipelineCommands

zadd

public Response<Long> zadd(String key,
                           Map<String,Double> scoreMembers)

Specified by:

zadd in interface SortedSetPipelineCommands

zadd

public Response<Long> zadd(String key,
                           Map<String,Double> scoreMembers,
                           ZAddParams params)

Specified by:

zadd in interface SortedSetPipelineCommands

zaddIncr

public Response<Double> zaddIncr(String key,
                                 double score,
                                 String member,
                                 ZAddParams params)

Specified by:

zaddIncr in interface SortedSetPipelineCommands

zrem

public Response<Long> zrem(String key,
                           String... members)

Specified by:

zrem in interface SortedSetPipelineCommands

zincrby

public Response<Double> zincrby(String key,
                                double increment,
                                String member)

Specified by:

zincrby in interface SortedSetPipelineCommands

zincrby

public Response<Double> zincrby(String key,
                                double increment,
                                String member,
                                ZIncrByParams params)

Specified by:

zincrby in interface SortedSetPipelineCommands

zrank

public Response<Long> zrank(String key,
                            String member)

Specified by:

zrank in interface SortedSetPipelineCommands

zrevrank

public Response<Long> zrevrank(String key,
                               String member)

Specified by:

zrevrank in interface SortedSetPipelineCommands

zrange

public Response<List<String>> zrange(String key,
                                     long start,
                                     long stop)

Specified by:

zrange in interface SortedSetPipelineCommands

zrevrange

public Response<List<String>> zrevrange(String key,
                                        long start,
                                        long stop)

Specified by:

zrevrange in interface SortedSetPipelineCommands

zrangeWithScores

public Response<List<Tuple>> zrangeWithScores(String key,
                                              long start,
                                              long stop)

Specified by:

zrangeWithScores in interface SortedSetPipelineCommands

zrevrangeWithScores

public Response<List<Tuple>> zrevrangeWithScores(String key,
                                                 long start,
                                                 long stop)

Specified by:

zrevrangeWithScores in interface SortedSetPipelineCommands

zrange

public Response<List<String>> zrange(String key,
                                     ZRangeParams zRangeParams)

Specified by:

zrange in interface SortedSetPipelineCommands

zrangeWithScores

public Response<List<Tuple>> zrangeWithScores(String key,
                                              ZRangeParams zRangeParams)

Specified by:

zrangeWithScores in interface SortedSetPipelineCommands

zrangestore

public Response<Long> zrangestore(String dest,
                                  String src,
                                  ZRangeParams zRangeParams)

Specified by:

zrangestore in interface SortedSetPipelineCommands

zrandmember

public Response<String> zrandmember(String key)

Specified by:

zrandmember in interface SortedSetPipelineCommands

zrandmember

public Response<List<String>> zrandmember(String key,
                                          long count)

Specified by:

zrandmember in interface SortedSetPipelineCommands

zrandmemberWithScores

public Response<List<Tuple>> zrandmemberWithScores(String key,
                                                   long count)

Specified by:

zrandmemberWithScores in interface SortedSetPipelineCommands

zcard

public Response<Long> zcard(String key)

Specified by:

zcard in interface SortedSetPipelineCommands

zscore

public Response<Double> zscore(String key,
                               String member)

Specified by:

zscore in interface SortedSetPipelineCommands

zmscore

public Response<List<Double>> zmscore(String key,
                                      String... members)

Specified by:

zmscore in interface SortedSetPipelineCommands

zpopmax

public Response<Tuple> zpopmax(String key)

Specified by:

zpopmax in interface SortedSetPipelineCommands

zpopmax

public Response<List<Tuple>> zpopmax(String key,
                                     int count)

Specified by:

zpopmax in interface SortedSetPipelineCommands

zpopmin

public Response<Tuple> zpopmin(String key)

Specified by:

zpopmin in interface SortedSetPipelineCommands

zpopmin

public Response<List<Tuple>> zpopmin(String key,
                                     int count)

Specified by:

zpopmin in interface SortedSetPipelineCommands

zcount

public Response<Long> zcount(String key,
                             double min,
                             double max)

Specified by:

zcount in interface SortedSetPipelineCommands

zcount

public Response<Long> zcount(String key,
                             String min,
                             String max)

Specified by:

zcount in interface SortedSetPipelineCommands

zrangeByScore

public Response<List<String>> zrangeByScore(String key,
                                            double min,
                                            double max)

Specified by:

zrangeByScore in interface SortedSetPipelineCommands

zrangeByScore

public Response<List<String>> zrangeByScore(String key,
                                            String min,
                                            String max)

Specified by:

zrangeByScore in interface SortedSetPipelineCommands

zrevrangeByScore

public Response<List<String>> zrevrangeByScore(String key,
                                               double max,
                                               double min)

Specified by:

zrevrangeByScore in interface SortedSetPipelineCommands

zrangeByScore

public Response<List<String>> zrangeByScore(String key,
                                            double min,
                                            double max,
                                            int offset,
                                            int count)

Specified by:

zrangeByScore in interface SortedSetPipelineCommands

zrevrangeByScore

public Response<List<String>> zrevrangeByScore(String key,
                                               String max,
                                               String min)

Specified by:

zrevrangeByScore in interface SortedSetPipelineCommands

zrangeByScore

public Response<List<String>> zrangeByScore(String key,
                                            String min,
                                            String max,
                                            int offset,
                                            int count)

Specified by:

zrangeByScore in interface SortedSetPipelineCommands

zrevrangeByScore

public Response<List<String>> zrevrangeByScore(String key,
                                               double max,
                                               double min,
                                               int offset,
                                               int count)

Specified by:

zrevrangeByScore in interface SortedSetPipelineCommands

zrangeByScoreWithScores

public Response<List<Tuple>> zrangeByScoreWithScores(String key,
                                                     double min,
                                                     double max)

Specified by:

zrangeByScoreWithScores in interface SortedSetPipelineCommands

zrevrangeByScoreWithScores

public Response<List<Tuple>> zrevrangeByScoreWithScores(String key,
                                                        double max,
                                                        double min)

Specified by:

zrevrangeByScoreWithScores in interface SortedSetPipelineCommands

zrangeByScoreWithScores

public Response<List<Tuple>> zrangeByScoreWithScores(String key,
                                                     double min,
                                                     double max,
                                                     int offset,
                                                     int count)

Specified by:

zrangeByScoreWithScores in interface SortedSetPipelineCommands

zrevrangeByScore

public Response<List<String>> zrevrangeByScore(String key,
                                               String max,
                                               String min,
                                               int offset,
                                               int count)

Specified by:

zrevrangeByScore in interface SortedSetPipelineCommands

zrangeByScoreWithScores

public Response<List<Tuple>> zrangeByScoreWithScores(String key,
                                                     String min,
                                                     String max)

Specified by:

zrangeByScoreWithScores in interface SortedSetPipelineCommands

zrevrangeByScoreWithScores

public Response<List<Tuple>> zrevrangeByScoreWithScores(String key,
                                                        String max,
                                                        String min)

Specified by:

zrevrangeByScoreWithScores in interface SortedSetPipelineCommands

zrangeByScoreWithScores

public Response<List<Tuple>> zrangeByScoreWithScores(String key,
                                                     String min,
                                                     String max,
                                                     int offset,
                                                     int count)

Specified by:

zrangeByScoreWithScores in interface SortedSetPipelineCommands

zrevrangeByScoreWithScores

public Response<List<Tuple>> zrevrangeByScoreWithScores(String key,
                                                        double max,
                                                        double min,
                                                        int offset,
                                                        int count)

Specified by:

zrevrangeByScoreWithScores in interface SortedSetPipelineCommands

zrevrangeByScoreWithScores

public Response<List<Tuple>> zrevrangeByScoreWithScores(String key,
                                                        String max,
                                                        String min,
                                                        int offset,
                                                        int count)

Specified by:

zrevrangeByScoreWithScores in interface SortedSetPipelineCommands

zremrangeByRank

public Response<Long> zremrangeByRank(String key,
                                      long start,
                                      long stop)

Specified by:

zremrangeByRank in interface SortedSetPipelineCommands

zremrangeByScore

public Response<Long> zremrangeByScore(String key,
                                       double min,
                                       double max)

Specified by:

zremrangeByScore in interface SortedSetPipelineCommands

zremrangeByScore

public Response<Long> zremrangeByScore(String key,
                                       String min,
                                       String max)

Specified by:

zremrangeByScore in interface SortedSetPipelineCommands

zlexcount

public Response<Long> zlexcount(String key,
                                String min,
                                String max)

Specified by:

zlexcount in interface SortedSetPipelineCommands

zrangeByLex

public Response<List<String>> zrangeByLex(String key,
                                          String min,
                                          String max)

Specified by:

zrangeByLex in interface SortedSetPipelineCommands

zrangeByLex

public Response<List<String>> zrangeByLex(String key,
                                          String min,
                                          String max,
                                          int offset,
                                          int count)

Specified by:

zrangeByLex in interface SortedSetPipelineCommands

zrevrangeByLex

public Response<List<String>> zrevrangeByLex(String key,
                                             String max,
                                             String min)

Specified by:

zrevrangeByLex in interface SortedSetPipelineCommands

zrevrangeByLex

public Response<List<String>> zrevrangeByLex(String key,
                                             String max,
                                             String min,
                                             int offset,
                                             int count)

Specified by:

zrevrangeByLex in interface SortedSetPipelineCommands

zremrangeByLex

public Response<Long> zremrangeByLex(String key,
                                     String min,
                                     String max)

Specified by:

zremrangeByLex in interface SortedSetPipelineCommands

zscan

public Response<ScanResult<Tuple>> zscan(String key,
                                         String cursor,
                                         ScanParams params)

Specified by:

zscan in interface SortedSetPipelineCommands

bzpopmax

public Response<KeyedZSetElement> bzpopmax(double timeout,
                                           String... keys)

Specified by:

bzpopmax in interface SortedSetPipelineCommands

bzpopmin

public Response<KeyedZSetElement> bzpopmin(double timeout,
                                           String... keys)

Specified by:

bzpopmin in interface SortedSetPipelineCommands

zmpop

public Response<KeyValue<String,List<Tuple>>> zmpop(SortedSetOption option,
                                                    String... keys)

Specified by:

zmpop in interface SortedSetPipelineCommands

zmpop

public Response<KeyValue<String,List<Tuple>>> zmpop(SortedSetOption option,
                                                    int count,
                                                    String... keys)

Specified by:

zmpop in interface SortedSetPipelineCommands

bzmpop

public Response<KeyValue<String,List<Tuple>>> bzmpop(long timeout,
                                                     SortedSetOption option,
                                                     String... keys)

Specified by:

bzmpop in interface SortedSetPipelineCommands

bzmpop

public Response<KeyValue<String,List<Tuple>>> bzmpop(long timeout,
                                                     SortedSetOption option,
                                                     int count,
                                                     String... keys)

Specified by:

bzmpop in interface SortedSetPipelineCommands

zdiff

public Response<Set<String>> zdiff(String... keys)

Specified by:

zdiff in interface SortedSetPipelineCommands

zdiffWithScores

public Response<Set<Tuple>> zdiffWithScores(String... keys)

Specified by:

zdiffWithScores in interface SortedSetPipelineCommands

zdiffStore

public Response<Long> zdiffStore(String dstKey,
                                 String... keys)

Specified by:

zdiffStore in interface SortedSetPipelineCommands

zinterstore

public Response<Long> zinterstore(String dstKey,
                                  String... sets)

Specified by:

zinterstore in interface SortedSetPipelineCommands

zinterstore

public Response<Long> zinterstore(String dstKey,
                                  ZParams params,
                                  String... sets)

Specified by:

zinterstore in interface SortedSetPipelineCommands

zinter

public Response<Set<String>> zinter(ZParams params,
                                    String... keys)

Specified by:

zinter in interface SortedSetPipelineCommands

zinterWithScores

public Response<Set<Tuple>> zinterWithScores(ZParams params,
                                             String... keys)

Specified by:

zinterWithScores in interface SortedSetPipelineCommands

zintercard

public Response<Long> zintercard(String... keys)

Specified by:

zintercard in interface SortedSetPipelineCommands

zintercard

public Response<Long> zintercard(long limit,
                                 String... keys)

Specified by:

zintercard in interface SortedSetPipelineCommands

zunion

public Response<Set<String>> zunion(ZParams params,
                                    String... keys)

Specified by:

zunion in interface SortedSetPipelineCommands

zunionWithScores

public Response<Set<Tuple>> zunionWithScores(ZParams params,
                                             String... keys)

Specified by:

zunionWithScores in interface SortedSetPipelineCommands

zunionstore

public Response<Long> zunionstore(String dstKey,
                                  String... sets)

Specified by:

zunionstore in interface SortedSetPipelineCommands

zunionstore

public Response<Long> zunionstore(String dstKey,
                                  ZParams params,
                                  String... sets)

Specified by:

zunionstore in interface SortedSetPipelineCommands

geoadd

public Response<Long> geoadd(String key,
                             double longitude,
                             double latitude,
                             String member)

Specified by:

geoadd in interface GeoPipelineCommands

geoadd

public Response<Long> geoadd(String key,
                             Map<String,GeoCoordinate> memberCoordinateMap)

Specified by:

geoadd in interface GeoPipelineCommands

geoadd

public Response<Long> geoadd(String key,
                             GeoAddParams params,
                             Map<String,GeoCoordinate> memberCoordinateMap)

Specified by:

geoadd in interface GeoPipelineCommands

geodist

public Response<Double> geodist(String key,
                                String member1,
                                String member2)

Specified by:

geodist in interface GeoPipelineCommands

geodist

public Response<Double> geodist(String key,
                                String member1,
                                String member2,
                                GeoUnit unit)

Specified by:

geodist in interface GeoPipelineCommands

geohash

public Response<List<String>> geohash(String key,
                                      String... members)

Specified by:

geohash in interface GeoPipelineCommands

geopos

public Response<List<GeoCoordinate>> geopos(String key,
                                            String... members)

Specified by:

geopos in interface GeoPipelineCommands

georadius

public Response<List<GeoRadiusResponse>> georadius(String key,
                                                   double longitude,
                                                   double latitude,
                                                   double radius,
                                                   GeoUnit unit)

Specified by:

georadius in interface GeoPipelineCommands

georadiusReadonly

public Response<List<GeoRadiusResponse>> georadiusReadonly(String key,
                                                           double longitude,
                                                           double latitude,
                                                           double radius,
                                                           GeoUnit unit)

Specified by:

georadiusReadonly in interface GeoPipelineCommands

georadius

public Response<List<GeoRadiusResponse>> georadius(String key,
                                                   double longitude,
                                                   double latitude,
                                                   double radius,
                                                   GeoUnit unit,
                                                   GeoRadiusParam param)

Specified by:

georadius in interface GeoPipelineCommands

georadiusReadonly

public Response<List<GeoRadiusResponse>> georadiusReadonly(String key,
                                                           double longitude,
                                                           double latitude,
                                                           double radius,
                                                           GeoUnit unit,
                                                           GeoRadiusParam param)

Specified by:

georadiusReadonly in interface GeoPipelineCommands

georadiusByMember

public Response<List<GeoRadiusResponse>> georadiusByMember(String key,
                                                           String member,
                                                           double radius,
                                                           GeoUnit unit)

Specified by:

georadiusByMember in interface GeoPipelineCommands

georadiusByMemberReadonly

public Response<List<GeoRadiusResponse>> georadiusByMemberReadonly(String key,
                                                                   String member,
                                                                   double radius,
                                                                   GeoUnit unit)

Specified by:

georadiusByMemberReadonly in interface GeoPipelineCommands

georadiusByMember

public Response<List<GeoRadiusResponse>> georadiusByMember(String key,
                                                           String member,
                                                           double radius,
                                                           GeoUnit unit,
                                                           GeoRadiusParam param)

Specified by:

georadiusByMember in interface GeoPipelineCommands

georadiusByMemberReadonly

public Response<List<GeoRadiusResponse>> georadiusByMemberReadonly(String key,
                                                                   String member,
                                                                   double radius,
                                                                   GeoUnit unit,
                                                                   GeoRadiusParam param)

Specified by:

georadiusByMemberReadonly in interface GeoPipelineCommands

georadiusStore

public Response<Long> georadiusStore(String key,
                                     double longitude,
                                     double latitude,
                                     double radius,
                                     GeoUnit unit,
                                     GeoRadiusParam param,
                                     GeoRadiusStoreParam storeParam)

Specified by:

georadiusStore in interface GeoPipelineCommands

georadiusByMemberStore

public Response<Long> georadiusByMemberStore(String key,
                                             String member,
                                             double radius,
                                             GeoUnit unit,
                                             GeoRadiusParam param,
                                             GeoRadiusStoreParam storeParam)

Specified by:

georadiusByMemberStore in interface GeoPipelineCommands

geosearch

public Response<List<GeoRadiusResponse>> geosearch(String key,
                                                   String member,
                                                   double radius,
                                                   GeoUnit unit)

Specified by:

geosearch in interface GeoPipelineCommands

geosearch

public Response<List<GeoRadiusResponse>> geosearch(String key,
                                                   GeoCoordinate coord,
                                                   double radius,
                                                   GeoUnit unit)

Specified by:

geosearch in interface GeoPipelineCommands

geosearch

public Response<List<GeoRadiusResponse>> geosearch(String key,
                                                   String member,
                                                   double width,
                                                   double height,
                                                   GeoUnit unit)

Specified by:

geosearch in interface GeoPipelineCommands

geosearch

public Response<List<GeoRadiusResponse>> geosearch(String key,
                                                   GeoCoordinate coord,
                                                   double width,
                                                   double height,
                                                   GeoUnit unit)

Specified by:

geosearch in interface GeoPipelineCommands

geosearch

public Response<List<GeoRadiusResponse>> geosearch(String key,
                                                   GeoSearchParam params)

Specified by:

geosearch in interface GeoPipelineCommands

geosearchStore

public Response<Long> geosearchStore(String dest,
                                     String src,
                                     String member,
                                     double radius,
                                     GeoUnit unit)

Specified by:

geosearchStore in interface GeoPipelineCommands

geosearchStore

public Response<Long> geosearchStore(String dest,
                                     String src,
                                     GeoCoordinate coord,
                                     double radius,
                                     GeoUnit unit)

Specified by:

geosearchStore in interface GeoPipelineCommands

geosearchStore

public Response<Long> geosearchStore(String dest,
                                     String src,
                                     String member,
                                     double width,
                                     double height,
                                     GeoUnit unit)

Specified by:

geosearchStore in interface GeoPipelineCommands

geosearchStore

public Response<Long> geosearchStore(String dest,
                                     String src,
                                     GeoCoordinate coord,
                                     double width,
                                     double height,
                                     GeoUnit unit)

Specified by:

geosearchStore in interface GeoPipelineCommands

geosearchStore

public Response<Long> geosearchStore(String dest,
                                     String src,
                                     GeoSearchParam params)

Specified by:

geosearchStore in interface GeoPipelineCommands

geosearchStoreStoreDist

public Response<Long> geosearchStoreStoreDist(String dest,
                                              String src,
                                              GeoSearchParam params)

Specified by:

geosearchStoreStoreDist in interface GeoPipelineCommands

pfadd

public Response<Long> pfadd(String key,
                            String... elements)

Specified by:

pfadd in interface HyperLogLogPipelineCommands

pfmerge

public Response<String> pfmerge(String destkey,
                                String... sourcekeys)

Specified by:

pfmerge in interface HyperLogLogPipelineCommands

pfcount

public Response<Long> pfcount(String key)

Specified by:

pfcount in interface HyperLogLogPipelineCommands

pfcount

public Response<Long> pfcount(String... keys)

Specified by:

pfcount in interface HyperLogLogPipelineCommands

xadd

public Response<StreamEntryID> xadd(String key,
                                    StreamEntryID id,
                                    Map<String,String> hash)

Description copied from interface: StreamPipelineCommands

XADD key ID field string [field string ...]

Specified by:

xadd in interface StreamPipelineCommands

Returns:

the ID of the added entry

xadd

public Response<StreamEntryID> xadd(String key,
                                    XAddParams params,
                                    Map<String,String> hash)

Specified by:

xadd in interface StreamPipelineCommands

xlen

public Response<Long> xlen(String key)

Description copied from interface: StreamPipelineCommands

XLEN key

Specified by:

xlen in interface StreamPipelineCommands

Returns:

length of stream

xrange

public Response<List<StreamEntry>> xrange(String key,
                                          StreamEntryID start,
                                          StreamEntryID end)

Description copied from interface: StreamPipelineCommands

XRANGE key start end

Specified by:

xrange in interface StreamPipelineCommands

start - minimum StreamEntryID for the retrieved range, passing null will indicate minimum ID possible in the stream

end - maximum StreamEntryID for the retrieved range, passing null will indicate maximum ID possible in the stream

Returns:

The entries with IDs matching the specified range.

xrange

public Response<List<StreamEntry>> xrange(String key,
                                          StreamEntryID start,
                                          StreamEntryID end,
                                          int count)

Description copied from interface: StreamPipelineCommands

XRANGE key start end COUNT count

Specified by:

xrange in interface StreamPipelineCommands

start - minimum StreamEntryID for the retrieved range, passing null will indicate minimum ID possible in the stream

end - maximum StreamEntryID for the retrieved range, passing null will indicate maximum ID possible in the stream

count - maximum number of entries returned

Returns:

The entries with IDs matching the specified range.

xrevrange

public Response<List<StreamEntry>> xrevrange(String key,
                                             StreamEntryID end,
                                             StreamEntryID start)

Description copied from interface: StreamPipelineCommands

XREVRANGE key end start

Specified by:

xrevrange in interface StreamPipelineCommands

end - maximum StreamEntryID for the retrieved range, passing null will indicate maximum ID possible in the stream

start - minimum StreamEntryID for the retrieved range, passing null will indicate minimum ID possible in the stream

Returns:

the entries with IDs matching the specified range, from the higher ID to the lower ID matching.

xrevrange

public Response<List<StreamEntry>> xrevrange(String key,
                                             StreamEntryID end,
                                             StreamEntryID start,
                                             int count)

Description copied from interface: StreamPipelineCommands

XREVRANGE key end start COUNT count

Specified by:

xrevrange in interface StreamPipelineCommands

end - maximum StreamEntryID for the retrieved range, passing null will indicate maximum ID possible in the stream

start - minimum StreamEntryID for the retrieved range, passing null will indicate minimum ID possible in the stream

count - The entries with IDs matching the specified range.

Returns:

the entries with IDs matching the specified range, from the higher ID to the lower ID matching.

xrange

public Response<List<StreamEntry>> xrange(String key,
                                          String start,
                                          String end)

Specified by:

xrange in interface StreamPipelineCommands

xrange

public Response<List<StreamEntry>> xrange(String key,
                                          String start,
                                          String end,
                                          int count)

Specified by:

xrange in interface StreamPipelineCommands

xrevrange

public Response<List<StreamEntry>> xrevrange(String key,
                                             String end,
                                             String start)

Specified by:

xrevrange in interface StreamPipelineCommands

xrevrange

public Response<List<StreamEntry>> xrevrange(String key,
                                             String end,
                                             String start,
                                             int count)

Specified by:

xrevrange in interface StreamPipelineCommands

xack

public Response<Long> xack(String key,
                           String group,
                           StreamEntryID... ids)

Description copied from interface: StreamPipelineCommands

XACK key group ID [ID ...]

Specified by:

xack in interface StreamPipelineCommands

xgroupCreate

public Response<String> xgroupCreate(String key,
                                     String groupName,
                                     StreamEntryID id,
                                     boolean makeStream)

Description copied from interface: StreamPipelineCommands

XGROUP CREATE

Specified by:

xgroupCreate in interface StreamPipelineCommands

xgroupSetID

public Response<String> xgroupSetID(String key,
                                    String groupName,
                                    StreamEntryID id)

Description copied from interface: StreamPipelineCommands

XGROUP SETID

Specified by:

xgroupSetID in interface StreamPipelineCommands

xgroupDestroy

public Response<Long> xgroupDestroy(String key,
                                    String groupName)

Description copied from interface: StreamPipelineCommands

XGROUP DESTROY

Specified by:

xgroupDestroy in interface StreamPipelineCommands

xgroupCreateConsumer

public Response<Boolean> xgroupCreateConsumer(String key,
                                              String groupName,
                                              String consumerName)

Description copied from interface: StreamPipelineCommands

XGROUP CREATECONSUMER

Specified by:

xgroupCreateConsumer in interface StreamPipelineCommands

xgroupDelConsumer

public Response<Long> xgroupDelConsumer(String key,
                                        String groupName,
                                        String consumerName)

Description copied from interface: StreamPipelineCommands

XGROUP DELCONSUMER

Specified by:

xgroupDelConsumer in interface StreamPipelineCommands

xpending

public Response<StreamPendingSummary> xpending(String key,
                                               String groupName)

Description copied from interface: StreamPipelineCommands

XPENDING key group

Specified by:

xpending in interface StreamPipelineCommands

xpending

public Response<List<StreamPendingEntry>> xpending(String key,
                                                   String groupName,
                                                   StreamEntryID start,
                                                   StreamEntryID end,
                                                   int count,
                                                   String consumerName)

Description copied from interface: StreamPipelineCommands

XPENDING key group [start end count] [consumer]

Specified by:

xpending in interface StreamPipelineCommands

xpending

public Response<List<StreamPendingEntry>> xpending(String key,
                                                   String groupName,
                                                   XPendingParams params)

Description copied from interface: StreamPipelineCommands

XPENDING key group [[IDLE min-idle-time] start end count [consumer]]

Specified by:

xpending in interface StreamPipelineCommands

xdel

public Response<Long> xdel(String key,
                           StreamEntryID... ids)

Description copied from interface: StreamPipelineCommands

XDEL key ID [ID ...]

Specified by:

xdel in interface StreamPipelineCommands

xtrim

public Response<Long> xtrim(String key,
                            long maxLen,
                            boolean approximate)

Description copied from interface: StreamPipelineCommands

XTRIM key MAXLEN [~] count

Specified by:

xtrim in interface StreamPipelineCommands

xtrim

public Response<Long> xtrim(String key,
                            XTrimParams params)

Description copied from interface: StreamPipelineCommands

XTRIM key MAXLEN|MINID [=|~] threshold [LIMIT count]

Specified by:

xtrim in interface StreamPipelineCommands

xclaim

public Response<List<StreamEntry>> xclaim(String key,
                                          String group,
                                          String consumerName,
                                          long minIdleTime,
                                          XClaimParams params,
                                          StreamEntryID... ids)

Description copied from interface: StreamPipelineCommands

XCLAIM ... [IDLE ] [TIME ] [RETRYCOUNT ] [FORCE]

Specified by:

xclaim in interface StreamPipelineCommands

xclaimJustId

public Response<List<StreamEntryID>> xclaimJustId(String key,
                                                  String group,
                                                  String consumerName,
                                                  long minIdleTime,
                                                  XClaimParams params,
                                                  StreamEntryID... ids)

Description copied from interface: StreamPipelineCommands

XCLAIM ... [IDLE ] [TIME ] [RETRYCOUNT ] [FORCE] JUSTID

Specified by:

xclaimJustId in interface StreamPipelineCommands

xautoclaim

public Response<Map.Entry<StreamEntryID,List<StreamEntry>>> xautoclaim(String key,
                                                                       String group,
                                                                       String consumerName,
                                                                       long minIdleTime,
                                                                       StreamEntryID start,
                                                                       XAutoClaimParams params)

Description copied from interface: StreamPipelineCommands

XAUTOCLAIM key group consumer min-idle-time start [COUNT count]

Specified by:

xautoclaim in interface StreamPipelineCommands

Parameters:

key - Stream Key

group - Consumer Group

consumerName - Consumer name to transfer the auto claimed entries

minIdleTime - Entries pending more than minIdleTime will be transferred ownership

start - StreamEntryID - Entries >= start will be transferred ownership, passing null will indicate '-'

params - XAutoClaimParams

xautoclaimJustId

public Response<Map.Entry<StreamEntryID,List<StreamEntryID>>> xautoclaimJustId(String key,
                                                                               String group,
                                                                               String consumerName,
                                                                               long minIdleTime,
                                                                               StreamEntryID start,
                                                                               XAutoClaimParams params)

Description copied from interface: StreamPipelineCommands

XAUTOCLAIM key group consumer min-idle-time start [COUNT count] JUSTID

Specified by:

xautoclaimJustId in interface StreamPipelineCommands

Parameters:

key - Stream Key

group - Consumer Group

consumerName - Consumer name to transfer the auto claimed entries

minIdleTime - Entries pending more than minIdleTime will be transferred ownership

start - StreamEntryID - Entries >= start will be transferred ownership, passing null will indicate '-'

params - XAutoClaimParams

xinfoStream

public Response<StreamInfo> xinfoStream(String key)

Description copied from interface: StreamPipelineCommands

Introspection command used in order to retrieve different information about the stream

Specified by:

xinfoStream in interface StreamPipelineCommands

Parameters:

key - Stream name

Returns:

StreamInfo that contains information about the stream

xinfoStreamFull

public Response<StreamFullInfo> xinfoStreamFull(String key)

Description copied from interface: StreamPipelineCommands

Introspection command used in order to retrieve all information about the stream

Specified by:

xinfoStreamFull in interface StreamPipelineCommands

Parameters:

key - Stream name

Returns:

StreamFullInfo that contains information about the stream

xinfoStreamFull

public Response<StreamFullInfo> xinfoStreamFull(String key,
                                                int count)

Description copied from interface: StreamPipelineCommands

Introspection command used in order to retrieve all information about the stream

Specified by:

xinfoStreamFull in interface StreamPipelineCommands

Parameters:

key - Stream name

count - stream info count

Returns:

StreamFullInfo that contains information about the stream

xinfoGroup

@Deprecated
public Response<List<StreamGroupInfo>> xinfoGroup(String key)

Deprecated.

Specified by:

xinfoGroup in interface StreamPipelineCommands

xinfoGroups

public Response<List<StreamGroupInfo>> xinfoGroups(String key)

Description copied from interface: StreamPipelineCommands

Introspection command used in order to retrieve different information about groups in the stream

Specified by:

xinfoGroups in interface StreamPipelineCommands

Parameters:

key - Stream name

Returns:

List of StreamGroupInfo containing information about groups

xinfoConsumers

public Response<List<StreamConsumersInfo>> xinfoConsumers(String key,
                                                          String group)

Description copied from interface: StreamPipelineCommands

Introspection command used in order to retrieve different information about consumers in the group

Specified by:

xinfoConsumers in interface StreamPipelineCommands

Parameters:

key - Stream name

group - Group name

Returns:

List of StreamConsumersInfo containing information about consumers that belong to the the group

xread

public Response<List<Map.Entry<String,List<StreamEntry>>>> xread(XReadParams xReadParams,
                                                                 Map<String,StreamEntryID> streams)

Description copied from interface: StreamPipelineCommands

XREAD [COUNT count] [BLOCK milliseconds] STREAMS key [key ...] ID [ID ...]

Specified by:

xread in interface StreamPipelineCommands

xreadGroup

public Response<List<Map.Entry<String,List<StreamEntry>>>> xreadGroup(String groupName,
                                                                      String consumer,
                                                                      XReadGroupParams xReadGroupParams,
                                                                      Map<String,StreamEntryID> streams)

Description copied from interface: StreamPipelineCommands

XREAD [COUNT count] [BLOCK milliseconds] STREAMS key [key ...] ID [ID ...]

Specified by:

xreadGroup in interface StreamPipelineCommands

eval

public Response<Object> eval(String script)

Specified by:

eval in interface ScriptingKeyPipelineCommands

eval

public Response<Object> eval(String script,
                             int keyCount,
                             String... params)

Specified by:

eval in interface ScriptingKeyPipelineCommands

eval

public Response<Object> eval(String script,
                             List<String> keys,
                             List<String> args)

Specified by:

eval in interface ScriptingKeyPipelineCommands

evalReadonly

public Response<Object> evalReadonly(String script,
                                     List<String> keys,
                                     List<String> args)

Specified by:

evalReadonly in interface ScriptingKeyPipelineCommands

evalsha

public Response<Object> evalsha(String sha1)

Specified by:

evalsha in interface ScriptingKeyPipelineCommands

evalsha

public Response<Object> evalsha(String sha1,
                                int keyCount,
                                String... params)

Specified by:

evalsha in interface ScriptingKeyPipelineCommands

evalsha

public Response<Object> evalsha(String sha1,
                                List<String> keys,
                                List<String> args)

Specified by:

evalsha in interface ScriptingKeyPipelineCommands

evalshaReadonly

public Response<Object> evalshaReadonly(String sha1,
                                        List<String> keys,
                                        List<String> args)

Specified by:

evalshaReadonly in interface ScriptingKeyPipelineCommands

waitReplicas

public Response<Long> waitReplicas(String sampleKey,
                                   int replicas,
                                   long timeout)

Specified by:

waitReplicas in interface SampleKeyedPipelineCommands

eval

public Response<Object> eval(String script,
                             String sampleKey)

Specified by:

eval in interface SampleKeyedPipelineCommands

evalsha

public Response<Object> evalsha(String sha1,
                                String sampleKey)

Specified by:

evalsha in interface SampleKeyedPipelineCommands

scriptExists

public Response<List<Boolean>> scriptExists(String sampleKey,
                                            String... sha1)

Specified by:

scriptExists in interface SampleKeyedPipelineCommands

scriptLoad

public Response<String> scriptLoad(String script,
                                   String sampleKey)

Specified by:

scriptLoad in interface SampleKeyedPipelineCommands

scriptFlush

public Response<String> scriptFlush(String sampleKey)

Specified by:

scriptFlush in interface SampleKeyedPipelineCommands

scriptFlush

public Response<String> scriptFlush(String sampleKey,
                                    FlushMode flushMode)

Specified by:

scriptFlush in interface SampleKeyedPipelineCommands

scriptKill

public Response<String> scriptKill(String sampleKey)

Specified by:

scriptKill in interface SampleKeyedPipelineCommands

fcall

public Response<Object> fcall(byte[] name,
                              List<byte[]> keys,
                              List<byte[]> args)

Specified by:

fcall in interface FunctionPipelineBinaryCommands

fcall

public Response<Object> fcall(String name,
                              List<String> keys,
                              List<String> args)

Specified by:

fcall in interface FunctionPipelineCommands

fcallReadonly

public Response<Object> fcallReadonly(byte[] name,
                                      List<byte[]> keys,
                                      List<byte[]> args)

Specified by:

fcallReadonly in interface FunctionPipelineBinaryCommands

fcallReadonly

public Response<Object> fcallReadonly(String name,
                                      List<String> keys,
                                      List<String> args)

Specified by:

fcallReadonly in interface FunctionPipelineCommands

functionDelete

public Response<String> functionDelete(byte[] libraryName)

Specified by:

functionDelete in interface FunctionPipelineBinaryCommands

functionDelete

public Response<String> functionDelete(String libraryName)

Specified by:

functionDelete in interface FunctionPipelineCommands

functionDump

public Response<byte[]> functionDump()

Specified by:

functionDump in interface FunctionPipelineBinaryCommands

Specified by:

functionDump in interface FunctionPipelineCommands

functionList

public Response<List<LibraryInfo>> functionList(String libraryNamePattern)

Specified by:

functionList in interface FunctionPipelineCommands

functionList

public Response<List<LibraryInfo>> functionList()

Specified by:

functionList in interface FunctionPipelineCommands

functionListWithCode

public Response<List<LibraryInfo>> functionListWithCode(String libraryNamePattern)

Specified by:

functionListWithCode in interface FunctionPipelineCommands

functionListWithCode

public Response<List<LibraryInfo>> functionListWithCode()

Specified by:

functionListWithCode in interface FunctionPipelineCommands

functionListBinary

public Response<List<Object>> functionListBinary()

Specified by:

functionListBinary in interface FunctionPipelineBinaryCommands

functionList

public Response<List<Object>> functionList(byte[] libraryNamePattern)

Specified by:

functionList in interface FunctionPipelineBinaryCommands

functionListWithCodeBinary

public Response<List<Object>> functionListWithCodeBinary()

Specified by:

functionListWithCodeBinary in interface FunctionPipelineBinaryCommands

functionListWithCode

public Response<List<Object>> functionListWithCode(byte[] libraryNamePattern)

Specified by:

functionListWithCode in interface FunctionPipelineBinaryCommands

functionLoad

public Response<String> functionLoad(byte[] functionCode)

Specified by:

functionLoad in interface FunctionPipelineBinaryCommands

functionLoad

public Response<String> functionLoad(String functionCode)

Specified by:

functionLoad in interface FunctionPipelineCommands

functionLoadReplace

public Response<String> functionLoadReplace(byte[] functionCode)

Specified by:

functionLoadReplace in interface FunctionPipelineBinaryCommands

functionLoadReplace

public Response<String> functionLoadReplace(String functionCode)

Specified by:

functionLoadReplace in interface FunctionPipelineCommands

functionRestore

public Response<String> functionRestore(byte[] serializedValue)

Specified by:

functionRestore in interface FunctionPipelineBinaryCommands

Specified by:

functionRestore in interface FunctionPipelineCommands

functionRestore

public Response<String> functionRestore(byte[] serializedValue,
                                        FunctionRestorePolicy policy)

Specified by:

functionRestore in interface FunctionPipelineBinaryCommands

Specified by:

functionRestore in interface FunctionPipelineCommands

functionFlush

public Response<String> functionFlush()

Specified by:

functionFlush in interface FunctionPipelineBinaryCommands

Specified by:

functionFlush in interface FunctionPipelineCommands

functionFlush

public Response<String> functionFlush(FlushMode mode)

Specified by:

functionFlush in interface FunctionPipelineBinaryCommands

Specified by:

functionFlush in interface FunctionPipelineCommands

functionKill

public Response<String> functionKill()

Specified by:

functionKill in interface FunctionPipelineBinaryCommands

Specified by:

functionKill in interface FunctionPipelineCommands

functionStats

public Response<FunctionStats> functionStats()

Specified by:

functionStats in interface FunctionPipelineCommands

functionStatsBinary

public Response<Object> functionStatsBinary()

Specified by:

functionStatsBinary in interface FunctionPipelineBinaryCommands

publish

public Response<Long> publish(String channel,
                              String message)

strAlgoLCSStrings

public Response<LCSMatchResult> strAlgoLCSStrings(String strA,
                                                  String strB,
                                                  StrAlgoLCSParams params)

geoadd

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

Specified by:

geoadd in interface GeoPipelineBinaryCommands

geoadd

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

Specified by:

geoadd in interface GeoPipelineBinaryCommands

geoadd

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

Specified by:

geoadd in interface GeoPipelineBinaryCommands

geodist

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

Specified by:

geodist in interface GeoPipelineBinaryCommands

geodist

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

Specified by:

geodist in interface GeoPipelineBinaryCommands

geohash

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

Specified by:

geohash in interface GeoPipelineBinaryCommands

geopos

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

Specified by:

geopos in interface GeoPipelineBinaryCommands

georadius

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

Specified by:

georadius in interface GeoPipelineBinaryCommands

georadiusReadonly

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

Specified by:

georadiusReadonly in interface GeoPipelineBinaryCommands

georadius

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

Specified by:

georadius in interface GeoPipelineBinaryCommands

georadiusReadonly

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

Specified by:

georadiusReadonly in interface GeoPipelineBinaryCommands

georadiusByMember

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

Specified by:

georadiusByMember in interface GeoPipelineBinaryCommands

georadiusByMemberReadonly

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

Specified by:

georadiusByMemberReadonly in interface GeoPipelineBinaryCommands

georadiusByMember

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

Specified by:

georadiusByMember in interface GeoPipelineBinaryCommands

georadiusByMemberReadonly

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

Specified by:

georadiusByMemberReadonly in interface GeoPipelineBinaryCommands

georadiusStore

public Response<Long> georadiusStore(byte[] key,
                                     double longitude,
                                     double latitude,
                                     double radius,
                                     GeoUnit unit,
                                     GeoRadiusParam param,
                                     GeoRadiusStoreParam storeParam)

Specified by:

georadiusStore in interface GeoPipelineBinaryCommands

georadiusByMemberStore

public Response<Long> georadiusByMemberStore(byte[] key,
                                             byte[] member,
                                             double radius,
                                             GeoUnit unit,
                                             GeoRadiusParam param,
                                             GeoRadiusStoreParam storeParam)

Specified by:

georadiusByMemberStore in interface GeoPipelineBinaryCommands

geosearch

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

Specified by:

geosearch in interface GeoPipelineBinaryCommands

geosearch

public Response<List<GeoRadiusResponse>> geosearch(byte[] key,
                                                   GeoCoordinate coord,
                                                   double radius,
                                                   GeoUnit unit)

Specified by:

geosearch in interface GeoPipelineBinaryCommands

geosearch

public Response<List<GeoRadiusResponse>> geosearch(byte[] key,
                                                   byte[] member,
                                                   double width,
                                                   double height,
                                                   GeoUnit unit)

Specified by:

geosearch in interface GeoPipelineBinaryCommands

geosearch

public Response<List<GeoRadiusResponse>> geosearch(byte[] key,
                                                   GeoCoordinate coord,
                                                   double width,
                                                   double height,
                                                   GeoUnit unit)

Specified by:

geosearch in interface GeoPipelineBinaryCommands

geosearch

public Response<List<GeoRadiusResponse>> geosearch(byte[] key,
                                                   GeoSearchParam params)

Specified by:

geosearch in interface GeoPipelineBinaryCommands

geosearchStore

public Response<Long> geosearchStore(byte[] dest,
                                     byte[] src,
                                     byte[] member,
                                     double radius,
                                     GeoUnit unit)

Specified by:

geosearchStore in interface GeoPipelineBinaryCommands

geosearchStore

public Response<Long> geosearchStore(byte[] dest,
                                     byte[] src,
                                     GeoCoordinate coord,
                                     double radius,
                                     GeoUnit unit)

Specified by:

geosearchStore in interface GeoPipelineBinaryCommands

geosearchStore

public Response<Long> geosearchStore(byte[] dest,
                                     byte[] src,
                                     byte[] member,
                                     double width,
                                     double height,
                                     GeoUnit unit)

Specified by:

geosearchStore in interface GeoPipelineBinaryCommands

geosearchStore

public Response<Long> geosearchStore(byte[] dest,
                                     byte[] src,
                                     GeoCoordinate coord,
                                     double width,
                                     double height,
                                     GeoUnit unit)

Specified by:

geosearchStore in interface GeoPipelineBinaryCommands

geosearchStore

public Response<Long> geosearchStore(byte[] dest,
                                     byte[] src,
                                     GeoSearchParam params)

Specified by:

geosearchStore in interface GeoPipelineBinaryCommands

geosearchStoreStoreDist

public Response<Long> geosearchStoreStoreDist(byte[] dest,
                                              byte[] src,
                                              GeoSearchParam params)

Specified by:

geosearchStoreStoreDist in interface GeoPipelineBinaryCommands

hset

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

Specified by:

hset in interface HashPipelineBinaryCommands

hset

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

Specified by:

hset in interface HashPipelineBinaryCommands

hget

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

Specified by:

hget in interface HashPipelineBinaryCommands

hsetnx

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

Specified by:

hsetnx in interface HashPipelineBinaryCommands

hmset

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

Specified by:

hmset in interface HashPipelineBinaryCommands

hmget

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

Specified by:

hmget in interface HashPipelineBinaryCommands

hincrBy

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

Specified by:

hincrBy in interface HashPipelineBinaryCommands

hincrByFloat

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

Specified by:

hincrByFloat in interface HashPipelineBinaryCommands

hexists

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

Specified by:

hexists in interface HashPipelineBinaryCommands

hdel

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

Specified by:

hdel in interface HashPipelineBinaryCommands

hlen

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

Specified by:

hlen in interface HashPipelineBinaryCommands

hkeys

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

Specified by:

hkeys in interface HashPipelineBinaryCommands

hvals

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

Specified by:

hvals in interface HashPipelineBinaryCommands

hgetAll

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

Specified by:

hgetAll in interface HashPipelineBinaryCommands

hrandfield

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

Specified by:

hrandfield in interface HashPipelineBinaryCommands

hrandfield

public Response<List<byte[]>> hrandfield(byte[] key,
                                         long count)

Specified by:

hrandfield in interface HashPipelineBinaryCommands

hrandfieldWithValues

public Response<Map<byte[],byte[]>> hrandfieldWithValues(byte[] key,
                                                         long count)

Specified by:

hrandfieldWithValues in interface HashPipelineBinaryCommands

hscan

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

Specified by:

hscan in interface HashPipelineBinaryCommands

hstrlen

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

Specified by:

hstrlen in interface HashPipelineBinaryCommands

pfadd

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

Specified by:

pfadd in interface HyperLogLogPipelineBinaryCommands

pfmerge

public Response<String> pfmerge(byte[] destkey,
                                byte[]... sourcekeys)

Specified by:

pfmerge in interface HyperLogLogPipelineBinaryCommands

pfcount

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

Specified by:

pfcount in interface HyperLogLogPipelineBinaryCommands

pfcount

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

Specified by:

pfcount in interface HyperLogLogPipelineBinaryCommands

exists

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

Specified by:

exists in interface KeyPipelineBinaryCommands

exists

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

Specified by:

exists in interface KeyPipelineBinaryCommands

persist

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

Specified by:

persist in interface KeyPipelineBinaryCommands

type

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

Specified by:

type in interface KeyPipelineBinaryCommands

dump

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

Specified by:

dump in interface KeyPipelineBinaryCommands

restore

public Response<String> restore(byte[] key,
                                long ttl,
                                byte[] serializedValue)

Specified by:

restore in interface KeyPipelineBinaryCommands

restore

public Response<String> restore(byte[] key,
                                long ttl,
                                byte[] serializedValue,
                                RestoreParams params)

Specified by:

restore in interface KeyPipelineBinaryCommands

expire

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

Specified by:

expire in interface KeyPipelineBinaryCommands

expire

public Response<Long> expire(byte[] key,
                             long seconds,
                             ExpiryOption expiryOption)

Specified by:

expire in interface KeyPipelineBinaryCommands

pexpire

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

Specified by:

pexpire in interface KeyPipelineBinaryCommands

pexpire

public Response<Long> pexpire(byte[] key,
                              long milliseconds,
                              ExpiryOption expiryOption)

Specified by:

pexpire in interface KeyPipelineBinaryCommands

expireTime

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

Specified by:

expireTime in interface KeyPipelineBinaryCommands

pexpireTime

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

Specified by:

pexpireTime in interface KeyPipelineBinaryCommands

expireAt

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

Specified by:

expireAt in interface KeyPipelineBinaryCommands

expireAt

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

Specified by:

expireAt in interface KeyPipelineBinaryCommands

pexpireAt

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

Specified by:

pexpireAt in interface KeyPipelineBinaryCommands

pexpireAt

public Response<Long> pexpireAt(byte[] key,
                                long millisecondsTimestamp,
                                ExpiryOption expiryOption)

Specified by:

pexpireAt in interface KeyPipelineBinaryCommands

ttl

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

Specified by:

ttl in interface KeyPipelineBinaryCommands

pttl

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

Specified by:

pttl in interface KeyPipelineBinaryCommands

touch

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

Specified by:

touch in interface KeyPipelineBinaryCommands

touch

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

Specified by:

touch in interface KeyPipelineBinaryCommands

sort

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

Specified by:

sort in interface KeyPipelineBinaryCommands

sort

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

Specified by:

sort in interface KeyPipelineBinaryCommands

sortReadonly

public Response<List<byte[]>> sortReadonly(byte[] key,
                                           SortingParams sortingParams)

Specified by:

sortReadonly in interface KeyPipelineBinaryCommands

del

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

Specified by:

del in interface KeyPipelineBinaryCommands

del

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

Specified by:

del in interface KeyPipelineBinaryCommands

unlink

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

Specified by:

unlink in interface KeyPipelineBinaryCommands

unlink

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

Specified by:

unlink in interface KeyPipelineBinaryCommands

copy

public Response<Boolean> copy(byte[] srcKey,
                              byte[] dstKey,
                              boolean replace)

Specified by:

copy in interface KeyPipelineBinaryCommands

rename

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

Specified by:

rename in interface KeyPipelineBinaryCommands

renamenx

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

Specified by:

renamenx in interface KeyPipelineBinaryCommands

sort

public Response<Long> sort(byte[] key,
                           SortingParams sortingParams,
                           byte[] dstkey)

Specified by:

sort in interface KeyPipelineBinaryCommands

sort

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

Specified by:

sort in interface KeyPipelineBinaryCommands

memoryUsage

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

Specified by:

memoryUsage in interface KeyPipelineBinaryCommands

memoryUsage

public Response<Long> memoryUsage(byte[] key,
                                  int samples)

Specified by:

memoryUsage in interface KeyPipelineBinaryCommands

objectRefcount

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

Specified by:

objectRefcount in interface KeyPipelineBinaryCommands

objectEncoding

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

Specified by:

objectEncoding in interface KeyPipelineBinaryCommands

objectIdletime

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

Specified by:

objectIdletime in interface KeyPipelineBinaryCommands

objectFreq

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

Specified by:

objectFreq in interface KeyPipelineBinaryCommands

migrate

public Response<String> migrate(String host,
                                int port,
                                byte[] key,
                                int timeout)

Specified by:

migrate in interface KeyPipelineBinaryCommands

migrate

public Response<String> migrate(String host,
                                int port,
                                int timeout,
                                MigrateParams params,
                                byte[]... keys)

Specified by:

migrate in interface KeyPipelineBinaryCommands

keys

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

Specified by:

keys in interface KeyPipelineBinaryCommands

scan

public Response<ScanResult<byte[]>> scan(byte[] cursor)

Specified by:

scan in interface KeyPipelineBinaryCommands

scan

public Response<ScanResult<byte[]>> scan(byte[] cursor,
                                         ScanParams params)

Specified by:

scan in interface KeyPipelineBinaryCommands

scan

public Response<ScanResult<byte[]>> scan(byte[] cursor,
                                         ScanParams params,
                                         byte[] type)

Specified by:

scan in interface KeyPipelineBinaryCommands

randomBinaryKey

public Response<byte[]> randomBinaryKey()

Specified by:

randomBinaryKey in interface KeyPipelineBinaryCommands

rpush

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

Specified by:

rpush in interface ListPipelineBinaryCommands

lpush

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

Specified by:

lpush in interface ListPipelineBinaryCommands

llen

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

Specified by:

llen in interface ListPipelineBinaryCommands

lrange

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

Specified by:

lrange in interface ListPipelineBinaryCommands

ltrim

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

Specified by:

ltrim in interface ListPipelineBinaryCommands

lindex

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

Specified by:

lindex in interface ListPipelineBinaryCommands

lset

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

Specified by:

lset in interface ListPipelineBinaryCommands

lrem

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

Specified by:

lrem in interface ListPipelineBinaryCommands

lpop

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

Specified by:

lpop in interface ListPipelineBinaryCommands

lpop

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

Specified by:

lpop in interface ListPipelineBinaryCommands

lpos

public Response<Long> lpos(byte[] key,
                           byte[] element)

Specified by:

lpos in interface ListPipelineBinaryCommands

lpos

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

Specified by:

lpos in interface ListPipelineBinaryCommands

lpos

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

Specified by:

lpos in interface ListPipelineBinaryCommands

rpop

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

Specified by:

rpop in interface ListPipelineBinaryCommands

rpop

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

Specified by:

rpop in interface ListPipelineBinaryCommands

linsert

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

Specified by:

linsert in interface ListPipelineBinaryCommands

lpushx

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

Specified by:

lpushx in interface ListPipelineBinaryCommands

rpushx

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

Specified by:

rpushx in interface ListPipelineBinaryCommands

blpop

public Response<List<byte[]>> blpop(int timeout,
                                    byte[]... keys)

Specified by:

blpop in interface ListPipelineBinaryCommands

blpop

public Response<List<byte[]>> blpop(double timeout,
                                    byte[]... keys)

Specified by:

blpop in interface ListPipelineBinaryCommands

brpop

public Response<List<byte[]>> brpop(int timeout,
                                    byte[]... keys)

Specified by:

brpop in interface ListPipelineBinaryCommands

brpop

public Response<List<byte[]>> brpop(double timeout,
                                    byte[]... keys)

Specified by:

brpop in interface ListPipelineBinaryCommands

rpoplpush

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

Specified by:

rpoplpush in interface ListPipelineBinaryCommands

brpoplpush

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

Specified by:

brpoplpush in interface ListPipelineBinaryCommands

lmove

public Response<byte[]> lmove(byte[] srcKey,
                              byte[] dstKey,
                              ListDirection from,
                              ListDirection to)

Specified by:

lmove in interface ListPipelineBinaryCommands

blmove

public Response<byte[]> blmove(byte[] srcKey,
                               byte[] dstKey,
                               ListDirection from,
                               ListDirection to,
                               double timeout)

Specified by:

blmove in interface ListPipelineBinaryCommands

lmpop

public Response<KeyValue<byte[],List<byte[]>>> lmpop(ListDirection direction,
                                                     byte[]... keys)

Specified by:

lmpop in interface ListPipelineBinaryCommands

lmpop

public Response<KeyValue<byte[],List<byte[]>>> lmpop(ListDirection direction,
                                                     int count,
                                                     byte[]... keys)

Specified by:

lmpop in interface ListPipelineBinaryCommands

blmpop

public Response<KeyValue<byte[],List<byte[]>>> blmpop(long timeout,
                                                      ListDirection direction,
                                                      byte[]... keys)

Specified by:

blmpop in interface ListPipelineBinaryCommands

blmpop

public Response<KeyValue<byte[],List<byte[]>>> blmpop(long timeout,
                                                      ListDirection direction,
                                                      int count,
                                                      byte[]... keys)

Specified by:

blmpop in interface ListPipelineBinaryCommands

publish

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

strAlgoLCSStrings

public Response<LCSMatchResult> strAlgoLCSStrings(byte[] strA,
                                                  byte[] strB,
                                                  StrAlgoLCSParams params)

waitReplicas

public Response<Long> waitReplicas(byte[] sampleKey,
                                   int replicas,
                                   long timeout)

Specified by:

waitReplicas in interface SampleBinaryKeyedPipelineCommands

eval

public Response<Object> eval(byte[] script,
                             byte[] sampleKey)

Specified by:

eval in interface SampleBinaryKeyedPipelineCommands

evalsha

public Response<Object> evalsha(byte[] sha1,
                                byte[] sampleKey)

Specified by:

evalsha in interface SampleBinaryKeyedPipelineCommands

scriptExists

public Response<List<Boolean>> scriptExists(byte[] sampleKey,
                                            byte[]... sha1s)

Specified by:

scriptExists in interface SampleBinaryKeyedPipelineCommands

scriptLoad

public Response<byte[]> scriptLoad(byte[] script,
                                   byte[] sampleKey)

Specified by:

scriptLoad in interface SampleBinaryKeyedPipelineCommands

scriptFlush

public Response<String> scriptFlush(byte[] sampleKey)

Specified by:

scriptFlush in interface SampleBinaryKeyedPipelineCommands

scriptFlush

public Response<String> scriptFlush(byte[] sampleKey,
                                    FlushMode flushMode)

Specified by:

scriptFlush in interface SampleBinaryKeyedPipelineCommands

scriptKill

public Response<String> scriptKill(byte[] sampleKey)

Specified by:

scriptKill in interface SampleBinaryKeyedPipelineCommands

eval

public Response<Object> eval(byte[] script)

Specified by:

eval in interface ScriptingKeyPipelineBinaryCommands

eval

public Response<Object> eval(byte[] script,
                             int keyCount,
                             byte[]... params)

Specified by:

eval in interface ScriptingKeyPipelineBinaryCommands

eval

public Response<Object> eval(byte[] script,
                             List<byte[]> keys,
                             List<byte[]> args)

Specified by:

eval in interface ScriptingKeyPipelineBinaryCommands

evalReadonly

public Response<Object> evalReadonly(byte[] script,
                                     List<byte[]> keys,
                                     List<byte[]> args)

Specified by:

evalReadonly in interface ScriptingKeyPipelineBinaryCommands

evalsha

public Response<Object> evalsha(byte[] sha1)

Specified by:

evalsha in interface ScriptingKeyPipelineBinaryCommands

evalsha

public Response<Object> evalsha(byte[] sha1,
                                int keyCount,
                                byte[]... params)

Specified by:

evalsha in interface ScriptingKeyPipelineBinaryCommands

evalsha

public Response<Object> evalsha(byte[] sha1,
                                List<byte[]> keys,
                                List<byte[]> args)

Specified by:

evalsha in interface ScriptingKeyPipelineBinaryCommands

evalshaReadonly

public Response<Object> evalshaReadonly(byte[] sha1,
                                        List<byte[]> keys,
                                        List<byte[]> args)

Specified by:

evalshaReadonly in interface ScriptingKeyPipelineBinaryCommands

sadd

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

Specified by:

sadd in interface SetPipelineBinaryCommands

smembers

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

Specified by:

smembers in interface SetPipelineBinaryCommands

srem

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

Specified by:

srem in interface SetPipelineBinaryCommands

spop

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

Specified by:

spop in interface SetPipelineBinaryCommands

spop

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

Specified by:

spop in interface SetPipelineBinaryCommands

scard

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

Specified by:

scard in interface SetPipelineBinaryCommands

sismember

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

Specified by:

sismember in interface SetPipelineBinaryCommands

smismember

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

Specified by:

smismember in interface SetPipelineBinaryCommands

srandmember

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

Specified by:

srandmember in interface SetPipelineBinaryCommands

srandmember

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

Specified by:

srandmember in interface SetPipelineBinaryCommands

sscan

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

Specified by:

sscan in interface SetPipelineBinaryCommands

sdiff

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

Specified by:

sdiff in interface SetPipelineBinaryCommands

sdiffstore

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

Specified by:

sdiffstore in interface SetPipelineBinaryCommands

sinter

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

Specified by:

sinter in interface SetPipelineBinaryCommands

sinterstore

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

Specified by:

sinterstore in interface SetPipelineBinaryCommands

sintercard

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

Specified by:

sintercard in interface SetPipelineBinaryCommands

sintercard

public Response<Long> sintercard(int limit,
                                 byte[]... keys)

Specified by:

sintercard in interface SetPipelineBinaryCommands

sunion

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

Specified by:

sunion in interface SetPipelineBinaryCommands

sunionstore

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

Specified by:

sunionstore in interface SetPipelineBinaryCommands

smove

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

Specified by:

smove in interface SetPipelineBinaryCommands

zadd

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

Specified by:

zadd in interface SortedSetPipelineBinaryCommands

zadd

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

Specified by:

zadd in interface SortedSetPipelineBinaryCommands

zadd

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

Specified by:

zadd in interface SortedSetPipelineBinaryCommands

zadd

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

Specified by:

zadd in interface SortedSetPipelineBinaryCommands

zaddIncr

public Response<Double> zaddIncr(byte[] key,
                                 double score,
                                 byte[] member,
                                 ZAddParams params)

Specified by:

zaddIncr in interface SortedSetPipelineBinaryCommands

zrem

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

Specified by:

zrem in interface SortedSetPipelineBinaryCommands

zincrby

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

Specified by:

zincrby in interface SortedSetPipelineBinaryCommands

zincrby

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

Specified by:

zincrby in interface SortedSetPipelineBinaryCommands

zrank

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

Specified by:

zrank in interface SortedSetPipelineBinaryCommands

zrevrank

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

Specified by:

zrevrank in interface SortedSetPipelineBinaryCommands

zrange

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

Specified by:

zrange in interface SortedSetPipelineBinaryCommands

zrevrange

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

Specified by:

zrevrange in interface SortedSetPipelineBinaryCommands

zrangeWithScores

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

Specified by:

zrangeWithScores in interface SortedSetPipelineBinaryCommands

zrevrangeWithScores

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

Specified by:

zrevrangeWithScores in interface SortedSetPipelineBinaryCommands

zrange

public Response<List<byte[]>> zrange(byte[] key,
                                     ZRangeParams zRangeParams)

Specified by:

zrange in interface SortedSetPipelineBinaryCommands

zrangeWithScores

public Response<List<Tuple>> zrangeWithScores(byte[] key,
                                              ZRangeParams zRangeParams)

Specified by:

zrangeWithScores in interface SortedSetPipelineBinaryCommands

zrangestore

public Response<Long> zrangestore(byte[] dest,
                                  byte[] src,
                                  ZRangeParams zRangeParams)

Specified by:

zrangestore in interface SortedSetPipelineBinaryCommands

zrandmember

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

Specified by:

zrandmember in interface SortedSetPipelineBinaryCommands

zrandmember

public Response<List<byte[]>> zrandmember(byte[] key,
                                          long count)

Specified by:

zrandmember in interface SortedSetPipelineBinaryCommands

zrandmemberWithScores

public Response<List<Tuple>> zrandmemberWithScores(byte[] key,
                                                   long count)

Specified by:

zrandmemberWithScores in interface SortedSetPipelineBinaryCommands

zcard

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

Specified by:

zcard in interface SortedSetPipelineBinaryCommands

zscore

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

Specified by:

zscore in interface SortedSetPipelineBinaryCommands

zmscore

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

Specified by:

zmscore in interface SortedSetPipelineBinaryCommands

zpopmax

public Response<Tuple> zpopmax(byte[] key)

Specified by:

zpopmax in interface SortedSetPipelineBinaryCommands

zpopmax

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

Specified by:

zpopmax in interface SortedSetPipelineBinaryCommands

zpopmin

public Response<Tuple> zpopmin(byte[] key)

Specified by:

zpopmin in interface SortedSetPipelineBinaryCommands

zpopmin

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

Specified by:

zpopmin in interface SortedSetPipelineBinaryCommands

zcount

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

Specified by:

zcount in interface SortedSetPipelineBinaryCommands

zcount

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

Specified by:

zcount in interface SortedSetPipelineBinaryCommands

zrangeByScore

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

Specified by:

zrangeByScore in interface SortedSetPipelineBinaryCommands

zrangeByScore

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

Specified by:

zrangeByScore in interface SortedSetPipelineBinaryCommands

zrevrangeByScore

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

Specified by:

zrevrangeByScore in interface SortedSetPipelineBinaryCommands

zrangeByScore

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

Specified by:

zrangeByScore in interface SortedSetPipelineBinaryCommands

zrevrangeByScore

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

Specified by:

zrevrangeByScore in interface SortedSetPipelineBinaryCommands

zrangeByScore

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

Specified by:

zrangeByScore in interface SortedSetPipelineBinaryCommands

zrevrangeByScore

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

Specified by:

zrevrangeByScore in interface SortedSetPipelineBinaryCommands

zrangeByScoreWithScores

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

Specified by:

zrangeByScoreWithScores in interface SortedSetPipelineBinaryCommands

zrevrangeByScoreWithScores

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

Specified by:

zrevrangeByScoreWithScores in interface SortedSetPipelineBinaryCommands

zrangeByScoreWithScores

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

Specified by:

zrangeByScoreWithScores in interface SortedSetPipelineBinaryCommands

zrevrangeByScore

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

Specified by:

zrevrangeByScore in interface SortedSetPipelineBinaryCommands

zrangeByScoreWithScores

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

Specified by:

zrangeByScoreWithScores in interface SortedSetPipelineBinaryCommands

zrevrangeByScoreWithScores

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

Specified by:

zrevrangeByScoreWithScores in interface SortedSetPipelineBinaryCommands

zrangeByScoreWithScores

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

Specified by:

zrangeByScoreWithScores in interface SortedSetPipelineBinaryCommands

zrevrangeByScoreWithScores

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

Specified by:

zrevrangeByScoreWithScores in interface SortedSetPipelineBinaryCommands

zrevrangeByScoreWithScores

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

Specified by:

zrevrangeByScoreWithScores in interface SortedSetPipelineBinaryCommands

zremrangeByRank

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

Specified by:

zremrangeByRank in interface SortedSetPipelineBinaryCommands

zremrangeByScore

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

Specified by:

zremrangeByScore in interface SortedSetPipelineBinaryCommands

zremrangeByScore

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

Specified by:

zremrangeByScore in interface SortedSetPipelineBinaryCommands

zlexcount

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

Specified by:

zlexcount in interface SortedSetPipelineBinaryCommands

zrangeByLex

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

Specified by:

zrangeByLex in interface SortedSetPipelineBinaryCommands

zrangeByLex

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

Specified by:

zrangeByLex in interface SortedSetPipelineBinaryCommands

zrevrangeByLex

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

Specified by:

zrevrangeByLex in interface SortedSetPipelineBinaryCommands

zrevrangeByLex

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

Specified by:

zrevrangeByLex in interface SortedSetPipelineBinaryCommands

zremrangeByLex

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

Specified by:

zremrangeByLex in interface SortedSetPipelineBinaryCommands

zscan

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

Specified by:

zscan in interface SortedSetPipelineBinaryCommands

bzpopmax

public Response<List<byte[]>> bzpopmax(double timeout,
                                       byte[]... keys)

Specified by:

bzpopmax in interface SortedSetPipelineBinaryCommands

bzpopmin

public Response<List<byte[]>> bzpopmin(double timeout,
                                       byte[]... keys)

Specified by:

bzpopmin in interface SortedSetPipelineBinaryCommands

zmpop

public Response<KeyValue<byte[],List<Tuple>>> zmpop(SortedSetOption option,
                                                    byte[]... keys)

Specified by:

zmpop in interface SortedSetPipelineBinaryCommands

zmpop

public Response<KeyValue<byte[],List<Tuple>>> zmpop(SortedSetOption option,
                                                    int count,
                                                    byte[]... keys)

Specified by:

zmpop in interface SortedSetPipelineBinaryCommands

bzmpop

public Response<KeyValue<byte[],List<Tuple>>> bzmpop(long timeout,
                                                     SortedSetOption option,
                                                     byte[]... keys)

Specified by:

bzmpop in interface SortedSetPipelineBinaryCommands

bzmpop

public Response<KeyValue<byte[],List<Tuple>>> bzmpop(long timeout,
                                                     SortedSetOption option,
                                                     int count,
                                                     byte[]... keys)

Specified by:

bzmpop in interface SortedSetPipelineBinaryCommands

zdiff

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

Specified by:

zdiff in interface SortedSetPipelineBinaryCommands

zdiffWithScores

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

Specified by:

zdiffWithScores in interface SortedSetPipelineBinaryCommands

zdiffStore

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

Specified by:

zdiffStore in interface SortedSetPipelineBinaryCommands

zinter

public Response<Set<byte[]>> zinter(ZParams params,
                                    byte[]... keys)

Specified by:

zinter in interface SortedSetPipelineBinaryCommands

zinterWithScores

public Response<Set<Tuple>> zinterWithScores(ZParams params,
                                             byte[]... keys)

Specified by:

zinterWithScores in interface SortedSetPipelineBinaryCommands

zinterstore

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

Specified by:

zinterstore in interface SortedSetPipelineBinaryCommands

zinterstore

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

Specified by:

zinterstore in interface SortedSetPipelineBinaryCommands

zintercard

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

Specified by:

zintercard in interface SortedSetPipelineBinaryCommands

zintercard

public Response<Long> zintercard(long limit,
                                 byte[]... keys)

Specified by:

zintercard in interface SortedSetPipelineBinaryCommands

zunion

public Response<Set<byte[]>> zunion(ZParams params,
                                    byte[]... keys)

Specified by:

zunion in interface SortedSetPipelineBinaryCommands

zunionWithScores

public Response<Set<Tuple>> zunionWithScores(ZParams params,
                                             byte[]... keys)

Specified by:

zunionWithScores in interface SortedSetPipelineBinaryCommands

zunionstore

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

Specified by:

zunionstore in interface SortedSetPipelineBinaryCommands

zunionstore

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

Specified by:

zunionstore in interface SortedSetPipelineBinaryCommands

xadd

public Response<byte[]> xadd(byte[] key,
                             XAddParams params,
                             Map<byte[],byte[]> hash)

Specified by:

xadd in interface StreamPipelineBinaryCommands

xlen

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

Specified by:

xlen in interface StreamPipelineBinaryCommands

xrange

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

Specified by:

xrange in interface StreamPipelineBinaryCommands

xrange

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

Specified by:

xrange in interface StreamPipelineBinaryCommands

xrevrange

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

Specified by:

xrevrange in interface StreamPipelineBinaryCommands

xrevrange

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

Specified by:

xrevrange in interface StreamPipelineBinaryCommands

xack

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

Specified by:

xack in interface StreamPipelineBinaryCommands

xgroupCreate

public Response<String> xgroupCreate(byte[] key,
                                     byte[] groupName,
                                     byte[] id,
                                     boolean makeStream)

Specified by:

xgroupCreate in interface StreamPipelineBinaryCommands

xgroupSetID

public Response<String> xgroupSetID(byte[] key,
                                    byte[] groupName,
                                    byte[] id)

Specified by:

xgroupSetID in interface StreamPipelineBinaryCommands

xgroupDestroy

public Response<Long> xgroupDestroy(byte[] key,
                                    byte[] groupName)

Specified by:

xgroupDestroy in interface StreamPipelineBinaryCommands

xgroupCreateConsumer

public Response<Boolean> xgroupCreateConsumer(byte[] key,
                                              byte[] groupName,
                                              byte[] consumerName)

Specified by:

xgroupCreateConsumer in interface StreamPipelineBinaryCommands

xgroupDelConsumer

public Response<Long> xgroupDelConsumer(byte[] key,
                                        byte[] groupName,
                                        byte[] consumerName)

Specified by:

xgroupDelConsumer in interface StreamPipelineBinaryCommands

xdel

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

Specified by:

xdel in interface StreamPipelineBinaryCommands

xtrim

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

Specified by:

xtrim in interface StreamPipelineBinaryCommands

xtrim

public Response<Long> xtrim(byte[] key,
                            XTrimParams params)

Specified by:

xtrim in interface StreamPipelineBinaryCommands

xpending

public Response<Object> xpending(byte[] key,
                                 byte[] groupName)

Specified by:

xpending in interface StreamPipelineBinaryCommands

xpending

public Response<List<Object>> xpending(byte[] key,
                                       byte[] groupName,
                                       byte[] start,
                                       byte[] end,
                                       int count,
                                       byte[] consumerName)

Specified by:

xpending in interface StreamPipelineBinaryCommands

xpending

public Response<List<Object>> xpending(byte[] key,
                                       byte[] groupName,
                                       XPendingParams params)

Specified by:

xpending in interface StreamPipelineBinaryCommands

xclaim

public Response<List<byte[]>> xclaim(byte[] key,
                                     byte[] group,
                                     byte[] consumerName,
                                     long minIdleTime,
                                     XClaimParams params,
                                     byte[]... ids)

Specified by:

xclaim in interface StreamPipelineBinaryCommands

xclaimJustId

public Response<List<byte[]>> xclaimJustId(byte[] key,
                                           byte[] group,
                                           byte[] consumerName,
                                           long minIdleTime,
                                           XClaimParams params,
                                           byte[]... ids)

Specified by:

xclaimJustId in interface StreamPipelineBinaryCommands

xautoclaim

public Response<List<Object>> xautoclaim(byte[] key,
                                         byte[] groupName,
                                         byte[] consumerName,
                                         long minIdleTime,
                                         byte[] start,
                                         XAutoClaimParams params)

Specified by:

xautoclaim in interface StreamPipelineBinaryCommands

xautoclaimJustId

public Response<List<Object>> xautoclaimJustId(byte[] key,
                                               byte[] groupName,
                                               byte[] consumerName,
                                               long minIdleTime,
                                               byte[] start,
                                               XAutoClaimParams params)

Specified by:

xautoclaimJustId in interface StreamPipelineBinaryCommands

xinfoStream

public Response<Object> xinfoStream(byte[] key)

Specified by:

xinfoStream in interface StreamPipelineBinaryCommands

xinfoStreamFull

public Response<Object> xinfoStreamFull(byte[] key)

Description copied from interface: StreamPipelineBinaryCommands

Introspection command used in order to retrieve all information about the stream

Specified by:

xinfoStreamFull in interface StreamPipelineBinaryCommands

Parameters:

key - Stream name

xinfoStreamFull

public Response<Object> xinfoStreamFull(byte[] key,
                                        int count)

Description copied from interface: StreamPipelineBinaryCommands

Introspection command used in order to retrieve all information about the stream

Specified by:

xinfoStreamFull in interface StreamPipelineBinaryCommands

Parameters:

key - Stream name

count - stream info count

xinfoGroup

@Deprecated
public Response<List<Object>> xinfoGroup(byte[] key)

Deprecated.

Specified by:

xinfoGroup in interface StreamPipelineBinaryCommands

xinfoGroups

public Response<List<Object>> xinfoGroups(byte[] key)

Specified by:

xinfoGroups in interface StreamPipelineBinaryCommands

xinfoConsumers

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

Specified by:

xinfoConsumers in interface StreamPipelineBinaryCommands

xread

public Response<List<byte[]>> xread(XReadParams xReadParams,
                                    Map.Entry<byte[],byte[]>... streams)

Specified by:

xread in interface StreamPipelineBinaryCommands

xreadGroup

public Response<List<byte[]>> xreadGroup(byte[] groupName,
                                         byte[] consumer,
                                         XReadGroupParams xReadGroupParams,
                                         Map.Entry<byte[],byte[]>... streams)

Specified by:

xreadGroup in interface StreamPipelineBinaryCommands

set

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

Specified by:

set in interface StringPipelineBinaryCommands

set

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

Specified by:

set in interface StringPipelineBinaryCommands

get

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

Specified by:

get in interface StringPipelineBinaryCommands

getDel

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

Specified by:

getDel in interface StringPipelineBinaryCommands

getEx

public Response<byte[]> getEx(byte[] key,
                              GetExParams params)

Specified by:

getEx in interface StringPipelineBinaryCommands

setbit

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

Specified by:

setbit in interface StringPipelineBinaryCommands

getbit

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

Specified by:

getbit in interface StringPipelineBinaryCommands

setrange

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

Specified by:

setrange in interface StringPipelineBinaryCommands

getrange

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

Specified by:

getrange in interface StringPipelineBinaryCommands

getSet

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

Specified by:

getSet in interface StringPipelineBinaryCommands

setnx

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

Specified by:

setnx in interface StringPipelineBinaryCommands

setex

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

Specified by:

setex in interface StringPipelineBinaryCommands

psetex

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

Specified by:

psetex in interface StringPipelineBinaryCommands

mget

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

Specified by:

mget in interface StringPipelineBinaryCommands

mset

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

Specified by:

mset in interface StringPipelineBinaryCommands

msetnx

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

Specified by:

msetnx in interface StringPipelineBinaryCommands

incr

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

Specified by:

incr in interface StringPipelineBinaryCommands

incrBy

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

Specified by:

incrBy in interface StringPipelineBinaryCommands

incrByFloat

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

Specified by:

incrByFloat in interface StringPipelineBinaryCommands

decr

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

Specified by:

decr in interface StringPipelineBinaryCommands

decrBy

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

Specified by:

decrBy in interface StringPipelineBinaryCommands

append

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

Specified by:

append in interface StringPipelineBinaryCommands

substr

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

Specified by:

substr in interface StringPipelineBinaryCommands

strlen

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

Specified by:

strlen in interface StringPipelineBinaryCommands

bitcount

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

Specified by:

bitcount in interface StringPipelineBinaryCommands

bitcount

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

Specified by:

bitcount in interface StringPipelineBinaryCommands

bitcount

public Response<Long> bitcount(byte[] key,
                               long start,
                               long end,
                               BitCountOption option)

Specified by:

bitcount in interface StringPipelineBinaryCommands

bitpos

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

Specified by:

bitpos in interface StringPipelineBinaryCommands

bitpos

public Response<Long> bitpos(byte[] key,
                             boolean value,
                             BitPosParams params)

Specified by:

bitpos in interface StringPipelineBinaryCommands

bitfield

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

Specified by:

bitfield in interface StringPipelineBinaryCommands

bitfieldReadonly

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

Specified by:

bitfieldReadonly in interface StringPipelineBinaryCommands

bitop

public Response<Long> bitop(BitOP op,
                            byte[] destKey,
                            byte[]... srcKeys)

Specified by:

bitop in interface StringPipelineBinaryCommands

strAlgoLCSKeys

public Response<LCSMatchResult> strAlgoLCSKeys(byte[] keyA,
                                               byte[] keyB,
                                               StrAlgoLCSParams params)

Specified by:

strAlgoLCSKeys in interface StringPipelineBinaryCommands

ftCreate

public Response<String> ftCreate(String indexName,
                                 IndexOptions indexOptions,
                                 Schema schema)

Specified by:

ftCreate in interface RediSearchPipelineCommands

ftAlter

public Response<String> ftAlter(String indexName,
                                Schema schema)

Specified by:

ftAlter in interface RediSearchPipelineCommands

ftSearch

public Response<SearchResult> ftSearch(String indexName,
                                       Query query)

Specified by:

ftSearch in interface RediSearchPipelineCommands

ftSearch

public Response<SearchResult> ftSearch(byte[] indexName,
                                       Query query)

Specified by:

ftSearch in interface RediSearchPipelineCommands

ftExplain

public Response<String> ftExplain(String indexName,
                                  Query query)

Specified by:

ftExplain in interface RediSearchPipelineCommands

ftExplainCLI

public Response<List<String>> ftExplainCLI(String indexName,
                                           Query query)

Specified by:

ftExplainCLI in interface RediSearchPipelineCommands

ftAggregate

public Response<AggregationResult> ftAggregate(String indexName,
                                               AggregationBuilder aggr)

Specified by:

ftAggregate in interface RediSearchPipelineCommands

ftCursorRead

public Response<AggregationResult> ftCursorRead(String indexName,
                                                long cursorId,
                                                int count)

Specified by:

ftCursorRead in interface RediSearchPipelineCommands

ftCursorDel

public Response<String> ftCursorDel(String indexName,
                                    long cursorId)

Specified by:

ftCursorDel in interface RediSearchPipelineCommands

ftDropIndex

public Response<String> ftDropIndex(String indexName)

Specified by:

ftDropIndex in interface RediSearchPipelineCommands

ftDropIndexDD

public Response<String> ftDropIndexDD(String indexName)

Specified by:

ftDropIndexDD in interface RediSearchPipelineCommands

ftSynUpdate

public Response<String> ftSynUpdate(String indexName,
                                    String synonymGroupId,
                                    String... terms)

Specified by:

ftSynUpdate in interface RediSearchPipelineCommands

ftSynDump

public Response<Map<String,List<String>>> ftSynDump(String indexName)

Specified by:

ftSynDump in interface RediSearchPipelineCommands

ftInfo

public Response<Map<String,Object>> ftInfo(String indexName)

Specified by:

ftInfo in interface RediSearchPipelineCommands

ftAliasAdd

public Response<String> ftAliasAdd(String aliasName,
                                   String indexName)

Specified by:

ftAliasAdd in interface RediSearchPipelineCommands

ftAliasUpdate

public Response<String> ftAliasUpdate(String aliasName,
                                      String indexName)

Specified by:

ftAliasUpdate in interface RediSearchPipelineCommands

ftAliasDel

public Response<String> ftAliasDel(String aliasName)

Specified by:

ftAliasDel in interface RediSearchPipelineCommands

ftConfigGet

public Response<Map<String,String>> ftConfigGet(String option)

Specified by:

ftConfigGet in interface RediSearchPipelineCommands

ftConfigGet

public Response<Map<String,String>> ftConfigGet(String indexName,
                                                String option)

Specified by:

ftConfigGet in interface RediSearchPipelineCommands

ftConfigSet

public Response<String> ftConfigSet(String option,
                                    String value)

Specified by:

ftConfigSet in interface RediSearchPipelineCommands

ftConfigSet

public Response<String> ftConfigSet(String indexName,
                                    String option,
                                    String value)

Specified by:

ftConfigSet in interface RediSearchPipelineCommands

lcs

public Response<LCSMatchResult> lcs(byte[] keyA,
                                    byte[] keyB,
                                    LCSParams params)

Specified by:

lcs in interface StringPipelineBinaryCommands

jsonSet

public Response<String> jsonSet(String key,
                                Path2 path,
                                Object object)

Specified by:

jsonSet in interface RedisJsonPipelineCommands

jsonSetWithEscape

public Response<String> jsonSetWithEscape(String key,
                                          Path2 path,
                                          Object object)

Specified by:

jsonSetWithEscape in interface RedisJsonPipelineCommands

jsonSet

public Response<String> jsonSet(String key,
                                Path path,
                                Object object)

Specified by:

jsonSet in interface RedisJsonPipelineCommands

jsonSet

public Response<String> jsonSet(String key,
                                Path2 path,
                                Object object,
                                JsonSetParams params)

Specified by:

jsonSet in interface RedisJsonPipelineCommands

jsonSetWithEscape

public Response<String> jsonSetWithEscape(String key,
                                          Path2 path,
                                          Object object,
                                          JsonSetParams params)

Specified by:

jsonSetWithEscape in interface RedisJsonPipelineCommands

jsonSet

public Response<String> jsonSet(String key,
                                Path path,
                                Object object,
                                JsonSetParams params)

Specified by:

jsonSet in interface RedisJsonPipelineCommands

jsonGet

public Response<Object> jsonGet(String key)

Specified by:

jsonGet in interface RedisJsonPipelineCommands

jsonGet

public <T> Response<T> jsonGet(String key,
                               Class<T> clazz)

Specified by:

jsonGet in interface RedisJsonPipelineCommands

jsonGet

public Response<Object> jsonGet(String key,
                                Path2... paths)

Specified by:

jsonGet in interface RedisJsonPipelineCommands

jsonGet

public Response<Object> jsonGet(String key,
                                Path... paths)

Specified by:

jsonGet in interface RedisJsonPipelineCommands

jsonGet

public <T> Response<T> jsonGet(String key,
                               Class<T> clazz,
                               Path... paths)

Specified by:

jsonGet in interface RedisJsonPipelineCommands

jsonMGet

public Response<List<org.json.JSONArray>> jsonMGet(Path2 path,
                                                   String... keys)

Specified by:

jsonMGet in interface RedisJsonPipelineCommands

jsonMGet

public <T> Response<List<T>> jsonMGet(Path path,
                                      Class<T> clazz,
                                      String... keys)

Specified by:

jsonMGet in interface RedisJsonPipelineCommands

jsonDel

public Response<Long> jsonDel(String key)

Specified by:

jsonDel in interface RedisJsonPipelineCommands

jsonDel

public Response<Long> jsonDel(String key,
                              Path2 path)

Specified by:

jsonDel in interface RedisJsonPipelineCommands

jsonDel

public Response<Long> jsonDel(String key,
                              Path path)

Specified by:

jsonDel in interface RedisJsonPipelineCommands

jsonClear

public Response<Long> jsonClear(String key)

Specified by:

jsonClear in interface RedisJsonPipelineCommands

jsonClear

public Response<Long> jsonClear(String key,
                                Path2 path)

Specified by:

jsonClear in interface RedisJsonPipelineCommands

jsonClear

public Response<Long> jsonClear(String key,
                                Path path)

Specified by:

jsonClear in interface RedisJsonPipelineCommands

jsonToggle

public Response<List<Boolean>> jsonToggle(String key,
                                          Path2 path)

Specified by:

jsonToggle in interface RedisJsonPipelineCommands

jsonToggle

public Response<String> jsonToggle(String key,
                                   Path path)

Specified by:

jsonToggle in interface RedisJsonPipelineCommands

jsonType

public Response<Class<?>> jsonType(String key)

Specified by:

jsonType in interface RedisJsonPipelineCommands

jsonType

public Response<List<Class<?>>> jsonType(String key,
                                         Path2 path)

Specified by:

jsonType in interface RedisJsonPipelineCommands

jsonType

public Response<Class<?>> jsonType(String key,
                                   Path path)

Specified by:

jsonType in interface RedisJsonPipelineCommands

jsonStrAppend

public Response<Long> jsonStrAppend(String key,
                                    Object string)

Specified by:

jsonStrAppend in interface RedisJsonPipelineCommands

jsonStrAppend

public Response<List<Long>> jsonStrAppend(String key,
                                          Path2 path,
                                          Object string)

Specified by:

jsonStrAppend in interface RedisJsonPipelineCommands

jsonStrAppend

public Response<Long> jsonStrAppend(String key,
                                    Path path,
                                    Object string)

Specified by:

jsonStrAppend in interface RedisJsonPipelineCommands

jsonStrLen

public Response<Long> jsonStrLen(String key)

Specified by:

jsonStrLen in interface RedisJsonPipelineCommands

jsonStrLen

public Response<List<Long>> jsonStrLen(String key,
                                       Path2 path)

Specified by:

jsonStrLen in interface RedisJsonPipelineCommands

jsonStrLen

public Response<Long> jsonStrLen(String key,
                                 Path path)

Specified by:

jsonStrLen in interface RedisJsonPipelineCommands

jsonArrAppend

public Response<List<Long>> jsonArrAppend(String key,
                                          Path2 path,
                                          Object... objects)

Specified by:

jsonArrAppend in interface RedisJsonPipelineCommands

jsonArrAppendWithEscape

public Response<List<Long>> jsonArrAppendWithEscape(String key,
                                                    Path2 path,
                                                    Object... objects)

Specified by:

jsonArrAppendWithEscape in interface RedisJsonPipelineCommands

jsonArrAppend

public Response<Long> jsonArrAppend(String key,
                                    Path path,
                                    Object... objects)

Specified by:

jsonArrAppend in interface RedisJsonPipelineCommands

jsonArrIndex

public Response<List<Long>> jsonArrIndex(String key,
                                         Path2 path,
                                         Object scalar)

Specified by:

jsonArrIndex in interface RedisJsonPipelineCommands

jsonArrIndexWithEscape

public Response<List<Long>> jsonArrIndexWithEscape(String key,
                                                   Path2 path,
                                                   Object scalar)

Specified by:

jsonArrIndexWithEscape in interface RedisJsonPipelineCommands

jsonArrIndex

public Response<Long> jsonArrIndex(String key,
                                   Path path,
                                   Object scalar)

Specified by:

jsonArrIndex in interface RedisJsonPipelineCommands

jsonArrInsert

public Response<List<Long>> jsonArrInsert(String key,
                                          Path2 path,
                                          int index,
                                          Object... objects)

Specified by:

jsonArrInsert in interface RedisJsonPipelineCommands

jsonArrInsertWithEscape

public Response<List<Long>> jsonArrInsertWithEscape(String key,
                                                    Path2 path,
                                                    int index,
                                                    Object... objects)

Specified by:

jsonArrInsertWithEscape in interface RedisJsonPipelineCommands

jsonArrInsert

public Response<Long> jsonArrInsert(String key,
                                    Path path,
                                    int index,
                                    Object... pojos)

Specified by:

jsonArrInsert in interface RedisJsonPipelineCommands

jsonArrPop

public Response<Object> jsonArrPop(String key)

Specified by:

jsonArrPop in interface RedisJsonPipelineCommands

jsonArrLen

public Response<Long> jsonArrLen(String key,
                                 Path path)

Specified by:

jsonArrLen in interface RedisJsonPipelineCommands

jsonArrTrim

public Response<List<Long>> jsonArrTrim(String key,
                                        Path2 path,
                                        int start,
                                        int stop)

Specified by:

jsonArrTrim in interface RedisJsonPipelineCommands

jsonArrTrim

public Response<Long> jsonArrTrim(String key,
                                  Path path,
                                  int start,
                                  int stop)

Specified by:

jsonArrTrim in interface RedisJsonPipelineCommands

jsonArrPop

public <T> Response<T> jsonArrPop(String key,
                                  Class<T> clazz,
                                  Path path)

Specified by:

jsonArrPop in interface RedisJsonPipelineCommands

jsonArrPop

public Response<List<Object>> jsonArrPop(String key,
                                         Path2 path,
                                         int index)

Specified by:

jsonArrPop in interface RedisJsonPipelineCommands

jsonArrPop

public Response<Object> jsonArrPop(String key,
                                   Path path,
                                   int index)

Specified by:

jsonArrPop in interface RedisJsonPipelineCommands

jsonArrPop

public <T> Response<T> jsonArrPop(String key,
                                  Class<T> clazz,
                                  Path path,
                                  int index)

Specified by:

jsonArrPop in interface RedisJsonPipelineCommands

jsonArrLen

public Response<Long> jsonArrLen(String key)

Specified by:

jsonArrLen in interface RedisJsonPipelineCommands

jsonArrLen

public Response<List<Long>> jsonArrLen(String key,
                                       Path2 path)

Specified by:

jsonArrLen in interface RedisJsonPipelineCommands

jsonArrPop

public <T> Response<T> jsonArrPop(String key,
                                  Class<T> clazz)

Specified by:

jsonArrPop in interface RedisJsonPipelineCommands

jsonArrPop

public Response<List<Object>> jsonArrPop(String key,
                                         Path2 path)

Specified by:

jsonArrPop in interface RedisJsonPipelineCommands

jsonArrPop

public Response<Object> jsonArrPop(String key,
                                   Path path)

Specified by:

jsonArrPop in interface RedisJsonPipelineCommands

tsCreate

public Response<String> tsCreate(String key)

Specified by:

tsCreate in interface RedisTimeSeriesPipelineCommands

tsCreate

public Response<String> tsCreate(String key,
                                 TSCreateParams createParams)

Specified by:

tsCreate in interface RedisTimeSeriesPipelineCommands

tsDel

public Response<Long> tsDel(String key,
                            long fromTimestamp,
                            long toTimestamp)

Specified by:

tsDel in interface RedisTimeSeriesPipelineCommands

tsAlter

public Response<String> tsAlter(String key,
                                TSAlterParams alterParams)

Specified by:

tsAlter in interface RedisTimeSeriesPipelineCommands

tsAdd

public Response<Long> tsAdd(String key,
                            double value)

Specified by:

tsAdd in interface RedisTimeSeriesPipelineCommands

tsAdd

public Response<Long> tsAdd(String key,
                            long timestamp,
                            double value)

Specified by:

tsAdd in interface RedisTimeSeriesPipelineCommands

tsAdd

public Response<Long> tsAdd(String key,
                            long timestamp,
                            double value,
                            TSCreateParams createParams)

Specified by:

tsAdd in interface RedisTimeSeriesPipelineCommands

tsRange

public Response<List<TSElement>> tsRange(String key,
                                         long fromTimestamp,
                                         long toTimestamp)

Specified by:

tsRange in interface RedisTimeSeriesPipelineCommands

tsRange

public Response<List<TSElement>> tsRange(String key,
                                         TSRangeParams rangeParams)

Specified by:

tsRange in interface RedisTimeSeriesPipelineCommands

tsRevRange

public Response<List<TSElement>> tsRevRange(String key,
                                            long fromTimestamp,
                                            long toTimestamp)

Specified by:

tsRevRange in interface RedisTimeSeriesPipelineCommands

tsRevRange

public Response<List<TSElement>> tsRevRange(String key,
                                            TSRangeParams rangeParams)

Specified by:

tsRevRange in interface RedisTimeSeriesPipelineCommands

tsMRange

public Response<List<TSKeyedElements>> tsMRange(long fromTimestamp,
                                                long toTimestamp,
                                                String... filters)

Specified by:

tsMRange in interface RedisTimeSeriesPipelineCommands

tsMRange

public Response<List<TSKeyedElements>> tsMRange(TSMRangeParams multiRangeParams)

Specified by:

tsMRange in interface RedisTimeSeriesPipelineCommands

tsMRevRange

public Response<List<TSKeyedElements>> tsMRevRange(long fromTimestamp,
                                                   long toTimestamp,
                                                   String... filters)

Specified by:

tsMRevRange in interface RedisTimeSeriesPipelineCommands

tsMRevRange

public Response<List<TSKeyedElements>> tsMRevRange(TSMRangeParams multiRangeParams)

Specified by:

tsMRevRange in interface RedisTimeSeriesPipelineCommands

tsGet

public Response<TSElement> tsGet(String key)

Specified by:

tsGet in interface RedisTimeSeriesPipelineCommands

tsMGet

public Response<List<TSKeyValue<TSElement>>> tsMGet(TSMGetParams multiGetParams,
                                                    String... filters)

Specified by:

tsMGet in interface RedisTimeSeriesPipelineCommands

tsCreateRule

public Response<String> tsCreateRule(String sourceKey,
                                     String destKey,
                                     AggregationType aggregationType,
                                     long timeBucket)

Specified by:

tsCreateRule in interface RedisTimeSeriesPipelineCommands

tsDeleteRule

public Response<String> tsDeleteRule(String sourceKey,
                                     String destKey)

Specified by:

tsDeleteRule in interface RedisTimeSeriesPipelineCommands

tsQueryIndex

public Response<List<String>> tsQueryIndex(String... filters)

Specified by:

tsQueryIndex in interface RedisTimeSeriesPipelineCommands

bfReserve

public Response<String> bfReserve(String key,
                                  double errorRate,
                                  long capacity)

Specified by:

bfReserve in interface BloomFilterPipelineCommands

bfReserve

public Response<String> bfReserve(String key,
                                  double errorRate,
                                  long capacity,
                                  BFReserveParams reserveParams)

Specified by:

bfReserve in interface BloomFilterPipelineCommands

bfAdd

public Response<Boolean> bfAdd(String key,
                               String item)

Specified by:

bfAdd in interface BloomFilterPipelineCommands

bfMAdd

public Response<List<Boolean>> bfMAdd(String key,
                                      String... items)

Specified by:

bfMAdd in interface BloomFilterPipelineCommands

bfInsert

public Response<List<Boolean>> bfInsert(String key,
                                        String... items)

Specified by:

bfInsert in interface BloomFilterPipelineCommands

bfInsert

public Response<List<Boolean>> bfInsert(String key,
                                        BFInsertParams insertParams,
                                        String... items)

Specified by:

bfInsert in interface BloomFilterPipelineCommands

bfExists

public Response<Boolean> bfExists(String key,
                                  String item)

Specified by:

bfExists in interface BloomFilterPipelineCommands

bfMExists

public Response<List<Boolean>> bfMExists(String key,
                                         String... items)

Specified by:

bfMExists in interface BloomFilterPipelineCommands

bfInfo

public Response<Map<String,Object>> bfInfo(String key)

Specified by:

bfInfo in interface BloomFilterPipelineCommands

cfReserve

public Response<String> cfReserve(String key,
                                  long capacity)

Specified by:

cfReserve in interface CuckooFilterPipelineCommands

cfReserve

public Response<String> cfReserve(String key,
                                  long capacity,
                                  CFReserveParams reserveParams)

Specified by:

cfReserve in interface CuckooFilterPipelineCommands

cfAdd

public Response<Boolean> cfAdd(String key,
                               String item)

Specified by:

cfAdd in interface CuckooFilterPipelineCommands

cfAddNx

public Response<Boolean> cfAddNx(String key,
                                 String item)

Specified by:

cfAddNx in interface CuckooFilterPipelineCommands

cfInsert

public Response<List<Boolean>> cfInsert(String key,
                                        String... items)

Specified by:

cfInsert in interface CuckooFilterPipelineCommands

cfInsert

public Response<List<Boolean>> cfInsert(String key,
                                        CFInsertParams insertParams,
                                        String... items)

Specified by:

cfInsert in interface CuckooFilterPipelineCommands

cfInsertNx

public Response<List<Boolean>> cfInsertNx(String key,
                                          String... items)

Specified by:

cfInsertNx in interface CuckooFilterPipelineCommands

cfInsertNx

public Response<List<Boolean>> cfInsertNx(String key,
                                          CFInsertParams insertParams,
                                          String... items)

Specified by:

cfInsertNx in interface CuckooFilterPipelineCommands

cfExists

public Response<Boolean> cfExists(String key,
                                  String item)

Specified by:

cfExists in interface CuckooFilterPipelineCommands

cfDel

public Response<Boolean> cfDel(String key,
                               String item)

Specified by:

cfDel in interface CuckooFilterPipelineCommands

cfCount

public Response<Long> cfCount(String key,
                              String item)

Specified by:

cfCount in interface CuckooFilterPipelineCommands

cfInfo

public Response<Map<String,Object>> cfInfo(String key)

Specified by:

cfInfo in interface CuckooFilterPipelineCommands

cmsInitByDim

public Response<String> cmsInitByDim(String key,
                                     long width,
                                     long depth)

Specified by:

cmsInitByDim in interface CountMinSketchPipelineCommands

cmsInitByProb

public Response<String> cmsInitByProb(String key,
                                      double error,
                                      double probability)

Specified by:

cmsInitByProb in interface CountMinSketchPipelineCommands

cmsIncrBy

public Response<List<Long>> cmsIncrBy(String key,
                                      Map<String,Long> itemIncrements)

Specified by:

cmsIncrBy in interface CountMinSketchPipelineCommands

cmsQuery

public Response<List<Long>> cmsQuery(String key,
                                     String... items)

Specified by:

cmsQuery in interface CountMinSketchPipelineCommands

cmsMerge

public Response<String> cmsMerge(String destKey,
                                 String... keys)

Specified by:

cmsMerge in interface CountMinSketchPipelineCommands

cmsMerge

public Response<String> cmsMerge(String destKey,
                                 Map<String,Long> keysAndWeights)

Specified by:

cmsMerge in interface CountMinSketchPipelineCommands

cmsInfo

public Response<Map<String,Object>> cmsInfo(String key)

Specified by:

cmsInfo in interface CountMinSketchPipelineCommands

topkReserve

public Response<String> topkReserve(String key,
                                    long topk)

Specified by:

topkReserve in interface TopKFilterPipelineCommands

topkReserve

public Response<String> topkReserve(String key,
                                    long topk,
                                    long width,
                                    long depth,
                                    double decay)

Specified by:

topkReserve in interface TopKFilterPipelineCommands

topkAdd

public Response<List<String>> topkAdd(String key,
                                      String... items)

Specified by:

topkAdd in interface TopKFilterPipelineCommands

topkIncrBy

public Response<List<String>> topkIncrBy(String key,
                                         Map<String,Long> itemIncrements)

Specified by:

topkIncrBy in interface TopKFilterPipelineCommands

topkQuery

public Response<List<Boolean>> topkQuery(String key,
                                         String... items)

Specified by:

topkQuery in interface TopKFilterPipelineCommands

topkCount

public Response<List<Long>> topkCount(String key,
                                      String... items)

Specified by:

topkCount in interface TopKFilterPipelineCommands

topkList

public Response<List<String>> topkList(String key)

Specified by:

topkList in interface TopKFilterPipelineCommands

topkInfo

public Response<Map<String,Object>> topkInfo(String key)

Specified by:

topkInfo in interface TopKFilterPipelineCommands

graphQuery

public Response<ResultSet> graphQuery(String name,
                                      String query)

Specified by:

graphQuery in interface RedisGraphPipelineCommands

graphReadonlyQuery

public Response<ResultSet> graphReadonlyQuery(String name,
                                              String query)

Specified by:

graphReadonlyQuery in interface RedisGraphPipelineCommands

graphQuery

public Response<ResultSet> graphQuery(String name,
                                      String query,
                                      long timeout)

Specified by:

graphQuery in interface RedisGraphPipelineCommands

graphReadonlyQuery

public Response<ResultSet> graphReadonlyQuery(String name,
                                              String query,
                                              long timeout)

Specified by:

graphReadonlyQuery in interface RedisGraphPipelineCommands

graphQuery

public Response<ResultSet> graphQuery(String name,
                                      String query,
                                      Map<String,Object> params)

Specified by:

graphQuery in interface RedisGraphPipelineCommands

graphReadonlyQuery

public Response<ResultSet> graphReadonlyQuery(String name,
                                              String query,
                                              Map<String,Object> params)

Specified by:

graphReadonlyQuery in interface RedisGraphPipelineCommands

graphQuery

public Response<ResultSet> graphQuery(String name,
                                      String query,
                                      Map<String,Object> params,
                                      long timeout)

Specified by:

graphQuery in interface RedisGraphPipelineCommands

graphReadonlyQuery

public Response<ResultSet> graphReadonlyQuery(String name,
                                              String query,
                                              Map<String,Object> params,
                                              long timeout)

Specified by:

graphReadonlyQuery in interface RedisGraphPipelineCommands

graphDelete

public Response<String> graphDelete(String name)

Specified by:

graphDelete in interface RedisGraphPipelineCommands

waitReplicas

public Response<Long> waitReplicas(int replicas,
                                   long timeout)

sendCommand

public Response<Object> sendCommand(ProtocolCommand cmd,
                                    String... args)

sendCommand

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

sendCommand

public Response<Object> sendCommand(CommandArguments args)

executeCommand

public <T> Response<T> executeCommand(CommandObject<T> command)