Struct OneTableFourColumns 

pub struct OneTableFourColumns { /* private fields */ }

One Arrow IPC section, one table, the facts one column each.

Arrow is columnar, so this is not row-contiguous: offset is its own buffer, len is its own buffer, and a full-row fetch still touches five strides that are megabytes apart. What it saves over FourTables is the framing of three IPC streams and nothing else — which is exactly what the measurement found.

The name counts the columns it had when it was named and measured; since delta_base (PLAN §13) there are five payload columns here and in FourTables alike, so the two are still separated by section count and nothing else.

Implementations

impl OneTableFourColumns

pub fn oid_column(&self) -> &FixedSizeBinaryArray

pub fn column_is_inside_ipc(&self) -> bool

All five arrays are views into the one IPC buffer.

pub fn ipc_slice(&self) -> &[u8]

The bytes this index would be persisted as — the single Arrow IPC stream every column is a view into, exactly as [to_ipc] framed it.

ObjectIndex::ipc_bytes reports this buffer’s length, which is enough to compare two layouts’ footprints and not enough to write one down. examples/tail_write_bench.rs needs the bytes themselves: its no-tail arm has to rewrite the whole index on every push, and a measurement of that write is only honest if the bytes going to the file are the index’s own and not a stand-in of the same size.

A borrowed slice and not a Vec: the buffer is already resident and aligned, and handing out a copy would put an allocation inside the very write this exists to measure.

Trait Implementations

impl ObjectIndex for OneTableFourColumns

fn build(entries: &[IndexEntry]) -> Result<Self>

fn lookup(&self, oid: &[u8]) -> Option<IndexRow>

Resolve one oid. None for an absent oid and for an oid of the wrong width.

fn lookup_batch(&self, oids: &[&[u8]]) -> Vec<Option<IndexRow>>

The batch path, and the one that matters: have negotiation sends up to 1000 oids at a time, the push connectivity check sends thousands. Positional — out[i] answers oids[i].

fn ordinals_batch(&self, oids: &[&[u8]]) -> Vec<Option<u32>>

oid → ordinal and stop. No payload column is touched at all.

fn extents_batch(&self, oids: &[&[u8]]) -> Vec<Option<(u64, u64)>>

The partial-row access pattern: byte extent only, two of the five facts. This is extents(&[oid]), what the wire path actually asks for when it is about to copy bytes out of a pack.

fn sum_uncompressed(&self) -> u64

Full column scan: total uncompressed bytes over every object. The quota gate. Reads one 8-byte fact per row and nothing else.

fn count_type(&self, t: ObjType) -> usize

Full column scan with a predicate: how many objects of this type. Reads one byte per row and nothing else — the most column-shaped query there is, and the one a row-packed layout should lose worst.

fn name(&self) -> &'static str

fn len(&self) -> usize

fn ipc_bytes(&self) -> usize

Total bytes of Arrow IPC this index holds resident. Four sections or one, this counts the same payload, so it is comparable across arms.

fn resident_bytes(&self) -> usize

IPC bytes plus the stree oid section — everything the index keeps alive, excluding the handful of Arc’d schema/metadata allocations.

fn is_empty(&self) -> bool