Struct Freezer 

pub struct Freezer<E: Storage + Metrics + Clock, K: Array, V: CodecShared> { /* private fields */ }

Implementation of Freezer.

Implementations

impl<E: Storage + Metrics + Clock, K: Array, V: CodecShared> Freezer<E, K, V>

pub async fn init(context: E, config: Config<V::Cfg>) -> Result<Self, Error>

Initialize a new Freezer instance.

pub async fn init_with_checkpoint( context: E, config: Config<V::Cfg>, checkpoint: Option<Checkpoint>, ) -> Result<Self, Error>

Initialize a new Freezer instance with a Checkpoint.

pub async fn put(&mut self, key: K, value: V) -> Result<Cursor, Error>

Put a key-value pair into the Freezer. If the key already exists, the value is updated.

pub async fn get<'a>( &'a self, identifier: Identifier<'a, K>, ) -> Result<Option<V>, Error>

Get the value for a given Identifier.

If a Cursor is known for the required key, it is much faster to use it than searching for a key.

pub async fn sync(&mut self) -> Result<Checkpoint, Error>

Sync all pending data in Freezer.

If the table needs to be resized, the resize will begin during this sync. The resize operation is performed incrementally across multiple sync calls to avoid a large latency spike (or unexpected long latency for Freezer::put). Each sync will process up to table_resize_chunk_size entries until the resize is complete.

pub async fn close(self) -> Result<Checkpoint, Error>

Close the Freezer and return a Checkpoint for recovery.

pub async fn destroy(self) -> Result<(), Error>

Close and remove any underlying blobs created by the Freezer.

Trait Implementations

impl<E: Storage + Metrics + Clock, K: Array, V: CodecShared> Gettable for Freezer<E, K, V>

type Key = K

type Value = V

type Error = Error

async fn get(&self, key: &Self::Key) -> Result<Option<Self::Value>, Self::Error>

Get the value of a key.

impl<E: Storage + Metrics + Clock, K: Array, V: CodecShared> Persistable for Freezer<E, K, V>

type Error = Error

The error type returned when there is a failure from the underlying storage system.

async fn commit(&mut self) -> Result<(), Self::Error>

Durably persist the structure, guaranteeing the current state will survive a crash.

async fn sync(&mut self) -> Result<(), Self::Error>

Durably persist the structure, guaranteeing the current state will survive a crash, and that no recovery will be needed on startup.

async fn destroy(self) -> Result<(), Self::Error>

Destroy the structure, removing all associated storage.

impl<E: Storage + Metrics + Clock, K: Array, V: CodecShared> Updatable for Freezer<E, K, V>

async fn update( &mut self, key: Self::Key, value: Self::Value, ) -> Result<(), Self::Error>

Update the value of a key.

fn create<'a>( &'a mut self, key: Self::Key, value: Self::Value, ) -> impl Future<Output = Result<bool, Self::Error>> + Send + use<'a, Self>

where Self: Send,

Creates a new key-value pair in the db. Returns true if the key was created, false if it already existed. The key is not modified if it already existed.

fn upsert<'a, F>( &'a mut self, key: Self::Key, update: F, ) -> impl Future<Output = Result<(), Self::Error>> + Send + use<'a, Self, F>

where Self: Send, Self::Value: Default, F: FnOnce(&mut Self::Value) + Send + 'a,

Updates the value associated with the given key in the store, inserting a default value if the key does not already exist.