Expand bitwise operations with DIFF, DIFF1, ANDOR, ONE.

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

@@ -1289,7 +1289,7 @@ default Mono<Long> bitPos(ByteBuffer key, boolean bit, Range<Long> range) {
 	}
 
 	/**
-	 * Emmit the the position of the first bit set to given {@code bit} in a string. Get the length of the value stored at
+	 * Emit the position of the first bit set to given {@code bit} in a string. Get the length of the value stored at
 	 * {@literal key}.
 	 *
 	 * @param commands must not be {@literal null}.

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

@@ -38,7 +38,7 @@
 public interface RedisStringCommands {
 
 	enum BitOperation {
-		AND, OR, XOR, NOT;
+		AND, OR, XOR, NOT, DIFF, DIFF1, ANDOR, ONE;
 	}
 
 	/**

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

@@ -285,6 +285,10 @@ public static BitOP toBitOp(BitOperation bitOp) {
 			case OR -> BitOP.OR;
 			case NOT -> BitOP.NOT;
 			case XOR -> BitOP.XOR;
+			case DIFF -> BitOP.DIFF;
+			case DIFF1 ->  BitOP.DIFF1;
+			case ANDOR -> BitOP.ANDOR;
+			case ONE -> BitOP.ONE;
 		};
 	}
 

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

@@ -22,6 +22,7 @@
 import reactor.core.publisher.Mono;
 
 import java.nio.ByteBuffer;
+import java.util.Arrays;
 import java.util.List;
 import java.util.stream.Collectors;
 
@@ -368,7 +369,10 @@ public Flux<NumericResponse<BitOpCommand, Long>> bitOp(Publisher<BitOpCommand> c
 					Assert.isTrue(sourceKeys.length == 1, "BITOP NOT does not allow more than 1 source key.");
 					yield reactiveCommands.bitopNot(destinationKey, sourceKeys[0]);
 				}
-				default -> throw new IllegalArgumentException("Unknown BITOP '%s'".formatted(command.getBitOp()));
+				case DIFF -> reactiveCommands.bitopDiff(destinationKey, sourceKeys[0], Arrays.copyOfRange(sourceKeys, 1, sourceKeys.length));
+				case DIFF1 -> reactiveCommands.bitopDiff1(destinationKey, sourceKeys[0], Arrays.copyOfRange(sourceKeys, 1, sourceKeys.length));
+				case ANDOR -> reactiveCommands.bitopAndor(destinationKey, sourceKeys[0], Arrays.copyOfRange(sourceKeys, 1, sourceKeys.length));
+				case ONE -> reactiveCommands.bitopOne(destinationKey, sourceKeys);
 			};
 
 			return result.map(value -> new NumericResponse<>(command, value));

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

@@ -18,6 +18,7 @@
 import io.lettuce.core.BitFieldArgs;
 import io.lettuce.core.api.async.RedisStringAsyncCommands;
 
+import java.util.Arrays;
 import java.util.List;
 import java.util.Map;
 
@@ -307,6 +308,10 @@ public Long bitOp(@NonNull BitOperation op, byte @NonNull [] destination, byte @
 				}
 				yield it.bitopNot(destination, keys[0]);
 			}
+			case DIFF -> it.bitopDiff(destination, keys[0], Arrays.copyOfRange(keys, 1, keys.length));
+			case DIFF1 -> it.bitopDiff1(destination, keys[0], Arrays.copyOfRange(keys, 1, keys.length));
+			case ANDOR -> it.bitopAndor(destination, keys[0], Arrays.copyOfRange(keys, 1, keys.length));
+			case ONE -> it.bitopOne(destination, keys);
 		});
 	}
 

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

@@ -571,6 +571,42 @@ void testBitOpNotMultipleSources() {
 				.isThrownBy(() -> connection.bitOp(BitOperation.NOT, "key3", "key1", "key2"));
 	}
 
+	@Test
+	void testBitOpDiff() {
+
+		actual.add(connection.set("key1", "foobar"));
+		actual.add(connection.set("key2", "abcdef"));
+		actual.add(connection.bitOp(BitOperation.DIFF, "key3", "key1", "key2"));
+		verifyResults(Arrays.asList(Boolean.TRUE, Boolean.TRUE, 6L));
+	}
+
+	@Test
+	void testBitOpDiff1() {
+
+		actual.add(connection.set("key1", "foobar"));
+		actual.add(connection.set("key2", "abcdef"));
+		actual.add(connection.bitOp(BitOperation.DIFF1, "key3", "key1", "key2"));
+		verifyResults(Arrays.asList(Boolean.TRUE, Boolean.TRUE, 6L));
+	}
+
+	@Test
+	void testBitOpAndor() {
+
+		actual.add(connection.set("key1", "foo"));
+		actual.add(connection.set("key2", "bar"));
+		actual.add(connection.bitOp(BitOperation.ANDOR, "key3", "key1", "key2"));
+		verifyResults(Arrays.asList(Boolean.TRUE, Boolean.TRUE, 3L));
+	}
+
+	@Test
+	void testBitOpOne() {
+
+		actual.add(connection.set("key1", "foo"));
+		actual.add(connection.set("key2", "bar"));
+		actual.add(connection.bitOp(BitOperation.ONE, "key3", "key1", "key2"));
+		verifyResults(Arrays.asList(Boolean.TRUE, Boolean.TRUE, 3L));
+	}
+
 	@Test
 	@EnabledOnCommand("COPY")
 	void testCopy() {

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

@@ -1010,6 +1010,90 @@ public void testBitOp() {
 		super.testBitOp();
 	}
 
+	@Test
+	public void testBitOpOrBytes() {
+		doReturn(Collections.singletonList(5L)).when(nativeConnection).closePipeline();
+		super.testBitOpOrBytes();
+	}
+
+	@Test
+	public void testBitOpOr() {
+		doReturn(Collections.singletonList(5L)).when(nativeConnection).closePipeline();
+		super.testBitOpOr();
+	}
+
+	@Test
+	public void testBitOpXorBytes() {
+		doReturn(Collections.singletonList(5L)).when(nativeConnection).closePipeline();
+		super.testBitOpXorBytes();
+	}
+
+	@Test
+	public void testBitOpXor() {
+		doReturn(Collections.singletonList(5L)).when(nativeConnection).closePipeline();
+		super.testBitOpXor();
+	}
+
+	@Test
+	public void testBitOpNotBytes() {
+		doReturn(Collections.singletonList(5L)).when(nativeConnection).closePipeline();
+		super.testBitOpNotBytes();
+	}
+
+	@Test
+	public void testBitOpNot() {
+		doReturn(Collections.singletonList(5L)).when(nativeConnection).closePipeline();
+		super.testBitOpNot();
+	}
+
+	@Test
+	public void testBitOpDiffBytes() {
+		doReturn(Collections.singletonList(5L)).when(nativeConnection).closePipeline();
+		super.testBitOpDiffBytes();
+	}
+
+	@Test
+	public void testBitOpDiff() {
+		doReturn(Collections.singletonList(5L)).when(nativeConnection).closePipeline();
+		super.testBitOpDiff();
+	}
+
+	@Test
+	public void testBitOpDiff1Bytes() {
+		doReturn(Collections.singletonList(5L)).when(nativeConnection).closePipeline();
+		super.testBitOpDiff1Bytes();
+	}
+
+	@Test
+	public void testBitOpDiff1() {
+		doReturn(Collections.singletonList(5L)).when(nativeConnection).closePipeline();
+		super.testBitOpDiff1();
+	}
+
+	@Test
+	public void testBitOpAndorBytes() {
+		doReturn(Collections.singletonList(5L)).when(nativeConnection).closePipeline();
+		super.testBitOpAndorBytes();
+	}
+
+	@Test
+	public void testBitOpAndor() {
+		doReturn(Collections.singletonList(5L)).when(nativeConnection).closePipeline();
+		super.testBitOpAndor();
+	}
+
+	@Test
+	public void testBitOpOneBytes() {
+		doReturn(Collections.singletonList(5L)).when(nativeConnection).closePipeline();
+		super.testBitOpOneBytes();
+	}
+
+	@Test
+	public void testBitOpOne() {
+		doReturn(Collections.singletonList(5L)).when(nativeConnection).closePipeline();
+		super.testBitOpOne();
+	}
+
 	@Test
 	public void testSUnionBytes() {
 		doReturn(Collections.singletonList(bytesSet)).when(nativeConnection).closePipeline();

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

@@ -1025,6 +1025,90 @@ public void testBitOp() {
 		super.testBitOp();
 	}
 
+	@Test
+	public void testBitOpOrBytes() {
+		doReturn(Collections.singletonList(Collections.singletonList(5L))).when(nativeConnection).closePipeline();
+		super.testBitOpOrBytes();
+	}
+
+	@Test
+	public void testBitOpOr() {
+		doReturn(Collections.singletonList(Collections.singletonList(5L))).when(nativeConnection).closePipeline();
+		super.testBitOpOr();
+	}
+
+	@Test
+	public void testBitOpXorBytes() {
+		doReturn(Collections.singletonList(Collections.singletonList(5L))).when(nativeConnection).closePipeline();
+		super.testBitOpXorBytes();
+	}
+
+	@Test
+	public void testBitOpXor() {
+		doReturn(Collections.singletonList(Collections.singletonList(5L))).when(nativeConnection).closePipeline();
+		super.testBitOpXor();
+	}
+
+	@Test
+	public void testBitOpNotBytes() {
+		doReturn(Collections.singletonList(Collections.singletonList(5L))).when(nativeConnection).closePipeline();
+		super.testBitOpNotBytes();
+	}
+
+	@Test
+	public void testBitOpNot() {
+		doReturn(Collections.singletonList(Collections.singletonList(5L))).when(nativeConnection).closePipeline();
+		super.testBitOpNot();
+	}
+
+	@Test
+	public void testBitOpDiffBytes() {
+		doReturn(Collections.singletonList(Collections.singletonList(5L))).when(nativeConnection).closePipeline();
+		super.testBitOpDiffBytes();
+	}
+
+	@Test
+	public void testBitOpDiff() {
+		doReturn(Collections.singletonList(Collections.singletonList(5L))).when(nativeConnection).closePipeline();
+		super.testBitOpDiff();
+	}
+
+	@Test
+	public void testBitOpDiff1Bytes() {
+		doReturn(Collections.singletonList(Collections.singletonList(5L))).when(nativeConnection).closePipeline();
+		super.testBitOpDiff1Bytes();
+	}
+
+	@Test
+	public void testBitOpDiff1() {
+		doReturn(Collections.singletonList(Collections.singletonList(5L))).when(nativeConnection).closePipeline();
+		super.testBitOpDiff1();
+	}
+
+	@Test
+	public void testBitOpAndorBytes() {
+		doReturn(Collections.singletonList(Collections.singletonList(5L))).when(nativeConnection).closePipeline();
+		super.testBitOpAndorBytes();
+	}
+
+	@Test
+	public void testBitOpAndor() {
+		doReturn(Collections.singletonList(Collections.singletonList(5L))).when(nativeConnection).closePipeline();
+		super.testBitOpAndor();
+	}
+
+	@Test
+	public void testBitOpOneBytes() {
+		doReturn(Collections.singletonList(Collections.singletonList(5L))).when(nativeConnection).closePipeline();
+		super.testBitOpOneBytes();
+	}
+
+	@Test
+	public void testBitOpOne() {
+		doReturn(Collections.singletonList(Collections.singletonList(5L))).when(nativeConnection).closePipeline();
+		super.testBitOpOne();
+	}
+
 	@Test
 	public void testSUnionBytes() {
 		doReturn(Collections.singletonList(Collections.singletonList(bytesSet))).when(nativeConnection).closePipeline();

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

@@ -1266,6 +1266,104 @@ public void testBitOp() {
 		verifyResults(Collections.singletonList(5L));
 	}
 
+	@Test
+	public void testBitOpOrBytes() {
+		doReturn(5L).when(nativeConnection).bitOp(BitOperation.OR, fooBytes, barBytes);
+		actual.add(connection.bitOp(BitOperation.OR, fooBytes, barBytes));
+		verifyResults(Collections.singletonList(5L));
+	}
+
+	@Test
+	public void testBitOpOr() {
+		doReturn(5L).when(nativeConnection).bitOp(BitOperation.OR, fooBytes, barBytes);
+		actual.add(connection.bitOp(BitOperation.OR, foo, bar));
+		verifyResults(Collections.singletonList(5L));
+	}
+
+	@Test
+	public void testBitOpXorBytes() {
+		doReturn(5L).when(nativeConnection).bitOp(BitOperation.XOR, fooBytes, barBytes);
+		actual.add(connection.bitOp(BitOperation.XOR, fooBytes, barBytes));
+		verifyResults(Collections.singletonList(5L));
+	}
+
+	@Test
+	public void testBitOpXor() {
+		doReturn(5L).when(nativeConnection).bitOp(BitOperation.XOR, fooBytes, barBytes);
+		actual.add(connection.bitOp(BitOperation.XOR, foo, bar));
+		verifyResults(Collections.singletonList(5L));
+	}
+
+	@Test
+	public void testBitOpNotBytes() {
+		doReturn(5L).when(nativeConnection).bitOp(BitOperation.NOT, fooBytes, barBytes);
+		actual.add(connection.bitOp(BitOperation.NOT, fooBytes, barBytes));
+		verifyResults(Collections.singletonList(5L));
+	}
+
+	@Test
+	public void testBitOpNot() {
+		doReturn(5L).when(nativeConnection).bitOp(BitOperation.NOT, fooBytes, barBytes);
+		actual.add(connection.bitOp(BitOperation.NOT, foo, bar));
+		verifyResults(Collections.singletonList(5L));
+	}
+
+	@Test
+	public void testBitOpDiffBytes() {
+		doReturn(5L).when(nativeConnection).bitOp(BitOperation.DIFF, fooBytes, barBytes);
+		actual.add(connection.bitOp(BitOperation.DIFF, fooBytes, barBytes));
+		verifyResults(Collections.singletonList(5L));
+	}
+
+	@Test
+	public void testBitOpDiff() {
+		doReturn(5L).when(nativeConnection).bitOp(BitOperation.DIFF, fooBytes, barBytes);
+		actual.add(connection.bitOp(BitOperation.DIFF, foo, bar));
+		verifyResults(Collections.singletonList(5L));
+	}
+
+	@Test
+	public void testBitOpDiff1Bytes() {
+		doReturn(5L).when(nativeConnection).bitOp(BitOperation.DIFF1, fooBytes, barBytes);
+		actual.add(connection.bitOp(BitOperation.DIFF1, fooBytes, barBytes));
+		verifyResults(Collections.singletonList(5L));
+	}
+
+	@Test
+	public void testBitOpDiff1() {
+		doReturn(5L).when(nativeConnection).bitOp(BitOperation.DIFF1, fooBytes, barBytes);
+		actual.add(connection.bitOp(BitOperation.DIFF1, foo, bar));
+		verifyResults(Collections.singletonList(5L));
+	}
+
+	@Test
+	public void testBitOpAndorBytes() {
+		doReturn(5L).when(nativeConnection).bitOp(BitOperation.ANDOR, fooBytes, barBytes);
+		actual.add(connection.bitOp(BitOperation.ANDOR, fooBytes, barBytes));
+		verifyResults(Collections.singletonList(5L));
+	}
+
+	@Test
+	public void testBitOpAndor() {
+		doReturn(5L).when(nativeConnection).bitOp(BitOperation.ANDOR, fooBytes, barBytes);
+		actual.add(connection.bitOp(BitOperation.ANDOR, foo, bar));
+		verifyResults(Collections.singletonList(5L));
+	}
+
+	@Test
+	public void testBitOpOneBytes() {
+		doReturn(5L).when(nativeConnection).bitOp(BitOperation.ONE, fooBytes, barBytes);
+		actual.add(connection.bitOp(BitOperation.ONE, fooBytes, barBytes));
+		verifyResults(Collections.singletonList(5L));
+	}
+
+	@Test
+	public void testBitOpOne() {
+		doReturn(5L).when(nativeConnection).bitOp(BitOperation.ONE, fooBytes, barBytes);
+		actual.add(connection.bitOp(BitOperation.ONE, foo, bar));
+		verifyResults(Collections.singletonList(5L));
+	}
+
 	@Test
 	public void testSUnionBytes() {
 		doReturn(bytesSet).when(nativeConnection).sUnion(fooBytes, barBytes);