Class RedisConnection

java.lang.Object

com.blackrook.redis.RedisConnectionAbstract

com.blackrook.redis.RedisConnection

All Implemented Interfaces:

RedisConnectionCommands, RedisHyperlogCommands, RedisScanCommands, AutoCloseable

public class RedisConnection
extends RedisConnectionAbstract
implements RedisConnectionCommands, RedisHyperlogCommands, RedisScanCommands

A single connection to a Redis server.

Author:

Matthew Tropiano

Field Summary

Fields inherited from class RedisConnectionAbstract

reader, writer

Fields inherited from interface RedisConnectionCommands

TTL_NO_EXPIRE, TTL_NOT_EXIST

Constructor Summary

Constructors

Constructor	Description
RedisConnection()	Creates an open connection to localhost, port 6379, the default Redis port.
RedisConnection(RedisInfo info)	Creates an open connection.
RedisConnection(String host, int port)	Creates an open connection.
RedisConnection(String host, int port, String password)	Creates an open connection.

Method Summary

Modifier and Type	Method	Description
long	append(String key, String value)	From http://redis.io/commands/append:
long	bitcount(String key)	From http://redis.io/commands/bitcount:
long	bitcount(String key, long start, long end)	From http://redis.io/commands/bitcount:
long	bitop(BitwiseOperation operation, String destkey, String key, String... keys)	From http://redis.io/commands/bitop:
long	bitpos(String key, long bit)	From http://redis.io/commands/bitpos:
long	bitpos(String key, long bit, Long start, Long end)	From http://redis.io/commands/bitpos:
KeyValue<String,String>	blpop(long timeout, String key, String... keys)	From http://redis.io/commands/blpop:
KeyValue<String,Long>	blpopLong(long timeout, String key, String... keys)	Like blpop(long, String, String...), except it casts the value to a long integer.
KeyValue<String,String>	brpop(long timeout, String key, String... keys)	From http://redis.io/commands/brpop:
KeyValue<String,Long>	brpopLong(long timeout, String key, String... keys)	Like brpop(long, String, String...), except it casts the value to a long integer.
String	brpoplpush(long timeout, String source, String destination)	From http://redis.io/commands/brpoplpush:
Long	brpoplpushLong(long timeout, String source, String destination)	Like brpoplpush(long, String, String), except it casts the value to a long integer.
String	clientGetName()	From http://redis.io/commands/client-getname:
boolean	clientSetName(String name)	From http://redis.io/commands/client-setname:
long	decr(String key)	From http://redis.io/commands/decr:
long	decrby(String key, long decrement)	From http://redis.io/commands/decrby:
long	del(String key, String... keys)	From http://redis.io/commands/del:
String	dump(String key)	From http://redis.io/commands/dump:
String	echo(String message)	From http://redis.io/commands/echo:
RedisObject	eval(String scriptContent, String[] keys, Object... args)	From http://redis.io/commands/eval:
RedisObject	evalsha(String hash, String[] keys, Object... args)	From http://redis.io/commands/evalsha:
boolean	exists(String key)	From http://redis.io/commands/exists:
boolean	expire(String key, long seconds)	From http://redis.io/commands/expire:
boolean	expireat(String key, long timestamp)	From http://redis.io/commands/expireat:
String	get(String key)	From http://redis.io/commands/get:
long	getbit(String key, long offset)	From http://redis.io/commands/getbit:
Long	getLong(String key)	Just like get(String), but it casts the result to a long integer.
String	getrange(String key, long start, long end)	From http://redis.io/commands/getrange:
String	getset(String key, Number value)	From http://redis.io/commands/getset:
String	getset(String key, String value)	From http://redis.io/commands/getset:
Long	getsetLong(String key, Number value)	Just like getset(String, String), but it casts the result to a long integer.
Long	getsetLong(String key, String value)	Just like getset(String, String), but it casts the result to a long integer.
long	hdel(String key, String field, String... fields)	From http://redis.io/commands/hdel:
boolean	hexists(String key, String field)	From http://redis.io/commands/hexists:
String	hget(String key, String field)	From http://redis.io/commands/hget:
String[]	hgetall(String key)	From http://redis.io/commands/hgetall:
HashMap<String,String>	hgetallMap(String key)	Just like hgetall(String), except the keys and values are returned in a map of key to value.
<T> T	hgetallObject(String key, Class<T> type)	Just like hgetall(String), except the keys and values are set on a new instance of a Java object via reflection.
<T> void	hgetallObject(String key, T object)	Just like hgetall(String), except the keys and values are set on an existing instance of a Java object via reflection.
Long	hgetLong(String key, String field)	Just like hget(String, String), but it casts the result to a long integer.
long	hincrby(String key, String field, long increment)	From http://redis.io/commands/hincrby:
double	hincrbyfloat(String key, String field, double increment)	From http://redis.io/commands/hincrbyfloat:
String[]	hkeys(String key)	From http://redis.io/commands/hkeys:
long	hlen(String key)	From http://redis.io/commands/hlen:
String[]	hmget(String key, String field, String... fields)	From http://redis.io/commands/hmget:
boolean	hmset(String key, KeyValue<String,Object>... pairs)	Like hmset(String, String, String, String...), except abstracted as KeyValues of key-value pairs.
boolean	hmset(String key, Object field, Object value, Object... fieldvalues)	From http://redis.io/commands/hmset:
boolean	hmset(String key, String field, String value, String... fieldvalues)	From http://redis.io/commands/hmset:
boolean	hmsetMap(String key, Map<String,Object> map)	Like hmset(String, String, String, String...), except abstracted as a map of key-value pairs.
<T> boolean	hmsetObject(String key, T object)	Like hmset(String, String, String, String...), except each field or getter sets the fields and values.
RedisCursor	hscan(String key, long cursor)	From http://redis.io/commands/sscan:
RedisCursor	hscan(String key, long cursor, long count)	From http://redis.io/commands/sscan:
RedisCursor	hscan(String key, long cursor, String pattern)	From http://redis.io/commands/sscan:
RedisCursor	hscan(String key, long cursor, String pattern, Long count)	From http://redis.io/commands/hscan:
boolean	hset(String key, String field, Number value)	From http://redis.io/commands/hset:
boolean	hset(String key, String field, String value)	From http://redis.io/commands/hset:
boolean	hsetnx(String key, String field, Number value)	From http://redis.io/commands/hsetnx:
boolean	hsetnx(String key, String field, String value)	From http://redis.io/commands/hsetnx:
String[]	hvals(String key)	From http://redis.io/commands/hvals:
long	incr(String key)	From http://redis.io/commands/incr:
long	incrby(String key, long increment)	From http://redis.io/commands/incrby:
double	incrbyfloat(String key, double increment)	From http://redis.io/commands/incrbyfloat:
String[]	keys(String pattern)	From http://redis.io/commands/keys:
String	lindex(String key, long index)	From http://redis.io/commands/lindex:
Long	lindexLong(String key, long index)	Like lindex(String, long), except it casts the value to a long integer.
long	linsert(String key, boolean before, String pivot, Number value)	From http://redis.io/commands/linsert:
long	linsert(String key, boolean before, String pivot, String value)	From http://redis.io/commands/linsert:
long	llen(String key)	From http://redis.io/commands/llen:
String	lpop(String key)	From http://redis.io/commands/lpop:
Long	lpopLong(String key)	Like lpop(String), except it casts the value to a long integer.
long	lpush(String key, String value, String... values)	From http://redis.io/commands/lpush:
long	lpushx(String key, String value)	From http://redis.io/commands/lpushx:
String[]	lrange(String key, long start, long stop)	From http://redis.io/commands/lrange:
long	lrem(String key, long count, String value)	From http://redis.io/commands/lrem:
boolean	lset(String key, long index, String value)	From http://redis.io/commands/lset:
boolean	ltrim(String key, long start, long stop)	From http://redis.io/commands/ltrim:
String[]	mget(String key, String... keys)	From http://redis.io/commands/mget:
boolean	move(String key, long db)	From http://redis.io/commands/move:
boolean	mset(KeyValue<String,Object>... pairs)	Like RedisConnectionCommands.mset(String, String, String...), but takes key-value pairs.
boolean	mset(String key, String value, String... keyValues)	From http://redis.io/commands/mset:
boolean	msetnx(KeyValue<String,Object>... pairs)	Like RedisConnectionCommands.msetnx(String, String, String...), but takes key-value pairs.
boolean	msetnx(String key, String value, String... keyValues)	From http://redis.io/commands/msetnx:
boolean	persist(String key)	From http://redis.io/commands/persist:
boolean	pexpire(String key, long milliseconds)	From http://redis.io/commands/pexpire:
boolean	pexpireat(String key, long timestamp)	From http://redis.io/commands/pexpireat:
boolean	pfadd(String key, String element, String... elements)	From http://redis.io/commands/pfadd:
long	pfcount(String key, String... keys)	From http://redis.io/commands/pfcount:
boolean	pfmerge(String destkey, String sourcekey, String... sourcekeys)	From http://redis.io/commands/pfmerge:
long	ping()	From http://redis.io/commands/ping:
boolean	psetex(String key, long milliseconds, String value)	From http://redis.io/commands/psetex:
long	pttl(String key)	From http://redis.io/commands/pttl:
long	publish(String channel, String message)	From http://redis.io/commands/publish:
boolean	quit()	From http://redis.io/commands/quit:
String	randomkey()	From http://redis.io/commands/randomkey:
boolean	rename(String key, String newkey)	From http://redis.io/commands/rename:
boolean	renamenx(String key, String newkey)	From http://redis.io/commands/renamenx:
boolean	restore(String key, long ttl, String serializedvalue)	From http://redis.io/commands/restore:
String	rpop(String key)	From http://redis.io/commands/rpop:
Long	rpopLong(String key)	Like rpop(String), except it casts the value to a long integer.
String	rpoplpush(String source, String destination)	From http://redis.io/commands/rpoplpush:
Long	rpoplpushLong(String source, String destination)	Like rpoplpush(String, String), except it casts the value to a long integer.
long	rpush(String key, String value, String... values)	From http://redis.io/commands/rpush:
long	rpushx(String key, String value)	From http://redis.io/commands/rpushx:
long	sadd(String key, Object member, Object... members)	From http://redis.io/commands/sadd:
long	sadd(String key, String member, String... members)	From http://redis.io/commands/sadd:
RedisCursor	scan(long cursor)	From http://redis.io/commands/scan:
RedisCursor	scan(long cursor, long count)	From http://redis.io/commands/scan:
RedisCursor	scan(long cursor, String pattern)	From http://redis.io/commands/scan:
RedisCursor	scan(long cursor, String pattern, Long count)	From http://redis.io/commands/scan:
long	scard(String key)	From http://redis.io/commands/scard:
boolean[]	scriptExists(String scriptHash, String... scriptHashes)	From http://redis.io/commands/script-exists:
boolean	scriptFlush()	From http://redis.io/commands/script-flush:
boolean	scriptKill(String hash)	From http://redis.io/commands/script-kill:
String	scriptLoad(File content)	From http://redis.io/commands/script-load:
String	scriptLoad(InputStream content)	From http://redis.io/commands/script-load:
String	scriptLoad(String content)	From http://redis.io/commands/script-load:
String[]	sdiff(String key, String... keys)	From http://redis.io/commands/sdiff:
long	sdiffstore(String destination, String key, String... keys)	From http://redis.io/commands/sdiffstore:
boolean	set(String key, Number value)	From http://redis.io/commands/set:
boolean	set(String key, String value)	From http://redis.io/commands/set:
long	setbit(String key, long offset, long value)	From http://redis.io/commands/setbit:
boolean	setex(String key, long seconds, String value)	From http://redis.io/commands/setex:
boolean	setnx(String key, String value)	From http://redis.io/commands/setnx:
long	setrange(String key, long offset, String value)	From http://redis.io/commands/setrange:
String[]	sinter(String key, String... keys)	From http://redis.io/commands/sinter:
long	sinterstore(String destination, String key, String... keys)	From http://redis.io/commands/sinterstore:
boolean	sismember(String key, Number member)	From http://redis.io/commands/sismember:
boolean	sismember(String key, String member)	From http://redis.io/commands/sismember:
String[]	smembers(String key)	From http://redis.io/commands/smembers:
boolean	smove(String source, String destination, String member)	From http://redis.io/commands/smove:
String[]	sort(String key, String pattern, SortOrder sortOrder, boolean alpha, Long limitOffset, Long limitCount, String storeKey, String... getPatterns)	From http://redis.io/commands/sort:
protected String	specialDouble(double d)	Converts some of Java's primitive doubles to Redis interval values.
String	spop(String key)	From http://redis.io/commands/spop:
Long	spopLong(String key)	Like spop(String), except it casts the value to a long integer.
String	srandmember(String key)	From http://redis.io/commands/srandmember:
String[]	srandmember(String key, long count)	From http://redis.io/commands/srandmember:
long	srem(String key, Object member, Object... members)	From http://redis.io/commands/srem:
long	srem(String key, String member, String... members)	From http://redis.io/commands/srem:
RedisCursor	sscan(String key, long cursor)	From http://redis.io/commands/hscan:
RedisCursor	sscan(String key, long cursor, long count)	From http://redis.io/commands/hscan:
RedisCursor	sscan(String key, long cursor, String pattern)	From http://redis.io/commands/hscan:
RedisCursor	sscan(String key, String cursor, String pattern, Long count)	From http://redis.io/commands/sscan:
RedisPipeline	startPipeline()	Creates a pipelined set of commands.
long	strlen(String key)	From http://redis.io/commands/strlen:
String[]	sunion(String key, String... keys)	From http://redis.io/commands/sunion:
long	sunionstore(String destination, String key, String... keys)	From http://redis.io/commands/sunionstore:
long	ttl(String key)	From http://redis.io/commands/ttl:
DataType	type(String key)	From http://redis.io/commands/type:
long	zadd(String key, double score, Number member)	From http://redis.io/commands/zadd:
long	zadd(String key, double score, String member)	From http://redis.io/commands/zadd:
long	zadd(String key, KeyValue<Double,String>... pairs)	From http://redis.io/commands/zadd:
long	zcard(String key)	From http://redis.io/commands/zcard:
long	zcount(String key, double min, double max)	Like zcount(String, String, String), except it accepts doubles for min and max, not strings.
long	zcount(String key, String min, String max)	From http://redis.io/commands/zcount:
double	zincrby(String key, double increment, String member)	From http://redis.io/commands/zincrby:
long	zinterstore(String destination, double[] weights, Aggregation aggregation, String key, String... keys)	From http://redis.io/commands/zinterstore:
long	zinterstore(String destination, double[] weights, String key, String... keys)	Like RedisConnectionCommands.zinterstore(String, double[], Aggregation, String, String...), except it does no aggregation of scores.
long	zinterstore(String destination, Aggregation aggregation, String key, String... keys)	Like RedisConnectionCommands.zinterstore(String, double[], Aggregation, String, String...), except no weights are applied to the source value scores.
long	zinterstore(String destination, String key, String... keys)	Like RedisConnectionCommands.zinterstore(String, double[], Aggregation, String, String...), except no weights are applied to the source value scores, and does no aggregation of scores.
long	zlexcount(String key, double min, double max)	Like RedisConnectionCommands.zlexcount(String, String, String), except it accepts doubles for min and max, not strings.
long	zlexcount(String key, String min, String max)	From http://redis.io/commands/zlexcount:
String[]	zrange(String key, long start, long stop, boolean withScores)	From http://redis.io/commands/zrange:
long	zrangebylex(String key, double min, double max)	Like zrangebylex(String, String, String), except it accepts doubles for min and max, not strings, with no limit.
long	zrangebylex(String key, double min, double max, Long limitOffset, Long limitCount)	Like zrangebylex(String, String, String, Long, Long), except it accepts doubles for min and max, not strings.
long	zrangebylex(String key, String min, String max)	Like zrangebylex(String, String, String, Long, Long), with no limit.
long	zrangebylex(String key, String min, String max, Long limitOffset, Long limitCount)	From http://redis.io/commands/zrangebylex:
String[]	zrangebyscore(String key, double min, double max, boolean withScores)	Like RedisConnectionCommands.zrangebyscore(String, String, String, boolean), except it accepts doubles for min and max, not strings.
String[]	zrangebyscore(String key, double min, double max, boolean withScores, Long limitOffset, Long limitCount)	Like RedisConnectionCommands.zrangebyscore(String, String, String, boolean, Long, Long), except it accepts doubles for min and max, not strings.
String[]	zrangebyscore(String key, String min, String max, boolean withScores)	Like RedisConnectionCommands.zrangebyscore(String, String, String, boolean, Long, Long), except specifies no limit.
String[]	zrangebyscore(String key, String min, String max, boolean withScores, Long limitOffset, Long limitCount)	From http://redis.io/commands/zrangebyscore:
Long	zrank(String key, Number member)	From http://redis.io/commands/zrank:
Long	zrank(String key, String member)	From http://redis.io/commands/zrank:
long	zrem(String key, Number member, Number... members)	From http://redis.io/commands/zrem:
long	zrem(String key, String member, String... members)	From http://redis.io/commands/zrem:
long	zremrangebylex(String key, double min, double max)	Like RedisConnectionCommands.zrangebylex(String, String, String), except it accepts doubles for min and max.
long	zremrangebylex(String key, String min, String max)	From http://redis.io/commands/zremrangebylex:
long	zremrangebyrank(String key, long start, long stop)	From http://redis.io/commands/zremrangebyrank:
long	zremrangebyscore(String key, double min, double max)	Like zremrangebyscore(String, String, String), except it accepts doubles for min and max, not strings.
long	zremrangebyscore(String key, String min, String max)	From http://redis.io/commands/zremrangebyscore:
String[]	zrevrange(String key, long start, long stop, boolean withScores)	From http://redis.io/commands/zrevrange:
String[]	zrevrangebyscore(String key, double min, double max, boolean withScores)	Like RedisConnectionCommands.zrevrangebyscore(String, String, String, boolean), except it accepts doubles for min and max, not strings.
String[]	zrevrangebyscore(String key, double min, double max, boolean withScores, Long limitOffset, Long limitCount)	Like RedisConnectionCommands.zrevrangebyscore(String, String, String, boolean, Long, Long), except it accepts doubles for min and max, not strings.
String[]	zrevrangebyscore(String key, String min, String max, boolean withScores)	Like RedisConnectionCommands.zrevrangebyscore(String, String, String, boolean, Long, Long), except specifies no limit.
String[]	zrevrangebyscore(String key, String min, String max, boolean withScores, Long limitOffset, Long limitCount)	From http://redis.io/commands/zrevrangebyscore:
Long	zrevrank(String key, String member)	From http://redis.io/commands/zrevrank:
RedisCursor	zscan(String key, long cursor)	From http://redis.io/commands/zscan:
RedisCursor	zscan(String key, long cursor, long count)	From http://redis.io/commands/zscan:
RedisCursor	zscan(String key, long cursor, String pattern)	From http://redis.io/commands/zscan:
RedisCursor	zscan(String key, long cursor, String pattern, Long count)	From http://redis.io/commands/zscan:
Double	zscore(String key, String member)	From http://redis.io/commands/zscore:
long	zunionstore(String destination, double[] weights, Aggregation aggregation, String key, String... keys)	From http://redis.io/commands/zunionstore:
long	zunionstore(String destination, double[] weights, String key, String... keys)	Like RedisConnectionCommands.zunionstore(String, double[], Aggregation, String, String...), except it does no aggregation of scores.
long	zunionstore(String destination, Aggregation aggregation, String key, String... keys)	Like RedisConnectionCommands.zunionstore(String, double[], Aggregation, String, String...), except no weights are applied to the source value scores.
long	zunionstore(String destination, String key, String... keys)	Like RedisConnectionCommands.zunionstore(String, double[], Aggregation, String, String...), except no weights are applied to the source value scores, and does no aggregation of scores.

Methods inherited from class RedisConnectionAbstract

close, disconnect, isBound, isClosed, isConnected, reconnect

Methods inherited from class Object

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

Constructor Details

RedisConnection

public RedisConnection()
                throws IOException

Creates an open connection to localhost, port 6379, the default Redis port.

Throws:

IOException - if an I/O error occurs when creating the socket.

UnknownHostException - if the IP address of the host could not be determined.

SecurityException - if a security manager exists and doesn't allow the connection to be made.

RedisConnection

public RedisConnection(String host,
 int port)
                throws IOException

Creates an open connection.

Parameters:

host - the server hostname or address.

port - the server connection port.

Throws:

IOException - if an I/O error occurs when creating the socket.

UnknownHostException - if the IP address of the host could not be determined.

SecurityException - if a security manager exists and doesn't allow the connection to be made.

RedisConnection

public RedisConnection(String host,
 int port,
 String password)
                throws IOException

Creates an open connection.

Parameters:

host - the server hostname or address.

port - the server connection port.

password - the server database password.

Throws:

IOException - if an I/O error occurs when creating the socket.

UnknownHostException - if the IP address of the host could not be determined.

SecurityException - if a security manager exists and doesn't allow the connection to be made.

RedisException - if the password in the server information is incorrect.

RedisConnection

public RedisConnection(RedisInfo info)
                throws IOException

Creates an open connection.

Parameters:

info - the RedisInfo class detailing a connection.

Throws:

IOException - if an I/O error occurs when creating the socket.

UnknownHostException - if the IP address of the host could not be determined.

SecurityException - if a security manager exists and doesn't allow the connection to be made.

RedisException - if the password in the server information is incorrect.

Method Details

startPipeline

public RedisPipeline startPipeline()

Creates a pipelined set of commands.

Returns:

a new pipeline.

echo

public String echo(String message)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/echo:

Available since 1.0.0.

Returns message.

Specified by:

echo in interface RedisConnectionCommands

Returns:

the string sent to the server.

ping

public long ping()

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/ping:

Available since 1.0.0.

This command is often used to test if a connection is still alive, or to measure latency.

Specified by:

ping in interface RedisConnectionCommands

Returns:

milliseconds between the call and the response. Ordinarily, Redis just returns "PONG", which is not very useful API-wise.

quit

public boolean quit()

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/quit:

Available since 1.0.0.

Ask the server to close the connection. The connection is closed as soon as all pending replies have been written to the client.

Specified by:

quit in interface RedisConnectionCommands

Returns:

always true.

clientGetName

public String clientGetName()

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/client-getname:

Available since 2.6.9.

Time complexity: O(1)

The CLIENT GETNAME returns the name of the current connection as set by CLIENT SETNAME. Since every new connection starts without an associated name, if no name was assigned a null bulk reply is returned.

Specified by:

clientGetName in interface RedisConnectionCommands

Returns:

the connection name, or null if no name is set.

clientSetName

public boolean clientSetName(String name)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/client-setname:

Available since 2.6.9.

Time complexity: O(1)

The CLIENT SETNAME command assigns a name to the current connection.

Specified by:

clientSetName in interface RedisConnectionCommands

Returns:

true if successful, false otherwise.

del

public long del(String key,
 String... keys)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/del:

Available since 1.0.0.

Time complexity: O(N) where N is the number of keys that will be removed. When a key to remove holds a value other than a string, the individual complexity for this key is O(M) where M is the number of elements in the list, set, sorted set or hash. Removing a single key that holds a string value is O(1).

Removes the specified keys. A key is ignored if it does not exist.

Specified by:

del in interface RedisConnectionCommands

Parameters:

key - the first key to delete.

keys - the additional keys to delete.

Returns:

The number of keys that were removed.

dump

public String dump(String key)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/dump:

Available since 2.6.0.

Time complexity: O(1) to access the key and additional O(N*M) to serialized it, where N is the number of Redis objects composing the value and M their average size. For small string values the time complexity is thus O(1)+O(1*M) where M is small, so simply O(1).

Serialize the value stored at key in a Redis-specific format and return it to the user. The returned value can be synthesized back into a Redis key using the RedisConnectionCommands.restore(String, long, String) command.

Specified by:

dump in interface RedisConnectionCommands

Returns:

the serialized value.

exists

public boolean exists(String key)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/exists:

Available since 1.0.0.

Time complexity: O(1)

Returns if key exists.

Specified by:

exists in interface RedisConnectionCommands

Returns:

true if the key exists, false if not.

expire

public boolean expire(String key,
 long seconds)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/expire:

Available since 1.0.0.

Time complexity: O(1)

Set a timeout on key. After the timeout has expired, the key will automatically be deleted. A key with an associated timeout is often said to be volatile in Redis terminology.

Specified by:

expire in interface RedisConnectionCommands

Parameters:

key - the key to expire.

seconds - the time-to-live in seconds.

Returns:

true if set, false if not set.

expireat

public boolean expireat(String key,
 long timestamp)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/expireat:

Available since 1.2.0.

Time complexity: O(1)

expireat has the same effect and semantic as RedisConnectionCommands.expire(String, long), but instead of specifying the number of seconds representing the TTL (time to live), it takes an absolute Unix timestamp (seconds since January 1, 1970).

Specified by:

expireat in interface RedisConnectionCommands

Parameters:

key - the key to expire.

timestamp - the timestamp in from-Epoch milliseconds.

Returns:

true if set, false if not set.

keys

public String[] keys(String pattern)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/keys:

Available since 1.0.0.

Time complexity: O(N) with N being the number of keys in the database, under the assumption that the key names in the database and the given pattern have limited length.

Returns all keys matching pattern.

Specified by:

keys in interface RedisConnectionCommands

Parameters:

pattern - a wildcard pattern for matching key names.

Returns:

a list of keys matching pattern.

move

public boolean move(String key,
 long db)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/move:

Available since 1.0.0.

Time complexity: O(1)

Move key from the currently selected database to the specified destination database. When key already exists in the destination database, or it does not exist in the source database, it does nothing. It is possible to use MOVE as a locking primitive because of this.

Specified by:

move in interface RedisConnectionCommands

Parameters:

key - the key to move.

db - the target database.

Returns:

true if the key was moved, false if not.

persist

public boolean persist(String key)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/persist:

Available since 2.2.0.

Time complexity: O(1)

Remove the existing timeout on key, turning the key from volatile (a key with an expire set) to persistent (a key that will never expire as no timeout is associated).

Specified by:

persist in interface RedisConnectionCommands

Parameters:

key - the key to persist (remove TTL).

Returns:

true if successful, false if not.

pexpire

public boolean pexpire(String key,
 long milliseconds)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/pexpire:

Available since 2.6.0.

Time complexity: O(1)

This command works exactly like RedisConnectionCommands.expire(String, long) but the time to live of the key is specified in milliseconds instead of seconds.

Specified by:

pexpire in interface RedisConnectionCommands

Parameters:

key - the key to expire.

milliseconds - the time-to-live in milliseconds.

Returns:

true if successful, false if not.

pexpireat

public boolean pexpireat(String key,
 long timestamp)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/pexpireat:

Available since 2.6.0.

Time complexity: O(1)

PEXPIREAT has the same effect and semantic as RedisConnectionCommands.expireat(String, long), but the Unix time at which the key will expire is specified in milliseconds instead of seconds.

Specified by:

pexpireat in interface RedisConnectionCommands

Parameters:

key - the key to expire.

timestamp - the timestamp in from-Epoch milliseconds.

Returns:

true if successful, false if not.

pttl

public long pttl(String key)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/pttl:

Available since 2.6.0.

Time complexity: O(1)

Like RedisConnectionCommands.ttl(String), this command returns the remaining time to live of a key that has an expire set, with the sole difference that TTL returns the amount of remaining time in seconds while PTTL returns it in milliseconds.

Specified by:

pttl in interface RedisConnectionCommands

Parameters:

key - the key to inspect.

Returns:

TTL in milliseconds, or a negative value in order to signal an error (see the description above).

publish

public long publish(String channel,
 String message)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/publish:

Available since 2.0.0.

Time complexity: O(N+M) where N is the number of clients subscribed to the receiving channel and M is the total number of subscribed patterns (by any client).

Posts a message to the given channel.

Specified by:

publish in interface RedisConnectionCommands

Returns:

the number of clients that received the message.

randomkey

public String randomkey()

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/randomkey:

Available since 1.0.0.

Time complexity: O(1)

Return a random key from the currently selected database.

Specified by:

randomkey in interface RedisConnectionCommands

Returns:

the random key, or null when the database is empty.

rename

public boolean rename(String key,
 String newkey)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/rename:

Available since 1.0.0.

Time complexity: O(1)

Renames key to newkey. It returns an error when the source and destination names are the same, or when key does not exist. If newkey already exists it is overwritten, when this happens RedisConnectionCommands.rename(String, String) executes an implicit RedisConnectionCommands.del(String, String...) operation, so if the deleted key contains a very big value it may cause high latency even if RedisConnectionCommands.rename(String, String) itself is usually a constant-time operation.

Specified by:

rename in interface RedisConnectionCommands

Parameters:

key - the old name.

newkey - the new name.

Returns:

always true.

renamenx

public boolean renamenx(String key,
 String newkey)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/renamenx:

Available since 1.0.0.

Time complexity: O(1)

Renames key to newkey if newkey does not yet exist. It returns an error under the same conditions as RedisConnectionCommands.rename(String, String).

Specified by:

renamenx in interface RedisConnectionCommands

Parameters:

key - the old name.

newkey - the new name.

Returns:

true if successful, false if not.

restore

public boolean restore(String key,
 long ttl,
 String serializedvalue)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/restore:

Available since 2.6.0.

Time complexity: O(1) to create the new key and additional O(N*M) to reconstruct the serialized value, where N is the number of Redis objects composing the value and M their average size. For small string values the time complexity is thus O(1)+O(1*M) where M is small, so simply O(1). However for sorted set values the complexity is O(N*M*log(N)) because inserting values into sorted sets is O(log(N)).

Create a key associated with a value that is obtained by deserializing the provided serialized value (obtained via RedisConnectionCommands.dump(String)).

Specified by:

restore in interface RedisConnectionCommands

Parameters:

key - the key to restore.

ttl - the time-to-live in milliseconds.

serializedvalue - the serialized value (from a RedisConnectionCommands.dump(String) call).

Returns:

always true.

scan

public RedisCursor scan(long cursor)

Description copied from interface: RedisScanCommands

From http://redis.io/commands/scan:

Available since 2.8.0.

Time complexity: O(1) for every call. O(N) for a complete iteration, including enough command calls for the cursor to return back to 0. N is the number of elements inside the collection..

Incrementally iterates over a collection of elements.

Specified by:

scan in interface RedisScanCommands

Parameters:

cursor - the cursor value.

Returns:

a RedisCursor that represents the result of a SCAN call.

scan

public RedisCursor scan(long cursor,
 String pattern)

Description copied from interface: RedisScanCommands

From http://redis.io/commands/scan:

Available since 2.8.0.

Time complexity: O(1) for every call. O(N) for a complete iteration, including enough command calls for the cursor to return back to 0. N is the number of elements inside the collection..

Incrementally iterates over a collection of elements.

Specified by:

scan in interface RedisScanCommands

Parameters:

cursor - the cursor value.

pattern - if not null, return keys that fit a pattern.

Returns:

a RedisCursor that represents the result of a SCAN call.

scan

public RedisCursor scan(long cursor,
 long count)

Description copied from interface: RedisScanCommands

From http://redis.io/commands/scan:

Available since 2.8.0.

Time complexity: O(1) for every call. O(N) for a complete iteration, including enough command calls for the cursor to return back to 0. N is the number of elements inside the collection..

Incrementally iterates over a collection of elements.

Specified by:

scan in interface RedisScanCommands

Parameters:

cursor - the cursor value.

count - if not null, cap the iterable keys at a limit.

Returns:

a RedisCursor that represents the result of a SCAN call.

scan

public RedisCursor scan(long cursor,
 String pattern,
 Long count)

Description copied from interface: RedisScanCommands

From http://redis.io/commands/scan:

Available since 2.8.0.

Time complexity: O(1) for every call. O(N) for a complete iteration, including enough command calls for the cursor to return back to 0. N is the number of elements inside the collection..

Incrementally iterates over a collection of elements.

Specified by:

scan in interface RedisScanCommands

Parameters:

cursor - the cursor value.

pattern - if not null, return keys that fit a pattern.

count - if not null, cap the iterable keys at a limit.

Returns:

a RedisCursor that represents the result of a SCAN call.

sort

public String[] sort(String key,
 String pattern,
 SortOrder sortOrder,
 boolean alpha,
 Long limitOffset,
 Long limitCount,
 String storeKey,
 String... getPatterns)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/sort:

Available since 1.0.0.

Time complexity: O(N+M*log(M)) where N is the number of elements in the list or set to sort, and M the number of returned elements. When the elements are not sorted, complexity is currently O(N) as there is a copy step that will be avoided in next releases.

Returns or stores the elements contained in the list, set, or sorted set at key. By default, sorting is numeric and elements are compared by their value interpreted as double precision floating point number.

Specified by:

sort in interface RedisConnectionCommands

Parameters:

key - the key to sort the contents of.

pattern - if not null,

sortOrder - if true, sort descending. if false or null, sort ascending.

alpha - if true, sort lexicographically, not by a score.

limitOffset - if not null, the starting offset into the list (0-based).

limitCount - if not null, the amount of objects from the offset to sort. else, return all the way to the end.

storeKey - if not null, this is the key to store the result in.

getPatterns - the patterns for finding the sort score.

Returns:

the list of sorted elements.

ttl

public long ttl(String key)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/ttl:

Available since 1.0.0.

Time complexity: O(1)

Returns the remaining time to live of a key that has a timeout. This introspection capability allows a Redis client to check how many seconds a given key will continue to be part of the dataset.

Specified by:

ttl in interface RedisConnectionCommands

Parameters:

key - the key to inspect.

Returns:

TTL in seconds, or a negative value in order to signal an error (see description).

type

public DataType type(String key)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/type:

Available since 1.0.0.

Time complexity: O(1)

Returns the string representation of the type of the value stored at key.

Specified by:

type in interface RedisConnectionCommands

Returns:

the type of key, or DataType.NONE when key does not exist.

append

public long append(String key,
 String value)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/append:

Available since 2.0.0.

Time complexity: O(1). The amortized time complexity is O(1) assuming the appended value is small and the already present value is of any size, since the dynamic string library used by Redis will double the free space available on every reallocation.

If key already exists and is a string, this command appends the value at the end of the string. If key does not exist it is created and set as an empty string, so APPEND will be similar to SET in this special case.

Specified by:

append in interface RedisConnectionCommands

Returns:

the length of the string after the append operation.

bitcount

public long bitcount(String key)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/bitcount:

Available since 2.6.0.

Time complexity: O(N)

Count the number of set bits (population counting) in a string.

Specified by:

bitcount in interface RedisConnectionCommands

Returns:

the count.

bitcount

public long bitcount(String key,
 long start,
 long end)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/bitcount:

Available since 2.6.0.

Time complexity: O(N)

Count the number of set bits (population counting) in a string between a start and end bit.

Specified by:

bitcount in interface RedisConnectionCommands

Returns:

the count.

bitop

public long bitop(BitwiseOperation operation,
 String destkey,
 String key,
 String... keys)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/bitop:

Available since 2.6.0.

Time complexity: O(N)

Perform a bitwise operation between multiple keys (containing string values) and store the result in the destination key.

Specified by:

bitop in interface RedisConnectionCommands

Returns:

the size of the string stored in the destination key, equal to the size of the longest input string.

bitpos

public long bitpos(String key,
 long bit)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/bitpos:

Available since 2.8.7.

Time complexity: O(N)

Return the position of the first bit set to 1 or 0 in a string.

Specified by:

bitpos in interface RedisConnectionCommands

Returns:

the command returns the position of the first bit set to 1 or 0 according to the request.

bitpos

public long bitpos(String key,
 long bit,
 Long start,
 Long end)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/bitpos:

Available since 2.8.7.

Time complexity: O(N)

Return the position of the first bit set to 1 or 0 in a string.

Specified by:

bitpos in interface RedisConnectionCommands

Returns:

the command returns the position of the first bit set to 1 or 0 according to the request.

decr

public long decr(String key)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/decr:

Available since 1.0.0.

Time complexity: O(1)

Decrements the number stored at key by one. If the key does not exist, it is set to 0 before performing the operation. An error is returned if the key contains a value of the wrong type or contains a string that can not be represented as integer. This operation is limited to 64 bit signed integers.

Specified by:

decr in interface RedisConnectionCommands

Returns:

the value of key after the decrement.

decrby

public long decrby(String key,
 long decrement)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/decrby:

Available since 1.0.0.

Time complexity: O(1)

Decrements the number stored at key by decrement. If the key does not exist, it is set to 0 before performing the operation. An error is returned if the key contains a value of the wrong type or contains a string that can not be represented as integer. This operation is limited to 64 bit signed integers.

Specified by:

decrby in interface RedisConnectionCommands

Returns:

the value of key after the decrement.

get

public String get(String key)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/get:

Available since 1.0.0.

Time complexity: O(1)

Get the value of key. If the key does not exist the special value null is returned. An error is returned if the value stored at key is not a string, because GET only handles string values.

Specified by:

get in interface RedisConnectionCommands

Returns:

the value of key, or null when key does not exist.

getLong

public Long getLong(String key)

Just like get(String), but it casts the result to a long integer.

Parameters:

key - the data key.

Returns:

the value of key, or null when key does not exist.

getbit

public long getbit(String key,
 long offset)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/getbit:

Available since 2.2.0.

Time complexity: O(1)

Returns the bit value at offset in the string value stored at key.

Specified by:

getbit in interface RedisConnectionCommands

Returns:

the bit value stored at offset.

getrange

public String getrange(String key,
 long start,
 long end)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/getrange:

Available since 2.4.0.

Time complexity: O(N) where N is the length of the returned string. The complexity is ultimately determined by the returned length, but because creating a substring from an existing string is very cheap, it can be considered O(1) for small strings. it is called SUBSTR in Redis versions <= 2.0.

Specified by:

getrange in interface RedisConnectionCommands

Returns:

the resultant substring.

getset

public String getset(String key,
 String value)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/getset:

Available since 1.0.0.

Time complexity: O(1)

Atomically sets key to value and returns the old value stored at key. Returns an error when key exists but does not hold a string value.

Specified by:

getset in interface RedisConnectionCommands

Returns:

the old value stored at key, or null when key did not exist.

getset

public String getset(String key,
 Number value)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/getset:

Available since 1.0.0.

Time complexity: O(1)

Atomically sets key to value and returns the old value stored at key. Returns an error when key exists but does not hold a string value.

Specified by:

getset in interface RedisConnectionCommands

Returns:

the old value stored at key, or null when key did not exist.

getsetLong

public Long getsetLong(String key,
 String value)

Just like getset(String, String), but it casts the result to a long integer.

Parameters:

key - th@param key the data key.

value -

Returns:

the previous value.

getsetLong

public Long getsetLong(String key,
 Number value)

Just like getset(String, String), but it casts the result to a long integer.

Parameters:

key - the data key.

value -

Returns:

the previous value.

incr

public long incr(String key)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/incr:

Available since 1.0.0.

Time complexity: O(1)

Increments the number stored at key by one. If the key does not exist, it is set to 0 before performing the operation. An error is returned if the key contains a value of the wrong type or contains a string that can not be represented as integer. This operation is limited to 64 bit signed integers.

Specified by:

incr in interface RedisConnectionCommands

Returns:

the value of key after the increment,

incrby

public long incrby(String key,
 long increment)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/incrby:

Available since 1.0.0.

Time complexity: O(1)

Increments the number stored at key by increment. If the key does not exist, it is set to 0 before performing the operation. An error is returned if the key contains a value of the wrong type or contains a string that can not be represented as integer. This operation is limited to 64 bit signed integers.

Specified by:

incrby in interface RedisConnectionCommands

Returns:

the value of key after the increment.

incrbyfloat

public double incrbyfloat(String key,
 double increment)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/incrbyfloat:

Available since 2.6.0.

Time complexity: O(1)

Increment the string representing a floating point number stored at key by the specified increment. If the key does not exist, it is set to 0 before performing the operation. An error is returned if one of the following conditions occur:

Specified by:

incrbyfloat in interface RedisConnectionCommands

Returns:

the value of key after the increment.

mget

public String[] mget(String key,
 String... keys)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/mget:

Available since 1.0.0.

Time complexity: O(N) where N is the number of keys to retrieve.

Returns the values of all specified keys. For every key that does not hold a string value or does not exist, the special value nil is returned. Because of this, the operation never fails.

Specified by:

mget in interface RedisConnectionCommands

Returns:

list of values at the specified keys.

mset

public boolean mset(String key,
 String value,
 String... keyValues)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/mset:

Available since 1.0.1.

Time complexity: O(N) where N is the number of keys to set.

Sets the given keys to their respective values. MSET replaces existing values with new values, just as regular SET. See RedisConnectionCommands.msetnx(String, String, String...) if you don't want to overwrite existing values.

Specified by:

mset in interface RedisConnectionCommands

Returns:

true, always.

mset

public boolean mset(KeyValue<String,Object>... pairs)

Description copied from interface: RedisConnectionCommands

Like RedisConnectionCommands.mset(String, String, String...), but takes key-value pairs.

Specified by:

mset in interface RedisConnectionCommands

msetnx

public boolean msetnx(String key,
 String value,
 String... keyValues)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/msetnx:

Available since 1.0.1.

Time complexity: O(N) where N is the number of keys to set.

Sets the given keys to their respective values. MSETNX will not perform any operation at all even if just a single key already exists.

Specified by:

msetnx in interface RedisConnectionCommands

Returns:

true if all of the keys were set, false if no key was set.

msetnx

public boolean msetnx(KeyValue<String,Object>... pairs)

Description copied from interface: RedisConnectionCommands

Like RedisConnectionCommands.msetnx(String, String, String...), but takes key-value pairs.

Specified by:

msetnx in interface RedisConnectionCommands

psetex

public boolean psetex(String key,
 long milliseconds,
 String value)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/psetex:

Available since 2.6.0.

Time complexity: O(1)

PSETEX works exactly like RedisConnectionCommands.setex(String, long, String) with the sole difference that the expire time is specified in milliseconds instead of seconds.

Specified by:

psetex in interface RedisConnectionCommands

Returns:

true, always.

set

public boolean set(String key,
 String value)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/set:

Available since 1.0.0.

Time complexity: O(1)

Set key to hold the string value. If key already holds a value, it is overwritten, regardless of its type. Any previous time to live associated with the key is discarded on successful SET operation.

Specified by:

set in interface RedisConnectionCommands

Returns:

true, always.

set

public boolean set(String key,
 Number value)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/set:

Available since 1.0.0.

Time complexity: O(1)

Set key to hold the string value. If key already holds a value, it is overwritten, regardless of its type. Any previous time to live associated with the key is discarded on successful SET operation.

Specified by:

set in interface RedisConnectionCommands

Returns:

true, always.

setbit

public long setbit(String key,
 long offset,
 long value)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/setbit:

Available since 2.2.0.

Time complexity: O(1)

Sets or clears the bit at offset in the string value stored at key.

Specified by:

setbit in interface RedisConnectionCommands

Returns:

the original bit value stored at offset.

setex

public boolean setex(String key,
 long seconds,
 String value)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/setex:

Available since 2.0.0.

Time complexity: O(1)

Set key to hold the string value and set key to timeout after a given number of seconds. This command is equivalent to executing the following commands:

Specified by:

setex in interface RedisConnectionCommands

Returns:

true, always.

setnx

public boolean setnx(String key,
 String value)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/setnx:

Available since 1.0.0.

Time complexity: O(1)

Set key to hold string value if key does not exist. In that case, it is equal to RedisConnectionCommands.set(String, String). When key already holds a value, no operation is performed. SETNX is short for "SET if N ot e X ists".

Specified by:

setnx in interface RedisConnectionCommands

Returns:

true if the key was set, false if not.

setrange

public long setrange(String key,
 long offset,
 String value)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/setrange:

Available since 2.2.0.

Time complexity: O(1), not counting the time taken to copy the new string in place. Usually, this string is very small so the amortized complexity is O(1). Otherwise, complexity is O(M) with M being the length of the value argument.

Overwrites part of the string stored at key, starting at the specified offset, for the entire length of value. If the offset is larger than the current length of the string at key, the string is padded with zero-bytes to make offset fit. Non-existing keys are considered as empty strings, so this command will make sure it holds a string large enough to be able to set value at offset.

Specified by:

setrange in interface RedisConnectionCommands

Returns:

the length of the string after it was modified by the command.

strlen

public long strlen(String key)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/strlen:

Available since 2.2.0.

Time complexity: O(1)

Returns the length of the string value stored at key. An error is returned when key holds a non-string value.

Specified by:

strlen in interface RedisConnectionCommands

Returns:

the length of the string at key, or 0 when key does not exist.

hdel

public long hdel(String key,
 String field,
 String... fields)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/hdel:

Available since 2.0.0.

Time complexity: O(N) where N is the number of fields to be removed.

Removes the specified fields from the hash stored at key. Specified fields that do not exist within this hash are ignored. If key does not exist, it is treated as an empty hash and this command returns 0.

Specified by:

hdel in interface RedisConnectionCommands

Returns:

the number of fields that were removed from the hash, not including specified but non existing fields.

hexists

public boolean hexists(String key,
 String field)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/hexists:

Available since 2.0.0.

Time complexity: O(1)

Returns if field is an existing field in the hash stored at key.

Specified by:

hexists in interface RedisConnectionCommands

Returns:

true if successful, false if not.

hget

public String hget(String key,
 String field)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/hget:

Available since 2.0.0.

Time complexity: O(1)

Returns the value associated with field in the hash stored at key.

Specified by:

hget in interface RedisConnectionCommands

Returns:

the value associated with field, or null when field is not present in the hash or key does not exist.

hgetLong

public Long hgetLong(String key,
 String field)

Just like hget(String, String), but it casts the result to a long integer.

Parameters:

key - the data key.

field -

Returns:

the previous value.

hgetall

public String[] hgetall(String key)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/hgetall:

Available since 2.0.0.

Time complexity: O(N) where N is the size of the hash.

Returns all fields and values of the hash stored at key. In the returned value, every field name is followed by its value, so the length of the reply is twice the size of the hash.

Specified by:

hgetall in interface RedisConnectionCommands

Returns:

a list of fields and their values stored in the hash, or an empty list when key does not exist.

hgetallMap

public HashMap<String,String> hgetallMap(String key)

Just like hgetall(String), except the keys and values are returned in a map of key to value.

Parameters:

key - the data key.

Returns:

the returned map.

hgetallObject

public <T> T hgetallObject(String key,
 Class<T> type)

Just like hgetall(String), except the keys and values are set on a new instance of a Java object via reflection. Fields/Setter Methods annotated with RedisIgnore are ignored.

Type Parameters:

T - the return type.

Parameters:

key - the data key.

type - the class type to crate and return.

Returns:

the returned object.

Throws:

RuntimeException - if instantiation cannot happen, either due to a non-existent constructor or a non-visible constructor.

ClassCastException - if a incoming type cannot be converted to a field value.

hgetallObject

public <T> void hgetallObject(String key,
 T object)

Just like hgetall(String), except the keys and values are set on an existing instance of a Java object via reflection. Fields/Setter Methods annotated with RedisIgnore are ignored.

Type Parameters:

T - the object type.

Parameters:

key - the data key.

object - the object to store.

Throws:

RuntimeException - if instantiation cannot happen, either due to a non-existent constructor or a non-visible constructor.

ClassCastException - if a incoming type cannot be converted to a field value.

hincrby

public long hincrby(String key,
 String field,
 long increment)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/hincrby:

Available since 2.0.0.

Time complexity: O(1)

Increments the number stored at field in the hash stored at key by increment. If key does not exist, a new key holding a hash is created. If field does not exist the value is set to 0 before the operation is performed.

Specified by:

hincrby in interface RedisConnectionCommands

Returns:

the value at field after the increment operation.

hincrbyfloat

public double hincrbyfloat(String key,
 String field,
 double increment)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/hincrbyfloat:

Available since 2.6.0.

Time complexity: O(1)

Increment the specified field of an hash stored at key, and representing a floating point number, by the specified increment. If the field does not exist, it is set to 0 before performing the operation.

Specified by:

hincrbyfloat in interface RedisConnectionCommands

Returns:

the value of field after the increment.

hkeys

public String[] hkeys(String key)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/hkeys:

Available since 2.0.0.

Time complexity: O(N) where N is the size of the hash.

Returns all field names in the hash stored at key.

Specified by:

hkeys in interface RedisConnectionCommands

Returns:

the list of fields in the hash, or an empty list when key does not exist.

hlen

public long hlen(String key)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/hlen:

Available since 2.0.0.

Time complexity: O(1)

Returns the number of fields contained in the hash stored at key.

Specified by:

hlen in interface RedisConnectionCommands

Returns:

the number of fields in the hash, or 0 when key does not exist.

hmget

public String[] hmget(String key,
 String field,
 String... fields)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/hmget:

Available since 2.0.0.

Time complexity: O(N) where N is the number of fields being requested.

Returns the values associated with the specified fields in the hash stored at key.

Specified by:

hmget in interface RedisConnectionCommands

Returns:

a list of values associated with the given fields, in the same order as they are requested.

hmset

public boolean hmset(String key,
 String field,
 String value,
 String... fieldvalues)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/hmset:

Available since 2.0.0.

Time complexity: O(N) where N is the number of fields being set.

Sets the specified fields to their respective values in the hash stored at key. This command overwrites any existing fields in the hash. If key does not exist, a new key holding a hash is created.

Parameters should alternate between field, value, field, value ...

Specified by:

hmset in interface RedisConnectionCommands

Returns:

always true.

hmset

public boolean hmset(String key,
 Object field,
 Object value,
 Object... fieldvalues)

From http://redis.io/commands/hmset:

Available since 2.0.0.

Time complexity: O(N) where N is the number of fields being set.

Sets the specified fields to their respective values in the hash stored at key. This command overwrites any existing fields in the hash. If key does not exist, a new key holding a hash is created.

Parameters should alternate between field, value, field, value ...

Parameters:

key - the key.

field - the first field.

value - the first value.

fieldvalues - the subsequent field-values for the hash.

Returns:

always true.

hmset

public boolean hmset(String key,
 KeyValue<String,Object>... pairs)

Like hmset(String, String, String, String...), except abstracted as KeyValues of key-value pairs.

Specified by:

hmset in interface RedisConnectionCommands

Returns:

always true.

hmsetMap

public boolean hmsetMap(String key,
 Map<String,Object> map)

Like hmset(String, String, String, String...), except abstracted as a map of key-value pairs.

Parameters:

key - the key.

map - the map of field-value pairs for the hash.

Returns:

true.

hmsetObject

public <T> boolean hmsetObject(String key,
 T object)

Like hmset(String, String, String, String...), except each field or getter sets the fields and values. Fields/Getter Methods annotated with RedisIgnore are ignored.

Type Parameters:

T - the object type.

Parameters:

key - the key.

object - the object to convert to a hash.

Returns:

true.

hset

public boolean hset(String key,
 String field,
 String value)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/hset:

Available since 2.0.0.

Time complexity: O(1)

Sets field in the hash stored at key to value. If key does not exist, a new key holding a hash is created. If field already exists in the hash, it is overwritten.

Specified by:

hset in interface RedisConnectionCommands

Returns:

true if a new field, false if set, but not a new field.

hset

public boolean hset(String key,
 String field,
 Number value)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/hset:

Available since 2.0.0.

Time complexity: O(1)

Sets field in the hash stored at key to value. If key does not exist, a new key holding a hash is created. If field already exists in the hash, it is overwritten.

Specified by:

hset in interface RedisConnectionCommands

Returns:

true if a new field, false if set, but not a new field.

hsetnx

public boolean hsetnx(String key,
 String field,
 String value)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/hsetnx:

Available since 2.0.0.

Time complexity: O(1)

Sets field in the hash stored at key to value, only if field does not yet exist. If key does not exist, a new key holding a hash is created. If field already exists, this operation has no effect.

Specified by:

hsetnx in interface RedisConnectionCommands

Returns:

true if a new field, false if set, but not a new field.

hsetnx

public boolean hsetnx(String key,
 String field,
 Number value)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/hsetnx:

Available since 2.0.0.

Time complexity: O(1)

Sets field in the hash stored at key to value, only if field does not yet exist. If key does not exist, a new key holding a hash is created. If field already exists, this operation has no effect.

Specified by:

hsetnx in interface RedisConnectionCommands

Returns:

true if a new field, false if set, but not a new field.

hvals

public String[] hvals(String key)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/hvals:

Available since 2.0.0.

Time complexity: O(N) where N is the size of the hash.

Returns all values in the hash stored at key.

Specified by:

hvals in interface RedisConnectionCommands

Returns:

a list of values in the hash, or an empty list when key does not exist.

hscan

public RedisCursor hscan(String key,
 long cursor)

Description copied from interface: RedisScanCommands

From http://redis.io/commands/sscan:

Available since 2.8.0.

Time complexity: O(1) for every call. O(N) for a complete iteration, including enough command calls for the cursor to return back to 0. N is the number of elements inside the collection..

Specified by:

hscan in interface RedisScanCommands

Parameters:

key - the key of the hash to scan.

cursor - the cursor value.

Returns:

a RedisCursor that represents the result of a SCAN call.

hscan

public RedisCursor hscan(String key,
 long cursor,
 String pattern)

Description copied from interface: RedisScanCommands

From http://redis.io/commands/sscan:

Available since 2.8.0.

Time complexity: O(1) for every call. O(N) for a complete iteration, including enough command calls for the cursor to return back to 0. N is the number of elements inside the collection..

Specified by:

hscan in interface RedisScanCommands

Parameters:

key - the key of the hash to scan.

cursor - the cursor value.

pattern - if not null, return keys that fit a pattern.

Returns:

a RedisCursor that represents the result of a SCAN call.

hscan

public RedisCursor hscan(String key,
 long cursor,
 long count)

Description copied from interface: RedisScanCommands

From http://redis.io/commands/sscan:

Available since 2.8.0.

Time complexity: O(1) for every call. O(N) for a complete iteration, including enough command calls for the cursor to return back to 0. N is the number of elements inside the collection..

Specified by:

hscan in interface RedisScanCommands

Parameters:

key - the key of the hash to scan.

cursor - the cursor value.

count - if not null, cap the iterable keys at a limit.

Returns:

a RedisCursor that represents the result of a SCAN call.

hscan

public RedisCursor hscan(String key,
 long cursor,
 String pattern,
 Long count)

Description copied from interface: RedisScanCommands

From http://redis.io/commands/hscan:

Available since 2.8.0.

Time complexity: O(1) for every call. O(N) for a complete iteration, including enough command calls for the cursor to return back to 0. N is the number of elements inside the collection..

Specified by:

hscan in interface RedisScanCommands

Parameters:

key - the key of the hash to scan.

cursor - the cursor value.

pattern - if not null, return keys that fit a pattern.

count - if not null, cap the iterable keys at a limit.

Returns:

a RedisCursor that represents the result of a SCAN call.

pfadd

public boolean pfadd(String key,
 String element,
 String... elements)

Description copied from interface: RedisHyperlogCommands

From http://redis.io/commands/pfadd:

Available since 2.8.9.

Time complexity: O(1) to add every element.

Adds all the element arguments to the HyperLogLog data structure stored at the variable name specified as first argument.

Specified by:

pfadd in interface RedisHyperlogCommands

Parameters:

key - the hyperlog key.

element - the first element.

elements - the rest of the elements.

Returns:

true if at least one internal register was altered, false otherwise.

pfcount

public long pfcount(String key,
 String... keys)

Description copied from interface: RedisHyperlogCommands

From http://redis.io/commands/pfcount:

Available since 2.8.9.

Time complexity: O(1).

Returns the approximated cardinality computed by the HyperLogLog data structure stored at the specified variable, which is 0 if the variable does not exist.

Specified by:

pfcount in interface RedisHyperlogCommands

Parameters:

key - the first key.

keys - the rest of the keys.

Returns:

the number of unique elements observed via RedisHyperlogCommands.pfadd(String, String, String...).

pfmerge

public boolean pfmerge(String destkey,
 String sourcekey,
 String... sourcekeys)

Description copied from interface: RedisHyperlogCommands

From http://redis.io/commands/pfmerge:

Available since 2.8.9.

Time complexity: O(N) to merge N HyperLogLogs, but with high constant times.

Merge multiple HyperLogLog values into an unique value that will approximate the cardinality of the union of the observed Sets of the source HyperLogLog structures.

Specified by:

pfmerge in interface RedisHyperlogCommands

Parameters:

destkey - the destination key.

sourcekey - the first key.

sourcekeys - the rest of the keys.

Returns:

always true.

blpop

public KeyValue<String,String> blpop(long timeout,
 String key,
 String... keys)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/blpop:

Available since 2.0.0.

Time complexity: O(1)

BLPOP is a blocking list pop primitive. It is the blocking version of RedisConnectionCommands.lpop(String) because it blocks the connection when there are no elements to pop from any of the given lists. An element is popped from the head of the first list that is non-empty, with the given keys being checked in the order that they are given. A timeout of zero can be used to block indefinitely. Timeout is in seconds.

Specified by:

blpop in interface RedisConnectionCommands

Returns:

an object pair consisting of popped list key and the value popped, or null on timeout.

blpopLong

public KeyValue<String,Long> blpopLong(long timeout,
 String key,
 String... keys)

Like blpop(long, String, String...), except it casts the value to a long integer.

Parameters:

timeout - the timeout in seconds.

key - the first key.

keys - the subsequent keys.

Returns:

an object pair consisting of popped list key and the numeric value popped, or null on timeout.

brpop

public KeyValue<String,String> brpop(long timeout,
 String key,
 String... keys)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/brpop:

Available since 2.0.0.

Time complexity: O(1)

BRPOP is a blocking list pop primitive. It is the blocking version of RedisConnectionCommands.rpop(String) because it blocks the connection when there are no elements to pop from any of the given lists. An element is popped from the tail of the first list that is non-empty, with the given keys being checked in the order that they are given. A timeout of zero can be used to block indefinitely. Timeout is in seconds.

Specified by:

brpop in interface RedisConnectionCommands

Returns:

an object pair consisting of popped list key and the value popped, or null on timeout.

brpopLong

public KeyValue<String,Long> brpopLong(long timeout,
 String key,
 String... keys)

Like brpop(long, String, String...), except it casts the value to a long integer.

Parameters:

timeout - the timeout in seconds.

key - the first key.

keys - the subsequent keys.

Returns:

an object pair consisting of popped list key and the numeric value popped, or null on timeout.

brpoplpush

public String brpoplpush(long timeout,
 String source,
 String destination)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/brpoplpush:

Available since 2.2.0.

Time complexity: O(1)

BRPOPLPUSH is the blocking variant of RedisConnectionCommands.rpoplpush(String, String). When source contains elements, this command behaves exactly like RedisConnectionCommands.rpoplpush(String, String). When source is empty, Redis will block the connection until another client pushes to it or until timeout is reached. A timeout of zero can be used to block indefinitely. Timeout is in seconds.

Specified by:

brpoplpush in interface RedisConnectionCommands

Returns:

the value popped-then-pushed to destination from source, or null on timeout.

brpoplpushLong

public Long brpoplpushLong(long timeout,
 String source,
 String destination)

Like brpoplpush(long, String, String), except it casts the value to a long integer.

Parameters:

timeout - the timeout in seconds.

source - the source key.

destination - the destination key.

Returns:

the value returned as a long.

lindex

public String lindex(String key,
 long index)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/lindex:

Available since 1.0.0.

Time complexity: O(N) where N is the number of elements to traverse to get to the element at index. This makes asking for the first or the last element of the list O(1).

Returns the element at index index in the list stored at key. The index is zero-based, so 0 means the first element, 1 the second element and so on. Negative indices can be used to designate elements starting at the tail of the list. Here, -1 means the last element, -2 means the penultimate and so forth.

Specified by:

lindex in interface RedisConnectionCommands

Returns:

the requested element, or null when index is out of range.

lindexLong

public Long lindexLong(String key,
 long index)

Like lindex(String, long), except it casts the value to a long integer.

Parameters:

key - the key.

index - the list index.

Returns:

the value returned as a long.

linsert

public long linsert(String key,
 boolean before,
 String pivot,
 String value)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/linsert:

Available since 2.2.0.

Time complexity: O(N) where N is the number of elements to traverse before seeing the value pivot. This means that inserting somewhere on the left end on the list (head) can be considered O(1) and inserting somewhere on the right end (tail) is O(N).

Inserts value in the list stored at key either before or after the reference value pivot.

Specified by:

linsert in interface RedisConnectionCommands

Returns:

the length of the list after the insert operation, or -1 when the value pivot was not found.

linsert

public long linsert(String key,
 boolean before,
 String pivot,
 Number value)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/linsert:

Available since 2.2.0.

Time complexity: O(N) where N is the number of elements to traverse before seeing the value pivot. This means that inserting somewhere on the left end on the list (head) can be considered O(1) and inserting somewhere on the right end (tail) is O(N).

Inserts value in the list stored at key either before or after the reference value pivot.

Specified by:

linsert in interface RedisConnectionCommands

Returns:

the length of the list after the insert operation, or -1 when the value pivot was not found.

llen

public long llen(String key)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/llen:

Available since 1.0.0.

Time complexity: O(1)

Returns the length of the list stored at key. If key does not exist, it is interpreted as an empty list and 0 is returned. An error is returned when the value stored at key is not a list.

Specified by:

llen in interface RedisConnectionCommands

Returns:

the length of the list at key.

lpop

public String lpop(String key)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/lpop:

Available since 1.0.0.

Time complexity: O(1)

Removes and returns the first element of the list stored at key.

Specified by:

lpop in interface RedisConnectionCommands

Returns:

the value of the first element, or null when key does not exist.

lpopLong

public Long lpopLong(String key)

Like lpop(String), except it casts the value to a long integer.

Parameters:

key - the key.

Returns:

the value returned as a long.

lpush

public long lpush(String key,
 String value,
 String... values)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/lpush:

Available since 1.0.0.

Time complexity: O(1)

Insert all the specified values at the head of the list stored at key. If key does not exist, it is created as empty list before performing the push operations. When key holds a value that is not a list, an error is returned.

Specified by:

lpush in interface RedisConnectionCommands

Returns:

the length of the list after the push operations.

lpushx

public long lpushx(String key,
 String value)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/lpushx:

Available since 2.2.0.

Time complexity: O(1)

Inserts value at the head of the list stored at key, only if key already exists and holds a list. In contrary to RedisConnectionCommands.lpush(String, String, String...), no operation will be performed when key does not yet exist.

Specified by:

lpushx in interface RedisConnectionCommands

Returns:

the length of the list after the push operation.

lrange

public String[] lrange(String key,
 long start,
 long stop)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/lrange:

Available since 1.0.0.

Time complexity: O(S+N) where S is the start offset and N is the number of elements in the specified range.

Returns the specified elements of the list stored at key. The offsets start and stop are zero-based indexes, with 0 being the first element of the list (the head of the list), 1 being the next element and so on.

Specified by:

lrange in interface RedisConnectionCommands

Returns:

list of elements in the specified range.

lrem

public long lrem(String key,
 long count,
 String value)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/lrem:

Available since 1.0.0.

Time complexity: O(N) where N is the length of the list.

Removes the first count occurrences of elements equal to value from the list stored at key. The count argument influences the operation in the following ways:

• count > 0: Remove elements equal to value moving from head to tail.
• count < 0: Remove elements equal to value moving from tail to head.
• count = 0: Remove all elements equal to value.

Specified by:

lrem in interface RedisConnectionCommands

Returns:

the number of removed elements.

lset

public boolean lset(String key,
 long index,
 String value)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/lset:

Available since 1.0.0.

Time complexity: O(N) where N is the length of the list. Setting either the first or the last element of the list is O(1).

Sets the list element at index to value. For more information on the index argument, see RedisConnectionCommands.lindex(String, long).

Specified by:

lset in interface RedisConnectionCommands

Returns:

always true.

ltrim

public boolean ltrim(String key,
 long start,
 long stop)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/ltrim:

Available since 1.0.0.

Time complexity: O(N) where N is the number of elements to be removed by the operation.

Trim an existing list so that it will contain only the specified range of elements specified. Both start and stop are zero-based indexes, where 0 is the first element of the list (the head), 1 the next element and so on.

Specified by:

ltrim in interface RedisConnectionCommands

Returns:

always true.

rpop

public String rpop(String key)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/rpop:

Available since 1.0.0.

Time complexity: O(1)

Removes and returns the last element of the list stored at key.

Specified by:

rpop in interface RedisConnectionCommands

Returns:

the value of the last element, or null when key does not exist.

rpopLong

public Long rpopLong(String key)

Like rpop(String), except it casts the value to a long integer.

Parameters:

key - the key.

Returns:

the value returned as a long.

rpoplpush

public String rpoplpush(String source,
 String destination)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/rpoplpush:

Available since 1.2.0.

Time complexity: O(1)

Atomically returns and removes the last element (tail) of the list stored at source, and pushes the element at the first element (head) of the list stored at destination.

Specified by:

rpoplpush in interface RedisConnectionCommands

Returns:

the element being popped and pushed.

rpoplpushLong

public Long rpoplpushLong(String source,
 String destination)

Like rpoplpush(String, String), except it casts the value to a long integer.

Parameters:

source - the source key.

destination - the destination key.

Returns:

the value returned as a long.

rpush

public long rpush(String key,
 String value,
 String... values)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/rpush:

Available since 1.0.0.

Time complexity: O(1)

Insert all the specified values at the tail of the list stored at key. If key does not exist, it is created as empty list before performing the push operation. When key holds a value that is not a list, an error is returned.

Specified by:

rpush in interface RedisConnectionCommands

Returns:

the length of the list after the push operation.

rpushx

public long rpushx(String key,
 String value)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/rpushx:

Available since 2.2.0.

Time complexity: O(1)

Inserts value at the tail of the list stored at key, only if key already exists and holds a list. In contrary to RedisConnectionCommands.rpush(String, String, String...), no operation will be performed when key does not yet exist.

Specified by:

rpushx in interface RedisConnectionCommands

Returns:

the length of the list after the push operation.

eval

public RedisObject eval(String scriptContent,
 String[] keys,
 Object... args)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/eval:

Available since 2.6.0.

Time complexity: Depends on the script that is executed.

Evaluates a Lua script. The keys specified in keys should be used as a hint for Redis as to what keys are touched during the script call.

Specified by:

eval in interface RedisConnectionCommands

Returns:

the content returned by the script. Can be null.

evalsha

public RedisObject evalsha(String hash,
 String[] keys,
 Object... args)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/evalsha:

Available since 2.6.0.

Time complexity: Depends on the script that is executed.

Evaluates a script cached on the server side by its SHA1 digest. Scripts are cached on the server side using the RedisConnectionCommands.scriptLoad(String) command. The command is otherwise identical to RedisConnectionCommands.eval(String, String[], Object...).

Specified by:

evalsha in interface RedisConnectionCommands

Returns:

the content returned by the script. Can be null.

scriptExists

public boolean[] scriptExists(String scriptHash,
 String... scriptHashes)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/script-exists:

Available since 2.6.0.

Time complexity: O(N) with N being the number of scripts to check (so checking a single script is an O(1) operation).

Returns information about the existence of the scripts in the script cache.

Specified by:

scriptExists in interface RedisConnectionCommands

Returns:

The command returns an array of booleans that correspond to the specified SHA1 digest arguments. For every corresponding SHA1 digest of a script that actually exists in the script cache, true is returned, otherwise false is returned.

scriptFlush

public boolean scriptFlush()

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/script-flush:

Available since 2.6.0.

Time complexity: O(N) with N being the number of scripts in cache

Flush the Lua scripts cache.

Specified by:

scriptFlush in interface RedisConnectionCommands

Returns:

always true.

scriptKill

public boolean scriptKill(String hash)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/script-kill:

Available since 2.6.0.

Time complexity: O(1)

Kills the currently executing Lua script, assuming no write operation was yet performed by the script.

Specified by:

scriptKill in interface RedisConnectionCommands

Returns:

always true.

scriptLoad

public String scriptLoad(String content)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/script-load:

Available since 2.6.0.

Time complexity: O(N) with N being the length in bytes of the script body.

Load a script into the scripts cache, without executing it. After the specified command is loaded into the script cache it will be callable using RedisConnectionCommands.evalsha(String, String[], Object...) with the correct SHA1 digest of the script, exactly like after the first successful invocation of RedisConnectionCommands.eval(String, String[], Object...).

Specified by:

scriptLoad in interface RedisConnectionCommands

Returns:

the SHA1 digest of the script added into the script cache.

scriptLoad

public String scriptLoad(File content)
                  throws IOException

From http://redis.io/commands/script-load:

Available since 2.6.0.

Time complexity: O(N) with N being the length in bytes of the script body.

Load a script into the scripts cache from the specified file without executing it. After the specified command is loaded into the script cache it will be callable using evalsha(String, String[], Object...) with the correct SHA1 digest of the script, exactly like after the first successful invocation of eval(String, String[], Object...).

Specified by:

scriptLoad in interface RedisConnectionCommands

Returns:

the SHA1 digest of the script added into the script cache.

Throws:

IOException

scriptLoad

public String scriptLoad(InputStream content)
                  throws IOException

From http://redis.io/commands/script-load:

Available since 2.6.0.

Time complexity: O(N) with N being the length in bytes of the script body.

Load a script into the scripts cache from the specified input stream (until the end is reached) without executing it. The stream is not closed after read. After the specified command is loaded into the script cache it will be callable using evalsha(String, String[], Object...) with the correct SHA1 digest of the script, exactly like after the first successful invocation of eval(String, String[], Object...).

Specified by:

scriptLoad in interface RedisConnectionCommands

Returns:

the SHA1 digest of the script added into the script cache.

Throws:

IOException

sadd

public long sadd(String key,
 String member,
 String... members)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/sadd:

Available since 1.0.0.

Time complexity: O(N) where N is the number of members to be added.

Add the specified members to the set stored at key. Specified members that are already a member of this set are ignored. If key does not exist, a new set is created before adding the specified members.

Specified by:

sadd in interface RedisConnectionCommands

Returns:

the number of elements that were added to the set, not including all the elements already present into the set.

sadd

public long sadd(String key,
 Object member,
 Object... members)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/sadd:

Available since 1.0.0.

Time complexity: O(N) where N is the number of members to be added.

Add the specified members to the set stored at key. Specified members that are already a member of this set are ignored. If key does not exist, a new set is created before adding the specified members.

Specified by:

sadd in interface RedisConnectionCommands

scard

public long scard(String key)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/scard:

Available since 1.0.0.

Time complexity: O(1)

Returns the set cardinality (number of elements) of the set stored at key.

Specified by:

scard in interface RedisConnectionCommands

Returns:

the cardinality (number of elements) of the set, or 0 if key does not exist.

sdiff

public String[] sdiff(String key,
 String... keys)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/sdiff:

Available since 1.0.0.

Time complexity: O(N) where N is the total number of elements in all given sets.

Returns the members of the set resulting from the difference between the first set and all the successive sets.

Specified by:

sdiff in interface RedisConnectionCommands

Returns:

list with members of the resulting set.

sdiffstore

public long sdiffstore(String destination,
 String key,
 String... keys)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/sdiffstore:

Available since 1.0.0.

Time complexity: O(N) where N is the total number of elements in all given sets.

This command is equal to SDIFF, but instead of returning the resulting set, it is stored in destination.

Specified by:

sdiffstore in interface RedisConnectionCommands

Returns:

the number of elements in the resulting set.

sinter

public String[] sinter(String key,
 String... keys)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/sinter:

Available since 1.0.0.

Time complexity: O(N*M) worst case where N is the cardinality of the smallest set and M is the number of sets.

Returns the members of the set resulting from the intersection of all the given sets.

Specified by:

sinter in interface RedisConnectionCommands

Returns:

list with members of the resulting set.

sinterstore

public long sinterstore(String destination,
 String key,
 String... keys)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/sinterstore:

Available since 1.0.0.

Time complexity: O(N*M) worst case where N is the cardinality of the smallest set and M is the number of sets.

This command is equal to SINTER, but instead of returning the resulting set, it is stored in destination.

Specified by:

sinterstore in interface RedisConnectionCommands

Returns:

the number of elements in the resulting set.

sismember

public boolean sismember(String key,
 String member)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/sismember:

Available since 1.0.0.

Time complexity: O(1)

Returns if member is a member of the set stored at key.

Specified by:

sismember in interface RedisConnectionCommands

Returns:

true if the member is in the set, or false if not.

sismember

public boolean sismember(String key,
 Number member)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/sismember:

Available since 1.0.0.

Time complexity: O(1)

Returns if member is a member of the set stored at key.

Specified by:

sismember in interface RedisConnectionCommands

Returns:

true if the member is in the set, or false if not.

smembers

public String[] smembers(String key)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/smembers:

Available since 1.0.0.

Time complexity: O(N) where N is the set cardinality.

Returns all the members of the set value stored at key.

Specified by:

smembers in interface RedisConnectionCommands

Returns:

all elements of the set.

smove

public boolean smove(String source,
 String destination,
 String member)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/smove:

Available since 1.0.0.

Time complexity: O(1)

Move member from the set at source to the set at destination. This operation is atomic. In every given moment the element will appear to be a member of source or destination for other clients.

Specified by:

smove in interface RedisConnectionCommands

Returns:

true if the move of the member is successful, or false if the source list did not contain the member to move.

spop

public String spop(String key)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/spop:

Available since 1.0.0.

Time complexity: O(1)

Removes and returns a random element from the set value stored at key.

Specified by:

spop in interface RedisConnectionCommands

Returns:

the removed element, or null when key does not exist.

spopLong

public Long spopLong(String key)

Like spop(String), except it casts the value to a long integer.

Parameters:

key - the key.

Returns:

the value returned as a long.

srandmember

public String srandmember(String key)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/srandmember:

Available since 1.0.0.

Time complexity: O(1).

When called with just the key argument, return a random element from the set value stored at key.

Specified by:

srandmember in interface RedisConnectionCommands

Returns:

the randomly selected element, or null when key does not exist.

srandmember

public String[] srandmember(String key,
 long count)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/srandmember:

Available since 1.0.0.

Time complexity: O(N) where N is the absolute value of the passed count.

When called with just the key argument, return a random element from the set value stored at key.

Specified by:

srandmember in interface RedisConnectionCommands

Returns:

an array of elements, or an empty array when key does not exist.

srem

public long srem(String key,
 String member,
 String... members)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/srem:

Available since 1.0.0.

Time complexity: O(N) where N is the number of members to be removed.

Remove the specified members from the set stored at key. Specified members that are not a member of this set are ignored. If key does not exist, it is treated as an empty set and this command returns 0.

Specified by:

srem in interface RedisConnectionCommands

Returns:

the number of members that were removed from the set, not including non existing members.

srem

public long srem(String key,
 Object member,
 Object... members)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/srem:

Available since 1.0.0.

Time complexity: O(N) where N is the number of members to be removed.

Remove the specified members from the set stored at key. Specified members that are not a member of this set are ignored. If key does not exist, it is treated as an empty set and this command returns 0.

Specified by:

srem in interface RedisConnectionCommands

Returns:

the number of members that were removed from the set, not including non existing members.

sunion

public String[] sunion(String key,
 String... keys)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/sunion:

Available since 1.0.0.

Time complexity: O(N) where N is the total number of elements in all given sets.

Returns the members of the set resulting from the union of all the given sets.

Specified by:

sunion in interface RedisConnectionCommands

Returns:

list with members of the resulting set.

sunionstore

public long sunionstore(String destination,
 String key,
 String... keys)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/sunionstore:

Available since 1.0.0.

Time complexity: O(N) where N is the total number of elements in all given sets.

This command is equal to SUNION, but instead of returning the resulting set, it is stored in destination.

Specified by:

sunionstore in interface RedisConnectionCommands

Returns:

the number of elements in the resulting set.

sscan

public RedisCursor sscan(String key,
 long cursor)

Description copied from interface: RedisScanCommands

From http://redis.io/commands/hscan:

Available since 2.8.0.

Time complexity: O(1) for every call. O(N) for a complete iteration, including enough command calls for the cursor to return back to 0. N is the number of elements inside the collection..

Specified by:

sscan in interface RedisScanCommands

Parameters:

key - the key of the set to scan.

cursor - the cursor value.

Returns:

a RedisCursor that represents the result of a SCAN call.

sscan

public RedisCursor sscan(String key,
 long cursor,
 String pattern)

Description copied from interface: RedisScanCommands

From http://redis.io/commands/hscan:

Available since 2.8.0.

Time complexity: O(1) for every call. O(N) for a complete iteration, including enough command calls for the cursor to return back to 0. N is the number of elements inside the collection..

Specified by:

sscan in interface RedisScanCommands

Parameters:

key - the key of the set to scan.

cursor - the cursor value.

pattern - if not null, return keys that fit a pattern.

Returns:

a RedisCursor that represents the result of a SCAN call.

sscan

public RedisCursor sscan(String key,
 long cursor,
 long count)

Description copied from interface: RedisScanCommands

From http://redis.io/commands/hscan:

Available since 2.8.0.

Time complexity: O(1) for every call. O(N) for a complete iteration, including enough command calls for the cursor to return back to 0. N is the number of elements inside the collection..

Specified by:

sscan in interface RedisScanCommands

Parameters:

key - the key of the set to scan.

cursor - the cursor value.

count - if not null, cap the iterable keys at a limit.

Returns:

a RedisCursor that represents the result of a SCAN call.

sscan

public RedisCursor sscan(String key,
 String cursor,
 String pattern,
 Long count)

Description copied from interface: RedisScanCommands

From http://redis.io/commands/sscan:

Available since 2.8.0.

Time complexity: O(1) for every call. O(N) for a complete iteration, including enough command calls for the cursor to return back to 0. N is the number of elements inside the collection..

Specified by:

sscan in interface RedisScanCommands

Parameters:

key - the key of the set to scan.

cursor - the cursor value.

pattern - if not null, return keys that fit a pattern.

count - if not null, cap the iterable keys at a limit.

Returns:

a RedisCursor that represents the result of a SCAN call.

zadd

public long zadd(String key,
 double score,
 String member)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/zadd:

Available since 1.2.0.

Time complexity: O(log(N)) where N is the number of elements in the sorted set.

Adds all the specified members with the specified scores to the sorted set stored at key. It is possible to specify multiple score/member pairs. If a specified member is already a member of the sorted set, the score is updated and the element reinserted at the right position to ensure the correct ordering. If key does not exist, a new sorted set with the specified members as sole members is created, like if the sorted set was empty. If the key exists but does not hold a sorted set, an error is returned.

Specified by:

zadd in interface RedisConnectionCommands

Returns:

the number of elements added to the sorted sets, not including elements already existing for which the score was updated.

zadd

public long zadd(String key,
 double score,
 Number member)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/zadd:

Available since 1.2.0.

Time complexity: O(log(N)) where N is the number of elements in the sorted set.

Adds all the specified members with the specified scores to the sorted set stored at key. It is possible to specify multiple score/member pairs. If a specified member is already a member of the sorted set, the score is updated and the element reinserted at the right position to ensure the correct ordering. If key does not exist, a new sorted set with the specified members as sole members is created, like if the sorted set was empty. If the key exists but does not hold a sorted set, an error is returned.

Specified by:

zadd in interface RedisConnectionCommands

zadd

public long zadd(String key,
 KeyValue<Double,String>... pairs)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/zadd:

Available since 1.2.0.

Time complexity: O(log(N)) where N is the number of elements in the sorted set.

Adds all the specified members with the specified scores to the sorted set stored at key. It is possible to specify multiple score/member pairs. If a specified member is already a member of the sorted set, the score is updated and the element reinserted at the right position to ensure the correct ordering. If key does not exist, a new sorted set with the specified members as sole members is created, like if the sorted set was empty. If the key exists but does not hold a sorted set, an error is returned.

Specified by:

zadd in interface RedisConnectionCommands

Returns:

the number of elements added to the sorted sets, not including elements already existing for which the score was updated.

zcard

public long zcard(String key)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/zcard:

Available since 1.2.0.

Time complexity: O(1)

Returns the sorted set cardinality (number of elements) of the sorted set stored at key.

Specified by:

zcard in interface RedisConnectionCommands

Returns:

the cardinality (number of elements) of the sorted set, or 0 if key does not exist.

zcount

public long zcount(String key,
 String min,
 String max)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/zcount:

Available since 2.0.0.

Time complexity: O(log(N)) with N being the number of elements in the sorted set.

Returns the number of elements in the sorted set at key with a score between min and max.

The arguments min and max are Strings so they can accept special ranges.

Specified by:

zcount in interface RedisConnectionCommands

Returns:

the number of elements in the specified score range.

zcount

public long zcount(String key,
 double min,
 double max)

Like zcount(String, String, String), except it accepts doubles for min and max, not strings.

Specified by:

zcount in interface RedisConnectionCommands

zincrby

public double zincrby(String key,
 double increment,
 String member)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/zincrby:

Available since 1.2.0.

Time complexity: O(log(N)) where N is the number of elements in the sorted set.

Increments the score of member in the sorted set stored at key by increment. If member does not exist in the sorted set, it is added with increment as its score (as if its previous score was 0.0). If key does not exist, a new sorted set with the specified member as its sole member is created.

Specified by:

zincrby in interface RedisConnectionCommands

Returns:

the new score of member (a double precision floating point number).

zrange

public String[] zrange(String key,
 long start,
 long stop,
 boolean withScores)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/zrange:

Available since 1.2.0.

Time complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements returned.

Returns the specified range of elements in the sorted set stored at key. The elements are considered to be ordered from the lowest to the highest score. Lexicographical order is used for elements with equal score.

Specified by:

zrange in interface RedisConnectionCommands

Returns:

list of elements in the specified range (optionally with their scores).

zrangebyscore

public String[] zrangebyscore(String key,
 String min,
 String max,
 boolean withScores,
 Long limitOffset,
 Long limitCount)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/zrangebyscore:

Available since 1.0.5.

Time complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements being returned. If M is constant (e.g. always asking for the first 10 elements with LIMIT), you can consider it O(log(N)).

Returns all the elements in the sorted set at key with a score between min and max (including elements with score equal to min or max). The elements are considered to be ordered from low to high scores.

The optional LIMIT argument can be used to only get a range of the matching elements (similar to SELECT LIMIT offset, count in SQL). Keep in mind that if offset is large, the sorted set needs to be traversed for offset elements before getting to the elements to return, which can add up to O(N) time complexity.

The arguments min and max are Strings so they can accept special ranges.

Specified by:

zrangebyscore in interface RedisConnectionCommands

Returns:

list of elements in the specified score range (optionally with their scores).

zrangebyscore

public String[] zrangebyscore(String key,
 double min,
 double max,
 boolean withScores)

Description copied from interface: RedisConnectionCommands

Like RedisConnectionCommands.zrangebyscore(String, String, String, boolean), except it accepts doubles for min and max, not strings.

Specified by:

zrangebyscore in interface RedisConnectionCommands

zrangebyscore

public String[] zrangebyscore(String key,
 String min,
 String max,
 boolean withScores)

Description copied from interface: RedisConnectionCommands

Like RedisConnectionCommands.zrangebyscore(String, String, String, boolean, Long, Long), except specifies no limit.

Specified by:

zrangebyscore in interface RedisConnectionCommands

zrangebyscore

public String[] zrangebyscore(String key,
 double min,
 double max,
 boolean withScores,
 Long limitOffset,
 Long limitCount)

Description copied from interface: RedisConnectionCommands

Like RedisConnectionCommands.zrangebyscore(String, String, String, boolean, Long, Long), except it accepts doubles for min and max, not strings.

Specified by:

zrangebyscore in interface RedisConnectionCommands

zrank

public Long zrank(String key,
 String member)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/zrank:

Available since 2.0.0.

Time complexity: O(log(N))

Returns the rank of member in the sorted set stored at key, with the scores ordered from low to high. The rank (or index) is 0-based, which means that the member with the lowest score has rank 0.

Specified by:

zrank in interface RedisConnectionCommands

Returns:

If member exists in the sorted set, the rank of member. If member does not exist in the sorted set or key does not exist, null.

zrank

public Long zrank(String key,
 Number member)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/zrank:

Available since 2.0.0.

Time complexity: O(log(N))

Returns the rank of member in the sorted set stored at key, with the scores ordered from low to high. The rank (or index) is 0-based, which means that the member with the lowest score has rank 0.

Specified by:

zrank in interface RedisConnectionCommands

Returns:

If member exists in the sorted set, the rank of member. If member does not exist in the sorted set or key does not exist, null.

zrem

public long zrem(String key,
 String member,
 String... members)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/zrem:

Available since 1.2.0.

Time complexity: O(M*log(N)) with N being the number of elements in the sorted set and M the number of elements to be removed.

Removes the specified members from the sorted set stored at key. Non existing members are ignored.

Specified by:

zrem in interface RedisConnectionCommands

Returns:

the number of members removed from the sorted set, not including non existing members.

zrem

public long zrem(String key,
 Number member,
 Number... members)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/zrem:

Available since 1.2.0.

Time complexity: O(M*log(N)) with N being the number of elements in the sorted set and M the number of elements to be removed.

Removes the specified members from the sorted set stored at key. Non existing members are ignored.

Specified by:

zrem in interface RedisConnectionCommands

Returns:

the number of members removed from the sorted set, not including non existing members.

zremrangebyrank

public long zremrangebyrank(String key,
 long start,
 long stop)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/zremrangebyrank:

Available since 2.0.0.

Time complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements removed by the operation.

Removes all elements in the sorted set stored at key with rank between start and stop. Both start and stop are 0 -based indexes with 0 being the element with the lowest score. These indexes can be negative numbers, where they indicate offsets starting at the element with the highest score. For example: -1 is the element with the highest score, -2 the element with the second highest score and so forth.

Specified by:

zremrangebyrank in interface RedisConnectionCommands

Returns:

the number of elements removed.

zremrangebyscore

public long zremrangebyscore(String key,
 String min,
 String max)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/zremrangebyscore:

Available since 1.2.0.

Time complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements removed by the operation.

Removes all elements in the sorted set stored at key with a score between min and max (inclusive).

The arguments min and max are Strings so they can accept special ranges.

Specified by:

zremrangebyscore in interface RedisConnectionCommands

Returns:

the number of elements removed.

zremrangebyscore

public long zremrangebyscore(String key,
 double min,
 double max)

Like zremrangebyscore(String, String, String), except it accepts doubles for min and max, not strings.

Specified by:

zremrangebyscore in interface RedisConnectionCommands

zrevrank

public Long zrevrank(String key,
 String member)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/zrevrank:

Available since 2.0.0.

Time complexity: O(log(N))

Returns the rank of member in the sorted set stored at key, with the scores ordered from high to low. The rank (or index) is 0-based, which means that the member with the highest score has rank 0.

Specified by:

zrevrank in interface RedisConnectionCommands

Returns:

If member exists in the sorted set, the rank of member. If member does not exist in the sorted set or key does not exist, null.

zrevrange

public String[] zrevrange(String key,
 long start,
 long stop,
 boolean withScores)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/zrevrange:

Available since 1.2.0.

Time complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements returned.

Returns the specified range of elements in the sorted set stored at key. The elements are considered to be ordered from the highest to the lowest score. Descending lexicographical order is used for elements with equal score.

Specified by:

zrevrange in interface RedisConnectionCommands

Returns:

list of elements in the specified range (optionally with their scores).

zrevrangebyscore

public String[] zrevrangebyscore(String key,
 String min,
 String max,
 boolean withScores,
 Long limitOffset,
 Long limitCount)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/zrevrangebyscore:

Available since 2.2.0.

Time complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements removed by the operation.

Returns all the elements in the sorted set at key with a score between max and min (including elements with score equal to max or min). In contrary to the default ordering of sorted sets, for this command the elements are considered to be ordered from high to low scores.

The optional LIMIT argument can be used to only get a range of the matching elements (similar to SELECT LIMIT offset, count in SQL). Keep in mind that if offset is large, the sorted set needs to be traversed for offset elements before getting to the elements to return, which can add up to O(N) time complexity.

The arguments min and max are Strings so they can accept special ranges.

Specified by:

zrevrangebyscore in interface RedisConnectionCommands

Returns:

list of elements in the specified score range (optionally with their scores).

zrevrangebyscore

public String[] zrevrangebyscore(String key,
 double min,
 double max,
 boolean withScores)

Description copied from interface: RedisConnectionCommands

Like RedisConnectionCommands.zrevrangebyscore(String, String, String, boolean), except it accepts doubles for min and max, not strings.

Specified by:

zrevrangebyscore in interface RedisConnectionCommands

zrevrangebyscore

public String[] zrevrangebyscore(String key,
 String min,
 String max,
 boolean withScores)

Description copied from interface: RedisConnectionCommands

Like RedisConnectionCommands.zrevrangebyscore(String, String, String, boolean, Long, Long), except specifies no limit.

Specified by:

zrevrangebyscore in interface RedisConnectionCommands

zrevrangebyscore

public String[] zrevrangebyscore(String key,
 double min,
 double max,
 boolean withScores,
 Long limitOffset,
 Long limitCount)

Description copied from interface: RedisConnectionCommands

Like RedisConnectionCommands.zrevrangebyscore(String, String, String, boolean, Long, Long), except it accepts doubles for min and max, not strings.

Specified by:

zrevrangebyscore in interface RedisConnectionCommands

zscore

public Double zscore(String key,
 String member)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/zscore:

Available since 1.2.0.

Time complexity: O(1)

Returns the score of member in the sorted set at key.

Specified by:

zscore in interface RedisConnectionCommands

Returns:

the score of member (a double precision floating point number).

zinterstore

public long zinterstore(String destination,
 double[] weights,
 Aggregation aggregation,
 String key,
 String... keys)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/zinterstore:

Available since 2.0.0.

Time complexity: O(N*K)+O(M*log(M)) worst case with N being the smallest input sorted set, K being the number of input sorted sets and M being the number of elements in the resulting sorted set.

Computes the intersection of numkeys sorted sets given by the specified keys, and stores the result in destination. It is mandatory to provide the number of input keys (numkeys) before passing the input keys and the other (optional) arguments.

Specified by:

zinterstore in interface RedisConnectionCommands

Returns:

the number of elements in the resulting sorted set at destination.

zinterstore

public long zinterstore(String destination,
 Aggregation aggregation,
 String key,
 String... keys)

Description copied from interface: RedisConnectionCommands

Like RedisConnectionCommands.zinterstore(String, double[], Aggregation, String, String...), except no weights are applied to the source value scores.

Equivalent to: zinterstore(destination, null, aggregation, key, keys)

Specified by:

zinterstore in interface RedisConnectionCommands

zinterstore

public long zinterstore(String destination,
 double[] weights,
 String key,
 String... keys)

Description copied from interface: RedisConnectionCommands

Like RedisConnectionCommands.zinterstore(String, double[], Aggregation, String, String...), except it does no aggregation of scores.

Equivalent to: zinterstore(destination, weights, null, key, keys)

Specified by:

zinterstore in interface RedisConnectionCommands

zinterstore

public long zinterstore(String destination,
 String key,
 String... keys)

Description copied from interface: RedisConnectionCommands

Like RedisConnectionCommands.zinterstore(String, double[], Aggregation, String, String...), except no weights are applied to the source value scores, and does no aggregation of scores.

Equivalent to: zinterstore(destination, null, null, key, keys)

Specified by:

zinterstore in interface RedisConnectionCommands

zunionstore

public long zunionstore(String destination,
 double[] weights,
 Aggregation aggregation,
 String key,
 String... keys)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/zunionstore:

Available since 2.0.0.

Time complexity: O(N)+O(M log(M)) with N being the sum of the sizes of the input sorted sets, and M being the number of elements in the resulting sorted set.

Computes the union of numkeys sorted sets given by the specified keys, and stores the result in destination. It is mandatory to provide the number of input keys (numkeys) before passing the input keys and the other (optional) arguments.

Specified by:

zunionstore in interface RedisConnectionCommands

Returns:

the number of elements in the resulting sorted set at destination.

zunionstore

public long zunionstore(String destination,
 Aggregation aggregation,
 String key,
 String... keys)

Description copied from interface: RedisConnectionCommands

Like RedisConnectionCommands.zunionstore(String, double[], Aggregation, String, String...), except no weights are applied to the source value scores.

Equivalent to: zunionstore(destination, null, aggregation, key, keys)

Specified by:

zunionstore in interface RedisConnectionCommands

zunionstore

public long zunionstore(String destination,
 double[] weights,
 String key,
 String... keys)

Description copied from interface: RedisConnectionCommands

Like RedisConnectionCommands.zunionstore(String, double[], Aggregation, String, String...), except it does no aggregation of scores.

Equivalent to: zunionstore(destination, weights, null, key, keys)

Specified by:

zunionstore in interface RedisConnectionCommands

zunionstore

public long zunionstore(String destination,
 String key,
 String... keys)

Description copied from interface: RedisConnectionCommands

Like RedisConnectionCommands.zunionstore(String, double[], Aggregation, String, String...), except no weights are applied to the source value scores, and does no aggregation of scores.

Equivalent to: zunionstore(destination, null, null, key, keys)

Specified by:

zunionstore in interface RedisConnectionCommands

zlexcount

public long zlexcount(String key,
 String min,
 String max)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/zlexcount:

Available since 2.8.9.

Time complexity: O(log(N)) with N being the number of elements in the sorted set.

When all the elements in a sorted set are inserted with the same score, in order to force lexicographical ordering, this command returns the number of elements in the sorted set at key with a value between min and max.

The arguments min and max are Strings so they can accept special ranges.

Specified by:

zlexcount in interface RedisConnectionCommands

Returns:

the number of elements in the specified score range.

zlexcount

public long zlexcount(String key,
 double min,
 double max)

Description copied from interface: RedisConnectionCommands

Like RedisConnectionCommands.zlexcount(String, String, String), except it accepts doubles for min and max, not strings.

Specified by:

zlexcount in interface RedisConnectionCommands

zrangebylex

public long zrangebylex(String key,
 String min,
 String max,
 Long limitOffset,
 Long limitCount)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/zrangebylex:

Available since 2.8.9.

Time complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements being returned. If M is constant (e.g. always asking for the first 10 elements with LIMIT), you can consider it O(log(N)).

When all the elements in a sorted set are inserted with the same score, in order to force lexicographical ordering, this command returns all the elements in the sorted set at key with a value between min and max.

The optional LIMIT argument can be used to only get a range of the matching elements (similar to SELECT LIMIT offset, count in SQL). Keep in mind that if offset is large, the sorted set needs to be traversed for offset elements before getting to the elements to return, which can add up to O(N) time complexity.

The arguments min and max are Strings so they can accept special ranges.

Specified by:

zrangebylex in interface RedisConnectionCommands

Returns:

list of elements in the specified score range.

zrangebylex

public long zrangebylex(String key,
 double min,
 double max,
 Long limitOffset,
 Long limitCount)

Like zrangebylex(String, String, String, Long, Long), except it accepts doubles for min and max, not strings.

Specified by:

zrangebylex in interface RedisConnectionCommands

zrangebylex

public long zrangebylex(String key,
 String min,
 String max)

Like zrangebylex(String, String, String, Long, Long), with no limit.

Specified by:

zrangebylex in interface RedisConnectionCommands

zrangebylex

public long zrangebylex(String key,
 double min,
 double max)

Like zrangebylex(String, String, String), except it accepts doubles for min and max, not strings, with no limit.

Specified by:

zrangebylex in interface RedisConnectionCommands

zremrangebylex

public long zremrangebylex(String key,
 String min,
 String max)

Description copied from interface: RedisConnectionCommands

From http://redis.io/commands/zremrangebylex:

Available since 2.8.9.

Time complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements removed by the operation.

When all the elements in a sorted set are inserted with the same score, in order to force lexicographical ordering, this command removes all elements in the sorted set stored at key between the lexicographical range specified by min and max.

The arguments min and max are Strings so they can accept special ranges.

Specified by:

zremrangebylex in interface RedisConnectionCommands

Returns:

the number of elements removed.

zremrangebylex

public long zremrangebylex(String key,
 double min,
 double max)

Description copied from interface: RedisConnectionCommands

Like RedisConnectionCommands.zrangebylex(String, String, String), except it accepts doubles for min and max.

Specified by:

zremrangebylex in interface RedisConnectionCommands

zscan

public RedisCursor zscan(String key,
 long cursor)

Description copied from interface: RedisScanCommands

From http://redis.io/commands/zscan:

Available since 2.8.0.

Time complexity: O(1) for every call. O(N) for a complete iteration, including enough command calls for the cursor to return back to 0. N is the number of elements inside the collection..

Specified by:

zscan in interface RedisScanCommands

Parameters:

key - the key of the sorted set to scan.

cursor - the cursor value.

Returns:

a RedisCursor that represents the result of a SCAN call.

zscan

public RedisCursor zscan(String key,
 long cursor,
 String pattern)

Description copied from interface: RedisScanCommands

From http://redis.io/commands/zscan:

Available since 2.8.0.

Time complexity: O(1) for every call. O(N) for a complete iteration, including enough command calls for the cursor to return back to 0. N is the number of elements inside the collection..

Specified by:

zscan in interface RedisScanCommands

Parameters:

key - the key of the sorted set to scan.

cursor - the cursor value.

pattern - if not null, return keys that fit a pattern.

Returns:

a RedisCursor that represents the result of a SCAN call.

zscan

public RedisCursor zscan(String key,
 long cursor,
 long count)

Description copied from interface: RedisScanCommands

From http://redis.io/commands/zscan:

Available since 2.8.0.

Time complexity: O(1) for every call. O(N) for a complete iteration, including enough command calls for the cursor to return back to 0. N is the number of elements inside the collection..

Specified by:

zscan in interface RedisScanCommands

Parameters:

key - the key of the sorted set to scan.

cursor - the cursor value.

count - if not null, cap the iterable keys at a limit.

Returns:

a RedisCursor that represents the result of a SCAN call.

zscan

public RedisCursor zscan(String key,
 long cursor,
 String pattern,
 Long count)

Description copied from interface: RedisScanCommands

From http://redis.io/commands/zscan:

Available since 2.8.0.

Time complexity: O(1) for every call. O(N) for a complete iteration, including enough command calls for the cursor to return back to 0. N is the number of elements inside the collection..

Specified by:

zscan in interface RedisScanCommands

Parameters:

key - the key of the sorted set to scan.

cursor - the cursor value.

pattern - if not null, return keys that fit a pattern.

count - if not null, cap the iterable keys at a limit.

Returns:

a RedisCursor that represents the result of a SCAN call.

specialDouble

protected String specialDouble(double d)

Converts some of Java's primitive doubles to Redis interval values.

• Double.NEGATIVE_INFINITY converts to "-".
• Double.POSITIVE_INFINITY converts to "+".
• All others convert to their string representation.

Parameters:

d - the input double.

Returns:

the string representation of the value.