Skip to content

Commit 5635dac

Browse files
viktoriya-kutsarovaviktoriya-kutsarova
committed
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)