Struct re_chunk::RowId

pub struct RowId(pub(crate) Tuid);

A unique ID for a row’s worth of data within a chunk.

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

Uniqueness

Duplicated RowIds within a single recording is considered undefined behavior.

While it is benign in most cases, care has to be taken when manually crafting RowIds. Ideally: don’t do so and stick to RowId::new instead to avoid bad surprises.

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

Query

Queries (both latest-at & range semantics) will defer to RowId order as a tie-breaker when looking at several rows worth of data that rest at the exact same timestamp.

In pseudo-code:

rr.set_time_sequence("frame", 10)

rr.log("my_entity", point1, row_id=#1)
rr.log("my_entity", point2, row_id=#0)

rr.query("my_entity", at=("frame", 10))  # returns `point1`

Think carefully about your RowIds when logging a lot of data at the same timestamp.

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.

Tuple Fields

0: Tuid

Implementations

impl RowId

pub const ZERO: Self = _

pub const MAX: Self = _

pub fn new() -> Self

Create a new unique RowId based on the current time.

pub fn from_tuid(tuid: Tuid) -> Self

pub fn next(&self) -> Self

Returns the next logical RowId.

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

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

Returns the n-next logical RowId.

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

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

pub fn nanoseconds_since_epoch(&self) -> u64

When the RowId was created, in nanoseconds since unix epoch.

pub fn from_u128(id: u128) -> Self

pub fn as_u128(&self) -> u128

Methods from Deref<Target = Tuid>

pub fn heap_size_bytes(&self) -> u64

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

NOTE: This crate cannot depend on re_types_core, therefore the actual implementation of SizeBytes for Tuid lives in re_types_core and calls this method.

pub const ZERO: Tuid = _

pub const MAX: Tuid = _

pub fn as_u128(&self) -> u128

pub fn nanoseconds_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 Clone for RowId

fn clone(&self) -> RowId

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for RowId

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

Formats the value using the given formatter.

impl Deref for RowId

type Target = Tuid

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for RowId

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'de> Deserialize<'de> for RowId

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for RowId

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

Formats the value using the given formatter.

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

fn from(value: &'a RowId) -> Self

Converts to this type from the input type.

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

fn from(value: RowId) -> Self

Converts to this type from the input type.

impl Hash for RowId

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

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 Loggable for RowId

type Name = ComponentName

fn name() -> Self::Name

The fully-qualified name of this loggable, e.g. rerun.datatypes.Vec2D.

fn arrow_datatype() -> DataType

The underlying [arrow2::datatypes::DataType], excluding datatype extensions.

fn to_arrow_opt<'a>( values: impl IntoIterator<Item = Option<impl Into<Cow<'a, Self>>>> ) -> SerializationResult<Box<dyn Array>>

where Self: 'a,

Given an iterator of options of owned or reference values to the current [Loggable], serializes them into an Arrow array.

fn to_arrow<'a>( values: impl IntoIterator<Item = impl Into<Cow<'a, Self>>> ) -> SerializationResult<Box<dyn Array>>

Given an iterator of owned or reference values to the current [Loggable], serializes them into an Arrow array.

fn from_arrow(array: &dyn Array) -> DeserializationResult<Vec<Self>>

Given an Arrow array, deserializes it into a collection of [Loggable]s.

fn from_arrow_opt( data: &(dyn Array + 'static) ) -> Result<Vec<Option<Self>>, DeserializationError>

Given an Arrow array, deserializes it into a collection of optional [Loggable]s.

impl Ord for RowId

fn cmp(&self, other: &RowId) -> 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 + PartialOrd,

Restrict a value to a certain interval.

impl PartialEq for RowId

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for RowId

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

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

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl Serialize for RowId

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl SizeBytes for RowId

fn heap_size_bytes(&self) -> u64

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

fn is_pod() -> bool

Is Self just plain old data?

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 Copy for RowId

impl Eq for RowId

impl StructuralPartialEq for RowId