The KEYS command needs to be keyless

Dltmd202 · Dltmd202 · commit bb9b5e816116 · 2025-06-30T01:34:17.000+09:00
diff --git a/src/main/java/io/lettuce/core/AbstractRedisAsyncCommands.java b/src/main/java/io/lettuce/core/AbstractRedisAsyncCommands.java
@@ -1826,12 +1826,12 @@ public RedisFuture<Map<V, Double>> vsimWithScore(K key, VSimArgs args, V element
     }
 
     @Override
-    public RedisFuture<List<K>> keys(K pattern) {
+    public RedisFuture<List<K>> keys(String pattern) {
         return dispatch(commandBuilder.keys(pattern));
     }
 
     @Override
-    public RedisFuture<Long> keys(KeyStreamingChannel<K> channel, K pattern) {
+    public RedisFuture<Long> keys(KeyStreamingChannel<K> channel, String pattern) {
         return dispatch(commandBuilder.keys(channel, pattern));
     }
 
diff --git a/src/main/java/io/lettuce/core/AbstractRedisReactiveCommands.java b/src/main/java/io/lettuce/core/AbstractRedisReactiveCommands.java
@@ -1893,12 +1893,12 @@ public Mono<Map<V, Double>> vsimWithScore(K key, VSimArgs args, V element) {
     }
 
     @Override
-    public Flux<K> keys(K pattern) {
+    public Flux<K> keys(String pattern) {
         return createDissolvingFlux(() -> commandBuilder.keys(pattern));
     }
 
     @Override
-    public Mono<Long> keys(KeyStreamingChannel<K> channel, K pattern) {
+    public Mono<Long> keys(KeyStreamingChannel<K> channel, String pattern) {
         return createMono(() -> commandBuilder.keys(channel, pattern));
     }
 
diff --git a/src/main/java/io/lettuce/core/RedisCommandBuilder.java b/src/main/java/io/lettuce/core/RedisCommandBuilder.java
@@ -1900,17 +1900,19 @@ Command<K, V, String> info(String section) {
         return createCommand(CommandType.INFO, new StatusOutput<>(codec), args);
     }
 
-    Command<K, V, List<K>> keys(K pattern) {
+    Command<K, V, List<K>> keys(String pattern) {
         LettuceAssert.notNull(pattern, "Pattern " + MUST_NOT_BE_NULL);
 
-        return createCommand(KEYS, new KeyListOutput<>(codec), pattern);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addGlobalPattern(pattern);
+        return createCommand(KEYS, new GlobPatternOutput<>(codec), args);
     }
 
-    Command<K, V, Long> keys(KeyStreamingChannel<K> channel, K pattern) {
+    Command<K, V, Long> keys(KeyStreamingChannel<K> channel, String pattern) {
         LettuceAssert.notNull(pattern, "Pattern " + MUST_NOT_BE_NULL);
         notNull(channel);
 
-        return createCommand(KEYS, new KeyStreamingOutput<>(codec, channel), pattern);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addGlobalPattern(pattern);
+        return createCommand(KEYS, new GlobPatternStreamingOutput<>(codec, channel), args);
     }
 
     Command<K, V, Date> lastsave() {
diff --git a/src/main/java/io/lettuce/core/api/RedisKeyCommands.java b/src/main/java/io/lettuce/core/api/RedisKeyCommands.java
@@ -219,7 +219,7 @@ public interface RedisKeyCommands<K, V> {
      * @param pattern the pattern type: patternkey (pattern).
      * @return List&lt;K&gt; array-reply list of keys matching {@code pattern}.
      */
-    List<K> keys(K pattern);
+    List<K> keys(String pattern);
 
     /**
      * Find all keys matching the given pattern.
@@ -228,7 +228,7 @@ public interface RedisKeyCommands<K, V> {
      * @param pattern the pattern.
      * @return Long array-reply list of keys matching {@code pattern}.
      */
-    Long keys(KeyStreamingChannel<K> channel, K pattern);
+    Long keys(KeyStreamingChannel<K> channel, String pattern);
 
     /**
      * Atomically transfer a key from a Redis instance to another one.
diff --git a/src/main/java/io/lettuce/core/api/async/RedisKeyAsyncCommands.java b/src/main/java/io/lettuce/core/api/async/RedisKeyAsyncCommands.java
@@ -220,7 +220,7 @@ public interface RedisKeyAsyncCommands<K, V> {
      * @param pattern the pattern type: patternkey (pattern).
      * @return List&lt;K&gt; array-reply list of keys matching {@code pattern}.
      */
-    RedisFuture<List<K>> keys(K pattern);
+    RedisFuture<List<K>> keys(String pattern);
 
     /**
      * Find all keys matching the given pattern.
@@ -229,7 +229,7 @@ public interface RedisKeyAsyncCommands<K, V> {
      * @param pattern the pattern.
      * @return Long array-reply list of keys matching {@code pattern}.
      */
-    RedisFuture<Long> keys(KeyStreamingChannel<K> channel, K pattern);
+    RedisFuture<Long> keys(KeyStreamingChannel<K> channel, String pattern);
 
     /**
      * Atomically transfer a key from a Redis instance to another one.
diff --git a/src/main/java/io/lettuce/core/api/reactive/RedisKeyReactiveCommands.java b/src/main/java/io/lettuce/core/api/reactive/RedisKeyReactiveCommands.java
@@ -230,7 +230,7 @@ public interface RedisKeyReactiveCommands<K, V> {
      * @param pattern the pattern type: patternkey (pattern).
      * @return K array-reply list of keys matching {@code pattern}.
      */
-    Flux<K> keys(K pattern);
+    Flux<K> keys(String pattern);
 
     /**
      * Find all keys matching the given pattern.
@@ -242,7 +242,7 @@ public interface RedisKeyReactiveCommands<K, V> {
      *             {@link #keys}.
      */
     @Deprecated
-    Mono<Long> keys(KeyStreamingChannel<K> channel, K pattern);
+    Mono<Long> keys(KeyStreamingChannel<K> channel, String pattern);
 
     /**
      * Atomically transfer a key from a Redis instance to another one.
diff --git a/src/main/java/io/lettuce/core/api/sync/RedisKeyCommands.java b/src/main/java/io/lettuce/core/api/sync/RedisKeyCommands.java
@@ -229,7 +229,7 @@ public interface RedisKeyCommands<K, V> {
      * @param pattern the pattern type: patternkey (pattern).
      * @return List&lt;K&gt; array-reply list of keys matching {@code pattern}.
      */
-    List<K> keys(K pattern);
+    List<K> keys(String pattern);
 
     /**
      * Find all keys matching the given pattern.
@@ -238,7 +238,7 @@ public interface RedisKeyCommands<K, V> {
      * @param pattern the pattern.
      * @return Long array-reply list of keys matching {@code pattern}.
      */
-    Long keys(KeyStreamingChannel<K> channel, K pattern);
+    Long keys(KeyStreamingChannel<K> channel, String pattern);
 
     /**
      * Atomically transfer a key from a Redis instance to another one.
diff --git a/src/main/java/io/lettuce/core/cluster/RedisAdvancedClusterAsyncCommandsImpl.java b/src/main/java/io/lettuce/core/cluster/RedisAdvancedClusterAsyncCommandsImpl.java
@@ -276,7 +276,7 @@ public RedisFuture<String> flushdb(FlushMode flushMode) {
     }
 
     @Override
-    public RedisFuture<List<K>> keys(K pattern) {
+    public RedisFuture<List<K>> keys(String pattern) {
 
         Map<String, CompletableFuture<List<K>>> executions = executeOnUpstream(commands -> commands.keys(pattern));
 
@@ -290,7 +290,7 @@ public RedisFuture<List<K>> keys(K pattern) {
     }
 
     @Override
-    public RedisFuture<Long> keys(KeyStreamingChannel<K> channel, K pattern) {
+    public RedisFuture<Long> keys(KeyStreamingChannel<K> channel, String pattern) {
 
         Map<String, CompletableFuture<Long>> executions = executeOnUpstream(commands -> commands.keys(channel, pattern));
         return MultiNodeExecution.aggregateAsync(executions);
diff --git a/src/main/java/io/lettuce/core/cluster/RedisAdvancedClusterReactiveCommandsImpl.java b/src/main/java/io/lettuce/core/cluster/RedisAdvancedClusterReactiveCommandsImpl.java
@@ -265,14 +265,14 @@ public Mono<String> flushdb(FlushMode flushMode) {
     }
 
     @Override
-    public Flux<K> keys(K pattern) {
+    public Flux<K> keys(String pattern) {
 
         Map<String, Publisher<K>> publishers = executeOnUpstream(commands -> commands.keys(pattern));
         return Flux.merge(publishers.values());
     }
 
     @Override
-    public Mono<Long> keys(KeyStreamingChannel<K> channel, K pattern) {
+    public Mono<Long> keys(KeyStreamingChannel<K> channel, String pattern) {
 
         Map<String, Publisher<Long>> publishers = executeOnUpstream(commands -> commands.keys(channel, pattern));
         return Flux.merge(publishers.values()).reduce((accu, next) -> accu + next);
diff --git a/src/main/java/io/lettuce/core/cluster/api/async/NodeSelectionKeyAsyncCommands.java b/src/main/java/io/lettuce/core/cluster/api/async/NodeSelectionKeyAsyncCommands.java
@@ -229,7 +229,7 @@ public interface NodeSelectionKeyAsyncCommands<K, V> {
      * @param pattern the pattern type: patternkey (pattern).
      * @return List&lt;K&gt; array-reply list of keys matching {@code pattern}.
      */
-    AsyncExecutions<List<K>> keys(K pattern);
+    AsyncExecutions<List<K>> keys(String pattern);
 
     /**
      * Find all keys matching the given pattern.
@@ -238,7 +238,7 @@ public interface NodeSelectionKeyAsyncCommands<K, V> {
      * @param pattern the pattern.
      * @return Long array-reply list of keys matching {@code pattern}.
      */
-    AsyncExecutions<Long> keys(KeyStreamingChannel<K> channel, K pattern);
+    AsyncExecutions<Long> keys(KeyStreamingChannel<K> channel, String pattern);
 
     /**
      * Atomically transfer a key from a Redis instance to another one.
diff --git a/src/main/java/io/lettuce/core/cluster/api/async/RedisAdvancedClusterAsyncCommands.java b/src/main/java/io/lettuce/core/cluster/api/async/RedisAdvancedClusterAsyncCommands.java
@@ -287,19 +287,19 @@ default AsyncNodeSelection<K, V> all() {
      *
      * @param pattern the pattern type: patternkey (pattern)
      * @return List&lt;K&gt; array-reply list of keys matching {@code pattern}.
-     * @see RedisKeyAsyncCommands#keys(Object)
+     * @see RedisKeyAsyncCommands#keys(String)
      */
-    RedisFuture<List<K>> keys(K pattern);
+    RedisFuture<List<K>> keys(String pattern);
 
     /**
      * Find all keys matching the given pattern on all cluster upstream nodes.
      *
      * @param channel the channel
      * @param pattern the pattern
      * @return Long array-reply list of keys matching {@code pattern}.
-     * @see RedisKeyAsyncCommands#keys(KeyStreamingChannel, Object)
+     * @see RedisKeyAsyncCommands#keys(KeyStreamingChannel, String)
      */
-    RedisFuture<Long> keys(KeyStreamingChannel<K> channel, K pattern);
+    RedisFuture<Long> keys(KeyStreamingChannel<K> channel, String pattern);
 
     /**
      * Return a random key from the keyspace on a random master.
diff --git a/src/main/java/io/lettuce/core/cluster/api/reactive/RedisAdvancedClusterReactiveCommands.java b/src/main/java/io/lettuce/core/cluster/api/reactive/RedisAdvancedClusterReactiveCommands.java
@@ -181,19 +181,19 @@ public interface RedisAdvancedClusterReactiveCommands<K, V> extends RedisCluster
      *
      * @param pattern the pattern type: patternkey (pattern)
      * @return List&lt;K&gt; array-reply list of keys matching {@code pattern}.
-     * @see RedisKeyReactiveCommands#keys(Object)
+     * @see RedisKeyReactiveCommands#keys(String)
      */
-    Flux<K> keys(K pattern);
+    Flux<K> keys(String pattern);
 
     /**
      * Find all keys matching the given pattern on all cluster masters.
      *
      * @param channel the channel
      * @param pattern the pattern
      * @return Long array-reply list of keys matching {@code pattern}.
-     * @see RedisKeyReactiveCommands#keys(KeyStreamingChannel, Object)
+     * @see RedisKeyReactiveCommands#keys(KeyStreamingChannel, String)
      */
-    Mono<Long> keys(KeyStreamingChannel<K> channel, K pattern);
+    Mono<Long> keys(KeyStreamingChannel<K> channel, String pattern);
 
     /**
      * Return a random key from the keyspace on a random master.
diff --git a/src/main/java/io/lettuce/core/cluster/api/sync/NodeSelectionKeyCommands.java b/src/main/java/io/lettuce/core/cluster/api/sync/NodeSelectionKeyCommands.java
@@ -229,7 +229,7 @@ public interface NodeSelectionKeyCommands<K, V> {
      * @param pattern the pattern type: patternkey (pattern).
      * @return List&lt;K&gt; array-reply list of keys matching {@code pattern}.
      */
-    Executions<List<K>> keys(K pattern);
+    Executions<List<K>> keys(String pattern);
 
     /**
      * Find all keys matching the given pattern.
@@ -238,7 +238,7 @@ public interface NodeSelectionKeyCommands<K, V> {
      * @param pattern the pattern.
      * @return Long array-reply list of keys matching {@code pattern}.
      */
-    Executions<Long> keys(KeyStreamingChannel<K> channel, K pattern);
+    Executions<Long> keys(KeyStreamingChannel<K> channel, String pattern);
 
     /**
      * Atomically transfer a key from a Redis instance to another one.
diff --git a/src/main/java/io/lettuce/core/cluster/api/sync/RedisAdvancedClusterCommands.java b/src/main/java/io/lettuce/core/cluster/api/sync/RedisAdvancedClusterCommands.java
@@ -284,19 +284,19 @@ default NodeSelection<K, V> all() {
      *
      * @param pattern the pattern type: patternkey (pattern)
      * @return List&lt;K&gt; array-reply list of keys matching {@code pattern}.
-     * @see RedisKeyCommands#keys(Object)
+     * @see RedisKeyCommands#keys(String)
      */
-    List<K> keys(K pattern);
+    List<K> keys(String pattern);
 
     /**
      * Find all keys matching the given pattern on all cluster upstream nodes.
      *
      * @param channel the channel
      * @param pattern the pattern
      * @return Long array-reply list of keys matching {@code pattern}.
-     * @see RedisKeyCommands#keys(KeyStreamingChannel, Object)
+     * @see RedisKeyCommands#keys(KeyStreamingChannel, String)
      */
-    Long keys(KeyStreamingChannel<K> channel, K pattern);
+    Long keys(KeyStreamingChannel<K> channel, String pattern);
 
     /**
      * Return a random key from the keyspace on a random master.
diff --git a/src/main/java/io/lettuce/core/output/GlobPatternOutput.java b/src/main/java/io/lettuce/core/output/GlobPatternOutput.java
@@ -0,0 +1,58 @@
+package io.lettuce.core.output;
+
+import io.lettuce.core.codec.RedisCodec;
+import io.lettuce.core.internal.LettuceAssert;
+
+import java.nio.ByteBuffer;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * Glob Pattern output.
+ *
+ * @param <K> Key type.
+ * @param <V> Value type.
+ *
+ * @author Seonghwan Lee
+ */
+public class GlobPatternOutput<K, V> extends CommandOutput<K, V, List<K>> implements StreamingOutput<K> {
+
+    private boolean initialized;
+
+    private Subscriber<K> subscriber;
+
+    public GlobPatternOutput(RedisCodec<K, V> codec) {
+        super(codec, Collections.emptyList());
+        setSubscriber(ListSubscriber.instance());
+    }
+
+    @Override
+    public void set(ByteBuffer bytes) {
+        if (bytes == null) {
+            return;
+        }
+
+        subscriber.onNext(output, bytes == null ? null : codec.decodeKey(bytes));
+    }
+
+    @Override
+    public void multi(int count) {
+
+        if (!initialized) {
+            output = OutputFactory.newList(count);
+            initialized = true;
+        }
+    }
+
+    @Override
+    public void setSubscriber(Subscriber<K> subscriber) {
+        LettuceAssert.notNull(subscriber, "Subscriber must not be null");
+        this.subscriber = subscriber;
+    }
+
+    @Override
+    public Subscriber<K> getSubscriber() {
+        return subscriber;
+    }
+
+}
diff --git a/src/main/java/io/lettuce/core/output/GlobPatternStreamingOutput.java b/src/main/java/io/lettuce/core/output/GlobPatternStreamingOutput.java
@@ -0,0 +1,30 @@
+package io.lettuce.core.output;
+
+import io.lettuce.core.codec.RedisCodec;
+
+import java.nio.ByteBuffer;
+
+/**
+ * Streaming-Output of Glob Patterns. Returns the count of all Glob Patterns (including null).
+ *
+ * @param <K> Key type.
+ * @param <V> Value type.
+ * @author Seonghwan Lee
+ */
+public class GlobPatternStreamingOutput<K, V> extends CommandOutput<K, V, Long> {
+
+    private final KeyStreamingChannel<K> channel;
+
+    public GlobPatternStreamingOutput(RedisCodec<K, V> codec, KeyStreamingChannel<K> channel) {
+        super(codec, Long.valueOf(0));
+        this.channel = channel;
+    }
+
+    @Override
+    public void set(ByteBuffer bytes) {
+
+        channel.onKey(bytes == null ? null : codec.decodeKey(bytes));
+        output = output.longValue() + 1;
+    }
+
+}
diff --git a/src/main/java/io/lettuce/core/protocol/CommandArgs.java b/src/main/java/io/lettuce/core/protocol/CommandArgs.java
diff --git a/src/main/kotlin/io/lettuce/core/api/coroutines/RedisKeyCoroutinesCommands.kt b/src/main/kotlin/io/lettuce/core/api/coroutines/RedisKeyCoroutinesCommands.kt
diff --git a/src/main/kotlin/io/lettuce/core/api/coroutines/RedisKeyCoroutinesCommandsImpl.kt b/src/main/kotlin/io/lettuce/core/api/coroutines/RedisKeyCoroutinesCommandsImpl.kt
diff --git a/src/test/java/io/lettuce/core/CustomCodecIntegrationTests.java b/src/test/java/io/lettuce/core/CustomCodecIntegrationTests.java

Original file line number	Diff line number	Diff line change
`@@ -1826,12 +1826,12 @@ public RedisFuture<Map<V, Double>> vsimWithScore(K key, VSimArgs args, V element`
`1826`	`1826`	`}`
`1827`	`1827`
`1828`	`1828`	`@Override`
`1829`		`- public RedisFuture<List<K>> keys(K pattern) {`
	`1829`	`+ public RedisFuture<List<K>> keys(String pattern) {`
`1830`	`1830`	`return dispatch(commandBuilder.keys(pattern));`
`1831`	`1831`	`}`
`1832`	`1832`
`1833`	`1833`	`@Override`
`1834`		`- public RedisFuture<Long> keys(KeyStreamingChannel<K> channel, K pattern) {`
	`1834`	`+ public RedisFuture<Long> keys(KeyStreamingChannel<K> channel, String pattern) {`
`1835`	`1835`	`return dispatch(commandBuilder.keys(channel, pattern));`
`1836`	`1836`	`}`
`1837`	`1837`
Original file line number	Diff line number	Diff line change
`@@ -1893,12 +1893,12 @@ public Mono<Map<V, Double>> vsimWithScore(K key, VSimArgs args, V element) {`
`1893`	`1893`	`}`
`1894`	`1894`
`1895`	`1895`	`@Override`
`1896`		`- public Flux<K> keys(K pattern) {`
	`1896`	`+ public Flux<K> keys(String pattern) {`
`1897`	`1897`	`return createDissolvingFlux(() -> commandBuilder.keys(pattern));`
`1898`	`1898`	`}`
`1899`	`1899`
`1900`	`1900`	`@Override`
`1901`		`- public Mono<Long> keys(KeyStreamingChannel<K> channel, K pattern) {`
	`1901`	`+ public Mono<Long> keys(KeyStreamingChannel<K> channel, String pattern) {`
`1902`	`1902`	`return createMono(() -> commandBuilder.keys(channel, pattern));`
`1903`	`1903`	`}`
`1904`	`1904`
Original file line number	Diff line number	Diff line change
`@@ -1900,17 +1900,19 @@ Command<K, V, String> info(String section) {`
`1900`	`1900`	`return createCommand(CommandType.INFO, new StatusOutput<>(codec), args);`
`1901`	`1901`	`}`
`1902`	`1902`
`1903`		`- Command<K, V, List<K>> keys(K pattern) {`
	`1903`	`+ Command<K, V, List<K>> keys(String pattern) {`
`1904`	`1904`	`LettuceAssert.notNull(pattern, "Pattern " + MUST_NOT_BE_NULL);`
`1905`	`1905`
`1906`		`- return createCommand(KEYS, new KeyListOutput<>(codec), pattern);`
	`1906`	`+ CommandArgs<K, V> args = new CommandArgs<>(codec).addGlobalPattern(pattern);`
	`1907`	`+ return createCommand(KEYS, new GlobPatternOutput<>(codec), args);`
`1907`	`1908`	`}`
`1908`	`1909`
`1909`		`- Command<K, V, Long> keys(KeyStreamingChannel<K> channel, K pattern) {`
	`1910`	`+ Command<K, V, Long> keys(KeyStreamingChannel<K> channel, String pattern) {`
`1910`	`1911`	`LettuceAssert.notNull(pattern, "Pattern " + MUST_NOT_BE_NULL);`
`1911`	`1912`	`notNull(channel);`
`1912`	`1913`
`1913`		`- return createCommand(KEYS, new KeyStreamingOutput<>(codec, channel), pattern);`
	`1914`	`+ CommandArgs<K, V> args = new CommandArgs<>(codec).addGlobalPattern(pattern);`
	`1915`	`+ return createCommand(KEYS, new GlobPatternStreamingOutput<>(codec, channel), args);`
`1914`	`1916`	`}`
`1915`	`1917`
`1916`	`1918`	`Command<K, V, Date> lastsave() {`
Original file line number	Diff line number	Diff line change
`@@ -276,7 +276,7 @@ public RedisFuture<String> flushdb(FlushMode flushMode) {`
`276`	`276`	`}`
`277`	`277`
`278`	`278`	`@Override`
`279`		`- public RedisFuture<List<K>> keys(K pattern) {`
	`279`	`+ public RedisFuture<List<K>> keys(String pattern) {`
`280`	`280`
`281`	`281`	`Map<String, CompletableFuture<List<K>>> executions = executeOnUpstream(commands -> commands.keys(pattern));`
`282`	`282`
`@@ -290,7 +290,7 @@ public RedisFuture<List<K>> keys(K pattern) {`
`290`	`290`	`}`
`291`	`291`
`292`	`292`	`@Override`
`293`		`- public RedisFuture<Long> keys(KeyStreamingChannel<K> channel, K pattern) {`
	`293`	`+ public RedisFuture<Long> keys(KeyStreamingChannel<K> channel, String pattern) {`
`294`	`294`
`295`	`295`	`Map<String, CompletableFuture<Long>> executions = executeOnUpstream(commands -> commands.keys(channel, pattern));`
`296`	`296`	`return MultiNodeExecution.aggregateAsync(executions);`
Original file line number	Diff line number	Diff line change
`@@ -265,14 +265,14 @@ public Mono<String> flushdb(FlushMode flushMode) {`
`265`	`265`	`}`
`266`	`266`
`267`	`267`	`@Override`
`268`		`- public Flux<K> keys(K pattern) {`
	`268`	`+ public Flux<K> keys(String pattern) {`
`269`	`269`
`270`	`270`	`Map<String, Publisher<K>> publishers = executeOnUpstream(commands -> commands.keys(pattern));`
`271`	`271`	`return Flux.merge(publishers.values());`
`272`	`272`	`}`
`273`	`273`
`274`	`274`	`@Override`
`275`		`- public Mono<Long> keys(KeyStreamingChannel<K> channel, K pattern) {`
	`275`	`+ public Mono<Long> keys(KeyStreamingChannel<K> channel, String pattern) {`
`276`	`276`
`277`	`277`	`Map<String, Publisher<Long>> publishers = executeOnUpstream(commands -> commands.keys(channel, pattern));`
`278`	`278`	`return Flux.merge(publishers.values()).reduce((accu, next) -> accu + next);`