Struct Dictionary 

pub struct Dictionary<K, V> { /* private fields */ }

Marker for an arrow Dictionary column, e.g. Dictionary<i32, Utf8>.

Think of Dictionary<K, V> as a column of V, dictionary-compressed: the encoding is a storage detail, and the element values are those of V (e.g. &str), looked up through the dictionary keys. K is the integer key type (i8–i64, u8–u64) — a space/size trade-off, never user-visible.

Nullability

Since Dictionary<K, V> is logically a column of V, row nullability works like for any other column: Option<Dictionary<K, V>> means the rows may be null (arrow encodes this in the validity bitmap of the keys). Dictionary<Option<K>, V> would be meaningless: the keys are storage indices, not values anyone reads — Option<…> always marks nullability of readable values.

Additionally, arrow allows null entries in the dictionary’s value table itself, so a valid key can point at a null. That (rare) case is Dictionary<K, Option<V>>. Column<Dictionary<K, V>> (no Option anywhere) guarantees the absence of both.

use quiver::{Column, Dictionary, Utf8};

// Building dictionary-encodes the values (can fail on key overflow):
let column = Column::<Dictionary<i32, Utf8>>::try_from_values(["a", "b", "a"]).unwrap();
assert_eq!(column.value(2), "a"); // transparent: reads like a plain column
assert_eq!(column.to_vec(), ["a", "b", "a"]);

This type is never instantiated — it only appears as a type parameter.

Trait Implementations

impl<K: DictionaryKey + 'static, V: ConcreteType + 'static> ConcreteType for Dictionary<K, V>

fn datatype() -> DataType

The exact arrow datatype, built recursively (including the nullability of inner fields).

fn build( values: impl Iterator<Item = Option<Self::Owned>>, ) -> Result<ArrayRef, ColumnError>

Builds an arrow array of this datatype from owned values.

impl<K: DictionaryKey + 'static, V: LogicalType + 'static> LogicalType for Dictionary<K, V>

type Typed = TypedDictionary<K, V>

The fully-downcast, validated representation of one column of this datatype. Cheap to clone (arrow arrays are reference-counted).

type Value<'a> = <V as LogicalType>::Value<'a>

Zero-copy element view: &'a str for Utf8, i64 for i64, an iterator for List<T>, Option<…> for Option<T>.

type Owned = <V as LogicalType>::Owned

The owned value of one element, used by the convenience constructors: String for Utf8, Option<i64> for Option<i64>, Vec<…> for List<…>, etc.

fn downcast(array: &dyn Array) -> Result<Self::Typed, ColumnError>

Validates that array has an acceptable datatype, then recursively downcasts it — checking the nulls of all children along the way.

fn is_null(typed: &Self::Typed, index: usize) -> bool

Is the value at index null?

unsafe fn is_null_unchecked(typed: &Self::Typed, index: usize) -> bool

Like is_null, but without the bounds check.

fn value(typed: &Self::Typed, index: usize) -> Self::Value<'_>

The value at index.

unsafe fn value_unchecked(typed: &Self::Typed, index: usize) -> Self::Value<'_>

The value at index, without the bounds check value performs.

fn to_owned_value(value: Self::Value<'_>) -> Self::Owned

Converts a borrowed element value into an owned one, e.g. &str → String.

const NULLABLE: bool = false

May the values at this level be null? (true only for Option<…>)

impl<K: DictionaryKey + 'static, V: RefType + 'static> RefType for Dictionary<K, V>

References are looked up through the dictionary keys, like LogicalType::value.

type Ref = <V as RefType>::Ref

The borrow target: str for Utf8, i64 for i64, etc.

fn value_ref(typed: &Self::Typed, index: usize) -> &Self::Ref

A reference to the value at index.