Struct linera_views::backends::value_splitting::ValueSplittingStore

pub struct ValueSplittingStore<K> { /* private fields */ }

A key-value store with no size limit for values.

It wraps a key-value store, potentially with a size limit, and automatically splits up large values into smaller ones. A single logical key-value pair is stored as multiple smaller key-value pairs in the wrapped store. See the README.md for additional details.

Implementations

impl<K> ValueSplittingStore<K>

where K: WithError,

pub fn new(store: K) -> Self

Creates a new store that deals with big values from one that does not.

Trait Implementations

impl<K> AdminKeyValueStore for ValueSplittingStore<K>

where K: AdminKeyValueStore + Send + Sync, K::Error: 'static,

type Config = <K as AdminKeyValueStore>::Config

The configuration needed to interact with a new store.

fn get_name() -> String

The name of this class of stores

async fn connect( config: &Self::Config, namespace: &str, root_key: &[u8], ) -> Result<Self, Self::Error>

Connects to an existing namespace using the given configuration.

fn clone_with_root_key(&self, root_key: &[u8]) -> Result<Self, Self::Error>

Takes a connection and creates a new one with a different root_key.

async fn list_all(config: &Self::Config) -> Result<Vec<String>, Self::Error>

Obtains the list of existing namespaces.

async fn list_root_keys( config: &Self::Config, namespace: &str, ) -> Result<Vec<Vec<u8>>, Self::Error>

Lists the root keys of the namespace. It is possible that some root keys have no keys.

async fn delete_all(config: &Self::Config) -> Result<(), Self::Error>

Deletes all the existing namespaces.

async fn exists( config: &Self::Config, namespace: &str, ) -> Result<bool, Self::Error>

Tests if a given namespace exists.

async fn create( config: &Self::Config, namespace: &str, ) -> Result<(), Self::Error>

Creates a namespace. Returns an error if the namespace exists.

async fn delete( config: &Self::Config, namespace: &str, ) -> Result<(), Self::Error>

Deletes the given namespace.

fn maybe_create_and_connect( config: &Self::Config, namespace: &str, root_key: &[u8], ) -> impl Future<Output = Result<Self, Self::Error>> + Send

Initializes a storage if missing and provides it.

fn recreate_and_connect( config: &Self::Config, namespace: &str, root_key: &[u8], ) -> impl Future<Output = Result<Self, Self::Error>> + Send

Creates a new storage. Overwrites it if this namespace already exists.

impl<K: Clone> Clone for ValueSplittingStore<K>

fn clone(&self) -> ValueSplittingStore<K>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<K> ReadableKeyValueStore for ValueSplittingStore<K>

where K: ReadableKeyValueStore + Send + Sync, K::Error: 'static,

const MAX_KEY_SIZE: usize = _

The maximal size of keys that can be stored.

type Keys = Vec<Vec<u8>>

Returns type for key search operations.

type KeyValues = Vec<(Vec<u8>, Vec<u8>)>

Returns type for key-value search operations.

fn max_stream_queries(&self) -> usize

Retrieve the number of stream queries.

async fn read_value_bytes( &self, key: &[u8], ) -> Result<Option<Vec<u8>>, Self::Error>

Retrieves a Vec<u8> from the database using the provided key.

async fn contains_key(&self, key: &[u8]) -> Result<bool, Self::Error>

Tests whether a key exists in the database

async fn contains_keys( &self, keys: Vec<Vec<u8>>, ) -> Result<Vec<bool>, Self::Error>

Tests whether a list of keys exist in the database

async fn read_multi_values_bytes( &self, keys: Vec<Vec<u8>>, ) -> Result<Vec<Option<Vec<u8>>>, Self::Error>

Retrieves multiple Vec<u8> from the database using the provided keys.

async fn find_keys_by_prefix( &self, key_prefix: &[u8], ) -> Result<Self::Keys, Self::Error>

Finds the key matching the prefix. The prefix is not included in the returned keys.

async fn find_key_values_by_prefix( &self, key_prefix: &[u8], ) -> Result<Self::KeyValues, Self::Error>

Finds the (key,value) pairs matching the prefix. The prefix is not included in the returned keys.

fn read_value<V: DeserializeOwned>( &self, key: &[u8], ) -> impl Future<Output = Result<Option<V>, Self::Error>> + Send

where Self: Sync,

Reads a single key and deserializes the result if present.

fn read_multi_values<V: DeserializeOwned + Send>( &self, keys: Vec<Vec<u8>>, ) -> impl Future<Output = Result<Vec<Option<V>>, Self::Error>> + Send

where Self: Sync,

Reads multiple keys and deserializes the results if present.

impl<K> TestKeyValueStore for ValueSplittingStore<K>

where K: TestKeyValueStore + Send + Sync, K::Error: 'static,

async fn new_test_config() -> Result<K::Config, Self::Error>

Obtains a test config

fn new_test_store() -> impl Future<Output = Result<Self, Self::Error>> + Send

Creates a store for testing purposes

impl<K> WithError for ValueSplittingStore<K>

where K: WithError, K::Error: 'static,

type Error = ValueSplittingError<<K as WithError>::Error>

The error type.

impl<K> WritableKeyValueStore for ValueSplittingStore<K>

where K: WritableKeyValueStore + Send + Sync, K::Error: 'static,

const MAX_VALUE_SIZE: usize = 18_446_744_073_709_551_615usize

The maximal size of values that can be stored.

async fn write_batch(&self, batch: Batch) -> Result<(), Self::Error>

Writes the batch in the database.

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

Clears any journal entry that may remain. The journal is located at the root_key.