Add AnyBinary: one logical type for any binary encoding

Mirrors `AnyList`: `Column<AnyBinary>` accepts any of arrow's byte-string
encodings — `Binary`, `LargeBinary`, `BinaryView`, or `FixedSizeBinary` (any
size) — and reads them all uniformly as `&[u8]` (a `FixedSizeBinary<N>`'s
fixed-width elements are seen as plain `&[u8]` slices, not `&[u8; N]`). Like
`AnyList` it is parse-only: implements `LogicalType` but not `ConcreteType`, so
no `from_values`/`Default`/schema — build a concrete encoding such as
`Column<Binary>`.

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

Author: emilk

README.md

@@ -197,6 +197,7 @@ The supported logical types:
 | `Utf8`, `LargeUtf8`, `Utf8View`              | The same                     | `&str`                    |
 | `FixedSizeBinary<N>`                         | `FixedSizeBinary(N)`         | `&[u8; N]`                |
 | `Binary`, `LargeBinary`, `BinaryView`        | The same                     | `&[u8]`                   |
+| `AnyBinary`                                  | *any* binary encoding (incl. `FixedSizeBinary`) | `&[u8]`        |
 | `Date32`, `Date64`                           | `Date32`, `Date64`           | `i32` days / `i64` ms     |
 | `Time32Second` … `Time64Nanosecond`          | `Time32(…)`, `Time64(…)`     | `i32` / `i64`             |
 | `TimestampNanosecond<Utc>`                   | `Timestamp(Nanosecond, UTC)` | `i64`                     |
@@ -240,6 +241,10 @@ Because it has no single arrow datatype, `AnyList` is **parse-only**: it impleme
 `datatype()`, `from_values`, `Default`, or schema generation. To *build* a column,
 pick a concrete encoding such as `Column<List<L>>`.
 
+`AnyBinary` is the same idea for byte strings: it accepts any of `Binary`,
+`LargeBinary`, `BinaryView`, or `FixedSizeBinary` (any size) and reads them all
+as `&[u8]`. Also parse-only.
+
 ### What is *not* supported
 
 These datatypes have no logical type yet, so there is no `Column<L>` for them:

crates/quiver/tests/column.rs

@@ -622,6 +622,58 @@ fn binary_view_columns() {
     assert_eq!(column.to_vec(), [short, long]);
 }
 
+#[test]
+fn any_binary_columns() {
+    use quiver::arrow::array::{BinaryViewArray, FixedSizeBinaryArray, LargeBinaryArray};
+    use quiver::{AnyBinary, Binary, BinaryView, FixedSizeBinary, LargeBinary};
+
+    // `try_from` accepts every byte-string encoding, read uniformly as `&[u8]`:
+    let encodings = [
+        Column::<Binary>::from_values([b"ab".to_vec(), vec![3_u8, 4]]).into_arrow(),
+        Column::<LargeBinary>::from_values([b"ab".to_vec(), vec![3_u8, 4]]).into_arrow(),
+        Column::<BinaryView>::from_values([b"ab".to_vec(), vec![3_u8, 4]]).into_arrow(),
+        // FixedSizeBinary too (any size) — its `&[u8; N]` reads here as `&[u8]`:
+        Column::<FixedSizeBinary<2>>::from_values([[b'a', b'b'], [3, 4]]).into_arrow(),
+    ];
+    for array in encodings {
+        let column = Column::<AnyBinary>::try_from(array).unwrap();
+        assert_eq!(column.value(0), b"ab");
+        assert_eq!(&column[1], &[3_u8, 4]); // `RefType` indexing
+        assert_eq!(column.to_vec(), [b"ab".to_vec(), vec![3, 4]]);
+    }
+
+    // A non-binary array is rejected:
+    let ints = Column::<i64>::from_values([1, 2]).into_arrow();
+    assert!(matches!(
+        Column::<AnyBinary>::try_from(ints),
+        Err(ColumnError::WrongDatatype { .. })
+    ));
+
+    // Nullable rows via the column-level `Option`:
+    let array = LargeBinaryArray::from_iter([Some(b"x".as_slice()), None]);
+    let column = Column::<Option<AnyBinary>>::try_from(Arc::new(array) as ArrayRef).unwrap();
+    let values: Vec<Option<&[u8]>> = column.iter().collect();
+    assert_eq!(values, [Some(b"x".as_slice()), None]);
+
+    // A null at a non-nullable level is rejected:
+    let array = BinaryViewArray::from_iter([Some(b"x".as_slice()), None]);
+    assert!(matches!(
+        Column::<AnyBinary>::try_from(Arc::new(array) as ArrayRef),
+        Err(ColumnError::UnexpectedNulls { null_count: 1 })
+    ));
+
+    // A FixedSizeBinary with a null is also rejected when non-nullable:
+    let array = FixedSizeBinaryArray::try_from_sparse_iter_with_size(
+        [Some([1_u8, 2]), None].into_iter(),
+        2,
+    )
+    .unwrap();
+    assert!(matches!(
+        Column::<AnyBinary>::try_from(Arc::new(array) as ArrayRef),
+        Err(ColumnError::UnexpectedNulls { null_count: 1 })
+    ));
+}
+
 #[test]
 fn f16_column() {
     use quiver::half::f16;

crates/quiver_types/src/binary.rs

@@ -9,6 +9,10 @@
 //! [`arrow::array::BinaryViewArray`] for the newer "view" encoding
 //! ([`DataType::BinaryView`]), optimized for comparisons and out-of-order writes.
 //! Reading is zero-copy: the element values are `&[u8]`.
+//!
+//! [`AnyBinary`] accepts *any* binary encoding — these three plus
+//! [`FixedSizeBinary`](crate::FixedSizeBinary) — all read as `&[u8]`, for when
+//! the encoding is decided at runtime.
 
 use arrow::array::{Array, ArrayRef};
 use arrow::datatypes::DataType;
@@ -116,3 +120,102 @@ impl_binary_datatype!(
     arrow::array::BinaryViewArray,
     DataType::BinaryView
 );
+
+/// Marker for a binary column in *any* of arrow's byte-string encodings.
+///
+/// Accepts [`Binary`], [`LargeBinary`], [`BinaryView`], or
+/// [`FixedSizeBinary`](crate::FixedSizeBinary) (of any size). They all read as
+/// `&[u8]` — a `FixedSizeBinary<N>`'s fixed-width elements are seen here as
+/// plain `&[u8]` slices (length `N`), not `&[u8; N]`.
+///
+/// Like [`AnyList`](crate::AnyList), this is a quiver-only logical type with no
+/// single arrow datatype: `Column<AnyBinary>` accepts whichever encoding it is
+/// handed and reads them all uniformly. It is *parse-only* — it implements
+/// [`LogicalType`] (so `try_from`/reading work) but not
+/// [`ConcreteType`](crate::ConcreteType), so there is no `from_values`/`Default`/
+/// schema; to build, pick a concrete encoding such as `Column<Binary>`.
+///
+/// ```
+/// use quiver::{AnyBinary, Column};
+/// use quiver::arrow::array::{ArrayRef, LargeBinaryArray};
+/// # use std::sync::Arc;
+///
+/// // `array` may be a Binary / LargeBinary / BinaryView:
+/// let array: ArrayRef = Arc::new(LargeBinaryArray::from_iter_values([b"abc"]));
+/// let column = Column::<AnyBinary>::try_from(array).unwrap();
+/// assert_eq!(column.value(0), b"abc");
+/// ```
+///
+/// This type is never instantiated — it only appears as a type parameter.
+pub struct AnyBinary;
+
+/// The validated representation of an [`AnyBinary`] column: one of the
+/// per-encoding binary arrays.
+#[derive(Clone)]
+pub enum AnyTypedBinary {
+    Binary(arrow::array::BinaryArray),
+    LargeBinary(arrow::array::LargeBinaryArray),
+    BinaryView(arrow::array::BinaryViewArray),
+    FixedSizeBinary(arrow::array::FixedSizeBinaryArray),
+}
+
+impl LogicalType for AnyBinary {
+    type Typed = AnyTypedBinary;
+    type Value<'a> = &'a [u8];
+    type Owned = Vec<u8>;
+
+    fn downcast(array: &dyn Array) -> Result<Self::Typed, ColumnError> {
+        match array.data_type() {
+            DataType::Binary => Ok(AnyTypedBinary::Binary(downcast_array(array, || {
+                "Binary".to_owned()
+            })?)),
+            DataType::LargeBinary => {
+                Ok(AnyTypedBinary::LargeBinary(downcast_array(array, || {
+                    "LargeBinary".to_owned()
+                })?))
+            }
+            DataType::BinaryView => Ok(AnyTypedBinary::BinaryView(downcast_array(array, || {
+                "BinaryView".to_owned()
+            })?)),
+            DataType::FixedSizeBinary(_) => Ok(AnyTypedBinary::FixedSizeBinary(downcast_array(
+                array,
+                || "FixedSizeBinary".to_owned(),
+            )?)),
+            actual => Err(ColumnError::WrongDatatype {
+                expected: "a binary array (Binary/LargeBinary/BinaryView/FixedSizeBinary)"
+                    .to_owned(),
+                actual: actual.clone(),
+            }),
+        }
+    }
+
+    fn is_null(typed: &Self::Typed, index: usize) -> bool {
+        match typed {
+            AnyTypedBinary::Binary(array) => array.is_null(index),
+            AnyTypedBinary::LargeBinary(array) => array.is_null(index),
+            AnyTypedBinary::BinaryView(array) => array.is_null(index),
+            AnyTypedBinary::FixedSizeBinary(array) => array.is_null(index),
+        }
+    }
+
+    fn value(typed: &Self::Typed, index: usize) -> Self::Value<'_> {
+        match typed {
+            AnyTypedBinary::Binary(array) => array.value(index),
+            AnyTypedBinary::LargeBinary(array) => array.value(index),
+            AnyTypedBinary::BinaryView(array) => array.value(index),
+            AnyTypedBinary::FixedSizeBinary(array) => array.value(index),
+        }
+    }
+
+    fn to_owned_value(value: Self::Value<'_>) -> Self::Owned {
+        value.to_vec()
+    }
+}
+
+impl RefType for AnyBinary {
+    type Ref = [u8];
+
+    fn value_ref(typed: &Self::Typed, index: usize) -> &[u8] {
+        Self::value(typed, index)
+    }
+}

crates/quiver_types/src/lib.rs

@@ -32,7 +32,7 @@ mod timestamp;
 mod typed_array;
 
 pub use self::any_list::{AnyList, AnyTypedList};
-pub use self::binary::{Binary, BinaryView, LargeBinary};
+pub use self::binary::{AnyBinary, AnyTypedBinary, Binary, BinaryView, LargeBinary};
 pub use self::column::{Column, ColumnIntoIter, ColumnIter};
 pub use self::column_desc::{ColumnDesc, DynColumnDesc};
 pub use self::datatype::{