Struct ChunkId 

pub struct ChunkId(/* private fields */);

A unique ID for a Chunk.

Chunks are the atomic unit of ingestion, transport, storage, events and GC in Rerun.

Internally, a Chunk is made up of rows, which are themselves uniquely identified by their RowId.

There is no relationship whatsoever between a ChunkId and the RowIds within that chunk.

String format

Example: chunk_182342300C5F8C327a7b4a6e5a379ac4. The “chunk_” prefix is optional when parsing. See re_tuid docs for explanations of TUID namespaces.

Uniqueness

ChunkId are assumed unique within a single Recording.

The chunk store will treat two chunks with the same ChunkId as the same, and only keep one of them (which one is kept is an arbitrary and unstable implementation detail).

This makes it easy to build and maintain secondary indices around RowIds with few to no extraneous state tracking.

Garbage collection

Garbage collection is handled at the chunk level by first ordering the chunks based on the minimum RowId present in each of them. Garbage collection therefore happens (roughly) in the logger’s wall-clock order.

This has very important implications when inserting data far into the past or into the future: think carefully about your RowIds in these cases.

Implementations

impl ChunkId

pub const ZERO: ChunkId

pub const MAX: ChunkId

pub fn new() -> ChunkId

Create a new unique ChunkId based on the current time.

pub fn from_tuid(tuid: Tuid) -> ChunkId

pub fn as_tuid(&self) -> Tuid

pub fn next(&self) -> ChunkId

Returns the next logical ChunkId.

Beware: wrong usage can easily lead to conflicts. Prefer ChunkId::new when unsure.

Only available in debug builds (tests). Use ChunkId::new in production.

pub fn from_u128(id: u128) -> ChunkId

pub fn arrow_from_slice(slice: &[ChunkId]) -> FixedSizeBinaryArray

impl ChunkId

pub fn partial_descriptor() -> ComponentDescriptor

Methods from Deref<Target = Tuid>

pub const ARROW_EXTENSION_NAME: &'static str = "rerun.datatypes.TUID"

pub const ZERO: Tuid

pub const MAX: Tuid

pub fn as_u128(&self) -> u128

pub fn as_bytes(&self) -> [u8; 16]

Returns most significant byte first (big endian).

pub fn nanos_since_epoch(&self) -> u64

Approximate nanoseconds since unix epoch.

The upper 64 bits of the Tuid.

pub fn inc(&self) -> u64

The increment part of the Tuid.

The lower 64 bits of the Tuid.

pub fn next(&self) -> Tuid

Returns the next logical Tuid.

Wraps the monotonically increasing back to zero on overflow.

Beware: wrong usage can easily lead to conflicts. Prefer Tuid::new when unsure.

pub fn incremented_by(&self, n: u64) -> Tuid

Returns the n-next logical Tuid.

This is equivalent to calling Tuid::next n times. Wraps the monotonically increasing back to zero on overflow.

Beware: wrong usage can easily lead to conflicts. Prefer Tuid::new when unsure.

pub fn short_string(&self) -> String

A shortened string representation of the Tuid.

Trait Implementations

impl AnyBitPattern for ChunkId

impl ArrowDataType for ChunkId

fn arrow_data_type() -> DataType

The underlying arrow::datatypes::DataType, excluding datatype extensions.

fn arrow_empty() -> Arc<dyn Array>

Returns an empty Arrow array that matches this type’s underlying datatype.

impl Clone for ChunkId

fn clone(&self) -> ChunkId

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Component for ChunkId

fn name() -> ComponentType

The fully-qualified type of this component, e.g. rerun.components.Position2D.

impl ConcreteType for ChunkId

where FixedSizeBinary<16>: ConcreteType,

fn data_type() -> DataType

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

fn build( values: impl Iterator<Item = Option<<ChunkId as LogicalType>::Owned>>, ) -> Result<Arc<dyn Array>, ColumnError>

Builds an arrow array of this data type from owned values.

impl Copy for ChunkId

impl Debug for ChunkId

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

Formats the value using the given formatter.

impl Deref for ChunkId

type Target = Tuid

The resulting type after dereferencing.

fn deref(&self) -> &<ChunkId as Deref>::Target

Dereferences the value.

impl DerefMut for ChunkId

fn deref_mut(&mut self) -> &mut <ChunkId as Deref>::Target

Mutably dereferences the value.

impl<'de> Deserialize<'de> for ChunkId

fn deserialize<__D>( __deserializer: __D, ) -> Result<ChunkId, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for ChunkId

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

Formats the value using the given formatter.

impl Eq for ChunkId

impl<'a> From<&'a ChunkId> for Cow<'a, ChunkId>

fn from(value: &'a ChunkId) -> Cow<'a, ChunkId>

Converts to this type from the input type.

impl From<ChunkId> for [u8; 16]

fn from(id: ChunkId) -> [u8; 16]

Converts to this type from the input type.

impl<'a> From<ChunkId> for Cow<'a, ChunkId>

fn from(value: ChunkId) -> Cow<'a, ChunkId>

Converts to this type from the input type.

impl From<[u8; 16]> for ChunkId

fn from(bytes: [u8; 16]) -> ChunkId

Converts to this type from the input type.

impl FromArrow for ChunkId

fn from_arrow(array: &dyn Array) -> Result<Vec<ChunkId>, DeserializationError>

Given an Arrow array, deserializes it into a collection of values.

fn verify_arrow_array(data: &dyn Array) -> Result<(), DeserializationError>

Verifies that the given Arrow array can be deserialized into a collection of Selfs.

impl FromStr for ChunkId

type Err = InvalidChunkIdError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<ChunkId, <ChunkId as FromStr>::Err>

Parses a string s to return a value of this type.

impl Hash for ChunkId

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl InfallibleBuild for ChunkId

where FixedSizeBinary<16>: InfallibleBuild,

impl LogicalType for ChunkId

const NULLABLE: bool = <quiver::FixedSizeBinary<16> as ::quiver_types::LogicalType>::NULLABLE

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

type Typed = <FixedSizeBinary<16> as LogicalType>::Typed

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

type Value<'a> = <FixedSizeBinary<16> as LogicalType>::Value<'a> where ChunkId: 'a

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

type Owned = ChunkId

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

type Optional = Option<ChunkId>

This type, made nullable: Option<Self> — except for Option<L>, which is already nullable and is its own Optional.

type Required = ChunkId

This type, made non-nullable: Self — except for Option<L>, whose Required is L’s (so every Option layer comes off).

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

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

fn is_null(typed: &<ChunkId as LogicalType>::Typed, index: usize) -> bool

Is the value at index null?

unsafe fn is_null_unchecked( typed: &<ChunkId as LogicalType>::Typed, index: usize, ) -> bool

Like is_null, but without the bounds check.

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

The value at index.

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

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

fn to_owned_value( value: <ChunkId as LogicalType>::Value<'_>, ) -> <ChunkId as LogicalType>::Owned

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

fn slice_typed( typed: &<ChunkId as LogicalType>::Typed, offset: usize, length: usize, ) -> Option<<ChunkId as LogicalType>::Typed>

The downcast view of the rows offset..offset + length, when this encoding can produce it without re-validating.

impl NoUninit for ChunkId

impl Ord for ChunkId

fn cmp(&self, other: &ChunkId) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

🔬This is a nightly-only experimental API. (clamp_to)

Restrict a value to a certain range.

impl PartialEq for ChunkId

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

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for ChunkId

fn partial_cmp(&self, other: &ChunkId) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl PrimitiveType for ChunkId

type Native = ChunkId

The in-memory element type: f32 for f32, i64 for Timestamp<…>, [u8; N] for [u8; N], etc.

fn values(typed: &<ChunkId as LogicalType>::Typed) -> &[ChunkId]

All values as one contiguous slice.

impl RefType for ChunkId

type Ref = ChunkId

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

fn value_ref(typed: &<ChunkId as LogicalType>::Typed, index: usize) -> &ChunkId

A reference to the value at index.

impl Serialize for ChunkId

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl SizeBytes for ChunkId

const IS_POD: bool = <re_tuid::Tuid as ::re_byte_size::SizeBytes>::IS_POD

fn heap_size_bytes(&self) -> u64

Returns how many bytes self uses on the heap.

fn total_size_bytes(&self) -> u64

Returns the total size of self in bytes, accounting for both stack and heap space.

fn stack_size_bytes(&self) -> u64

Returns the total size of self on the stack, in bytes.

impl StructuralPartialEq for ChunkId

impl ToArrow for ChunkId

fn to_arrow<'a>( values: impl IntoIterator<Item = impl Into<Cow<'a, ChunkId>>>, ) -> Result<Arc<dyn Array>, SerializationError>

Given an iterator of owned or reference values, serializes them into an Arrow array.

impl Zeroable for ChunkId

fn zeroed() -> Self

Calls zeroed.