From 7b300602b0c6fd5bebb275a19fa7a94554872193 Mon Sep 17 00:00:00 2001
From: shockp <masque2204@gmail.com>
Date: Thu, 23 Apr 2026 11:25:07 +0200
Subject: [PATCH 1/4] GH-45819: [C++] Implement OptionalBitmapAnd utility

Centralizes the logic for conjoining optional null bitmaps.
Optimizes memory allocations by returning nullptr or falling back to
CopyBitmap when one or both of the input buffers are missing.
---
 cpp/src/arrow/util/bitmap_ops.cc | 20 ++++++++++++++++++++
 cpp/src/arrow/util/bitmap_ops.h  | 23 +++++++++++++++++++++++
 testing                          |  2 +-
 3 files changed, 44 insertions(+), 1 deletion(-)

diff --git a/cpp/src/arrow/util/bitmap_ops.cc b/cpp/src/arrow/util/bitmap_ops.cc
index cc24146ae94e..da693750f626 100644
--- a/cpp/src/arrow/util/bitmap_ops.cc
+++ b/cpp/src/arrow/util/bitmap_ops.cc
@@ -31,6 +31,7 @@
 #include "arrow/util/bitmap_reader.h"
 #include "arrow/util/bitmap_writer.h"
 #include "arrow/util/logging_internal.h"
+#include "bitmap_ops.h"
 
 namespace arrow {
 namespace internal {
@@ -329,6 +330,25 @@ bool OptionalBitmapEquals(const std::shared_ptr<Buffer>& left, int64_t left_offs
                               right ? right->data() : nullptr, right_offset, length);
 }
 
+Result<std::shared_ptr<Buffer>> OptionalBitmapAnd(MemoryPool* pool,
+                                                  const std::shared_ptr<Buffer>& left,
+                                                  int64_t left_offset,
+                                                  const std::shared_ptr<Buffer>& right,
+                                                  int64_t right_offset, int64_t length,
+                                                  int64_t out_offset) {
+  if (left == nullptr && right == nullptr) {
+    return nullptr;
+  }
+  if (left == nullptr) {
+    return CopyBitmap(pool, right->data(), right_offset, length, out_offset);
+  }
+  if (right == nullptr) {
+    return CopyBitmap(pool, left->data(), left_offset, length, out_offset);
+  }
+  return BitmapAnd(pool, left->data(), left_offset, right->data(), right_offset, length,
+                   out_offset);
+}
+
 namespace {
 
 template <template <typename> class BitOp>
diff --git a/cpp/src/arrow/util/bitmap_ops.h b/cpp/src/arrow/util/bitmap_ops.h
index ac05bc87b307..7126e5e53209 100644
--- a/cpp/src/arrow/util/bitmap_ops.h
+++ b/cpp/src/arrow/util/bitmap_ops.h
@@ -166,6 +166,29 @@ ARROW_EXPORT
 void BitmapAnd(const uint8_t* left, int64_t left_offset, const uint8_t* right,
                int64_t right_offset, int64_t length, int64_t out_offset, uint8_t* out);
 
+/// \brief Do a "bitmap and" on two buffers, handling null buffers safely.
+///
+/// If both buffers are null, returns nullptr.
+/// If one buffer is null, allocates a new buffer and copies the valid buffer into it.
+/// If both buffers are valid, allocates a new buffer and performs a bitwise AND.
+///
+/// \param[in] pool memory pool to allocate memory from
+/// \param[in] left left source buffer (may be null)
+/// \param[in] left_offset bit offset into the left buffer
+/// \param[in] right right source buffer (may be null)
+/// \param[in] right_offset bit offset into the right buffer
+/// \param[in] length number of bits to compute
+/// \param[in] out_offset bit offset into the output buffer
+///
+/// \return Resulting buffer (may be null)
+ARROW_EXPORT
+Result<std::shared_ptr<Buffer>> OptionalBitmapAnd(MemoryPool* pool,
+                                                  const std::shared_ptr<Buffer>& left,
+                                                  int64_t left_offset,
+                                                  const std::shared_ptr<Buffer>& right,
+                                                  int64_t right_offset, int64_t length,
+                                                  int64_t out_offset);
+
 /// \brief Do a "bitmap or" for the given bit length on right and left buffers
 /// starting at their respective bit-offsets and put the results in out_buffer
 /// starting at the given bit-offset.
diff --git a/testing b/testing
index 190638e1b14a..a871ddc17a4d 160000
--- a/testing
+++ b/testing
@@ -1 +1 @@
-Subproject commit 190638e1b14af926601dbe0a95caa1940dafedd8
+Subproject commit a871ddc17a4dd936b7aa43898d59f86a11c3a2b5

From 1d4e0eba14dcdb6cd74e3d0233fc5e3a5dd954f6 Mon Sep 17 00:00:00 2001
From: shockp <masque2204@gmail.com>
Date: Thu, 23 Apr 2026 12:15:36 +0200
Subject: [PATCH 2/4] GH-45819: [C++] Add tests for OptionalBitmapAnd

---
 cpp/src/arrow/util/bitmap_test.cc | 40 +++++++++++++++++++++++++++++++
 1 file changed, 40 insertions(+)

diff --git a/cpp/src/arrow/util/bitmap_test.cc b/cpp/src/arrow/util/bitmap_test.cc
index 603008420ab1..87e820912479 100644
--- a/cpp/src/arrow/util/bitmap_test.cc
+++ b/cpp/src/arrow/util/bitmap_test.cc
@@ -17,6 +17,7 @@
 
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
+#include <cstring>
 
 #include "arrow/array/array_base.h"
 #include "arrow/array/data.h"
@@ -1236,6 +1237,45 @@ TEST(BitmapOpTest, PartialLeadingByteSafety) {
   }
 }
 
+TEST(BitmapOpTest, OptionalBitmapAnd) {
+  MemoryPool* pool = default_memory_pool();
+  int64_t length = 16;
+  int64_t phys_bits = length;
+
+  // Create two distinct test buffers
+  ASSERT_OK_AND_ASSIGN(auto buf1, AllocateEmptyBitmap(phys_bits, pool));
+  ASSERT_OK_AND_ASSIGN(auto buf2, AllocateEmptyBitmap(phys_bits, pool));
+
+  // Fill buf1 with 1s (true)
+  std::memset(buf1->mutable_data(), 0xFF, buf1->size());
+  // Fill buf2 with alternating bits 01010101 (0xAA)
+  std::memset(buf2->mutable_data(), 0xAA, buf2->size());
+
+  // State 1: Both nullptr
+  ASSERT_OK_AND_ASSIGN(auto result1,
+                       OptionalBitmapAnd(pool, nullptr, 0, nullptr, 0, length, 0));
+  ASSERT_EQ(result1, nullptr);
+
+  // State 2: Left nullptr, Right valid (Should copy Right)
+  ASSERT_OK_AND_ASSIGN(auto result2,
+                       OptionalBitmapAnd(pool, nullptr, 0, buf2, 0, length, 0));
+  ASSERT_NE(result2, nullptr);
+  EXPECT_TRUE(BitmapEquals(buf2->data(), 0, result2->data(), 0, length));
+
+  // State 3: Left valid, Right nullptr (Should copy Left)
+  ASSERT_OK_AND_ASSIGN(auto result3,
+                       OptionalBitmapAnd(pool, buf1, 0, nullptr, 0, length, 0));
+  ASSERT_NE(result3, nullptr);
+  EXPECT_TRUE(BitmapEquals(buf1->data(), 0, result3->data(), 0, length));
+
+  // State 4: Both valid (Should perform Bitwise AND)
+  ASSERT_OK_AND_ASSIGN(auto result4,
+                       OptionalBitmapAnd(pool, buf1, 0, buf2, 0, length, 0));
+  ASSERT_NE(result4, nullptr);
+  // Since buf1 is all 1s, (buf1 AND buf2) should perfectly equal buf2
+  EXPECT_TRUE(BitmapEquals(buf2->data(), 0, result4->data(), 0, length));
+}
+
 // Tests for Bitmap visiting.
 
 // test the basic assumption of word level Bitmap::Visit

From 28d69c7612126acf8eb08bdc2b3ce1772b606eed Mon Sep 17 00:00:00 2001
From: shockp <masque2204@gmail.com>
Date: Thu, 23 Apr 2026 12:48:27 +0200
Subject: [PATCH 3/4] GH-45819: [C++] Fix include path for bitmap_ops.h

---
 cpp/src/arrow/util/bitmap_ops.cc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cpp/src/arrow/util/bitmap_ops.cc b/cpp/src/arrow/util/bitmap_ops.cc
index da693750f626..bc16b3fec970 100644
--- a/cpp/src/arrow/util/bitmap_ops.cc
+++ b/cpp/src/arrow/util/bitmap_ops.cc
@@ -28,10 +28,10 @@
 #include "arrow/util/align_util.h"
 #include "arrow/util/bit_block_counter.h"
 #include "arrow/util/bit_util.h"
+#include "arrow/util/bitmap_ops.h"
 #include "arrow/util/bitmap_reader.h"
 #include "arrow/util/bitmap_writer.h"
 #include "arrow/util/logging_internal.h"
-#include "bitmap_ops.h"
 
 namespace arrow {
 namespace internal {

From b9e12ac6bf502afcc3eb7530b268efdcf4bb6627 Mon Sep 17 00:00:00 2001
From: shockp <masque2204@gmail.com>
Date: Thu, 23 Apr 2026 13:26:09 +0200
Subject: [PATCH 4/4] GH-45819: [C++] Remove redundant header include in
 bitmap_ops.cc

---
 cpp/src/arrow/util/bitmap_ops.cc | 1 -
 1 file changed, 1 deletion(-)

diff --git a/cpp/src/arrow/util/bitmap_ops.cc b/cpp/src/arrow/util/bitmap_ops.cc
index bc16b3fec970..d93a7545a965 100644
--- a/cpp/src/arrow/util/bitmap_ops.cc
+++ b/cpp/src/arrow/util/bitmap_ops.cc
@@ -28,7 +28,6 @@
 #include "arrow/util/align_util.h"
 #include "arrow/util/bit_block_counter.h"
 #include "arrow/util/bit_util.h"
-#include "arrow/util/bitmap_ops.h"
 #include "arrow/util/bitmap_reader.h"
 #include "arrow/util/bitmap_writer.h"
 #include "arrow/util/logging_internal.h"