Struct re_chunk::chunk::TimeColumn

pub struct TimeColumn {
    pub(crate) timeline: Timeline,
    pub(crate) times: PrimitiveArray<i64>,
    pub(crate) is_sorted: bool,
    pub(crate) time_range: ResolvedTimeRange,
}

Fields

timeline: Timeline

times: PrimitiveArray<i64>

Every single timestamp for this timeline.

• This might or might not be sorted, depending on how the data was logged.
• This is guaranteed to always be dense, because chunks are split anytime a timeline is added or removed.
• This cannot ever contain TimeInt::STATIC, since static data doesn’t even have timelines.

is_sorted: bool

Is Self::times sorted?

This is completely independent of Chunk::is_sorted: a timeline doesn’t necessarily follow the global RowId-based order, although it does in most cases (happy path).

time_range: ResolvedTimeRange

The time range covered by Self::times.

Not necessarily contiguous! Just the min and max value found in Self::times.

Implementations

impl TimeColumn

pub fn builder(timeline: Timeline) -> TimeColumnBuilder

Initializes a new TimeColumnBuilder.

impl TimeColumn

pub fn new( is_sorted: Option<bool>, timeline: Timeline, times: ArrowPrimitiveArray<i64> ) -> Self

Creates a new TimeColumn.

Iff you know for sure whether the data is already appropriately sorted or not, specify is_sorted. When left unspecified (None), it will be computed in O(n) time.

For a row-oriented constructor, see Self::builder.

pub fn new_sequence( name: impl Into<TimelineName>, times: impl IntoIterator<Item = impl Into<i64>> ) -> Self

Creates a new TimeColumn of sequence type.

pub fn new_seconds( name: impl Into<TimelineName>, times: impl IntoIterator<Item = impl Into<f64>> ) -> Self

Creates a new TimeColumn of sequence type.

pub fn new_nanos( name: impl Into<TimelineName>, times: impl IntoIterator<Item = impl Into<i64>> ) -> Self

Creates a new TimeColumn of nanoseconds type.

impl TimeColumn

pub fn timeline(&self) -> &Timeline

pub fn name(&self) -> &str

pub fn time_range(&self) -> ResolvedTimeRange

pub fn times_array(&self) -> &ArrowPrimitiveArray<i64>

pub fn times_raw(&self) -> &[i64]

pub fn times(&self) -> impl DoubleEndedIterator<Item = TimeInt> + '_

pub fn num_rows(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn time_range_per_component( &self, components: &BTreeMap<ComponentName, ArrowListArray<i32>> ) -> BTreeMap<ComponentName, ResolvedTimeRange>

Computes the time range covered by each individual component column.

This is different from the time range covered by the TimeColumn as a whole because component columns are potentially sparse.

This is crucial for indexing and queries to work properly.

impl TimeColumn

pub fn sanity_check(&self) -> ChunkResult<()>

Returns an error if the Chunk’s invariants are not upheld.

Costly checks are only run in debug builds.

impl TimeColumn

pub fn concatenated(&self, rhs: &Self) -> Option<Self>

Concatenates two TimeColumns into a new one.

The order of the arguments matter: self‘s contents will precede rhs’ contents in the returned TimeColumn.

This will return None if the time chunks do not share the same timeline.

impl TimeColumn

pub fn is_sorted(&self) -> bool

Is the timeline sorted?

This is O(1) (cached).

See also Self::is_sorted_uncached.

pub fn is_sorted_uncached(&self) -> bool

Like Self::is_sorted, but actually checks the entire dataset rather than relying on the cached value.

O(n). Useful for tests/debugging, or when you just don’t know.

See also Self::is_sorted.

impl TimeColumn

pub fn row_sliced(&self, index: usize, len: usize) -> Self

Slices the TimeColumn vertically.

The result is a new TimeColumn with the same timelines and (potentially) less rows.

This cannot fail nor panic: index and len will be capped so that they cannot run out of bounds. This can result in an empty TimeColumn being returned if the slice is completely OOB.

pub fn emptied(&self) -> Self

Empties the TimeColumn vertically.

The result is a new TimeColumn with the same columns but zero rows.

pub(crate) fn filtered(&self, filter: &ArrowBooleanArray) -> Self

Runs a filter compute kernel on the time data with the specified mask.

pub(crate) fn taken<O: Index>(&self, indices: &ArrowPrimitiveArray<O>) -> Self

Runs a take compute kernel on the time data with the specified indices.

Trait Implementations

impl Clone for TimeColumn

fn clone(&self) -> TimeColumn

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for TimeColumn

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

Formats the value using the given formatter.

impl PartialEq for TimeColumn

fn eq(&self, other: &TimeColumn) -> 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 SizeBytes for TimeColumn

fn heap_size_bytes(&self) -> u64

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

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.

fn is_pod() -> bool

Is Self just plain old data?

impl StructuralPartialEq for TimeColumn