perf(parquet/file): avoid double bool bitmap conversion (#707)

### Rationale for this change
Boolean columns currently get double converted when transferring between
Arrow and Parquet

### What changes are included in this PR?

**1. Arrow bitutil (`arrow/bitutil/bitmaps.go`)**
- Added `AppendBitmap()` method to `BitmapWriter`
- Directly copies bits from source bitmap using efficient `CopyBitmap()`

**2. Parquet encoder (`parquet/internal/encoding/boolean_encoder.go`)**
- Added `PutBitmap()` method to `PlainBooleanEncoder`
- Writes bitmap data directly without bool slice conversion

**3. Parquet decoder (`parquet/internal/encoding/boolean_decoder.go`)**
- Added `DecodeToBitmap()` method to `PlainBooleanDecoder`
- Reads directly into output bitmap
- Optimized fast path for byte-aligned cases

**4. Column writer (`parquet/file/column_writer_types.gen.go`)**
- Added `WriteBitmapBatch()` for non-nullable boolean columns
- Added `WriteBitmapBatchSpaced()` for nullable boolean columns
- Internal helper methods `writeBitmapValues()` and
`writeBitmapValuesSpaced()`

**5. Arrow-Parquet bridge (`parquet/pqarrow/encode_arrow.go`)**
- Modified `writeDenseArrow()` to detect boolean arrays
- Uses bitmap methods when available
- Falls back to original `[]bool` path if needed (backward compatible)


### Are these changes tested?

Yes, and new benchmarks are added as appropriate

### Are there any user-facing changes?

Just performance:

### Non-Nullable Boolean Columns
```
BenchmarkBooleanBitmapWrite/1K-16          314847    19126 ns/op    6.54 MB/s    36057 B/op    237 allocs/op
BenchmarkBooleanBitmapWrite/10K-16         174715    33985 ns/op   36.78 MB/s    53266 B/op    247 allocs/op
BenchmarkBooleanBitmapWrite/100K-16         34099   175655 ns/op   71.16 MB/s   218866 B/op    340 allocs/op
BenchmarkBooleanBitmapWrite/1M-16            3778  1568818 ns/op   79.68 MB/s  1763712 B/op   1237 allocs/op
```

### Nullable Boolean Columns (10% null rate)
```
BenchmarkBooleanBitmapWriteNullable/1K-16   214921    28002 ns/op    4.46 MB/s    39706 B/op    249 allocs/op
BenchmarkBooleanBitmapWriteNullable/10K-16   44618   134483 ns/op    9.29 MB/s   113690 B/op    268 allocs/op
BenchmarkBooleanBitmapWriteNullable/100K-16   5239  1149658 ns/op   10.87 MB/s   657178 B/op    451 allocs/op
BenchmarkBooleanBitmapWriteNullable/1M-16      556 10926274 ns/op   11.44 MB/s  5575200 B/op   2219 allocs/op
```

**Key Observations:**
- Direct bitmap path successfully avoids `[]bool` conversion
- Throughput scales well with data size (6.5 → 80 MB/s for non-nullable)
- Memory usage remains efficient with minimal allocations per operation
- Nullable columns have overhead from validity bitmap processing
(expected)

---------

Co-authored-by: Matt <zero@gibson>

Author: zeroshade

arrow/bitutil/bitmaps.go

@@ -167,6 +167,39 @@ func (b *BitmapWriter) AppendBools(in []bool) int {
 	return space
 }
 
+// AppendBitmap writes bits directly from a source bitmap to this bitmap writer,
+// avoiding the intermediate []bool conversion. Returns the number of bits written.
+func (b *BitmapWriter) AppendBitmap(srcBitmap []byte, srcOffset int64, length int64) int64 {
+	space := int64(min(b.length-b.pos, int(length)))
+	if space == 0 {
+		return 0
+	}
+
+	bitOffset := bits.TrailingZeros32(uint32(b.bitMask))
+	dstOffset := int64(b.byteOffset)*8 + int64(bitOffset)
+
+	// Flush curByte to buffer before CopyBitmap overwrites it
+	// Similar to how AppendBools writes curByte to appslice[0]
+	b.buf[b.byteOffset] = b.curByte
+
+	// Use CopyBitmap for efficient bit-level copying
+	CopyBitmap(srcBitmap, int(srcOffset), int(space), b.buf, int(dstOffset))
+
+	// Update writer state
+	b.pos += int(space)
+	newBitOffset := (bitOffset + int(space)) % 8
+	b.bitMask = BitMask[newBitOffset]
+	b.byteOffset += (bitOffset + int(space)) / 8
+
+	// Reload curByte to reflect the current byte's state after CopyBitmap
+	// We must reload even if pos == length, as Finish() may need to write curByte
+	if b.byteOffset < len(b.buf) {
+		b.curByte = b.buf[b.byteOffset]
+	}
+
+	return space
+}
+
 // Finish flushes the final byte out to the byteslice in case it was not already
 // on a byte aligned boundary.
 func (b *BitmapWriter) Finish() {

arrow/bitutil/bitmaps_test.go

@@ -596,3 +596,133 @@ func BenchmarkBitmapAnd(b *testing.B) {
 		})
 	}
 }
+
+func TestBitmapWriterAppendBitmap(t *testing.T) {
+	tests := []struct {
+		name       string
+		srcBits    []bool
+		dstOffset  int
+		srcOffset  int64
+		length     int64
+		wantResult []bool
+	}{
+		{
+			name:       "append_aligned",
+			srcBits:    []bool{true, false, true, true, false, false, true, false},
+			dstOffset:  0,
+			srcOffset:  0,
+			length:     8,
+			wantResult: []bool{true, false, true, true, false, false, true, false},
+		},
+		{
+			name:       "append_unaligned_source",
+			srcBits:    []bool{false, false, true, false, true, true, false, false, true, false},
+			dstOffset:  0,
+			srcOffset:  2,
+			length:     6,
+			wantResult: []bool{true, false, true, true, false, false},
+		},
+		{
+			name:       "append_unaligned_dest",
+			srcBits:    []bool{true, true, false, false},
+			dstOffset:  3,
+			srcOffset:  0,
+			length:     4,
+			wantResult: []bool{true, true, false, false},
+		},
+		{
+			name:       "append_partial_byte",
+			srcBits:    []bool{true, false, true},
+			dstOffset:  0,
+			srcOffset:  0,
+			length:     3,
+			wantResult: []bool{true, false, true},
+		},
+		{
+			name:       "append_multiple_bytes",
+			srcBits:    []bool{true, false, true, false, true, false, true, false, false, true, false, true, false, true, false, true},
+			dstOffset:  0,
+			srcOffset:  0,
+			length:     16,
+			wantResult: []bool{true, false, true, false, true, false, true, false, false, true, false, true, false, true, false, true},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Create source bitmap
+			srcBytes := make([]byte, bitutil.BytesForBits(int64(len(tt.srcBits))))
+			for i, bit := range tt.srcBits {
+				if bit {
+					bitutil.SetBit(srcBytes, i)
+				}
+			}
+
+			// Create destination bitmap
+			dstBytes := make([]byte, bitutil.BytesForBits(int64(tt.dstOffset+len(tt.wantResult))))
+			writer := bitutil.NewBitmapWriter(dstBytes, tt.dstOffset, len(tt.wantResult))
+
+			// Append bitmap
+			written := writer.AppendBitmap(srcBytes, tt.srcOffset, tt.length)
+			writer.Finish()
+
+			// Verify
+			assert.Equal(t, tt.length, written, "wrong number of bits written")
+			for i, expectedBit := range tt.wantResult {
+				actualBit := bitutil.BitIsSet(dstBytes, tt.dstOffset+i)
+				assert.Equal(t, expectedBit, actualBit, "bit mismatch at position %d", i)
+			}
+		})
+	}
+}
+
+func TestBitmapWriterAppendBitmapEmpty(t *testing.T) {
+	dstBytes := make([]byte, 10)
+	writer := bitutil.NewBitmapWriter(dstBytes, 0, 8)
+
+	// Append zero bits
+	written := writer.AppendBitmap([]byte{0xFF}, 0, 0)
+	assert.Equal(t, int64(0), written)
+}
+
+func TestBitmapWriterAppendBitmapFull(t *testing.T) {
+	dstBytes := make([]byte, 1)
+	writer := bitutil.NewBitmapWriter(dstBytes, 0, 4)
+
+	srcBytes := []byte{0xFF}
+
+	// Write 4 bits
+	written := writer.AppendBitmap(srcBytes, 0, 4)
+	assert.Equal(t, int64(4), written)
+
+	// Try to write more (should write 0 since buffer is full)
+	written = writer.AppendBitmap(srcBytes, 0, 4)
+	assert.Equal(t, int64(0), written)
+}
+
+func TestBitmapWriterAppendBitmapLarge(t *testing.T) {
+	// Test with large bitmap (1024 bits = 128 bytes)
+	numBits := 1024
+	srcBytes := make([]byte, bitutil.BytesForBits(int64(numBits)))
+	dstBytes := make([]byte, bitutil.BytesForBits(int64(numBits)))
+
+	// Create alternating pattern
+	for i := 0; i < numBits; i++ {
+		if i%2 == 0 {
+			bitutil.SetBit(srcBytes, i)
+		}
+	}
+
+	writer := bitutil.NewBitmapWriter(dstBytes, 0, numBits)
+	written := writer.AppendBitmap(srcBytes, 0, int64(numBits))
+	writer.Finish()
+
+	assert.Equal(t, int64(numBits), written)
+
+	// Verify pattern
+	for i := 0; i < numBits; i++ {
+		expected := i%2 == 0
+		actual := bitutil.BitIsSet(dstBytes, i)
+		assert.Equal(t, expected, actual, "bit mismatch at position %d", i)
+	}
+}

parquet/file/column_writer_test.go

@@ -862,3 +862,94 @@ func TestWriteDataFailure(t *testing.T) {
 	assert.Equal(t, err, failureErr)
 	assert.Equal(t, int64(0), wr.TotalBytesWritten())
 }
+
+func (b *BooleanValueWriterSuite) TestWriteBitmapBatch() {
+	b.SetupSchema(parquet.Repetitions.Required, 1)
+	writer := b.buildWriter(SmallSize, parquet.DefaultColumnProperties(), parquet.WithVersion(parquet.V1_0)).(*file.BooleanColumnChunkWriter)
+
+	// Create test bitmap with alternating pattern for SmallSize elements
+	expected := make([]bool, SmallSize)
+	bitmapBytes := make([]byte, bitutil.BytesForBits(int64(SmallSize)))
+	for i := 0; i < SmallSize; i++ {
+		val := (i % 4) < 2 // Pattern: true, true, false, false, repeat
+		expected[i] = val
+		if val {
+			bitutil.SetBit(bitmapBytes, i)
+		}
+	}
+
+	// Write using WriteBitmapBatch
+	n, err := writer.WriteBitmapBatch(bitmapBytes, 0, SmallSize, nil, nil)
+	b.NoError(err)
+	b.Equal(int64(SmallSize), n)
+
+	writer.Close()
+	b.readColumn(compress.Codecs.Uncompressed)
+	b.Equal(expected, b.ValuesOut)
+}
+
+func (b *BooleanValueWriterSuite) TestWriteBitmapBatchUnaligned() {
+	b.SetupSchema(parquet.Repetitions.Required, 1)
+	writer := b.buildWriter(SmallSize, parquet.DefaultColumnProperties(), parquet.WithVersion(parquet.V1_0)).(*file.BooleanColumnChunkWriter)
+
+	// Create source bitmap with more elements
+	srcSize := SmallSize + 10
+	srcBits := make([]bool, srcSize)
+	bitmapBytes := make([]byte, bitutil.BytesForBits(int64(srcSize)))
+	for i := 0; i < srcSize; i++ {
+		val := (i % 3) == 0
+		srcBits[i] = val
+		if val {
+			bitutil.SetBit(bitmapBytes, i)
+		}
+	}
+
+	// Write SmallSize bits starting from offset 5
+	expected := srcBits[5 : 5+SmallSize]
+	n, err := writer.WriteBitmapBatch(bitmapBytes, 5, SmallSize, nil, nil)
+	b.NoError(err)
+	b.Equal(int64(SmallSize), n)
+
+	writer.Close()
+	b.readColumn(compress.Codecs.Uncompressed)
+	b.Equal(expected, b.ValuesOut)
+}
+
+func (b *BooleanValueWriterSuite) TestWriteBitmapBatchSpaced() {
+	b.SetupSchema(parquet.Repetitions.Optional, 1)
+	b.descr = b.Schema.Column(0)
+
+	// Create test data with nulls (every 4th element is null)
+	bitmapBytes := make([]byte, bitutil.BytesForBits(int64(SmallSize)))
+	validBits := make([]byte, bitutil.BytesForBits(int64(SmallSize)))
+	defLevels := make([]int16, SmallSize)
+	expected := make([]bool, 0)
+
+	for i := 0; i < SmallSize; i++ {
+		if i%4 == 0 {
+			// Null value
+			defLevels[i] = 0
+		} else {
+			// Valid value
+			defLevels[i] = 1
+			bitutil.SetBit(validBits, i)
+			val := (i % 3) == 1
+			if val {
+				bitutil.SetBit(bitmapBytes, i)
+			}
+			expected = append(expected, val)
+		}
+	}
+
+	writer := b.buildWriter(int64(SmallSize), parquet.DefaultColumnProperties(), parquet.WithVersion(parquet.V1_0)).(*file.BooleanColumnChunkWriter)
+	writer.WriteBitmapBatchSpaced(bitmapBytes, 0, SmallSize, defLevels, nil, validBits, 0)
+	writer.Close()
+
+	// Read back with proper def levels setup
+	b.GenerateData(SmallSize) // This initializes DefLevels and DefLevelsOut properly for optional
+	values := b.readColumn(compress.Codecs.Uncompressed)
+	b.Equal(int64(len(expected)), values) // Should read only non-null values
+
+	// ValuesOut should contain only the non-null values
+	b.Equal(expected, b.ValuesOut.([]bool)[:values])
+}