Introduce FromBitpacked trait and use debug_assert in BitReader

Replace unreachable!() stubs for from_u64 on Int96/ByteArray/FixedLenByteArray
with a separate FromBitpacked trait that is only implemented for types that
can actually be converted from u64 (primitives, floats, bool). Also convert
assert! to debug_assert! for num_bits bounds checks in get_value/get_batch.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: Dandandan

parquet/src/arrow/array_reader/byte_array_dictionary.rs

@@ -34,7 +34,7 @@ use crate::column::reader::decoder::ColumnValueDecoder;
 use crate::encodings::rle::RleDecoder;
 use crate::errors::{ParquetError, Result};
 use crate::schema::types::ColumnDescPtr;
-use crate::util::bit_util::FromBytes;
+use crate::util::bit_util::FromBitpacked;
 
 /// A macro to reduce verbosity of [`make_byte_array_dictionary_reader`]
 macro_rules! make_reader {
@@ -128,7 +128,7 @@ struct ByteArrayDictionaryReader<K: ArrowNativeType, V: OffsetSizeTrait> {
 
 impl<K, V> ByteArrayDictionaryReader<K, V>
 where
-    K: FromBytes + Ord + ArrowNativeType,
+    K: FromBitpacked + Ord + ArrowNativeType,
     V: OffsetSizeTrait,
 {
     fn new(
@@ -148,7 +148,7 @@ where
 
 impl<K, V> ArrayReader for ByteArrayDictionaryReader<K, V>
 where
-    K: FromBytes + Ord + ArrowNativeType,
+    K: FromBitpacked + Ord + ArrowNativeType,
     V: OffsetSizeTrait,
 {
     fn as_any(&self) -> &dyn Any {
@@ -226,7 +226,7 @@ struct DictionaryDecoder<K, V> {
 
 impl<K, V> ColumnValueDecoder for DictionaryDecoder<K, V>
 where
-    K: FromBytes + Ord + ArrowNativeType,
+    K: FromBitpacked + Ord + ArrowNativeType,
     V: OffsetSizeTrait,
 {
     type Buffer = DictionaryBuffer<K, V>;

parquet/src/encodings/decoding.rs

@@ -31,7 +31,7 @@ use crate::encodings::decoding::byte_stream_split_decoder::{
 };
 use crate::errors::{ParquetError, Result};
 use crate::schema::types::ColumnDescPtr;
-use crate::util::bit_util::{self, BitReader};
+use crate::util::bit_util::{self, BitReader, FromBitpacked};
 
 mod byte_stream_split_decoder;
 
@@ -455,7 +455,10 @@ impl<T: DataType> RleValueDecoder<T> {
     }
 }
 
-impl<T: DataType> Decoder<T> for RleValueDecoder<T> {
+impl<T: DataType> Decoder<T> for RleValueDecoder<T>
+where
+    T::T: FromBitpacked,
+{
     #[inline]
     fn set_data(&mut self, data: Bytes, num_values: usize) -> Result<()> {
         // Only support RLE value reader for boolean values with bit width of 1.
@@ -658,7 +661,7 @@ where
 
 impl<T: DataType> Decoder<T> for DeltaBitPackDecoder<T>
 where
-    T::T: Default + FromPrimitive + WrappingAdd + Copy,
+    T::T: Default + FromPrimitive + FromBitpacked + WrappingAdd + Copy,
 {
     // # of total values is derived from encoding
     #[inline]

parquet/src/encodings/rle.rs

@@ -39,7 +39,7 @@ use std::{cmp, mem::size_of};
 use bytes::Bytes;
 
 use crate::errors::{ParquetError, Result};
-use crate::util::bit_util::{self, BitReader, BitWriter, FromBytes};
+use crate::util::bit_util::{self, BitReader, BitWriter, FromBitpacked};
 
 /// Maximum groups of 8 values per bit-packed run. Current value is 64.
 const MAX_GROUPS_PER_BIT_PACKED_RUN: usize = 1 << 6;
@@ -352,7 +352,7 @@ impl RleDecoder {
     // that damage L1d-cache occupancy. This results in a ~18% performance drop
     #[inline(never)]
     #[allow(unused)]
-    pub fn get<T: FromBytes>(&mut self) -> Result<Option<T>> {
+    pub fn get<T: FromBitpacked>(&mut self) -> Result<Option<T>> {
         assert!(size_of::<T>() <= 8);
 
         while self.rle_left == 0 && self.bit_packed_left == 0 {
@@ -388,7 +388,7 @@ impl RleDecoder {
     }
 
     #[inline(never)]
-    pub fn get_batch<T: FromBytes + Clone>(&mut self, buffer: &mut [T]) -> Result<usize> {
+    pub fn get_batch<T: FromBitpacked + Clone>(&mut self, buffer: &mut [T]) -> Result<usize> {
         assert!(size_of::<T>() <= 8);
 
         let mut values_read = 0;

parquet/src/util/bit_util.rs

@@ -44,6 +44,15 @@ pub unsafe trait FromBytes: Sized {
     type Buffer: AsMut<[u8]> + Default;
     fn try_from_le_slice(b: &[u8]) -> Result<Self>;
     fn from_le_bytes(bs: Self::Buffer) -> Self;
+}
+
+/// Types that can be decoded from bitpacked representations.
+///
+/// This is implemented for primitive types and bool that can be
+/// directly converted from a u64 value. Types like Int96, ByteArray,
+/// and FixedLenByteArray that cannot be represented in 64 bits do not
+/// implement this trait.
+pub trait FromBitpacked: FromBytes {
     /// Convert directly from a u64 value by truncation, avoiding byte slice copies.
     fn from_u64(v: u64) -> Self;
 }
@@ -61,6 +70,8 @@ macro_rules! from_le_bytes {
             fn from_le_bytes(bs: Self::Buffer) -> Self {
                 <$ty>::from_le_bytes(bs)
             }
+        }
+        impl FromBitpacked for $ty {
             #[inline]
             fn from_u64(v: u64) -> Self {
                 v as Self
@@ -82,6 +93,9 @@ unsafe impl FromBytes for f32 {
     fn from_le_bytes(bs: Self::Buffer) -> Self {
         f32::from_le_bytes(bs)
     }
+}
+
+impl FromBitpacked for f32 {
     #[inline]
     fn from_u64(v: u64) -> Self {
         f32::from_bits(v as u32)
@@ -98,6 +112,9 @@ unsafe impl FromBytes for f64 {
     fn from_le_bytes(bs: Self::Buffer) -> Self {
         f64::from_le_bytes(bs)
     }
+}
+
+impl FromBitpacked for f64 {
     #[inline]
     fn from_u64(v: u64) -> Self {
         f64::from_bits(v)
@@ -115,6 +132,9 @@ unsafe impl FromBytes for bool {
     fn from_le_bytes(bs: Self::Buffer) -> Self {
         bs[0] != 0
     }
+}
+
+impl FromBitpacked for bool {
     #[inline]
     fn from_u64(v: u64) -> Self {
         v != 0
@@ -146,9 +166,6 @@ unsafe impl FromBytes for Int96 {
         );
         i
     }
-    fn from_u64(_v: u64) -> Self {
-        unreachable!("Int96 does not support from_u64")
-    }
 }
 
 // SAFETY: BIT_CAPACITY is 0.
@@ -162,9 +179,6 @@ unsafe impl FromBytes for ByteArray {
     fn from_le_bytes(bs: Self::Buffer) -> Self {
         bs.into()
     }
-    fn from_u64(_v: u64) -> Self {
-        unreachable!("ByteArray does not support from_u64")
-    }
 }
 
 // SAFETY: BIT_CAPACITY is 0.
@@ -178,9 +192,6 @@ unsafe impl FromBytes for FixedLenByteArray {
     fn from_le_bytes(bs: Self::Buffer) -> Self {
         bs.into()
     }
-    fn from_u64(_v: u64) -> Self {
-        unreachable!("FixedLenByteArray does not support from_u64")
-    }
 }
 
 /// Reads `size` of bytes from `src`, and reinterprets them as type `ty`, in
@@ -464,7 +475,7 @@ impl BitReader {
     /// Reads a value of type `T` and of size `num_bits`.
     ///
     /// Returns `None` if there's not enough data available. `Some` otherwise.
-    pub fn get_value<T: FromBytes>(&mut self, num_bits: usize) -> Option<T> {
+    pub fn get_value<T: FromBitpacked>(&mut self, num_bits: usize) -> Option<T> {
         assert!(num_bits <= 64);
         assert!(num_bits <= size_of::<T>() * 8);
 
@@ -507,8 +518,8 @@ impl BitReader {
     /// This function panics if
     /// - `num_bits` is larger than the bit-capacity of `T`
     ///
-    pub fn get_batch<T: FromBytes>(&mut self, batch: &mut [T], num_bits: usize) -> usize {
-        assert!(num_bits <= size_of::<T>() * 8);
+    pub fn get_batch<T: FromBitpacked>(&mut self, batch: &mut [T], num_bits: usize) -> usize {
+        debug_assert!(num_bits <= size_of::<T>() * 8);
 
         let mut values_to_read = batch.len();
         let needed_bits = num_bits * values_to_read;
@@ -1074,7 +1085,7 @@ mod tests {
 
     fn test_get_batch_helper<T>(total: usize, num_bits: usize)
     where
-        T: FromBytes + Default + Clone + Debug + Eq,
+        T: FromBitpacked + Default + Clone + Debug + Eq,
     {
         assert!(num_bits <= 64);
         let num_bytes = ceil(num_bits, 8);