Struct re_entity_db::entity_db::EntityDb

pub struct EntityDb {
    pub data_source: Option<SmartChannelSource>,
    set_store_info: Option<SetStoreInfo>,
    last_modified_at: Instant,
    latest_row_id: Option<RowId>,
    entity_path_from_hash: IntMap<EntityPathHash, EntityPath>,
    times_per_timeline: TimesPerTimeline,
    time_histogram_per_timeline: TimeHistogramPerTimeline,
    tree: EntityTree,
    storage_engine: StorageEngine,
    stats: IngestionStatistics,
}

An in-memory database built from a stream of [LogMsg]es.

NOTE: all mutation is to be done via public functions!

Fields

data_source: Option<SmartChannelSource>

Set by whomever created this EntityDb.

Clones of an EntityDb gets a None source.

set_store_info: Option<SetStoreInfo>

Comes in a special message, [LogMsg::SetStoreInfo].

last_modified_at: Instant

Keeps track of the last time data was inserted into this store (viewer wall-clock).

latest_row_id: Option<RowId>

The highest RowId in the store, which corresponds to the last edit time. Ignores deletions.

entity_path_from_hash: IntMap<EntityPathHash, EntityPath>

In many places we just store the hashes, so we need a way to translate back.

times_per_timeline: TimesPerTimeline

The global-scope time tracker.

For each timeline, keeps track of what times exist, recursively across all entities/components.

Used for time control.

TODO(#7084): Get rid of TimesPerTimeline and implement time-stepping with crate::TimeHistogram instead.

time_histogram_per_timeline: TimeHistogramPerTimeline

A time histogram of all entities, for every timeline.

tree: EntityTree

A tree-view (split on path components) of the entities.

storage_engine: StorageEngine

The StorageEngine that backs this EntityDb.

This object and all its internal fields are never allowed to be publicly exposed, whether that is directly or through methods, even if that’s just shared references.

The only way to get access to the StorageEngine from the outside is to use EntityDb::storage_engine, which returns a read-only guard. The design statically guarantees the absence of deadlocks and race conditions that normally results from letting store and cache handles arbitrarily loose all across the codebase.

stats: IngestionStatistics

Implementations

impl EntityDb

pub fn new(store_id: StoreId) -> Self

pub fn with_store_config( store_id: StoreId, store_config: ChunkStoreConfig ) -> Self

pub fn tree(&self) -> &EntityTree

pub fn storage_engine(&self) -> StorageEngineReadGuard<'_>

Returns a read-only guard to the backing StorageEngine.

pub fn storage_engine_arc(&self) -> StorageEngineArcReadGuard

Returns a read-only guard to the backing StorageEngine.

That guard can be cloned at will and has a static lifetime.

It is not possible to insert any more data in this EntityDb until the returned guard, and any clones, have been dropped.

pub fn store_info_msg(&self) -> Option<&SetStoreInfo>

pub fn store_info(&self) -> Option<&StoreInfo>

pub fn app_id(&self) -> Option<&ApplicationId>

pub fn latest_at( &self, query: &LatestAtQuery, entity_path: &EntityPath, component_names: impl IntoIterator<Item = ComponentName> ) -> LatestAtResults

Queries for the given component_names using latest-at semantics.

See re_query::LatestAtResults for more information about how to handle the results.

This is a cached API – data will be lazily cached upon access.

pub fn latest_at_component<C: Component>( &self, entity_path: &EntityPath, query: &LatestAtQuery ) -> Option<((TimeInt, RowId), C)>

Get the latest index and value for a given dense [re_types_core::Component].

This assumes that the row we get from the store contains at most one instance for this component; it will log a warning otherwise.

This should only be used for “mono-components” such as Transform and Tensor.

This is a best-effort helper, it will merely log errors on failure.

pub fn latest_at_component_quiet<C: Component>( &self, entity_path: &EntityPath, query: &LatestAtQuery ) -> Option<((TimeInt, RowId), C)>

Get the latest index and value for a given dense [re_types_core::Component].

This assumes that the row we get from the store contains at most one instance for this component; it will log a warning otherwise.

This should only be used for “mono-components” such as Transform and Tensor.

This is a best-effort helper, and will quietly swallow any errors.

pub fn latest_at_component_at_closest_ancestor<C: Component>( &self, entity_path: &EntityPath, query: &LatestAtQuery ) -> Option<(EntityPath, (TimeInt, RowId), C)>

pub fn store_kind(&self) -> StoreKind

pub fn store_id(&self) -> StoreId

pub fn cloned_from(&self) -> Option<&StoreId>

If this entity db is the result of a clone, which store was it cloned from?

A cloned store always gets a new unique ID.

We currently only use entity db cloning for blueprints: when we activate a default blueprint that was received on the wire (e.g. from a recording), we clone it and make the clone the active blueprint. This means all active blueprints are clones.

pub fn timelines(&self) -> impl ExactSizeIterator<Item = &Timeline>

pub fn times_per_timeline(&self) -> &TimesPerTimeline

pub fn has_any_data_on_timeline(&self, timeline: &Timeline) -> bool

pub fn time_range_for(&self, timeline: &Timeline) -> Option<ResolvedTimeRange>

Returns the time range of data on the given timeline, ignoring any static times.

pub fn time_histogram(&self, timeline: &Timeline) -> Option<&TimeHistogram>

Histogram of all events on the timeeline, of all entities.

pub fn num_rows(&self) -> u64

pub fn generation(&self) -> ChunkStoreGeneration

Return the current ChunkStoreGeneration. This can be used to determine whether the database has been modified since the last time it was queried.

pub fn last_modified_at(&self) -> Instant

pub fn latest_row_id(&self) -> Option<RowId>

The highest RowId in the store, which corresponds to the last edit time. Ignores deletions.

pub fn is_empty(&self) -> bool

pub fn entity_paths(&self) -> Vec<&EntityPath>

A sorted list of all the entity paths in this database.

pub fn ingestion_stats(&self) -> &IngestionStatistics

pub fn entity_path_from_hash( &self, entity_path_hash: &EntityPathHash ) -> Option<&EntityPath>

pub fn is_known_entity(&self, entity_path: &EntityPath) -> bool

Returns true also for entities higher up in the hierarchy.

pub fn is_logged_entity(&self, entity_path: &EntityPath) -> bool

If you log world/points, then that is a logged entity, but world is not, unless you log something to world too.

pub fn add(&mut self, msg: &LogMsg) -> Result<Vec<ChunkStoreEvent>, Error>

pub fn add_chunk( &mut self, chunk: &Arc<Chunk> ) -> Result<Vec<ChunkStoreEvent>, Error>

pub fn set_store_info(&mut self, store_info: SetStoreInfo)

pub fn gc_everything_but_the_latest_row_on_non_default_timelines( &mut self ) -> Vec<ChunkStoreEvent>

pub fn purge_fraction_of_ram( &mut self, fraction_to_purge: f32 ) -> Vec<ChunkStoreEvent>

Free up some RAM by forgetting the older parts of all timelines.

pub(crate) fn gc( &mut self, gc_options: &GarbageCollectionOptions ) -> Vec<ChunkStoreEvent>

pub fn drop_time_range( &mut self, timeline: &Timeline, drop_range: ResolvedTimeRange ) -> Vec<ChunkStoreEvent>

Drop all events in the given time range from the given timeline.

Used to implement undo (erase the last event from the blueprint db).

pub fn drop_entity_path(&mut self, entity_path: &EntityPath)

Unconditionally drops all the data for a given [EntityPath] .

This is not recursive. Children of this entity will not be affected.

To drop the entire subtree below an entity, see: Self::drop_entity_path_recursive.

pub fn drop_entity_path_recursive(&mut self, entity_path: &EntityPath)

Unconditionally drops all the data for a given [EntityPath] and all its children.

fn on_store_deletions( times_per_timeline: &mut TimesPerTimeline, time_histogram_per_timeline: &mut TimeHistogramPerTimeline, tree: &mut EntityTree, engine: StorageEngineWriteGuard<'_>, store_events: &[ChunkStoreEvent] )

pub fn sort_key(&self) -> impl Ord + '_

Key used for sorting recordings in the UI.

pub fn to_messages( &self, time_selection: Option<(Timeline, ResolvedTimeRangeF)> ) -> impl Iterator<Item = ChunkResult<LogMsg>> + '_

Export the contents of the current database to a sequence of messages.

If time_selection is specified, then only data for that specific timeline over that specific time range will be accounted for.

pub fn clone_with_new_id(&self, new_id: StoreId) -> Result<Self, Error>

Make a clone of this EntityDb, assigning it a new [StoreId].

impl EntityDb

Stats

pub fn subtree_stats_static( &self, engine: &StorageEngineReadGuard<'_>, entity_path: &EntityPath ) -> ChunkStoreChunkStats

Returns the stats for the static store of the entity and all its children, recursively.

This excludes temporal data.

pub fn subtree_stats_on_timeline( &self, engine: &StorageEngineReadGuard<'_>, entity_path: &EntityPath, timeline: &Timeline ) -> ChunkStoreChunkStats

Returns the stats for the entity and all its children on the given timeline, recursively.

This excludes static data.

pub fn subtree_has_data_on_timeline( &self, engine: &StorageEngineReadGuard<'_>, timeline: &Timeline, entity_path: &EntityPath ) -> bool

Returns true if an entity or any of its children have any data on the given timeline.

This includes static data.

pub fn subtree_has_temporal_data_on_timeline( &self, engine: &StorageEngineReadGuard<'_>, timeline: &Timeline, entity_path: &EntityPath ) -> bool

Returns true if an entity or any of its children have any temporal data on the given timeline.

This ignores static data.

Trait Implementations

impl SizeBytes for EntityDb

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?