Struct exocore_store::local::EntityIndex

pub struct EntityIndex<CS, PS> where
    CS: ChainStore,
    PS: PendingStore,  { /* fields omitted */ }

Manages and index entities and their traits stored in the chain and pending store of the chain layer. The index accepts mutations from the chain layer through its event stream, and manages both indices to be consistent.

The chain index is persisted on disk, while the pending store index is an in-memory index. Since the persistence in the chain is not definitive until blocks and their operations (entity mutations) are stored at a certain depth, a part of the chain is actually indexed in the in-memory index. Once they reach a certain depth, they are persisted in the chain index.

Implementations

impl<CS, PS> EntityIndex<CS, PS> where
    CS: ChainStore,
    PS: PendingStore, 

pub fn open_or_create(
    cell: FullCell,
    config: EntityIndexConfig,
    chain_handle: EngineHandle<CS, PS>,
    clock: Clock
) -> Result<EntityIndex<CS, PS>, Error>

Opens or create an entities index

pub fn handle_chain_engine_event(
    &mut self,
    event: Event
) -> Result<(Vec<OperationId>, usize), Error>

pub fn handle_chain_engine_events<E>(
    &mut self,
    events: E
) -> Result<(Vec<OperationId>, usize), Error> where
    E: Iterator<Item = Event>, 

Handles events coming from the chain layer. These events allow keeping the index consistent with the chain layer, up to the consistency guarantees that the layer offers. Returns operations that have been involved and the number of index operations applied.

Since the events stream is buffered, we may receive a discontinuity if the chain layer couldn’t send us an event. In that case, we re-index the pending index since we can’t guarantee that we didn’t lose an event.

pub fn search<Q: Borrow<EntityQuery>>(
    &self,
    query: Q
) -> Result<EntityResults, Error>

Executes a search query on the indices, and returning all entities matching the query.

pub fn run_garbage_collector(&self) -> Result<Vec<EntityMutation>, Error>

Calls the garbage collector to run a pass on entities that got flagged and generates deletion mutations.

pub fn fetch_aggregated_entity_mutations(
    &self,
    entity_id: &str
) -> Result<EntityAggregator, Error>

Fetches indexed mutations metadata from pending and chain indices for this entity id and aggregate them.

pub fn fetch_entity_mutations_metadata(
    &self,
    entity_id: &str
) -> Result<impl Iterator<Item = MutationMetadata>, Error>

Fetches indexed mutations metadata from pending and chain indices for this entity id.