Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Sign up
Appearance settings

Commit 5b033a1

Browse files
Add a method that returns the number of existing keys
1 parent aa34126 commit 5b033a1

File tree

6 files changed

+72
-29
lines changed

6 files changed

+72
-29
lines changed

‎src/main/java/org/springframework/data/redis/connection/ReactiveKeyCommands.java‎

Lines changed: 4 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -176,19 +176,13 @@ default Mono<Boolean> exists(ByteBuffer key) {
176176
return exists(Mono.just(new KeyCommand(key))).next().map(BooleanResponse::getOutput);
177177
}
178178
/**
179-
* Determine if given all {@literal keys} exist.
179+
* Determine the number of given {@literal keys} that exist.
180180
*
181181
* @param keys must not be {@literal null} or {@literal empty}.
182-
* @return {@link Mono} emitting {@literal true} if all keys exist.
183-
* @see <a href="https://redis.io/commands/exists">Redis Documentation: EXISTS</a>
182+
* @return {@link Mono} emitting {@literal the number of existing keys}.
183+
* @see <a href="https://redis.io/docs/commands/exists/">Redis Documentation: EXISTS</a>
184184
*/
185-
default Mono<Boolean> exists(List<ByteBuffer> keys) {
186-
187-
Assert.notNull(keys, "Keys must not be null");
188-
Assert.notEmpty(keys, "Keys must not be empty");
189-
190-
return exists(Flux.fromIterable(keys).map(KeyCommand::new)).all(BooleanResponse::getOutput);
191-
}
185+
Mono<Long> exists(List<ByteBuffer> keys);
192186

193187
/**
194188
* Determine if given {@literal key} exists.

‎src/main/java/org/springframework/data/redis/connection/lettuce/LettuceReactiveKeyCommands.java‎

Lines changed: 8 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -319,4 +319,12 @@ public Mono<Duration> idletime(ByteBuffer key) {
319319
public Mono<Long> refcount(ByteBuffer key) {
320320
return connection.execute(cmd -> cmd.objectRefcount(key)).next();
321321
}
322+
323+
@Override
324+
public Mono<Long> exists(List<ByteBuffer> keys) {
325+
Assert.notNull(keys, "Key list must not be null");
326+
Assert.notEmpty(keys, "Key list must not be empty");
327+
328+
return connection.execute(cmd -> cmd.exists(keys.toArray(ByteBuffer[]::new))).next();
329+
}
322330
}

‎src/main/java/org/springframework/data/redis/core/ReactiveRedisOperations.java‎

Lines changed: 10 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -22,6 +22,7 @@
2222
import java.time.Duration;
2323
import java.time.Instant;
2424
import java.util.Arrays;
25+
import java.util.Collection;
2526
import java.util.Collections;
2627
import java.util.List;
2728

@@ -402,6 +403,15 @@ default Flux<K> scan() {
402403
*/
403404
Mono<Duration> getExpire(K key);
404405

406+
/**
407+
* Get the number of given {@code keys} that exists.
408+
*
409+
* @param keys must not be {@literal null} or {@literal empty}.
410+
* @return the number of existing keys in redis. 0 if there are no existing keys.
411+
* @see <a href="https://redis.io/docs/commands/exists/">Redis Documentation: EXISTS</a>
412+
*/
413+
Mono<Long> countExistingKeys(Collection<K> keys);
414+
405415
// -------------------------------------------------------------------------
406416
// Methods dealing with Redis Lua scripts
407417
// -------------------------------------------------------------------------

‎src/main/java/org/springframework/data/redis/core/ReactiveRedisTemplate.java‎

Lines changed: 20 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -23,6 +23,7 @@
2323
import java.time.Duration;
2424
import java.time.Instant;
2525
import java.util.Arrays;
26+
import java.util.Collection;
2627
import java.util.List;
2728
import java.util.stream.Collectors;
2829

@@ -489,6 +490,14 @@ public Mono<Boolean> move(K key, int dbIndex) {
489490
return doCreateMono(connection -> connection.keyCommands().move(rawKey(key), dbIndex));
490491
}
491492

493+
@Override
494+
public Mono<Long> countExistingKeys(Collection<K> keys) {
495+
Assert.notNull(keys, "Keys must not be null");
496+
497+
ByteBuffer[] rawKeys = rawKeys(keys);
498+
return doCreateMono(connection -> connection.keyCommands().exists(Arrays.asList(rawKeys)));
499+
}
500+
492501
// -------------------------------------------------------------------------
493502
// Methods dealing with Redis Lua scripts
494503
// -------------------------------------------------------------------------
@@ -672,6 +681,17 @@ private ByteBuffer rawKey(K key) {
672681
return getSerializationContext().getKeySerializationPair().getWriter().write(key);
673682
}
674683

684+
private ByteBuffer[] rawKeys(Collection<K> keys) {
685+
final ByteBuffer[] rawKeys = new ByteBuffer[keys.size()];
686+
687+
int i = 0;
688+
for (K key : keys) {
689+
rawKeys[i++] = rawKey(key);
690+
}
691+
692+
return rawKeys;
693+
}
694+
675695
@Nullable
676696
private K readKey(ByteBuffer buffer) {
677697
return getSerializationContext().getKeySerializationPair().getReader().read(buffer);

‎src/test/java/org/springframework/data/redis/connection/lettuce/LettuceReactiveKeyCommandsIntegrationTests.java‎

Lines changed: 9 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -67,27 +67,21 @@ void existsShouldReturnFalseForNonExistingKeys() {
6767
}
6868

6969
@ParameterizedRedisTest
70-
void existsShouldReturnTrueWhenKeysExist() {
71-
72-
nativeCommands.set(KEY_1, VALUE_1);
73-
nativeCommands.set(KEY_2, VALUE_2);
70+
void existsKeyReturnsKeyCount() {
71+
nativeCommands.set(KEY_1, "1000");
72+
nativeCommands.set(KEY_2, "2000");
73+
nativeCommands.set(KEY_3, "3000");
7474

75-
connection.keyCommands().exists(Arrays.asList(KEY_1_BBUFFER, KEY_2_BBUFFER)).as(StepVerifier::create)
76-
.expectNext(true)
77-
.verifyComplete();
75+
connection.keyCommands().exists(List.of(KEY_1_BBUFFER, KEY_2_BBUFFER, KEY_3_BBUFFER)).as(StepVerifier::create)
76+
.expectNext(3L).verifyComplete();
7877
}
7978

8079
@ParameterizedRedisTest
81-
void existsShouldReturnFalseWhenKeysDoNotExist() {
82-
83-
nativeCommands.set(KEY_1, VALUE_1);
84-
85-
connection.keyCommands().exists(Arrays.asList(KEY_1_BBUFFER, KEY_2_BBUFFER)).as(StepVerifier::create)
86-
.expectNext(false) //
87-
.verifyComplete();
80+
void existsKeyReturnsZeroWhenKeyDoesNotExist() {
81+
connection.keyCommands().exists(List.of(KEY_1_BBUFFER, KEY_2_BBUFFER, KEY_3_BBUFFER)).as(StepVerifier::create)
82+
.expectNext(0L).verifyComplete();
8883
}
8984

90-
9185
@ParameterizedRedisTest // DATAREDIS-525
9286
void typeShouldReturnTypeCorrectly() {
9387

‎src/test/java/org/springframework/data/redis/core/ReactiveRedisTemplateIntegrationTests.java‎

Lines changed: 21 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -24,10 +24,7 @@
2424

2525
import java.time.Duration;
2626
import java.time.Instant;
27-
import java.util.Collection;
28-
import java.util.Collections;
29-
import java.util.HashMap;
30-
import java.util.Map;
27+
import java.util.*;
3128
import java.util.function.Function;
3229

3330
import org.junit.jupiter.api.BeforeEach;
@@ -544,4 +541,24 @@ void listenToPatternLaterShouldReceiveChannelMessagesCorrectly() {
544541
.thenCancel() //
545542
.verify(Duration.ofSeconds(3));
546543
}
544+
545+
@ParameterizedRedisTest
546+
void countExistingKeysIfValidKeyExists() {
547+
548+
K key = keyFactory.instance();
549+
K key2 = keyFactory.instance();
550+
K key3 = keyFactory.instance();
551+
552+
redisTemplate.opsForValue().set(key, valueFactory.instance()).as(StepVerifier::create).expectNext(true).verifyComplete();
553+
redisTemplate.opsForValue().set(key2, valueFactory.instance()).as(StepVerifier::create).expectNext(true).verifyComplete();
554+
redisTemplate.opsForValue().set(key3, valueFactory.instance()).as(StepVerifier::create).expectNext(true).verifyComplete();
555+
556+
redisTemplate.countExistingKeys(Arrays.asList(key, key2, key3)).as(StepVerifier::create).expectNext(3L).verifyComplete();
557+
}
558+
559+
@ParameterizedRedisTest
560+
void countExistingKeysIfNotValidKeyExists() {
561+
K key = keyFactory.instance();
562+
redisTemplate.countExistingKeys(List.of(key)).as(StepVerifier::create).expectNext(0L).verifyComplete();
563+
}
547564
}

0 commit comments

Comments
(0)

AltStyle によって変換されたページ (->オリジナル) /