Struct persist::indexed::AppliedState

struct AppliedState {
    saved_seqno: SeqNo,
    highest_assigned_seqno: SeqNo,
    id_mapping: Vec<StreamRegistration>,
    graveyard: Vec<StreamRegistration>,
    arrangements: BTreeMap<Id, Arrangement>,
}

The cumulative state that results from applying some prefix of the persist state change log.

BlobMeta is the serialized version of exactly this state.

Fields

saved_seqno: SeqNo

highest_assigned_seqno: SeqNo

id_mapping: Vec<StreamRegistration>

graveyard: Vec<StreamRegistration>

arrangements: BTreeMap<Id, Arrangement>

Implementations

impl AppliedState

fn new(meta: BlobMeta) -> Self

fn assign_seqno(&mut self) -> SeqNo

impl AppliedState

fn do_load(
    &mut self,
    id_str: &str,
    key_codec_name: &str,
    val_codec_name: &str
) -> Result<Option<Id>, Error>

fn do_register(
    &mut self,
    id_str: &str,
    key_codec_name: &str,
    val_codec_name: &str
) -> Result<Id, Error>

fn do_destroy(&mut self, id_str: &str) -> Result<bool, Error>

impl AppliedState

fn compact_unsealed(&mut self) -> Result<Vec<UnsealedBatchMeta>, Error>

impl AppliedState

fn validate_write(
    &mut self,
    updates: &[(Id, ColumnarRecords)]
) -> Result<(), String>

fn drain_pending_writes<B: Blob>(
    &mut self,
    writes_by_id: HashMap<Id, Vec<ColumnarRecords>>,
    blob: &mut BlobCache<B>
) -> Result<(), Error>

Drain pending writes to unsealed.

The caller is responsible for committing metadata after this succeeds, and restoring metadata if this fails.

impl AppliedState

fn drain_pending_writes_inner<B: Blob>(
    &mut self,
    id: Id,
    updates: Vec<ColumnarRecords>,
    desc: &Range<SeqNo>,
    blob: &mut BlobCache<B>
) -> Result<(), Error>

Construct a new BlobUnsealedBatch out of the provided updates and add it to the unsealed for id.

The caller is responsible for updating META after they’ve finished updating unsealeds.

fn drain_unsealed<B: Blob>(
    &mut self,
    blob: &mut BlobCache<B>
) -> Result<(), Error>

Atomically moves all writes in unsealed not in advance of the trace’s seal frontier into the trace and does any necessary resulting eviction work to remove unnecessary batches.

fn sealed_frontier(&self, id: Id) -> Result<Antichain<u64>, String>

Returns the current “sealed” frontier for an id.

This frontier represents a contract of time such that all updates with a time less than it have arrived. This frontier is advanced though the seal method. Once a time has been sealed for an id, it becomes an error to later seal it at an time less than the sealed frontier. It is also an error to write new data with a time less than the sealed frontier.

fn do_seal(&mut self, ids: &[Id], seal_ts: u64) -> Result<(), String>

Apply a seal command to in-memory state if it is valid.

fn do_get_description(&self, name: &str) -> Result<Description<u64>, Error>

fn do_allow_compaction(
    &mut self,
    id_sinces: Vec<(Id, Antichain<u64>)>
) -> Result<(), String>

fn append_unsealed<B: Blob>(
    &mut self,
    id: Id,
    batch: BlobUnsealedBatch,
    blob: &mut BlobCache<B>
) -> Result<(), Error>

Appends the given batch to the unsealed for id, writing the data into blob storage.

The caller is responsible for updating META after they’ve finished updating unsealeds.

fn serialize_meta(&self) -> BlobMeta

fn do_snapshot<B: BlobRead>(
    &self,
    id: Id,
    blob: &BlobCache<B>
) -> Result<ArrangementSnapshot, Error>

Trait Implementations

impl Debug for AppliedState

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

Formats the value using the given formatter.