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

    • io.lettuce.core.AbstractRedisAsyncCommands Maven / Gradle / Ivy

    Go to download

    Advanced and thread-safe Java Redis client for synchronous, asynchronous, and reactive usage. Supports Cluster, Sentinel, Pipelining, Auto-Reconnect, Codecs and much more.

    The newest version!
    /*
 * Copyright 2011-Present, Redis Ltd. and Contributors
 * All rights reserved.
 *
 * Licensed under the MIT License.
 *
 * This file contains contributions from third-party contributors
 * licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package io.lettuce.core;

import io.lettuce.core.GeoArgs.Unit;
import io.lettuce.core.api.StatefulConnection;
import io.lettuce.core.api.async.*;
import io.lettuce.core.cluster.api.async.RedisClusterAsyncCommands;
import io.lettuce.core.codec.Base16;
import io.lettuce.core.codec.RedisCodec;
import io.lettuce.core.internal.LettuceAssert;
import io.lettuce.core.json.JsonParser;
import io.lettuce.core.json.JsonType;
import io.lettuce.core.json.JsonValue;
import io.lettuce.core.json.arguments.JsonGetArgs;
import io.lettuce.core.json.arguments.JsonMsetArgs;
import io.lettuce.core.json.JsonPath;
import io.lettuce.core.json.arguments.JsonRangeArgs;
import io.lettuce.core.json.arguments.JsonSetArgs;
import io.lettuce.core.models.stream.ClaimedMessages;
import io.lettuce.core.models.stream.PendingMessage;
import io.lettuce.core.models.stream.PendingMessages;
import io.lettuce.core.output.CommandOutput;
import io.lettuce.core.output.KeyStreamingChannel;
import io.lettuce.core.output.KeyValueStreamingChannel;
import io.lettuce.core.output.ScoredValueStreamingChannel;
import io.lettuce.core.output.ValueStreamingChannel;
import io.lettuce.core.protocol.AsyncCommand;
import io.lettuce.core.protocol.Command;
import io.lettuce.core.protocol.CommandArgs;
import io.lettuce.core.protocol.CommandType;
import io.lettuce.core.protocol.ProtocolKeyword;
import io.lettuce.core.protocol.RedisCommand;
import reactor.core.publisher.Mono;

import java.time.Duration;
import java.time.Instant;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.Set;

import static io.lettuce.core.protocol.CommandType.EXEC;
import static io.lettuce.core.protocol.CommandType.GEORADIUSBYMEMBER_RO;
import static io.lettuce.core.protocol.CommandType.GEORADIUS_RO;

/**
 * An asynchronous and thread-safe API for a Redis connection.
 *
 * @param  Key type.
 * @param  Value type.
 * @author Will Glozer
 * @author Mark Paluch
 * @author Tugdual Grall
 * @author dengliming
 * @author Andrey Shlykov
 * @author Ali Takavci
 */
@SuppressWarnings("unchecked")
public abstract class AbstractRedisAsyncCommands implements RedisAclAsyncCommands, RedisHashAsyncCommands,
        RedisKeyAsyncCommands, RedisStringAsyncCommands, RedisListAsyncCommands, RedisSetAsyncCommands,
        RedisSortedSetAsyncCommands, RedisScriptingAsyncCommands, RedisServerAsyncCommands,
        RedisHLLAsyncCommands, BaseRedisAsyncCommands, RedisTransactionalAsyncCommands,
        RedisGeoAsyncCommands, RedisClusterAsyncCommands, RedisJsonAsyncCommands {

    private final StatefulConnection connection;

    private final RedisCommandBuilder commandBuilder;

    private final RedisJsonCommandBuilder jsonCommandBuilder;

    private final Mono parser;

    /**
     * Initialize a new instance.
     *
     * @param connection the connection to operate on
     * @param codec the codec for command encoding
     */
    public AbstractRedisAsyncCommands(StatefulConnection connection, RedisCodec codec, Mono parser) {
        this.parser = parser;
        this.connection = connection;
        this.commandBuilder = new RedisCommandBuilder<>(codec);
        this.jsonCommandBuilder = new RedisJsonCommandBuilder<>(codec, parser);
    }

    @Override
    public RedisFuture> aclCat() {
        return dispatch(commandBuilder.aclCat());
    }

    @Override
    public RedisFuture> aclCat(AclCategory category) {
        return dispatch(commandBuilder.aclCat(category));
    }

    @Override
    public RedisFuture aclDeluser(String... usernames) {
        return dispatch(commandBuilder.aclDeluser(usernames));
    }

    @Override
    public RedisFuture aclDryRun(String username, String command, String... args) {
        return dispatch(commandBuilder.aclDryRun(username, command, args));
    }

    @Override
    public RedisFuture aclDryRun(String username, RedisCommand command) {
        return dispatch(commandBuilder.aclDryRun(username, command));
    }

    @Override
    public RedisFuture aclGenpass() {
        return dispatch(commandBuilder.aclGenpass());
    }

    @Override
    public RedisFuture aclGenpass(int bits) {
        return dispatch(commandBuilder.aclGenpass(bits));
    }

    @Override
    public RedisFuture> aclGetuser(String username) {
        return dispatch(commandBuilder.aclGetuser(username));
    }

    @Override
    public RedisFuture> aclList() {
        return dispatch(commandBuilder.aclList());
    }

    @Override
    public RedisFuture aclLoad() {
        return dispatch(commandBuilder.aclLoad());
    }

    @Override
    public RedisFuture>> aclLog() {
        return dispatch(commandBuilder.aclLog());
    }

    @Override
    public RedisFuture>> aclLog(int count) {
        return dispatch(commandBuilder.aclLog(count));
    }

    @Override
    public RedisFuture aclLogReset() {
        return dispatch(commandBuilder.aclLogReset());
    }

    @Override
    public RedisFuture aclSave() {
        return dispatch(commandBuilder.aclSave());
    }

    @Override
    public RedisFuture aclSetuser(String username, AclSetuserArgs args) {
        return dispatch(commandBuilder.aclSetuser(username, args));
    }

    @Override
    public RedisFuture> aclUsers() {
        return dispatch(commandBuilder.aclUsers());
    }

    @Override
    public RedisFuture aclWhoami() {
        return dispatch(commandBuilder.aclWhoami());
    }

    @Override
    public RedisFuture append(K key, V value) {
        return dispatch(commandBuilder.append(key, value));
    }

    @Override
    public RedisFuture asking() {
        return dispatch(commandBuilder.asking());
    }

    @Override
    public RedisFuture auth(CharSequence password) {

        LettuceAssert.notNull(password, "Password must not be null");
        return dispatch(commandBuilder.auth(password));
    }

    public RedisFuture auth(char[] password) {

        LettuceAssert.notNull(password, "Password must not be null");
        return dispatch(commandBuilder.auth(password));
    }

    @Override
    public RedisFuture auth(String username, CharSequence password) {
        LettuceAssert.notNull(username, "Username must not be null");
        LettuceAssert.notNull(password, "Password must not be null");
        return dispatch(commandBuilder.auth(username, password));
    }

    public RedisFuture auth(String username, char[] password) {
        LettuceAssert.notNull(username, "Username must not be null");
        LettuceAssert.notNull(password, "Password must not be null");
        return dispatch(commandBuilder.auth(username, password));
    }

    @Override
    public RedisFuture bgrewriteaof() {
        return dispatch(commandBuilder.bgrewriteaof());
    }

    @Override
    public RedisFuture bgsave() {
        return dispatch(commandBuilder.bgsave());
    }

    @Override
    public RedisFuture bitcount(K key) {
        return dispatch(commandBuilder.bitcount(key));
    }

    @Override
    public RedisFuture bitcount(K key, long start, long end) {
        return dispatch(commandBuilder.bitcount(key, start, end));
    }

    @Override
    public RedisFuture> bitfield(K key, BitFieldArgs bitFieldArgs) {
        return dispatch(commandBuilder.bitfield(key, bitFieldArgs));
    }

    @Override
    public RedisFuture bitopAnd(K destination, K... keys) {
        return dispatch(commandBuilder.bitopAnd(destination, keys));
    }

    @Override
    public RedisFuture bitopNot(K destination, K source) {
        return dispatch(commandBuilder.bitopNot(destination, source));
    }

    @Override
    public RedisFuture bitopOr(K destination, K... keys) {
        return dispatch(commandBuilder.bitopOr(destination, keys));
    }

    @Override
    public RedisFuture bitopXor(K destination, K... keys) {
        return dispatch(commandBuilder.bitopXor(destination, keys));
    }

    @Override
    public RedisFuture bitpos(K key, boolean state) {
        return dispatch(commandBuilder.bitpos(key, state));
    }

    @Override
    public RedisFuture bitpos(K key, boolean state, long start) {
        return dispatch(commandBuilder.bitpos(key, state, start));
    }

    @Override
    public RedisFuture bitpos(K key, boolean state, long start, long end) {
        return dispatch(commandBuilder.bitpos(key, state, start, end));
    }

    @Override
    public RedisFuture blmove(K source, K destination, LMoveArgs args, long timeout) {
        return dispatch(commandBuilder.blmove(source, destination, args, timeout));
    }

    @Override
    public RedisFuture blmove(K source, K destination, LMoveArgs args, double timeout) {
        return dispatch(commandBuilder.blmove(source, destination, args, timeout));
    }

    @Override
    public RedisFuture>> blmpop(long timeout, LMPopArgs args, K... keys) {
        return dispatch(commandBuilder.blmpop(timeout, args, keys));
    }

    @Override
    public RedisFuture>> blmpop(double timeout, LMPopArgs args, K... keys) {
        return dispatch(commandBuilder.blmpop(timeout, args, keys));
    }

    @Override
    public RedisFuture> blpop(long timeout, K... keys) {
        return dispatch(commandBuilder.blpop(timeout, keys));
    }

    @Override
    public RedisFuture> blpop(double timeout, K... keys) {
        return dispatch(commandBuilder.blpop(timeout, keys));
    }

    @Override
    public RedisFuture> brpop(long timeout, K... keys) {
        return dispatch(commandBuilder.brpop(timeout, keys));
    }

    @Override
    public RedisFuture> brpop(double timeout, K... keys) {
        return dispatch(commandBuilder.brpop(timeout, keys));
    }

    @Override
    public RedisFuture brpoplpush(long timeout, K source, K destination) {
        return dispatch(commandBuilder.brpoplpush(timeout, source, destination));
    }

    @Override
    public RedisFuture brpoplpush(double timeout, K source, K destination) {
        return dispatch(commandBuilder.brpoplpush(timeout, source, destination));
    }

    @Override
    public RedisFuture clientCaching(boolean enabled) {
        return dispatch(commandBuilder.clientCaching(enabled));
    }

    @Override
    public RedisFuture clientGetname() {
        return dispatch(commandBuilder.clientGetname());
    }

    @Override
    public RedisFuture clientGetredir() {
        return dispatch(commandBuilder.clientGetredir());
    }

    @Override
    public RedisFuture clientKill(String addr) {
        return dispatch(commandBuilder.clientKill(addr));
    }

    @Override
    public RedisFuture clientKill(KillArgs killArgs) {
        return dispatch(commandBuilder.clientKill(killArgs));
    }

    @Override
    public RedisFuture clientList() {
        return dispatch(commandBuilder.clientList());
    }

    @Override
    public RedisFuture clientList(ClientListArgs clientListArgs) {
        return dispatch(commandBuilder.clientList(clientListArgs));
    }

    @Override
    public RedisFuture clientInfo() {
        return dispatch(commandBuilder.clientInfo());
    }

    @Override
    public RedisFuture clientNoEvict(boolean on) {
        return dispatch(commandBuilder.clientNoEvict(on));
    }

    @Override
    public RedisFuture clientId() {
        return dispatch(commandBuilder.clientId());
    }

    @Override
    public RedisFuture clientPause(long timeout) {
        return dispatch(commandBuilder.clientPause(timeout));
    }

    @Override
    public RedisFuture clientSetname(K name) {
        return dispatch(commandBuilder.clientSetname(name));
    }

    @Override
    public RedisFuture clientSetinfo(String key, String value) {
        return dispatch(commandBuilder.clientSetinfo(key, value));
    }

    @Override
    public RedisFuture clientTracking(TrackingArgs args) {
        return dispatch(commandBuilder.clientTracking(args));
    }

    @Override
    public RedisFuture clientTrackinginfo() {
        return dispatch(commandBuilder.clientTrackinginfo());
    }

    @Override
    public RedisFuture clientUnblock(long id, UnblockType type) {
        return dispatch(commandBuilder.clientUnblock(id, type));
    }

    @Override
    public RedisFuture clusterAddSlots(int... slots) {
        return dispatch(commandBuilder.clusterAddslots(slots));
    }

    @Override
    public RedisFuture clusterAddSlotsRange(Range... ranges) {
        return dispatch(commandBuilder.clusterAddSlotsRange(ranges));
    }

    @Override
    public RedisFuture clusterBumpepoch() {
        return dispatch(commandBuilder.clusterBumpepoch());
    }

    @Override
    public RedisFuture clusterCountFailureReports(String nodeId) {
        return dispatch(commandBuilder.clusterCountFailureReports(nodeId));
    }

    @Override
    public RedisFuture clusterCountKeysInSlot(int slot) {
        return dispatch(commandBuilder.clusterCountKeysInSlot(slot));
    }

    @Override
    public RedisFuture clusterDelSlots(int... slots) {
        return dispatch(commandBuilder.clusterDelslots(slots));
    }

    @Override
    public RedisFuture clusterDelSlotsRange(Range... ranges) {
        return dispatch(commandBuilder.clusterDelSlotsRange(ranges));
    }

    @Override
    public RedisFuture clusterFailover(boolean force) {
        return dispatch(commandBuilder.clusterFailover(force));
    }

    @Override
    public RedisFuture clusterFailover(boolean force, boolean takeOver) {
        return dispatch(commandBuilder.clusterFailover(force, takeOver));
    }

    @Override
    public RedisFuture clusterFlushslots() {
        return dispatch(commandBuilder.clusterFlushslots());
    }

    @Override
    public RedisFuture clusterForget(String nodeId) {
        return dispatch(commandBuilder.clusterForget(nodeId));
    }

    @Override
    public RedisFuture> clusterGetKeysInSlot(int slot, int count) {
        return dispatch(commandBuilder.clusterGetKeysInSlot(slot, count));
    }

    @Override
    public RedisFuture clusterInfo() {
        return dispatch(commandBuilder.clusterInfo());
    }

    @Override
    public RedisFuture clusterKeyslot(K key) {
        return dispatch(commandBuilder.clusterKeyslot(key));
    }

    @Override
    public RedisFuture clusterMeet(String ip, int port) {
        return dispatch(commandBuilder.clusterMeet(ip, port));
    }

    @Override
    public RedisFuture clusterMyId() {
        return dispatch(commandBuilder.clusterMyId());
    }

    @Override
    public RedisFuture clusterMyShardId() {
        return dispatch(commandBuilder.clusterMyShardId());
    }

    @Override
    public RedisFuture clusterNodes() {
        return dispatch(commandBuilder.clusterNodes());
    }

    @Override
    public RedisFuture clusterReplicate(String nodeId) {
        return dispatch(commandBuilder.clusterReplicate(nodeId));
    }

    @Override
    public RedisFuture> clusterReplicas(String nodeId) {
        return dispatch(commandBuilder.clusterReplicas(nodeId));
    }

    @Override
    public RedisFuture clusterReset(boolean hard) {
        return dispatch(commandBuilder.clusterReset(hard));
    }

    @Override
    public RedisFuture clusterSaveconfig() {
        return dispatch(commandBuilder.clusterSaveconfig());
    }

    @Override
    public RedisFuture clusterSetConfigEpoch(long configEpoch) {
        return dispatch(commandBuilder.clusterSetConfigEpoch(configEpoch));
    }

    @Override
    public RedisFuture clusterSetSlotImporting(int slot, String nodeId) {
        return dispatch(commandBuilder.clusterSetSlotImporting(slot, nodeId));
    }

    @Override
    public RedisFuture clusterSetSlotMigrating(int slot, String nodeId) {
        return dispatch(commandBuilder.clusterSetSlotMigrating(slot, nodeId));
    }

    @Override
    public RedisFuture clusterSetSlotNode(int slot, String nodeId) {
        return dispatch(commandBuilder.clusterSetSlotNode(slot, nodeId));
    }

    @Override
    public RedisFuture clusterSetSlotStable(int slot) {
        return dispatch(commandBuilder.clusterSetSlotStable(slot));
    }

    @Override
    public RedisFuture> clusterShards() {
        return dispatch(commandBuilder.clusterShards());
    }

    @Override
    public RedisFuture> clusterSlaves(String nodeId) {
        return dispatch(commandBuilder.clusterSlaves(nodeId));
    }

    @Override
    public RedisFuture> clusterSlots() {
        return dispatch(commandBuilder.clusterSlots());
    }

    @Override
    public RedisFuture> command() {
        return dispatch(commandBuilder.command());
    }

    @Override
    public RedisFuture commandCount() {
        return dispatch(commandBuilder.commandCount());
    }

    @Override
    public RedisFuture> commandInfo(String... commands) {
        return dispatch(commandBuilder.commandInfo(commands));
    }

    @Override
    public RedisFuture> commandInfo(CommandType... commands) {
        String[] stringCommands = new String[commands.length];
        for (int i = 0; i < commands.length; i++) {
            stringCommands[i] = commands[i].name();
        }

        return commandInfo(stringCommands);
    }

    @Override
    public RedisFuture> configGet(String parameter) {
        return dispatch(commandBuilder.configGet(parameter));
    }

    @Override
    public RedisFuture> configGet(String... parameters) {
        return dispatch(commandBuilder.configGet(parameters));
    }

    @Override
    public RedisFuture configResetstat() {
        return dispatch(commandBuilder.configResetstat());
    }

    @Override
    public RedisFuture configRewrite() {
        return dispatch(commandBuilder.configRewrite());
    }

    @Override
    public RedisFuture configSet(String parameter, String value) {
        return dispatch(commandBuilder.configSet(parameter, value));
    }

    @Override
    public RedisFuture configSet(Map kvs) {
        return dispatch(commandBuilder.configSet(kvs));
    }

    @Override
    public RedisFuture dbsize() {
        return dispatch(commandBuilder.dbsize());
    }

    @Override
    public RedisFuture debugCrashAndRecover(Long delay) {
        return dispatch(commandBuilder.debugCrashAndRecover(delay));
    }

    @Override
    public RedisFuture debugHtstats(int db) {
        return dispatch(commandBuilder.debugHtstats(db));
    }

    @Override
    public RedisFuture debugObject(K key) {
        return dispatch(commandBuilder.debugObject(key));
    }

    @Override
    public void debugOom() {
        dispatch(commandBuilder.debugOom());
    }

    @Override
    public RedisFuture debugReload() {
        return dispatch(commandBuilder.debugReload());
    }

    @Override
    public RedisFuture debugRestart(Long delay) {
        return dispatch(commandBuilder.debugRestart(delay));
    }

    @Override
    public RedisFuture debugSdslen(K key) {
        return dispatch(commandBuilder.debugSdslen(key));
    }

    @Override
    public void debugSegfault() {
        dispatch(commandBuilder.debugSegfault());
    }

    @Override
    public RedisFuture decr(K key) {
        return dispatch(commandBuilder.decr(key));
    }

    @Override
    public RedisFuture decrby(K key, long amount) {
        return dispatch(commandBuilder.decrby(key, amount));
    }

    @Override
    public RedisFuture del(K... keys) {
        return dispatch(commandBuilder.del(keys));
    }

    public RedisFuture del(Iterable keys) {
        return dispatch(commandBuilder.del(keys));
    }

    @Override
    public String digest(String script) {
        return digest(encodeScript(script));
    }

    @Override
    public String digest(byte[] script) {
        return Base16.digest(script);
    }

    @Override
    public RedisFuture discard() {
        return dispatch(commandBuilder.discard());
    }

    @Override
    public  RedisFuture dispatch(ProtocolKeyword type, CommandOutput output) {

        LettuceAssert.notNull(type, "Command type must not be null");
        LettuceAssert.notNull(output, "CommandOutput type must not be null");

        return dispatch(new AsyncCommand<>(new Command<>(type, output)));
    }

    @Override
    public  RedisFuture dispatch(ProtocolKeyword type, CommandOutput output, CommandArgs args) {

        LettuceAssert.notNull(type, "Command type must not be null");
        LettuceAssert.notNull(output, "CommandOutput type must not be null");
        LettuceAssert.notNull(args, "CommandArgs type must not be null");

        return dispatch(new AsyncCommand<>(new Command<>(type, output, args)));
    }

    protected  RedisFuture dispatch(CommandType type, CommandOutput output) {
        return dispatch(type, output, null);
    }

    protected  RedisFuture dispatch(CommandType type, CommandOutput output, CommandArgs args) {
        return dispatch(new AsyncCommand<>(new Command<>(type, output, args)));
    }

    public  AsyncCommand dispatch(RedisCommand cmd) {
        AsyncCommand asyncCommand = new AsyncCommand<>(cmd);
        RedisCommand dispatched = connection.dispatch(asyncCommand);
        if (dispatched instanceof AsyncCommand) {
            return (AsyncCommand) dispatched;
        }
        return asyncCommand;
    }

    @Override
    public RedisFuture dump(K key) {
        return dispatch(commandBuilder.dump(key));
    }

    @Override
    public RedisFuture echo(V msg) {
        return dispatch(commandBuilder.echo(msg));
    }

    @Override
    @SuppressWarnings("unchecked")
    public  RedisFuture eval(String script, ScriptOutputType type, K... keys) {
        return eval(encodeScript(script), type, keys);
    }

    @Override
    public  RedisFuture eval(byte[] script, ScriptOutputType type, K... keys) {
        return (RedisFuture) dispatch(commandBuilder.eval(script, type, keys));
    }

    @Override
    @SuppressWarnings("unchecked")
    public  RedisFuture eval(String script, ScriptOutputType type, K[] keys, V... values) {
        return eval(encodeScript(script), type, keys, values);
    }

    @Override
    public  RedisFuture eval(byte[] script, ScriptOutputType type, K[] keys, V... values) {
        return (RedisFuture) dispatch(commandBuilder.eval(script, type, keys, values));
    }

    @Override
    @SuppressWarnings("unchecked")
    public  RedisFuture evalReadOnly(String script, ScriptOutputType type, K[] keys, V... values) {
        return evalReadOnly(encodeScript(script), type, keys, values);
    }

    @Override
    public  RedisFuture evalReadOnly(byte[] script, ScriptOutputType type, K[] keys, V... values) {
        return (RedisFuture) dispatch(commandBuilder.eval(script, type, true, keys, values));
    }

    @Override
    @SuppressWarnings("unchecked")
    public  RedisFuture evalsha(String digest, ScriptOutputType type, K... keys) {
        return (RedisFuture) dispatch(commandBuilder.evalsha(digest, type, keys));
    }

    @Override
    @SuppressWarnings("unchecked")
    public  RedisFuture evalsha(String digest, ScriptOutputType type, K[] keys, V... values) {
        return (RedisFuture) dispatch(commandBuilder.evalsha(digest, type, keys, values));
    }

    @Override
    public  RedisFuture evalshaReadOnly(String digest, ScriptOutputType type, K[] keys, V... values) {
        return dispatch(commandBuilder.evalsha(digest, type, true, keys, values));
    }

    @Override
    public RedisFuture exec() {
        return dispatch(EXEC, null);
    }

    @Override
    public RedisFuture exists(K... keys) {
        return dispatch(commandBuilder.exists(keys));
    }

    public RedisFuture exists(Iterable keys) {
        return dispatch(commandBuilder.exists(keys));
    }

    @Override
    public RedisFuture expire(K key, long seconds) {
        return expire(key, seconds, null);
    }

    @Override
    public RedisFuture expire(K key, long seconds, ExpireArgs expireArgs) {
        return dispatch(commandBuilder.expire(key, seconds, expireArgs));
    }

    @Override
    public RedisFuture expire(K key, Duration seconds) {
        return expire(key, seconds, null);
    }

    @Override
    public RedisFuture expire(K key, Duration seconds, ExpireArgs expireArgs) {
        LettuceAssert.notNull(seconds, "Timeout must not be null");
        return expire(key, seconds.toMillis() / 1000, expireArgs);
    }

    @Override
    public RedisFuture> hexpire(K key, long seconds, K... fields) {
        return hexpire(key, seconds, null, fields);
    }

    @Override
    public RedisFuture> hexpire(K key, long seconds, ExpireArgs expireArgs, K... fields) {
        return dispatch(commandBuilder.hexpire(key, seconds, expireArgs, fields));
    }

    @Override
    public RedisFuture> hexpire(K key, Duration seconds, K... fields) {
        return hexpire(key, seconds, null, fields);
    }

    @Override
    public RedisFuture> hexpire(K key, Duration seconds, ExpireArgs expireArgs, K... fields) {
        LettuceAssert.notNull(seconds, "Timeout must not be null");
        return hexpire(key, seconds.toMillis() / 1000, expireArgs, fields);
    }

    @Override
    public RedisFuture> httl(K key, K... fields) {
        return dispatch(commandBuilder.httl(key, fields));
    }

    @Override
    public RedisFuture> hpexpire(K key, long milliseconds, K... fields) {
        return hpexpire(key, milliseconds, null, fields);
    }

    @Override
    public RedisFuture> hpexpire(K key, long milliseconds, ExpireArgs expireArgs, K... fields) {
        return dispatch(commandBuilder.hpexpire(key, milliseconds, expireArgs, fields));
    }

    @Override
    public RedisFuture> hpexpire(K key, Duration milliseconds, K... fields) {
        return hpexpire(key, milliseconds, null, fields);
    }

    @Override
    public RedisFuture> hpexpire(K key, Duration milliseconds, ExpireArgs expireArgs, K... fields) {
        LettuceAssert.notNull(milliseconds, "Timeout must not be null");
        return hpexpire(key, milliseconds.toMillis(), expireArgs, fields);
    }

    @Override
    public RedisFuture> hpexpireat(K key, Date timestamp, K... fields) {
        return hpexpireat(key, timestamp, null, fields);
    }

    @Override
    public RedisFuture> hpexpireat(K key, Date timestamp, ExpireArgs expireArgs, K... fields) {
        LettuceAssert.notNull(timestamp, "Timestamp must not be null");
        return hpexpireat(key, timestamp.getTime(), expireArgs, fields);
    }

    @Override
    public RedisFuture> hpexpireat(K key, Instant timestamp, K... fields) {
        return hpexpireat(key, timestamp, null, fields);
    }

    @Override
    public RedisFuture> hpexpireat(K key, Instant timestamp, ExpireArgs expireArgs, K... fields) {
        LettuceAssert.notNull(timestamp, "Timestamp must not be null");
        return hpexpireat(key, timestamp.toEpochMilli(), expireArgs, fields);
    }

    @Override
    public RedisFuture> hpexpireat(K key, long timestamp, K... fields) {
        return hpexpireat(key, timestamp, null, fields);
    }

    @Override
    public RedisFuture> hpexpireat(K key, long timestamp, ExpireArgs expireArgs, K... fields) {
        return dispatch(commandBuilder.hpexpireat(key, timestamp, expireArgs, fields));
    }

    @Override
    public RedisFuture> hpexpiretime(K key, K... fields) {
        return dispatch(commandBuilder.hpexpiretime(key, fields));
    }

    @Override
    public RedisFuture> hpttl(K key, K... fields) {
        return dispatch(commandBuilder.hpttl(key, fields));
    }

    @Override
    public RedisFuture expireat(K key, long timestamp) {
        return expireat(key, timestamp, null);
    }

    @Override
    public RedisFuture expireat(K key, long timestamp, ExpireArgs expireArgs) {
        return dispatch(commandBuilder.expireat(key, timestamp, expireArgs));
    }

    @Override
    public RedisFuture expireat(K key, Date timestamp) {
        return expireat(key, timestamp, null);
    }

    @Override
    public RedisFuture expireat(K key, Date timestamp, ExpireArgs expireArgs) {
        LettuceAssert.notNull(timestamp, "Timestamp must not be null");
        return expireat(key, timestamp.getTime() / 1000, expireArgs);
    }

    @Override
    public RedisFuture expireat(K key, Instant timestamp) {
        return expireat(key, timestamp, null);
    }

    @Override
    public RedisFuture expireat(K key, Instant timestamp, ExpireArgs expireArgs) {
        LettuceAssert.notNull(timestamp, "Timestamp must not be null");
        return expireat(key, timestamp.toEpochMilli() / 1000, expireArgs);
    }

    @Override
    public RedisFuture> hexpireat(K key, long timestamp, K... fields) {
        return hexpireat(key, timestamp, null, fields);
    }

    @Override
    public RedisFuture> hexpireat(K key, long timestamp, ExpireArgs expireArgs, K... fields) {
        return dispatch(commandBuilder.hexpireat(key, timestamp, expireArgs, fields));

    }

    @Override
    public RedisFuture> hexpireat(K key, Date timestamp, K... fields) {
        return hexpireat(key, timestamp, null, fields);
    }

    @Override
    public RedisFuture> hexpireat(K key, Date timestamp, ExpireArgs expireArgs, K... fields) {
        LettuceAssert.notNull(timestamp, "Timestamp must not be null");
        return hexpireat(key, timestamp.getTime() / 1000, expireArgs, fields);
    }

    @Override
    public RedisFuture> hexpireat(K key, Instant timestamp, K... fields) {
        return hexpireat(key, timestamp, null, fields);
    }

    @Override
    public RedisFuture> hexpireat(K key, Instant timestamp, ExpireArgs expireArgs, K... fields) {
        LettuceAssert.notNull(timestamp, "Timestamp must not be null");
        return hexpireat(key, timestamp.toEpochMilli() / 1000, expireArgs, fields);
    }

    @Override
    public RedisFuture expiretime(K key) {
        return dispatch(commandBuilder.expiretime(key));
    }

    @Override
    public RedisFuture> hexpiretime(K key, K... fields) {
        return dispatch(commandBuilder.hexpiretime(key, fields));
    }

    @Override
    public  RedisFuture fcall(String function, ScriptOutputType type, K... keys) {
        return dispatch(commandBuilder.fcall(function, type, false, keys));
    }

    @Override
    public  RedisFuture fcall(String function, ScriptOutputType type, K[] keys, V... values) {
        return dispatch(commandBuilder.fcall(function, type, false, keys, values));
    }

    @Override
    public  RedisFuture fcallReadOnly(String function, ScriptOutputType type, K... keys) {
        return dispatch(commandBuilder.fcall(function, type, true, keys));
    }

    @Override
    public  RedisFuture fcallReadOnly(String function, ScriptOutputType type, K[] keys, V... values) {
        return dispatch(commandBuilder.fcall(function, type, true, keys, values));
    }

    @Override
    public RedisFuture functionLoad(String functionCode) {
        return functionLoad(functionCode, false);
    }

    @Override
    public RedisFuture functionLoad(String functionCode, boolean replace) {
        return dispatch(commandBuilder.functionLoad(encodeFunction(functionCode), replace));
    }

    @Override
    public RedisFuture functionDump() {
        return dispatch(commandBuilder.functionDump());
    }

    @Override
    public RedisFuture functionRestore(byte[] dump) {
        return functionRestore(dump, null);
    }

    @Override
    public RedisFuture functionRestore(byte[] dump, FunctionRestoreMode mode) {
        return dispatch(commandBuilder.functionRestore(dump, mode));
    }

    @Override
    public RedisFuture functionFlush(FlushMode flushMode) {
        return dispatch(commandBuilder.functionFlush(flushMode));
    }

    @Override
    public RedisFuture functionKill() {
        return dispatch(commandBuilder.functionKill());
    }

    @Override
    public RedisFuture>> functionList() {
        return functionList(null);
    }

    @Override
    public RedisFuture>> functionList(String libraryName) {
        return dispatch(commandBuilder.functionList(libraryName));
    }

    @Override
    public void flushCommands() {
        connection.flushCommands();
    }

    @Override
    public RedisFuture flushall() {
        return dispatch(commandBuilder.flushall());
    }

    @Override
    public RedisFuture flushall(FlushMode flushMode) {
        return dispatch(commandBuilder.flushall(flushMode));
    }

    @Override
    public RedisFuture flushallAsync() {
        return flushall(FlushMode.ASYNC);
    }

    @Override
    public RedisFuture flushdb() {
        return dispatch(commandBuilder.flushdb());
    }

    @Override
    public RedisFuture flushdb(FlushMode flushMode) {
        return dispatch(commandBuilder.flushdb(flushMode));
    }

    @Override
    public RedisFuture flushdbAsync() {
        return flushdb(FlushMode.ASYNC);
    }

    @Override
    public RedisFuture geoadd(K key, double longitude, double latitude, V member) {
        return geoadd(key, longitude, latitude, member, null);
    }

    @Override
    public RedisFuture geoadd(K key, double longitude, double latitude, V member, GeoAddArgs args) {
        return dispatch(commandBuilder.geoadd(key, longitude, latitude, member, args));
    }

    @Override
    public RedisFuture geoadd(K key, Object... lngLatMember) {
        return geoadd(key, null, lngLatMember);
    }

    @Override
    public RedisFuture geoadd(K key, GeoValue... values) {
        return dispatch(commandBuilder.geoadd(key, values, null));
    }

    @Override
    public RedisFuture geoadd(K key, GeoAddArgs args, Object... lngLatMember) {
        return dispatch(commandBuilder.geoadd(key, lngLatMember, args));
    }

    @Override
    public RedisFuture geoadd(K key, GeoAddArgs args, GeoValue... values) {
        return dispatch(commandBuilder.geoadd(key, values, args));
    }

    @Override
    public RedisFuture geodist(K key, V from, V to, GeoArgs.Unit unit) {
        return dispatch(commandBuilder.geodist(key, from, to, unit));
    }

    @Override
    public RedisFuture>> geohash(K key, V... members) {
        return dispatch(commandBuilder.geohash(key, members));
    }

    @Override
    public RedisFuture> geopos(K key, V... members) {
        return dispatch(commandBuilder.geopos(key, members));
    }

    @Override
    public RedisFuture> georadius(K key, double longitude, double latitude, double distance, GeoArgs.Unit unit) {
        return georadius_ro(key, longitude, latitude, distance, unit);
    }

    @Override
    public RedisFuture>> georadius(K key, double longitude, double latitude, double distance,
            GeoArgs.Unit unit, GeoArgs geoArgs) {
        return georadius_ro(key, longitude, latitude, distance, unit, geoArgs);
    }

    @Override
    public RedisFuture georadius(K key, double longitude, double latitude, double distance, Unit unit,
            GeoRadiusStoreArgs geoRadiusStoreArgs) {
        return dispatch(commandBuilder.georadius(key, longitude, latitude, distance, unit.name(), geoRadiusStoreArgs));
    }

    protected RedisFuture> georadius_ro(K key, double longitude, double latitude, double distance, GeoArgs.Unit unit) {
        return dispatch(commandBuilder.georadius(GEORADIUS_RO, key, longitude, latitude, distance, unit.name()));
    }

    protected RedisFuture>> georadius_ro(K key, double longitude, double latitude, double distance,
            GeoArgs.Unit unit, GeoArgs geoArgs) {
        return dispatch(commandBuilder.georadius(GEORADIUS_RO, key, longitude, latitude, distance, unit.name(), geoArgs));
    }

    @Override
    public RedisFuture> georadiusbymember(K key, V member, double distance, GeoArgs.Unit unit) {
        return georadiusbymember_ro(key, member, distance, unit);
    }

    @Override
    public RedisFuture>> georadiusbymember(K key, V member, double distance, GeoArgs.Unit unit,
            GeoArgs geoArgs) {
        return georadiusbymember_ro(key, member, distance, unit, geoArgs);
    }

    @Override
    public RedisFuture georadiusbymember(K key, V member, double distance, Unit unit,
            GeoRadiusStoreArgs geoRadiusStoreArgs) {
        return dispatch(commandBuilder.georadiusbymember(key, member, distance, unit.name(), geoRadiusStoreArgs));
    }

    protected RedisFuture> georadiusbymember_ro(K key, V member, double distance, GeoArgs.Unit unit) {
        return dispatch(commandBuilder.georadiusbymember(GEORADIUSBYMEMBER_RO, key, member, distance, unit.name()));
    }

    protected RedisFuture>> georadiusbymember_ro(K key, V member, double distance, GeoArgs.Unit unit,
            GeoArgs geoArgs) {
        return dispatch(commandBuilder.georadiusbymember(GEORADIUSBYMEMBER_RO, key, member, distance, unit.name(), geoArgs));
    }

    @Override
    public RedisFuture> geosearch(K key, GeoSearch.GeoRef reference, GeoSearch.GeoPredicate predicate) {
        return dispatch(commandBuilder.geosearch(key, reference, predicate));
    }

    @Override
    public RedisFuture>> geosearch(K key, GeoSearch.GeoRef reference, GeoSearch.GeoPredicate predicate,
            GeoArgs geoArgs) {
        return dispatch(commandBuilder.geosearch(key, reference, predicate, geoArgs));
    }

    @Override
    public RedisFuture geosearchstore(K destination, K key, GeoSearch.GeoRef reference,
            GeoSearch.GeoPredicate predicate, GeoArgs geoArgs, boolean storeDist) {
        return dispatch(commandBuilder.geosearchstore(destination, key, reference, predicate, geoArgs, storeDist));
    }

    @Override
    public RedisFuture get(K key) {
        return dispatch(commandBuilder.get(key));
    }

    public StatefulConnection getConnection() {
        return connection;
    }

    @Override
    public RedisFuture getbit(K key, long offset) {
        return dispatch(commandBuilder.getbit(key, offset));
    }

    @Override
    public RedisFuture getdel(K key) {
        return dispatch(commandBuilder.getdel(key));
    }

    @Override
    public RedisFuture getex(K key, GetExArgs args) {
        return dispatch(commandBuilder.getex(key, args));
    }

    @Override
    public RedisFuture getrange(K key, long start, long end) {
        return dispatch(commandBuilder.getrange(key, start, end));
    }

    @Override
    public RedisFuture getset(K key, V value) {
        return dispatch(commandBuilder.getset(key, value));
    }

    @Override
    public RedisFuture hdel(K key, K... fields) {
        return dispatch(commandBuilder.hdel(key, fields));
    }

    @Override
    public RedisFuture hexists(K key, K field) {
        return dispatch(commandBuilder.hexists(key, field));
    }

    @Override
    public RedisFuture hget(K key, K field) {
        return dispatch(commandBuilder.hget(key, field));
    }

    @Override
    public RedisFuture> hgetall(K key) {
        return dispatch(commandBuilder.hgetall(key));
    }

    @Override
    public RedisFuture hgetall(KeyValueStreamingChannel channel, K key) {
        return dispatch(commandBuilder.hgetall(channel, key));
    }

    @Override
    public RedisFuture hincrby(K key, K field, long amount) {
        return dispatch(commandBuilder.hincrby(key, field, amount));
    }

    @Override
    public RedisFuture hincrbyfloat(K key, K field, double amount) {
        return dispatch(commandBuilder.hincrbyfloat(key, field, amount));
    }

    @Override
    public RedisFuture> hkeys(K key) {
        return dispatch(commandBuilder.hkeys(key));
    }

    @Override
    public RedisFuture hkeys(KeyStreamingChannel channel, K key) {
        return dispatch(commandBuilder.hkeys(channel, key));
    }

    @Override
    public RedisFuture hlen(K key) {
        return dispatch(commandBuilder.hlen(key));
    }

    @Override
    public RedisFuture>> hmget(K key, K... fields) {
        return dispatch(commandBuilder.hmgetKeyValue(key, fields));
    }

    @Override
    public RedisFuture hmget(KeyValueStreamingChannel channel, K key, K... fields) {
        return dispatch(commandBuilder.hmget(channel, key, fields));
    }

    @Override
    public RedisFuture hmset(K key, Map map) {
        return dispatch(commandBuilder.hmset(key, map));
    }

    @Override
    public RedisFuture hrandfield(K key) {
        return dispatch(commandBuilder.hrandfield(key));
    }

    @Override
    public RedisFuture> hrandfield(K key, long count) {
        return dispatch(commandBuilder.hrandfield(key, count));
    }

    @Override
    public RedisFuture> hrandfieldWithvalues(K key) {
        return dispatch(commandBuilder.hrandfieldWithvalues(key));
    }

    @Override
    public RedisFuture>> hrandfieldWithvalues(K key, long count) {
        return dispatch(commandBuilder.hrandfieldWithvalues(key, count));
    }

    @Override
    public RedisFuture> hscan(K key) {
        return dispatch(commandBuilder.hscan(key));
    }

    @Override
    public RedisFuture> hscanNovalues(K key) {
        return dispatch(commandBuilder.hscanNovalues(key));
    }

    @Override
    public RedisFuture> hscan(K key, ScanArgs scanArgs) {
        return dispatch(commandBuilder.hscan(key, scanArgs));
    }

    @Override
    public RedisFuture> hscanNovalues(K key, ScanArgs scanArgs) {
        return dispatch(commandBuilder.hscanNovalues(key, scanArgs));
    }

    @Override
    public RedisFuture> hscan(K key, ScanCursor scanCursor, ScanArgs scanArgs) {
        return dispatch(commandBuilder.hscan(key, scanCursor, scanArgs));
    }

    @Override
    public RedisFuture> hscanNovalues(K key, ScanCursor scanCursor, ScanArgs scanArgs) {
        return dispatch(commandBuilder.hscanNovalues(key, scanCursor, scanArgs));
    }

    @Override
    public RedisFuture> hscan(K key, ScanCursor scanCursor) {
        return dispatch(commandBuilder.hscan(key, scanCursor));
    }

    @Override
    public RedisFuture> hscanNovalues(K key, ScanCursor scanCursor) {
        return dispatch(commandBuilder.hscanNovalues(key, scanCursor));
    }

    @Override
    public RedisFuture hscan(KeyValueStreamingChannel channel, K key) {
        return dispatch(commandBuilder.hscanStreaming(channel, key));
    }

    @Override
    public RedisFuture hscanNovalues(KeyStreamingChannel channel, K key) {
        return dispatch(commandBuilder.hscanNoValuesStreaming(channel, key));
    }

    @Override
    public RedisFuture hscan(KeyValueStreamingChannel channel, K key, ScanArgs scanArgs) {
        return dispatch(commandBuilder.hscanStreaming(channel, key, scanArgs));
    }

    @Override
    public RedisFuture hscanNovalues(KeyStreamingChannel channel, K key, ScanArgs scanArgs) {
        return dispatch(commandBuilder.hscanNoValuesStreaming(channel, key, scanArgs));
    }

    @Override
    public RedisFuture hscan(KeyValueStreamingChannel channel, K key, ScanCursor scanCursor,
            ScanArgs scanArgs) {
        return dispatch(commandBuilder.hscanStreaming(channel, key, scanCursor, scanArgs));
    }

    @Override
    public RedisFuture hscanNovalues(KeyStreamingChannel channel, K key, ScanCursor scanCursor,
            ScanArgs scanArgs) {
        return dispatch(commandBuilder.hscanNoValuesStreaming(channel, key, scanCursor, scanArgs));
    }

    @Override
    public RedisFuture hscan(KeyValueStreamingChannel channel, K key, ScanCursor scanCursor) {
        return dispatch(commandBuilder.hscanStreaming(channel, key, scanCursor));
    }

    @Override
    public RedisFuture hscanNovalues(KeyStreamingChannel channel, K key, ScanCursor scanCursor) {
        return dispatch(commandBuilder.hscanNoValuesStreaming(channel, key, scanCursor));
    }

    @Override
    public RedisFuture hset(K key, K field, V value) {
        return dispatch(commandBuilder.hset(key, field, value));
    }

    @Override
    public RedisFuture hset(K key, Map map) {
        return dispatch(commandBuilder.hset(key, map));
    }

    @Override
    public RedisFuture hsetnx(K key, K field, V value) {
        return dispatch(commandBuilder.hsetnx(key, field, value));
    }

    @Override
    public RedisFuture hstrlen(K key, K field) {
        return dispatch(commandBuilder.hstrlen(key, field));
    }

    @Override
    public RedisFuture> hvals(K key) {
        return dispatch(commandBuilder.hvals(key));
    }

    @Override
    public RedisFuture hvals(ValueStreamingChannel channel, K key) {
        return dispatch(commandBuilder.hvals(channel, key));
    }

    @Override
    public RedisFuture incr(K key) {
        return dispatch(commandBuilder.incr(key));
    }

    @Override
    public RedisFuture incrby(K key, long amount) {
        return dispatch(commandBuilder.incrby(key, amount));
    }

    @Override
    public RedisFuture incrbyfloat(K key, double amount) {
        return dispatch(commandBuilder.incrbyfloat(key, amount));
    }

    @Override
    public RedisFuture info() {
        return dispatch(commandBuilder.info());
    }

    @Override
    public RedisFuture info(String section) {
        return dispatch(commandBuilder.info(section));
    }

    @Override
    public boolean isOpen() {
        return connection.isOpen();
    }

    @Override
    public RedisFuture> jsonArrappend(K key, JsonPath jsonPath, JsonValue... values) {
        return dispatch(jsonCommandBuilder.jsonArrappend(key, jsonPath, values));
    }

    @Override
    public RedisFuture> jsonArrappend(K key, JsonValue... values) {
        return dispatch(jsonCommandBuilder.jsonArrappend(key, JsonPath.ROOT_PATH, values));
    }

    @Override
    public RedisFuture> jsonArrindex(K key, JsonPath jsonPath, JsonValue value, JsonRangeArgs range) {
        return dispatch(jsonCommandBuilder.jsonArrindex(key, jsonPath, value, range));
    }

    @Override
    public RedisFuture> jsonArrindex(K key, JsonPath jsonPath, JsonValue value) {
        return dispatch(jsonCommandBuilder.jsonArrindex(key, jsonPath, value, JsonRangeArgs.Builder.defaults()));
    }

    @Override
    public RedisFuture> jsonArrinsert(K key, JsonPath jsonPath, int index, JsonValue... values) {
        return dispatch(jsonCommandBuilder.jsonArrinsert(key, jsonPath, index, values));
    }

    @Override
    public RedisFuture> jsonArrlen(K key, JsonPath jsonPath) {
        return dispatch(jsonCommandBuilder.jsonArrlen(key, jsonPath));
    }

    @Override
    public RedisFuture> jsonArrlen(K key) {
        return dispatch(jsonCommandBuilder.jsonArrlen(key, JsonPath.ROOT_PATH));
    }

    @Override
    public RedisFuture> jsonArrpop(K key, JsonPath jsonPath, int index) {
        return dispatch(jsonCommandBuilder.jsonArrpop(key, jsonPath, index));
    }

    @Override
    public RedisFuture> jsonArrpop(K key, JsonPath jsonPath) {
        return dispatch(jsonCommandBuilder.jsonArrpop(key, jsonPath, -1));
    }

    @Override
    public RedisFuture> jsonArrpop(K key) {
        return dispatch(jsonCommandBuilder.jsonArrpop(key, JsonPath.ROOT_PATH, -1));
    }

    @Override
    public RedisFuture> jsonArrtrim(K key, JsonPath jsonPath, JsonRangeArgs range) {
        return dispatch(jsonCommandBuilder.jsonArrtrim(key, jsonPath, range));
    }

    @Override
    public RedisFuture jsonClear(K key, JsonPath jsonPath) {
        return dispatch(jsonCommandBuilder.jsonClear(key, jsonPath));
    }

    @Override
    public RedisFuture jsonClear(K key) {
        return dispatch(jsonCommandBuilder.jsonClear(key, JsonPath.ROOT_PATH));
    }

    @Override
    public RedisFuture jsonDel(K key, JsonPath jsonPath) {
        return dispatch(jsonCommandBuilder.jsonDel(key, jsonPath));
    }

    @Override
    public RedisFuture jsonDel(K key) {
        return dispatch(jsonCommandBuilder.jsonDel(key, JsonPath.ROOT_PATH));
    }

    @Override
    public RedisFuture> jsonGet(K key, JsonGetArgs options, JsonPath... jsonPaths) {
        return dispatch(jsonCommandBuilder.jsonGet(key, options, jsonPaths));
    }

    @Override
    public RedisFuture> jsonGet(K key, JsonPath... jsonPaths) {
        return dispatch(jsonCommandBuilder.jsonGet(key, JsonGetArgs.Builder.defaults(), jsonPaths));
    }

    @Override
    public RedisFuture jsonMerge(K key, JsonPath jsonPath, JsonValue value) {
        return dispatch(jsonCommandBuilder.jsonMerge(key, jsonPath, value));
    }

    @Override
    public RedisFuture> jsonMGet(JsonPath jsonPath, K... keys) {
        return dispatch(jsonCommandBuilder.jsonMGet(jsonPath, keys));
    }

    @Override
    public RedisFuture jsonMSet(List> arguments) {
        return dispatch(jsonCommandBuilder.jsonMSet(arguments));
    }

    @Override
    public RedisFuture> jsonNumincrby(K key, JsonPath jsonPath, Number number) {
        return dispatch(jsonCommandBuilder.jsonNumincrby(key, jsonPath, number));
    }

    @Override
    public RedisFuture> jsonObjkeys(K key, JsonPath jsonPath) {
        return dispatch(jsonCommandBuilder.jsonObjkeys(key, jsonPath));
    }

    @Override
    public RedisFuture> jsonObjkeys(K key) {
        return dispatch(jsonCommandBuilder.jsonObjkeys(key, JsonPath.ROOT_PATH));
    }

    @Override
    public RedisFuture> jsonObjlen(K key, JsonPath jsonPath) {
        return dispatch(jsonCommandBuilder.jsonObjlen(key, jsonPath));
    }

    @Override
    public RedisFuture> jsonObjlen(K key) {
        return dispatch(jsonCommandBuilder.jsonObjlen(key, JsonPath.ROOT_PATH));
    }

    @Override
    public RedisFuture jsonSet(K key, JsonPath jsonPath, JsonValue value, JsonSetArgs options) {
        return dispatch(jsonCommandBuilder.jsonSet(key, jsonPath, value, options));
    }

    @Override
    public RedisFuture jsonSet(K key, JsonPath jsonPath, JsonValue value) {
        return dispatch(jsonCommandBuilder.jsonSet(key, jsonPath, value, JsonSetArgs.Builder.defaults()));
    }

    @Override
    public RedisFuture> jsonStrappend(K key, JsonPath jsonPath, JsonValue value) {
        return dispatch(jsonCommandBuilder.jsonStrappend(key, jsonPath, value));
    }

    @Override
    public RedisFuture> jsonStrappend(K key, JsonValue value) {
        return dispatch(jsonCommandBuilder.jsonStrappend(key, JsonPath.ROOT_PATH, value));
    }

    @Override
    public RedisFuture> jsonStrlen(K key, JsonPath jsonPath) {
        return dispatch(jsonCommandBuilder.jsonStrlen(key, jsonPath));
    }

    @Override
    public RedisFuture> jsonStrlen(K key) {
        return dispatch(jsonCommandBuilder.jsonStrlen(key, JsonPath.ROOT_PATH));
    }

    @Override
    public RedisFuture> jsonToggle(K key, JsonPath jsonPath) {
        return dispatch(jsonCommandBuilder.jsonToggle(key, jsonPath));
    }

    @Override
    public RedisFuture> jsonType(K key, JsonPath jsonPath) {
        return dispatch(jsonCommandBuilder.jsonType(key, jsonPath));
    }

    @Override
    public RedisFuture> jsonType(K key) {
        return dispatch(jsonCommandBuilder.jsonType(key, JsonPath.ROOT_PATH));
    }

    @Override
    public RedisFuture> keys(K pattern) {
        return dispatch(commandBuilder.keys(pattern));
    }

    @Override
    public RedisFuture keys(KeyStreamingChannel channel, K pattern) {
        return dispatch(commandBuilder.keys(channel, pattern));
    }

    @Override
    public RedisFuture lastsave() {
        return dispatch(commandBuilder.lastsave());
    }

    @Override
    public RedisFuture lindex(K key, long index) {
        return dispatch(commandBuilder.lindex(key, index));
    }

    @Override
    public RedisFuture linsert(K key, boolean before, V pivot, V value) {
        return dispatch(commandBuilder.linsert(key, before, pivot, value));
    }

    @Override
    public RedisFuture llen(K key) {
        return dispatch(commandBuilder.llen(key));
    }

    @Override
    public RedisFuture lmove(K source, K destination, LMoveArgs args) {
        return dispatch(commandBuilder.lmove(source, destination, args));
    }

    @Override
    public RedisFuture lpop(K key) {
        return dispatch(commandBuilder.lpop(key));
    }

    @Override
    public RedisFuture> lpop(K key, long count) {
        return dispatch(commandBuilder.lpop(key, count));
    }

    @Override
    public RedisFuture>> lmpop(LMPopArgs args, K... keys) {
        return dispatch(commandBuilder.lmpop(args, keys));
    }

    @Override
    public RedisFuture lpos(K key, V value) {
        return lpos(key, value, null);
    }

    @Override
    public RedisFuture lpos(K key, V value, LPosArgs args) {
        return dispatch(commandBuilder.lpos(key, value, args));
    }

    @Override
    public RedisFuture> lpos(K key, V value, int count) {
        return lpos(key, value, count, null);
    }

    @Override
    public RedisFuture> lpos(K key, V value, int count, LPosArgs args) {
        return dispatch(commandBuilder.lpos(key, value, count, args));
    }

    @Override
    public RedisFuture lpush(K key, V... values) {
        return dispatch(commandBuilder.lpush(key, values));
    }

    @Override
    public RedisFuture lpushx(K key, V... values) {
        return dispatch(commandBuilder.lpushx(key, values));
    }

    @Override
    public RedisFuture> lrange(K key, long start, long stop) {
        return dispatch(commandBuilder.lrange(key, start, stop));
    }

    @Override
    public RedisFuture lrange(ValueStreamingChannel channel, K key, long start, long stop) {
        return dispatch(commandBuilder.lrange(channel, key, start, stop));
    }

    @Override
    public RedisFuture lrem(K key, long count, V value) {
        return dispatch(commandBuilder.lrem(key, count, value));
    }

    @Override
    public RedisFuture lset(K key, long index, V value) {
        return dispatch(commandBuilder.lset(key, index, value));
    }

    @Override
    public RedisFuture ltrim(K key, long start, long stop) {
        return dispatch(commandBuilder.ltrim(key, start, stop));
    }

    @Override
    public RedisFuture memoryUsage(K key) {
        return dispatch(commandBuilder.memoryUsage(key));
    }

    @Override
    public RedisFuture>> mget(K... keys) {
        return dispatch(commandBuilder.mgetKeyValue(keys));
    }

    public RedisFuture>> mget(Iterable keys) {
        return dispatch(commandBuilder.mgetKeyValue(keys));
    }

    @Override
    public RedisFuture mget(KeyValueStreamingChannel channel, K... keys) {
        return dispatch(commandBuilder.mget(channel, keys));
    }

    public RedisFuture mget(KeyValueStreamingChannel channel, Iterable keys) {
        return dispatch(commandBuilder.mget(channel, keys));
    }

    @Override
    public RedisFuture migrate(String host, int port, K key, int db, long timeout) {
        return dispatch(commandBuilder.migrate(host, port, key, db, timeout));
    }

    @Override
    public RedisFuture migrate(String host, int port, int db, long timeout, MigrateArgs migrateArgs) {
        return dispatch(commandBuilder.migrate(host, port, db, timeout, migrateArgs));
    }

    @Override
    public RedisFuture move(K key, int db) {
        return dispatch(commandBuilder.move(key, db));
    }

    @Override
    public RedisFuture mset(Map map) {
        return dispatch(commandBuilder.mset(map));
    }

    @Override
    public RedisFuture msetnx(Map map) {
        return dispatch(commandBuilder.msetnx(map));
    }

    @Override
    public RedisFuture multi() {
        return dispatch(commandBuilder.multi());
    }

    @Override
    public RedisFuture objectEncoding(K key) {
        return dispatch(commandBuilder.objectEncoding(key));
    }

    @Override
    public RedisFuture objectFreq(K key) {
        return dispatch(commandBuilder.objectFreq(key));
    }

    @Override
    public RedisFuture objectIdletime(K key) {
        return dispatch(commandBuilder.objectIdletime(key));
    }

    @Override
    public RedisFuture objectRefcount(K key) {
        return dispatch(commandBuilder.objectRefcount(key));
    }

    @Override
    public RedisFuture persist(K key) {
        return dispatch(commandBuilder.persist(key));
    }

    @Override
    public RedisFuture> hpersist(K key, K... fields) {
        return dispatch(commandBuilder.hpersist(key, fields));
    }

    @Override
    public RedisFuture pexpire(K key, long milliseconds) {
        return pexpire(key, milliseconds, null);
    }

    @Override
    public RedisFuture pexpire(K key, long milliseconds, ExpireArgs expireArgs) {
        return dispatch(commandBuilder.pexpire(key, milliseconds, expireArgs));
    }

    @Override
    public RedisFuture pexpire(K key, Duration milliseconds) {
        return pexpire(key, milliseconds, null);
    }

    @Override
    public RedisFuture pexpire(K key, Duration milliseconds, ExpireArgs expireArgs) {
        LettuceAssert.notNull(milliseconds, "Timeout must not be null");
        return pexpire(key, milliseconds.toMillis(), expireArgs);
    }

    @Override
    public RedisFuture pexpireat(K key, Date timestamp) {
        return pexpireat(key, timestamp, null);
    }

    @Override
    public RedisFuture pexpireat(K key, Date timestamp, ExpireArgs expireArgs) {
        LettuceAssert.notNull(timestamp, "Timestamp must not be null");
        return pexpireat(key, timestamp.getTime(), expireArgs);
    }

    @Override
    public RedisFuture pexpireat(K key, Instant timestamp) {
        return pexpireat(key, timestamp, null);
    }

    @Override
    public RedisFuture pexpireat(K key, Instant timestamp, ExpireArgs expireArgs) {
        LettuceAssert.notNull(timestamp, "Timestamp must not be null");
        return pexpireat(key, timestamp.toEpochMilli(), expireArgs);
    }

    @Override
    public RedisFuture pexpireat(K key, long timestamp) {
        return pexpireat(key, timestamp, null);
    }

    @Override
    public RedisFuture pexpireat(K key, long timestamp, ExpireArgs expireArgs) {
        return dispatch(commandBuilder.pexpireat(key, timestamp, expireArgs));
    }

    @Override
    public RedisFuture pexpiretime(K key) {
        return dispatch(commandBuilder.pexpiretime(key));
    }

    @Override
    public RedisFuture pfadd(K key, V... values) {
        return dispatch(commandBuilder.pfadd(key, values));
    }

    @Override
    public RedisFuture pfcount(K... keys) {
        return dispatch(commandBuilder.pfcount(keys));
    }

    @Override
    public RedisFuture pfmerge(K destkey, K... sourcekeys) {
        return dispatch(commandBuilder.pfmerge(destkey, sourcekeys));
    }

    @Override
    public RedisFuture ping() {
        return dispatch(commandBuilder.ping());
    }

    @Override
    public RedisFuture psetex(K key, long milliseconds, V value) {
        return dispatch(commandBuilder.psetex(key, milliseconds, value));
    }

    @Override
    public RedisFuture pttl(K key) {
        return dispatch(commandBuilder.pttl(key));
    }

    @Override
    public RedisFuture publish(K channel, V message) {
        return dispatch(commandBuilder.publish(channel, message));
    }

    @Override
    public RedisFuture> pubsubChannels() {
        return dispatch(commandBuilder.pubsubChannels());
    }

    @Override
    public RedisFuture> pubsubChannels(K channel) {
        return dispatch(commandBuilder.pubsubChannels(channel));
    }

    @Override
    public RedisFuture pubsubNumpat() {
        return dispatch(commandBuilder.pubsubNumpat());
    }

    @Override
    public RedisFuture> pubsubNumsub(K... channels) {
        return dispatch(commandBuilder.pubsubNumsub(channels));
    }

    @Override
    public RedisFuture> pubsubShardChannels() {
        return dispatch(commandBuilder.pubsubShardChannels());
    }

    @Override
    public RedisFuture> pubsubShardChannels(K pattern) {
        return dispatch(commandBuilder.pubsubShardChannels(pattern));
    }

    @Override
    public RedisFuture> pubsubShardNumsub(K... shardChannels) {
        return dispatch(commandBuilder.pubsubShardNumsub(shardChannels));
    }

    @Override
    public RedisFuture quit() {
        return dispatch(commandBuilder.quit());
    }

    @Override
    public RedisFuture randomkey() {
        return dispatch(commandBuilder.randomkey());
    }

    @Override
    public RedisFuture readOnly() {
        return dispatch(commandBuilder.readOnly());
    }

    @Override
    public RedisFuture readWrite() {
        return dispatch(commandBuilder.readWrite());
    }

    @Override
    public RedisFuture rename(K key, K newKey) {
        return dispatch(commandBuilder.rename(key, newKey));
    }

    @Override
    public RedisFuture renamenx(K key, K newKey) {
        return dispatch(commandBuilder.renamenx(key, newKey));
    }

    @Override
    public RedisFuture replicaof(String host, int port) {
        return dispatch(commandBuilder.replicaof(host, port));
    }

    @Override
    public RedisFuture replicaofNoOne() {
        return dispatch(commandBuilder.replicaofNoOne());
    }

    @Override
    public void reset() {
        getConnection().reset();
    }

    @Override
    public RedisFuture restore(K key, long ttl, byte[] value) {
        return dispatch(commandBuilder.restore(key, value, RestoreArgs.Builder.ttl(ttl)));
    }

    @Override
    public RedisFuture restore(K key, byte[] value, RestoreArgs args) {
        return dispatch(commandBuilder.restore(key, value, args));
    }

    @Override
    public RedisFuture> role() {
        return dispatch(commandBuilder.role());
    }

    @Override
    public RedisFuture rpop(K key) {
        return dispatch(commandBuilder.rpop(key));
    }

    @Override
    public RedisFuture> rpop(K key, long count) {
        return dispatch(commandBuilder.rpop(key, count));
    }

    @Override
    public RedisFuture rpoplpush(K source, K destination) {
        return dispatch(commandBuilder.rpoplpush(source, destination));
    }

    @Override
    public RedisFuture rpush(K key, V... values) {
        return dispatch(commandBuilder.rpush(key, values));
    }

    @Override
    public RedisFuture rpushx(K key, V... values) {
        return dispatch(commandBuilder.rpushx(key, values));
    }

    @Override
    public RedisFuture sadd(K key, V... members) {
        return dispatch(commandBuilder.sadd(key, members));
    }

    @Override
    public RedisFuture save() {
        return dispatch(commandBuilder.save());
    }

    @Override
    public RedisFuture> scan() {
        return dispatch(commandBuilder.scan());
    }

    @Override
    public RedisFuture> scan(ScanArgs scanArgs) {
        return dispatch(commandBuilder.scan(scanArgs));
    }

    @Override
    public RedisFuture> scan(ScanCursor scanCursor, ScanArgs scanArgs) {
        return dispatch(commandBuilder.scan(scanCursor, scanArgs));
    }

    @Override
    public RedisFuture> scan(ScanCursor scanCursor) {
        return dispatch(commandBuilder.scan(scanCursor));
    }

    @Override
    public RedisFuture scan(KeyStreamingChannel channel) {
        return dispatch(commandBuilder.scanStreaming(channel));
    }

    @Override
    public RedisFuture scan(KeyStreamingChannel channel, ScanArgs scanArgs) {
        return dispatch(commandBuilder.scanStreaming(channel, scanArgs));
    }

    @Override
    public RedisFuture scan(KeyStreamingChannel channel, ScanCursor scanCursor, ScanArgs scanArgs) {
        return dispatch(commandBuilder.scanStreaming(channel, scanCursor, scanArgs));
    }

    @Override
    public RedisFuture scan(KeyStreamingChannel channel, ScanCursor scanCursor) {
        return dispatch(commandBuilder.scanStreaming(channel, scanCursor));
    }

    @Override
    public RedisFuture scard(K key) {
        return dispatch(commandBuilder.scard(key));
    }

    @Override
    public RedisFuture> scriptExists(String... digests) {
        return dispatch(commandBuilder.scriptExists(digests));
    }

    @Override
    public RedisFuture scriptFlush() {
        return dispatch(commandBuilder.scriptFlush());
    }

    @Override
    public RedisFuture scriptFlush(FlushMode flushMode) {
        return dispatch(commandBuilder.scriptFlush(flushMode));
    }

    @Override
    public RedisFuture scriptKill() {
        return dispatch(commandBuilder.scriptKill());
    }

    @Override
    public RedisFuture scriptLoad(String script) {
        return scriptLoad(encodeScript(script));
    }

    @Override
    public RedisFuture scriptLoad(byte[] script) {
        return dispatch(commandBuilder.scriptLoad(script));
    }

    @Override
    public RedisFuture> sdiff(K... keys) {
        return dispatch(commandBuilder.sdiff(keys));
    }

    @Override
    public RedisFuture sdiff(ValueStreamingChannel channel, K... keys) {
        return dispatch(commandBuilder.sdiff(channel, keys));
    }

    @Override
    public RedisFuture sdiffstore(K destination, K... keys) {
        return dispatch(commandBuilder.sdiffstore(destination, keys));
    }

    public RedisFuture select(int db) {
        return dispatch(commandBuilder.select(db));
    }

    @Override
    public RedisFuture set(K key, V value) {
        return dispatch(commandBuilder.set(key, value));
    }

    @Override
    public RedisFuture set(K key, V value, SetArgs setArgs) {
        return dispatch(commandBuilder.set(key, value, setArgs));
    }

    @Override
    public RedisFuture setGet(K key, V value) {
        return dispatch(commandBuilder.setGet(key, value));
    }

    @Override
    public RedisFuture setGet(K key, V value, SetArgs setArgs) {
        return dispatch(commandBuilder.setGet(key, value, setArgs));
    }

    @Override
    public void setAutoFlushCommands(boolean autoFlush) {
        connection.setAutoFlushCommands(autoFlush);
    }

    @Override
    public void setTimeout(Duration timeout) {
        connection.setTimeout(timeout);
    }

    @Override
    public RedisFuture setbit(K key, long offset, int value) {
        return dispatch(commandBuilder.setbit(key, offset, value));
    }

    @Override
    public RedisFuture setex(K key, long seconds, V value) {
        return dispatch(commandBuilder.setex(key, seconds, value));
    }

    @Override
    public RedisFuture setnx(K key, V value) {
        return dispatch(commandBuilder.setnx(key, value));
    }

    @Override
    public RedisFuture setrange(K key, long offset, V value) {
        return dispatch(commandBuilder.setrange(key, offset, value));
    }

    @Override
    public void shutdown(boolean save) {
        dispatch(commandBuilder.shutdown(save));
    }

    @Override
    public void shutdown(ShutdownArgs args) {
        dispatch(commandBuilder.shutdown(args));
    }

    @Override
    public RedisFuture> sinter(K... keys) {
        return dispatch(commandBuilder.sinter(keys));
    }

    @Override
    public RedisFuture sinter(ValueStreamingChannel channel, K... keys) {
        return dispatch(commandBuilder.sinter(channel, keys));
    }

    @Override
    public RedisFuture sintercard(K... keys) {
        return dispatch(commandBuilder.sintercard(keys));
    }

    @Override
    public RedisFuture sintercard(long limit, K... keys) {
        return dispatch(commandBuilder.sintercard(limit, keys));
    }

    @Override
    public RedisFuture sinterstore(K destination, K... keys) {
        return dispatch(commandBuilder.sinterstore(destination, keys));
    }

    @Override
    public RedisFuture sismember(K key, V member) {
        return dispatch(commandBuilder.sismember(key, member));
    }

    @Override
    public RedisFuture slaveof(String host, int port) {
        return dispatch(commandBuilder.slaveof(host, port));
    }

    @Override
    public RedisFuture slaveofNoOne() {
        return dispatch(commandBuilder.slaveofNoOne());
    }

    @Override
    public RedisFuture> slowlogGet() {
        return dispatch(commandBuilder.slowlogGet());
    }

    @Override
    public RedisFuture> slowlogGet(int count) {
        return dispatch(commandBuilder.slowlogGet(count));
    }

    @Override
    public RedisFuture slowlogLen() {
        return dispatch(commandBuilder.slowlogLen());
    }

    @Override
    public RedisFuture slowlogReset() {
        return dispatch(commandBuilder.slowlogReset());
    }

    @Override
    public RedisFuture> smembers(K key) {
        return dispatch(commandBuilder.smembers(key));
    }

    @Override
    public RedisFuture smembers(ValueStreamingChannel channel, K key) {
        return dispatch(commandBuilder.smembers(channel, key));
    }

    @Override
    public RedisFuture> smismember(K key, V... members) {
        return dispatch(commandBuilder.smismember(key, members));
    }

    @Override
    public RedisFuture smove(K source, K destination, V member) {
        return dispatch(commandBuilder.smove(source, destination, member));
    }

    @Override
    public RedisFuture> sort(K key) {
        return dispatch(commandBuilder.sort(key));
    }

    @Override
    public RedisFuture sort(ValueStreamingChannel channel, K key) {
        return dispatch(commandBuilder.sort(channel, key));
    }

    @Override
    public RedisFuture> sort(K key, SortArgs sortArgs) {
        return dispatch(commandBuilder.sort(key, sortArgs));
    }

    @Override
    public RedisFuture sort(ValueStreamingChannel channel, K key, SortArgs sortArgs) {
        return dispatch(commandBuilder.sortReadOnly(channel, key, sortArgs));
    }

    @Override
    public RedisFuture> sortReadOnly(K key) {
        return dispatch(commandBuilder.sortReadOnly(key));
    }

    @Override
    public RedisFuture sortReadOnly(ValueStreamingChannel channel, K key) {
        return dispatch(commandBuilder.sortReadOnly(channel, key));
    }

    @Override
    public RedisFuture> sortReadOnly(K key, SortArgs sortArgs) {
        return dispatch(commandBuilder.sortReadOnly(key, sortArgs));
    }

    @Override
    public RedisFuture sortReadOnly(ValueStreamingChannel channel, K key, SortArgs sortArgs) {
        return dispatch(commandBuilder.sortReadOnly(channel, key, sortArgs));
    }

    @Override
    public RedisFuture sortStore(K key, SortArgs sortArgs, K destination) {
        return dispatch(commandBuilder.sortStore(key, sortArgs, destination));
    }

    @Override
    public RedisFuture spop(K key) {
        return dispatch(commandBuilder.spop(key));
    }

    @Override
    public RedisFuture> spop(K key, long count) {
        return dispatch(commandBuilder.spop(key, count));
    }

    @Override
    public RedisFuture spublish(K shardChannel, V message) {
        return dispatch(commandBuilder.spublish(shardChannel, message));
    }

    @Override
    public RedisFuture srandmember(K key) {
        return dispatch(commandBuilder.srandmember(key));
    }

    @Override
    public RedisFuture> srandmember(K key, long count) {
        return dispatch(commandBuilder.srandmember(key, count));
    }

    @Override
    public RedisFuture srandmember(ValueStreamingChannel channel, K key, long count) {
        return dispatch(commandBuilder.srandmember(channel, key, count));
    }

    @Override
    public RedisFuture srem(K key, V... members) {
        return dispatch(commandBuilder.srem(key, members));
    }

    @Override
    public RedisFuture> sscan(K key) {
        return dispatch(commandBuilder.sscan(key));
    }

    @Override
    public RedisFuture> sscan(K key, ScanArgs scanArgs) {
        return dispatch(commandBuilder.sscan(key, scanArgs));
    }

    @Override
    public RedisFuture> sscan(K key, ScanCursor scanCursor, ScanArgs scanArgs) {
        return dispatch(commandBuilder.sscan(key, scanCursor, scanArgs));
    }

    @Override
    public RedisFuture> sscan(K key, ScanCursor scanCursor) {
        return dispatch(commandBuilder.sscan(key, scanCursor));
    }

    @Override
    public RedisFuture sscan(ValueStreamingChannel channel, K key) {
        return dispatch(commandBuilder.sscanStreaming(channel, key));
    }

    @Override
    public RedisFuture sscan(ValueStreamingChannel channel, K key, ScanArgs scanArgs) {
        return dispatch(commandBuilder.sscanStreaming(channel, key, scanArgs));
    }

    @Override
    public RedisFuture sscan(ValueStreamingChannel channel, K key, ScanCursor scanCursor,
            ScanArgs scanArgs) {
        return dispatch(commandBuilder.sscanStreaming(channel, key, scanCursor, scanArgs));
    }

    @Override
    public RedisFuture sscan(ValueStreamingChannel channel, K key, ScanCursor scanCursor) {
        return dispatch(commandBuilder.sscanStreaming(channel, key, scanCursor));
    }

    @Override
    public RedisFuture strlen(K key) {
        return dispatch(commandBuilder.strlen(key));
    }

    @Override
    public RedisFuture stralgoLcs(StrAlgoArgs args) {
        return dispatch(commandBuilder.stralgoLcs(args));
    }

    @Override
    public RedisFuture lcs(LcsArgs args) {
        return dispatch(commandBuilder.lcs(args));
    }

    @Override
    public RedisFuture> sunion(K... keys) {
        return dispatch(commandBuilder.sunion(keys));
    }

    @Override
    public RedisFuture sunion(ValueStreamingChannel channel, K... keys) {
        return dispatch(commandBuilder.sunion(channel, keys));
    }

    @Override
    public RedisFuture sunionstore(K destination, K... keys) {
        return dispatch(commandBuilder.sunionstore(destination, keys));
    }

    public RedisFuture swapdb(int db1, int db2) {
        return dispatch(commandBuilder.swapdb(db1, db2));
    }

    @Override
    public RedisFuture> time() {
        return dispatch(commandBuilder.time());
    }

    @Override
    public RedisFuture touch(K... keys) {
        return dispatch(commandBuilder.touch(keys));
    }

    public RedisFuture touch(Iterable keys) {
        return dispatch(commandBuilder.touch(keys));
    }

    @Override
    public RedisFuture ttl(K key) {
        return dispatch(commandBuilder.ttl(key));
    }

    @Override
    public RedisFuture type(K key) {
        return dispatch(commandBuilder.type(key));
    }

    @Override
    public RedisFuture unlink(K... keys) {
        return dispatch(commandBuilder.unlink(keys));
    }

    public RedisFuture unlink(Iterable keys) {
        return dispatch(commandBuilder.unlink(keys));
    }

    @Override
    public RedisFuture copy(K source, K destination) {
        return dispatch(commandBuilder.copy(source, destination));
    }

    @Override
    public RedisFuture copy(K source, K destination, CopyArgs copyArgs) {
        return dispatch(commandBuilder.copy(source, destination, copyArgs));
    }

    @Override
    public RedisFuture unwatch() {
        return dispatch(commandBuilder.unwatch());
    }

    @Override
    public RedisFuture waitForReplication(int replicas, long timeout) {
        return dispatch(commandBuilder.wait(replicas, timeout));
    }

    @Override
    public RedisFuture watch(K... keys) {
        return dispatch(commandBuilder.watch(keys));
    }

    @Override
    public RedisFuture xack(K key, K group, String... messageIds) {
        return dispatch(commandBuilder.xack(key, group, messageIds));
    }

    @Override
    public RedisFuture xadd(K key, Map body) {
        return dispatch(commandBuilder.xadd(key, null, body));
    }

    @Override
    public RedisFuture xadd(K key, XAddArgs args, Map body) {
        return dispatch(commandBuilder.xadd(key, args, body));
    }

    @Override
    public RedisFuture xadd(K key, Object... keysAndValues) {
        return dispatch(commandBuilder.xadd(key, null, keysAndValues));
    }

    @Override
    public RedisFuture xadd(K key, XAddArgs args, Object... keysAndValues) {
        return dispatch(commandBuilder.xadd(key, args, keysAndValues));
    }

    @Override
    public RedisFuture> xautoclaim(K key, XAutoClaimArgs args) {
        return dispatch(commandBuilder.xautoclaim(key, args));
    }

    @Override
    public RedisFuture>> xclaim(K key, Consumer consumer, long minIdleTime, String... messageIds) {
        return dispatch(commandBuilder.xclaim(key, consumer, XClaimArgs.Builder.minIdleTime(minIdleTime), messageIds));
    }

    @Override
    public RedisFuture>> xclaim(K key, Consumer consumer, XClaimArgs args, String... messageIds) {
        return dispatch(commandBuilder.xclaim(key, consumer, args, messageIds));
    }

    @Override
    public RedisFuture xdel(K key, String... messageIds) {
        return dispatch(commandBuilder.xdel(key, messageIds));
    }

    @Override
    public RedisFuture xgroupCreate(XReadArgs.StreamOffset offset, K group) {
        return dispatch(commandBuilder.xgroupCreate(offset, group, null));
    }

    @Override
    public RedisFuture xgroupCreate(XReadArgs.StreamOffset offset, K group, XGroupCreateArgs args) {
        return dispatch(commandBuilder.xgroupCreate(offset, group, args));
    }

    @Override
    public RedisFuture xgroupCreateconsumer(K key, Consumer consumer) {
        return dispatch(commandBuilder.xgroupCreateconsumer(key, consumer));
    }

    @Override
    public RedisFuture xgroupDelconsumer(K key, Consumer consumer) {
        return dispatch(commandBuilder.xgroupDelconsumer(key, consumer));
    }

    @Override
    public RedisFuture xgroupDestroy(K key, K group) {
        return dispatch(commandBuilder.xgroupDestroy(key, group));
    }

    @Override
    public RedisFuture xgroupSetid(XReadArgs.StreamOffset offset, K group) {
        return dispatch(commandBuilder.xgroupSetid(offset, group));
    }

    @Override
    public RedisFuture> xinfoStream(K key) {
        return dispatch(commandBuilder.xinfoStream(key));
    }

    @Override
    public RedisFuture> xinfoGroups(K key) {
        return dispatch(commandBuilder.xinfoGroups(key));
    }

    @Override
    public RedisFuture> xinfoConsumers(K key, K group) {
        return dispatch(commandBuilder.xinfoConsumers(key, group));
    }

    @Override
    public RedisFuture xlen(K key) {
        return dispatch(commandBuilder.xlen(key));
    }

    @Override
    public RedisFuture xpending(K key, K group) {
        return dispatch(commandBuilder.xpending(key, group));
    }

    @Override
    public RedisFuture> xpending(K key, K group, Range range, Limit limit) {
        return dispatch(commandBuilder.xpending(key, group, range, limit));
    }

    @Override
    public RedisFuture> xpending(K key, Consumer consumer, Range range, Limit limit) {
        return dispatch(commandBuilder.xpending(key, consumer, range, limit));
    }

    @Override
    public RedisFuture> xpending(K key, XPendingArgs args) {
        return dispatch(commandBuilder.xpending(key, args));
    }

    @Override
    public RedisFuture>> xrange(K key, Range range) {
        return dispatch(commandBuilder.xrange(key, range, Limit.unlimited()));
    }

    @Override
    public RedisFuture>> xrange(K key, Range range, Limit limit) {
        return dispatch(commandBuilder.xrange(key, range, limit));
    }

    @Override
    public RedisFuture>> xread(XReadArgs.StreamOffset... streams) {
        return dispatch(commandBuilder.xread(null, streams));
    }

    @Override
    public RedisFuture>> xread(XReadArgs args, XReadArgs.StreamOffset... streams) {
        return dispatch(commandBuilder.xread(args, streams));
    }

    @Override
    public RedisFuture>> xreadgroup(Consumer consumer, XReadArgs.StreamOffset... streams) {
        return dispatch(commandBuilder.xreadgroup(consumer, null, streams));
    }

    @Override
    public RedisFuture>> xreadgroup(Consumer consumer, XReadArgs args,
            XReadArgs.StreamOffset... streams) {
        return dispatch(commandBuilder.xreadgroup(consumer, args, streams));
    }

    @Override
    public RedisFuture>> xrevrange(K key, Range range) {
        return dispatch(commandBuilder.xrevrange(key, range, Limit.unlimited()));
    }

    @Override
    public RedisFuture>> xrevrange(K key, Range range, Limit limit) {
        return dispatch(commandBuilder.xrevrange(key, range, limit));
    }

    @Override
    public RedisFuture xtrim(K key, long count) {
        return xtrim(key, false, count);
    }

    @Override
    public RedisFuture xtrim(K key, boolean approximateTrimming, long count) {
        return dispatch(commandBuilder.xtrim(key, approximateTrimming, count));
    }

    @Override
    public RedisFuture xtrim(K key, XTrimArgs args) {
        return dispatch(commandBuilder.xtrim(key, args));
    }

    @Override
    public RedisFuture>> bzmpop(long timeout, ZPopArgs args, K... keys) {
        return dispatch(commandBuilder.bzmpop(timeout, args, keys));
    }

    @Override
    public RedisFuture>>> bzmpop(long timeout, long count, ZPopArgs args, K... keys) {
        return dispatch(commandBuilder.bzmpop(timeout, count, args, keys));
    }

    @Override
    public RedisFuture>> bzmpop(double timeout, ZPopArgs args, K... keys) {
        return dispatch(commandBuilder.bzmpop(timeout, args, keys));
    }

    @Override
    public RedisFuture>>> bzmpop(double timeout, int count, ZPopArgs args, K... keys) {
        return dispatch(commandBuilder.bzmpop(timeout, count, args, keys));
    }

    @Override
    public RedisFuture>> bzpopmin(long timeout, K... keys) {
        return dispatch(commandBuilder.bzpopmin(timeout, keys));
    }

    @Override
    public RedisFuture>> bzpopmin(double timeout, K... keys) {
        return dispatch(commandBuilder.bzpopmin(timeout, keys));
    }

    @Override
    public RedisFuture>> bzpopmax(long timeout, K... keys) {
        return dispatch(commandBuilder.bzpopmax(timeout, keys));
    }

    @Override
    public RedisFuture>> bzpopmax(double timeout, K... keys) {
        return dispatch(commandBuilder.bzpopmax(timeout, keys));
    }

    @Override
    public RedisFuture zadd(K key, double score, V member) {
        return dispatch(commandBuilder.zadd(key, null, score, member));
    }

    @Override
    public RedisFuture zadd(K key, Object... scoresAndValues) {
        return dispatch(commandBuilder.zadd(key, null, scoresAndValues));
    }

    @Override
    public RedisFuture zadd(K key, ScoredValue... scoredValues) {
        return dispatch(commandBuilder.zadd(key, null, (Object[]) scoredValues));
    }

    @Override
    public RedisFuture zadd(K key, ZAddArgs zAddArgs, double score, V member) {
        return dispatch(commandBuilder.zadd(key, zAddArgs, score, member));
    }

    @Override
    public RedisFuture zadd(K key, ZAddArgs zAddArgs, Object... scoresAndValues) {
        return dispatch(commandBuilder.zadd(key, zAddArgs, scoresAndValues));
    }

    @Override
    public RedisFuture zadd(K key, ZAddArgs zAddArgs, ScoredValue... scoredValues) {
        return dispatch(commandBuilder.zadd(key, zAddArgs, (Object[]) scoredValues));
    }

    @Override
    public RedisFuture zaddincr(K key, double score, V member) {
        return dispatch(commandBuilder.zaddincr(key, null, score, member));
    }

    @Override
    public RedisFuture zaddincr(K key, ZAddArgs zAddArgs, double score, V member) {
        return dispatch(commandBuilder.zaddincr(key, zAddArgs, score, member));
    }

    @Override
    public RedisFuture zcard(K key) {
        return dispatch(commandBuilder.zcard(key));
    }

    @Override
    public RedisFuture zcount(K key, double min, double max) {
        return dispatch(commandBuilder.zcount(key, min, max));
    }

    @Override
    public RedisFuture zcount(K key, String min, String max) {
        return dispatch(commandBuilder.zcount(key, min, max));
    }

    @Override
    public RedisFuture zcount(K key, Range range) {
        return dispatch(commandBuilder.zcount(key, range));
    }

    @Override
    public RedisFuture> zdiff(K... keys) {
        return dispatch(commandBuilder.zdiff(keys));
    }

    @Override
    public RedisFuture zdiffstore(K destKey, K... srcKeys) {
        return dispatch(commandBuilder.zdiffstore(destKey, srcKeys));
    }

    @Override
    public RedisFuture>> zdiffWithScores(K... keys) {
        return dispatch(commandBuilder.zdiffWithScores(keys));
    }

    @Override
    public RedisFuture zincrby(K key, double amount, V member) {
        return dispatch(commandBuilder.zincrby(key, amount, member));
    }

    @Override
    public RedisFuture> zinter(K... keys) {
        return dispatch(commandBuilder.zinter(keys));
    }

    @Override
    public RedisFuture> zinter(ZAggregateArgs aggregateArgs, K... keys) {
        return dispatch(commandBuilder.zinter(aggregateArgs, keys));
    }

    @Override
    public RedisFuture zintercard(K... keys) {
        return dispatch(commandBuilder.zintercard(keys));
    }

    @Override
    public RedisFuture zintercard(long limit, K... keys) {
        return dispatch(commandBuilder.zintercard(limit, keys));
    }

    @Override
    public RedisFuture>> zinterWithScores(K... keys) {
        return dispatch(commandBuilder.zinterWithScores(keys));
    }

    @Override
    public RedisFuture>> zinterWithScores(ZAggregateArgs aggregateArgs, K... keys) {
        return dispatch(commandBuilder.zinterWithScores(aggregateArgs, keys));
    }

    @Override
    public RedisFuture zinterstore(K destination, K... keys) {
        return dispatch(commandBuilder.zinterstore(destination, keys));
    }

    @Override
    public RedisFuture zinterstore(K destination, ZStoreArgs zStoreArgs, K... keys) {
        return dispatch(commandBuilder.zinterstore(destination, zStoreArgs, keys));
    }

    @Override
    public RedisFuture zlexcount(K key, String min, String max) {
        return dispatch(commandBuilder.zlexcount(key, min, max));
    }

    @Override
    public RedisFuture zlexcount(K key, Range range) {
        return dispatch(commandBuilder.zlexcount(key, range));
    }

    @Override
    public RedisFuture> zmscore(K key, V... members) {
        return dispatch(commandBuilder.zmscore(key, members));
    }

    @Override
    public RedisFuture>> zmpop(ZPopArgs args, K... keys) {
        return dispatch(commandBuilder.zmpop(args, keys));
    }

    @Override
    public RedisFuture>>> zmpop(int count, ZPopArgs args, K... keys) {
        return dispatch(commandBuilder.zmpop(count, args, keys));
    }

    @Override
    public RedisFuture> zpopmin(K key) {
        return dispatch(commandBuilder.zpopmin(key));
    }

    @Override
    public RedisFuture>> zpopmin(K key, long count) {
        return dispatch(commandBuilder.zpopmin(key, count));
    }

    @Override
    public RedisFuture> zpopmax(K key) {
        return dispatch(commandBuilder.zpopmax(key));
    }

    @Override
    public RedisFuture>> zpopmax(K key, long count) {
        return dispatch(commandBuilder.zpopmax(key, count));
    }

    @Override
    public RedisFuture zrandmember(K key) {
        return dispatch(commandBuilder.zrandmember(key));
    }

    @Override
    public RedisFuture> zrandmember(K key, long count) {
        return dispatch(commandBuilder.zrandmember(key, count));
    }

    @Override
    public RedisFuture> zrandmemberWithScores(K key) {
        return dispatch(commandBuilder.zrandmemberWithScores(key));
    }

    @Override
    public RedisFuture>> zrandmemberWithScores(K key, long count) {
        return dispatch(commandBuilder.zrandmemberWithScores(key, count));
    }

    @Override
    public RedisFuture> zrange(K key, long start, long stop) {
        return dispatch(commandBuilder.zrange(key, start, stop));
    }

    @Override
    public RedisFuture zrange(ValueStreamingChannel channel, K key, long start, long stop) {
        return dispatch(commandBuilder.zrange(channel, key, start, stop));
    }

    @Override
    public RedisFuture>> zrangeWithScores(K key, long start, long stop) {
        return dispatch(commandBuilder.zrangeWithScores(key, start, stop));
    }

    @Override
    public RedisFuture zrangeWithScores(ScoredValueStreamingChannel channel, K key, long start, long stop) {
        return dispatch(commandBuilder.zrangeWithScores(channel, key, start, stop));
    }

    @Override
    public RedisFuture> zrangebylex(K key, String min, String max) {
        return dispatch(commandBuilder.zrangebylex(key, min, max));
    }

    @Override
    public RedisFuture> zrangebylex(K key, Range range) {
        return dispatch(commandBuilder.zrangebylex(key, range, Limit.unlimited()));
    }

    @Override
    public RedisFuture> zrangebylex(K key, String min, String max, long offset, long count) {
        return dispatch(commandBuilder.zrangebylex(key, min, max, offset, count));
    }

    @Override
    public RedisFuture> zrangebylex(K key, Range range, Limit limit) {
        return dispatch(commandBuilder.zrangebylex(key, range, limit));
    }

    @Override
    public RedisFuture> zrangebyscore(K key, double min, double max) {
        return dispatch(commandBuilder.zrangebyscore(key, min, max));
    }

    @Override
    public RedisFuture> zrangebyscore(K key, String min, String max) {
        return dispatch(commandBuilder.zrangebyscore(key, min, max));
    }

    @Override
    public RedisFuture> zrangebyscore(K key, Range range) {
        return dispatch(commandBuilder.zrangebyscore(key, range, Limit.unlimited()));
    }

    @Override
    public RedisFuture> zrangebyscore(K key, double min, double max, long offset, long count) {
        return dispatch(commandBuilder.zrangebyscore(key, min, max, offset, count));
    }

    @Override
    public RedisFuture> zrangebyscore(K key, String min, String max, long offset, long count) {
        return dispatch(commandBuilder.zrangebyscore(key, min, max, offset, count));
    }

    @Override
    public RedisFuture> zrangebyscore(K key, Range range, Limit limit) {
        return dispatch(commandBuilder.zrangebyscore(key, range, limit));
    }

    @Override
    public RedisFuture zrangebyscore(ValueStreamingChannel channel, K key, double min, double max) {
        return dispatch(commandBuilder.zrangebyscore(channel, key, min, max));
    }

    @Override
    public RedisFuture zrangebyscore(ValueStreamingChannel channel, K key, String min, String max) {
        return dispatch(commandBuilder.zrangebyscore(channel, key, min, max));
    }

    @Override
    public RedisFuture zrangebyscore(ValueStreamingChannel channel, K key, Range range) {
        return dispatch(commandBuilder.zrangebyscore(channel, key, range, Limit.unlimited()));
    }

    @Override
    public RedisFuture zrangebyscore(ValueStreamingChannel channel, K key, double min, double max, long offset,
            long count) {
        return dispatch(commandBuilder.zrangebyscore(channel, key, min, max, offset, count));
    }

    @Override
    public RedisFuture zrangebyscore(ValueStreamingChannel channel, K key, String min, String max, long offset,
            long count) {
        return dispatch(commandBuilder.zrangebyscore(channel, key, min, max, offset, count));
    }

    @Override
    public RedisFuture zrangebyscore(ValueStreamingChannel channel, K key, Range range,
            Limit limit) {
        return dispatch(commandBuilder.zrangebyscore(channel, key, range, limit));
    }

    @Override
    public RedisFuture>> zrangebyscoreWithScores(K key, double min, double max) {
        return dispatch(commandBuilder.zrangebyscoreWithScores(key, min, max));
    }

    @Override
    public RedisFuture>> zrangebyscoreWithScores(K key, String min, String max) {
        return dispatch(commandBuilder.zrangebyscoreWithScores(key, min, max));
    }

    @Override
    public RedisFuture>> zrangebyscoreWithScores(K key, Range range) {
        return dispatch(commandBuilder.zrangebyscoreWithScores(key, range, Limit.unlimited()));
    }

    @Override
    public RedisFuture>> zrangebyscoreWithScores(K key, double min, double max, long offset, long count) {
        return dispatch(commandBuilder.zrangebyscoreWithScores(key, min, max, offset, count));
    }

    @Override
    public RedisFuture>> zrangebyscoreWithScores(K key, String min, String max, long offset, long count) {
        return dispatch(commandBuilder.zrangebyscoreWithScores(key, min, max, offset, count));
    }

    @Override
    public RedisFuture>> zrangebyscoreWithScores(K key, Range range, Limit limit) {
        return dispatch(commandBuilder.zrangebyscoreWithScores(key, range, limit));
    }

    @Override
    public RedisFuture zrangebyscoreWithScores(ScoredValueStreamingChannel channel, K key, double min, double max) {
        return dispatch(commandBuilder.zrangebyscoreWithScores(channel, key, min, max));
    }

    @Override
    public RedisFuture zrangebyscoreWithScores(ScoredValueStreamingChannel channel, K key, String min, String max) {
        return dispatch(commandBuilder.zrangebyscoreWithScores(channel, key, min, max));
    }

    @Override
    public RedisFuture zrangebyscoreWithScores(ScoredValueStreamingChannel channel, K key,
            Range range) {
        return dispatch(commandBuilder.zrangebyscoreWithScores(channel, key, range, Limit.unlimited()));
    }

    @Override
    public RedisFuture zrangebyscoreWithScores(ScoredValueStreamingChannel channel, K key, double min, double max,
            long offset, long count) {
        return dispatch(commandBuilder.zrangebyscoreWithScores(channel, key, min, max, offset, count));
    }

    @Override
    public RedisFuture zrangebyscoreWithScores(ScoredValueStreamingChannel channel, K key, String min, String max,
            long offset, long count) {
        return dispatch(commandBuilder.zrangebyscoreWithScores(channel, key, min, max, offset, count));
    }

    @Override
    public RedisFuture zrangebyscoreWithScores(ScoredValueStreamingChannel channel, K key,
            Range range, Limit limit) {
        return dispatch(commandBuilder.zrangebyscoreWithScores(channel, key, range, limit));
    }

    @Override
    public RedisFuture zrangestore(K dstKey, K srcKey, Range range) {
        return dispatch(commandBuilder.zrangestore(dstKey, srcKey, range, false));
    }

    @Override
    public RedisFuture zrangestorebylex(K dstKey, K srcKey, Range range, Limit limit) {
        return dispatch(commandBuilder.zrangestorebylex(dstKey, srcKey, range, limit, false));
    }

    @Override
    public RedisFuture zrangestorebyscore(K dstKey, K srcKey, Range range, Limit limit) {
        return dispatch(commandBuilder.zrangestorebyscore(dstKey, srcKey, range, limit, false));
    }

    @Override
    public RedisFuture zrank(K key, V member) {
        return dispatch(commandBuilder.zrank(key, member));
    }

    @Override
    public RedisFuture> zrankWithScore(K key, V member) {
        return dispatch(commandBuilder.zrankWithScore(key, member));
    }

    @Override
    public RedisFuture zrem(K key, V... members) {
        return dispatch(commandBuilder.zrem(key, members));
    }

    @Override
    public RedisFuture zremrangebylex(K key, String min, String max) {
        return dispatch(commandBuilder.zremrangebylex(key, min, max));
    }

    @Override
    public RedisFuture zremrangebylex(K key, Range range) {
        return dispatch(commandBuilder.zremrangebylex(key, range));
    }

    @Override
    public RedisFuture zremrangebyrank(K key, long start, long stop) {
        return dispatch(commandBuilder.zremrangebyrank(key, start, stop));
    }

    @Override
    public RedisFuture zremrangebyscore(K key, double min, double max) {
        return dispatch(commandBuilder.zremrangebyscore(key, min, max));
    }

    @Override
    public RedisFuture zremrangebyscore(K key, String min, String max) {
        return dispatch(commandBuilder.zremrangebyscore(key, min, max));
    }

    @Override
    public RedisFuture zremrangebyscore(K key, Range range) {
        return dispatch(commandBuilder.zremrangebyscore(key, range));
    }

    @Override
    public RedisFuture> zrevrange(K key, long start, long stop) {
        return dispatch(commandBuilder.zrevrange(key, start, stop));
    }

    @Override
    public RedisFuture zrevrange(ValueStreamingChannel channel, K key, long start, long stop) {
        return dispatch(commandBuilder.zrevrange(channel, key, start, stop));
    }

    @Override
    public RedisFuture>> zrevrangeWithScores(K key, long start, long stop) {
        return dispatch(commandBuilder.zrevrangeWithScores(key, start, stop));
    }

    @Override
    public RedisFuture zrevrangeWithScores(ScoredValueStreamingChannel channel, K key, long start, long stop) {
        return dispatch(commandBuilder.zrevrangeWithScores(channel, key, start, stop));
    }

    @Override
    public RedisFuture zrevrangestore(K dstKey, K srcKey, Range range) {
        return dispatch(commandBuilder.zrangestore(dstKey, srcKey, range, true));
    }

    @Override
    public RedisFuture zrevrangestorebylex(K dstKey, K srcKey, Range range, Limit limit) {
        return dispatch(commandBuilder.zrangestorebylex(dstKey, srcKey, range, limit, true));
    }

    @Override
    public RedisFuture zrevrangestorebyscore(K dstKey, K srcKey, Range range, Limit limit) {
        return dispatch(commandBuilder.zrangestorebyscore(dstKey, srcKey, range, limit, true));
    }

    @Override
    public RedisFuture> zrevrangebylex(K key, Range range) {
        return dispatch(commandBuilder.zrevrangebylex(key, range, Limit.unlimited()));
    }

    @Override
    public RedisFuture> zrevrangebylex(K key, Range range, Limit limit) {
        return dispatch(commandBuilder.zrevrangebylex(key, range, limit));
    }

    @Override
    public RedisFuture> zrevrangebyscore(K key, double max, double min) {
        return dispatch(commandBuilder.zrevrangebyscore(key, max, min));
    }

    @Override
    public RedisFuture> zrevrangebyscore(K key, String max, String min) {
        return dispatch(commandBuilder.zrevrangebyscore(key, max, min));
    }

    @Override
    public RedisFuture> zrevrangebyscore(K key, Range range) {
        return dispatch(commandBuilder.zrevrangebyscore(key, range, Limit.unlimited()));
    }

    @Override
    public RedisFuture> zrevrangebyscore(K key, double max, double min, long offset, long count) {
        return dispatch(commandBuilder.zrevrangebyscore(key, max, min, offset, count));
    }

    @Override
    public RedisFuture> zrevrangebyscore(K key, String max, String min, long offset, long count) {
        return dispatch(commandBuilder.zrevrangebyscore(key, max, min, offset, count));
    }

    @Override
    public RedisFuture> zrevrangebyscore(K key, Range range, Limit limit) {
        return dispatch(commandBuilder.zrevrangebyscore(key, range, limit));
    }

    @Override
    public RedisFuture zrevrangebyscore(ValueStreamingChannel channel, K key, double max, double min) {
        return dispatch(commandBuilder.zrevrangebyscore(channel, key, max, min));
    }

    @Override
    public RedisFuture zrevrangebyscore(ValueStreamingChannel channel, K key, String max, String min) {
        return dispatch(commandBuilder.zrevrangebyscore(channel, key, max, min));
    }

    @Override
    public RedisFuture zrevrangebyscore(ValueStreamingChannel channel, K key, Range range) {
        return dispatch(commandBuilder.zrevrangebyscore(channel, key, range, Limit.unlimited()));
    }

    @Override
    public RedisFuture zrevrangebyscore(ValueStreamingChannel channel, K key, double max, double min, long offset,
            long count) {
        return dispatch(commandBuilder.zrevrangebyscore(channel, key, max, min, offset, count));
    }

    @Override
    public RedisFuture zrevrangebyscore(ValueStreamingChannel channel, K key, String max, String min, long offset,
            long count) {
        return dispatch(commandBuilder.zrevrangebyscore(channel, key, max, min, offset, count));
    }

    @Override
    public RedisFuture zrevrangebyscore(ValueStreamingChannel channel, K key, Range range,
            Limit limit) {
        return dispatch(commandBuilder.zrevrangebyscore(channel, key, range, limit));
    }

    @Override
    public RedisFuture>> zrevrangebyscoreWithScores(K key, double max, double min) {
        return dispatch(commandBuilder.zrevrangebyscoreWithScores(key, max, min));
    }

    @Override
    public RedisFuture>> zrevrangebyscoreWithScores(K key, String max, String min) {
        return dispatch(commandBuilder.zrevrangebyscoreWithScores(key, max, min));
    }

    @Override
    public RedisFuture>> zrevrangebyscoreWithScores(K key, Range range) {
        return dispatch(commandBuilder.zrevrangebyscoreWithScores(key, range, Limit.unlimited()));
    }

    @Override
    public RedisFuture>> zrevrangebyscoreWithScores(K key, double max, double min, long offset,
            long count) {
        return dispatch(commandBuilder.zrevrangebyscoreWithScores(key, max, min, offset, count));
    }

    @Override
    public RedisFuture>> zrevrangebyscoreWithScores(K key, String max, String min, long offset,
            long count) {
        return dispatch(commandBuilder.zrevrangebyscoreWithScores(key, max, min, offset, count));
    }

    @Override
    public RedisFuture>> zrevrangebyscoreWithScores(K key, Range range, Limit limit) {
        return dispatch(commandBuilder.zrevrangebyscoreWithScores(key, range, limit));
    }

    @Override
    public RedisFuture zrevrangebyscoreWithScores(ScoredValueStreamingChannel channel, K key, double max, double min) {
        return dispatch(commandBuilder.zrevrangebyscoreWithScores(channel, key, max, min));
    }

    @Override
    public RedisFuture zrevrangebyscoreWithScores(ScoredValueStreamingChannel channel, K key, String max, String min) {
        return dispatch(commandBuilder.zrevrangebyscoreWithScores(channel, key, max, min));
    }

    @Override
    public RedisFuture zrevrangebyscoreWithScores(ScoredValueStreamingChannel channel, K key,
            Range range) {
        return dispatch(commandBuilder.zrevrangebyscoreWithScores(channel, key, range, Limit.unlimited()));
    }

    @Override
    public RedisFuture zrevrangebyscoreWithScores(ScoredValueStreamingChannel channel, K key, double max, double min,
            long offset, long count) {
        return dispatch(commandBuilder.zrevrangebyscoreWithScores(channel, key, max, min, offset, count));
    }

    @Override
    public RedisFuture zrevrangebyscoreWithScores(ScoredValueStreamingChannel channel, K key, String max, String min,
            long offset, long count) {
        return dispatch(commandBuilder.zrevrangebyscoreWithScores(channel, key, max, min, offset, count));
    }

    @Override
    public RedisFuture zrevrangebyscoreWithScores(ScoredValueStreamingChannel channel, K key,
            Range range, Limit limit) {
        return dispatch(commandBuilder.zrevrangebyscoreWithScores(channel, key, range, limit));
    }

    @Override
    public RedisFuture zrevrank(K key, V member) {
        return dispatch(commandBuilder.zrevrank(key, member));
    }

    @Override
    public RedisFuture> zrevrankWithScore(K key, V member) {
        return dispatch(commandBuilder.zrevrankWithScore(key, member));
    }

    @Override
    public RedisFuture> zscan(K key) {
        return dispatch(commandBuilder.zscan(key));
    }

    @Override
    public RedisFuture> zscan(K key, ScanArgs scanArgs) {
        return dispatch(commandBuilder.zscan(key, scanArgs));
    }

    @Override
    public RedisFuture> zscan(K key, ScanCursor scanCursor, ScanArgs scanArgs) {
        return dispatch(commandBuilder.zscan(key, scanCursor, scanArgs));
    }

    @Override
    public RedisFuture> zscan(K key, ScanCursor scanCursor) {
        return dispatch(commandBuilder.zscan(key, scanCursor));
    }

    @Override
    public RedisFuture zscan(ScoredValueStreamingChannel channel, K key) {
        return dispatch(commandBuilder.zscanStreaming(channel, key));
    }

    @Override
    public RedisFuture zscan(ScoredValueStreamingChannel channel, K key, ScanArgs scanArgs) {
        return dispatch(commandBuilder.zscanStreaming(channel, key, scanArgs));
    }

    @Override
    public RedisFuture zscan(ScoredValueStreamingChannel channel, K key, ScanCursor scanCursor,
            ScanArgs scanArgs) {
        return dispatch(commandBuilder.zscanStreaming(channel, key, scanCursor, scanArgs));
    }

    @Override
    public RedisFuture zscan(ScoredValueStreamingChannel channel, K key, ScanCursor scanCursor) {
        return dispatch(commandBuilder.zscanStreaming(channel, key, scanCursor));
    }

    @Override
    public RedisFuture zscore(K key, V member) {
        return dispatch(commandBuilder.zscore(key, member));
    }

    @Override
    public RedisFuture> zunion(K... keys) {
        return dispatch(commandBuilder.zunion(keys));
    }

    @Override
    public RedisFuture> zunion(ZAggregateArgs aggregateArgs, K... keys) {
        return dispatch(commandBuilder.zunion(aggregateArgs, keys));
    }

    @Override
    public RedisFuture>> zunionWithScores(K... keys) {
        return dispatch(commandBuilder.zunionWithScores(keys));
    }

    @Override
    public RedisFuture>> zunionWithScores(ZAggregateArgs aggregateArgs, K... keys) {
        return dispatch(commandBuilder.zunionWithScores(aggregateArgs, keys));
    }

    @Override
    public RedisFuture zunionstore(K destination, K... keys) {
        return dispatch(commandBuilder.zunionstore(destination, keys));
    }

    @Override
    public RedisFuture zunionstore(K destination, ZStoreArgs zStoreArgs, K... keys) {
        return dispatch(commandBuilder.zunionstore(destination, zStoreArgs, keys));
    }

    @Override
    public RedisFuture>> clusterLinks() {
        return dispatch(commandBuilder.clusterLinks());
    }

    @Override
    public JsonParser getJsonParser() {
        return this.parser.block();
    }

    private byte[] encodeFunction(String functionCode) {
        LettuceAssert.notNull(functionCode, "Function code must not be null");
        LettuceAssert.notEmpty(functionCode, "Function code script must not be empty");
        return functionCode.getBytes(getConnection().getOptions().getScriptCharset());
    }

    private byte[] encodeScript(String script) {
        LettuceAssert.notNull(script, "Lua script must not be null");
        LettuceAssert.notEmpty(script, "Lua script must not be empty");
        return script.getBytes(getConnection().getOptions().getScriptCharset());
    }

}




    © 2015 - 2025 Weber Informatics LLC | Privacy Policy