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 5635dac

Browse files
Expand bitwise operations with DIFF, DIFF1, ANDOR, ONE.
Signed-off-by: viktoriya.kutsarova <viktoriya.kutsarova@redis.com>
1 parent fc93414 commit 5635dac

14 files changed

+686
-3
lines changed

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

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1289,7 +1289,7 @@ default Mono<Long> bitPos(ByteBuffer key, boolean bit, Range<Long> range) {
12891289
}
12901290

12911291
/**
1292-
* Emmit the the position of the first bit set to given {@code bit} in a string. Get the length of the value stored at
1292+
* Emit the position of the first bit set to given {@code bit} in a string. Get the length of the value stored at
12931293
* {@literal key}.
12941294
*
12951295
* @param commands must not be {@literal null}.

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

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -38,7 +38,7 @@
3838
public interface RedisStringCommands {
3939

4040
enum BitOperation {
41-
AND, OR, XOR, NOT;
41+
AND, OR, XOR, NOT, DIFF, DIFF1, ANDOR, ONE;
4242
}
4343

4444
/**

‎src/main/java/org/springframework/data/redis/connection/jedis/JedisConverters.java‎

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -285,6 +285,10 @@ public static BitOP toBitOp(BitOperation bitOp) {
285285
case OR -> BitOP.OR;
286286
case NOT -> BitOP.NOT;
287287
case XOR -> BitOP.XOR;
288+
case DIFF -> BitOP.DIFF;
289+
case DIFF1 -> BitOP.DIFF1;
290+
case ANDOR -> BitOP.ANDOR;
291+
case ONE -> BitOP.ONE;
288292
};
289293
}
290294

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

Lines changed: 5 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -22,6 +22,7 @@
2222
import reactor.core.publisher.Mono;
2323

2424
import java.nio.ByteBuffer;
25+
import java.util.Arrays;
2526
import java.util.List;
2627
import java.util.stream.Collectors;
2728

@@ -368,7 +369,10 @@ public Flux<NumericResponse<BitOpCommand, Long>> bitOp(Publisher<BitOpCommand> c
368369
Assert.isTrue(sourceKeys.length == 1, "BITOP NOT does not allow more than 1 source key.");
369370
yield reactiveCommands.bitopNot(destinationKey, sourceKeys[0]);
370371
}
371-
default -> throw new IllegalArgumentException("Unknown BITOP '%s'".formatted(command.getBitOp()));
372+
case DIFF -> reactiveCommands.bitopDiff(destinationKey, sourceKeys[0], Arrays.copyOfRange(sourceKeys, 1, sourceKeys.length));
373+
case DIFF1 -> reactiveCommands.bitopDiff1(destinationKey, sourceKeys[0], Arrays.copyOfRange(sourceKeys, 1, sourceKeys.length));
374+
case ANDOR -> reactiveCommands.bitopAndor(destinationKey, sourceKeys[0], Arrays.copyOfRange(sourceKeys, 1, sourceKeys.length));
375+
case ONE -> reactiveCommands.bitopOne(destinationKey, sourceKeys);
372376
};
373377

374378
return result.map(value -> new NumericResponse<>(command, value));

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

Lines changed: 5 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -18,6 +18,7 @@
1818
import io.lettuce.core.BitFieldArgs;
1919
import io.lettuce.core.api.async.RedisStringAsyncCommands;
2020

21+
import java.util.Arrays;
2122
import java.util.List;
2223
import java.util.Map;
2324

@@ -307,6 +308,10 @@ public Long bitOp(@NonNull BitOperation op, byte @NonNull [] destination, byte @
307308
}
308309
yield it.bitopNot(destination, keys[0]);
309310
}
311+
case DIFF -> it.bitopDiff(destination, keys[0], Arrays.copyOfRange(keys, 1, keys.length));
312+
case DIFF1 -> it.bitopDiff1(destination, keys[0], Arrays.copyOfRange(keys, 1, keys.length));
313+
case ANDOR -> it.bitopAndor(destination, keys[0], Arrays.copyOfRange(keys, 1, keys.length));
314+
case ONE -> it.bitopOne(destination, keys);
310315
});
311316
}
312317

‎src/test/java/org/springframework/data/redis/connection/AbstractConnectionIntegrationTests.java‎

Lines changed: 36 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -571,6 +571,42 @@ void testBitOpNotMultipleSources() {
571571
.isThrownBy(() -> connection.bitOp(BitOperation.NOT, "key3", "key1", "key2"));
572572
}
573573

574+
@Test
575+
void testBitOpDiff() {
576+
577+
actual.add(connection.set("key1", "foobar"));
578+
actual.add(connection.set("key2", "abcdef"));
579+
actual.add(connection.bitOp(BitOperation.DIFF, "key3", "key1", "key2"));
580+
verifyResults(Arrays.asList(Boolean.TRUE, Boolean.TRUE, 6L));
581+
}
582+
583+
@Test
584+
void testBitOpDiff1() {
585+
586+
actual.add(connection.set("key1", "foobar"));
587+
actual.add(connection.set("key2", "abcdef"));
588+
actual.add(connection.bitOp(BitOperation.DIFF1, "key3", "key1", "key2"));
589+
verifyResults(Arrays.asList(Boolean.TRUE, Boolean.TRUE, 6L));
590+
}
591+
592+
@Test
593+
void testBitOpAndor() {
594+
595+
actual.add(connection.set("key1", "foo"));
596+
actual.add(connection.set("key2", "bar"));
597+
actual.add(connection.bitOp(BitOperation.ANDOR, "key3", "key1", "key2"));
598+
verifyResults(Arrays.asList(Boolean.TRUE, Boolean.TRUE, 3L));
599+
}
600+
601+
@Test
602+
void testBitOpOne() {
603+
604+
actual.add(connection.set("key1", "foo"));
605+
actual.add(connection.set("key2", "bar"));
606+
actual.add(connection.bitOp(BitOperation.ONE, "key3", "key1", "key2"));
607+
verifyResults(Arrays.asList(Boolean.TRUE, Boolean.TRUE, 3L));
608+
}
609+
574610
@Test
575611
@EnabledOnCommand("COPY")
576612
void testCopy() {

‎src/test/java/org/springframework/data/redis/connection/DefaultStringRedisConnectionPipelineTests.java‎

Lines changed: 84 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1010,6 +1010,90 @@ public void testBitOp() {
10101010
super.testBitOp();
10111011
}
10121012

1013+
@Test
1014+
public void testBitOpOrBytes() {
1015+
doReturn(Collections.singletonList(5L)).when(nativeConnection).closePipeline();
1016+
super.testBitOpOrBytes();
1017+
}
1018+
1019+
@Test
1020+
public void testBitOpOr() {
1021+
doReturn(Collections.singletonList(5L)).when(nativeConnection).closePipeline();
1022+
super.testBitOpOr();
1023+
}
1024+
1025+
@Test
1026+
public void testBitOpXorBytes() {
1027+
doReturn(Collections.singletonList(5L)).when(nativeConnection).closePipeline();
1028+
super.testBitOpXorBytes();
1029+
}
1030+
1031+
@Test
1032+
public void testBitOpXor() {
1033+
doReturn(Collections.singletonList(5L)).when(nativeConnection).closePipeline();
1034+
super.testBitOpXor();
1035+
}
1036+
1037+
@Test
1038+
public void testBitOpNotBytes() {
1039+
doReturn(Collections.singletonList(5L)).when(nativeConnection).closePipeline();
1040+
super.testBitOpNotBytes();
1041+
}
1042+
1043+
@Test
1044+
public void testBitOpNot() {
1045+
doReturn(Collections.singletonList(5L)).when(nativeConnection).closePipeline();
1046+
super.testBitOpNot();
1047+
}
1048+
1049+
@Test
1050+
public void testBitOpDiffBytes() {
1051+
doReturn(Collections.singletonList(5L)).when(nativeConnection).closePipeline();
1052+
super.testBitOpDiffBytes();
1053+
}
1054+
1055+
@Test
1056+
public void testBitOpDiff() {
1057+
doReturn(Collections.singletonList(5L)).when(nativeConnection).closePipeline();
1058+
super.testBitOpDiff();
1059+
}
1060+
1061+
@Test
1062+
public void testBitOpDiff1Bytes() {
1063+
doReturn(Collections.singletonList(5L)).when(nativeConnection).closePipeline();
1064+
super.testBitOpDiff1Bytes();
1065+
}
1066+
1067+
@Test
1068+
public void testBitOpDiff1() {
1069+
doReturn(Collections.singletonList(5L)).when(nativeConnection).closePipeline();
1070+
super.testBitOpDiff1();
1071+
}
1072+
1073+
@Test
1074+
public void testBitOpAndorBytes() {
1075+
doReturn(Collections.singletonList(5L)).when(nativeConnection).closePipeline();
1076+
super.testBitOpAndorBytes();
1077+
}
1078+
1079+
@Test
1080+
public void testBitOpAndor() {
1081+
doReturn(Collections.singletonList(5L)).when(nativeConnection).closePipeline();
1082+
super.testBitOpAndor();
1083+
}
1084+
1085+
@Test
1086+
public void testBitOpOneBytes() {
1087+
doReturn(Collections.singletonList(5L)).when(nativeConnection).closePipeline();
1088+
super.testBitOpOneBytes();
1089+
}
1090+
1091+
@Test
1092+
public void testBitOpOne() {
1093+
doReturn(Collections.singletonList(5L)).when(nativeConnection).closePipeline();
1094+
super.testBitOpOne();
1095+
}
1096+
10131097
@Test
10141098
public void testSUnionBytes() {
10151099
doReturn(Collections.singletonList(bytesSet)).when(nativeConnection).closePipeline();

‎src/test/java/org/springframework/data/redis/connection/DefaultStringRedisConnectionPipelineTxTests.java‎

Lines changed: 84 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1025,6 +1025,90 @@ public void testBitOp() {
10251025
super.testBitOp();
10261026
}
10271027

1028+
@Test
1029+
public void testBitOpOrBytes() {
1030+
doReturn(Collections.singletonList(Collections.singletonList(5L))).when(nativeConnection).closePipeline();
1031+
super.testBitOpOrBytes();
1032+
}
1033+
1034+
@Test
1035+
public void testBitOpOr() {
1036+
doReturn(Collections.singletonList(Collections.singletonList(5L))).when(nativeConnection).closePipeline();
1037+
super.testBitOpOr();
1038+
}
1039+
1040+
@Test
1041+
public void testBitOpXorBytes() {
1042+
doReturn(Collections.singletonList(Collections.singletonList(5L))).when(nativeConnection).closePipeline();
1043+
super.testBitOpXorBytes();
1044+
}
1045+
1046+
@Test
1047+
public void testBitOpXor() {
1048+
doReturn(Collections.singletonList(Collections.singletonList(5L))).when(nativeConnection).closePipeline();
1049+
super.testBitOpXor();
1050+
}
1051+
1052+
@Test
1053+
public void testBitOpNotBytes() {
1054+
doReturn(Collections.singletonList(Collections.singletonList(5L))).when(nativeConnection).closePipeline();
1055+
super.testBitOpNotBytes();
1056+
}
1057+
1058+
@Test
1059+
public void testBitOpNot() {
1060+
doReturn(Collections.singletonList(Collections.singletonList(5L))).when(nativeConnection).closePipeline();
1061+
super.testBitOpNot();
1062+
}
1063+
1064+
@Test
1065+
public void testBitOpDiffBytes() {
1066+
doReturn(Collections.singletonList(Collections.singletonList(5L))).when(nativeConnection).closePipeline();
1067+
super.testBitOpDiffBytes();
1068+
}
1069+
1070+
@Test
1071+
public void testBitOpDiff() {
1072+
doReturn(Collections.singletonList(Collections.singletonList(5L))).when(nativeConnection).closePipeline();
1073+
super.testBitOpDiff();
1074+
}
1075+
1076+
@Test
1077+
public void testBitOpDiff1Bytes() {
1078+
doReturn(Collections.singletonList(Collections.singletonList(5L))).when(nativeConnection).closePipeline();
1079+
super.testBitOpDiff1Bytes();
1080+
}
1081+
1082+
@Test
1083+
public void testBitOpDiff1() {
1084+
doReturn(Collections.singletonList(Collections.singletonList(5L))).when(nativeConnection).closePipeline();
1085+
super.testBitOpDiff1();
1086+
}
1087+
1088+
@Test
1089+
public void testBitOpAndorBytes() {
1090+
doReturn(Collections.singletonList(Collections.singletonList(5L))).when(nativeConnection).closePipeline();
1091+
super.testBitOpAndorBytes();
1092+
}
1093+
1094+
@Test
1095+
public void testBitOpAndor() {
1096+
doReturn(Collections.singletonList(Collections.singletonList(5L))).when(nativeConnection).closePipeline();
1097+
super.testBitOpAndor();
1098+
}
1099+
1100+
@Test
1101+
public void testBitOpOneBytes() {
1102+
doReturn(Collections.singletonList(Collections.singletonList(5L))).when(nativeConnection).closePipeline();
1103+
super.testBitOpOneBytes();
1104+
}
1105+
1106+
@Test
1107+
public void testBitOpOne() {
1108+
doReturn(Collections.singletonList(Collections.singletonList(5L))).when(nativeConnection).closePipeline();
1109+
super.testBitOpOne();
1110+
}
1111+
10281112
@Test
10291113
public void testSUnionBytes() {
10301114
doReturn(Collections.singletonList(Collections.singletonList(bytesSet))).when(nativeConnection).closePipeline();

‎src/test/java/org/springframework/data/redis/connection/DefaultStringRedisConnectionTests.java‎

Lines changed: 98 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1266,6 +1266,104 @@ public void testBitOp() {
12661266
verifyResults(Collections.singletonList(5L));
12671267
}
12681268

1269+
@Test
1270+
public void testBitOpOrBytes() {
1271+
doReturn(5L).when(nativeConnection).bitOp(BitOperation.OR, fooBytes, barBytes);
1272+
actual.add(connection.bitOp(BitOperation.OR, fooBytes, barBytes));
1273+
verifyResults(Collections.singletonList(5L));
1274+
}
1275+
1276+
@Test
1277+
public void testBitOpOr() {
1278+
doReturn(5L).when(nativeConnection).bitOp(BitOperation.OR, fooBytes, barBytes);
1279+
actual.add(connection.bitOp(BitOperation.OR, foo, bar));
1280+
verifyResults(Collections.singletonList(5L));
1281+
}
1282+
1283+
@Test
1284+
public void testBitOpXorBytes() {
1285+
doReturn(5L).when(nativeConnection).bitOp(BitOperation.XOR, fooBytes, barBytes);
1286+
actual.add(connection.bitOp(BitOperation.XOR, fooBytes, barBytes));
1287+
verifyResults(Collections.singletonList(5L));
1288+
}
1289+
1290+
@Test
1291+
public void testBitOpXor() {
1292+
doReturn(5L).when(nativeConnection).bitOp(BitOperation.XOR, fooBytes, barBytes);
1293+
actual.add(connection.bitOp(BitOperation.XOR, foo, bar));
1294+
verifyResults(Collections.singletonList(5L));
1295+
}
1296+
1297+
@Test
1298+
public void testBitOpNotBytes() {
1299+
doReturn(5L).when(nativeConnection).bitOp(BitOperation.NOT, fooBytes, barBytes);
1300+
actual.add(connection.bitOp(BitOperation.NOT, fooBytes, barBytes));
1301+
verifyResults(Collections.singletonList(5L));
1302+
}
1303+
1304+
@Test
1305+
public void testBitOpNot() {
1306+
doReturn(5L).when(nativeConnection).bitOp(BitOperation.NOT, fooBytes, barBytes);
1307+
actual.add(connection.bitOp(BitOperation.NOT, foo, bar));
1308+
verifyResults(Collections.singletonList(5L));
1309+
}
1310+
1311+
@Test
1312+
public void testBitOpDiffBytes() {
1313+
doReturn(5L).when(nativeConnection).bitOp(BitOperation.DIFF, fooBytes, barBytes);
1314+
actual.add(connection.bitOp(BitOperation.DIFF, fooBytes, barBytes));
1315+
verifyResults(Collections.singletonList(5L));
1316+
}
1317+
1318+
@Test
1319+
public void testBitOpDiff() {
1320+
doReturn(5L).when(nativeConnection).bitOp(BitOperation.DIFF, fooBytes, barBytes);
1321+
actual.add(connection.bitOp(BitOperation.DIFF, foo, bar));
1322+
verifyResults(Collections.singletonList(5L));
1323+
}
1324+
1325+
@Test
1326+
public void testBitOpDiff1Bytes() {
1327+
doReturn(5L).when(nativeConnection).bitOp(BitOperation.DIFF1, fooBytes, barBytes);
1328+
actual.add(connection.bitOp(BitOperation.DIFF1, fooBytes, barBytes));
1329+
verifyResults(Collections.singletonList(5L));
1330+
}
1331+
1332+
@Test
1333+
public void testBitOpDiff1() {
1334+
doReturn(5L).when(nativeConnection).bitOp(BitOperation.DIFF1, fooBytes, barBytes);
1335+
actual.add(connection.bitOp(BitOperation.DIFF1, foo, bar));
1336+
verifyResults(Collections.singletonList(5L));
1337+
}
1338+
1339+
@Test
1340+
public void testBitOpAndorBytes() {
1341+
doReturn(5L).when(nativeConnection).bitOp(BitOperation.ANDOR, fooBytes, barBytes);
1342+
actual.add(connection.bitOp(BitOperation.ANDOR, fooBytes, barBytes));
1343+
verifyResults(Collections.singletonList(5L));
1344+
}
1345+
1346+
@Test
1347+
public void testBitOpAndor() {
1348+
doReturn(5L).when(nativeConnection).bitOp(BitOperation.ANDOR, fooBytes, barBytes);
1349+
actual.add(connection.bitOp(BitOperation.ANDOR, foo, bar));
1350+
verifyResults(Collections.singletonList(5L));
1351+
}
1352+
1353+
@Test
1354+
public void testBitOpOneBytes() {
1355+
doReturn(5L).when(nativeConnection).bitOp(BitOperation.ONE, fooBytes, barBytes);
1356+
actual.add(connection.bitOp(BitOperation.ONE, fooBytes, barBytes));
1357+
verifyResults(Collections.singletonList(5L));
1358+
}
1359+
1360+
@Test
1361+
public void testBitOpOne() {
1362+
doReturn(5L).when(nativeConnection).bitOp(BitOperation.ONE, fooBytes, barBytes);
1363+
actual.add(connection.bitOp(BitOperation.ONE, foo, bar));
1364+
verifyResults(Collections.singletonList(5L));
1365+
}
1366+
12691367
@Test
12701368
public void testSUnionBytes() {
12711369
doReturn(bytesSet).when(nativeConnection).sUnion(fooBytes, barBytes);

0 commit comments

Comments
(0)

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