java.lang.Object
- io.toro.martini.redis.RedisBaseMethods
- - io.toro.martini.redis.RedisKeyMethods

public class RedisKeyMethods
extends io.toro.martini.redis.RedisBaseMethods

Methods for Keys (Key manipulation/querying).

Field Summary

Fields
Modifier and Type Field Description

static String MIGRATE_ARGS_GLOOP_DOC

static String SORT_ARGS_GLOOP_DOC

Constructor Summary

Constructors
Constructor Description

RedisKeyMethods(io.toro.martini.database.DataSourceManager dataSourceManager)

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method	Description
`static Long`	`del(String connectionName, GloopExecutionContext context, Object... keys)`	Delete one or more keys.
`static Future<Long>`	`delAsync(String connectionName, GloopExecutionContext context, Object... keys)`	Asynchronously delete one or more keys.
`static byte[]`	`dump(String connectionName, GloopExecutionContext context, Object key)`	Return a serialized version of the value stored at the specified key.
`static Future<byte[]>`	`dumpAsync(String connectionName, Object key, GloopExecutionContext context)`	Asynchronously return a serialized version of the value stored at the specified key.
`static Long`	`exists(String connectionName, GloopExecutionContext context, Object... keys)`	Determine how many keys exist.
`static Future<Long>`	`existsAsync(String connectionName, GloopExecutionContext context, Object... keys)`	Asynchronously determine how many keys exist.
`static Boolean`	`expire(String connectionName, Object key, long seconds, GloopExecutionContext context)`	Set a key's time to live in seconds.
`static Future<Boolean>`	`expireAsync(String connectionName, Object key, long seconds, GloopExecutionContext context)`	Asynchronously set a key's time to live in seconds.
`static Boolean`	`expireat(String connectionName, Object key, long timestamp, GloopExecutionContext context)`	Set the expiration for a key as a UNIX timestamp.
`static Boolean`	`expireat(String connectionName, Object key, Date timestamp, GloopExecutionContext context)`	Set the expiration for a key as a UNIX timestamp.
`static Future<Boolean>`	`expireatAsync(String connectionName, Object key, long timestamp, GloopExecutionContext context)`	Asynchronously set the expiration for a key as a uNIX timestamp.
`static Future<Boolean>`	`expireatAsync(String connectionName, Object key, Date timestamp, GloopExecutionContext context)`	Asynchronously set the expiration for a key as a uNIX timestamp.
`static Long`	`keys(String connectionName, KeyStreamingChannel<Object> channel, Object pattern, GloopExecutionContext context)`	Find all keys matching the given pattern.
`static List<Object>`	`keys(String connectionName, Object pattern, GloopExecutionContext context)`	Find all keys matching the given pattern.
`static Future<Long>`	`keysAsync(String connectionName, KeyStreamingChannel<Object> channel, Object pattern, GloopExecutionContext context)`	Asynchronously find all keys matching the given pattern.
`static Future<List<Object>>`	`keysAsync(String connectionName, Object pattern, GloopExecutionContext context)`	Asynchronously find all keys matching the given pattern.
`static String`	`migrate(String connectionName, String host, int port, int db, long timeout, GloopModel migrateArgs, GloopExecutionContext context)`	Atomically transfer one or more keys from a Redis instance to another one.
`static String`	`migrate(String connectionName, String host, int port, Object key, int db, long timeout, GloopExecutionContext context)`	Atomically transfer a key from a Redis instance to another one.
`static Future<String>`	`migrateAsync(String connectionName, String host, int port, int db, long timeout, GloopModel migrateArgs, GloopExecutionContext context)`	Asynchronously atomically transfer one or more keys from a redis instance to another one.
`static Future<String>`	`migrateAsync(String connectionName, String host, int port, Object key, int db, long timeout, GloopExecutionContext context)`	Asynchronously atomically transfer a key from a redis instance to another one.
`static Boolean`	`move(String connectionName, Object key, int db, GloopExecutionContext context)`	Move a key to another database.
`static Future<Boolean>`	`moveAsync(String connectionName, Object key, int db, GloopExecutionContext context)`	Asynchronously move a key to another database.
`static String`	`objectEncoding(String connectionName, Object key, GloopExecutionContext context)`	returns the kind of internal representation used in order to store the value associated with a key.
`static Future<String>`	`objectEncodingAsync(String connectionName, Object key, GloopExecutionContext context)`	Asynchronously returns the kind of internal representation used in order to store the value associated with a key.
`static Long`	`objectIdletime(String connectionName, Object key, GloopExecutionContext context)`	returns the number of seconds since the object stored at the specified key is idle (not requested by read or write operations).
`static Future<Long>`	`objectIdletimeAsync(String connectionName, Object key, GloopExecutionContext context)`	Asynchronously returns the number of seconds since the object stored at the specified key is idle (not requested by read or write operations).
`static Long`	`objectRefcount(String connectionName, Object key, GloopExecutionContext context)`	returns the number of references of the value associated with the specified key.
`static Future<Long>`	`objectRefcountAsync(String connectionName, Object key, GloopExecutionContext context)`	Asynchronously returns the number of references of the value associated with the specified key.
`static Boolean`	`persist(String connectionName, Object key, GloopExecutionContext context)`	Remove the expiration from a key.
`static Future<Boolean>`	`persistAsync(String connectionName, Object key, GloopExecutionContext context)`	Asynchronously remove the expiration from a key.
`static Boolean`	`pexpire(String connectionName, Object key, long milliseconds, GloopExecutionContext context)`	Set a key's time to live in milliseconds.
`static Future<Boolean>`	`pexpireAsync(String connectionName, Object key, long milliseconds, GloopExecutionContext context)`	Asynchronously set a key's time to live in milliseconds.
`static Boolean`	`pexpireat(String connectionName, Object key, long timestamp, GloopExecutionContext context)`	Set the expiration for a key as a UNIX timestamp specified in milliseconds.
`static Boolean`	`pexpireat(String connectionName, Object key, Date timestamp, GloopExecutionContext context)`	Set the expiration for a key as a UNIX timestamp specified in milliseconds.
`static Future<Boolean>`	`pexpireatAsync(String connectionName, Object key, long timestamp, GloopExecutionContext context)`	Asynchronously set the expiration for a key as a uNIX timestamp specified in milliseconds.
`static Future<Boolean>`	`pexpireatAsync(String connectionName, Object key, Date timestamp, GloopExecutionContext context)`	Asynchronously set the expiration for a key as a uNIX timestamp specified in milliseconds.
`static Long`	`pttl(String connectionName, Object key, GloopExecutionContext context)`	Get the time to live for a key in milliseconds.
`static Future<Long>`	`pttlAsync(String connectionName, Object key, GloopExecutionContext context)`	Asynchronously get the time to live for a key in milliseconds.
`static Object`	`randomkey(String connectionName, GloopExecutionContext context)`	Return a random key from the keyspace.
`static Future<Object>`	`randomkeyAsync(String connectionName, GloopExecutionContext context)`	Asynchronously return a random key from the keyspace.
`static String`	`rename(String connectionName, Object key, Object newKey, GloopExecutionContext context)`	Rename a key.
`static Future<String>`	`renameAsync(String connectionName, Object key, Object newKey, GloopExecutionContext context)`	Asynchronously rename a key.
`static Boolean`	`renamenx(String connectionName, Object key, Object newKey, GloopExecutionContext context)`	Rename a key, only if the new key does not exist.
`static Future<Boolean>`	`renamenxAsync(String connectionName, Object key, Object newKey, GloopExecutionContext context)`	Asynchronously rename a key, only if the new key does not exist.
`static String`	`restore(String connectionName, Object key, long ttl, byte[] value, GloopExecutionContext context)`	Create a key using the provided serialized value, previously obtained using DUMP.
`static Future<String>`	`restoreAsync(String connectionName, Object key, long ttl, byte[] value, GloopExecutionContext context)`	Asynchronously create a key using the provided serialized value, previously obtained using dUMP.
`static StreamScanCursor`	`scan(String connectionName, KeyStreamingChannel<Object> channel, ScanCursor scanCursor, GloopExecutionContext context)`	Incrementally iterate the keys space.
`static StreamScanCursor`	`scan(String connectionName, KeyStreamingChannel<Object> channel, ScanCursor scanCursor, GloopModel scanArgs, GloopExecutionContext context)`	Incrementally iterate the keys space.
`static StreamScanCursor`	`scan(String connectionName, KeyStreamingChannel<Object> channel, GloopExecutionContext context)`	Incrementally iterate the keys space.
`static StreamScanCursor`	`scan(String connectionName, KeyStreamingChannel<Object> channel, GloopModel scanArgs, GloopExecutionContext context)`	Incrementally iterate the keys space.
`static KeyScanCursor<Object>`	`scan(String connectionName, ScanCursor scanCursor, GloopExecutionContext context)`	Incrementally iterate the keys space.
`static KeyScanCursor<Object>`	`scan(String connectionName, ScanCursor scanCursor, GloopModel scanArgs, GloopExecutionContext context)`	Incrementally iterate the keys space.
`static KeyScanCursor<Object>`	`scan(String connectionName, GloopExecutionContext context)`	Incrementally iterate the keys space.
`static KeyScanCursor<Object>`	`scan(String connectionName, GloopModel scanArgs, GloopExecutionContext context)`	Incrementally iterate the keys space.
`static Future<StreamScanCursor>`	`scanAsync(String connectionName, KeyStreamingChannel<Object> channel, ScanCursor scanCursor, GloopExecutionContext context)`	Asynchronously incrementally iterate the keys space.
`static Future<StreamScanCursor>`	`scanAsync(String connectionName, KeyStreamingChannel<Object> channel, ScanCursor scanCursor, GloopModel scanArgs, GloopExecutionContext context)`	Asynchronously incrementally iterate the keys space.
`static Future<StreamScanCursor>`	`scanAsync(String connectionName, KeyStreamingChannel<Object> channel, GloopExecutionContext context)`	Asynchronously incrementally iterate the keys space.
`static Future<StreamScanCursor>`	`scanAsync(String connectionName, KeyStreamingChannel<Object> channel, GloopModel scanArgs, GloopExecutionContext context)`	Asynchronously incrementally iterate the keys space.
`static Future<KeyScanCursor<Object>>`	`scanAsync(String connectionName, ScanCursor scanCursor, GloopExecutionContext context)`	Asynchronously incrementally iterate the keys space.
`static Future<KeyScanCursor<Object>>`	`scanAsync(String connectionName, ScanCursor scanCursor, GloopModel scanArgs, GloopExecutionContext context)`	Asynchronously incrementally iterate the keys space.
`static Future<KeyScanCursor<Object>>`	`scanAsync(String connectionName, GloopExecutionContext context)`	Asynchronously incrementally iterate the keys space.
`static Future<KeyScanCursor<Object>>`	`scanAsync(String connectionName, GloopModel scanArgs, GloopExecutionContext context)`	Asynchronously incrementally iterate the keys space.
`static Long`	`sort(String connectionName, ValueStreamingChannel<Object> channel, Object key, GloopExecutionContext context)`	Sort the elements in a list, set or sorted set.
`static Long`	`sort(String connectionName, ValueStreamingChannel<Object> channel, Object key, GloopModel sortArgs, GloopExecutionContext context)`	Sort the elements in a list, set or sorted set.
`static List<Object>`	`sort(String connectionName, Object key, GloopExecutionContext context)`	Sort the elements in a list, set or sorted set.
`static List<Object>`	`sort(String connectionName, Object key, GloopModel sortArgs, GloopExecutionContext context)`	Sort the elements in a list, set or sorted set.
`static Future<Long>`	`sortAsync(String connectionName, ValueStreamingChannel<Object> channel, Object key, GloopExecutionContext context)`	Asynchronously sort the elements in a list, set or sorted set.
`static Future<Long>`	`sortAsync(String connectionName, ValueStreamingChannel<Object> channel, Object key, GloopModel sortArgs, GloopExecutionContext context)`	Asynchronously sort the elements in a list, set or sorted set.
`static Future<List<Object>>`	`sortAsync(String connectionName, Object key, GloopExecutionContext context)`	Asynchronously sort the elements in a list, set or sorted set.
`static Future<List<Object>>`	`sortAsync(String connectionName, Object key, GloopModel sortArgs, GloopExecutionContext context)`	Asynchronously sort the elements in a list, set or sorted set.
`static Long`	`sortStore(String connectionName, Object key, GloopModel sortArgs, Object destination, GloopExecutionContext context)`	Sort the elements in a list, set or sorted set.
`static Future<Long>`	`sortStoreAsync(String connectionName, Object key, GloopModel sortArgs, Object destination, GloopExecutionContext context)`	Asynchronously sort the elements in a list, set or sorted set.
`static Long`	`touch(String connectionName, GloopExecutionContext context, Object... keys)`	Touch one or more keys.
`static Future<Long>`	`touchAsync(String connectionName, GloopExecutionContext context, Object... keys)`	Asynchronously touch one or more keys.
`static Long`	`ttl(String connectionName, Object key, GloopExecutionContext context)`	Get the time to live for a key.
`static Future<Long>`	`ttlAsync(String connectionName, Object key, GloopExecutionContext context)`	Asynchronously get the time to live for a key.
`static String`	`type(String connectionName, Object key, GloopExecutionContext context)`	Determine the type stored at key.
`static Future<String>`	`typeAsync(String connectionName, Object key, GloopExecutionContext context)`	Asynchronously determine the type stored at key.
`static Long`	`unlink(String connectionName, GloopExecutionContext context, Object... keys)`	Unlink one or more keys (non blocking DEL).
`static Future<Long>`	`unlinkAsync(String connectionName, GloopExecutionContext context, Object... keys)`	Asynchronously unlink one or more keys (non blocking dEL).

Methods inherited from class io.toro.martini.redis.RedisBaseMethods
getDataSourceManager, getRedisConnection, getRedisConnection

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail
- MIGRATE_ARGS_GLOOP_DOC
```
public static final String MIGRATE_ARGS_GLOOP_DOC
```
  See Also:
  
  Constant Field Values
- SORT_ARGS_GLOOP_DOC
```
public static final String SORT_ARGS_GLOOP_DOC
```
  See Also:
  
  Constant Field Values

Constructor Detail

RedisKeyMethods

@Autowired
RedisKeyMethods(io.toro.martini.database.DataSourceManager dataSourceManager)

Method Detail

del

@GloopParameter(name="redisDelOutput")
public static Long del(@GloopParameter(allowNull=false)
                       String connectionName,
                       GloopExecutionContext context,
                       @GloopParameter(allowNull=false)
                       Object... keys)

Delete one or more keys.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; keys - the keys
Returns:: Long integer-reply The number of keys that were removed.

delAsync

@GloopParameter(name="redisFutureDelOutput")
public static Future<Long> delAsync(@GloopParameter(allowNull=false)
                                    String connectionName,
                                    GloopExecutionContext context,
                                    @GloopParameter(allowNull=false)
                                    Object... keys)

Asynchronously delete one or more keys.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; keys - the keys
Returns:: long integer-reply the number of keys that were removed.

unlink

@GloopParameter(name="redisUnlinkOutput")
public static Long unlink(@GloopParameter(allowNull=false)
                          String connectionName,
                          GloopExecutionContext context,
                          @GloopParameter(allowNull=false)
                          Object... keys)

Unlink one or more keys (non blocking DEL).

Parameters:: connectionName - The Martini Runtime Redis connection pool name; keys - the keys
Returns:: Long integer-reply The number of keys that were removed.

unlinkAsync

@GloopParameter(name="redisFutureUnlinkOutput")
public static Future<Long> unlinkAsync(@GloopParameter(allowNull=false)
                                       String connectionName,
                                       GloopExecutionContext context,
                                       @GloopParameter(allowNull=false)
                                       Object... keys)

Asynchronously unlink one or more keys (non blocking dEL).

Parameters:: connectionName - The Martini Runtime Redis connection pool name; keys - the keys
Returns:: long integer-reply the number of keys that were removed.

dump

@GloopParameter(name="redisDumpOutput")
public static byte[] dump(@GloopParameter(allowNull=false)
                          String connectionName,
                          GloopExecutionContext context,
                          @GloopParameter(allowNull=false)
                          Object key)

Return a serialized version of the value stored at the specified key.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; key - the key
Returns:: byte[] bulk-string-reply the serialized value.

dumpAsync

@GloopParameter(name="redisFutureDumpOutput")
public static Future<byte[]> dumpAsync(@GloopParameter(allowNull=false)
                                       String connectionName,
                                       @GloopParameter(allowNull=false)
                                       Object key,
                                       GloopExecutionContext context)

Asynchronously return a serialized version of the value stored at the specified key.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; key - the key
Returns:: byte[] bulk-string-reply the serialized value.

exists

@GloopParameter(name="redisExistsOutput")
public static Long exists(@GloopParameter(allowNull=false)
                          String connectionName,
                          GloopExecutionContext context,
                          @GloopParameter(allowNull=false)
                          Object... keys)

Determine how many keys exist.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; keys - the keys
Returns:: Long integer-reply specifically: Number of existing keys

existsAsync

@GloopParameter(name="redisFutureExistsOutput")
public static Future<Long> existsAsync(@GloopParameter(allowNull=false)
                                       String connectionName,
                                       GloopExecutionContext context,
                                       @GloopParameter(allowNull=false)
                                       Object... keys)

Asynchronously determine how many keys exist.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; keys - the keys
Returns:: long integer-reply specifically: number of existing keys

expire

@GloopParameter(name="redisExpireOutput")
public static Boolean expire(@GloopParameter(allowNull=false)
                             String connectionName,
                             @GloopParameter(allowNull=false)
                             Object key,
                             @GloopParameter(allowNull=false)
                             long seconds,
                             GloopExecutionContext context)

Set a key's time to live in seconds.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; key - the key; seconds - the seconds type: long
Returns:: Boolean integer-reply specifically: true if the timeout was set. false if key does not exist or the timeout could not be set.

expireAsync

@GloopParameter(name="redisFutureExpireOutput")
public static Future<Boolean> expireAsync(@GloopParameter(allowNull=false)
                                          String connectionName,
                                          @GloopParameter(allowNull=false)
                                          Object key,
                                          @GloopParameter(allowNull=false)
                                          long seconds,
                                          GloopExecutionContext context)

Asynchronously set a key's time to live in seconds.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; key - the key; seconds - the seconds type: long
Returns:: boolean integer-reply specifically: true if the timeout was set. false if key does not exist or the timeout could not be set.

expireat

@GloopParameter(name="redisExpireatOutput")
public static Boolean expireat(@GloopParameter(allowNull=false)
                               String connectionName,
                               @GloopParameter(allowNull=false)
                               Object key,
                               @GloopParameter(allowNull=false)
                               Date timestamp,
                               GloopExecutionContext context)

Set the expiration for a key as a UNIX timestamp.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; key - the key; timestamp - the timestamp type: posix time
Returns:: Boolean integer-reply specifically: true if the timeout was set. false if key does not exist or the timeout could not be set (see: EXPIRE).

expireat

@GloopParameter(name="redisExpireatOutput")
public static Boolean expireat(@GloopParameter(allowNull=false)
                               String connectionName,
                               @GloopParameter(allowNull=false)
                               Object key,
                               @GloopParameter(allowNull=false)
                               long timestamp,
                               GloopExecutionContext context)

Set the expiration for a key as a UNIX timestamp.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; key - the key; timestamp - the timestamp type: posix time
Returns:: Boolean integer-reply specifically: true if the timeout was set. false if key does not exist or the timeout could not be set (see: EXPIRE).

expireatAsync

@GloopParameter(name="redisFutureExpireatOutput")
public static Future<Boolean> expireatAsync(@GloopParameter(allowNull=false)
                                            String connectionName,
                                            @GloopParameter(allowNull=false)
                                            Object key,
                                            @GloopParameter(allowNull=false)
                                            Date timestamp,
                                            GloopExecutionContext context)

Asynchronously set the expiration for a key as a uNIX timestamp.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; key - the key; timestamp - the timestamp type: posix time
Returns:: boolean integer-reply specifically: true if the timeout was set. false if key does not exist or the timeout could not be set (see: eXPIRE).

expireatAsync

@GloopParameter(name="redisFutureExpireatOutput")
public static Future<Boolean> expireatAsync(@GloopParameter(allowNull=false)
                                            String connectionName,
                                            @GloopParameter(allowNull=false)
                                            Object key,
                                            @GloopParameter(allowNull=false)
                                            long timestamp,
                                            GloopExecutionContext context)

Asynchronously set the expiration for a key as a uNIX timestamp.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; key - the key; timestamp - the timestamp type: posix time
Returns:: boolean integer-reply specifically: true if the timeout was set. false if key does not exist or the timeout could not be set (see: eXPIRE).

keys

@GloopParameter(name="redisKeysOutput")
public static List<Object> keys(@GloopParameter(allowNull=false)
                                String connectionName,
                                @GloopParameter(allowNull=false)
                                Object pattern,
                                GloopExecutionContext context)

Find all keys matching the given pattern.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; pattern - the pattern type: patternkey (pattern)
Returns:: List<K> array-reply list of keys matching pattern.

keys

@GloopParameter(name="redisKeysOutput")
public static Long keys(@GloopParameter(allowNull=false)
                        String connectionName,
                        @GloopParameter(allowNull=false)
                        KeyStreamingChannel<Object> channel,
                        @GloopParameter(allowNull=false)
                        Object pattern,
                        GloopExecutionContext context)

Find all keys matching the given pattern.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; channel - the channel; pattern - the pattern
Returns:: Long array-reply list of keys matching pattern.

keysAsync

@GloopParameter(name="redisFutureKeysOutput")
public static Future<List<Object>> keysAsync(@GloopParameter(allowNull=false)
                                             String connectionName,
                                             @GloopParameter(allowNull=false)
                                             Object pattern,
                                             GloopExecutionContext context)

Asynchronously find all keys matching the given pattern.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; pattern - the pattern type: patternkey (pattern)
Returns:: list<K> array-reply list of keys matching pattern.

keysAsync

@GloopParameter(name="redisFutureKeysOutput")
public static Future<Long> keysAsync(@GloopParameter(allowNull=false)
                                     String connectionName,
                                     @GloopParameter(allowNull=false)
                                     KeyStreamingChannel<Object> channel,
                                     @GloopParameter(allowNull=false)
                                     Object pattern,
                                     GloopExecutionContext context)

Asynchronously find all keys matching the given pattern.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; channel - the channel; pattern - the pattern
Returns:: long array-reply list of keys matching pattern.

migrate

@GloopParameter(name="redisMigrateOutput")
public static String migrate(@GloopParameter(allowNull=false)
                             String connectionName,
                             @GloopParameter(allowNull=false)
                             String host,
                             @GloopParameter(allowNull=false)
                             int port,
                             @GloopParameter(allowNull=false)
                             Object key,
                             @GloopParameter(allowNull=false)
                             int db,
                             @GloopParameter(allowNull=false)
                             long timeout,
                             GloopExecutionContext context)

Atomically transfer a key from a Redis instance to another one.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; host - the host; port - the port; key - the key; db - the database; timeout - the timeout in milliseconds
Returns:: String simple-string-reply The command returns OK on success.

migrate

@GloopParameter(name="redisMigrateOutput")
public static String migrate(@GloopParameter(allowNull=false)
                             String connectionName,
                             @GloopParameter(allowNull=false)
                             String host,
                             @GloopParameter(allowNull=false)
                             int port,
                             @GloopParameter(allowNull=false)
                             int db,
                             @GloopParameter(allowNull=false)
                             long timeout,
                             @GloopObjectParameter("migrateArgs{\n  copy:boolean:Do not remove the key from the local instance by setting {@code COPY}\n  replace:boolean:Replace existing key on the remote instance by setting {@code REPLACE}\n  keys[]:object:Migrate one or more {@code keys}:false\n  password::Creates new {@link MigrateArgs} with {@code AUTH} (target authentication) enabled:false\n}")
                             GloopModel migrateArgs,
                             GloopExecutionContext context)

Atomically transfer one or more keys from a Redis instance to another one.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; host - the host; port - the port; db - the database; timeout - the timeout in milliseconds; migrateArgs - migrate args that allow to configure further options
Returns:: String simple-string-reply The command returns OK on success.

migrateAsync

@GloopParameter(name="redisFutureMigrateOutput")
public static Future<String> migrateAsync(@GloopParameter(allowNull=false)
                                          String connectionName,
                                          @GloopParameter(allowNull=false)
                                          String host,
                                          @GloopParameter(allowNull=false)
                                          int port,
                                          @GloopParameter(allowNull=false)
                                          Object key,
                                          @GloopParameter(allowNull=false)
                                          int db,
                                          @GloopParameter(allowNull=false)
                                          long timeout,
                                          GloopExecutionContext context)

Asynchronously atomically transfer a key from a redis instance to another one.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; host - the host; port - the port; key - the key; db - the database; timeout - the timeout in milliseconds
Returns:: string simple-string-reply the command returns oK on success.

migrateAsync

@GloopParameter(name="redisFutureMigrateOutput")
public static Future<String> migrateAsync(@GloopParameter(allowNull=false)
                                          String connectionName,
                                          @GloopParameter(allowNull=false)
                                          String host,
                                          @GloopParameter(allowNull=false)
                                          int port,
                                          @GloopParameter(allowNull=false)
                                          int db,
                                          @GloopParameter(allowNull=false)
                                          long timeout,
                                          @GloopObjectParameter("migrateArgs{\n  copy:boolean:Do not remove the key from the local instance by setting {@code COPY}\n  replace:boolean:Replace existing key on the remote instance by setting {@code REPLACE}\n  keys[]:object:Migrate one or more {@code keys}:false\n  password::Creates new {@link MigrateArgs} with {@code AUTH} (target authentication) enabled:false\n}")
                                          GloopModel migrateArgs,
                                          GloopExecutionContext context)

Asynchronously atomically transfer one or more keys from a redis instance to another one.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; host - the host; port - the port; db - the database; timeout - the timeout in milliseconds; migrateArgs - migrate args that allow to configure further options
Returns:: string simple-string-reply the command returns oK on success.

move

@GloopParameter(name="redisMoveOutput")
public static Boolean move(@GloopParameter(allowNull=false)
                           String connectionName,
                           @GloopParameter(allowNull=false)
                           Object key,
                           @GloopParameter(allowNull=false)
                           int db,
                           GloopExecutionContext context)

Move a key to another database.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; key - the key; db - the db type: long
Returns:: Boolean integer-reply specifically:

moveAsync

@GloopParameter(name="redisFutureMoveOutput")
public static Future<Boolean> moveAsync(@GloopParameter(allowNull=false)
                                        String connectionName,
                                        @GloopParameter(allowNull=false)
                                        Object key,
                                        @GloopParameter(allowNull=false)
                                        int db,
                                        GloopExecutionContext context)

Asynchronously move a key to another database.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; key - the key; db - the db type: long
Returns:: boolean integer-reply specifically:

objectEncoding

@GloopParameter(name="redisObjectEncodingOutput")
public static String objectEncoding(@GloopParameter(allowNull=false)
                                    String connectionName,
                                    @GloopParameter(allowNull=false)
                                    Object key,
                                    GloopExecutionContext context)

returns the kind of internal representation used in order to store the value associated with a key.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; key - the key
Returns:: String

objectEncodingAsync

@GloopParameter(name="redisFutureObjectEncodingOutput")
public static Future<String> objectEncodingAsync(@GloopParameter(allowNull=false)
                                                 String connectionName,
                                                 @GloopParameter(allowNull=false)
                                                 Object key,
                                                 GloopExecutionContext context)

Asynchronously returns the kind of internal representation used in order to store the value associated with a key.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; key - the key
Returns:: string

objectIdletime

@GloopParameter(name="redisObjectIdletimeOutput")
public static Long objectIdletime(@GloopParameter(allowNull=false)
                                  String connectionName,
                                  @GloopParameter(allowNull=false)
                                  Object key,
                                  GloopExecutionContext context)

returns the number of seconds since the object stored at the specified key is idle (not requested by read or write operations).

Parameters:: connectionName - The Martini Runtime Redis connection pool name; key - the key
Returns:: number of seconds since the object stored at the specified key is idle.

objectIdletimeAsync

@GloopParameter(name="redisFutureObjectIdletimeOutput")
public static Future<Long> objectIdletimeAsync(@GloopParameter(allowNull=false)
                                               String connectionName,
                                               @GloopParameter(allowNull=false)
                                               Object key,
                                               GloopExecutionContext context)

Asynchronously returns the number of seconds since the object stored at the specified key is idle (not requested by read or write operations).

Parameters:: connectionName - The Martini Runtime Redis connection pool name; key - the key
Returns:: number of seconds since the object stored at the specified key is idle.

objectRefcount

@GloopParameter(name="redisObjectRefcountOutput")
public static Long objectRefcount(@GloopParameter(allowNull=false)
                                  String connectionName,
                                  @GloopParameter(allowNull=false)
                                  Object key,
                                  GloopExecutionContext context)

returns the number of references of the value associated with the specified key.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; key - the key
Returns:: Long

objectRefcountAsync

@GloopParameter(name="redisFutureObjectRefcountOutput")
public static Future<Long> objectRefcountAsync(@GloopParameter(allowNull=false)
                                               String connectionName,
                                               @GloopParameter(allowNull=false)
                                               Object key,
                                               GloopExecutionContext context)

Asynchronously returns the number of references of the value associated with the specified key.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; key - the key
Returns:: long

persist

@GloopParameter(name="redisPersistOutput")
public static Boolean persist(@GloopParameter(allowNull=false)
                              String connectionName,
                              @GloopParameter(allowNull=false)
                              Object key,
                              GloopExecutionContext context)

Remove the expiration from a key.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; key - the key
Returns:: Boolean integer-reply specifically: true if the timeout was removed. false if key does not exist or does not have an associated timeout.

persistAsync

@GloopParameter(name="redisFuturePersistOutput")
public static Future<Boolean> persistAsync(@GloopParameter(allowNull=false)
                                           String connectionName,
                                           @GloopParameter(allowNull=false)
                                           Object key,
                                           GloopExecutionContext context)

Asynchronously remove the expiration from a key.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; key - the key
Returns:: boolean integer-reply specifically: true if the timeout was removed. false if key does not exist or does not have an associated timeout.

pexpire

@GloopParameter(name="redisPexpireOutput")
public static Boolean pexpire(@GloopParameter(allowNull=false)
                              String connectionName,
                              @GloopParameter(allowNull=false)
                              Object key,
                              @GloopParameter(allowNull=false)
                              long milliseconds,
                              GloopExecutionContext context)

Set a key's time to live in milliseconds.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; key - the key; milliseconds - the milliseconds type: long
Returns:: integer-reply, specifically: true if the timeout was set. false if key does not exist or the timeout could not be set.

pexpireAsync

@GloopParameter(name="redisFuturePexpireOutput")
public static Future<Boolean> pexpireAsync(@GloopParameter(allowNull=false)
                                           String connectionName,
                                           @GloopParameter(allowNull=false)
                                           Object key,
                                           @GloopParameter(allowNull=false)
                                           long milliseconds,
                                           GloopExecutionContext context)

Asynchronously set a key's time to live in milliseconds.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; key - the key; milliseconds - the milliseconds type: long
Returns:: integer-reply, specifically: true if the timeout was set. false if key does not exist or the timeout could not be set.

pexpireat

@GloopParameter(name="redisPexpireatOutput")
public static Boolean pexpireat(@GloopParameter(allowNull=false)
                                String connectionName,
                                @GloopParameter(allowNull=false)
                                Object key,
                                @GloopParameter(allowNull=false)
                                Date timestamp,
                                GloopExecutionContext context)

Set the expiration for a key as a UNIX timestamp specified in milliseconds.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; key - the key; timestamp - the milliseconds-timestamp type: posix time
Returns:: Boolean integer-reply specifically: true if the timeout was set. false if key does not exist or the timeout could not be set (see: EXPIRE).

pexpireat

@GloopParameter(name="redisPexpireatOutput")
public static Boolean pexpireat(@GloopParameter(allowNull=false)
                                String connectionName,
                                @GloopParameter(allowNull=false)
                                Object key,
                                @GloopParameter(allowNull=false)
                                long timestamp,
                                GloopExecutionContext context)

Set the expiration for a key as a UNIX timestamp specified in milliseconds.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; key - the key; timestamp - the milliseconds-timestamp type: posix time
Returns:: Boolean integer-reply specifically: true if the timeout was set. false if key does not exist or the timeout could not be set (see: EXPIRE).

pexpireatAsync

@GloopParameter(name="redisFuturePexpireatOutput")
public static Future<Boolean> pexpireatAsync(@GloopParameter(allowNull=false)
                                             String connectionName,
                                             @GloopParameter(allowNull=false)
                                             Object key,
                                             @GloopParameter(allowNull=false)
                                             Date timestamp,
                                             GloopExecutionContext context)

Asynchronously set the expiration for a key as a uNIX timestamp specified in milliseconds.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; key - the key; timestamp - the milliseconds-timestamp type: posix time
Returns:: boolean integer-reply specifically: true if the timeout was set. false if key does not exist or the timeout could not be set (see: eXPIRE).

pexpireatAsync

@GloopParameter(name="redisFuturePexpireatOutput")
public static Future<Boolean> pexpireatAsync(@GloopParameter(allowNull=false)
                                             String connectionName,
                                             @GloopParameter(allowNull=false)
                                             Object key,
                                             @GloopParameter(allowNull=false)
                                             long timestamp,
                                             GloopExecutionContext context)

Asynchronously set the expiration for a key as a uNIX timestamp specified in milliseconds.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; key - the key; timestamp - the milliseconds-timestamp type: posix time
Returns:: boolean integer-reply specifically: true if the timeout was set. false if key does not exist or the timeout could not be set (see: eXPIRE).

pttl

@GloopParameter(name="redisPttlOutput")
public static Long pttl(@GloopParameter(allowNull=false)
                        String connectionName,
                        @GloopParameter(allowNull=false)
                        Object key,
                        GloopExecutionContext context)

Get the time to live for a key in milliseconds.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; key - the key
Returns:: Long integer-reply TTL in milliseconds, or a negative value in order to signal an error (see the description above).

pttlAsync

@GloopParameter(name="redisFuturePttlOutput")
public static Future<Long> pttlAsync(@GloopParameter(allowNull=false)
                                     String connectionName,
                                     @GloopParameter(allowNull=false)
                                     Object key,
                                     GloopExecutionContext context)

Asynchronously get the time to live for a key in milliseconds.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; key - the key
Returns:: long integer-reply tTL in milliseconds, or a negative value in order to signal an error (see the description above).

randomkey

@GloopParameter(name="redisRandomkeyOutput")
public static Object randomkey(@GloopParameter(allowNull=false)
                               String connectionName,
                               GloopExecutionContext context)

Return a random key from the keyspace.

Parameters:: connectionName - The Martini Runtime Redis connection pool name
Returns:: V bulk-string-reply the random key, or null when the database is empty.

randomkeyAsync

@GloopParameter(name="redisFutureRandomkeyOutput")
public static Future<Object> randomkeyAsync(@GloopParameter(allowNull=false)
                                            String connectionName,
                                            GloopExecutionContext context)

Asynchronously return a random key from the keyspace.

Parameters:: connectionName - The Martini Runtime Redis connection pool name
Returns:: v bulk-string-reply the random key, or null when the database is empty.

rename

@GloopParameter(name="redisRenameOutput")
public static String rename(@GloopParameter(allowNull=false)
                            String connectionName,
                            @GloopParameter(allowNull=false)
                            Object key,
                            @GloopParameter(allowNull=false)
                            Object newKey,
                            GloopExecutionContext context)

Rename a key.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; key - the key; newKey - the newkey type: key
Returns:: String simple-string-reply

renameAsync

@GloopParameter(name="redisFutureRenameOutput")
public static Future<String> renameAsync(@GloopParameter(allowNull=false)
                                         String connectionName,
                                         @GloopParameter(allowNull=false)
                                         Object key,
                                         @GloopParameter(allowNull=false)
                                         Object newKey,
                                         GloopExecutionContext context)

Asynchronously rename a key.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; key - the key; newKey - the newkey type: key
Returns:: string simple-string-reply

renamenx

@GloopParameter(name="redisRenamenxOutput")
public static Boolean renamenx(@GloopParameter(allowNull=false)
                               String connectionName,
                               @GloopParameter(allowNull=false)
                               Object key,
                               @GloopParameter(allowNull=false)
                               Object newKey,
                               GloopExecutionContext context)

Rename a key, only if the new key does not exist.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; key - the key; newKey - the newkey type: key
Returns:: Boolean integer-reply specifically: true if key was renamed to newkey. false if newkey already exists.

renamenxAsync

@GloopParameter(name="redisFutureRenamenxOutput")
public static Future<Boolean> renamenxAsync(@GloopParameter(allowNull=false)
                                            String connectionName,
                                            @GloopParameter(allowNull=false)
                                            Object key,
                                            @GloopParameter(allowNull=false)
                                            Object newKey,
                                            GloopExecutionContext context)

Asynchronously rename a key, only if the new key does not exist.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; key - the key; newKey - the newkey type: key
Returns:: boolean integer-reply specifically: true if key was renamed to newkey. false if newkey already exists.

restore

@GloopParameter(name="redisRestoreOutput")
public static String restore(@GloopParameter(allowNull=false)
                             String connectionName,
                             @GloopParameter(allowNull=false)
                             Object key,
                             @GloopParameter(allowNull=false)
                             long ttl,
                             @GloopParameter(allowNull=false)
                             byte[] value,
                             GloopExecutionContext context)

Create a key using the provided serialized value, previously obtained using DUMP.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; key - the key; ttl - the ttl type: long; value - the serialized-value type: string
Returns:: String simple-string-reply The command returns OK on success.

restoreAsync

@GloopParameter(name="redisFutureRestoreOutput")
public static Future<String> restoreAsync(@GloopParameter(allowNull=false)
                                          String connectionName,
                                          @GloopParameter(allowNull=false)
                                          Object key,
                                          @GloopParameter(allowNull=false)
                                          long ttl,
                                          @GloopParameter(allowNull=false)
                                          byte[] value,
                                          GloopExecutionContext context)

Asynchronously create a key using the provided serialized value, previously obtained using dUMP.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; key - the key; ttl - the ttl type: long; value - the serialized-value type: string
Returns:: string simple-string-reply the command returns oK on success.

sort

@GloopParameter(name="redisSortOutput")
public static List<Object> sort(@GloopParameter(allowNull=false)
                                String connectionName,
                                @GloopParameter(allowNull=false)
                                Object key,
                                GloopExecutionContext context)

Sort the elements in a list, set or sorted set.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; key - the key
Returns:: List<V> array-reply list of sorted elements.

sort

@GloopParameter(name="redisSortOutput")
public static Long sort(@GloopParameter(allowNull=false)
                        String connectionName,
                        @GloopParameter(allowNull=false)
                        ValueStreamingChannel<Object> channel,
                        @GloopParameter(allowNull=false)
                        Object key,
                        GloopExecutionContext context)

Sort the elements in a list, set or sorted set.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; channel - streaming channel that receives a call for every value; key - the key
Returns:: Long number of values.

sort

@GloopParameter(name="redisSortOutput")
public static List<Object> sort(@GloopParameter(allowNull=false)
                                String connectionName,
                                @GloopParameter(allowNull=false)
                                Object key,
                                @GloopObjectParameter("sortArgs{\n  by::Sort keys by an external list. Key names are obtained substituting the first occurrence of {@code *} with the actual value of the element in the list.\n  limit:Limit the number of returned elements{\n    offset:long\n    count:long\n  }\n  get[]::Retrieve external keys during sort. {@literal GET} supports {@code #} and {@code *} wildcards\n  asc:boolean:Apply numeric sort in ascending order\n  alpha:boolean:Apply lexicographically sort\n}")
                                GloopModel sortArgs,
                                GloopExecutionContext context)

Sort the elements in a list, set or sorted set.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; key - the key; sortArgs - sort arguments
Returns:: List<V> array-reply list of sorted elements.

sort

@GloopParameter(name="redisSortOutput")
public static Long sort(@GloopParameter(allowNull=false)
                        String connectionName,
                        @GloopParameter(allowNull=false)
                        ValueStreamingChannel<Object> channel,
                        @GloopParameter(allowNull=false)
                        Object key,
                        @GloopObjectParameter("sortArgs{\n  by::Sort keys by an external list. Key names are obtained substituting the first occurrence of {@code *} with the actual value of the element in the list.\n  limit:Limit the number of returned elements{\n    offset:long\n    count:long\n  }\n  get[]::Retrieve external keys during sort. {@literal GET} supports {@code #} and {@code *} wildcards\n  asc:boolean:Apply numeric sort in ascending order\n  alpha:boolean:Apply lexicographically sort\n}")
                        GloopModel sortArgs,
                        GloopExecutionContext context)

Sort the elements in a list, set or sorted set.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; channel - streaming channel that receives a call for every value; key - the key; sortArgs - sort arguments
Returns:: Long number of values.

sortAsync

@GloopParameter(name="redisFutureSortOutput")
public static Future<List<Object>> sortAsync(@GloopParameter(allowNull=false)
                                             String connectionName,
                                             @GloopParameter(allowNull=false)
                                             Object key,
                                             GloopExecutionContext context)

Asynchronously sort the elements in a list, set or sorted set.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; key - the key
Returns:: list<V> array-reply list of sorted elements.

sortAsync

@GloopParameter(name="redisFutureSortOutput")
public static Future<Long> sortAsync(@GloopParameter(allowNull=false)
                                     String connectionName,
                                     @GloopParameter(allowNull=false)
                                     ValueStreamingChannel<Object> channel,
                                     @GloopParameter(allowNull=false)
                                     Object key,
                                     GloopExecutionContext context)

Asynchronously sort the elements in a list, set or sorted set.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; channel - streaming channel that receives a call for every value; key - the key
Returns:: long number of values.

sortAsync

@GloopParameter(name="redisFutureSortOutput")
public static Future<List<Object>> sortAsync(@GloopParameter(allowNull=false)
                                             String connectionName,
                                             @GloopParameter(allowNull=false)
                                             Object key,
                                             @GloopObjectParameter("sortArgs{\n  by::Sort keys by an external list. Key names are obtained substituting the first occurrence of {@code *} with the actual value of the element in the list.\n  limit:Limit the number of returned elements{\n    offset:long\n    count:long\n  }\n  get[]::Retrieve external keys during sort. {@literal GET} supports {@code #} and {@code *} wildcards\n  asc:boolean:Apply numeric sort in ascending order\n  alpha:boolean:Apply lexicographically sort\n}")
                                             GloopModel sortArgs,
                                             GloopExecutionContext context)

Asynchronously sort the elements in a list, set or sorted set.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; key - the key; sortArgs - sort arguments
Returns:: list<V> array-reply list of sorted elements.

sortAsync

@GloopParameter(name="redisFutureSortOutput")
public static Future<Long> sortAsync(@GloopParameter(allowNull=false)
                                     String connectionName,
                                     @GloopParameter(allowNull=false)
                                     ValueStreamingChannel<Object> channel,
                                     @GloopParameter(allowNull=false)
                                     Object key,
                                     @GloopObjectParameter("sortArgs{\n  by::Sort keys by an external list. Key names are obtained substituting the first occurrence of {@code *} with the actual value of the element in the list.\n  limit:Limit the number of returned elements{\n    offset:long\n    count:long\n  }\n  get[]::Retrieve external keys during sort. {@literal GET} supports {@code #} and {@code *} wildcards\n  asc:boolean:Apply numeric sort in ascending order\n  alpha:boolean:Apply lexicographically sort\n}")
                                     GloopModel sortArgs,
                                     GloopExecutionContext context)

Asynchronously sort the elements in a list, set or sorted set.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; channel - streaming channel that receives a call for every value; key - the key; sortArgs - sort arguments
Returns:: long number of values.

sortStore

@GloopParameter(name="redisSortStoreOutput")
public static Long sortStore(@GloopParameter(allowNull=false)
                             String connectionName,
                             @GloopParameter(allowNull=false)
                             Object key,
                             @GloopObjectParameter("sortArgs{\n  by::Sort keys by an external list. Key names are obtained substituting the first occurrence of {@code *} with the actual value of the element in the list.\n  limit:Limit the number of returned elements{\n    offset:long\n    count:long\n  }\n  get[]::Retrieve external keys during sort. {@literal GET} supports {@code #} and {@code *} wildcards\n  asc:boolean:Apply numeric sort in ascending order\n  alpha:boolean:Apply lexicographically sort\n}")
                             GloopModel sortArgs,
                             @GloopParameter(allowNull=false)
                             Object destination,
                             GloopExecutionContext context)

Sort the elements in a list, set or sorted set.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; key - the key; sortArgs - sort arguments; destination - the destination key to store sort results
Returns:: Long number of values.

sortStoreAsync

@GloopParameter(name="redisFutureSortStoreOutput")
public static Future<Long> sortStoreAsync(@GloopParameter(allowNull=false)
                                          String connectionName,
                                          @GloopParameter(allowNull=false)
                                          Object key,
                                          @GloopObjectParameter("sortArgs{\n  by::Sort keys by an external list. Key names are obtained substituting the first occurrence of {@code *} with the actual value of the element in the list.\n  limit:Limit the number of returned elements{\n    offset:long\n    count:long\n  }\n  get[]::Retrieve external keys during sort. {@literal GET} supports {@code #} and {@code *} wildcards\n  asc:boolean:Apply numeric sort in ascending order\n  alpha:boolean:Apply lexicographically sort\n}")
                                          GloopModel sortArgs,
                                          @GloopParameter(allowNull=false)
                                          Object destination,
                                          GloopExecutionContext context)

Asynchronously sort the elements in a list, set or sorted set.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; key - the key; sortArgs - sort arguments; destination - the destination key to store sort results
Returns:: long number of values.

touch

@GloopParameter(name="redisTouchOutput")
public static Long touch(@GloopParameter(allowNull=false)
                         String connectionName,
                         GloopExecutionContext context,
                         @GloopParameter(allowNull=false)
                         Object... keys)

Touch one or more keys. Touch sets the last accessed time for a key. Non-existent keys wont get created.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; keys - the keys
Returns:: Long integer-reply the number of found keys.

touchAsync

@GloopParameter(name="redisFutureTouchOutput")
public static Future<Long> touchAsync(@GloopParameter(allowNull=false)
                                      String connectionName,
                                      GloopExecutionContext context,
                                      @GloopParameter(allowNull=false)
                                      Object... keys)

Asynchronously touch one or more keys. touch sets the last accessed time for a key. non-existent keys wont get created.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; keys - the keys
Returns:: long integer-reply the number of found keys.

ttl

@GloopParameter(name="redisTtlOutput")
public static Long ttl(@GloopParameter(allowNull=false)
                       String connectionName,
                       @GloopParameter(allowNull=false)
                       Object key,
                       GloopExecutionContext context)

Get the time to live for a key.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; key - the key
Returns:: Long integer-reply TTL in seconds, or a negative value in order to signal an error (see the description above).

ttlAsync

@GloopParameter(name="redisFutureTtlOutput")
public static Future<Long> ttlAsync(@GloopParameter(allowNull=false)
                                    String connectionName,
                                    @GloopParameter(allowNull=false)
                                    Object key,
                                    GloopExecutionContext context)

Asynchronously get the time to live for a key.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; key - the key
Returns:: long integer-reply tTL in seconds, or a negative value in order to signal an error (see the description above).

type

@GloopParameter(name="redisTypeOutput")
public static String type(@GloopParameter(allowNull=false)
                          String connectionName,
                          @GloopParameter(allowNull=false)
                          Object key,
                          GloopExecutionContext context)

Determine the type stored at key.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; key - the key
Returns:: String simple-string-reply type of key, or none when key does not exist.

typeAsync

@GloopParameter(name="redisFutureTypeOutput")
public static Future<String> typeAsync(@GloopParameter(allowNull=false)
                                       String connectionName,
                                       @GloopParameter(allowNull=false)
                                       Object key,
                                       GloopExecutionContext context)

Asynchronously determine the type stored at key.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; key - the key
Returns:: string simple-string-reply type of key, or none when key does not exist.

scan

@GloopParameter(name="redisScanOutput")
public static KeyScanCursor<Object> scan(@GloopParameter(allowNull=false)
                                         String connectionName,
                                         GloopExecutionContext context)

Incrementally iterate the keys space.

Parameters:: connectionName - The Martini Runtime Redis connection pool name
Returns:: KeyScanCursor<K> scan cursor.

scan

@GloopParameter(name="redisScanOutput")
public static KeyScanCursor<Object> scan(@GloopParameter(allowNull=false)
                                         String connectionName,
                                         @GloopObjectParameter("scanArgs{\n  limit:long:Limit the scan by count:false\n match::Set the match filter:false\n}\n")
                                         GloopModel scanArgs,
                                         GloopExecutionContext context)

Incrementally iterate the keys space.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; scanArgs - scan arguments
Returns:: KeyScanCursor<K> scan cursor.

scan

@GloopParameter(name="redisScanOutput")
public static KeyScanCursor<Object> scan(@GloopParameter(allowNull=false)
                                         String connectionName,
                                         @GloopParameter(allowNull=false)
                                         ScanCursor scanCursor,
                                         @GloopObjectParameter("scanArgs{\n  limit:long:Limit the scan by count:false\n match::Set the match filter:false\n}\n")
                                         GloopModel scanArgs,
                                         GloopExecutionContext context)

Incrementally iterate the keys space.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; scanCursor - cursor to resume from a previous scan, must not be null; scanArgs - scan arguments
Returns:: KeyScanCursor<K> scan cursor.

scan

@GloopParameter(name="redisScanOutput")
public static StreamScanCursor scan(@GloopParameter(allowNull=false)
                                    String connectionName,
                                    @GloopParameter(allowNull=false)
                                    KeyStreamingChannel<Object> channel,
                                    GloopExecutionContext context)

Incrementally iterate the keys space.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; channel - streaming channel that receives a call for every key
Returns:: StreamScanCursor scan cursor.

scan

@GloopParameter(name="redisScanOutput")
public static StreamScanCursor scan(@GloopParameter(allowNull=false)
                                    String connectionName,
                                    @GloopParameter(allowNull=false)
                                    KeyStreamingChannel<Object> channel,
                                    @GloopObjectParameter("scanArgs{\n  limit:long:Limit the scan by count:false\n match::Set the match filter:false\n}\n")
                                    GloopModel scanArgs,
                                    GloopExecutionContext context)

Incrementally iterate the keys space.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; channel - streaming channel that receives a call for every key; scanArgs - scan arguments
Returns:: StreamScanCursor scan cursor.

scan

@GloopParameter(name="redisScanOutput")
public static StreamScanCursor scan(@GloopParameter(allowNull=false)
                                    String connectionName,
                                    @GloopParameter(allowNull=false)
                                    KeyStreamingChannel<Object> channel,
                                    @GloopParameter(allowNull=false)
                                    ScanCursor scanCursor,
                                    @GloopObjectParameter("scanArgs{\n  limit:long:Limit the scan by count:false\n match::Set the match filter:false\n}\n")
                                    GloopModel scanArgs,
                                    GloopExecutionContext context)

Incrementally iterate the keys space.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; channel - streaming channel that receives a call for every key; scanCursor - cursor to resume from a previous scan, must not be null; scanArgs - scan arguments
Returns:: StreamScanCursor scan cursor.

scan

@GloopParameter(name="redisScanOutput")
public static StreamScanCursor scan(@GloopParameter(allowNull=false)
                                    String connectionName,
                                    @GloopParameter(allowNull=false)
                                    KeyStreamingChannel<Object> channel,
                                    @GloopParameter(allowNull=false)
                                    ScanCursor scanCursor,
                                    GloopExecutionContext context)

Incrementally iterate the keys space.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; channel - streaming channel that receives a call for every key; scanCursor - cursor to resume from a previous scan, must not be null
Returns:: StreamScanCursor scan cursor.

scan

@GloopParameter(name="redisScanOutput")
public static KeyScanCursor<Object> scan(@GloopParameter(allowNull=false)
                                         String connectionName,
                                         @GloopParameter(allowNull=false)
                                         ScanCursor scanCursor,
                                         GloopExecutionContext context)

Incrementally iterate the keys space.

Parameters:: connectionName - The Martini Runtime Redis connection pool name; scanCursor - cursor to resume from a previous scan, must not be null
Returns:: KeyScanCursor<K> scan cursor.