Struct KeyBuilder 

pub struct KeyBuilder { /* private fields */ }

Streams typed logical fields into a canonical cache key.

Integer methods use little-endian fixed-width encoding. Variable-width strings and bytes are type-tagged and length-prefixed. There is deliberately no usize method because cache identities must not depend on target width.

Examples

use lance_core::cache::{CacheKeySchema, CacheNamespace, KeyBuilder};

let namespace = CacheNamespace::root().child("dataset");
let mut builder = KeyBuilder::new(
    namespace,
    "example.Page",
    CacheKeySchema::new("example.page-key", 1),
);
builder.write_u32(7);
builder.write_str("values");
let key = builder.finish();
assert_eq!(key.as_bytes().len(), 16);

Implementations

impl KeyBuilder

pub fn new( namespace: CacheNamespace, stable_type_id: &'static str, schema: CacheKeySchema, ) -> Self

Start a key in a namespace with a stable value type and key schema.

pub fn write_u8(&mut self, value: u8)

Append a tagged, fixed-width u8.

pub fn write_u16(&mut self, value: u16)

Append a tagged, little-endian u16.

pub fn write_u32(&mut self, value: u32)

Append a tagged, little-endian u32.

pub fn write_u64(&mut self, value: u64)

Append a tagged, little-endian u64.

pub fn write_i32(&mut self, value: i32)

Append a tagged, little-endian i32.

pub fn write_i64(&mut self, value: i64)

Append a tagged, little-endian i64.

pub fn write_bool(&mut self, value: bool)

Append a tagged boolean.

pub fn write_str(&mut self, value: &str)

Append a tagged, length-prefixed UTF-8 string.

pub fn write_bytes(&mut self, value: &[u8])

Append tagged, length-prefixed bytes.

pub fn write_fixed_bytes<const N: usize>(&mut self, value: &[u8; N])

Append a tagged fixed-size byte array, including its length.

pub fn write_none(&mut self)

Append the canonical marker for an absent optional value.

pub fn write_some(&mut self)

Append the canonical marker for a present optional value.

pub fn write_variant(&mut self, variant: u32)

Append a tagged enum variant ordinal.

pub fn write_sequence_len(&mut self, len: u64)

Append the length of a following sequence.

pub fn finish(self) -> InternalCacheKey

Finalize and return the canonical 128-bit key.