ESQL: Add boolean support to Max and Min aggs (elastic#110527)

- Added support for Booleans on Max and Min
- Added some helper methods to BitArray (`set(index, value)` and `fill(from, to, value)`). This way, the container is more similar to other BigArrays, and it's easier to work with

Part of elastic#110346, as Max
and Min are dependencies of Top.

docs/changelog/110527.yaml

@@ -0,0 +1,5 @@
+pr: 110527
+summary: "ESQL: Add boolean support to Max and Min aggs"
+area: ES|QL
+type: feature
+issues: []

server/src/main/java/org/elasticsearch/common/util/BitArray.java

@@ -64,6 +64,17 @@ public void writeTo(StreamOutput out) throws IOException {
         bits.writeTo(out);
     }
 
+    /**
+     * Set or clear the {@code index}th bit based on the specified value.
+     */
+    public void set(long index, boolean value) {
+        if (value) {
+            set(index);
+        } else {
+            clear(index);
+        }
+    }
+
     /**
      * Set the {@code index}th bit.
      */
@@ -158,6 +169,68 @@ public boolean get(long index) {
         return (bits.get(wordNum) & bitmask) != 0;
     }
 
+    /**
+     * Set or clear slots between {@code fromIndex} inclusive to {@code toIndex} based on {@code value}.
+     */
+    public void fill(long fromIndex, long toIndex, boolean value) {
+        if (fromIndex > toIndex) {
+            throw new IllegalArgumentException("From should be less than or equal to toIndex");
+        }
+        long currentSize = size();
+        if (value == false) {
+            // There's no need to grow the array just to clear bits.
+            toIndex = Math.min(toIndex, currentSize);
+        }
+        if (fromIndex == toIndex) {
+            return; // Empty range
+        }
+
+        if (toIndex > currentSize) {
+            bits = bigArrays.grow(bits, wordNum(toIndex) + 1);
+        }
+
+        int wordLength = Long.BYTES * Byte.SIZE;
+        long fullWord = 0xFFFFFFFFFFFFFFFFL;
+
+        long firstWordIndex = fromIndex % wordLength;
+        long lastWordIndex = toIndex % wordLength;
+
+        long firstWordNum = wordNum(fromIndex);
+        long lastWordNum = wordNum(toIndex - 1);
+
+        // Mask first word
+        if (firstWordIndex > 0) {
+            long mask = fullWord << firstWordIndex;
+
+            if (firstWordNum == lastWordNum) {
+                mask &= fullWord >>> (wordLength - lastWordIndex);
+            }
+
+            if (value) {
+                bits.set(firstWordNum, bits.get(firstWordNum) | mask);
+            } else {
+                bits.set(firstWordNum, bits.get(firstWordNum) & ~mask);
+            }
+
+            firstWordNum++;
+        }
+
+        // Mask last word
+        if (firstWordNum <= lastWordNum) {
+            long mask = fullWord >>> (wordLength - lastWordIndex);
+
+            if (value) {
+                bits.set(lastWordNum, bits.get(lastWordNum) | mask);
+            } else {
+                bits.set(lastWordNum, bits.get(lastWordNum) & ~mask);
+            }
+        }
+
+        if (firstWordNum < lastWordNum) {
+            bits.fill(firstWordNum, lastWordNum, value ? fullWord : 0L);
+        }
+    }
+
     public long size() {
         return bits.size() * (long) Long.BYTES * Byte.SIZE;
     }

server/src/test/java/org/elasticsearch/common/util/BitArrayTests.java

@@ -51,6 +51,27 @@ public void testRandom() {
         }
     }
 
+    public void testRandomSetValue() {
+        try (BitArray bitArray = new BitArray(1, BigArrays.NON_RECYCLING_INSTANCE)) {
+            int numBits = randomIntBetween(1000, 10000);
+            for (int step = 0; step < 3; step++) {
+                boolean[] bits = new boolean[numBits];
+                List<Integer> slots = new ArrayList<>();
+                for (int i = 0; i < numBits; i++) {
+                    bits[i] = randomBoolean();
+                    slots.add(i);
+                }
+                Collections.shuffle(slots, random());
+                for (int i : slots) {
+                    bitArray.set(i, bits[i]);
+                }
+                for (int i = 0; i < numBits; i++) {
+                    assertEquals(bitArray.get(i), bits[i]);
+                }
+            }
+        }
+    }
+
     public void testVeryLarge() {
         assumeThat(Runtime.getRuntime().maxMemory(), greaterThanOrEqualTo(ByteSizeUnit.MB.toBytes(512)));
         try (BitArray bitArray = new BitArray(1, BigArrays.NON_RECYCLING_INSTANCE)) {
@@ -183,6 +204,78 @@ public void testGetAndSet() {
         }
     }
 
+    public void testFillTrueRandom() {
+        try (BitArray bitArray = new BitArray(1, BigArrays.NON_RECYCLING_INSTANCE)) {
+            int from = randomIntBetween(0, 1000);
+            int to = randomIntBetween(from, 1000);
+
+            bitArray.fill(0, 1000, false);
+            bitArray.fill(from, to, true);
+
+            for (int i = 0; i < 1000; i++) {
+                if (i < from || i >= to) {
+                    assertFalse(bitArray.get(i));
+                } else {
+                    assertTrue(bitArray.get(i));
+                }
+            }
+        }
+    }
+
+    public void testFillFalseRandom() {
+        try (BitArray bitArray = new BitArray(1, BigArrays.NON_RECYCLING_INSTANCE)) {
+            int from = randomIntBetween(0, 1000);
+            int to = randomIntBetween(from, 1000);
+
+            bitArray.fill(0, 1000, true);
+            bitArray.fill(from, to, false);
+
+            for (int i = 0; i < 1000; i++) {
+                if (i < from || i >= to) {
+                    assertTrue(bitArray.get(i));
+                } else {
+                    assertFalse(bitArray.get(i));
+                }
+            }
+        }
+    }
+
+    public void testFillTrueSingleWord() {
+        try (BitArray bitArray = new BitArray(1, BigArrays.NON_RECYCLING_INSTANCE)) {
+            int from = 8;
+            int to = 56;
+
+            bitArray.fill(0, 64, false);
+            bitArray.fill(from, to, true);
+
+            for (int i = 0; i < 64; i++) {
+                if (i < from || i >= to) {
+                    assertFalse(bitArray.get(i));
+                } else {
+                    assertTrue(bitArray.get(i));
+                }
+            }
+        }
+    }
+
+    public void testFillFalseSingleWord() {
+        try (BitArray bitArray = new BitArray(1, BigArrays.NON_RECYCLING_INSTANCE)) {
+            int from = 8;
+            int to = 56;
+
+            bitArray.fill(0, 64, true);
+            bitArray.fill(from, to, false);
+
+            for (int i = 0; i < 64; i++) {
+                if (i < from || i >= to) {
+                    assertTrue(bitArray.get(i));
+                } else {
+                    assertFalse(bitArray.get(i));
+                }
+            }
+        }
+    }
+
     public void testSerialize() throws Exception {
         int initial = randomIntBetween(1, 100_000);
         BitArray bits1 = new BitArray(initial, BigArrays.NON_RECYCLING_INSTANCE);