Struct ArrowColumnChunkData 

struct ArrowColumnChunkData {
    length: usize,
    store: Box<dyn PageStore>,
    keys: Vec<PageKey>,
    dictionary_keys: Vec<PageKey>,
    dictionary_len: usize,
}

A single column chunk produced by ArrowColumnWriter.

Holds the serialized page blobs (each page’s header ‖ compressed data, in write order) in a PageStore, plus the handles needed to read them back, in order, when the chunk is spliced into the output file.

Fields

length: usize

store: Box<dyn PageStore>

keys: Vec<PageKey>

dictionary_keys: Vec<PageKey>

Handles to the dictionary page’s blobs (header then data) in the store.

A dictionary page is produced at most once and bounded by dict_page_size_limit, but it must be written first in the chunk even though the data pages reach the writer before it (see PageWriter::defers_dictionary_ordering). Its header and data are put into the store like any other page — which keeps the store uniform, and lets an oversized dictionary page spill — and their handles are held apart so they can be emitted ahead of the data pages at splice. Empty for non-dictionary columns.

dictionary_len: usize

Serialized length of the dictionary page (0 if there is none), recorded so the data pages can be shifted past it when offsets are rewritten to a dictionary-first layout at splice.

Implementations

impl ArrowColumnChunkData

fn new(store: Box<dyn PageStore>) -> Self

fn push(&mut self, value: Bytes) -> Result<()>

Append a data-page blob to the store, recording its handle in write order.

fn push_dictionary(&mut self, value: Bytes) -> Result<()>

Store a dictionary-page blob (header or data) in the page store, recording its handle (emitted first at splice) and accumulating its serialized length.

fn memory_size(&self) -> usize

Bytes this chunk currently holds on the heap: whatever the store keeps resident (zero for a spilling backend).