Enum LookupPath 

pub enum LookupPath {
    Serial,
    Batch,
}

Which path a lookup of n oids takes.

The number this dispatch was written for is index_layout_bench’s: on the bare Arrow arms, lookup_batch with a single element costs 818 ns against lookup’s 482 ns — 1.7x worse — because the batch path allocates a result vector, a key vector and a second pass over them to serve one oid.

RE-MEASURED against the shipping read stack, and the magnitude does not carry over. oden 2026-08-07, release, 1-min loadavg 4.94 (another tenant’s work — see LAW: never measure on a busy box, and read these as a ratio rather than as absolutes), ObjectReadStack<OneTableFourColumns> over a real repository’s 2687-object pack, 20 000 iterations ([crate::store::tests::the_batch_of_one_really_is_slower_than_the_serial_path]):

call	per oid
lookup	628 ns
lookup_batch with 1 oid	639 ns — 1.02x worse
lookup_batch with 100 oids	161 ns — 3.9x better

So: the direction holds and the dispatch is right — a batch of one is never faster — but on this stack at this size it costs 2%, not 70%. The real finding is the third row: the batch path is worth 3.9x at BATCH_SATURATES_AT, which is a much stronger reason to keep the two paths apart than the batch-of-one penalty ever was. Both numbers are stated because quoting only the 1.7x would be quoting a figure this stack does not reproduce.

The dispatch is a named function with its own guard precisely so it cannot quietly become lookup_batch for every n.

Variants

Serial

One oid: ObjectIndex::lookup.

Batch

Two or more: ObjectIndex::lookup_batch, one pass.

Trait Implementations

impl Clone for LookupPath

fn clone(&self) -> LookupPath

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for LookupPath

impl Debug for LookupPath

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for LookupPath

impl PartialEq for LookupPath

fn eq(&self, other: &LookupPath) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for LookupPath