All Downloads are FREE. Search and download functionalities are using the official Maven repository.
  • Log In
  • Register

    • redis.clients.jedis.TransactionBase Maven / Gradle / Ivy

    There is a newer version: 5.2.0
    Show newest version
    package redis.clients.jedis;

import static redis.clients.jedis.Protocol.Command.DISCARD;
import static redis.clients.jedis.Protocol.Command.EXEC;
import static redis.clients.jedis.Protocol.Command.MULTI;
import static redis.clients.jedis.Protocol.Command.UNWATCH;
import static redis.clients.jedis.Protocol.Command.WATCH;

import java.io.Closeable;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.json.JSONArray;

import redis.clients.jedis.args.*;
import redis.clients.jedis.bloom.*;
import redis.clients.jedis.commands.PipelineBinaryCommands;
import redis.clients.jedis.commands.PipelineCommands;
import redis.clients.jedis.commands.ProtocolCommand;
import redis.clients.jedis.commands.RedisModulePipelineCommands;
import redis.clients.jedis.exceptions.JedisConnectionException;
import redis.clients.jedis.exceptions.JedisDataException;
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.params.*;
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.schemafields.SchemaField;
import redis.clients.jedis.timeseries.*;
import redis.clients.jedis.util.KeyValue;

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

  protected final Connection connection;
  private final boolean closeConnection;
  private final CommandObjects commandObjects;
  private final GraphCommandObjects graphCommandObjects;

  private boolean broken = false;
  private boolean inWatch = false;
  private boolean inMulti = false;

  /**
   * Creates a new transaction.
   * 
   * A MULTI command will be added to be sent to server. WATCH/UNWATCH/MULTI commands must not be
   * called with this object.
   * @param connection connection
   */
  public TransactionBase(Connection connection) {
    this(connection, true);
  }

  /**
   * Creates a new transaction.
   *
   * A user wanting to WATCH/UNWATCH keys followed by a call to MULTI ({@link #multi()}) it should
   * be {@code doMulti=false}.
   *
   * @param connection connection
   * @param doMulti {@code false} should be set to enable manual WATCH, UNWATCH and MULTI
   */
  public TransactionBase(Connection connection, boolean doMulti) {
    this(connection, doMulti, false);
  }

  /**
   * Creates a new transaction.
   *
   * A user wanting to WATCH/UNWATCH keys followed by a call to MULTI ({@link #multi()}) it should
   * be {@code doMulti=false}.
   *
   * @param connection connection
   * @param doMulti {@code false} should be set to enable manual WATCH, UNWATCH and MULTI
   * @param closeConnection should the 'connection' be closed when 'close()' is called?
   */
  public TransactionBase(Connection connection, boolean doMulti, boolean closeConnection) {
    this.connection = connection;
    this.closeConnection = closeConnection;
    this.commandObjects = new CommandObjects();
    this.graphCommandObjects = new GraphCommandObjects(this.connection);
    if (doMulti) multi();
  }

  public final void multi() {
    connection.sendCommand(MULTI);
    processMultiResponse();
    inMulti = true;
  }

  public String watch(final String... keys) {
    connection.sendCommand(WATCH, keys);
    String status = connection.getStatusCodeReply();
    inWatch = true;
    return status;
  }

  public String watch(final byte[]... keys) {
    connection.sendCommand(WATCH, keys);
    String status = connection.getStatusCodeReply();
    inWatch = true;
    return status;
  }

  public String unwatch() {
    connection.sendCommand(UNWATCH);
    String status = connection.getStatusCodeReply();
    inWatch = false;
    return status;
  }

  protected abstract void processMultiResponse();

  protected abstract void processAppendStatus();

  protected final  Response appendCommand(CommandObject commandObject) {
    connection.sendCommand(commandObject.getArguments());
    processAppendStatus();
    return enqueResponse(commandObject.getBuilder());
  }

  @Override
  public final void close() {
    try {
      clear();
    } finally {
      if (closeConnection) {
        connection.close();
      }
    }
  }

  public final void clear() {
    if (broken) {
      return;
    }
    if (inMulti) {
      discard();
    } else if (inWatch) {
      unwatch();
    }
  }

  protected abstract void processPipelinedResponses();

  public List exec() {
    if (!inMulti) {
      throw new IllegalStateException("EXEC without MULTI");
    }

    try {
      processPipelinedResponses();
      connection.sendCommand(EXEC);

      List unformatted = connection.getObjectMultiBulkReply();
      if (unformatted == null) {
        clean();
        return null;
      }

      List formatted = new ArrayList<>(unformatted.size());
      for (Object o : unformatted) {
        try {
          formatted.add(generateResponse(o).get());
        } catch (JedisDataException e) {
          formatted.add(e);
        }
      }
      return formatted;
    } catch (JedisConnectionException jce) {
      broken = true;
      throw jce;
    } finally {
      inMulti = false;
      inWatch = false;
      clean();
    }
  }

  public String discard() {
    if (!inMulti) {
      throw new IllegalStateException("DISCARD without MULTI");
    }

    try {
      processPipelinedResponses();
      connection.sendCommand(DISCARD);
      return connection.getStatusCodeReply();
    } catch (JedisConnectionException jce) {
      broken = true;
      throw jce;
    } finally {
      inMulti = false;
      inWatch = false;
      clean();
    }
  }

  @Override
  public Response exists(String key) {
    return appendCommand(commandObjects.exists(key));
  }

  @Override
  public Response exists(String... keys) {
    return appendCommand(commandObjects.exists(keys));
  }

  @Override
  public Response persist(String key) {
    return appendCommand(commandObjects.persist(key));
  }

  @Override
  public Response type(String key) {
    return appendCommand(commandObjects.type(key));
  }

  @Override
  public Response dump(String key) {
    return appendCommand(commandObjects.dump(key));
  }

  @Override
  public Response restore(String key, long ttl, byte[] serializedValue) {
    return appendCommand(commandObjects.restore(key, ttl, serializedValue));
  }

  @Override
  public Response restore(String key, long ttl, byte[] serializedValue, RestoreParams params) {
    return appendCommand(commandObjects.restore(key, ttl, serializedValue, params));
  }

  @Override
  public Response expire(String key, long seconds) {
    return appendCommand(commandObjects.expire(key, seconds));
  }

  @Override
  public Response expire(String key, long seconds, ExpiryOption expiryOption) {
    return appendCommand(commandObjects.expire(key, seconds, expiryOption));
  }

  @Override
  public Response pexpire(String key, long milliseconds) {
    return appendCommand(commandObjects.pexpire(key, milliseconds));
  }

  @Override
  public Response pexpire(String key, long milliseconds, ExpiryOption expiryOption) {
    return appendCommand(commandObjects.pexpire(key, milliseconds, expiryOption));
  }

  @Override
  public Response expireTime(String key) {
    return appendCommand(commandObjects.expireTime(key));
  }

  @Override
  public Response pexpireTime(String key) {
    return appendCommand(commandObjects.pexpireTime(key));
  }

  @Override
  public Response expireAt(String key, long unixTime) {
    return appendCommand(commandObjects.expireAt(key, unixTime));
  }

  @Override
  public Response expireAt(String key, long unixTime, ExpiryOption expiryOption) {
    return appendCommand(commandObjects.expireAt(key, unixTime, expiryOption));
  }

  @Override
  public Response pexpireAt(String key, long millisecondsTimestamp) {
    return appendCommand(commandObjects.pexpireAt(key, millisecondsTimestamp));
  }

  @Override
  public Response pexpireAt(String key, long millisecondsTimestamp, ExpiryOption expiryOption) {
    return appendCommand(commandObjects.pexpireAt(key, millisecondsTimestamp, expiryOption));
  }

  @Override
  public Response ttl(String key) {
    return appendCommand(commandObjects.ttl(key));
  }

  @Override
  public Response pttl(String key) {
    return appendCommand(commandObjects.pttl(key));
  }

  @Override
  public Response touch(String key) {
    return appendCommand(commandObjects.touch(key));
  }

  @Override
  public Response touch(String... keys) {
    return appendCommand(commandObjects.touch(keys));
  }

  @Override
  public Response> sort(String key) {
    return appendCommand(commandObjects.sort(key));
  }

  @Override
  public Response sort(String key, String dstKey) {
    return appendCommand(commandObjects.sort(key, dstKey));
  }

  @Override
  public Response> sort(String key, SortingParams sortingParams) {
    return appendCommand(commandObjects.sort(key, sortingParams));
  }

  @Override
  public Response sort(String key, SortingParams sortingParams, String dstKey) {
    return appendCommand(commandObjects.sort(key, sortingParams, dstKey));
  }

  @Override
  public Response> sortReadonly(String key, SortingParams sortingParams) {
    return appendCommand(commandObjects.sortReadonly(key, sortingParams));
  }

  @Override
  public Response del(String key) {
    return appendCommand(commandObjects.del(key));
  }

  @Override
  public Response del(String... keys) {
    return appendCommand(commandObjects.del(keys));
  }

  @Override
  public Response unlink(String key) {
    return appendCommand(commandObjects.unlink(key));
  }

  @Override
  public Response unlink(String... keys) {
    return appendCommand(commandObjects.unlink(keys));
  }

  @Override
  public Response copy(String srcKey, String dstKey, boolean replace) {
    return appendCommand(commandObjects.copy(srcKey, dstKey, replace));
  }

  @Override
  public Response rename(String oldkey, String newkey) {
    return appendCommand(commandObjects.rename(oldkey, newkey));
  }

  @Override
  public Response renamenx(String oldkey, String newkey) {
    return appendCommand(commandObjects.renamenx(oldkey, newkey));
  }

  @Override
  public Response memoryUsage(String key) {
    return appendCommand(commandObjects.memoryUsage(key));
  }

  @Override
  public Response memoryUsage(String key, int samples) {
    return appendCommand(commandObjects.memoryUsage(key, samples));
  }

  @Override
  public Response objectRefcount(String key) {
    return appendCommand(commandObjects.objectRefcount(key));
  }

  @Override
  public Response objectEncoding(String key) {
    return appendCommand(commandObjects.objectEncoding(key));
  }

  @Override
  public Response objectIdletime(String key) {
    return appendCommand(commandObjects.objectIdletime(key));
  }

  @Override
  public Response objectFreq(String key) {
    return appendCommand(commandObjects.objectFreq(key));
  }

  @Override
  public Response migrate(String host, int port, String key, int timeout) {
    return appendCommand(commandObjects.migrate(host, port, key, timeout));
  }

  @Override
  public Response migrate(String host, int port, int timeout, MigrateParams params, String... keys) {
    return appendCommand(commandObjects.migrate(host, port, timeout, params, keys));
  }

  @Override
  public Response> keys(String pattern) {
    return appendCommand(commandObjects.keys(pattern));
  }

  @Override
  public Response> scan(String cursor) {
    return appendCommand(commandObjects.scan(cursor));
  }

  @Override
  public Response> scan(String cursor, ScanParams params) {
    return appendCommand(commandObjects.scan(cursor, params));
  }

  @Override
  public Response> scan(String cursor, ScanParams params, String type) {
    return appendCommand(commandObjects.scan(cursor, params, type));
  }

  @Override
  public Response randomKey() {
    return appendCommand(commandObjects.randomKey());
  }

  @Override
  public Response get(String key) {
    return appendCommand(commandObjects.get(key));
  }

  @Override
  public Response setGet(String key, String value, SetParams params) {
    return appendCommand(commandObjects.setGet(key, value, params));
  }

  @Override
  public Response getDel(String key) {
    return appendCommand(commandObjects.getDel(key));
  }

  @Override
  public Response getEx(String key, GetExParams params) {
    return appendCommand(commandObjects.getEx(key, params));
  }

  @Override
  public Response setbit(String key, long offset, boolean value) {
    return appendCommand(commandObjects.setbit(key, offset, value));
  }

  @Override
  public Response getbit(String key, long offset) {
    return appendCommand(commandObjects.getbit(key, offset));
  }

  @Override
  public Response setrange(String key, long offset, String value) {
    return appendCommand(commandObjects.setrange(key, offset, value));
  }

  @Override
  public Response getrange(String key, long startOffset, long endOffset) {
    return appendCommand(commandObjects.getrange(key, startOffset, endOffset));
  }

  @Override
  public Response getSet(String key, String value) {
    return appendCommand(commandObjects.getSet(key, value));
  }

  @Override
  public Response setnx(String key, String value) {
    return appendCommand(commandObjects.setnx(key, value));
  }

  @Override
  public Response setex(String key, long seconds, String value) {
    return appendCommand(commandObjects.setex(key, seconds, value));
  }

  @Override
  public Response psetex(String key, long milliseconds, String value) {
    return appendCommand(commandObjects.psetex(key, milliseconds, value));
  }

  @Override
  public Response> mget(String... keys) {
    return appendCommand(commandObjects.mget(keys));
  }

  @Override
  public Response mset(String... keysvalues) {
    return appendCommand(commandObjects.mset(keysvalues));
  }

  @Override
  public Response msetnx(String... keysvalues) {
    return appendCommand(commandObjects.msetnx(keysvalues));
  }

  @Override
  public Response incr(String key) {
    return appendCommand(commandObjects.incr(key));
  }

  @Override
  public Response incrBy(String key, long increment) {
    return appendCommand(commandObjects.incrBy(key, increment));
  }

  @Override
  public Response incrByFloat(String key, double increment) {
    return appendCommand(commandObjects.incrByFloat(key, increment));
  }

  @Override
  public Response decr(String key) {
    return appendCommand(commandObjects.decr(key));
  }

  @Override
  public Response decrBy(String key, long decrement) {
    return appendCommand(commandObjects.decrBy(key, decrement));
  }

  @Override
  public Response append(String key, String value) {
    return appendCommand(commandObjects.append(key, value));
  }

  @Override
  public Response substr(String key, int start, int end) {
    return appendCommand(commandObjects.substr(key, start, end));
  }

  @Override
  public Response strlen(String key) {
    return appendCommand(commandObjects.strlen(key));
  }

  @Override
  public Response bitcount(String key) {
    return appendCommand(commandObjects.bitcount(key));
  }

  @Override
  public Response bitcount(String key, long start, long end) {
    return appendCommand(commandObjects.bitcount(key, start, end));
  }

  @Override
  public Response bitcount(String key, long start, long end, BitCountOption option) {
    return appendCommand(commandObjects.bitcount(key, start, end, option));
  }

  @Override
  public Response bitpos(String key, boolean value) {
    return appendCommand(commandObjects.bitpos(key, value));
  }

  @Override
  public Response bitpos(String key, boolean value, BitPosParams params) {
    return appendCommand(commandObjects.bitpos(key, value, params));
  }

  @Override
  public Response> bitfield(String key, String... arguments) {
    return appendCommand(commandObjects.bitfield(key, arguments));
  }

  @Override
  public Response> bitfieldReadonly(String key, String... arguments) {
    return appendCommand(commandObjects.bitfieldReadonly(key, arguments));
  }

  @Override
  public Response bitop(BitOP op, String destKey, String... srcKeys) {
    return appendCommand(commandObjects.bitop(op, destKey, srcKeys));
  }

  @Override
  public Response strAlgoLCSKeys(String keyA, String keyB, StrAlgoLCSParams params) {
    return appendCommand(commandObjects.strAlgoLCSKeys(keyA, keyB, params));
  }

  @Override
  public Response lcs(String keyA, String keyB, LCSParams params) {
    return appendCommand(commandObjects.lcs(keyA, keyB, params));
  }

  @Override
  public Response set(String key, String value) {
    return appendCommand(commandObjects.set(key, value));
  }

  @Override
  public Response set(String key, String value, SetParams params) {
    return appendCommand(commandObjects.set(key, value, params));
  }

  @Override
  public Response rpush(String key, String... string) {
    return appendCommand(commandObjects.rpush(key, string));

  }

  @Override
  public Response lpush(String key, String... string) {
    return appendCommand(commandObjects.lpush(key, string));
  }

  @Override
  public Response llen(String key) {
    return appendCommand(commandObjects.llen(key));
  }

  @Override
  public Response> lrange(String key, long start, long stop) {
    return appendCommand(commandObjects.lrange(key, start, stop));
  }

  @Override
  public Response ltrim(String key, long start, long stop) {
    return appendCommand(commandObjects.ltrim(key, start, stop));
  }

  @Override
  public Response lindex(String key, long index) {
    return appendCommand(commandObjects.lindex(key, index));
  }

  @Override
  public Response lset(String key, long index, String value) {
    return appendCommand(commandObjects.lset(key, index, value));
  }

  @Override
  public Response lrem(String key, long count, String value) {
    return appendCommand(commandObjects.lrem(key, count, value));
  }

  @Override
  public Response lpop(String key) {
    return appendCommand(commandObjects.lpop(key));
  }

  @Override
  public Response> lpop(String key, int count) {
    return appendCommand(commandObjects.lpop(key, count));
  }

  @Override
  public Response lpos(String key, String element) {
    return appendCommand(commandObjects.lpos(key, element));
  }

  @Override
  public Response lpos(String key, String element, LPosParams params) {
    return appendCommand(commandObjects.lpos(key, element, params));
  }

  @Override
  public Response> lpos(String key, String element, LPosParams params, long count) {
    return appendCommand(commandObjects.lpos(key, element, params, count));
  }

  @Override
  public Response rpop(String key) {
    return appendCommand(commandObjects.rpop(key));
  }

  @Override
  public Response> rpop(String key, int count) {
    return appendCommand(commandObjects.rpop(key, count));
  }

  @Override
  public Response linsert(String key, ListPosition where, String pivot, String value) {
    return appendCommand(commandObjects.linsert(key, where, pivot, value));
  }

  @Override
  public Response lpushx(String key, String... strings) {
    return appendCommand(commandObjects.lpushx(key, strings));
  }

  @Override
  public Response rpushx(String key, String... strings) {
    return appendCommand(commandObjects.rpushx(key, strings));
  }

  @Override
  public Response> blpop(int timeout, String key) {
    return appendCommand(commandObjects.blpop(timeout, key));
  }

  @Override
  public Response blpop(double timeout, String key) {
    return appendCommand(commandObjects.blpop(timeout, key));
  }

  @Override
  public Response> brpop(int timeout, String key) {
    return appendCommand(commandObjects.brpop(timeout, key));
  }

  @Override
  public Response brpop(double timeout, String key) {
    return appendCommand(commandObjects.brpop(timeout, key));
  }

  @Override
  public Response> blpop(int timeout, String... keys) {
    return appendCommand(commandObjects.blpop(timeout, keys));
  }

  @Override
  public Response blpop(double timeout, String... keys) {
    return appendCommand(commandObjects.blpop(timeout, keys));
  }

  @Override
  public Response> brpop(int timeout, String... keys) {
    return appendCommand(commandObjects.brpop(timeout, keys));
  }

  @Override
  public Response brpop(double timeout, String... keys) {
    return appendCommand(commandObjects.brpop(timeout, keys));
  }

  @Override
  public Response rpoplpush(String srcKey, String dstKey) {
    return appendCommand(commandObjects.rpoplpush(srcKey, dstKey));
  }

  @Override
  public Response brpoplpush(String source, String destination, int timeout) {
    return appendCommand(commandObjects.brpoplpush(source, destination, timeout));
  }

  @Override
  public Response lmove(String srcKey, String dstKey, ListDirection from, ListDirection to) {
    return appendCommand(commandObjects.lmove(srcKey, dstKey, from, to));
  }

  @Override
  public Response blmove(String srcKey, String dstKey, ListDirection from, ListDirection to, double timeout) {
    return appendCommand(commandObjects.blmove(srcKey, dstKey, from, to, timeout));
  }

  @Override
  public Response>> lmpop(ListDirection direction, String... keys) {
    return appendCommand(commandObjects.lmpop(direction, keys));
  }

  @Override
  public Response>> lmpop(ListDirection direction, int count, String... keys) {
    return appendCommand(commandObjects.lmpop(direction, count, keys));
  }

  @Override
  public Response>> blmpop(long timeout, ListDirection direction, String... keys) {
    return appendCommand(commandObjects.blmpop(timeout, direction, keys));
  }

  @Override
  public Response>> blmpop(long timeout, ListDirection direction, int count, String... keys) {
    return appendCommand(commandObjects.blmpop(timeout, direction, count, keys));
  }

  @Override
  public Response hset(String key, String field, String value) {
    return appendCommand(commandObjects.hset(key, field, value));
  }

  @Override
  public Response hset(String key, Map hash) {
    return appendCommand(commandObjects.hset(key, hash));
  }

  @Override
  public Response hget(String key, String field) {
    return appendCommand(commandObjects.hget(key, field));
  }

  @Override
  public Response hsetnx(String key, String field, String value) {
    return appendCommand(commandObjects.hsetnx(key, field, value));
  }

  @Override
  public Response hmset(String key, Map hash) {
    return appendCommand(commandObjects.hmset(key, hash));
  }

  @Override
  public Response> hmget(String key, String... fields) {
    return appendCommand(commandObjects.hmget(key, fields));
  }

  @Override
  public Response hincrBy(String key, String field, long value) {
    return appendCommand(commandObjects.hincrBy(key, field, value));
  }

  @Override
  public Response hincrByFloat(String key, String field, double value) {
    return appendCommand(commandObjects.hincrByFloat(key, field, value));
  }

  @Override
  public Response hexists(String key, String field) {
    return appendCommand(commandObjects.hexists(key, field));
  }

  @Override
  public Response hdel(String key, String... field) {
    return appendCommand(commandObjects.hdel(key, field));
  }

  @Override
  public Response hlen(String key) {
    return appendCommand(commandObjects.hlen(key));
  }

  @Override
  public Response> hkeys(String key) {
    return appendCommand(commandObjects.hkeys(key));
  }

  @Override
  public Response> hvals(String key) {
    return appendCommand(commandObjects.hvals(key));
  }

  @Override
  public Response> hgetAll(String key) {
    return appendCommand(commandObjects.hgetAll(key));
  }

  @Override
  public Response hrandfield(String key) {
    return appendCommand(commandObjects.hrandfield(key));
  }

  @Override
  public Response> hrandfield(String key, long count) {
    return appendCommand(commandObjects.hrandfield(key, count));
  }

  @Override
  public Response> hrandfieldWithValues(String key, long count) {
    return appendCommand(commandObjects.hrandfieldWithValues(key, count));
  }

  @Override
  public Response>> hscan(String key, String cursor, ScanParams params) {
    return appendCommand(commandObjects.hscan(key, cursor, params));
  }

  @Override
  public Response hstrlen(String key, String field) {
    return appendCommand(commandObjects.hstrlen(key, field));
  }

  @Override
  public Response sadd(String key, String... members) {
    return appendCommand(commandObjects.sadd(key, members));
  }

  @Override
  public Response> smembers(String key) {
    return appendCommand(commandObjects.smembers(key));
  }

  @Override
  public Response srem(String key, String... members) {
    return appendCommand(commandObjects.srem(key, members));
  }

  @Override
  public Response spop(String key) {
    return appendCommand(commandObjects.spop(key));
  }

  @Override
  public Response> spop(String key, long count) {
    return appendCommand(commandObjects.spop(key, count));
  }

  @Override
  public Response scard(String key) {
    return appendCommand(commandObjects.scard(key));
  }

  @Override
  public Response sismember(String key, String member) {
    return appendCommand(commandObjects.sismember(key, member));
  }

  @Override
  public Response> smismember(String key, String... members) {
    return appendCommand(commandObjects.smismember(key, members));
  }

  @Override
  public Response srandmember(String key) {
    return appendCommand(commandObjects.srandmember(key));
  }

  @Override
  public Response> srandmember(String key, int count) {
    return appendCommand(commandObjects.srandmember(key, count));
  }

  @Override
  public Response> sscan(String key, String cursor, ScanParams params) {
    return appendCommand(commandObjects.sscan(key, cursor, params));
  }

  @Override
  public Response> sdiff(String... keys) {
    return appendCommand(commandObjects.sdiff(keys));
  }

  @Override
  public Response sdiffstore(String dstKey, String... keys) {
    return appendCommand(commandObjects.sdiffstore(dstKey, keys));
  }

  @Override
  public Response> sinter(String... keys) {
    return appendCommand(commandObjects.sinter(keys));
  }

  @Override
  public Response sinterstore(String dstKey, String... keys) {
    return appendCommand(commandObjects.sinterstore(dstKey, keys));
  }

  @Override
  public Response sintercard(String... keys) {
    return appendCommand(commandObjects.sintercard(keys));
  }

  @Override
  public Response sintercard(int limit, String... keys) {
    return appendCommand(commandObjects.sintercard(limit, keys));
  }

  @Override
  public Response> sunion(String... keys) {
    return appendCommand(commandObjects.sunion(keys));
  }

  @Override
  public Response sunionstore(String dstKey, String... keys) {
    return appendCommand(commandObjects.sunionstore(dstKey, keys));
  }

  @Override
  public Response smove(String srcKey, String dstKey, String member) {
    return appendCommand(commandObjects.smove(srcKey, dstKey, member));
  }

  @Override
  public Response zadd(String key, double score, String member) {
    return appendCommand(commandObjects.zadd(key, score, member));
  }

  @Override
  public Response zadd(String key, double score, String member, ZAddParams params) {
    return appendCommand(commandObjects.zadd(key, score, member, params));
  }

  @Override
  public Response zadd(String key, Map scoreMembers) {
    return appendCommand(commandObjects.zadd(key, scoreMembers));
  }

  @Override
  public Response zadd(String key, Map scoreMembers, ZAddParams params) {
    return appendCommand(commandObjects.zadd(key, scoreMembers, params));
  }

  @Override
  public Response zaddIncr(String key, double score, String member, ZAddParams params) {
    return appendCommand(commandObjects.zaddIncr(key, score, member, params));
  }

  @Override
  public Response zrem(String key, String... members) {
    return appendCommand(commandObjects.zrem(key, members));
  }

  @Override
  public Response zincrby(String key, double increment, String member) {
    return appendCommand(commandObjects.zincrby(key, increment, member));
  }

  @Override
  public Response zincrby(String key, double increment, String member, ZIncrByParams params) {
    return appendCommand(commandObjects.zincrby(key, increment, member, params));
  }

  @Override
  public Response zrank(String key, String member) {
    return appendCommand(commandObjects.zrank(key, member));
  }

  @Override
  public Response zrevrank(String key, String member) {
    return appendCommand(commandObjects.zrevrank(key, member));
  }

  @Override
  public Response> zrankWithScore(String key, String member) {
    return appendCommand(commandObjects.zrankWithScore(key, member));
  }

  @Override
  public Response> zrevrankWithScore(String key, String member) {
    return appendCommand(commandObjects.zrevrankWithScore(key, member));
  }

  @Override
  public Response> zrange(String key, long start, long stop) {
    return appendCommand(commandObjects.zrange(key, start, stop));
  }

  @Override
  public Response> zrevrange(String key, long start, long stop) {
    return appendCommand(commandObjects.zrevrange(key, start, stop));
  }

  @Override
  public Response> zrangeWithScores(String key, long start, long stop) {
    return appendCommand(commandObjects.zrangeWithScores(key, start, stop));
  }

  @Override
  public Response> zrevrangeWithScores(String key, long start, long stop) {
    return appendCommand(commandObjects.zrevrangeWithScores(key, start, stop));
  }

  @Override
  public Response> zrange(String key, ZRangeParams zRangeParams) {
    return appendCommand(commandObjects.zrange(key, zRangeParams));
  }

  @Override
  public Response> zrangeWithScores(String key, ZRangeParams zRangeParams) {
    return appendCommand(commandObjects.zrangeWithScores(key, zRangeParams));
  }

  @Override
  public Response zrangestore(String dest, String src, ZRangeParams zRangeParams) {
    return appendCommand(commandObjects.zrangestore(dest, src, zRangeParams));
  }

  @Override
  public Response zrandmember(String key) {
    return appendCommand(commandObjects.zrandmember(key));
  }

  @Override
  public Response> zrandmember(String key, long count) {
    return appendCommand(commandObjects.zrandmember(key, count));
  }

  @Override
  public Response> zrandmemberWithScores(String key, long count) {
    return appendCommand(commandObjects.zrandmemberWithScores(key, count));
  }

  @Override
  public Response zcard(String key) {
    return appendCommand(commandObjects.zcard(key));
  }

  @Override
  public Response zscore(String key, String member) {
    return appendCommand(commandObjects.zscore(key, member));
  }

  @Override
  public Response> zmscore(String key, String... members) {
    return appendCommand(commandObjects.zmscore(key, members));
  }

  @Override
  public Response zpopmax(String key) {
    return appendCommand(commandObjects.zpopmax(key));
  }

  @Override
  public Response> zpopmax(String key, int count) {
    return appendCommand(commandObjects.zpopmax(key, count));
  }

  @Override
  public Response zpopmin(String key) {
    return appendCommand(commandObjects.zpopmin(key));
  }

  @Override
  public Response> zpopmin(String key, int count) {
    return appendCommand(commandObjects.zpopmin(key, count));
  }

  @Override
  public Response zcount(String key, double min, double max) {
    return appendCommand(commandObjects.zcount(key, min, max));
  }

  @Override
  public Response zcount(String key, String min, String max) {
    return appendCommand(commandObjects.zcount(key, min, max));
  }

  @Override
  public Response> zrangeByScore(String key, double min, double max) {
    return appendCommand(commandObjects.zrangeByScore(key, min, max));
  }

  @Override
  public Response> zrangeByScore(String key, String min, String max) {
    return appendCommand(commandObjects.zrangeByScore(key, min, max));
  }

  @Override
  public Response> zrevrangeByScore(String key, double max, double min) {
    return appendCommand(commandObjects.zrevrangeByScore(key, max, min));

  }

  @Override
  public Response> zrangeByScore(String key, double min, double max, int offset, int count) {
    return appendCommand(commandObjects.zrangeByScore(key, min, max, offset, count));
  }

  @Override
  public Response> zrevrangeByScore(String key, String max, String min) {
    return appendCommand(commandObjects.zrevrangeByScore(key, max, min));
  }

  @Override
  public Response> zrangeByScore(String key, String min, String max, int offset, int count) {
    return appendCommand(commandObjects.zrangeByScore(key, min, max, offset, count));
  }

  @Override
  public Response> zrevrangeByScore(String key, double max, double min, int offset, int count) {
    return appendCommand(commandObjects.zrevrangeByScore(key, max, min, offset, count));
  }

  @Override
  public Response> zrangeByScoreWithScores(String key, double min, double max) {
    return appendCommand(commandObjects.zrangeByScoreWithScores(key, min, max));
  }

  @Override
  public Response> zrevrangeByScoreWithScores(String key, double max, double min) {
    return appendCommand(commandObjects.zrevrangeByScoreWithScores(key, max, min));
  }

  @Override
  public Response> zrangeByScoreWithScores(String key, double min, double max, int offset, int count) {
    return appendCommand(commandObjects.zrangeByScoreWithScores(key, min, max, offset, count));
  }

  @Override
  public Response> zrevrangeByScore(String key, String max, String min, int offset, int count) {
    return appendCommand(commandObjects.zrevrangeByScore(key, max, min, offset, count));
  }

  @Override
  public Response> zrangeByScoreWithScores(String key, String min, String max) {
    return appendCommand(commandObjects.zrangeByScoreWithScores(key, min, max));
  }

  @Override
  public Response> zrevrangeByScoreWithScores(String key, String max, String min) {
    return appendCommand(commandObjects.zrevrangeByScoreWithScores(key, max, min));
  }

  @Override
  public Response> zrangeByScoreWithScores(String key, String min, String max, int offset, int count) {
    return appendCommand(commandObjects.zrangeByScoreWithScores(key, min, max, offset, count));
  }

  @Override
  public Response> zrevrangeByScoreWithScores(String key, double max, double min, int offset, int count) {
    return appendCommand(commandObjects.zrevrangeByScoreWithScores(key, max, min, offset, count));
  }

  @Override
  public Response> zrevrangeByScoreWithScores(String key, String max, String min, int offset, int count) {
    return appendCommand(commandObjects.zrevrangeByScoreWithScores(key, max, min, offset, count));
  }

  @Override
  public Response zremrangeByRank(String key, long start, long stop) {
    return appendCommand(commandObjects.zremrangeByRank(key, start, stop));
  }

  @Override
  public Response zremrangeByScore(String key, double min, double max) {
    return appendCommand(commandObjects.zremrangeByScore(key, min, max));
  }

  @Override
  public Response zremrangeByScore(String key, String min, String max) {
    return appendCommand(commandObjects.zremrangeByScore(key, min, max));
  }

  @Override
  public Response zlexcount(String key, String min, String max) {
    return appendCommand(commandObjects.zlexcount(key, min, max));
  }

  @Override
  public Response> zrangeByLex(String key, String min, String max) {
    return appendCommand(commandObjects.zrangeByLex(key, min, max));
  }

  @Override
  public Response> zrangeByLex(String key, String min, String max, int offset, int count) {
    return appendCommand(commandObjects.zrangeByLex(key, min, max, offset, count));
  }

  @Override
  public Response> zrevrangeByLex(String key, String max, String min) {
    return appendCommand(commandObjects.zrevrangeByLex(key, max, min));
  }

  @Override
  public Response> zrevrangeByLex(String key, String max, String min, int offset, int count) {
    return appendCommand(commandObjects.zrevrangeByLex(key, max, min, offset, count));
  }

  @Override
  public Response zremrangeByLex(String key, String min, String max) {
    return appendCommand(commandObjects.zremrangeByLex(key, min, max));
  }

  @Override
  public Response> zscan(String key, String cursor, ScanParams params) {
    return appendCommand(commandObjects.zscan(key, cursor, params));
  }

  @Override
  public Response bzpopmax(double timeout, String... keys) {
    return appendCommand(commandObjects.bzpopmax(timeout, keys));
  }

  @Override
  public Response bzpopmin(double timeout, String... keys) {
    return appendCommand(commandObjects.bzpopmin(timeout, keys));
  }

  @Override
  public Response>> zmpop(SortedSetOption option, String... keys) {
    return appendCommand(commandObjects.zmpop(option, keys));
  }

  @Override
  public Response>> zmpop(SortedSetOption option, int count, String... keys) {
    return appendCommand(commandObjects.zmpop(option, count, keys));
  }

  @Override
  public Response>> bzmpop(long timeout, SortedSetOption option, String... keys) {
    return appendCommand(commandObjects.bzmpop(timeout, option, keys));
  }

  @Override
  public Response>> bzmpop(long timeout, SortedSetOption option, int count, String... keys) {
    return appendCommand(commandObjects.bzmpop(timeout, option, count, keys));
  }

  @Override
  public Response> zdiff(String... keys) {
    return appendCommand(commandObjects.zdiff(keys));
  }

  @Override
  public Response> zdiffWithScores(String... keys) {
    return appendCommand(commandObjects.zdiffWithScores(keys));
  }

  @Override
  public Response zdiffStore(String dstKey, String... keys) {
    return appendCommand(commandObjects.zdiffStore(dstKey, keys));
  }

  @Override
  public Response zinterstore(String dstKey, String... sets) {
    return appendCommand(commandObjects.zinterstore(dstKey, sets));
  }

  @Override
  public Response zinterstore(String dstKey, ZParams params, String... sets) {
    return appendCommand(commandObjects.zinterstore(dstKey, params, sets));
  }

  @Override
  public Response> zinter(ZParams params, String... keys) {
    return appendCommand(commandObjects.zinter(params, keys));
  }

  @Override
  public Response> zinterWithScores(ZParams params, String... keys) {
    return appendCommand(commandObjects.zinterWithScores(params, keys));
  }

  @Override
  public Response zintercard(String... keys) {
    return appendCommand(commandObjects.zintercard(keys));
  }

  @Override
  public Response zintercard(long limit, String... keys) {
    return appendCommand(commandObjects.zintercard(limit, keys));
  }

  @Override
  public Response> zunion(ZParams params, String... keys) {
    return appendCommand(commandObjects.zunion(params, keys));
  }

  @Override
  public Response> zunionWithScores(ZParams params, String... keys) {
    return appendCommand(commandObjects.zunionWithScores(params, keys));
  }

  @Override
  public Response zunionstore(String dstKey, String... sets) {
    return appendCommand(commandObjects.zunionstore(dstKey, sets));
  }

  @Override
  public Response zunionstore(String dstKey, ZParams params, String... sets) {
    return appendCommand(commandObjects.zunionstore(dstKey, params, sets));
  }

  @Override
  public Response geoadd(String key, double longitude, double latitude, String member) {
    return appendCommand(commandObjects.geoadd(key, longitude, latitude, member));
  }

  @Override
  public Response geoadd(String key, Map memberCoordinateMap) {
    return appendCommand(commandObjects.geoadd(key, memberCoordinateMap));
  }

  @Override
  public Response geoadd(String key, GeoAddParams params, Map memberCoordinateMap) {
    return appendCommand(commandObjects.geoadd(key, params, memberCoordinateMap));
  }

  @Override
  public Response geodist(String key, String member1, String member2) {
    return appendCommand(commandObjects.geodist(key, member1, member2));
  }

  @Override
  public Response geodist(String key, String member1, String member2, GeoUnit unit) {
    return appendCommand(commandObjects.geodist(key, member1, member2, unit));
  }

  @Override
  public Response> geohash(String key, String... members) {
    return appendCommand(commandObjects.geohash(key, members));
  }

  @Override
  public Response> geopos(String key, String... members) {
    return appendCommand(commandObjects.geopos(key, members));
  }

  @Override
  public Response> georadius(String key, double longitude, double latitude, double radius, GeoUnit unit) {
    return appendCommand(commandObjects.georadius(key, longitude, latitude, radius, unit));
  }

  @Override
  public Response> georadiusReadonly(String key, double longitude, double latitude, double radius, GeoUnit unit) {
    return appendCommand(commandObjects.georadiusReadonly(key, longitude, latitude, radius, unit));
  }

  @Override
  public Response> georadius(String key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param) {
    return appendCommand(commandObjects.georadius(key, longitude, latitude, radius, unit, param));
  }

  @Override
  public Response> georadiusReadonly(String key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param) {
    return appendCommand(commandObjects.georadiusReadonly(key, longitude, latitude, radius, unit, param));
  }

  @Override
  public Response> georadiusByMember(String key, String member, double radius, GeoUnit unit) {
    return appendCommand(commandObjects.georadiusByMember(key, member, radius, unit));
  }

  @Override
  public Response> georadiusByMemberReadonly(String key, String member, double radius, GeoUnit unit) {
    return appendCommand(commandObjects.georadiusByMemberReadonly(key, member, radius, unit));
  }

  @Override
  public Response> georadiusByMember(String key, String member, double radius, GeoUnit unit, GeoRadiusParam param) {
    return appendCommand(commandObjects.georadiusByMember(key, member, radius, unit, param));
  }

  @Override
  public Response> georadiusByMemberReadonly(String key, String member, double radius, GeoUnit unit, GeoRadiusParam param) {
    return appendCommand(commandObjects.georadiusByMemberReadonly(key, member, radius, unit, param));
  }

  @Override
  public Response georadiusStore(String key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param, GeoRadiusStoreParam storeParam) {
    return appendCommand(commandObjects.georadiusStore(key, longitude, latitude, radius, unit, param, storeParam));
  }

  @Override
  public Response georadiusByMemberStore(String key, String member, double radius, GeoUnit unit, GeoRadiusParam param, GeoRadiusStoreParam storeParam) {
    return appendCommand(commandObjects.georadiusByMemberStore(key, member, radius, unit, param, storeParam));
  }

  @Override
  public Response> geosearch(String key, String member, double radius, GeoUnit unit) {
    return appendCommand(commandObjects.geosearch(key, member, radius, unit));
  }

  @Override
  public Response> geosearch(String key, GeoCoordinate coord, double radius, GeoUnit unit) {
    return appendCommand(commandObjects.geosearch(key, coord, radius, unit));
  }

  @Override
  public Response> geosearch(String key, String member, double width, double height, GeoUnit unit) {
    return appendCommand(commandObjects.geosearch(key, member, width, height, unit));
  }

  @Override
  public Response> geosearch(String key, GeoCoordinate coord, double width, double height, GeoUnit unit) {
    return appendCommand(commandObjects.geosearch(key, coord, width, height, unit));
  }

  @Override
  public Response> geosearch(String key, GeoSearchParam params) {
    return appendCommand(commandObjects.geosearch(key, params));
  }

  @Override
  public Response geosearchStore(String dest, String src, String member, double radius, GeoUnit unit) {
    return appendCommand(commandObjects.geosearchStore(dest, src, member, radius, unit));
  }

  @Override
  public Response geosearchStore(String dest, String src, GeoCoordinate coord, double radius, GeoUnit unit) {
    return appendCommand(commandObjects.geosearchStore(dest, src, coord, radius, unit));
  }

  @Override
  public Response geosearchStore(String dest, String src, String member, double width, double height, GeoUnit unit) {
    return appendCommand(commandObjects.geosearchStore(dest, src, member, width, height, unit));
  }

  @Override
  public Response geosearchStore(String dest, String src, GeoCoordinate coord, double width, double height, GeoUnit unit) {
    return appendCommand(commandObjects.geosearchStore(dest, src, coord, width, height, unit));
  }

  @Override
  public Response geosearchStore(String dest, String src, GeoSearchParam params) {
    return appendCommand(commandObjects.geosearchStore(dest, src, params));
  }

  @Override
  public Response geosearchStoreStoreDist(String dest, String src, GeoSearchParam params) {
    return appendCommand(commandObjects.geosearchStoreStoreDist(dest, src, params));
  }

  @Override
  public Response pfadd(String key, String... elements) {
    return appendCommand(commandObjects.pfadd(key, elements));
  }

  @Override
  public Response pfmerge(String destkey, String... sourcekeys) {
    return appendCommand(commandObjects.pfmerge(destkey, sourcekeys));
  }

  @Override
  public Response pfcount(String key) {
    return appendCommand(commandObjects.pfcount(key));
  }

  @Override
  public Response pfcount(String... keys) {
    return appendCommand(commandObjects.pfcount(keys));
  }

  @Override
  public Response xadd(String key, StreamEntryID id, Map hash) {
    return appendCommand(commandObjects.xadd(key, id, hash));
  }

  @Override
  public Response xadd(String key, XAddParams params, Map hash) {
    return appendCommand(commandObjects.xadd(key, params, hash));
  }

  @Override
  public Response xlen(String key) {
    return appendCommand(commandObjects.xlen(key));
  }

  @Override
  public Response> xrange(String key, StreamEntryID start, StreamEntryID end) {
    return appendCommand(commandObjects.xrange(key, start, end));
  }

  @Override
  public Response> xrange(String key, StreamEntryID start, StreamEntryID end, int count) {
    return appendCommand(commandObjects.xrange(key, start, end, count));
  }

  @Override
  public Response> xrevrange(String key, StreamEntryID end, StreamEntryID start) {
    return appendCommand(commandObjects.xrevrange(key, start, end));
  }

  @Override
  public Response> xrevrange(String key, StreamEntryID end, StreamEntryID start, int count) {
    return appendCommand(commandObjects.xrevrange(key, start, end, count));
  }

  @Override
  public Response> xrange(String key, String start, String end) {
    return appendCommand(commandObjects.xrange(key, start, end));
  }

  @Override
  public Response> xrange(String key, String start, String end, int count) {
    return appendCommand(commandObjects.xrange(key, start, end, count));
  }

  @Override
  public Response> xrevrange(String key, String end, String start) {
    return appendCommand(commandObjects.xrevrange(key, start, end));
  }

  @Override
  public Response> xrevrange(String key, String end, String start, int count) {
    return appendCommand(commandObjects.xrevrange(key, start, end, count));
  }

  @Override
  public Response xack(String key, String group, StreamEntryID... ids) {
    return appendCommand(commandObjects.xack(key, group, ids));
  }

  @Override
  public Response xgroupCreate(String key, String groupName, StreamEntryID id, boolean makeStream) {
    return appendCommand(commandObjects.xgroupCreate(key, groupName, id, makeStream));
  }

  @Override
  public Response xgroupSetID(String key, String groupName, StreamEntryID id) {
    return appendCommand(commandObjects.xgroupSetID(key, groupName, id));
  }

  @Override
  public Response xgroupDestroy(String key, String groupName) {
    return appendCommand(commandObjects.xgroupDestroy(key, groupName));
  }

  @Override
  public Response xgroupCreateConsumer(String key, String groupName, String consumerName) {
    return appendCommand(commandObjects.xgroupCreateConsumer(key, groupName, consumerName));
  }

  @Override
  public Response xgroupDelConsumer(String key, String groupName, String consumerName) {
    return appendCommand(commandObjects.xgroupDelConsumer(key, groupName, consumerName));
  }

  @Override
  public Response xpending(String key, String groupName) {
    return appendCommand(commandObjects.xpending(key, groupName));
  }

  @Override
  public Response> xpending(String key, String groupName, StreamEntryID start, StreamEntryID end, int count, String consumerName) {
    return appendCommand(commandObjects.xpending(key, groupName, start, end, count, consumerName));
  }

  @Override
  public Response> xpending(String key, String groupName, XPendingParams params) {
    return appendCommand(commandObjects.xpending(key, groupName, params));
  }

  @Override
  public Response xdel(String key, StreamEntryID... ids) {
    return appendCommand(commandObjects.xdel(key, ids));
  }

  @Override
  public Response xtrim(String key, long maxLen, boolean approximate) {
    return appendCommand(commandObjects.xtrim(key, maxLen, approximate));
  }

  @Override
  public Response xtrim(String key, XTrimParams params) {
    return appendCommand(commandObjects.xtrim(key, params));
  }

  @Override
  public Response> xclaim(String key, String group, String consumerName, long minIdleTime, XClaimParams params, StreamEntryID... ids) {
    return appendCommand(commandObjects.xclaim(key, group, consumerName, minIdleTime, params, ids));
  }

  @Override
  public Response> xclaimJustId(String key, String group, String consumerName, long minIdleTime, XClaimParams params, StreamEntryID... ids) {
    return appendCommand(commandObjects.xclaimJustId(key, group, consumerName, minIdleTime, params, ids));
  }

  @Override
  public Response>> xautoclaim(String key, String group, String consumerName, long minIdleTime, StreamEntryID start, XAutoClaimParams params) {
    return appendCommand(commandObjects.xautoclaim(key, group, consumerName, minIdleTime, start, params));
  }

  @Override
  public Response>> xautoclaimJustId(String key, String group, String consumerName, long minIdleTime, StreamEntryID start, XAutoClaimParams params) {
    return appendCommand(commandObjects.xautoclaimJustId(key, group, consumerName, minIdleTime, start, params));
  }

  @Override
  public Response xinfoStream(String key) {
    return appendCommand(commandObjects.xinfoStream(key));
  }

  @Override
  public Response xinfoStreamFull(String key) {
    return appendCommand(commandObjects.xinfoStreamFull(key));
  }

  @Override
  public Response xinfoStreamFull(String key, int count) {
    return appendCommand(commandObjects.xinfoStreamFull(key, count));
  }

  @Override
  @Deprecated
  public Response> xinfoGroup(String key) {
    return appendCommand(commandObjects.xinfoGroup(key));
  }

  @Override
  public Response> xinfoGroups(String key) {
    return appendCommand(commandObjects.xinfoGroups(key));
  }

  @Override
  public Response> xinfoConsumers(String key, String group) {
    return appendCommand(commandObjects.xinfoConsumers(key, group));
  }

  @Override
  public Response>>> xread(XReadParams xReadParams, Map streams) {
    return appendCommand(commandObjects.xread(xReadParams, streams));
  }

  @Override
  public Response>>> xreadGroup(String groupName, String consumer, XReadGroupParams xReadGroupParams, Map streams) {
    return appendCommand(commandObjects.xreadGroup(groupName, consumer, xReadGroupParams, streams));
  }

  @Override
  public Response eval(String script) {
    return appendCommand(commandObjects.eval(script));
  }

  @Override
  public Response eval(String script, int keyCount, String... params) {
    return appendCommand(commandObjects.eval(script, keyCount, params));
  }

  @Override
  public Response eval(String script, List keys, List args) {
    return appendCommand(commandObjects.eval(script, keys, args));
  }

  @Override
  public Response evalReadonly(String script, List keys, List args) {
    return appendCommand(commandObjects.evalReadonly(script, keys, args));
  }

  @Override
  public Response evalsha(String sha1) {
    return appendCommand(commandObjects.evalsha(sha1));
  }

  @Override
  public Response evalsha(String sha1, int keyCount, String... params) {
    return appendCommand(commandObjects.evalsha(sha1, keyCount, params));
  }

  @Override
  public Response evalsha(String sha1, List keys, List args) {
    return appendCommand(commandObjects.evalsha(sha1, keys, args));
  }

  @Override
  public Response evalshaReadonly(String sha1, List keys, List args) {
    return appendCommand(commandObjects.evalshaReadonly(sha1, keys, args));
  }


  @Override
  public Response waitReplicas(String sampleKey, int replicas, long timeout) {
    return appendCommand(commandObjects.waitReplicas(sampleKey, replicas, timeout));
  }

  @Override
  public Response> waitAOF(String sampleKey, long numLocal, long numReplicas, long timeout) {
    return appendCommand(commandObjects.waitAOF(sampleKey, numLocal, numReplicas, timeout));
  }

  @Override
  public Response eval(String script, String sampleKey) {
    return appendCommand(commandObjects.eval(script, sampleKey));
  }

  @Override
  public Response evalsha(String sha1, String sampleKey) {
    return appendCommand(commandObjects.evalsha(sha1, sampleKey));
  }

  @Override
  public Response> scriptExists(String sampleKey, String... sha1) {
    return appendCommand(commandObjects.scriptExists(sampleKey, sha1));
  }

  @Override
  public Response scriptLoad(String script, String sampleKey) {
    return appendCommand(commandObjects.scriptLoad(script, sampleKey));
  }

  @Override
  public Response scriptFlush(String sampleKey) {
    return appendCommand(commandObjects.scriptFlush(sampleKey));
  }

  @Override
  public Response scriptFlush(String sampleKey, FlushMode flushMode) {
    return appendCommand(commandObjects.scriptFlush(sampleKey, flushMode));
  }

  @Override
  public Response scriptKill(String sampleKey) {
    return appendCommand(commandObjects.scriptKill(sampleKey));
  }

  @Override
  public Response fcall(byte[] name, List keys, List args) {
    return appendCommand(commandObjects.fcall(name, keys, args));
  }

  @Override
  public Response fcall(String name, List keys, List args) {
    return appendCommand(commandObjects.fcall(name, keys, args));
  }

  @Override
  public Response fcallReadonly(byte[] name, List keys, List args) {
    return appendCommand(commandObjects.fcallReadonly(name, keys, args));
  }

  @Override
  public Response fcallReadonly(String name, List keys, List args) {
    return appendCommand(commandObjects.fcallReadonly(name, keys, args));
  }

  @Override
  public Response functionDelete(byte[] libraryName) {
    return appendCommand(commandObjects.functionDelete(libraryName));
  }

  @Override
  public Response functionDelete(String libraryName) {
    return appendCommand(commandObjects.functionDelete(libraryName));
  }

  @Override
  public Response functionDump() {
    return appendCommand(commandObjects.functionDump());
  }

  @Override
  public Response> functionList(String libraryNamePattern) {
    return appendCommand(commandObjects.functionList(libraryNamePattern));
  }

  @Override
  public Response> functionList() {
    return appendCommand(commandObjects.functionList());
  }

  @Override
  public Response> functionListWithCode(String libraryNamePattern) {
    return appendCommand(commandObjects.functionListWithCode(libraryNamePattern));
  }

  @Override
  public Response> functionListWithCode() {
    return appendCommand(commandObjects.functionListWithCode());
  }

  @Override
  public Response> functionListBinary() {
    return appendCommand(commandObjects.functionListBinary());
  }

  @Override
  public Response> functionList(final byte[] libraryNamePattern) {
    return appendCommand(commandObjects.functionList(libraryNamePattern));
  }

  @Override
  public Response> functionListWithCodeBinary() {
    return appendCommand(commandObjects.functionListWithCodeBinary());
  }

  @Override
  public Response> functionListWithCode(final byte[] libraryNamePattern) {
    return appendCommand(commandObjects.functionListWithCode(libraryNamePattern));
  }

  @Override
  public Response functionLoad(byte[] functionCode) {
    return appendCommand(commandObjects.functionLoad(functionCode));
  }

  @Override
  public Response functionLoad(String functionCode) {
    return appendCommand(commandObjects.functionLoad(functionCode));
  }

  @Override
  public Response functionLoadReplace(byte[] functionCode) {
    return appendCommand(commandObjects.functionLoadReplace(functionCode));
  }

  @Override
  public Response functionLoadReplace(String functionCode) {
    return appendCommand(commandObjects.functionLoadReplace(functionCode));
  }

  @Override
  public Response functionRestore(byte[] serializedValue) {
    return appendCommand(commandObjects.functionRestore(serializedValue));
  }

  @Override
  public Response functionRestore(byte[] serializedValue, FunctionRestorePolicy policy) {
    return appendCommand(commandObjects.functionRestore(serializedValue, policy));
  }

  @Override
  public Response functionFlush() {
    return appendCommand(commandObjects.functionFlush());
  }

  @Override
  public Response functionFlush(FlushMode mode) {
    return appendCommand(commandObjects.functionFlush(mode));
  }

  @Override
  public Response functionKill() {
    return appendCommand(commandObjects.functionKill());
  }

  @Override
  public Response functionStats() {
    return appendCommand(commandObjects.functionStats());
  }

  @Override
  public Response functionStatsBinary() {
    return appendCommand(commandObjects.functionStatsBinary());
  }

  public Response publish(String channel, String message) {
    return appendCommand(commandObjects.publish(channel, message));
  }

  public Response strAlgoLCSStrings(String strA, String strB, StrAlgoLCSParams params) {
    return appendCommand(commandObjects.strAlgoLCSStrings(strA, strB, params));
  }

  @Override
  public Response geoadd(byte[] key, double longitude, double latitude, byte[] member) {
    return appendCommand(commandObjects.geoadd(key, longitude, latitude, member));
  }

  @Override
  public Response geoadd(byte[] key, Map memberCoordinateMap) {
    return appendCommand(commandObjects.geoadd(key, memberCoordinateMap));
  }

  @Override
  public Response geoadd(byte[] key, GeoAddParams params, Map memberCoordinateMap) {
    return appendCommand(commandObjects.geoadd(key, params, memberCoordinateMap));
  }

  @Override
  public Response geodist(byte[] key, byte[] member1, byte[] member2) {
    return appendCommand(commandObjects.geodist(key, member1, member2));
  }

  @Override
  public Response geodist(byte[] key, byte[] member1, byte[] member2, GeoUnit unit) {
    return appendCommand(commandObjects.geodist(key, member1, member2, unit));
  }

  @Override
  public Response> geohash(byte[] key, byte[]... members) {
    return appendCommand(commandObjects.geohash(key, members));
  }

  @Override
  public Response> geopos(byte[] key, byte[]... members) {
    return appendCommand(commandObjects.geopos(key, members));
  }

  @Override
  public Response> georadius(byte[] key, double longitude, double latitude, double radius, GeoUnit unit) {
    return appendCommand(commandObjects.georadius(key, longitude, latitude, radius, unit));
  }

  @Override
  public Response> georadiusReadonly(byte[] key, double longitude, double latitude, double radius, GeoUnit unit) {
    return appendCommand(commandObjects.georadiusReadonly(key, longitude, latitude, radius, unit));
  }

  @Override
  public Response> georadius(byte[] key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param) {
    return appendCommand(commandObjects.georadius(key, longitude, latitude, radius, unit, param));
  }

  @Override
  public Response> georadiusReadonly(byte[] key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param) {
    return appendCommand(commandObjects.georadiusReadonly(key, longitude, latitude, radius, unit, param));
  }

  @Override
  public Response> georadiusByMember(byte[] key, byte[] member, double radius, GeoUnit unit) {
    return appendCommand(commandObjects.georadiusByMember(key, member, radius, unit));
  }

  @Override
  public Response> georadiusByMemberReadonly(byte[] key, byte[] member, double radius, GeoUnit unit) {
    return appendCommand(commandObjects.georadiusByMemberReadonly(key, member, radius, unit));
  }

  @Override
  public Response> georadiusByMember(byte[] key, byte[] member, double radius, GeoUnit unit, GeoRadiusParam param) {
    return appendCommand(commandObjects.georadiusByMember(key, member, radius, unit, param));
  }

  @Override
  public Response> georadiusByMemberReadonly(byte[] key, byte[] member, double radius, GeoUnit unit, GeoRadiusParam param) {
    return appendCommand(commandObjects.georadiusByMemberReadonly(key, member, radius, unit, param));
  }

  @Override
  public Response georadiusStore(byte[] key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param, GeoRadiusStoreParam storeParam) {
    return appendCommand(commandObjects.georadiusStore(key, longitude, latitude, radius, unit, param, storeParam));
  }

  @Override
  public Response georadiusByMemberStore(byte[] key, byte[] member, double radius, GeoUnit unit, GeoRadiusParam param, GeoRadiusStoreParam storeParam) {
    return appendCommand(commandObjects.georadiusByMemberStore(key, member, radius, unit, param, storeParam));
  }

  @Override
  public Response> geosearch(byte[] key, byte[] member, double radius, GeoUnit unit) {
    return appendCommand(commandObjects.geosearch(key, member, radius, unit));
  }

  @Override
  public Response> geosearch(byte[] key, GeoCoordinate coord, double radius, GeoUnit unit) {
    return appendCommand(commandObjects.geosearch(key, coord, radius, unit));
  }

  @Override
  public Response> geosearch(byte[] key, byte[] member, double width, double height, GeoUnit unit) {
    return appendCommand(commandObjects.geosearch(key, member, width, height, unit));
  }

  @Override
  public Response> geosearch(byte[] key, GeoCoordinate coord, double width, double height, GeoUnit unit) {
    return appendCommand(commandObjects.geosearch(key, coord, width, height, unit));
  }

  @Override
  public Response> geosearch(byte[] key, GeoSearchParam params) {
    return appendCommand(commandObjects.geosearch(key, params));
  }

  @Override
  public Response geosearchStore(byte[] dest, byte[] src, byte[] member, double radius, GeoUnit unit) {
    return appendCommand(commandObjects.geosearchStore(dest, src, member, radius, unit));
  }

  @Override
  public Response geosearchStore(byte[] dest, byte[] src, GeoCoordinate coord, double radius, GeoUnit unit) {
    return appendCommand(commandObjects.geosearchStore(dest, src, coord, radius, unit));
  }

  @Override
  public Response geosearchStore(byte[] dest, byte[] src, byte[] member, double width, double height, GeoUnit unit) {
    return appendCommand(commandObjects.geosearchStore(dest, src, member, width, height, unit));
  }

  @Override
  public Response geosearchStore(byte[] dest, byte[] src, GeoCoordinate coord, double width, double height, GeoUnit unit) {
    return appendCommand(commandObjects.geosearchStore(dest, src, coord, width, height, unit));
  }

  @Override
  public Response geosearchStore(byte[] dest, byte[] src, GeoSearchParam params) {
    return appendCommand(commandObjects.geosearchStore(dest, src, params));
  }

  @Override
  public Response geosearchStoreStoreDist(byte[] dest, byte[] src, GeoSearchParam params) {
    return appendCommand(commandObjects.geosearchStoreStoreDist(dest, src, params));
  }

  @Override
  public Response hset(byte[] key, byte[] field, byte[] value) {
    return appendCommand(commandObjects.hset(key, field, value));
  }

  @Override
  public Response hset(byte[] key, Map hash) {
    return appendCommand(commandObjects.hset(key, hash));
  }

  @Override
  public Response hget(byte[] key, byte[] field) {
    return appendCommand(commandObjects.hget(key, field));
  }

  @Override
  public Response hsetnx(byte[] key, byte[] field, byte[] value) {
    return appendCommand(commandObjects.hsetnx(key, field, value));
  }

  @Override
  public Response hmset(byte[] key, Map hash) {
    return appendCommand(commandObjects.hmset(key, hash));
  }

  @Override
  public Response> hmget(byte[] key, byte[]... fields) {
    return appendCommand(commandObjects.hmget(key, fields));
  }

  @Override
  public Response hincrBy(byte[] key, byte[] field, long value) {
    return appendCommand(commandObjects.hincrBy(key, field, value));
  }

  @Override
  public Response hincrByFloat(byte[] key, byte[] field, double value) {
    return appendCommand(commandObjects.hincrByFloat(key, field, value));
  }

  @Override
  public Response hexists(byte[] key, byte[] field) {
    return appendCommand(commandObjects.hexists(key, field));
  }

  @Override
  public Response hdel(byte[] key, byte[]... field) {
    return appendCommand(commandObjects.hdel(key, field));
  }

  @Override
  public Response hlen(byte[] key) {
    return appendCommand(commandObjects.hlen(key));
  }

  @Override
  public Response> hkeys(byte[] key) {
    return appendCommand(commandObjects.hkeys(key));
  }

  @Override
  public Response> hvals(byte[] key) {
    return appendCommand(commandObjects.hvals(key));
  }

  @Override
  public Response> hgetAll(byte[] key) {
    return appendCommand(commandObjects.hgetAll(key));
  }

  @Override
  public Response hrandfield(byte[] key) {
    return appendCommand(commandObjects.hrandfield(key));
  }

  @Override
  public Response> hrandfield(byte[] key, long count) {
    return appendCommand(commandObjects.hrandfield(key, count));
  }

  @Override
  public Response> hrandfieldWithValues(byte[] key, long count) {
    return appendCommand(commandObjects.hrandfieldWithValues(key, count));
  }

  @Override
  public Response>> hscan(byte[] key, byte[] cursor, ScanParams params) {
    return appendCommand(commandObjects.hscan(key, cursor, params));
  }

  @Override
  public Response hstrlen(byte[] key, byte[] field) {
    return appendCommand(commandObjects.hstrlen(key, field));
  }

  @Override
  public Response pfadd(byte[] key, byte[]... elements) {
    return appendCommand(commandObjects.pfadd(key, elements));
  }

  @Override
  public Response pfmerge(byte[] destkey, byte[]... sourcekeys) {
    return appendCommand(commandObjects.pfmerge(destkey, sourcekeys));
  }

  @Override
  public Response pfcount(byte[] key) {
    return appendCommand(commandObjects.pfcount(key));
  }

  @Override
  public Response pfcount(byte[]... keys) {
    return appendCommand(commandObjects.pfcount(keys));
  }

  @Override
  public Response exists(byte[] key) {
    return appendCommand(commandObjects.exists(key));
  }

  @Override
  public Response exists(byte[]... keys) {
    return appendCommand(commandObjects.exists(keys));
  }

  @Override
  public Response persist(byte[] key) {
    return appendCommand(commandObjects.persist(key));
  }

  @Override
  public Response type(byte[] key) {
    return appendCommand(commandObjects.type(key));
  }

  @Override
  public Response dump(byte[] key) {
    return appendCommand(commandObjects.dump(key));
  }

  @Override
  public Response restore(byte[] key, long ttl, byte[] serializedValue) {
    return appendCommand(commandObjects.restore(key, ttl, serializedValue));
  }

  @Override
  public Response restore(byte[] key, long ttl, byte[] serializedValue, RestoreParams params) {
    return appendCommand(commandObjects.restore(key, ttl, serializedValue, params));
  }

  @Override
  public Response expire(byte[] key, long seconds) {
    return appendCommand(commandObjects.expire(key, seconds));
  }

  @Override
  public Response expire(byte[] key, long seconds, ExpiryOption expiryOption) {
    return appendCommand(commandObjects.expire(key, seconds, expiryOption));
  }

  @Override
  public Response pexpire(byte[] key, long milliseconds) {
    return appendCommand(commandObjects.pexpire(key, milliseconds));
  }

  @Override
  public Response pexpire(byte[] key, long milliseconds, ExpiryOption expiryOption) {
    return appendCommand(commandObjects.pexpire(key, milliseconds, expiryOption));
  }

  @Override
  public Response expireTime(byte[] key) {
    return appendCommand(commandObjects.expireTime(key));
  }

  @Override
  public Response pexpireTime(byte[] key) {
    return appendCommand(commandObjects.pexpireTime(key));
  }

  @Override
  public Response expireAt(byte[] key, long unixTime) {
    return appendCommand(commandObjects.expireAt(key, unixTime));
  }

  @Override
  public Response expireAt(byte[] key, long unixTime, ExpiryOption expiryOption) {
    return appendCommand(commandObjects.expireAt(key, unixTime, expiryOption));
  }

  @Override
  public Response pexpireAt(byte[] key, long millisecondsTimestamp) {
    return appendCommand(commandObjects.pexpireAt(key, millisecondsTimestamp));
  }

  @Override
  public Response pexpireAt(byte[] key, long millisecondsTimestamp, ExpiryOption expiryOption) {
    return appendCommand(commandObjects.pexpireAt(key, millisecondsTimestamp, expiryOption));
  }

  @Override
  public Response ttl(byte[] key) {
    return appendCommand(commandObjects.ttl(key));
  }

  @Override
  public Response pttl(byte[] key) {
    return appendCommand(commandObjects.pttl(key));
  }

  @Override
  public Response touch(byte[] key) {
    return appendCommand(commandObjects.touch(key));
  }

  @Override
  public Response touch(byte[]... keys) {
    return appendCommand(commandObjects.touch(keys));
  }

  @Override
  public Response> sort(byte[] key) {
    return appendCommand(commandObjects.sort(key));
  }

  @Override
  public Response> sort(byte[] key, SortingParams sortingParams) {
    return appendCommand(commandObjects.sort(key, sortingParams));
  }

  @Override
  public Response> sortReadonly(byte[] key, SortingParams sortingParams) {
    return appendCommand(commandObjects.sortReadonly(key, sortingParams));
  }

  @Override
  public Response del(byte[] key) {
    return appendCommand(commandObjects.del(key));
  }

  @Override
  public Response del(byte[]... keys) {
    return appendCommand(commandObjects.del(keys));
  }

  @Override
  public Response unlink(byte[] key) {
    return appendCommand(commandObjects.unlink(key));
  }

  @Override
  public Response unlink(byte[]... keys) {
    return appendCommand(commandObjects.unlink(keys));
  }

  @Override
  public Response copy(byte[] srcKey, byte[] dstKey, boolean replace) {
    return appendCommand(commandObjects.copy(srcKey, dstKey, replace));
  }

  @Override
  public Response rename(byte[] oldkey, byte[] newkey) {
    return appendCommand(commandObjects.rename(oldkey, newkey));
  }

  @Override
  public Response renamenx(byte[] oldkey, byte[] newkey) {
    return appendCommand(commandObjects.renamenx(oldkey, newkey));
  }

  @Override
  public Response sort(byte[] key, SortingParams sortingParams, byte[] dstkey) {
    return appendCommand(commandObjects.sort(key, sortingParams, dstkey));
  }

  @Override
  public Response sort(byte[] key, byte[] dstkey) {
    return appendCommand(commandObjects.sort(key, dstkey));
  }

  @Override
  public Response memoryUsage(byte[] key) {
    return appendCommand(commandObjects.memoryUsage(key));
  }

  @Override
  public Response memoryUsage(byte[] key, int samples) {
    return appendCommand(commandObjects.memoryUsage(key, samples));
  }

  @Override
  public Response objectRefcount(byte[] key) {
    return appendCommand(commandObjects.objectRefcount(key));
  }

  @Override
  public Response objectEncoding(byte[] key) {
    return appendCommand(commandObjects.objectEncoding(key));
  }

  @Override
  public Response objectIdletime(byte[] key) {
    return appendCommand(commandObjects.objectIdletime(key));
  }

  @Override
  public Response objectFreq(byte[] key) {
    return appendCommand(commandObjects.objectFreq(key));
  }

  @Override
  public Response migrate(String host, int port, byte[] key, int timeout) {
    return appendCommand(commandObjects.migrate(host, port, key, timeout));
  }

  @Override
  public Response migrate(String host, int port, int timeout, MigrateParams params, byte[]... keys) {
    return appendCommand(commandObjects.migrate(host, port, timeout, params, keys));
  }

  @Override
  public Response> keys(byte[] pattern) {
    return appendCommand(commandObjects.keys(pattern));
  }

  @Override
  public Response> scan(byte[] cursor) {
    return appendCommand(commandObjects.scan(cursor));
  }

  @Override
  public Response> scan(byte[] cursor, ScanParams params) {
    return appendCommand(commandObjects.scan(cursor, params));
  }

  @Override
  public Response> scan(byte[] cursor, ScanParams params, byte[] type) {
    return appendCommand(commandObjects.scan(cursor, params, type));
  }

  @Override
  public Response randomBinaryKey() {
    return appendCommand(commandObjects.randomBinaryKey());
  }

  @Override
  public Response rpush(byte[] key, byte[]... args) {
    return appendCommand(commandObjects.rpush(key, args));
  }

  @Override
  public Response lpush(byte[] key, byte[]... args) {
    return appendCommand(commandObjects.lpush(key, args));
  }

  @Override
  public Response llen(byte[] key) {
    return appendCommand(commandObjects.llen(key));
  }

  @Override
  public Response> lrange(byte[] key, long start, long stop) {
    return appendCommand(commandObjects.lrange(key, start, stop));
  }

  @Override
  public Response ltrim(byte[] key, long start, long stop) {
    return appendCommand(commandObjects.ltrim(key, start, stop));
  }

  @Override
  public Response lindex(byte[] key, long index) {
    return appendCommand(commandObjects.lindex(key, index));
  }

  @Override
  public Response lset(byte[] key, long index, byte[] value) {
    return appendCommand(commandObjects.lset(key, index, value));
  }

  @Override
  public Response lrem(byte[] key, long count, byte[] value) {
    return appendCommand(commandObjects.lrem(key, count, value));
  }

  @Override
  public Response lpop(byte[] key) {
    return appendCommand(commandObjects.lpop(key));
  }

  @Override
  public Response> lpop(byte[] key, int count) {
    return appendCommand(commandObjects.lpop(key, count));
  }

  @Override
  public Response lpos(byte[] key, byte[] element) {
    return appendCommand(commandObjects.lpos(key, element));
  }

  @Override
  public Response lpos(byte[] key, byte[] element, LPosParams params) {
    return appendCommand(commandObjects.lpos(key, element, params));
  }

  @Override
  public Response> lpos(byte[] key, byte[] element, LPosParams params, long count) {
    return appendCommand(commandObjects.lpos(key, element, params, count));
  }

  @Override
  public Response rpop(byte[] key) {
    return appendCommand(commandObjects.rpop(key));
  }

  @Override
  public Response> rpop(byte[] key, int count) {
    return appendCommand(commandObjects.rpop(key, count));
  }

  @Override
  public Response linsert(byte[] key, ListPosition where, byte[] pivot, byte[] value) {
    return appendCommand(commandObjects.linsert(key, where, pivot, value));
  }

  @Override
  public Response lpushx(byte[] key, byte[]... args) {
    return appendCommand(commandObjects.lpushx(key, args));
  }

  @Override
  public Response rpushx(byte[] key, byte[]... args) {
    return appendCommand(commandObjects.rpushx(key, args));
  }

  @Override
  public Response> blpop(int timeout, byte[]... keys) {
    return appendCommand(commandObjects.blpop(timeout, keys));
  }

  @Override
  public Response> blpop(double timeout, byte[]... keys) {
    return appendCommand(commandObjects.blpop(timeout, keys));
  }

  @Override
  public Response> brpop(int timeout, byte[]... keys) {
    return appendCommand(commandObjects.brpop(timeout, keys));
  }

  @Override
  public Response> brpop(double timeout, byte[]... keys) {
    return appendCommand(commandObjects.brpop(timeout, keys));
  }

  @Override
  public Response rpoplpush(byte[] srckey, byte[] dstkey) {
    return appendCommand(commandObjects.rpoplpush(srckey, dstkey));
  }

  @Override
  public Response brpoplpush(byte[] source, byte[] destination, int timeout) {
    return appendCommand(commandObjects.brpoplpush(source, destination, timeout));
  }

  @Override
  public Response lmove(byte[] srcKey, byte[] dstKey, ListDirection from, ListDirection to) {
    return appendCommand(commandObjects.lmove(srcKey, dstKey, from, to));
  }

  @Override
  public Response blmove(byte[] srcKey, byte[] dstKey, ListDirection from, ListDirection to, double timeout) {
    return appendCommand(commandObjects.blmove(srcKey, dstKey, from, to, timeout));
  }

  @Override
  public Response>> lmpop(ListDirection direction, byte[]... keys) {
    return appendCommand(commandObjects.lmpop(direction, keys));
  }

  @Override
  public Response>> lmpop(ListDirection direction, int count, byte[]... keys) {
    return appendCommand(commandObjects.lmpop(direction, count, keys));
  }

  @Override
  public Response>> blmpop(long timeout, ListDirection direction, byte[]... keys) {
    return appendCommand(commandObjects.blmpop(timeout, direction, keys));
  }

  @Override
  public Response>> blmpop(long timeout, ListDirection direction, int count, byte[]... keys) {
    return appendCommand(commandObjects.blmpop(timeout, direction, count, keys));
  }

  public Response publish(byte[] channel, byte[] message) {
    return appendCommand(commandObjects.publish(channel, message));
  }

  public Response strAlgoLCSStrings(byte[] strA, byte[] strB, StrAlgoLCSParams params) {
    return appendCommand(commandObjects.strAlgoLCSStrings(strA, strB, params));
  }

  @Override
  public Response waitReplicas(byte[] sampleKey, int replicas, long timeout) {
    return appendCommand(commandObjects.waitReplicas(sampleKey, replicas, timeout));
  }

  @Override
  public Response> waitAOF(byte[] sampleKey, long numLocal, long numReplicas, long timeout) {
    return appendCommand(commandObjects.waitAOF(sampleKey, numLocal, numReplicas, timeout));
  }

  @Override
  public Response eval(byte[] script, byte[] sampleKey) {
    return appendCommand(commandObjects.eval(script, sampleKey));
  }

  @Override
  public Response evalsha(byte[] sha1, byte[] sampleKey) {
    return appendCommand(commandObjects.evalsha(sha1, sampleKey));
  }

  @Override
  public Response> scriptExists(byte[] sampleKey, byte[]... sha1s) {
    return appendCommand(commandObjects.scriptExists(sampleKey, sha1s));
  }

  @Override
  public Response scriptLoad(byte[] script, byte[] sampleKey) {
    return appendCommand(commandObjects.scriptLoad(script, sampleKey));
  }

  @Override
  public Response scriptFlush(byte[] sampleKey) {
    return appendCommand(commandObjects.scriptFlush(sampleKey));
  }

  @Override
  public Response scriptFlush(byte[] sampleKey, FlushMode flushMode) {
    return appendCommand(commandObjects.scriptFlush(sampleKey, flushMode));
  }

  @Override
  public Response scriptKill(byte[] sampleKey) {
    return appendCommand(commandObjects.scriptKill(sampleKey));
  }

  @Override
  public Response eval(byte[] script) {
    return appendCommand(commandObjects.eval(script));
  }

  @Override
  public Response eval(byte[] script, int keyCount, byte[]... params) {
    return appendCommand(commandObjects.eval(script, keyCount, params));
  }

  @Override
  public Response eval(byte[] script, List keys, List args) {
    return appendCommand(commandObjects.eval(script, keys, args));
  }

  @Override
  public Response evalReadonly(byte[] script, List keys, List args) {
    return appendCommand(commandObjects.evalReadonly(script, keys, args));
  }

  @Override
  public Response evalsha(byte[] sha1) {
    return appendCommand(commandObjects.evalsha(sha1));
  }

  @Override
  public Response evalsha(byte[] sha1, int keyCount, byte[]... params) {
    return appendCommand(commandObjects.evalsha(sha1, keyCount, params));
  }

  @Override
  public Response evalsha(byte[] sha1, List keys, List args) {
    return appendCommand(commandObjects.evalsha(sha1, keys, args));
  }

  @Override
  public Response evalshaReadonly(byte[] sha1, List keys, List args) {
    return appendCommand(commandObjects.evalshaReadonly(sha1, keys, args));
  }

  @Override
  public Response sadd(byte[] key, byte[]... members) {
    return appendCommand(commandObjects.sadd(key, members));
  }

  @Override
  public Response> smembers(byte[] key) {
    return appendCommand(commandObjects.smembers(key));
  }

  @Override
  public Response srem(byte[] key, byte[]... members) {
    return appendCommand(commandObjects.srem(key, members));
  }

  @Override
  public Response spop(byte[] key) {
    return appendCommand(commandObjects.spop(key));
  }

  @Override
  public Response> spop(byte[] key, long count) {
    return appendCommand(commandObjects.spop(key, count));
  }

  @Override
  public Response scard(byte[] key) {
    return appendCommand(commandObjects.scard(key));
  }

  @Override
  public Response sismember(byte[] key, byte[] member) {
    return appendCommand(commandObjects.sismember(key, member));
  }

  @Override
  public Response> smismember(byte[] key, byte[]... members) {
    return appendCommand(commandObjects.smismember(key, members));
  }

  @Override
  public Response srandmember(byte[] key) {
    return appendCommand(commandObjects.srandmember(key));
  }

  @Override
  public Response> srandmember(byte[] key, int count) {
    return appendCommand(commandObjects.srandmember(key, count));
  }

  @Override
  public Response> sscan(byte[] key, byte[] cursor, ScanParams params) {
    return appendCommand(commandObjects.sscan(key, cursor, params));
  }

  @Override
  public Response> sdiff(byte[]... keys) {
    return appendCommand(commandObjects.sdiff(keys));
  }

  @Override
  public Response sdiffstore(byte[] dstkey, byte[]... keys) {
    return appendCommand(commandObjects.sdiffstore(dstkey, keys));
  }

  @Override
  public Response> sinter(byte[]... keys) {
    return appendCommand(commandObjects.sinter(keys));
  }

  @Override
  public Response sinterstore(byte[] dstkey, byte[]... keys) {
    return appendCommand(commandObjects.sinterstore(dstkey, keys));
  }

  @Override
  public Response sintercard(byte[]... keys) {
    return appendCommand(commandObjects.sintercard(keys));
  }

  @Override
  public Response sintercard(int limit, byte[]... keys) {
    return appendCommand(commandObjects.sintercard(limit, keys));
  }

  @Override
  public Response> sunion(byte[]... keys) {
    return appendCommand(commandObjects.sunion(keys));
  }

  @Override
  public Response sunionstore(byte[] dstkey, byte[]... keys) {
    return appendCommand(commandObjects.sunionstore(dstkey, keys));
  }

  @Override
  public Response smove(byte[] srckey, byte[] dstkey, byte[] member) {
    return appendCommand(commandObjects.smove(srckey, dstkey, member));
  }

  @Override
  public Response zadd(byte[] key, double score, byte[] member) {
    return appendCommand(commandObjects.zadd(key, score, member));
  }

  @Override
  public Response zadd(byte[] key, double score, byte[] member, ZAddParams params) {
    return appendCommand(commandObjects.zadd(key, score, member, params));
  }

  @Override
  public Response zadd(byte[] key, Map scoreMembers) {
    return appendCommand(commandObjects.zadd(key, scoreMembers));
  }

  @Override
  public Response zadd(byte[] key, Map scoreMembers, ZAddParams params) {
    return appendCommand(commandObjects.zadd(key, scoreMembers, params));
  }

  @Override
  public Response zaddIncr(byte[] key, double score, byte[] member, ZAddParams params) {
    return appendCommand(commandObjects.zaddIncr(key, score, member, params));
  }

  @Override
  public Response zrem(byte[] key, byte[]... members) {
    return appendCommand(commandObjects.zrem(key, members));
  }

  @Override
  public Response zincrby(byte[] key, double increment, byte[] member) {
    return appendCommand(commandObjects.zincrby(key, increment, member));
  }

  @Override
  public Response zincrby(byte[] key, double increment, byte[] member, ZIncrByParams params) {
    return appendCommand(commandObjects.zincrby(key, increment, member, params));
  }

  @Override
  public Response zrank(byte[] key, byte[] member) {
    return appendCommand(commandObjects.zrank(key, member));
  }

  @Override
  public Response zrevrank(byte[] key, byte[] member) {
    return appendCommand(commandObjects.zrevrank(key, member));
  }

  @Override
  public Response> zrankWithScore(byte[] key, byte[] member) {
    return appendCommand(commandObjects.zrankWithScore(key, member));
  }

  @Override
  public Response> zrevrankWithScore(byte[] key, byte[] member) {
    return appendCommand(commandObjects.zrevrankWithScore(key, member));
  }

  @Override
  public Response> zrange(byte[] key, long start, long stop) {
    return appendCommand(commandObjects.zrange(key, start, stop));
  }

  @Override
  public Response> zrevrange(byte[] key, long start, long stop) {
    return appendCommand(commandObjects.zrevrange(key, start, stop));
  }

  @Override
  public Response> zrangeWithScores(byte[] key, long start, long stop) {
    return appendCommand(commandObjects.zrangeWithScores(key, start, stop));
  }

  @Override
  public Response> zrevrangeWithScores(byte[] key, long start, long stop) {
    return appendCommand(commandObjects.zrevrangeWithScores(key, start, stop));
  }

  @Override
  public Response> zrange(byte[] key, ZRangeParams zRangeParams) {
    return appendCommand(commandObjects.zrange(key, zRangeParams));
  }

  @Override
  public Response> zrangeWithScores(byte[] key, ZRangeParams zRangeParams) {
    return appendCommand(commandObjects.zrangeWithScores(key, zRangeParams));
  }

  @Override
  public Response zrangestore(byte[] dest, byte[] src, ZRangeParams zRangeParams) {
    return appendCommand(commandObjects.zrangestore(dest, src, zRangeParams));
  }

  @Override
  public Response zrandmember(byte[] key) {
    return appendCommand(commandObjects.zrandmember(key));
  }

  @Override
  public Response> zrandmember(byte[] key, long count) {
    return appendCommand(commandObjects.zrandmember(key, count));
  }

  @Override
  public Response> zrandmemberWithScores(byte[] key, long count) {
    return appendCommand(commandObjects.zrandmemberWithScores(key, count));
  }

  @Override
  public Response zcard(byte[] key) {
    return appendCommand(commandObjects.zcard(key));
  }

  @Override
  public Response zscore(byte[] key, byte[] member) {
    return appendCommand(commandObjects.zscore(key, member));
  }

  @Override
  public Response> zmscore(byte[] key, byte[]... members) {
    return appendCommand(commandObjects.zmscore(key, members));
  }

  @Override
  public Response zpopmax(byte[] key) {
    return appendCommand(commandObjects.zpopmax(key));
  }

  @Override
  public Response> zpopmax(byte[] key, int count) {
    return appendCommand(commandObjects.zpopmax(key, count));
  }

  @Override
  public Response zpopmin(byte[] key) {
    return appendCommand(commandObjects.zpopmin(key));
  }

  @Override
  public Response> zpopmin(byte[] key, int count) {
    return appendCommand(commandObjects.zpopmin(key, count));
  }

  @Override
  public Response zcount(byte[] key, double min, double max) {
    return appendCommand(commandObjects.zcount(key, min, max));
  }

  @Override
  public Response zcount(byte[] key, byte[] min, byte[] max) {
    return appendCommand(commandObjects.zcount(key, min, max));
  }

  @Override
  public Response> zrangeByScore(byte[] key, double min, double max) {
    return appendCommand(commandObjects.zrangeByScore(key, min, max));
  }

  @Override
  public Response> zrangeByScore(byte[] key, byte[] min, byte[] max) {
    return appendCommand(commandObjects.zrangeByScore(key, min, max));
  }

  @Override
  public Response> zrevrangeByScore(byte[] key, double max, double min) {
    return appendCommand(commandObjects.zrevrangeByScore(key, max, min));
  }

  @Override
  public Response> zrangeByScore(byte[] key, double min, double max, int offset, int count) {
    return appendCommand(commandObjects.zrangeByScore(key, min, max, offset, count));
  }

  @Override
  public Response> zrevrangeByScore(byte[] key, byte[] max, byte[] min) {
    return appendCommand(commandObjects.zrevrangeByScore(key, max, min));
  }

  @Override
  public Response> zrangeByScore(byte[] key, byte[] min, byte[] max, int offset, int count) {
    return appendCommand(commandObjects.zrangeByScore(key, min, max, offset, count));
  }

  @Override
  public Response> zrevrangeByScore(byte[] key, double max, double min, int offset, int count) {
    return appendCommand(commandObjects.zrevrangeByScore(key, max, min, offset, count));
  }

  @Override
  public Response> zrangeByScoreWithScores(byte[] key, double min, double max) {
    return appendCommand(commandObjects.zrangeByScoreWithScores(key, min, max));
  }

  @Override
  public Response> zrevrangeByScoreWithScores(byte[] key, double max, double min) {
    return appendCommand(commandObjects.zrevrangeByScoreWithScores(key, max, min));
  }

  @Override
  public Response> zrangeByScoreWithScores(byte[] key, double min, double max, int offset, int count) {
    return appendCommand(commandObjects.zrangeByScoreWithScores(key, min, max, offset, count));
  }

  @Override
  public Response> zrevrangeByScore(byte[] key, byte[] max, byte[] min, int offset, int count) {
    return appendCommand(commandObjects.zrevrangeByScore(key, max, min, offset, count));
  }

  @Override
  public Response> zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max) {
    return appendCommand(commandObjects.zrangeByScoreWithScores(key, min, max));
  }

  @Override
  public Response> zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min) {
    return appendCommand(commandObjects.zrevrangeByScoreWithScores(key, max, min));
  }

  @Override
  public Response> zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max, int offset, int count) {
    return appendCommand(commandObjects.zrangeByScoreWithScores(key, min, max, offset, count));
  }

  @Override
  public Response> zrevrangeByScoreWithScores(byte[] key, double max, double min, int offset, int count) {
    return appendCommand(commandObjects.zrevrangeByScoreWithScores(key, max, min, offset, count));
  }

  @Override
  public Response> zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min, int offset, int count) {
    return appendCommand(commandObjects.zrevrangeByScoreWithScores(key, max, min, offset, count));
  }

  @Override
  public Response zremrangeByRank(byte[] key, long start, long stop) {
    return appendCommand(commandObjects.zremrangeByRank(key, start, stop));
  }

  @Override
  public Response zremrangeByScore(byte[] key, double min, double max) {
    return appendCommand(commandObjects.zremrangeByScore(key, min, max));
  }

  @Override
  public Response zremrangeByScore(byte[] key, byte[] min, byte[] max) {
    return appendCommand(commandObjects.zremrangeByScore(key, min, max));
  }

  @Override
  public Response zlexcount(byte[] key, byte[] min, byte[] max) {
    return appendCommand(commandObjects.zlexcount(key, min, max));
  }

  @Override
  public Response> zrangeByLex(byte[] key, byte[] min, byte[] max) {
    return appendCommand(commandObjects.zrangeByLex(key, min, max));
  }

  @Override
  public Response> zrangeByLex(byte[] key, byte[] min, byte[] max, int offset, int count) {
    return appendCommand(commandObjects.zrangeByLex(key, min, max, offset, count));
  }

  @Override
  public Response> zrevrangeByLex(byte[] key, byte[] max, byte[] min) {
    return appendCommand(commandObjects.zrevrangeByLex(key, min, max));
  }

  @Override
  public Response> zrevrangeByLex(byte[] key, byte[] max, byte[] min, int offset, int count) {
    return appendCommand(commandObjects.zrevrangeByLex(key, min, max, offset, count));
  }

  @Override
  public Response zremrangeByLex(byte[] key, byte[] min, byte[] max) {
    return appendCommand(commandObjects.zremrangeByLex(key, min, max));
  }

  @Override
  public Response> zscan(byte[] key, byte[] cursor, ScanParams params) {
    return appendCommand(commandObjects.zscan(key, cursor, params));
  }

  @Override
  public Response> bzpopmax(double timeout, byte[]... keys) {
    return appendCommand(commandObjects.bzpopmax(timeout, keys));
  }

  @Override
  public Response> bzpopmin(double timeout, byte[]... keys) {
    return appendCommand(commandObjects.bzpopmin(timeout, keys));
  }

  @Override
  public Response>> zmpop(SortedSetOption option, byte[]... keys) {
    return appendCommand(commandObjects.zmpop(option, keys));
  }

  @Override
  public Response>> zmpop(SortedSetOption option, int count, byte[]... keys) {
    return appendCommand(commandObjects.zmpop(option, count, keys));
  }

  @Override
  public Response>> bzmpop(long timeout, SortedSetOption option, byte[]... keys) {
    return appendCommand(commandObjects.bzmpop(timeout, option, keys));
  }

  @Override
  public Response>> bzmpop(long timeout, SortedSetOption option, int count, byte[]... keys) {
    return appendCommand(commandObjects.bzmpop(timeout, option, count, keys));
  }

  @Override
  public Response> zdiff(byte[]... keys) {
    return appendCommand(commandObjects.zdiff(keys));
  }

  @Override
  public Response> zdiffWithScores(byte[]... keys) {
    return appendCommand(commandObjects.zdiffWithScores(keys));
  }

  @Override
  public Response zdiffStore(byte[] dstkey, byte[]... keys) {
    return appendCommand(commandObjects.zdiffStore(dstkey, keys));
  }

  @Override
  public Response> zinter(ZParams params, byte[]... keys) {
    return appendCommand(commandObjects.zinter(params, keys));
  }

  @Override
  public Response> zinterWithScores(ZParams params, byte[]... keys) {
    return appendCommand(commandObjects.zinterWithScores(params, keys));
  }

  @Override
  public Response zinterstore(byte[] dstkey, byte[]... sets) {
    return appendCommand(commandObjects.zinterstore(dstkey, sets));
  }

  @Override
  public Response zinterstore(byte[] dstkey, ZParams params, byte[]... sets) {
    return appendCommand(commandObjects.zinterstore(dstkey, params, sets));
  }

  @Override
  public Response zintercard(byte[]... keys) {
    return appendCommand(commandObjects.zintercard(keys));
  }

  @Override
  public Response zintercard(long limit, byte[]... keys) {
    return appendCommand(commandObjects.zintercard(limit, keys));
  }

  @Override
  public Response> zunion(ZParams params, byte[]... keys) {
    return appendCommand(commandObjects.zunion(params, keys));
  }

  @Override
  public Response> zunionWithScores(ZParams params, byte[]... keys) {
    return appendCommand(commandObjects.zunionWithScores(params, keys));
  }

  @Override
  public Response zunionstore(byte[] dstkey, byte[]... sets) {
    return appendCommand(commandObjects.zunionstore(dstkey, sets));
  }

  @Override
  public Response zunionstore(byte[] dstkey, ZParams params, byte[]... sets) {
    return appendCommand(commandObjects.zunionstore(dstkey, params, sets));
  }

  @Override
  public Response xadd(byte[] key, XAddParams params, Map hash) {
    return appendCommand(commandObjects.xadd(key, params, hash));
  }

  @Override
  public Response xlen(byte[] key) {
    return appendCommand(commandObjects.xlen(key));
  }

  @Override
  public Response> xrange(byte[] key, byte[] start, byte[] end) {
    return appendCommand(commandObjects.xrange(key, start, end));
  }

  @Override
  public Response> xrange(byte[] key, byte[] start, byte[] end, int count) {
    return appendCommand(commandObjects.xrange(key, start, end, count));
  }

  @Override
  public Response> xrevrange(byte[] key, byte[] end, byte[] start) {
    return appendCommand(commandObjects.xrevrange(key, end, start));
  }

  @Override
  public Response> xrevrange(byte[] key, byte[] end, byte[] start, int count) {
    return appendCommand(commandObjects.xrevrange(key, end, start, count));
  }

  @Override
  public Response xack(byte[] key, byte[] group, byte[]... ids) {
    return appendCommand(commandObjects.xack(key, group, ids));
  }

  @Override
  public Response xgroupCreate(byte[] key, byte[] groupName, byte[] id, boolean makeStream) {
    return appendCommand(commandObjects.xgroupCreate(key, groupName, id, makeStream));
  }

  @Override
  public Response xgroupSetID(byte[] key, byte[] groupName, byte[] id) {
    return appendCommand(commandObjects.xgroupSetID(key, groupName, id));
  }

  @Override
  public Response xgroupDestroy(byte[] key, byte[] groupName) {
    return appendCommand(commandObjects.xgroupDestroy(key, groupName));
  }

  @Override
  public Response xgroupCreateConsumer(byte[] key, byte[] groupName, byte[] consumerName) {
    return appendCommand(commandObjects.xgroupCreateConsumer(key, groupName, consumerName));
  }

  @Override
  public Response xgroupDelConsumer(byte[] key, byte[] groupName, byte[] consumerName) {
    return appendCommand(commandObjects.xgroupDelConsumer(key, groupName, consumerName));
  }

  @Override
  public Response xdel(byte[] key, byte[]... ids) {
    return appendCommand(commandObjects.xdel(key, ids));
  }

  @Override
  public Response xtrim(byte[] key, long maxLen, boolean approximateLength) {
    return appendCommand(commandObjects.xtrim(key, maxLen, approximateLength));
  }

  @Override
  public Response xtrim(byte[] key, XTrimParams params) {
    return appendCommand(commandObjects.xtrim(key, params));
  }

  @Override
  public Response xpending(byte[] key, byte[] groupName) {
    return appendCommand(commandObjects.xpending(key, groupName));
  }

  @Override
  public Response> xpending(byte[] key, byte[] groupName, byte[] start, byte[] end, int count, byte[] consumerName) {
    return appendCommand(commandObjects.xpending(key, groupName, start, end, count, consumerName));
  }

  @Override
  public Response> xpending(byte[] key, byte[] groupName, XPendingParams params) {
    return appendCommand(commandObjects.xpending(key, groupName, params));
  }

  @Override
  public Response> xclaim(byte[] key, byte[] group, byte[] consumerName, long minIdleTime, XClaimParams params, byte[]... ids) {
    return appendCommand(commandObjects.xclaim(key, group, consumerName, minIdleTime, params, ids));
  }

  @Override
  public Response> xclaimJustId(byte[] key, byte[] group, byte[] consumerName, long minIdleTime, XClaimParams params, byte[]... ids) {
    return appendCommand(commandObjects.xclaimJustId(key, group, consumerName, minIdleTime, params, ids));
  }

  @Override
  public Response> xautoclaim(byte[] key, byte[] groupName, byte[] consumerName, long minIdleTime, byte[] start, XAutoClaimParams params) {
    return appendCommand(commandObjects.xautoclaim(key, groupName, consumerName, minIdleTime, start, params));
  }

  @Override
  public Response> xautoclaimJustId(byte[] key, byte[] groupName, byte[] consumerName, long minIdleTime, byte[] start, XAutoClaimParams params) {
    return appendCommand(commandObjects.xautoclaimJustId(key, groupName, consumerName, minIdleTime, start, params));
  }

  @Override
  public Response xinfoStream(byte[] key) {
    return appendCommand(commandObjects.xinfoStream(key));
  }

  @Override
  public Response xinfoStreamFull(byte[] key) {
    return appendCommand(commandObjects.xinfoStreamFull(key));
  }

  @Override
  public Response xinfoStreamFull(byte[] key, int count) {
    return appendCommand(commandObjects.xinfoStreamFull(key, count));
  }

  @Override
  @Deprecated
  public Response> xinfoGroup(byte[] key) {
    return appendCommand(commandObjects.xinfoGroup(key));
  }

  @Override
  public Response> xinfoGroups(byte[] key) {
    return appendCommand(commandObjects.xinfoGroups(key));
  }

  @Override
  public Response> xinfoConsumers(byte[] key, byte[] group) {
    return appendCommand(commandObjects.xinfoConsumers(key, group));
  }

  @Override
  public Response> xread(XReadParams xReadParams, Map.Entry... streams) {
    return appendCommand(commandObjects.xread(xReadParams, streams));
  }

  @Override
  public Response> xreadGroup(byte[] groupName, byte[] consumer, XReadGroupParams xReadGroupParams, Map.Entry... streams) {
    return appendCommand(commandObjects.xreadGroup(groupName, consumer, xReadGroupParams, streams));
  }

  @Override
  public Response set(byte[] key, byte[] value) {
    return appendCommand(commandObjects.set(key, value));
  }

  @Override
  public Response set(byte[] key, byte[] value, SetParams params) {
    return appendCommand(commandObjects.set(key, value, params));
  }

  @Override
  public Response get(byte[] key) {
    return appendCommand(commandObjects.get(key));
  }

  @Override
  public Response setGet(byte[] key, byte[] value, SetParams params) {
    return appendCommand(commandObjects.setGet(key, value, params));
  }

  @Override
  public Response getDel(byte[] key) {
    return appendCommand(commandObjects.getDel(key));
  }

  @Override
  public Response getEx(byte[] key, GetExParams params) {
    return appendCommand(commandObjects.getEx(key, params));
  }

  @Override
  public Response setbit(byte[] key, long offset, boolean value) {
    return appendCommand(commandObjects.setbit(key, offset, value));
  }

  @Override
  public Response getbit(byte[] key, long offset) {
    return appendCommand(commandObjects.getbit(key, offset));
  }

  @Override
  public Response setrange(byte[] key, long offset, byte[] value) {
    return appendCommand(commandObjects.setrange(key, offset, value));
  }

  @Override
  public Response getrange(byte[] key, long startOffset, long endOffset) {
    return appendCommand(commandObjects.getrange(key, startOffset, endOffset));
  }

  @Override
  public Response getSet(byte[] key, byte[] value) {
    return appendCommand(commandObjects.getSet(key, value));
  }

  @Override
  public Response setnx(byte[] key, byte[] value) {
    return appendCommand(commandObjects.setnx(key, value));
  }

  @Override
  public Response setex(byte[] key, long seconds, byte[] value) {
    return appendCommand(commandObjects.setex(key, seconds, value));
  }

  @Override
  public Response psetex(byte[] key, long milliseconds, byte[] value) {
    return appendCommand(commandObjects.psetex(key, milliseconds, value));
  }

  @Override
  public Response> mget(byte[]... keys) {
    return appendCommand(commandObjects.mget(keys));
  }

  @Override
  public Response mset(byte[]... keysvalues) {
    return appendCommand(commandObjects.mset(keysvalues));
  }

  @Override
  public Response msetnx(byte[]... keysvalues) {
    return appendCommand(commandObjects.msetnx(keysvalues));
  }

  @Override
  public Response incr(byte[] key) {
    return appendCommand(commandObjects.incr(key));
  }

  @Override
  public Response incrBy(byte[] key, long increment) {
    return appendCommand(commandObjects.incrBy(key, increment));
  }

  @Override
  public Response incrByFloat(byte[] key, double increment) {
    return appendCommand(commandObjects.incrByFloat(key, increment));
  }

  @Override
  public Response decr(byte[] key) {
    return appendCommand(commandObjects.decr(key));
  }

  @Override
  public Response decrBy(byte[] key, long decrement) {
    return appendCommand(commandObjects.decrBy(key, decrement));
  }

  @Override
  public Response append(byte[] key, byte[] value) {
    return appendCommand(commandObjects.append(key, value));
  }

  @Override
  public Response substr(byte[] key, int start, int end) {
    return appendCommand(commandObjects.substr(key, start, end));
  }

  @Override
  public Response strlen(byte[] key) {
    return appendCommand(commandObjects.strlen(key));
  }

  @Override
  public Response bitcount(byte[] key) {
    return appendCommand(commandObjects.bitcount(key));
  }

  @Override
  public Response bitcount(byte[] key, long start, long end) {
    return appendCommand(commandObjects.bitcount(key, start, end));
  }

  @Override
  public Response bitcount(byte[] key, long start, long end, BitCountOption option) {
    return appendCommand(commandObjects.bitcount(key, start, end, option));
  }

  @Override
  public Response bitpos(byte[] key, boolean value) {
    return appendCommand(commandObjects.bitpos(key, value));
  }

  @Override
  public Response bitpos(byte[] key, boolean value, BitPosParams params) {
    return appendCommand(commandObjects.bitpos(key, value, params));
  }

  @Override
  public Response> bitfield(byte[] key, byte[]... arguments) {
    return appendCommand(commandObjects.bitfield(key, arguments));
  }

  @Override
  public Response> bitfieldReadonly(byte[] key, byte[]... arguments) {
    return appendCommand(commandObjects.bitfieldReadonly(key, arguments));
  }

  @Override
  public Response bitop(BitOP op, byte[] destKey, byte[]... srcKeys) {
    return appendCommand(commandObjects.bitop(op, destKey, srcKeys));
  }

  @Override
  public Response strAlgoLCSKeys(byte[] keyA, byte[] keyB, StrAlgoLCSParams params) {
    return appendCommand(commandObjects.strAlgoLCSKeys(keyA, keyB, params));
  }

  // RediSearch commands
  @Override
  public Response ftCreate(String indexName, IndexOptions indexOptions, Schema schema) {
    return appendCommand(commandObjects.ftCreate(indexName, indexOptions, schema));
  }

  @Override
  public Response ftCreate(String indexName, FTCreateParams createParams, Iterable schemaFields) {
    return appendCommand(commandObjects.ftCreate(indexName, createParams, schemaFields));
  }

  @Override
  public Response ftAlter(String indexName, Schema schema) {
    return appendCommand(commandObjects.ftAlter(indexName, schema));
  }

  @Override
  public Response ftAlter(String indexName, Iterable schemaFields) {
    return appendCommand(commandObjects.ftAlter(indexName, schemaFields));
  }

  @Override
  public Response ftSearch(String indexName, String query) {
    return appendCommand(commandObjects.ftSearch(indexName, query));
  }

  @Override
  public Response ftSearch(String indexName, String query, FTSearchParams searchParams) {
    return appendCommand(commandObjects.ftSearch(indexName, query, searchParams));
  }

  @Override
  public Response ftSearch(String indexName, Query query) {
    return appendCommand(commandObjects.ftSearch(indexName, query));
  }

  @Override
  public Response ftSearch(byte[] indexName, Query query) {
    return appendCommand(commandObjects.ftSearch(indexName, query));
  }

  @Override
  public Response ftExplain(String indexName, Query query) {
    return appendCommand(commandObjects.ftExplain(indexName, query));
  }

  @Override
  public Response> ftExplainCLI(String indexName, Query query) {
    return appendCommand(commandObjects.ftExplainCLI(indexName, query));
  }

  @Override
  public Response ftAggregate(String indexName, AggregationBuilder aggr) {
    return appendCommand(commandObjects.ftAggregate(indexName, aggr));
  }

  @Override
  @Deprecated
  public Response ftCursorRead(String indexName, long cursorId, int count) {
    return appendCommand(commandObjects.ftCursorRead(indexName, cursorId, count));
  }

  @Override
  @Deprecated
  public Response ftCursorDel(String indexName, long cursorId) {
    return appendCommand(commandObjects.ftCursorDel(indexName, cursorId));
  }

  @Override
  @Deprecated
  public Response ftDropIndex(String indexName) {
    return appendCommand(commandObjects.ftDropIndex(indexName));
  }

  @Override
  @Deprecated
  public Response ftDropIndexDD(String indexName) {
    return appendCommand(commandObjects.ftDropIndexDD(indexName));
  }

  @Override
  public Response ftSynUpdate(String indexName, String synonymGroupId, String... terms) {
    return appendCommand(commandObjects.ftSynUpdate(indexName, synonymGroupId, terms));
  }

  @Override
  public Response>> ftSynDump(String indexName) {
    return appendCommand(commandObjects.ftSynDump(indexName));
  }

  @Override
  public Response ftDictAdd(String dictionary, String... terms) {
    return appendCommand(commandObjects.ftDictAdd(dictionary, terms));
  }

  @Override
  public Response ftDictDel(String dictionary, String... terms) {
    return appendCommand(commandObjects.ftDictDel(dictionary, terms));
  }

  @Override
  public Response> ftDictDump(String dictionary) {
    return appendCommand(commandObjects.ftDictDump(dictionary));
  }

  @Override
  public Response ftDictAddBySampleKey(String indexName, String dictionary, String... terms) {
    return appendCommand(commandObjects.ftDictAddBySampleKey(indexName, dictionary, terms));
  }

  @Override
  public Response ftDictDelBySampleKey(String indexName, String dictionary, String... terms) {
    return appendCommand(commandObjects.ftDictDelBySampleKey(indexName, dictionary, terms));
  }

  @Override
  public Response> ftDictDumpBySampleKey(String indexName, String dictionary) {
    return appendCommand(commandObjects.ftDictDumpBySampleKey(indexName, dictionary));
  }

  @Override
  public Response>> ftSpellCheck(String index, String query) {
    return appendCommand(commandObjects.ftSpellCheck(index, query));
  }

  @Override
  public Response>> ftSpellCheck(String index, String query, FTSpellCheckParams spellCheckParams) {
    return appendCommand(commandObjects.ftSpellCheck(index, query, spellCheckParams));
  }

  @Override
  public Response> ftInfo(String indexName) {
    return appendCommand(commandObjects.ftInfo(indexName));
  }

  @Override
  public Response> ftTagVals(String indexName, String fieldName) {
    return appendCommand(commandObjects.ftTagVals(indexName, fieldName));
  }

  @Override
  @Deprecated
  public Response ftAliasAdd(String aliasName, String indexName) {
    return appendCommand(commandObjects.ftAliasAdd(aliasName, indexName));
  }

  @Override
  @Deprecated
  public Response ftAliasUpdate(String aliasName, String indexName) {
    return appendCommand(commandObjects.ftAliasUpdate(aliasName, indexName));
  }

  @Override
  @Deprecated
  public Response ftAliasDel(String aliasName) {
    return appendCommand(commandObjects.ftAliasDel(aliasName));
  }

  @Override
  public Response> ftConfigGet(String option) {
    return appendCommand(commandObjects.ftConfigGet(option));
  }

  @Override
  public Response> ftConfigGet(String indexName, String option) {
    return appendCommand(commandObjects.ftConfigGet(indexName, option));
  }

  @Override
  public Response ftConfigSet(String option, String value) {
    return appendCommand(commandObjects.ftConfigSet(option, value));
  }

  @Override
  public Response ftConfigSet(String indexName, String option, String value) {
    return appendCommand(commandObjects.ftConfigSet(indexName, option, value));
  }

  @Override
  public Response ftSugAdd(String key, String string, double score) {
    return appendCommand(commandObjects.ftSugAdd(key, string, score));
  }

  @Override
  public Response ftSugAddIncr(String key, String string, double score) {
    return appendCommand(commandObjects.ftSugAddIncr(key, string, score));
  }

  @Override
  public Response> ftSugGet(String key, String prefix) {
    return appendCommand(commandObjects.ftSugGet(key, prefix));
  }

  @Override
  public Response> ftSugGet(String key, String prefix, boolean fuzzy, int max) {
    return appendCommand(commandObjects.ftSugGet(key, prefix, fuzzy, max));
  }

  @Override
  public Response> ftSugGetWithScores(String key, String prefix) {
    return appendCommand(commandObjects.ftSugGetWithScores(key, prefix));
  }

  @Override
  public Response> ftSugGetWithScores(String key, String prefix, boolean fuzzy, int max) {
    return appendCommand(commandObjects.ftSugGetWithScores(key, prefix, fuzzy, max));
  }

  @Override
  public Response ftSugDel(String key, String string) {
    return appendCommand(commandObjects.ftSugDel(key, string));
  }

  @Override
  public Response ftSugLen(String key) {
    return appendCommand(commandObjects.ftSugLen(key));
  }
  // RediSearch commands

  // RedisJSON commands
  @Override
  public Response lcs(byte[] keyA, byte[] keyB, LCSParams params) {
    return appendCommand(commandObjects.lcs(keyA, keyB, params));
  }


  @Override
  public Response jsonSet(String key, Path2 path, Object object) {
    return appendCommand(commandObjects.jsonSet(key, path, object));
  }

  @Override
  public Response jsonSetWithEscape(String key, Path2 path, Object object) {
    return appendCommand(commandObjects.jsonSetWithEscape(key, path, object));
  }

  @Override
  public Response jsonSet(String key, Path path, Object object) {
    return appendCommand(commandObjects.jsonSet(key, path, object));
  }

  @Override
  public Response jsonSet(String key, Path2 path, Object object, JsonSetParams params) {
    return appendCommand(commandObjects.jsonSet(key, path, object, params));
  }

  @Override
  public Response jsonSetWithEscape(String key, Path2 path, Object object, JsonSetParams params) {
    return appendCommand(commandObjects.jsonSetWithEscape(key, path, object, params));
  }

  @Override
  public Response jsonSet(String key, Path path, Object object, JsonSetParams params) {
    return appendCommand(commandObjects.jsonSet(key, path, object, params));
  }

  @Override
  public Response jsonGet(String key) {
    return appendCommand(commandObjects.jsonGet(key));
  }

  @Override
  public  Response jsonGet(String key, Class clazz) {
    return appendCommand(commandObjects.jsonGet(key, clazz));
  }

  @Override
  public Response jsonGet(String key, Path2... paths) {
    return appendCommand(commandObjects.jsonGet(key, paths));
  }

  @Override
  public Response jsonGet(String key, Path... paths) {
    return appendCommand(commandObjects.jsonGet(key, paths));
  }

  @Override
  public  Response jsonGet(String key, Class clazz, Path... paths) {
    return appendCommand(commandObjects.jsonGet(key, clazz, paths));
  }

  @Override
  public Response> jsonMGet(Path2 path, String... keys) {
    return appendCommand(commandObjects.jsonMGet(path, keys));
  }

  @Override
  public  Response> jsonMGet(Path path, Class clazz, String... keys) {
    return appendCommand(commandObjects.jsonMGet(path, clazz, keys));
  }

  @Override
  public Response jsonDel(String key) {
    return appendCommand(commandObjects.jsonDel(key));
  }

  @Override
  public Response jsonDel(String key, Path2 path) {
    return appendCommand(commandObjects.jsonDel(key, path));
  }

  @Override
  public Response jsonDel(String key, Path path) {
    return appendCommand(commandObjects.jsonDel(key, path));
  }

  @Override
  public Response jsonClear(String key) {
    return appendCommand(commandObjects.jsonClear(key));
  }

  @Override
  public Response jsonClear(String key, Path2 path) {
    return appendCommand(commandObjects.jsonClear(key, path));
  }

  @Override
  public Response jsonClear(String key, Path path) {
    return appendCommand(commandObjects.jsonClear(key, path));
  }

  @Override
  public Response> jsonToggle(String key, Path2 path) {
    return appendCommand(commandObjects.jsonToggle(key, path));
  }

  @Override
  public Response jsonToggle(String key, Path path) {
    return appendCommand(commandObjects.jsonToggle(key, path));
  }

  @Override
  public Response> jsonType(String key) {
    return appendCommand(commandObjects.jsonType(key));
  }

  @Override
  public Response>> jsonType(String key, Path2 path) {
    return appendCommand(commandObjects.jsonType(key, path));
  }

  @Override
  public Response> jsonType(String key, Path path) {
    return appendCommand(commandObjects.jsonType(key, path));
  }

  @Override
  public Response jsonStrAppend(String key, Object string) {
    return appendCommand(commandObjects.jsonStrAppend(key, string));
  }

  @Override
  public Response> jsonStrAppend(String key, Path2 path, Object string) {
    return appendCommand(commandObjects.jsonStrAppend(key, path, string));
  }

  @Override
  public Response jsonStrAppend(String key, Path path, Object string) {
    return appendCommand(commandObjects.jsonStrAppend(key, path, string));
  }

  @Override
  public Response jsonStrLen(String key) {
    return appendCommand(commandObjects.jsonStrLen(key));
  }

  @Override
  public Response> jsonStrLen(String key, Path2 path) {
    return appendCommand(commandObjects.jsonStrLen(key, path));
  }

  @Override
  public Response jsonStrLen(String key, Path path) {
    return appendCommand(commandObjects.jsonStrLen(key, path));
  }

  @Override
  public Response jsonNumIncrBy(String key, Path2 path, double value) {
    return appendCommand(commandObjects.jsonNumIncrBy(key, path, value));
  }

  @Override
  public Response jsonNumIncrBy(String key, Path path, double value) {
    return appendCommand(commandObjects.jsonNumIncrBy(key, path, value));
  }

  @Override
  public Response> jsonArrAppend(String key, Path2 path, Object... objects) {
    return appendCommand(commandObjects.jsonArrAppend(key, path, objects));
  }

  @Override
  public Response> jsonArrAppendWithEscape(String key, Path2 path, Object... objects) {
    return appendCommand(commandObjects.jsonArrAppendWithEscape(key, path, objects));
  }

  @Override
  public Response jsonArrAppend(String key, Path path, Object... objects) {
    return appendCommand(commandObjects.jsonArrAppend(key, path, objects));
  }

  @Override
  public Response> jsonArrIndex(String key, Path2 path, Object scalar) {
    return appendCommand(commandObjects.jsonArrIndex(key, path, scalar));
  }

  @Override
  public Response> jsonArrIndexWithEscape(String key, Path2 path, Object scalar) {
    return appendCommand(commandObjects.jsonArrIndexWithEscape(key, path, scalar));
  }

  @Override
  public Response jsonArrIndex(String key, Path path, Object scalar) {
    return appendCommand(commandObjects.jsonArrIndex(key, path, scalar));
  }

  @Override
  public Response> jsonArrInsert(String key, Path2 path, int index, Object... objects) {
    return appendCommand(commandObjects.jsonArrInsert(key, path, index, objects));
  }

  @Override
  public Response> jsonArrInsertWithEscape(String key, Path2 path, int index, Object... objects) {
    return appendCommand(commandObjects.jsonArrInsertWithEscape(key, path, index, objects));
  }

  @Override
  public Response jsonArrInsert(String key, Path path, int index, Object... pojos) {
    return appendCommand(commandObjects.jsonArrInsert(key, path, index, pojos));
  }

  @Override
  public Response jsonArrPop(String key) {
    return appendCommand(commandObjects.jsonArrPop(key));
  }

  @Override
  public Response jsonArrLen(String key, Path path) {
    return appendCommand(commandObjects.jsonArrLen(key, path));
  }

  @Override
  public Response> jsonArrTrim(String key, Path2 path, int start, int stop) {
    return appendCommand(commandObjects.jsonArrTrim(key, path, start, stop));
  }

  @Override
  public Response jsonArrTrim(String key, Path path, int start, int stop) {
    return appendCommand(commandObjects.jsonArrTrim(key, path, start, stop));
  }

  @Override
  public  Response jsonArrPop(String key, Class clazz, Path path) {
    return appendCommand(commandObjects.jsonArrPop(key, clazz, path));
  }

  @Override
  public Response> jsonArrPop(String key, Path2 path, int index) {
    return appendCommand(commandObjects.jsonArrPop(key, path, index));
  }

  @Override
  public Response jsonArrPop(String key, Path path, int index) {
    return appendCommand(commandObjects.jsonArrPop(key, path, index));
  }

  @Override
  public  Response jsonArrPop(String key, Class clazz, Path path, int index) {
    return appendCommand(commandObjects.jsonArrPop(key, clazz, path, index));
  }

  @Override
  public Response jsonArrLen(String key) {
    return appendCommand(commandObjects.jsonArrLen(key));
  }

  @Override
  public Response> jsonArrLen(String key, Path2 path) {
    return appendCommand(commandObjects.jsonArrLen(key, path));
  }

  @Override
  public  Response jsonArrPop(String key, Class clazz) {
    return appendCommand(commandObjects.jsonArrPop(key, clazz));
  }

  @Override
  public Response> jsonArrPop(String key, Path2 path) {
    return appendCommand(commandObjects.jsonArrPop(key, path));
  }

  @Override
  public Response jsonArrPop(String key, Path path) {
    return appendCommand(commandObjects.jsonArrPop(key, path));
  }
  // RedisJSON commands

  // RedisTimeSeries commands
  @Override
  public Response tsCreate(String key) {
    return appendCommand(commandObjects.tsCreate(key));
  }

  @Override
  public Response tsCreate(String key, TSCreateParams createParams) {
    return appendCommand(commandObjects.tsCreate(key, createParams));
  }

  @Override
  public Response tsDel(String key, long fromTimestamp, long toTimestamp) {
    return appendCommand(commandObjects.tsDel(key, fromTimestamp, toTimestamp));
  }

  @Override
  public Response tsAlter(String key, TSAlterParams alterParams) {
    return appendCommand(commandObjects.tsAlter(key, alterParams));
  }

  @Override
  public Response tsAdd(String key, double value) {
    return appendCommand(commandObjects.tsAdd(key, value));
  }

  @Override
  public Response tsAdd(String key, long timestamp, double value) {
    return appendCommand(commandObjects.tsAdd(key, timestamp, value));
  }

  @Override
  public Response tsAdd(String key, long timestamp, double value, TSCreateParams createParams) {
    return appendCommand(commandObjects.tsAdd(key, timestamp, value, createParams));
  }

  @Override
  public Response> tsMAdd(Map.Entry... entries) {
    return appendCommand(commandObjects.tsMAdd(entries));
  }

  @Override
  public Response tsIncrBy(String key, double value) {
    return appendCommand(commandObjects.tsIncrBy(key, value));
  }

  @Override
  public Response tsIncrBy(String key, double value, long timestamp) {
    return appendCommand(commandObjects.tsIncrBy(key, value, timestamp));
  }

  @Override
  public Response tsDecrBy(String key, double value) {
    return appendCommand(commandObjects.tsDecrBy(key, value));
  }

  @Override
  public Response tsDecrBy(String key, double value, long timestamp) {
    return appendCommand(commandObjects.tsDecrBy(key, value, timestamp));
  }

  @Override
  public Response> tsRange(String key, long fromTimestamp, long toTimestamp) {
    return appendCommand(commandObjects.tsRange(key, fromTimestamp, toTimestamp));
  }

  @Override
  public Response> tsRange(String key, TSRangeParams rangeParams) {
    return appendCommand(commandObjects.tsRange(key, rangeParams));
  }

  @Override
  public Response> tsRevRange(String key, long fromTimestamp, long toTimestamp) {
    return appendCommand(commandObjects.tsRevRange(key, fromTimestamp, toTimestamp));
  }

  @Override
  public Response> tsRevRange(String key, TSRangeParams rangeParams) {
    return appendCommand(commandObjects.tsRevRange(key, rangeParams));
  }

  @Override
  public Response> tsMRange(long fromTimestamp, long toTimestamp, String... filters) {
    return appendCommand(commandObjects.tsMRange(fromTimestamp, toTimestamp, filters));
  }

  @Override
  public Response> tsMRange(TSMRangeParams multiRangeParams) {
    return appendCommand(commandObjects.tsMRange(multiRangeParams));
  }

  @Override
  public Response> tsMRevRange(long fromTimestamp, long toTimestamp, String... filters) {
    return appendCommand(commandObjects.tsMRevRange(fromTimestamp, toTimestamp, filters));
  }

  @Override
  public Response> tsMRevRange(TSMRangeParams multiRangeParams) {
    return appendCommand(commandObjects.tsMRevRange(multiRangeParams));
  }

  @Override
  public Response tsGet(String key) {
    return appendCommand(commandObjects.tsGet(key));
  }

  @Override
  public Response tsGet(String key, TSGetParams getParams) {
    return appendCommand(commandObjects.tsGet(key, getParams));
  }

  @Override
  public Response>> tsMGet(TSMGetParams multiGetParams, String... filters) {
    return appendCommand(commandObjects.tsMGet(multiGetParams, filters));
  }

  @Override
  public Response tsCreateRule(String sourceKey, String destKey, AggregationType aggregationType, long timeBucket) {
    return appendCommand(commandObjects.tsCreateRule(sourceKey, destKey, aggregationType, timeBucket));
  }

  @Override
  public Response tsCreateRule(String sourceKey, String destKey, AggregationType aggregationType, long bucketDuration, long alignTimestamp) {
    return appendCommand(commandObjects.tsCreateRule(sourceKey, destKey, aggregationType, bucketDuration, alignTimestamp));
  }

  @Override
  public Response tsDeleteRule(String sourceKey, String destKey) {
    return appendCommand(commandObjects.tsDeleteRule(sourceKey, destKey));
  }

  @Override
  public Response> tsQueryIndex(String... filters) {
    return appendCommand(commandObjects.tsQueryIndex(filters));
  }
  // RedisTimeSeries commands

  // RedisBloom commands
  @Override
  public Response bfReserve(String key, double errorRate, long capacity) {
    return appendCommand(commandObjects.bfReserve(key, errorRate, capacity));
  }

  @Override
  public Response bfReserve(String key, double errorRate, long capacity, BFReserveParams reserveParams) {
    return appendCommand(commandObjects.bfReserve(key, errorRate, capacity, reserveParams));
  }

  @Override
  public Response bfAdd(String key, String item) {
    return appendCommand(commandObjects.bfAdd(key, item));
  }

  @Override
  public Response> bfMAdd(String key, String... items) {
    return appendCommand(commandObjects.bfMAdd(key, items));
  }

  @Override
  public Response> bfInsert(String key, String... items) {
    return appendCommand(commandObjects.bfInsert(key, items));
  }

  @Override
  public Response> bfInsert(String key, BFInsertParams insertParams, String... items) {
    return appendCommand(commandObjects.bfInsert(key, insertParams, items));
  }

  @Override
  public Response bfExists(String key, String item) {
    return appendCommand(commandObjects.bfExists(key, item));
  }

  @Override
  public Response> bfMExists(String key, String... items) {
    return appendCommand(commandObjects.bfMExists(key, items));
  }

  @Override
  public Response> bfScanDump(String key, long iterator) {
    return appendCommand(commandObjects.bfScanDump(key, iterator));
  }

  @Override
  public Response bfLoadChunk(String key, long iterator, byte[] data) {
    return appendCommand(commandObjects.bfLoadChunk(key, iterator, data));
  }

  @Override
  public Response bfCard(String key) {
    return appendCommand(commandObjects.bfCard(key));
  }

  @Override
  public Response> bfInfo(String key) {
    return appendCommand(commandObjects.bfInfo(key));
  }

  @Override
  public Response cfReserve(String key, long capacity) {
    return appendCommand(commandObjects.cfReserve(key, capacity));
  }

  @Override
  public Response cfReserve(String key, long capacity, CFReserveParams reserveParams) {
    return appendCommand(commandObjects.cfReserve(key, capacity, reserveParams));
  }

  @Override
  public Response cfAdd(String key, String item) {
    return appendCommand(commandObjects.cfAdd(key, item));
  }

  @Override
  public Response cfAddNx(String key, String item) {
    return appendCommand(commandObjects.cfAddNx(key, item));
  }

  @Override
  public Response> cfInsert(String key, String... items) {
    return appendCommand(commandObjects.cfInsert(key, items));
  }

  @Override
  public Response> cfInsert(String key, CFInsertParams insertParams, String... items) {
    return appendCommand(commandObjects.cfInsert(key, insertParams, items));
  }

  @Override
  public Response> cfInsertNx(String key, String... items) {
    return appendCommand(commandObjects.cfInsertNx(key, items));
  }

  @Override
  public Response> cfInsertNx(String key, CFInsertParams insertParams, String... items) {
    return appendCommand(commandObjects.cfInsertNx(key, insertParams, items));
  }

  @Override
  public Response cfExists(String key, String item) {
    return appendCommand(commandObjects.cfExists(key, item));
  }

  @Override
  public Response cfDel(String key, String item) {
    return appendCommand(commandObjects.cfDel(key, item));
  }

  @Override
  public Response cfCount(String key, String item) {
    return appendCommand(commandObjects.cfCount(key, item));
  }

  @Override
  public Response> cfScanDump(String key, long iterator) {
    return appendCommand(commandObjects.cfScanDump(key, iterator));
  }

  @Override
  public Response cfLoadChunk(String key, long iterator, byte[] data) {
    return appendCommand(commandObjects.cfLoadChunk(key, iterator, data));
  }

  @Override
  public Response> cfInfo(String key) {
    return appendCommand(commandObjects.cfInfo(key));
  }

  @Override
  public Response cmsInitByDim(String key, long width, long depth) {
    return appendCommand(commandObjects.cmsInitByDim(key, width, depth));
  }

  @Override
  public Response cmsInitByProb(String key, double error, double probability) {
    return appendCommand(commandObjects.cmsInitByProb(key, error, probability));
  }

  @Override
  public Response> cmsIncrBy(String key, Map itemIncrements) {
    return appendCommand(commandObjects.cmsIncrBy(key, itemIncrements));
  }

  @Override
  public Response> cmsQuery(String key, String... items) {
    return appendCommand(commandObjects.cmsQuery(key, items));
  }

  @Override
  public Response cmsMerge(String destKey, String... keys) {
    return appendCommand(commandObjects.cmsMerge(destKey, keys));
  }

  @Override
  public Response cmsMerge(String destKey, Map keysAndWeights) {
    return appendCommand(commandObjects.cmsMerge(destKey, keysAndWeights));
  }

  @Override
  public Response> cmsInfo(String key) {
    return appendCommand(commandObjects.cmsInfo(key));
  }

  @Override
  public Response topkReserve(String key, long topk) {
    return appendCommand(commandObjects.topkReserve(key, topk));
  }

  @Override
  public Response topkReserve(String key, long topk, long width, long depth, double decay) {
    return appendCommand(commandObjects.topkReserve(key, topk, width, depth, decay));
  }

  @Override
  public Response> topkAdd(String key, String... items) {
    return appendCommand(commandObjects.topkAdd(key, items));
  }

  @Override
  public Response> topkIncrBy(String key, Map itemIncrements) {
    return appendCommand(commandObjects.topkIncrBy(key, itemIncrements));
  }

  @Override
  public Response> topkQuery(String key, String... items) {
    return appendCommand(commandObjects.topkQuery(key, items));
  }

  @Override
  public Response> topkCount(String key, String... items) {
    return appendCommand(commandObjects.topkCount(key, items));
  }

  @Override
  public Response> topkList(String key) {
    return appendCommand(commandObjects.topkList(key));
  }

  @Override
  public Response> topkInfo(String key) {
    return appendCommand(commandObjects.topkInfo(key));
  }

  @Override
  public Response tdigestCreate(String key) {
    return appendCommand(commandObjects.tdigestCreate(key));
  }

  @Override
  public Response tdigestCreate(String key, int compression) {
    return appendCommand(commandObjects.tdigestCreate(key, compression));
  }

  @Override
  public Response tdigestReset(String key) {
    return appendCommand(commandObjects.tdigestReset(key));
  }

  @Override
  public Response tdigestMerge(String destinationKey, String... sourceKeys) {
    return appendCommand(commandObjects.tdigestMerge(destinationKey, sourceKeys));
  }

  @Override
  public Response tdigestMerge(TDigestMergeParams mergeParams, String destinationKey, String... sourceKeys) {
    return appendCommand(commandObjects.tdigestMerge(mergeParams, destinationKey, sourceKeys));
  }

  @Override
  public Response> tdigestInfo(String key) {
    return appendCommand(commandObjects.tdigestInfo(key));
  }

  @Override
  public Response tdigestAdd(String key, double... values) {
    return appendCommand(commandObjects.tdigestAdd(key, values));
  }

  @Override
  public Response> tdigestCDF(String key, double... values) {
    return appendCommand(commandObjects.tdigestCDF(key, values));
  }

  @Override
  public Response> tdigestQuantile(String key, double... quantiles) {
    return appendCommand(commandObjects.tdigestQuantile(key, quantiles));
  }

  @Override
  public Response tdigestMin(String key) {
    return appendCommand(commandObjects.tdigestMin(key));
  }

  @Override
  public Response tdigestMax(String key) {
    return appendCommand(commandObjects.tdigestMax(key));
  }

  @Override
  public Response tdigestTrimmedMean(String key, double lowCutQuantile, double highCutQuantile) {
    return appendCommand(commandObjects.tdigestTrimmedMean(key, lowCutQuantile, highCutQuantile));
  }

  @Override
  public Response> tdigestRank(String key, double... values) {
    return appendCommand(commandObjects.tdigestRank(key, values));
  }

  @Override
  public Response> tdigestRevRank(String key, double... values) {
    return appendCommand(commandObjects.tdigestRevRank(key, values));
  }

  @Override
  public Response> tdigestByRank(String key, long... ranks) {
    return appendCommand(commandObjects.tdigestByRank(key, ranks));
  }

  @Override
  public Response> tdigestByRevRank(String key, long... ranks) {
    return appendCommand(commandObjects.tdigestByRevRank(key, ranks));
  }
  // RedisBloom commands

  // RedisGraph commands
  @Override
  public Response graphQuery(String name, String query) {
    return appendCommand(graphCommandObjects.graphQuery(name, query));
  }

  @Override
  public Response graphReadonlyQuery(String name, String query) {
    return appendCommand(graphCommandObjects.graphReadonlyQuery(name, query));
  }

  @Override
  public Response graphQuery(String name, String query, long timeout) {
    return appendCommand(graphCommandObjects.graphQuery(name, query, timeout));
  }

  @Override
  public Response graphReadonlyQuery(String name, String query, long timeout) {
    return appendCommand(graphCommandObjects.graphReadonlyQuery(name, query, timeout));
  }

  @Override
  public Response graphQuery(String name, String query, Map params) {
    return appendCommand(graphCommandObjects.graphQuery(name, query, params));
  }

  @Override
  public Response graphReadonlyQuery(String name, String query, Map params) {
    return appendCommand(graphCommandObjects.graphReadonlyQuery(name, query, params));
  }

  @Override
  public Response graphQuery(String name, String query, Map params, long timeout) {
    return appendCommand(graphCommandObjects.graphQuery(name, query, params, timeout));
  }

  @Override
  public Response graphReadonlyQuery(String name, String query, Map params, long timeout) {
    return appendCommand(graphCommandObjects.graphReadonlyQuery(name, query, params, timeout));
  }

  @Override
  public Response graphDelete(String name) {
    return appendCommand(graphCommandObjects.graphDelete(name));
  }

  @Override
  public Response> graphProfile(String graphName, String query) {
    return appendCommand(commandObjects.graphProfile(graphName, query));
  }
  // RedisGraph commands

  public Response waitReplicas(int replicas, long timeout) {
    return appendCommand(commandObjects.waitReplicas(replicas, timeout));
  }

  public Response sendCommand(ProtocolCommand cmd, String... args) {
    return sendCommand(new CommandArguments(cmd).addObjects((Object[]) args));
  }

  public Response sendCommand(ProtocolCommand cmd, byte[]... args) {
    return sendCommand(new CommandArguments(cmd).addObjects((Object[]) args));
  }

  public Response sendCommand(CommandArguments args) {
    return executeCommand(new CommandObject<>(args, BuilderFactory.RAW_OBJECT));
  }

  public  Response executeCommand(CommandObject command) {
    return appendCommand(command);
  }

  public void setJsonObjectMapper(JsonObjectMapper jsonObjectMapper) {
    this.commandObjects.setJsonObjectMapper(jsonObjectMapper);
  }
}
    
    
    
    

    




    
    
    © 2015 - 2024 Weber Informatics LLC | Privacy Policy