redis.clients.jedis.UnifiedJedis Maven / Gradle / Ivy
Show all versions of jedis_preview Show documentation
package redis.clients.jedis;
import java.net.URI;
import java.time.Duration;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.regex.Pattern;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import org.json.JSONArray;
import redis.clients.jedis.args.*;
import redis.clients.jedis.bloom.*;
import redis.clients.jedis.commands.JedisCommands;
import redis.clients.jedis.commands.JedisBinaryCommands;
import redis.clients.jedis.commands.ProtocolCommand;
import redis.clients.jedis.commands.SampleBinaryKeyedCommands;
import redis.clients.jedis.commands.SampleKeyedCommands;
import redis.clients.jedis.commands.RedisModuleCommands;
import redis.clients.jedis.exceptions.JedisException;
import redis.clients.jedis.executors.*;
import redis.clients.jedis.gears.TFunctionListParams;
import redis.clients.jedis.gears.TFunctionLoadParams;
import redis.clients.jedis.gears.resps.GearsLibraryInfo;
import redis.clients.jedis.graph.GraphCommandObjects;
import redis.clients.jedis.graph.ResultSet;
import redis.clients.jedis.json.JsonSetParams;
import redis.clients.jedis.json.Path;
import redis.clients.jedis.json.Path2;
import redis.clients.jedis.json.JsonObjectMapper;
import redis.clients.jedis.mcf.CircuitBreakerCommandExecutor;
import redis.clients.jedis.mcf.MultiClusterPipeline;
import redis.clients.jedis.mcf.MultiClusterTransaction;
import redis.clients.jedis.params.*;
import redis.clients.jedis.providers.*;
import redis.clients.jedis.resps.*;
import redis.clients.jedis.search.*;
import redis.clients.jedis.search.aggr.AggregationBuilder;
import redis.clients.jedis.search.aggr.AggregationResult;
import redis.clients.jedis.search.aggr.FtAggregateIteration;
import redis.clients.jedis.search.schemafields.SchemaField;
import redis.clients.jedis.timeseries.*;
import redis.clients.jedis.util.IOUtils;
import redis.clients.jedis.util.JedisURIHelper;
import redis.clients.jedis.util.KeyValue;
public class UnifiedJedis implements JedisCommands, JedisBinaryCommands,
SampleKeyedCommands, SampleBinaryKeyedCommands, RedisModuleCommands,
AutoCloseable {
@Deprecated protected RedisProtocol protocol = null;
private final ClientSideCache clientSideCache;
protected final ConnectionProvider provider;
protected final CommandExecutor executor;
protected final CommandObjects commandObjects;
private final GraphCommandObjects graphCommandObjects;
private JedisBroadcastAndRoundRobinConfig broadcastAndRoundRobinConfig = null;
public UnifiedJedis() {
this(new HostAndPort(Protocol.DEFAULT_HOST, Protocol.DEFAULT_PORT));
}
public UnifiedJedis(HostAndPort hostAndPort) {
this(new PooledConnectionProvider(hostAndPort), (RedisProtocol) null);
}
public UnifiedJedis(final String url) {
this(URI.create(url));
}
public UnifiedJedis(final URI uri) {
this(JedisURIHelper.getHostAndPort(uri), DefaultJedisClientConfig.builder()
.user(JedisURIHelper.getUser(uri)).password(JedisURIHelper.getPassword(uri))
.database(JedisURIHelper.getDBIndex(uri)).protocol(JedisURIHelper.getRedisProtocol(uri))
.ssl(JedisURIHelper.isRedisSSLScheme(uri)).build(), JedisURIHelper.getClientSideCache(uri));
}
public UnifiedJedis(final URI uri, JedisClientConfig config) {
this(JedisURIHelper.getHostAndPort(uri), DefaultJedisClientConfig.builder()
.connectionTimeoutMillis(config.getConnectionTimeoutMillis())
.socketTimeoutMillis(config.getSocketTimeoutMillis())
.blockingSocketTimeoutMillis(config.getBlockingSocketTimeoutMillis())
.user(JedisURIHelper.getUser(uri)).password(JedisURIHelper.getPassword(uri))
.database(JedisURIHelper.getDBIndex(uri)).clientName(config.getClientName())
.protocol(JedisURIHelper.getRedisProtocol(uri))
.ssl(JedisURIHelper.isRedisSSLScheme(uri)).sslSocketFactory(config.getSslSocketFactory())
.sslParameters(config.getSslParameters()).hostnameVerifier(config.getHostnameVerifier())
.build(), JedisURIHelper.getClientSideCache(uri));
}
public UnifiedJedis(HostAndPort hostAndPort, JedisClientConfig clientConfig) {
this(new PooledConnectionProvider(hostAndPort, clientConfig), clientConfig.getRedisProtocol());
}
public UnifiedJedis(HostAndPort hostAndPort, JedisClientConfig clientConfig, ClientSideCache clientSideCache) {
this(new PooledConnectionProvider(hostAndPort, clientConfig, clientSideCache), clientConfig.getRedisProtocol(), clientSideCache);
}
public UnifiedJedis(ConnectionProvider provider) {
this(new DefaultCommandExecutor(provider), provider);
}
protected UnifiedJedis(ConnectionProvider provider, RedisProtocol protocol) {
this(new DefaultCommandExecutor(provider), provider, new CommandObjects(), protocol);
}
protected UnifiedJedis(ConnectionProvider provider, RedisProtocol protocol, ClientSideCache clientSideCache) {
this(new DefaultCommandExecutor(provider), provider, new CommandObjects(), protocol, clientSideCache);
}
/**
* The constructor to directly use a custom {@link JedisSocketFactory}.
*
* WARNING: Using this constructor means a {@link NullPointerException} will be occurred if
* {@link UnifiedJedis#provider} is accessed.
*/
public UnifiedJedis(JedisSocketFactory socketFactory) {
this(new Connection(socketFactory));
}
/**
* The constructor to directly use a custom {@link JedisSocketFactory}.
*
* WARNING: Using this constructor means a {@link NullPointerException} will be occurred if
* {@link UnifiedJedis#provider} is accessed.
*/
public UnifiedJedis(JedisSocketFactory socketFactory, JedisClientConfig clientConfig) {
this(new Connection(socketFactory, clientConfig));
}
/**
* The constructor to directly use a {@link Connection}.
*
* WARNING: Using this constructor means a {@link NullPointerException} will be occurred if
* {@link UnifiedJedis#provider} is accessed.
*/
public UnifiedJedis(Connection connection) {
this.provider = null;
this.executor = new SimpleCommandExecutor(connection);
this.commandObjects = new CommandObjects();
RedisProtocol proto = connection.getRedisProtocol();
if (proto != null) this.commandObjects.setProtocol(proto);
this.graphCommandObjects = new GraphCommandObjects(this);
this.clientSideCache = null; // TODO:
}
@Deprecated
public UnifiedJedis(Set jedisClusterNodes, JedisClientConfig clientConfig, int maxAttempts) {
this(jedisClusterNodes, clientConfig, maxAttempts, Duration.ofMillis(maxAttempts * clientConfig.getSocketTimeoutMillis()));
}
@Deprecated
public UnifiedJedis(Set jedisClusterNodes, JedisClientConfig clientConfig, int maxAttempts,
Duration maxTotalRetriesDuration) {
this(new ClusterConnectionProvider(jedisClusterNodes, clientConfig), maxAttempts, maxTotalRetriesDuration,
clientConfig.getRedisProtocol());
}
@Deprecated
public UnifiedJedis(Set jedisClusterNodes, JedisClientConfig clientConfig,
GenericObjectPoolConfig poolConfig, int maxAttempts, Duration maxTotalRetriesDuration) {
this(new ClusterConnectionProvider(jedisClusterNodes, clientConfig, poolConfig), maxAttempts,
maxTotalRetriesDuration, clientConfig.getRedisProtocol());
}
// Uses a fetched connection to process protocol. Should be avoided if possible.
public UnifiedJedis(ClusterConnectionProvider provider, int maxAttempts, Duration maxTotalRetriesDuration) {
this(new ClusterCommandExecutor(provider, maxAttempts, maxTotalRetriesDuration), provider,
new ClusterCommandObjects());
}
protected UnifiedJedis(ClusterConnectionProvider provider, int maxAttempts, Duration maxTotalRetriesDuration,
RedisProtocol protocol) {
this(new ClusterCommandExecutor(provider, maxAttempts, maxTotalRetriesDuration), provider,
new ClusterCommandObjects(), protocol);
}
protected UnifiedJedis(ClusterConnectionProvider provider, int maxAttempts, Duration maxTotalRetriesDuration,
RedisProtocol protocol, ClientSideCache clientSideCache) {
this(new ClusterCommandExecutor(provider, maxAttempts, maxTotalRetriesDuration), provider,
new ClusterCommandObjects(), protocol, clientSideCache);
}
/**
* @deprecated Sharding/Sharded feature will be removed in next major release.
*/
@Deprecated
public UnifiedJedis(ShardedConnectionProvider provider) {
this(new DefaultCommandExecutor(provider), provider, new ShardedCommandObjects(provider.getHashingAlgo()));
}
/**
* @deprecated Sharding/Sharded feature will be removed in next major release.
*/
@Deprecated
public UnifiedJedis(ShardedConnectionProvider provider, Pattern tagPattern) {
this(new DefaultCommandExecutor(provider), provider, new ShardedCommandObjects(provider.getHashingAlgo(), tagPattern));
}
public UnifiedJedis(ConnectionProvider provider, int maxAttempts, Duration maxTotalRetriesDuration) {
this(new RetryableCommandExecutor(provider, maxAttempts, maxTotalRetriesDuration), provider);
}
/**
* Constructor which supports multiple cluster/database endpoints each with their own isolated connection pool.
*
* With this Constructor users can seamlessly failover to Disaster Recovery (DR), Backup, and Active-Active cluster(s)
* by using simple configuration which is passed through from Resilience4j - https://resilience4j.readme.io/docs
*
*/
public UnifiedJedis(MultiClusterPooledConnectionProvider provider) {
this(new CircuitBreakerCommandExecutor(provider), provider);
}
/**
* The constructor to use a custom {@link CommandExecutor}.
*
* WARNING: Using this constructor means a {@link NullPointerException} will be occurred if
* {@link UnifiedJedis#provider} is accessed.
*/
public UnifiedJedis(CommandExecutor executor) {
this(executor, (ConnectionProvider) null);
}
private UnifiedJedis(CommandExecutor executor, ConnectionProvider provider) {
this(executor, provider, new CommandObjects());
}
// Uses a fetched connection to process protocol. Should be avoided if possible.
private UnifiedJedis(CommandExecutor executor, ConnectionProvider provider, CommandObjects commandObjects) {
this(executor, provider, commandObjects, null, null);
if (this.provider != null) {
try (Connection conn = this.provider.getConnection()) {
if (conn != null) {
RedisProtocol proto = conn.getRedisProtocol();
if (proto != null) this.commandObjects.setProtocol(proto);
}
} catch (JedisException je) { }
}
}
private UnifiedJedis(CommandExecutor executor, ConnectionProvider provider, CommandObjects commandObjects,
RedisProtocol protocol) {
this(executor, provider, commandObjects, protocol, (ClientSideCache) null);
}
private UnifiedJedis(CommandExecutor executor, ConnectionProvider provider, CommandObjects commandObjects,
RedisProtocol protocol, ClientSideCache clientSideCache) {
if (clientSideCache != null && protocol != RedisProtocol.RESP3) {
throw new IllegalArgumentException("Client-side caching is only supported with RESP3.");
}
this.provider = provider;
this.executor = executor;
this.commandObjects = commandObjects;
if (protocol != null) this.commandObjects.setProtocol(protocol);
this.graphCommandObjects = new GraphCommandObjects(this);
this.graphCommandObjects.setBaseCommandArgumentsCreator((comm) -> this.commandObjects.commandArguments(comm));
this.clientSideCache = clientSideCache;
}
@Override
public void close() {
IOUtils.closeQuietly(this.executor);
}
@Deprecated
protected final void setProtocol(RedisProtocol protocol) {
this.protocol = protocol;
this.commandObjects.setProtocol(this.protocol);
}
public final T executeCommand(CommandObject commandObject) {
return executor.executeCommand(commandObject);
}
public final T broadcastCommand(CommandObject commandObject) {
return executor.broadcastCommand(commandObject);
}
private T checkAndBroadcastCommand(CommandObject commandObject) {
boolean broadcast = true;
if (broadcastAndRoundRobinConfig == null) {
} else if (commandObject.getArguments().getCommand() instanceof SearchProtocol.SearchCommand
&& broadcastAndRoundRobinConfig.getRediSearchModeInCluster() == JedisBroadcastAndRoundRobinConfig.RediSearchMode.LIGHT) {
broadcast = false;
}
return broadcast ? broadcastCommand(commandObject) : executeCommand(commandObject);
}
public void setBroadcastAndRoundRobinConfig(JedisBroadcastAndRoundRobinConfig config) {
this.broadcastAndRoundRobinConfig = config;
this.commandObjects.setBroadcastAndRoundRobinConfig(this.broadcastAndRoundRobinConfig);
}
private T checkAndClientSideCacheCommand(CommandObject command, Object... keys) {
if (clientSideCache == null) {
return executeCommand(command);
}
return clientSideCache.getValue((cmd) -> executeCommand(cmd), command, keys);
}
public String ping() {
return checkAndBroadcastCommand(commandObjects.ping());
}
public String flushDB() {
return checkAndBroadcastCommand(commandObjects.flushDB());
}
public String flushAll() {
return checkAndBroadcastCommand(commandObjects.flushAll());
}
public String configSet(String parameter, String value) {
return checkAndBroadcastCommand(commandObjects.configSet(parameter, value));
}
// Key commands
@Override
public boolean exists(String key) {
return checkAndClientSideCacheCommand(commandObjects.exists(key), key);
}
@Override
public long exists(String... keys) {
return checkAndClientSideCacheCommand(commandObjects.exists(keys), (Object[]) keys);
}
@Override
public long persist(String key) {
return executeCommand(commandObjects.persist(key));
}
@Override
public String type(String key) {
return checkAndClientSideCacheCommand(commandObjects.type(key), key);
}
@Override
public boolean exists(byte[] key) {
return checkAndClientSideCacheCommand(commandObjects.exists(key), key);
}
@Override
public long exists(byte[]... keys) {
return checkAndClientSideCacheCommand(commandObjects.exists(keys), (Object[]) keys);
}
@Override
public long persist(byte[] key) {
return executeCommand(commandObjects.persist(key));
}
@Override
public String type(byte[] key) {
return checkAndClientSideCacheCommand(commandObjects.type(key), key);
}
@Override
public byte[] dump(String key) {
return executeCommand(commandObjects.dump(key));
}
@Override
public String restore(String key, long ttl, byte[] serializedValue) {
return executeCommand(commandObjects.restore(key, ttl, serializedValue));
}
@Override
public String restore(String key, long ttl, byte[] serializedValue, RestoreParams params) {
return executeCommand(commandObjects.restore(key, ttl, serializedValue, params));
}
@Override
public byte[] dump(byte[] key) {
return executeCommand(commandObjects.dump(key));
}
@Override
public String restore(byte[] key, long ttl, byte[] serializedValue) {
return executeCommand(commandObjects.restore(key, ttl, serializedValue));
}
@Override
public String restore(byte[] key, long ttl, byte[] serializedValue, RestoreParams params) {
return executeCommand(commandObjects.restore(key, ttl, serializedValue, params));
}
@Override
public long expire(String key, long seconds) {
return executeCommand(commandObjects.expire(key, seconds));
}
@Override
public long expire(String key, long seconds, ExpiryOption expiryOption) {
return executeCommand(commandObjects.expire(key, seconds, expiryOption));
}
@Override
public long pexpire(String key, long milliseconds) {
return executeCommand(commandObjects.pexpire(key, milliseconds));
}
@Override
public long pexpire(String key, long milliseconds, ExpiryOption expiryOption) {
return executeCommand(commandObjects.pexpire(key, milliseconds, expiryOption));
}
@Override
public long expireTime(String key) {
return executeCommand(commandObjects.expireTime(key));
}
@Override
public long pexpireTime(String key) {
return executeCommand(commandObjects.pexpireTime(key));
}
@Override
public long expireAt(String key, long unixTime) {
return executeCommand(commandObjects.expireAt(key, unixTime));
}
@Override
public long expireAt(String key, long unixTime, ExpiryOption expiryOption) {
return executeCommand(commandObjects.expireAt(key, unixTime, expiryOption));
}
@Override
public long pexpireAt(String key, long millisecondsTimestamp) {
return executeCommand(commandObjects.pexpireAt(key, millisecondsTimestamp));
}
@Override
public long pexpireAt(String key, long millisecondsTimestamp, ExpiryOption expiryOption) {
return executeCommand(commandObjects.pexpireAt(key, millisecondsTimestamp, expiryOption));
}
@Override
public long expire(byte[] key, long seconds) {
return executeCommand(commandObjects.expire(key, seconds));
}
@Override
public long expire(byte[] key, long seconds, ExpiryOption expiryOption) {
return executeCommand(commandObjects.expire(key, seconds, expiryOption));
}
@Override
public long pexpire(byte[] key, long milliseconds) {
return executeCommand(commandObjects.pexpire(key, milliseconds));
}
@Override
public long pexpire(byte[] key, long milliseconds, ExpiryOption expiryOption) {
return executeCommand(commandObjects.pexpire(key, milliseconds, expiryOption));
}
@Override
public long expireTime(byte[] key) {
return executeCommand(commandObjects.expireTime(key));
}
@Override
public long pexpireTime(byte[] key) {
return executeCommand(commandObjects.pexpireTime(key));
}
@Override
public long expireAt(byte[] key, long unixTime) {
return executeCommand(commandObjects.expireAt(key, unixTime));
}
@Override
public long expireAt(byte[] key, long unixTime, ExpiryOption expiryOption) {
return executeCommand(commandObjects.expireAt(key, unixTime, expiryOption));
}
@Override
public long pexpireAt(byte[] key, long millisecondsTimestamp) {
return executeCommand(commandObjects.pexpireAt(key, millisecondsTimestamp));
}
@Override
public long pexpireAt(byte[] key, long millisecondsTimestamp, ExpiryOption expiryOption) {
return executeCommand(commandObjects.expireAt(key, millisecondsTimestamp, expiryOption));
}
@Override
public long ttl(String key) {
return executeCommand(commandObjects.ttl(key));
}
@Override
public long pttl(String key) {
return executeCommand(commandObjects.pttl(key));
}
@Override
public long touch(String key) {
return executeCommand(commandObjects.touch(key));
}
@Override
public long touch(String... keys) {
return executeCommand(commandObjects.touch(keys));
}
@Override
public long ttl(byte[] key) {
return executeCommand(commandObjects.ttl(key));
}
@Override
public long pttl(byte[] key) {
return executeCommand(commandObjects.pttl(key));
}
@Override
public long touch(byte[] key) {
return executeCommand(commandObjects.touch(key));
}
@Override
public long touch(byte[]... keys) {
return executeCommand(commandObjects.touch(keys));
}
@Override
public List sort(String key) {
return executeCommand(commandObjects.sort(key));
}
@Override
public List sort(String key, SortingParams sortingParams) {
return executeCommand(commandObjects.sort(key, sortingParams));
}
@Override
public long sort(String key, String dstkey) {
return executeCommand(commandObjects.sort(key, dstkey));
}
@Override
public long sort(String key, SortingParams sortingParams, String dstkey) {
return executeCommand(commandObjects.sort(key, sortingParams, dstkey));
}
@Override
public List sortReadonly(String key, SortingParams sortingParams) {
return executeCommand(commandObjects.sortReadonly(key, sortingParams));
}
@Override
public List sort(byte[] key) {
return executeCommand(commandObjects.sort(key));
}
@Override
public List sort(byte[] key, SortingParams sortingParams) {
return executeCommand(commandObjects.sort(key, sortingParams));
}
@Override
public long sort(byte[] key, byte[] dstkey) {
return executeCommand(commandObjects.sort(key, dstkey));
}
@Override
public List sortReadonly(byte[] key, SortingParams sortingParams) {
return executeCommand(commandObjects.sortReadonly(key, sortingParams));
}
@Override
public long sort(byte[] key, SortingParams sortingParams, byte[] dstkey) {
return executeCommand(commandObjects.sort(key, sortingParams, dstkey));
}
@Override
public long del(String key) {
return executeCommand(commandObjects.del(key));
}
@Override
public long del(String... keys) {
return executeCommand(commandObjects.del(keys));
}
@Override
public long unlink(String key) {
return executeCommand(commandObjects.unlink(key));
}
@Override
public long unlink(String... keys) {
return executeCommand(commandObjects.unlink(keys));
}
@Override
public long del(byte[] key) {
return executeCommand(commandObjects.del(key));
}
@Override
public long del(byte[]... keys) {
return executeCommand(commandObjects.del(keys));
}
@Override
public long unlink(byte[] key) {
return executeCommand(commandObjects.unlink(key));
}
@Override
public long unlink(byte[]... keys) {
return executeCommand(commandObjects.unlink(keys));
}
@Override
public Long memoryUsage(String key) {
return executeCommand(commandObjects.memoryUsage(key));
}
@Override
public Long memoryUsage(String key, int samples) {
return executeCommand(commandObjects.memoryUsage(key, samples));
}
@Override
public Long memoryUsage(byte[] key) {
return executeCommand(commandObjects.memoryUsage(key));
}
@Override
public Long memoryUsage(byte[] key, int samples) {
return executeCommand(commandObjects.memoryUsage(key, samples));
}
@Override
public boolean copy(String srcKey, String dstKey, boolean replace) {
return executeCommand(commandObjects.copy(srcKey, dstKey, replace));
}
@Override
public String rename(String oldkey, String newkey) {
return executeCommand(commandObjects.rename(oldkey, newkey));
}
@Override
public long renamenx(String oldkey, String newkey) {
return executeCommand(commandObjects.renamenx(oldkey, newkey));
}
@Override
public boolean copy(byte[] srcKey, byte[] dstKey, boolean replace) {
return executeCommand(commandObjects.copy(srcKey, dstKey, replace));
}
@Override
public String rename(byte[] oldkey, byte[] newkey) {
return executeCommand(commandObjects.rename(oldkey, newkey));
}
@Override
public long renamenx(byte[] oldkey, byte[] newkey) {
return executeCommand(commandObjects.renamenx(oldkey, newkey));
}
public long dbSize() {
return executeCommand(commandObjects.dbSize());
}
@Override
public Set keys(String pattern) {
return executeCommand(commandObjects.keys(pattern));
}
@Override
public ScanResult scan(String cursor) {
return executeCommand(commandObjects.scan(cursor));
}
@Override
public ScanResult scan(String cursor, ScanParams params) {
return executeCommand(commandObjects.scan(cursor, params));
}
@Override
public ScanResult scan(String cursor, ScanParams params, String type) {
return executeCommand(commandObjects.scan(cursor, params, type));
}
/**
* @param batchCount COUNT for each batch execution
* @param match pattern
* @return scan iteration
*/
public ScanIteration scanIteration(int batchCount, String match) {
return new ScanIteration(provider, batchCount, match);
}
/**
* @param batchCount COUNT for each batch execution
* @param match pattern
* @param type key type
* @return scan iteration
*/
public ScanIteration scanIteration(int batchCount, String match, String type) {
return new ScanIteration(provider, batchCount, match, type);
}
@Override
public Set keys(byte[] pattern) {
return executeCommand(commandObjects.keys(pattern));
}
@Override
public ScanResult scan(byte[] cursor) {
return executeCommand(commandObjects.scan(cursor));
}
@Override
public ScanResult scan(byte[] cursor, ScanParams params) {
return executeCommand(commandObjects.scan(cursor, params));
}
@Override
public ScanResult scan(byte[] cursor, ScanParams params, byte[] type) {
return executeCommand(commandObjects.scan(cursor, params, type));
}
@Override
public String randomKey() {
return executeCommand(commandObjects.randomKey());
}
@Override
public byte[] randomBinaryKey() {
return executeCommand(commandObjects.randomBinaryKey());
}
// Key commands
// String commands
@Override
public String set(String key, String value) {
return executeCommand(commandObjects.set(key, value));
}
@Override
public String set(String key, String value, SetParams params) {
return executeCommand(commandObjects.set(key, value, params));
}
@Override
public String get(String key) {
return checkAndClientSideCacheCommand(commandObjects.get(key), key);
}
@Override
public String setGet(String key, String value) {
return executeCommand(commandObjects.setGet(key, value));
}
@Override
public String setGet(String key, String value, SetParams params) {
return executeCommand(commandObjects.setGet(key, value, params));
}
@Override
public String getDel(String key) {
return executeCommand(commandObjects.getDel(key));
}
@Override
public String getEx(String key, GetExParams params) {
return executeCommand(commandObjects.getEx(key, params));
}
@Override
public String set(byte[] key, byte[] value) {
return executeCommand(commandObjects.set(key, value));
}
@Override
public String set(byte[] key, byte[] value, SetParams params) {
return executeCommand(commandObjects.set(key, value, params));
}
@Override
public byte[] get(byte[] key) {
return checkAndClientSideCacheCommand(commandObjects.get(key), key);
}
@Override
public byte[] setGet(byte[] key, byte[] value) {
return executeCommand(commandObjects.setGet(key, value));
}
@Override
public byte[] setGet(byte[] key, byte[] value, SetParams params) {
return executeCommand(commandObjects.setGet(key, value, params));
}
@Override
public byte[] getDel(byte[] key) {
return executeCommand(commandObjects.getDel(key));
}
@Override
public byte[] getEx(byte[] key, GetExParams params) {
return executeCommand(commandObjects.getEx(key, params));
}
@Override
public boolean setbit(String key, long offset, boolean value) {
return executeCommand(commandObjects.setbit(key, offset, value));
}
@Override
public boolean getbit(String key, long offset) {
return checkAndClientSideCacheCommand(commandObjects.getbit(key, offset), key);
}
@Override
public long setrange(String key, long offset, String value) {
return executeCommand(commandObjects.setrange(key, offset, value));
}
@Override
public String getrange(String key, long startOffset, long endOffset) {
return checkAndClientSideCacheCommand(commandObjects.getrange(key, startOffset, endOffset), key);
}
@Override
public boolean setbit(byte[] key, long offset, boolean value) {
return executeCommand(commandObjects.setbit(key, offset, value));
}
@Override
public boolean getbit(byte[] key, long offset) {
return checkAndClientSideCacheCommand(commandObjects.getbit(key, offset), key);
}
@Override
public long setrange(byte[] key, long offset, byte[] value) {
return executeCommand(commandObjects.setrange(key, offset, value));
}
@Override
public byte[] getrange(byte[] key, long startOffset, long endOffset) {
return checkAndClientSideCacheCommand(commandObjects.getrange(key, startOffset, endOffset), key);
}
@Override
public String getSet(String key, String value) {
return executeCommand(commandObjects.getSet(key, value));
}
@Override
public long setnx(String key, String value) {
return executeCommand(commandObjects.setnx(key, value));
}
@Override
public String setex(String key, long seconds, String value) {
return executeCommand(commandObjects.setex(key, seconds, value));
}
@Override
public String psetex(String key, long milliseconds, String value) {
return executeCommand(commandObjects.psetex(key, milliseconds, value));
}
@Override
public byte[] getSet(byte[] key, byte[] value) {
return executeCommand(commandObjects.getSet(key, value));
}
@Override
public long setnx(byte[] key, byte[] value) {
return executeCommand(commandObjects.setnx(key, value));
}
@Override
public String setex(byte[] key, long seconds, byte[] value) {
return executeCommand(commandObjects.setex(key, seconds, value));
}
@Override
public String psetex(byte[] key, long milliseconds, byte[] value) {
return executeCommand(commandObjects.psetex(key, milliseconds, value));
}
@Override
public long incr(String key) {
return executeCommand(commandObjects.incr(key));
}
@Override
public long incrBy(String key, long increment) {
return executeCommand(commandObjects.incrBy(key, increment));
}
@Override
public double incrByFloat(String key, double increment) {
return executeCommand(commandObjects.incrByFloat(key, increment));
}
@Override
public long decr(String key) {
return executeCommand(commandObjects.decr(key));
}
@Override
public long decrBy(String key, long decrement) {
return executeCommand(commandObjects.decrBy(key, decrement));
}
@Override
public long incr(byte[] key) {
return executeCommand(commandObjects.incr(key));
}
@Override
public long incrBy(byte[] key, long increment) {
return executeCommand(commandObjects.incrBy(key, increment));
}
@Override
public double incrByFloat(byte[] key, double increment) {
return executeCommand(commandObjects.incrByFloat(key, increment));
}
@Override
public long decr(byte[] key) {
return executeCommand(commandObjects.decr(key));
}
@Override
public long decrBy(byte[] key, long decrement) {
return executeCommand(commandObjects.decrBy(key, decrement));
}
@Override
public List mget(String... keys) {
return checkAndClientSideCacheCommand(commandObjects.mget(keys), (Object[]) keys);
}
@Override
public String mset(String... keysvalues) {
return executeCommand(commandObjects.mset(keysvalues));
}
@Override
public long msetnx(String... keysvalues) {
return executeCommand(commandObjects.msetnx(keysvalues));
}
@Override
public List mget(byte[]... keys) {
return checkAndClientSideCacheCommand(commandObjects.mget(keys), (Object[]) keys);
}
@Override
public String mset(byte[]... keysvalues) {
return executeCommand(commandObjects.mset(keysvalues));
}
@Override
public long msetnx(byte[]... keysvalues) {
return executeCommand(commandObjects.msetnx(keysvalues));
}
@Override
public long append(String key, String value) {
return executeCommand(commandObjects.append(key, value));
}
@Override
public String substr(String key, int start, int end) {
return checkAndClientSideCacheCommand(commandObjects.substr(key, start, end), key);
}
@Override
public long strlen(String key) {
return checkAndClientSideCacheCommand(commandObjects.strlen(key), key);
}
@Override
public long append(byte[] key, byte[] value) {
return executeCommand(commandObjects.append(key, value));
}
@Override
public byte[] substr(byte[] key, int start, int end) {
return checkAndClientSideCacheCommand(commandObjects.substr(key, start, end), key);
}
@Override
public long strlen(byte[] key) {
return checkAndClientSideCacheCommand(commandObjects.strlen(key), key);
}
@Override
public long bitcount(String key) {
return checkAndClientSideCacheCommand(commandObjects.bitcount(key), key);
}
@Override
public long bitcount(String key, long start, long end) {
return checkAndClientSideCacheCommand(commandObjects.bitcount(key, start, end), key);
}
@Override
public long bitcount(String key, long start, long end, BitCountOption option) {
return checkAndClientSideCacheCommand(commandObjects.bitcount(key, start, end, option), key);
}
@Override
public long bitpos(String key, boolean value) {
return checkAndClientSideCacheCommand(commandObjects.bitpos(key, value), key);
}
@Override
public long bitpos(String key, boolean value, BitPosParams params) {
return checkAndClientSideCacheCommand(commandObjects.bitpos(key, value, params), key);
}
@Override
public long bitcount(byte[] key) {
return checkAndClientSideCacheCommand(commandObjects.bitcount(key), key);
}
@Override
public long bitcount(byte[] key, long start, long end) {
return checkAndClientSideCacheCommand(commandObjects.bitcount(key, start, end), key);
}
@Override
public long bitcount(byte[] key, long start, long end, BitCountOption option) {
return checkAndClientSideCacheCommand(commandObjects.bitcount(key, start, end, option), key);
}
@Override
public long bitpos(byte[] key, boolean value) {
return checkAndClientSideCacheCommand(commandObjects.bitpos(key, value), key);
}
@Override
public long bitpos(byte[] key, boolean value, BitPosParams params) {
return checkAndClientSideCacheCommand(commandObjects.bitpos(key, value, params), key);
}
@Override
public List bitfield(String key, String... arguments) {
return executeCommand(commandObjects.bitfield(key, arguments));
}
@Override
public List bitfieldReadonly(String key, String... arguments) {
return checkAndClientSideCacheCommand(commandObjects.bitfieldReadonly(key, arguments), key);
}
@Override
public List bitfield(byte[] key, byte[]... arguments) {
return executeCommand(commandObjects.bitfield(key, arguments));
}
@Override
public List bitfieldReadonly(byte[] key, byte[]... arguments) {
return checkAndClientSideCacheCommand(commandObjects.bitfieldReadonly(key, arguments), key);
}
@Override
public long bitop(BitOP op, String destKey, String... srcKeys) {
return executeCommand(commandObjects.bitop(op, destKey, srcKeys));
}
@Override
public long bitop(BitOP op, byte[] destKey, byte[]... srcKeys) {
return executeCommand(commandObjects.bitop(op, destKey, srcKeys));
}
@Override
public LCSMatchResult lcs(String keyA, String keyB, LCSParams params) {
return checkAndClientSideCacheCommand(commandObjects.lcs(keyA, keyB, params), keyA, keyB);
}
@Override
public LCSMatchResult lcs(byte[] keyA, byte[] keyB, LCSParams params) {
return checkAndClientSideCacheCommand(commandObjects.lcs(keyA, keyB, params), keyA, keyB);
}
// String commands
// List commands
@Override
public long rpush(String key, String... string) {
return executeCommand(commandObjects.rpush(key, string));
}
@Override
public long lpush(String key, String... string) {
return executeCommand(commandObjects.lpush(key, string));
}
@Override
public long llen(String key) {
return checkAndClientSideCacheCommand(commandObjects.llen(key), key);
}
@Override
public List lrange(String key, long start, long stop) {
return checkAndClientSideCacheCommand(commandObjects.lrange(key, start, stop), key);
}
@Override
public String ltrim(String key, long start, long stop) {
return executeCommand(commandObjects.ltrim(key, start, stop));
}
@Override
public String lindex(String key, long index) {
return checkAndClientSideCacheCommand(commandObjects.lindex(key, index), key);
}
@Override
public long rpush(byte[] key, byte[]... args) {
return executeCommand(commandObjects.rpush(key, args));
}
@Override
public long lpush(byte[] key, byte[]... args) {
return executeCommand(commandObjects.lpush(key, args));
}
@Override
public long llen(byte[] key) {
return checkAndClientSideCacheCommand(commandObjects.llen(key), key);
}
@Override
public List lrange(byte[] key, long start, long stop) {
return checkAndClientSideCacheCommand(commandObjects.lrange(key, start, stop), key);
}
@Override
public String ltrim(byte[] key, long start, long stop) {
return executeCommand(commandObjects.ltrim(key, start, stop));
}
@Override
public byte[] lindex(byte[] key, long index) {
return checkAndClientSideCacheCommand(commandObjects.lindex(key, index), key);
}
@Override
public String lset(String key, long index, String value) {
return executeCommand(commandObjects.lset(key, index, value));
}
@Override
public long lrem(String key, long count, String value) {
return executeCommand(commandObjects.lrem(key, count, value));
}
@Override
public String lpop(String key) {
return executeCommand(commandObjects.lpop(key));
}
@Override
public List lpop(String key, int count) {
return executeCommand(commandObjects.lpop(key, count));
}
@Override
public String lset(byte[] key, long index, byte[] value) {
return executeCommand(commandObjects.lset(key, index, value));
}
@Override
public long lrem(byte[] key, long count, byte[] value) {
return executeCommand(commandObjects.lrem(key, count, value));
}
@Override
public byte[] lpop(byte[] key) {
return executeCommand(commandObjects.lpop(key));
}
@Override
public List lpop(byte[] key, int count) {
return executeCommand(commandObjects.lpop(key, count));
}
@Override
public Long lpos(String key, String element) {
return checkAndClientSideCacheCommand(commandObjects.lpos(key, element), key);
}
@Override
public Long lpos(String key, String element, LPosParams params) {
return checkAndClientSideCacheCommand(commandObjects.lpos(key, element, params), key);
}
@Override
public List lpos(String key, String element, LPosParams params, long count) {
return checkAndClientSideCacheCommand(commandObjects.lpos(key, element, params, count), key);
}
@Override
public Long lpos(byte[] key, byte[] element) {
return checkAndClientSideCacheCommand(commandObjects.lpos(key, element), key);
}
@Override
public Long lpos(byte[] key, byte[] element, LPosParams params) {
return checkAndClientSideCacheCommand(commandObjects.lpos(key, element, params), key);
}
@Override
public List lpos(byte[] key, byte[] element, LPosParams params, long count) {
return checkAndClientSideCacheCommand(commandObjects.lpos(key, element, params, count), key);
}
@Override
public String rpop(String key) {
return executeCommand(commandObjects.rpop(key));
}
@Override
public List rpop(String key, int count) {
return executeCommand(commandObjects.rpop(key, count));
}
@Override
public byte[] rpop(byte[] key) {
return executeCommand(commandObjects.rpop(key));
}
@Override
public List rpop(byte[] key, int count) {
return executeCommand(commandObjects.rpop(key, count));
}
@Override
public long linsert(String key, ListPosition where, String pivot, String value) {
return executeCommand(commandObjects.linsert(key, where, pivot, value));
}
@Override
public long lpushx(String key, String... strings) {
return executeCommand(commandObjects.lpushx(key, strings));
}
@Override
public long rpushx(String key, String... strings) {
return executeCommand(commandObjects.rpushx(key, strings));
}
@Override
public long linsert(byte[] key, ListPosition where, byte[] pivot, byte[] value) {
return executeCommand(commandObjects.linsert(key, where, pivot, value));
}
@Override
public long lpushx(byte[] key, byte[]... args) {
return executeCommand(commandObjects.lpushx(key, args));
}
@Override
public long rpushx(byte[] key, byte[]... args) {
return executeCommand(commandObjects.rpushx(key, args));
}
@Override
public List blpop(int timeout, String key) {
return executeCommand(commandObjects.blpop(timeout, key));
}
@Override
public KeyValue blpop(double timeout, String key) {
return executeCommand(commandObjects.blpop(timeout, key));
}
@Override
public List brpop(int timeout, String key) {
return executeCommand(commandObjects.brpop(timeout, key));
}
@Override
public KeyValue brpop(double timeout, String key) {
return executeCommand(commandObjects.brpop(timeout, key));
}
@Override
public List blpop(int timeout, String... keys) {
return executeCommand(commandObjects.blpop(timeout, keys));
}
@Override
public KeyValue blpop(double timeout, String... keys) {
return executeCommand(commandObjects.blpop(timeout, keys));
}
@Override
public List brpop(int timeout, String... keys) {
return executeCommand(commandObjects.brpop(timeout, keys));
}
@Override
public KeyValue brpop(double timeout, String... keys) {
return executeCommand(commandObjects.brpop(timeout, keys));
}
@Override
public List blpop(int timeout, byte[]... keys) {
return executeCommand(commandObjects.blpop(timeout, keys));
}
@Override
public KeyValue blpop(double timeout, byte[]... keys) {
return executeCommand(commandObjects.blpop(timeout, keys));
}
@Override
public List brpop(int timeout, byte[]... keys) {
return executeCommand(commandObjects.brpop(timeout, keys));
}
@Override
public KeyValue brpop(double timeout, byte[]... keys) {
return executeCommand(commandObjects.brpop(timeout, keys));
}
@Override
public String rpoplpush(String srckey, String dstkey) {
return executeCommand(commandObjects.rpoplpush(srckey, dstkey));
}
@Override
public String brpoplpush(String source, String destination, int timeout) {
return executeCommand(commandObjects.brpoplpush(source, destination, timeout));
}
@Override
public byte[] rpoplpush(byte[] srckey, byte[] dstkey) {
return executeCommand(commandObjects.rpoplpush(srckey, dstkey));
}
@Override
public byte[] brpoplpush(byte[] source, byte[] destination, int timeout) {
return executeCommand(commandObjects.brpoplpush(source, destination, timeout));
}
@Override
public String lmove(String srcKey, String dstKey, ListDirection from, ListDirection to) {
return executeCommand(commandObjects.lmove(srcKey, dstKey, from, to));
}
@Override
public String blmove(String srcKey, String dstKey, ListDirection from, ListDirection to, double timeout) {
return executeCommand(commandObjects.blmove(srcKey, dstKey, from, to, timeout));
}
@Override
public byte[] lmove(byte[] srcKey, byte[] dstKey, ListDirection from, ListDirection to) {
return executeCommand(commandObjects.lmove(srcKey, dstKey, from, to));
}
@Override
public byte[] blmove(byte[] srcKey, byte[] dstKey, ListDirection from, ListDirection to, double timeout) {
return executeCommand(commandObjects.blmove(srcKey, dstKey, from, to, timeout));
}
@Override
public KeyValue> lmpop(ListDirection direction, String... keys) {
return executeCommand(commandObjects.lmpop(direction, keys));
}
@Override
public KeyValue> lmpop(ListDirection direction, int count, String... keys) {
return executeCommand(commandObjects.lmpop(direction, count, keys));
}
@Override
public KeyValue> blmpop(double timeout, ListDirection direction, String... keys) {
return executeCommand(commandObjects.blmpop(timeout, direction, keys));
}
@Override
public KeyValue> blmpop(double timeout, ListDirection direction, int count, String... keys) {
return executeCommand(commandObjects.blmpop(timeout, direction, count, keys));
}
@Override
public KeyValue> lmpop(ListDirection direction, byte[]... keys) {
return executeCommand(commandObjects.lmpop(direction, keys));
}
@Override
public KeyValue> lmpop(ListDirection direction, int count, byte[]... keys) {
return executeCommand(commandObjects.lmpop(direction, count, keys));
}
@Override
public KeyValue> blmpop(double timeout, ListDirection direction, byte[]... keys) {
return executeCommand(commandObjects.blmpop(timeout, direction, keys));
}
@Override
public KeyValue> blmpop(double timeout, ListDirection direction, int count, byte[]... keys) {
return executeCommand(commandObjects.blmpop(timeout, direction, count, keys));
}
// List commands
// Hash commands
@Override
public long hset(String key, String field, String value) {
return executeCommand(commandObjects.hset(key, field, value));
}
@Override
public long hset(String key, Map hash) {
return executeCommand(commandObjects.hset(key, hash));
}
@Override
public String hget(String key, String field) {
return checkAndClientSideCacheCommand(commandObjects.hget(key, field), key);
}
@Override
public long hsetnx(String key, String field, String value) {
return executeCommand(commandObjects.hsetnx(key, field, value));
}
@Override
public String hmset(String key, Map hash) {
return executeCommand(commandObjects.hmset(key, hash));
}
@Override
public List hmget(String key, String... fields) {
return checkAndClientSideCacheCommand(commandObjects.hmget(key, fields), key);
}
@Override
public long hset(byte[] key, byte[] field, byte[] value) {
return executeCommand(commandObjects.hset(key, field, value));
}
@Override
public long hset(byte[] key, Map hash) {
return executeCommand(commandObjects.hset(key, hash));
}
@Override
public byte[] hget(byte[] key, byte[] field) {
return checkAndClientSideCacheCommand(commandObjects.hget(key, field), key);
}
@Override
public long hsetnx(byte[] key, byte[] field, byte[] value) {
return executeCommand(commandObjects.hsetnx(key, field, value));
}
@Override
public String hmset(byte[] key, Map hash) {
return executeCommand(commandObjects.hmset(key, hash));
}
@Override
public List hmget(byte[] key, byte[]... fields) {
return checkAndClientSideCacheCommand(commandObjects.hmget(key, fields), key);
}
@Override
public long hincrBy(String key, String field, long value) {
return executeCommand(commandObjects.hincrBy(key, field, value));
}
@Override
public double hincrByFloat(String key, String field, double value) {
return executeCommand(commandObjects.hincrByFloat(key, field, value));
}
@Override
public boolean hexists(String key, String field) {
return checkAndClientSideCacheCommand(commandObjects.hexists(key, field), key);
}
@Override
public long hdel(String key, String... field) {
return executeCommand(commandObjects.hdel(key, field));
}
@Override
public long hlen(String key) {
return checkAndClientSideCacheCommand(commandObjects.hlen(key), key);
}
@Override
public long hincrBy(byte[] key, byte[] field, long value) {
return executeCommand(commandObjects.hincrBy(key, field, value));
}
@Override
public double hincrByFloat(byte[] key, byte[] field, double value) {
return executeCommand(commandObjects.hincrByFloat(key, field, value));
}
@Override
public boolean hexists(byte[] key, byte[] field) {
return checkAndClientSideCacheCommand(commandObjects.hexists(key, field), key);
}
@Override
public long hdel(byte[] key, byte[]... field) {
return executeCommand(commandObjects.hdel(key, field));
}
@Override
public long hlen(byte[] key) {
return checkAndClientSideCacheCommand(commandObjects.hlen(key), key);
}
@Override
public Set hkeys(String key) {
return checkAndClientSideCacheCommand(commandObjects.hkeys(key), key);
}
@Override
public List hvals(String key) {
return checkAndClientSideCacheCommand(commandObjects.hvals(key), key);
}
@Override
public Map hgetAll(String key) {
return checkAndClientSideCacheCommand(commandObjects.hgetAll(key), key);
}
@Override
public Set hkeys(byte[] key) {
return checkAndClientSideCacheCommand(commandObjects.hkeys(key), key);
}
@Override
public List hvals(byte[] key) {
return checkAndClientSideCacheCommand(commandObjects.hvals(key), key);
}
@Override
public Map hgetAll(byte[] key) {
return checkAndClientSideCacheCommand(commandObjects.hgetAll(key), key);
}
@Override
public String hrandfield(String key) {
return executeCommand(commandObjects.hrandfield(key));
}
@Override
public List hrandfield(String key, long count) {
return executeCommand(commandObjects.hrandfield(key, count));
}
@Override
public List> hrandfieldWithValues(String key, long count) {
return executeCommand(commandObjects.hrandfieldWithValues(key, count));
}
@Override
public ScanResult> hscan(String key, String cursor, ScanParams params) {
return executeCommand(commandObjects.hscan(key, cursor, params));
}
@Override
public long hstrlen(String key, String field) {
return checkAndClientSideCacheCommand(commandObjects.hstrlen(key, field), key);
}
@Override
public byte[] hrandfield(byte[] key) {
return executeCommand(commandObjects.hrandfield(key));
}
@Override
public List hrandfield(byte[] key, long count) {
return executeCommand(commandObjects.hrandfield(key, count));
}
@Override
public List> hrandfieldWithValues(byte[] key, long count) {
return executeCommand(commandObjects.hrandfieldWithValues(key, count));
}
@Override
public ScanResult> hscan(byte[] key, byte[] cursor, ScanParams params) {
return executeCommand(commandObjects.hscan(key, cursor, params));
}
@Override
public long hstrlen(byte[] key, byte[] field) {
return checkAndClientSideCacheCommand(commandObjects.hstrlen(key, field), key);
}
// Hash commands
// Set commands
@Override
public long sadd(String key, String... members) {
return executeCommand(commandObjects.sadd(key, members));
}
@Override
public Set smembers(String key) {
return checkAndClientSideCacheCommand(commandObjects.smembers(key), key);
}
@Override
public long srem(String key, String... members) {
return executeCommand(commandObjects.srem(key, members));
}
@Override
public String spop(String key) {
return executeCommand(commandObjects.spop(key));
}
@Override
public Set spop(String key, long count) {
return executeCommand(commandObjects.spop(key, count));
}
@Override
public long scard(String key) {
return checkAndClientSideCacheCommand(commandObjects.scard(key), key);
}
@Override
public boolean sismember(String key, String member) {
return checkAndClientSideCacheCommand(commandObjects.sismember(key, member), key);
}
@Override
public List smismember(String key, String... members) {
return checkAndClientSideCacheCommand(commandObjects.smismember(key, members), key);
}
@Override
public long sadd(byte[] key, byte[]... members) {
return executeCommand(commandObjects.sadd(key, members));
}
@Override
public Set smembers(byte[] key) {
return checkAndClientSideCacheCommand(commandObjects.smembers(key), key);
}
@Override
public long srem(byte[] key, byte[]... members) {
return executeCommand(commandObjects.srem(key, members));
}
@Override
public byte[] spop(byte[] key) {
return executeCommand(commandObjects.spop(key));
}
@Override
public Set spop(byte[] key, long count) {
return executeCommand(commandObjects.spop(key, count));
}
@Override
public long scard(byte[] key) {
return checkAndClientSideCacheCommand(commandObjects.scard(key), key);
}
@Override
public boolean sismember(byte[] key, byte[] member) {
return checkAndClientSideCacheCommand(commandObjects.sismember(key, member), key);
}
@Override
public List smismember(byte[] key, byte[]... members) {
return checkAndClientSideCacheCommand(commandObjects.smismember(key, members), key);
}
@Override
public String srandmember(String key) {
return executeCommand(commandObjects.srandmember(key));
}
@Override
public List srandmember(String key, int count) {
return executeCommand(commandObjects.srandmember(key, count));
}
@Override
public ScanResult sscan(String key, String cursor, ScanParams params) {
return executeCommand(commandObjects.sscan(key, cursor, params));
}
@Override
public byte[] srandmember(byte[] key) {
return executeCommand(commandObjects.srandmember(key));
}
@Override
public List srandmember(byte[] key, int count) {
return executeCommand(commandObjects.srandmember(key, count));
}
@Override
public ScanResult sscan(byte[] key, byte[] cursor, ScanParams params) {
return executeCommand(commandObjects.sscan(key, cursor, params));
}
@Override
public Set sdiff(String... keys) {
return checkAndClientSideCacheCommand(commandObjects.sdiff(keys), (Object[]) keys);
}
@Override
public long sdiffstore(String dstkey, String... keys) {
return executeCommand(commandObjects.sdiffstore(dstkey, keys));
}
@Override
public Set sinter(String... keys) {
return checkAndClientSideCacheCommand(commandObjects.sinter(keys), (Object[]) keys);
}
@Override
public long sinterstore(String dstkey, String... keys) {
return executeCommand(commandObjects.sinterstore(dstkey, keys));
}
@Override
public long sintercard(String... keys) {
return executeCommand(commandObjects.sintercard(keys));
}
@Override
public long sintercard(int limit, String... keys) {
return executeCommand(commandObjects.sintercard(limit, keys));
}
@Override
public Set sunion(String... keys) {
return checkAndClientSideCacheCommand(commandObjects.sunion(keys), (Object[]) keys);
}
@Override
public long sunionstore(String dstkey, String... keys) {
return executeCommand(commandObjects.sunionstore(dstkey, keys));
}
@Override
public long smove(String srckey, String dstkey, String member) {
return executeCommand(commandObjects.smove(srckey, dstkey, member));
}
@Override
public Set sdiff(byte[]... keys) {
return checkAndClientSideCacheCommand(commandObjects.sdiff(keys), (Object[]) keys);
}
@Override
public long sdiffstore(byte[] dstkey, byte[]... keys) {
return executeCommand(commandObjects.sdiffstore(dstkey, keys));
}
@Override
public Set sinter(byte[]... keys) {
return checkAndClientSideCacheCommand(commandObjects.sinter(keys), (Object[]) keys);
}
@Override
public long sinterstore(byte[] dstkey, byte[]... keys) {
return executeCommand(commandObjects.sinterstore(dstkey, keys));
}
@Override
public long sintercard(byte[]... keys) {
return executeCommand(commandObjects.sintercard(keys));
}
@Override
public long sintercard(int limit, byte[]... keys) {
return executeCommand(commandObjects.sintercard(limit, keys));
}
@Override
public Set sunion(byte[]... keys) {
return checkAndClientSideCacheCommand(commandObjects.sunion(keys), (Object[]) keys);
}
@Override
public long sunionstore(byte[] dstkey, byte[]... keys) {
return executeCommand(commandObjects.sunionstore(dstkey, keys));
}
@Override
public long smove(byte[] srckey, byte[] dstkey, byte[] member) {
return executeCommand(commandObjects.smove(srckey, dstkey, member));
}
// Set commands
// Sorted Set commands
@Override
public long zadd(String key, double score, String member) {
return executeCommand(commandObjects.zadd(key, score, member));
}
@Override
public long zadd(String key, double score, String member, ZAddParams params) {
return executeCommand(commandObjects.zadd(key, score, member, params));
}
@Override
public long zadd(String key, Map scoreMembers) {
return executeCommand(commandObjects.zadd(key, scoreMembers));
}
@Override
public long zadd(String key, Map scoreMembers, ZAddParams params) {
return executeCommand(commandObjects.zadd(key, scoreMembers, params));
}
@Override
public Double zaddIncr(String key, double score, String member, ZAddParams params) {
return executeCommand(commandObjects.zaddIncr(key, score, member, params));
}
@Override
public long zadd(byte[] key, double score, byte[] member) {
return executeCommand(commandObjects.zadd(key, score, member));
}
@Override
public long zadd(byte[] key, double score, byte[] member, ZAddParams params) {
return executeCommand(commandObjects.zadd(key, score, member, params));
}
@Override
public long zadd(byte[] key, Map scoreMembers) {
return executeCommand(commandObjects.zadd(key, scoreMembers));
}
@Override
public long zadd(byte[] key, Map scoreMembers, ZAddParams params) {
return executeCommand(commandObjects.zadd(key, scoreMembers, params));
}
@Override
public Double zaddIncr(byte[] key, double score, byte[] member, ZAddParams params) {
return executeCommand(commandObjects.zaddIncr(key, score, member, params));
}
@Override
public long zrem(String key, String... members) {
return executeCommand(commandObjects.zrem(key, members));
}
@Override
public double zincrby(String key, double increment, String member) {
return executeCommand(commandObjects.zincrby(key, increment, member));
}
@Override
public Double zincrby(String key, double increment, String member, ZIncrByParams params) {
return executeCommand(commandObjects.zincrby(key, increment, member, params));
}
@Override
public Long zrank(String key, String member) {
return checkAndClientSideCacheCommand(commandObjects.zrank(key, member), key);
}
@Override
public Long zrevrank(String key, String member) {
return checkAndClientSideCacheCommand(commandObjects.zrevrank(key, member), key);
}
@Override
public KeyValue zrankWithScore(String key, String member) {
return checkAndClientSideCacheCommand(commandObjects.zrankWithScore(key, member), key);
}
@Override
public KeyValue zrevrankWithScore(String key, String member) {
return checkAndClientSideCacheCommand(commandObjects.zrevrankWithScore(key, member), key);
}
@Override
public long zrem(byte[] key, byte[]... members) {
return executeCommand(commandObjects.zrem(key, members));
}
@Override
public double zincrby(byte[] key, double increment, byte[] member) {
return executeCommand(commandObjects.zincrby(key, increment, member));
}
@Override
public Double zincrby(byte[] key, double increment, byte[] member, ZIncrByParams params) {
return executeCommand(commandObjects.zincrby(key, increment, member, params));
}
@Override
public Long zrank(byte[] key, byte[] member) {
return checkAndClientSideCacheCommand(commandObjects.zrank(key, member), key);
}
@Override
public Long zrevrank(byte[] key, byte[] member) {
return checkAndClientSideCacheCommand(commandObjects.zrevrank(key, member), key);
}
@Override
public KeyValue zrankWithScore(byte[] key, byte[] member) {
return checkAndClientSideCacheCommand(commandObjects.zrankWithScore(key, member), key);
}
@Override
public KeyValue zrevrankWithScore(byte[] key, byte[] member) {
return checkAndClientSideCacheCommand(commandObjects.zrevrankWithScore(key, member), key);
}
@Override
public String zrandmember(String key) {
return executeCommand(commandObjects.zrandmember(key));
}
@Override
public List zrandmember(String key, long count) {
return executeCommand(commandObjects.zrandmember(key, count));
}
@Override
public List zrandmemberWithScores(String key, long count) {
return executeCommand(commandObjects.zrandmemberWithScores(key, count));
}
@Override
public long zcard(String key) {
return checkAndClientSideCacheCommand(commandObjects.zcard(key), key);
}
@Override
public Double zscore(String key, String member) {
return checkAndClientSideCacheCommand(commandObjects.zscore(key, member), key);
}
@Override
public List zmscore(String key, String... members) {
return checkAndClientSideCacheCommand(commandObjects.zmscore(key, members), key);
}
@Override
public byte[] zrandmember(byte[] key) {
return executeCommand(commandObjects.zrandmember(key));
}
@Override
public List zrandmember(byte[] key, long count) {
return executeCommand(commandObjects.zrandmember(key, count));
}
@Override
public List zrandmemberWithScores(byte[] key, long count) {
return executeCommand(commandObjects.zrandmemberWithScores(key, count));
}
@Override
public long zcard(byte[] key) {
return checkAndClientSideCacheCommand(commandObjects.zcard(key), key);
}
@Override
public Double zscore(byte[] key, byte[] member) {
return checkAndClientSideCacheCommand(commandObjects.zscore(key, member), key);
}
@Override
public List zmscore(byte[] key, byte[]... members) {
return checkAndClientSideCacheCommand(commandObjects.zmscore(key, members), key);
}
@Override
public Tuple zpopmax(String key) {
return executeCommand(commandObjects.zpopmax(key));
}
@Override
public List zpopmax(String key, int count) {
return executeCommand(commandObjects.zpopmax(key, count));
}
@Override
public Tuple zpopmin(String key) {
return executeCommand(commandObjects.zpopmin(key));
}
@Override
public List zpopmin(String key, int count) {
return executeCommand(commandObjects.zpopmin(key, count));
}
@Override
public long zcount(String key, double min, double max) {
return checkAndClientSideCacheCommand(commandObjects.zcount(key, min, max), key);
}
@Override
public long zcount(String key, String min, String max) {
return checkAndClientSideCacheCommand(commandObjects.zcount(key, min, max), key);
}
@Override
public Tuple zpopmax(byte[] key) {
return executeCommand(commandObjects.zpopmax(key));
}
@Override
public List zpopmax(byte[] key, int count) {
return executeCommand(commandObjects.zpopmax(key, count));
}
@Override
public Tuple zpopmin(byte[] key) {
return executeCommand(commandObjects.zpopmin(key));
}
@Override
public List zpopmin(byte[] key, int count) {
return executeCommand(commandObjects.zpopmin(key, count));
}
@Override
public long zcount(byte[] key, double min, double max) {
return checkAndClientSideCacheCommand(commandObjects.zcount(key, min, max), key);
}
@Override
public long zcount(byte[] key, byte[] min, byte[] max) {
return checkAndClientSideCacheCommand(commandObjects.zcount(key, min, max), key);
}
@Override
public List zrange(String key, long start, long stop) {
return checkAndClientSideCacheCommand(commandObjects.zrange(key, start, stop), key);
}
@Override
public List zrevrange(String key, long start, long stop) {
return checkAndClientSideCacheCommand(commandObjects.zrevrange(key, start, stop), key);
}
@Override
public List zrangeWithScores(String key, long start, long stop) {
return checkAndClientSideCacheCommand(commandObjects.zrangeWithScores(key, start, stop), key);
}
@Override
public List zrevrangeWithScores(String key, long start, long stop) {
return checkAndClientSideCacheCommand(commandObjects.zrevrangeWithScores(key, start, stop), key);
}
@Override
public List zrange(String key, ZRangeParams zRangeParams) {
return checkAndClientSideCacheCommand(commandObjects.zrange(key, zRangeParams), key);
}
@Override
public List zrangeWithScores(String key, ZRangeParams zRangeParams) {
return checkAndClientSideCacheCommand(commandObjects.zrangeWithScores(key, zRangeParams), key);
}
@Override
public long zrangestore(String dest, String src, ZRangeParams zRangeParams) {
return executeCommand(commandObjects.zrangestore(dest, src, zRangeParams));
}
@Override
public List zrangeByScore(String key, double min, double max) {
return checkAndClientSideCacheCommand(commandObjects.zrangeByScore(key, min, max), key);
}
@Override
public List zrangeByScore(String key, String min, String max) {
return checkAndClientSideCacheCommand(commandObjects.zrangeByScore(key, min, max), key);
}
@Override
public List zrevrangeByScore(String key, double max, double min) {
return checkAndClientSideCacheCommand(commandObjects.zrevrangeByScore(key, max, min), key);
}
@Override
public List zrangeByScore(String key, double min, double max, int offset, int count) {
return checkAndClientSideCacheCommand(commandObjects.zrangeByScore(key, min, max, offset, count), key);
}
@Override
public List zrevrangeByScore(String key, String max, String min) {
return checkAndClientSideCacheCommand(commandObjects.zrevrangeByScore(key, max, min), key);
}
@Override
public List zrangeByScore(String key, String min, String max, int offset, int count) {
return checkAndClientSideCacheCommand(commandObjects.zrangeByScore(key, min, max, offset, count), key);
}
@Override
public List zrevrangeByScore(String key, double max, double min, int offset, int count) {
return checkAndClientSideCacheCommand(commandObjects.zrevrangeByScore(key, max, min, offset, count), key);
}
@Override
public List zrangeByScoreWithScores(String key, double min, double max) {
return checkAndClientSideCacheCommand(commandObjects.zrangeByScoreWithScores(key, min, max), key);
}
@Override
public List zrevrangeByScoreWithScores(String key, double max, double min) {
return checkAndClientSideCacheCommand(commandObjects.zrevrangeByScoreWithScores(key, max, min), key);
}
@Override
public List zrangeByScoreWithScores(String key, double min, double max, int offset, int count) {
return checkAndClientSideCacheCommand(commandObjects.zrangeByScoreWithScores(key, min, max, offset, count), key);
}
@Override
public List zrevrangeByScore(String key, String max, String min, int offset, int count) {
return checkAndClientSideCacheCommand(commandObjects.zrevrangeByScore(key, max, min, offset, count), key);
}
@Override
public List zrangeByScoreWithScores(String key, String min, String max) {
return checkAndClientSideCacheCommand(commandObjects.zrangeByScoreWithScores(key, min, max), key);
}
@Override
public List zrevrangeByScoreWithScores(String key, String max, String min) {
return checkAndClientSideCacheCommand(commandObjects.zrevrangeByScoreWithScores(key, max, min), key);
}
@Override
public List zrangeByScoreWithScores(String key, String min, String max, int offset, int count) {
return checkAndClientSideCacheCommand(commandObjects.zrangeByScoreWithScores(key, min, max, offset, count), key);
}
@Override
public List zrevrangeByScoreWithScores(String key, double max, double min, int offset, int count) {
return checkAndClientSideCacheCommand(commandObjects.zrevrangeByScoreWithScores(key, max, min, offset, count), key);
}
@Override
public List zrevrangeByScoreWithScores(String key, String max, String min, int offset, int count) {
return checkAndClientSideCacheCommand(commandObjects.zrevrangeByScoreWithScores(key, max, min, offset, count), key);
}
@Override
public List zrange(byte[] key, long start, long stop) {
return checkAndClientSideCacheCommand(commandObjects.zrange(key, start, stop), key);
}
@Override
public List zrevrange(byte[] key, long start, long stop) {
return checkAndClientSideCacheCommand(commandObjects.zrevrange(key, start, stop), key);
}
@Override
public List zrangeWithScores(byte[] key, long start, long stop) {
return checkAndClientSideCacheCommand(commandObjects.zrangeWithScores(key, start, stop), key);
}
@Override
public List zrevrangeWithScores(byte[] key, long start, long stop) {
return checkAndClientSideCacheCommand(commandObjects.zrevrangeWithScores(key, start, stop), key);
}
@Override
public List zrange(byte[] key, ZRangeParams zRangeParams) {
return checkAndClientSideCacheCommand(commandObjects.zrange(key, zRangeParams), key);
}
@Override
public List zrangeWithScores(byte[] key, ZRangeParams zRangeParams) {
return checkAndClientSideCacheCommand(commandObjects.zrangeWithScores(key, zRangeParams), key);
}
@Override
public long zrangestore(byte[] dest, byte[] src, ZRangeParams zRangeParams) {
return executeCommand(commandObjects.zrangestore(dest, src, zRangeParams));
}
@Override
public List zrangeByScore(byte[] key, double min, double max) {
return checkAndClientSideCacheCommand(commandObjects.zrangeByScore(key, min, max), key);
}
@Override
public List zrangeByScore(byte[] key, byte[] min, byte[] max) {
return checkAndClientSideCacheCommand(commandObjects.zrangeByScore(key, min, max), key);
}
@Override
public List zrevrangeByScore(byte[] key, double max, double min) {
return checkAndClientSideCacheCommand(commandObjects.zrevrangeByScore(key, max, min), key);
}
@Override
public List zrangeByScore(byte[] key, double min, double max, int offset, int count) {
return checkAndClientSideCacheCommand(commandObjects.zrangeByScore(key, min, max, offset, count), key);
}
@Override
public List zrevrangeByScore(byte[] key, byte[] max, byte[] min) {
return checkAndClientSideCacheCommand(commandObjects.zrevrangeByScore(key, max, min), key);
}
@Override
public List zrangeByScore(byte[] key, byte[] min, byte[] max, int offset, int count) {
return checkAndClientSideCacheCommand(commandObjects.zrangeByScore(key, min, max, offset, count), key);
}
@Override
public List zrevrangeByScore(byte[] key, double max, double min, int offset, int count) {
return checkAndClientSideCacheCommand(commandObjects.zrevrangeByScore(key, max, min, offset, count), key);
}
@Override
public List zrangeByScoreWithScores(byte[] key, double min, double max) {
return checkAndClientSideCacheCommand(commandObjects.zrangeByScoreWithScores(key, min, max), key);
}
@Override
public List zrevrangeByScoreWithScores(byte[] key, double max, double min) {
return checkAndClientSideCacheCommand(commandObjects.zrevrangeByScoreWithScores(key, max, min), key);
}
@Override
public List zrangeByScoreWithScores(byte[] key, double min, double max, int offset, int count) {
return checkAndClientSideCacheCommand(commandObjects.zrangeByScoreWithScores(key, min, max, offset, count), key);
}
@Override
public List zrevrangeByScore(byte[] key, byte[] max, byte[] min, int offset, int count) {
return checkAndClientSideCacheCommand(commandObjects.zrevrangeByScore(key, max, min, offset, count), key);
}
@Override
public List zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max) {
return checkAndClientSideCacheCommand(commandObjects.zrangeByScoreWithScores(key, min, max), key);
}
@Override
public List zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min) {
return checkAndClientSideCacheCommand(commandObjects.zrevrangeByScoreWithScores(key, max, min), key);
}
@Override
public List zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max, int offset, int count) {
return checkAndClientSideCacheCommand(commandObjects.zrangeByScoreWithScores(key, min, max, offset, count), key);
}
@Override
public List zrevrangeByScoreWithScores(byte[] key, double max, double min, int offset, int count) {
return checkAndClientSideCacheCommand(commandObjects.zrevrangeByScoreWithScores(key, max, min, offset, count), key);
}
@Override
public List zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min, int offset, int count) {
return checkAndClientSideCacheCommand(commandObjects.zrevrangeByScoreWithScores(key, max, min, offset, count), key);
}
@Override
public long zremrangeByRank(String key, long start, long stop) {
return executeCommand(commandObjects.zremrangeByRank(key, start, stop));
}
@Override
public long zremrangeByScore(String key, double min, double max) {
return executeCommand(commandObjects.zremrangeByScore(key, min, max));
}
@Override
public long zremrangeByScore(String key, String min, String max) {
return executeCommand(commandObjects.zremrangeByScore(key, min, max));
}
@Override
public long zremrangeByRank(byte[] key, long start, long stop) {
return executeCommand(commandObjects.zremrangeByRank(key, start, stop));
}
@Override
public long zremrangeByScore(byte[] key, double min, double max) {
return executeCommand(commandObjects.zremrangeByScore(key, min, max));
}
@Override
public long zremrangeByScore(byte[] key, byte[] min, byte[] max) {
return executeCommand(commandObjects.zremrangeByScore(key, min, max));
}
@Override
public long zlexcount(String key, String min, String max) {
return checkAndClientSideCacheCommand(commandObjects.zlexcount(key, min, max), key);
}
@Override
public List zrangeByLex(String key, String min, String max) {
return checkAndClientSideCacheCommand(commandObjects.zrangeByLex(key, min, max), key);
}
@Override
public List zrangeByLex(String key, String min, String max, int offset, int count) {
return checkAndClientSideCacheCommand(commandObjects.zrangeByLex(key, min, max, offset, count), key);
}
@Override
public List zrevrangeByLex(String key, String max, String min) {
return checkAndClientSideCacheCommand(commandObjects.zrevrangeByLex(key, max, min), key);
}
@Override
public List zrevrangeByLex(String key, String max, String min, int offset, int count) {
return checkAndClientSideCacheCommand(commandObjects.zrevrangeByLex(key, max, min, offset, count), key);
}
@Override
public long zremrangeByLex(String key, String min, String max) {
return executeCommand(commandObjects.zremrangeByLex(key, min, max));
}
@Override
public long zlexcount(byte[] key, byte[] min, byte[] max) {
return checkAndClientSideCacheCommand(commandObjects.zlexcount(key, min, max), key);
}
@Override
public List zrangeByLex(byte[] key, byte[] min, byte[] max) {
return checkAndClientSideCacheCommand(commandObjects.zrangeByLex(key, min, max), key);
}
@Override
public List zrangeByLex(byte[] key, byte[] min, byte[] max, int offset, int count) {
return checkAndClientSideCacheCommand(commandObjects.zrangeByLex(key, min, max, offset, count), key);
}
@Override
public List zrevrangeByLex(byte[] key, byte[] max, byte[] min) {
return checkAndClientSideCacheCommand(commandObjects.zrevrangeByLex(key, max, min), key);
}
@Override
public List zrevrangeByLex(byte[] key, byte[] max, byte[] min, int offset, int count) {
return checkAndClientSideCacheCommand(commandObjects.zrevrangeByLex(key, max, min, offset, count), key);
}
@Override
public long zremrangeByLex(byte[] key, byte[] min, byte[] max) {
return executeCommand(commandObjects.zremrangeByLex(key, min, max));
}
@Override
public ScanResult zscan(String key, String cursor, ScanParams params) {
return executeCommand(commandObjects.zscan(key, cursor, params));
}
@Override
public ScanResult zscan(byte[] key, byte[] cursor, ScanParams params) {
return executeCommand(commandObjects.zscan(key, cursor, params));
}
@Override
public KeyValue bzpopmax(double timeout, String... keys) {
return executeCommand(commandObjects.bzpopmax(timeout, keys));
}
@Override
public KeyValue bzpopmin(double timeout, String... keys) {
return executeCommand(commandObjects.bzpopmin(timeout, keys));
}
@Override
public KeyValue bzpopmax(double timeout, byte[]... keys) {
return executeCommand(commandObjects.bzpopmax(timeout, keys));
}
@Override
public KeyValue bzpopmin(double timeout, byte[]... keys) {
return executeCommand(commandObjects.bzpopmin(timeout, keys));
}
@Override
public List zdiff(String... keys) {
return executeCommand(commandObjects.zdiff(keys));
}
@Override
public List zdiffWithScores(String... keys) {
return executeCommand(commandObjects.zdiffWithScores(keys));
}
@Override
@Deprecated
public long zdiffStore(String dstkey, String... keys) {
return executeCommand(commandObjects.zdiffStore(dstkey, keys));
}
@Override
public long zdiffstore(String dstkey, String... keys) {
return executeCommand(commandObjects.zdiffstore(dstkey, keys));
}
@Override
public List zdiff(byte[]... keys) {
return executeCommand(commandObjects.zdiff(keys));
}
@Override
public List zdiffWithScores(byte[]... keys) {
return executeCommand(commandObjects.zdiffWithScores(keys));
}
@Override
@Deprecated
public long zdiffStore(byte[] dstkey, byte[]... keys) {
return executeCommand(commandObjects.zdiffStore(dstkey, keys));
}
@Override
public long zdiffstore(byte[] dstkey, byte[]... keys) {
return executeCommand(commandObjects.zdiffstore(dstkey, keys));
}
@Override
public long zinterstore(String dstkey, String... sets) {
return executeCommand(commandObjects.zinterstore(dstkey, sets));
}
@Override
public long zinterstore(String dstkey, ZParams params, String... sets) {
return executeCommand(commandObjects.zinterstore(dstkey, params, sets));
}
@Override
public List zinter(ZParams params, String... keys) {
return executeCommand(commandObjects.zinter(params, keys));
}
@Override
public List zinterWithScores(ZParams params, String... keys) {
return executeCommand(commandObjects.zinterWithScores(params, keys));
}
@Override
public long zinterstore(byte[] dstkey, byte[]... sets) {
return executeCommand(commandObjects.zinterstore(dstkey, sets));
}
@Override
public long zinterstore(byte[] dstkey, ZParams params, byte[]... sets) {
return executeCommand(commandObjects.zinterstore(dstkey, params, sets));
}
@Override
public long zintercard(byte[]... keys) {
return executeCommand(commandObjects.zintercard(keys));
}
@Override
public long zintercard(long limit, byte[]... keys) {
return executeCommand(commandObjects.zintercard(limit, keys));
}
@Override
public long zintercard(String... keys) {
return executeCommand(commandObjects.zintercard(keys));
}
@Override
public long zintercard(long limit, String... keys) {
return executeCommand(commandObjects.zintercard(limit, keys));
}
@Override
public List zinter(ZParams params, byte[]... keys) {
return executeCommand(commandObjects.zinter(params, keys));
}
@Override
public List zinterWithScores(ZParams params, byte[]... keys) {
return executeCommand(commandObjects.zinterWithScores(params, keys));
}
@Override
public List zunion(ZParams params, String... keys) {
return executeCommand(commandObjects.zunion(params, keys));
}
@Override
public List zunionWithScores(ZParams params, String... keys) {
return executeCommand(commandObjects.zunionWithScores(params, keys));
}
@Override
public long zunionstore(String dstkey, String... sets) {
return executeCommand(commandObjects.zunionstore(dstkey, sets));
}
@Override
public long zunionstore(String dstkey, ZParams params, String... sets) {
return executeCommand(commandObjects.zunionstore(dstkey, params, sets));
}
@Override
public List zunion(ZParams params, byte[]... keys) {
return executeCommand(commandObjects.zunion(params, keys));
}
@Override
public List zunionWithScores(ZParams params, byte[]... keys) {
return executeCommand(commandObjects.zunionWithScores(params, keys));
}
@Override
public long zunionstore(byte[] dstkey, byte[]... sets) {
return executeCommand(commandObjects.zunionstore(dstkey, sets));
}
@Override
public long zunionstore(byte[] dstkey, ZParams params, byte[]... sets) {
return executeCommand(commandObjects.zunionstore(dstkey, params, sets));
}
@Override
public KeyValue> zmpop(SortedSetOption option, String... keys) {
return executeCommand(commandObjects.zmpop(option, keys));
}
@Override
public KeyValue> zmpop(SortedSetOption option, int count, String... keys) {
return executeCommand(commandObjects.zmpop(option, count, keys));
}
@Override
public KeyValue> bzmpop(double timeout, SortedSetOption option, String... keys) {
return executeCommand(commandObjects.bzmpop(timeout, option, keys));
}
@Override
public KeyValue> bzmpop(double timeout, SortedSetOption option, int count, String... keys) {
return executeCommand(commandObjects.bzmpop(timeout, option, count, keys));
}
@Override
public KeyValue> zmpop(SortedSetOption option, byte[]... keys) {
return executeCommand(commandObjects.zmpop(option, keys));
}
@Override
public KeyValue> zmpop(SortedSetOption option, int count, byte[]... keys) {
return executeCommand(commandObjects.zmpop(option, count, keys));
}
@Override
public KeyValue> bzmpop(double timeout, SortedSetOption option, byte[]... keys) {
return executeCommand(commandObjects.bzmpop(timeout, option, keys));
}
@Override
public KeyValue> bzmpop(double timeout, SortedSetOption option, int count, byte[]... keys) {
return executeCommand(commandObjects.bzmpop(timeout, option, count, keys));
}
// Sorted Set commands
// Geo commands
@Override
public long geoadd(String key, double longitude, double latitude, String member) {
return executeCommand(commandObjects.geoadd(key, longitude, latitude, member));
}
@Override
public long geoadd(String key, Map memberCoordinateMap) {
return executeCommand(commandObjects.geoadd(key, memberCoordinateMap));
}
@Override
public long geoadd(String key, GeoAddParams params, Map memberCoordinateMap) {
return executeCommand(commandObjects.geoadd(key, params, memberCoordinateMap));
}
@Override
public Double geodist(String key, String member1, String member2) {
return checkAndClientSideCacheCommand(commandObjects.geodist(key, member1, member2), key);
}
@Override
public Double geodist(String key, String member1, String member2, GeoUnit unit) {
return checkAndClientSideCacheCommand(commandObjects.geodist(key, member1, member2, unit), key);
}
@Override
public List geohash(String key, String... members) {
return checkAndClientSideCacheCommand(commandObjects.geohash(key, members), key);
}
@Override
public List geopos(String key, String... members) {
return checkAndClientSideCacheCommand(commandObjects.geopos(key, members), key);
}
@Override
public long geoadd(byte[] key, double longitude, double latitude, byte[] member) {
return executeCommand(commandObjects.geoadd(key, longitude, latitude, member));
}
@Override
public long geoadd(byte[] key, Map memberCoordinateMap) {
return executeCommand(commandObjects.geoadd(key, memberCoordinateMap));
}
@Override
public long geoadd(byte[] key, GeoAddParams params, Map memberCoordinateMap) {
return executeCommand(commandObjects.geoadd(key, params, memberCoordinateMap));
}
@Override
public Double geodist(byte[] key, byte[] member1, byte[] member2) {
return checkAndClientSideCacheCommand(commandObjects.geodist(key, member1, member2), key);
}
@Override
public Double geodist(byte[] key, byte[] member1, byte[] member2, GeoUnit unit) {
return checkAndClientSideCacheCommand(commandObjects.geodist(key, member1, member2, unit), key);
}
@Override
public List geohash(byte[] key, byte[]... members) {
return checkAndClientSideCacheCommand(commandObjects.geohash(key, members), key);
}
@Override
public List geopos(byte[] key, byte[]... members) {
return checkAndClientSideCacheCommand(commandObjects.geopos(key, members), key);
}
@Override
public List georadius(String key, double longitude, double latitude, double radius, GeoUnit unit) {
return executeCommand(commandObjects.georadius(key, longitude, latitude, radius, unit));
}
@Override
public List georadiusReadonly(String key, double longitude, double latitude, double radius, GeoUnit unit) {
return checkAndClientSideCacheCommand(commandObjects.georadiusReadonly(key, longitude, latitude, radius, unit), key);
}
@Override
public List georadius(String key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param) {
return executeCommand(commandObjects.georadius(key, longitude, latitude, radius, unit, param));
}
@Override
public List georadiusReadonly(String key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param) {
return checkAndClientSideCacheCommand(commandObjects.georadiusReadonly(key, longitude, latitude, radius, unit, param), key);
}
@Override
public List georadiusByMember(String key, String member, double radius, GeoUnit unit) {
return executeCommand(commandObjects.georadiusByMember(key, member, radius, unit));
}
@Override
public List georadiusByMemberReadonly(String key, String member, double radius, GeoUnit unit) {
return checkAndClientSideCacheCommand(commandObjects.georadiusByMemberReadonly(key, member, radius, unit), key);
}
@Override
public List georadiusByMember(String key, String member, double radius, GeoUnit unit, GeoRadiusParam param) {
return executeCommand(commandObjects.georadiusByMember(key, member, radius, unit, param));
}
@Override
public List georadiusByMemberReadonly(String key, String member, double radius, GeoUnit unit, GeoRadiusParam param) {
return checkAndClientSideCacheCommand(commandObjects.georadiusByMemberReadonly(key, member, radius, unit, param), key);
}
@Override
public long georadiusStore(String key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param, GeoRadiusStoreParam storeParam) {
return executeCommand(commandObjects.georadiusStore(key, longitude, latitude, radius, unit, param, storeParam));
}
@Override
public long georadiusByMemberStore(String key, String member, double radius, GeoUnit unit, GeoRadiusParam param, GeoRadiusStoreParam storeParam) {
return executeCommand(commandObjects.georadiusByMemberStore(key, member, radius, unit, param, storeParam));
}
@Override
public List geosearch(String key, String member, double radius, GeoUnit unit) {
return checkAndClientSideCacheCommand(commandObjects.geosearch(key, member, radius, unit), key);
}
@Override
public List geosearch(String key, GeoCoordinate coord, double radius, GeoUnit unit) {
return checkAndClientSideCacheCommand(commandObjects.geosearch(key, coord, radius, unit), key);
}
@Override
public List geosearch(String key, String member, double width, double height, GeoUnit unit) {
return checkAndClientSideCacheCommand(commandObjects.geosearch(key, member, width, height, unit), key);
}
@Override
public List geosearch(String key, GeoCoordinate coord, double width, double height, GeoUnit unit) {
return checkAndClientSideCacheCommand(commandObjects.geosearch(key, coord, width, height, unit), key);
}
@Override
public List geosearch(String key, GeoSearchParam params) {
return checkAndClientSideCacheCommand(commandObjects.geosearch(key, params), key);
}
@Override
public long geosearchStore(String dest, String src, String member, double radius, GeoUnit unit) {
return executeCommand(commandObjects.geosearchStore(dest, src, member, radius, unit));
}
@Override
public long geosearchStore(String dest, String src, GeoCoordinate coord, double radius, GeoUnit unit) {
return executeCommand(commandObjects.geosearchStore(dest, src, coord, radius, unit));
}
@Override
public long geosearchStore(String dest, String src, String member, double width, double height, GeoUnit unit) {
return executeCommand(commandObjects.geosearchStore(dest, src, member, width, height, unit));
}
@Override
public long geosearchStore(String dest, String src, GeoCoordinate coord, double width, double height, GeoUnit unit) {
return executeCommand(commandObjects.geosearchStore(dest, src, coord, width, height, unit));
}
@Override
public long geosearchStore(String dest, String src, GeoSearchParam params) {
return executeCommand(commandObjects.geosearchStore(dest, src, params));
}
@Override
public long geosearchStoreStoreDist(String dest, String src, GeoSearchParam params) {
return executeCommand(commandObjects.geosearchStoreStoreDist(dest, src, params));
}
@Override
public List georadius(byte[] key, double longitude, double latitude, double radius, GeoUnit unit) {
return executeCommand(commandObjects.georadius(key, longitude, latitude, radius, unit));
}
@Override
public List georadiusReadonly(byte[] key, double longitude, double latitude, double radius, GeoUnit unit) {
return checkAndClientSideCacheCommand(commandObjects.georadiusReadonly(key, longitude, latitude, radius, unit), key);
}
@Override
public List georadius(byte[] key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param) {
return executeCommand(commandObjects.georadius(key, longitude, latitude, radius, unit, param));
}
@Override
public List georadiusReadonly(byte[] key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param) {
return checkAndClientSideCacheCommand(commandObjects.georadiusReadonly(key, longitude, latitude, radius, unit, param), key);
}
@Override
public List georadiusByMember(byte[] key, byte[] member, double radius, GeoUnit unit) {
return executeCommand(commandObjects.georadiusByMember(key, member, radius, unit));
}
@Override
public List georadiusByMemberReadonly(byte[] key, byte[] member, double radius, GeoUnit unit) {
return checkAndClientSideCacheCommand(commandObjects.georadiusByMemberReadonly(key, member, radius, unit), key);
}
@Override
public List georadiusByMember(byte[] key, byte[] member, double radius, GeoUnit unit, GeoRadiusParam param) {
return executeCommand(commandObjects.georadiusByMember(key, member, radius, unit, param));
}
@Override
public List georadiusByMemberReadonly(byte[] key, byte[] member, double radius, GeoUnit unit, GeoRadiusParam param) {
return checkAndClientSideCacheCommand(commandObjects.georadiusByMemberReadonly(key, member, radius, unit, param), key);
}
@Override
public long georadiusStore(byte[] key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param, GeoRadiusStoreParam storeParam) {
return executeCommand(commandObjects.georadiusStore(key, longitude, latitude, radius, unit, param, storeParam));
}
@Override
public long georadiusByMemberStore(byte[] key, byte[] member, double radius, GeoUnit unit, GeoRadiusParam param, GeoRadiusStoreParam storeParam) {
return executeCommand(commandObjects.georadiusByMemberStore(key, member, radius, unit, param, storeParam));
}
@Override
public List geosearch(byte[] key, byte[] member, double radius, GeoUnit unit) {
return checkAndClientSideCacheCommand(commandObjects.geosearch(key, member, radius, unit), key);
}
@Override
public List geosearch(byte[] key, GeoCoordinate coord, double radius, GeoUnit unit) {
return checkAndClientSideCacheCommand(commandObjects.geosearch(key, coord, radius, unit), key);
}
@Override
public List geosearch(byte[] key, byte[] member, double width, double height, GeoUnit unit) {
return checkAndClientSideCacheCommand(commandObjects.geosearch(key, member, width, height, unit), key);
}
@Override
public List geosearch(byte[] key, GeoCoordinate coord, double width, double height, GeoUnit unit) {
return checkAndClientSideCacheCommand(commandObjects.geosearch(key, coord, width, height, unit), key);
}
@Override
public List geosearch(byte[] key, GeoSearchParam params) {
return checkAndClientSideCacheCommand(commandObjects.geosearch(key, params), key);
}
@Override
public long geosearchStore(byte[] dest, byte[] src, byte[] member, double radius, GeoUnit unit) {
return executeCommand(commandObjects.geosearchStore(dest, src, member, radius, unit));
}
@Override
public long geosearchStore(byte[] dest, byte[] src, GeoCoordinate coord, double radius, GeoUnit unit) {
return executeCommand(commandObjects.geosearchStore(dest, src, coord, radius, unit));
}
@Override
public long geosearchStore(byte[] dest, byte[] src, byte[] member, double width, double height, GeoUnit unit) {
return executeCommand(commandObjects.geosearchStore(dest, src, member, width, height, unit));
}
@Override
public long geosearchStore(byte[] dest, byte[] src, GeoCoordinate coord, double width, double height, GeoUnit unit) {
return executeCommand(commandObjects.geosearchStore(dest, src, coord, width, height, unit));
}
@Override
public long geosearchStore(byte[] dest, byte[] src, GeoSearchParam params) {
return executeCommand(commandObjects.geosearchStore(dest, src, params));
}
@Override
public long geosearchStoreStoreDist(byte[] dest, byte[] src, GeoSearchParam params) {
return executeCommand(commandObjects.geosearchStoreStoreDist(dest, src, params));
}
// Geo commands
// Hyper Log Log commands
@Override
public long pfadd(String key, String... elements) {
return executeCommand(commandObjects.pfadd(key, elements));
}
@Override
public String pfmerge(String destkey, String... sourcekeys) {
return executeCommand(commandObjects.pfmerge(destkey, sourcekeys));
}
@Override
public long pfcount(String key) {
return executeCommand(commandObjects.pfcount(key));
}
@Override
public long pfcount(String... keys) {
return executeCommand(commandObjects.pfcount(keys));
}
@Override
public long pfadd(byte[] key, byte[]... elements) {
return executeCommand(commandObjects.pfadd(key, elements));
}
@Override
public String pfmerge(byte[] destkey, byte[]... sourcekeys) {
return executeCommand(commandObjects.pfmerge(destkey, sourcekeys));
}
@Override
public long pfcount(byte[] key) {
return executeCommand(commandObjects.pfcount(key));
}
@Override
public long pfcount(byte[]... keys) {
return executeCommand(commandObjects.pfcount(keys));
}
// Hyper Log Log commands
// Stream commands
@Override
public StreamEntryID xadd(String key, StreamEntryID id, Map hash) {
return executeCommand(commandObjects.xadd(key, id, hash));
}
@Override
public StreamEntryID xadd(String key, XAddParams params, Map hash) {
return executeCommand(commandObjects.xadd(key, params, hash));
}
@Override
public long xlen(String key) {
return checkAndClientSideCacheCommand(commandObjects.xlen(key), key);
}
@Override
public List xrange(String key, StreamEntryID start, StreamEntryID end) {
return checkAndClientSideCacheCommand(commandObjects.xrange(key, start, end), key);
}
@Override
public List xrange(String key, StreamEntryID start, StreamEntryID end, int count) {
return checkAndClientSideCacheCommand(commandObjects.xrange(key, start, end, count), key);
}
@Override
public List xrevrange(String key, StreamEntryID end, StreamEntryID start) {
return checkAndClientSideCacheCommand(commandObjects.xrevrange(key, end, start), key);
}
@Override
public List xrevrange(String key, StreamEntryID end, StreamEntryID start, int count) {
return checkAndClientSideCacheCommand(commandObjects.xrevrange(key, end, start, count), key);
}
@Override
public List xrange(String key, String start, String end) {
return checkAndClientSideCacheCommand(commandObjects.xrange(key, start, end), key);
}
@Override
public List xrange(String key, String start, String end, int count) {
return checkAndClientSideCacheCommand(commandObjects.xrange(key, start, end, count), key);
}
@Override
public List xrevrange(String key, String end, String start) {
return checkAndClientSideCacheCommand(commandObjects.xrevrange(key, end, start), key);
}
@Override
public List xrevrange(String key, String end, String start, int count) {
return checkAndClientSideCacheCommand(commandObjects.xrevrange(key, end, start, count), key);
}
@Override
public long xack(String key, String group, StreamEntryID... ids) {
return executeCommand(commandObjects.xack(key, group, ids));
}
@Override
public String xgroupCreate(String key, String groupName, StreamEntryID id, boolean makeStream) {
return executeCommand(commandObjects.xgroupCreate(key, groupName, id, makeStream));
}
@Override
public String xgroupSetID(String key, String groupName, StreamEntryID id) {
return executeCommand(commandObjects.xgroupSetID(key, groupName, id));
}
@Override
public long xgroupDestroy(String key, String groupName) {
return executeCommand(commandObjects.xgroupDestroy(key, groupName));
}
@Override
public boolean xgroupCreateConsumer(String key, String groupName, String consumerName) {
return executeCommand(commandObjects.xgroupCreateConsumer(key, groupName, consumerName));
}
@Override
public long xgroupDelConsumer(String key, String groupName, String consumerName) {
return executeCommand(commandObjects.xgroupDelConsumer(key, groupName, consumerName));
}
@Override
public StreamPendingSummary xpending(String key, String groupName) {
return checkAndClientSideCacheCommand(commandObjects.xpending(key, groupName), key);
}
@Override
public List xpending(String key, String groupName, XPendingParams params) {
return checkAndClientSideCacheCommand(commandObjects.xpending(key, groupName, params), key);
}
@Override
public long xdel(String key, StreamEntryID... ids) {
return executeCommand(commandObjects.xdel(key, ids));
}
@Override
public long xtrim(String key, long maxLen, boolean approximate) {
return executeCommand(commandObjects.xtrim(key, maxLen, approximate));
}
@Override
public long xtrim(String key, XTrimParams params) {
return executeCommand(commandObjects.xtrim(key, params));
}
@Override
public List xclaim(String key, String group, String consumerName, long minIdleTime, XClaimParams params, StreamEntryID... ids) {
return executeCommand(commandObjects.xclaim(key, group, consumerName, minIdleTime, params, ids));
}
@Override
public List xclaimJustId(String key, String group, String consumerName, long minIdleTime, XClaimParams params, StreamEntryID... ids) {
return executeCommand(commandObjects.xclaimJustId(key, group, consumerName, minIdleTime, params, ids));
}
@Override
public Map.Entry> xautoclaim(String key, String group, String consumerName, long minIdleTime, StreamEntryID start, XAutoClaimParams params) {
return executeCommand(commandObjects.xautoclaim(key, group, consumerName, minIdleTime, start, params));
}
@Override
public Map.Entry> xautoclaimJustId(String key, String group, String consumerName, long minIdleTime, StreamEntryID start, XAutoClaimParams params) {
return executeCommand(commandObjects.xautoclaimJustId(key, group, consumerName, minIdleTime, start, params));
}
@Override
public StreamInfo xinfoStream(String key) {
return executeCommand(commandObjects.xinfoStream(key));
}
@Override
public StreamFullInfo xinfoStreamFull(String key) {
return executeCommand(commandObjects.xinfoStreamFull(key));
}
@Override
public StreamFullInfo xinfoStreamFull(String key, int count) {
return executeCommand(commandObjects.xinfoStreamFull(key, count));
}
@Override
public List xinfoGroups(String key) {
return executeCommand(commandObjects.xinfoGroups(key));
}
@Override
public List xinfoConsumers(String key, String group) {
return executeCommand(commandObjects.xinfoConsumers(key, group));
}
@Override
public List xinfoConsumers2(String key, String group) {
return executeCommand(commandObjects.xinfoConsumers2(key, group));
}
@Override
public List>> xread(XReadParams xReadParams, Map streams) {
return executeCommand(commandObjects.xread(xReadParams, streams));
}
@Override
public List>> xreadGroup(String groupName, String consumer,
XReadGroupParams xReadGroupParams, Map streams) {
return executeCommand(commandObjects.xreadGroup(groupName, consumer, xReadGroupParams, streams));
}
@Override
public byte[] xadd(byte[] key, XAddParams params, Map hash) {
return executeCommand(commandObjects.xadd(key, params, hash));
}
@Override
public long xlen(byte[] key) {
return checkAndClientSideCacheCommand(commandObjects.xlen(key), key);
}
@Override
public List