Add Support for New BITOP Operations in Redis 8.2 (#4188) (#4190)

* Add Support for New BITOP Operations in Redis 8.2 (#4188)

This PR adds support for the new BITOP operations introduced in Redis Community Edition 8.2: DIFF, DIFF1, ANDOR, and ONE.

Changes
  - Added new enum values to BitOP.java for the new operations: DIFF, DIFF1, ANDOR, and ONE
  - Updated tests in BitCommandsTest.java and BitCommandsTestBase.java to verify the new operations

New Operations
  - DIFF(X, Y1, Y2, ...): Members of X that are not members of any of Y1, Y2, ...
    Equivalent to: X ∧ ¬(Y1 ∨ Y2 ∨ ...)
  - DIFF1(X, Y1, Y2, ...): Members of one or more of Y1, Y2, ... that are not members of X
    Equivalent to: ¬X ∧ (Y1 ∨ Y2 ∨ ...)
  - ANDOR(X, Y1, Y2, ...): Members of X that are also members of one or more of Y1, Y2, ...
    Equivalent to: X ∧ (Y1 ∨ Y2 ∨ ...)
  - ONE(X1, X2, ...): Members of exactly one of X1, X2, ...
    For two bitmaps, this is equivalent to XOR(X1, X2)
    For more than two bitmaps, this represents elements that appear in exactly one input

Closes #4188

* Apply suggestions from code review

Co-authored-by: Igor Malinovskiy <[email protected]>

* format new bitop tests

* Bump of  test infra to use Redis 8.2 will be handled with separate PR

* format

---------

Co-authored-by: Igor Malinovskiy <[email protected]>

Author: ggivo

src/main/java/redis/clients/jedis/args/BitOP.java

@@ -7,7 +7,7 @@
  */
 public enum BitOP implements Rawable {
 
-  AND, OR, XOR, NOT;
+  AND, OR, XOR, NOT, DIFF, DIFF1, ANDOR, ONE;
 
   private final byte[] raw;
 

src/main/java/redis/clients/jedis/commands/BitBinaryCommands.java

@@ -26,5 +26,13 @@ public interface BitBinaryCommands {
 
   List<Long> bitfieldReadonly(byte[] key, byte[]... arguments);
 
+  /**
+   * <b><a href="http://redis.io/commands/bitop">Bitop Command</a></b> Perform a bitwise operation
+   * between multiple keys and store the result in the destKey.
+   * @param op can be AND, OR, XOR, NOT, DIFF, DIFF1, ANDOR and ONE
+   * @param destKey
+   * @param srcKeys
+   * @return The size of the string stored in the destKey
+   */
   long bitop(BitOP op, byte[] destKey, byte[]... srcKeys);
 }

src/main/java/redis/clients/jedis/commands/BitCommands.java

@@ -99,7 +99,7 @@ public interface BitCommands {
   /**
    * <b><a href="http://redis.io/commands/bitop">Bitop Command</a></b>
    * Perform a bitwise operation between multiple keys (containing string values) and store the result in the destKey.
-   * @param op can be AND, OR, XOR or NOT
+   * @param op can be AND, OR, XOR, NOT, DIFF, DIFF1, ANDOR and ONE
    * @param destKey
    * @param srcKeys
    * @return The size of the string stored in the destKey

src/test/java/redis/clients/jedis/commands/jedis/BitCommandsTest.java

@@ -20,6 +20,7 @@
 import static org.junit.jupiter.api.Assertions.assertArrayEquals;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.junit.jupiter.api.Assertions.fail;
 
@@ -308,4 +309,286 @@ public void testBinaryBitfieldReadonly() {
     assertEquals(1L, responses2.get(0).longValue());
   }
 
+  @Test
+  @SinceRedisVersion("8.1.240")
+  public void bitOpDiff() {
+    // Use single-byte values for simplicity
+    byte[] key1 = new byte[] { (byte) 0b00000111 }; // bits 0,1,2 set
+    byte[] key2 = new byte[] { (byte) 0b00000010 }; // bit 1 set
+    byte[] key3 = new byte[] { (byte) 0b00000100 }; // bit 2 set
+    String destKey = "resultDiff";
+
+    // Set keys using byte arrays
+    jedis.set("key1".getBytes(), key1);
+    jedis.set("key2".getBytes(), key2);
+    jedis.set("key3".getBytes(), key3);
+
+    // DIFF(key1, key2, key3) = key1 AND NOT(key2 OR key3)
+    // key1 = 00000111 (bits 0,1,2 set)
+    // key2 = 00000010 (bit 1 set)
+    // key3 = 00000100 (bit 2 set)
+    // key2 OR key3 = 00000110 (bits 1,2 set)
+    // NOT(key2 OR key3) = 11111001 (all bits except 1,2 set)
+    // key1 AND NOT(key2 OR key3) = 00000001 (only bit 0 set)
+    jedis.bitop(BitOP.DIFF, destKey, "key1", "key2", "key3");
+
+    // Get result as bytes
+    byte[] resultBytes = jedis.get(destKey).getBytes();
+
+    // Expected result: 00000001 (only bit 0 set)
+    byte[] expectedBytes = new byte[] { (byte) 0b00000001 };
+
+    // Verify the result
+    assertArrayEquals(expectedBytes, resultBytes);
+  }
+
+  @Test
+  @SinceRedisVersion("8.1.240")
+  public void bitOpDiff1() {
+    // Use single-byte values for simplicity
+    byte[] key1 = new byte[] { (byte) 0x07 }; // 00000111 - bits 0,1,2 set
+    byte[] key2 = new byte[] { (byte) 0x02 }; // 00000010 - bit 1 set
+    byte[] key3 = new byte[] { (byte) 0x04 }; // 00000100 - bit 2 set
+    String destKey = "resultDiff1";
+
+    // Set keys using byte arrays
+    jedis.set("key1".getBytes(), key1);
+    jedis.set("key2".getBytes(), key2);
+    jedis.set("key3".getBytes(), key3);
+
+    // DIFF1(key1, key2, key3) = NOT(key1) AND (key2 OR key3)
+    // key1 = 00000111 (bits 0,1,2 set)
+    // key2 = 00000010 (bit 1 set)
+    // key3 = 00000100 (bit 2 set)
+    // key2 OR key3 = 00000110 (bits 1,2 set)
+    // NOT(key1) = 11111000 (all bits except 0,1,2 set)
+    // NOT(key1) AND (key2 OR key3) = 00000000 (no bits set)
+    jedis.bitop(BitOP.DIFF1, destKey, "key1", "key2", "key3");
+
+    // Get result as bytes
+    byte[] resultBytes = jedis.get(destKey).getBytes();
+
+    // Expected result: 00000000 (no bits set)
+    byte[] expectedBytes = new byte[] { (byte) 0x00 };
+
+    // Verify the result
+    assertArrayEquals(expectedBytes, resultBytes);
+  }
+
+  @Test
+  @SinceRedisVersion("8.1.240")
+  public void bitOpAndor() {
+    // Use single-byte values for simplicity
+    byte[] key1 = new byte[] { (byte) 0x07 }; // 00000111 - bits 0,1,2 set
+    byte[] key2 = new byte[] { (byte) 0x02 }; // 00000010 - bit 1 set
+    byte[] key3 = new byte[] { (byte) 0x04 }; // 00000100 - bit 2 set
+    String destKey = "resultAndor";
+
+    // Set keys using byte arrays
+    jedis.set("key1".getBytes(), key1);
+    jedis.set("key2".getBytes(), key2);
+    jedis.set("key3".getBytes(), key3);
+
+    // ANDOR(key1, key2, key3) = key1 AND (key2 OR key3)
+    // key1 = 00000111 (bits 0,1,2 set)
+    // key2 = 00000010 (bit 1 set)
+    // key3 = 00000100 (bit 2 set)
+    // key2 OR key3 = 00000110 (bits 1,2 set)
+    // key1 AND (key2 OR key3) = 00000110 (bits 1,2 set)
+    jedis.bitop(BitOP.ANDOR, destKey, "key1", "key2", "key3");
+
+    // Get result as bytes
+    byte[] resultBytes = jedis.get(destKey).getBytes();
+
+    // Expected result: 00000110 (bits 1,2 set)
+    byte[] expectedBytes = new byte[] { (byte) 0x06 };
+
+    // Verify the result
+    assertArrayEquals(expectedBytes, resultBytes);
+  }
+
+  @Test
+  @SinceRedisVersion("8.1.240")
+  public void bitOpOne() {
+    // Use single-byte values for simplicity
+    byte[] key1 = new byte[] { (byte) 0x01 }; // 00000001 - bit 0 set
+    byte[] key2 = new byte[] { (byte) 0x02 }; // 00000010 - bit 1 set
+    byte[] key3 = new byte[] { (byte) 0x04 }; // 00000100 - bit 2 set
+    String destKey = "resultOne";
+
+    // Set keys using byte arrays
+    jedis.set("key1".getBytes(), key1);
+    jedis.set("key2".getBytes(), key2);
+    jedis.set("key3".getBytes(), key3);
+
+    // ONE(key1, key2, key3) = bits set in exactly one of the inputs
+    // key1 = 00000001 (bit 0 set)
+    // key2 = 00000010 (bit 1 set)
+    // key3 = 00000100 (bit 2 set)
+    // Result = 00000111 (bits 0,1,2 set - each in exactly one input)
+    jedis.bitop(BitOP.ONE, destKey, "key1", "key2", "key3");
+
+    // Get result as bytes
+    byte[] resultBytes = jedis.get(destKey).getBytes();
+
+    // Expected result: 00000111 (bits 0,1,2 set)
+    byte[] expectedBytes = new byte[] { (byte) 0x07 };
+
+    // Verify the result
+    assertArrayEquals(expectedBytes, resultBytes);
+  }
+
+  @Test
+  @SinceRedisVersion("8.1.240")
+  public void bitOpDiffBinary() {
+    byte[] key1 = { (byte) 0x07 }; // 00000111 - bits 0,1,2 set
+    byte[] key2 = { (byte) 0x02 }; // 00000010 - bit 1 set
+    byte[] key3 = { (byte) 0x04 }; // 00000100 - bit 2 set
+    byte[] dest = "resultDiffBinary".getBytes();
+
+    jedis.set("key1".getBytes(), key1);
+    jedis.set("key2".getBytes(), key2);
+    jedis.set("key3".getBytes(), key3);
+
+    // DIFF(key1, key2, key3) = key1 AND NOT(key2 OR key3)
+    // key1 = 00000111 (bits 0,1,2 set)
+    // key2 = 00000010 (bit 1 set)
+    // key3 = 00000100 (bit 2 set)
+    // key2 OR key3 = 00000110 (bits 1,2 set)
+    // NOT(key2 OR key3) = 11111001 (all bits except 1,2 set)
+    // key1 AND NOT(key2 OR key3) = 00000001 (only bit 0 set)
+    jedis.bitop(BitOP.DIFF, dest, "key1".getBytes(), "key2".getBytes(), "key3".getBytes());
+
+    // Expected result: 00000001 (only bit 0 set)
+    byte[] expectedBytes = new byte[] { (byte) 0x01 };
+
+    // Verify the result
+    assertArrayEquals(expectedBytes, jedis.get(dest));
+  }
+
+  @Test
+  @SinceRedisVersion("8.1.240")
+  public void bitOpDiff1Binary() {
+    byte[] key1 = { (byte) 0x07 }; // 00000111 - bits 0,1,2 set
+    byte[] key2 = { (byte) 0x02 }; // 00000010 - bit 1 set
+    byte[] key3 = { (byte) 0x04 }; // 00000100 - bit 2 set
+    byte[] dest = "resultDiff1Binary".getBytes();
+
+    jedis.set("key1".getBytes(), key1);
+    jedis.set("key2".getBytes(), key2);
+    jedis.set("key3".getBytes(), key3);
+
+    // DIFF1(key1, key2, key3) = NOT(key1) AND (key2 OR key3)
+    // key1 = 00000111 (bits 0,1,2 set)
+    // key2 = 00000010 (bit 1 set)
+    // key3 = 00000100 (bit 2 set)
+    // key2 OR key3 = 00000110 (bits 1,2 set)
+    // NOT(key1) = 11111000 (all bits except 0,1,2 set)
+    // NOT(key1) AND (key2 OR key3) = 00000000 (no bits set)
+    jedis.bitop(BitOP.DIFF1, dest, "key1".getBytes(), "key2".getBytes(), "key3".getBytes());
+
+    // Expected result: 00000000 (no bits set)
+    byte[] expectedBytes = new byte[] { (byte) 0x00 };
+
+    // Verify the result
+    assertArrayEquals(expectedBytes, jedis.get(dest));
+  }
+
+  @Test
+  @SinceRedisVersion("8.1.240")
+  public void bitOpAndorBinary() {
+    byte[] key1 = { (byte) 0x07 }; // 00000111 - bits 0,1,2 set
+    byte[] key2 = { (byte) 0x02 }; // 00000010 - bit 1 set
+    byte[] key3 = { (byte) 0x04 }; // 00000100 - bit 2 set
+    byte[] dest = "resultAndorBinary".getBytes();
+
+    jedis.set("key1".getBytes(), key1);
+    jedis.set("key2".getBytes(), key2);
+    jedis.set("key3".getBytes(), key3);
+
+    // ANDOR(key1, key2, key3) = key1 AND (key2 OR key3)
+    // key1 = 00000111 (bits 0,1,2 set)
+    // key2 = 00000010 (bit 1 set)
+    // key3 = 00000100 (bit 2 set)
+    // key2 OR key3 = 00000110 (bits 1,2 set)
+    // key1 AND (key2 OR key3) = 00000110 (bits 1,2 set)
+    jedis.bitop(BitOP.ANDOR, dest, "key1".getBytes(), "key2".getBytes(), "key3".getBytes());
+
+    // Expected result: 00000110 (bits 1,2 set)
+    byte[] expectedBytes = new byte[] { (byte) 0x06 };
+
+    // Verify the result
+    assertArrayEquals(expectedBytes, jedis.get(dest));
+  }
+
+  @Test
+  @SinceRedisVersion("8.1.240")
+  public void bitOpOneBinary() {
+    byte[] key1 = { (byte) 0x01 }; // 00000001 - bit 0 set
+    byte[] key2 = { (byte) 0x02 }; // 00000010 - bit 1 set
+    byte[] key3 = { (byte) 0x04 }; // 00000100 - bit 2 set
+    byte[] dest = "resultOneBinary".getBytes();
+
+    jedis.set("key1".getBytes(), key1);
+    jedis.set("key2".getBytes(), key2);
+    jedis.set("key3".getBytes(), key3);
+
+    // ONE(key1, key2, key3) = bits set in exactly one of the inputs
+    // key1 = 00000001 (bit 0 set)
+    // key2 = 00000010 (bit 1 set)
+    // key3 = 00000100 (bit 2 set)
+    // Result = 00000111 (bits 0,1,2 set - each in exactly one input)
+    jedis.bitop(BitOP.ONE, dest, "key1".getBytes(), "key2".getBytes(), "key3".getBytes());
+
+    // Expected result: 00000111 (bits 0,1,2 set)
+    byte[] expectedBytes = new byte[] { (byte) 0x07 };
+
+    // Verify the result
+    assertArrayEquals(expectedBytes, jedis.get(dest));
+  }
+
+  @Test
+  @SinceRedisVersion("8.1.240")
+  public void bitOpDiffSingleSourceShouldFail() {
+    assertThrows(JedisDataException.class, () -> jedis.bitop(BitOP.DIFF, "dest", "src1"));
+  }
+
+  @Test
+  @SinceRedisVersion("8.1.240")
+  public void bitOpDiff1SingleSourceShouldFail() {
+    assertThrows(JedisDataException.class, () -> jedis.bitop(BitOP.DIFF1, "dest", "src1"));
+  }
+
+  @Test
+  @SinceRedisVersion("8.1.240")
+  public void bitOpAndorSingleSourceShouldFail() {
+    assertThrows(JedisDataException.class, () -> jedis.bitop(BitOP.ANDOR, "dest", "src1"));
+  }
+
+  @Test
+  @SinceRedisVersion("8.1.240")
+  public void bitOpDiffBinarySingleSourceShouldFail() {
+    byte[] dest = "dest".getBytes();
+    byte[] src1 = "src1".getBytes();
+
+    assertThrows(JedisDataException.class, () -> jedis.bitop(BitOP.DIFF, dest, src1));
+  }
+
+  @Test
+  @SinceRedisVersion("8.1.240")
+  public void bitOpDiff1BinarySingleSourceShouldFail() {
+    byte[] dest = "dest".getBytes();
+    byte[] src1 = "src1".getBytes();
+
+    assertThrows(JedisDataException.class, () -> jedis.bitop(BitOP.DIFF1, dest, src1));
+  }
+
+  @Test
+  @SinceRedisVersion("8.1.240")
+  public void bitOpAndorBinarySingleSourceShouldFail() {
+    byte[] dest = "dest".getBytes();
+    byte[] src1 = "src1".getBytes();
+
+    assertThrows(JedisDataException.class, () -> jedis.bitop(BitOP.ANDOR, dest, src1));
+  }
 }