Struct KeyValueDispatch 

pub struct KeyValueDispatch { /* private fields */ }

Implementations

impl KeyValueDispatch

pub fn new( allowed_stores: HashSet<String>, manager: Arc<dyn StoreManager>, ) -> Self

pub fn new_with_capacity( allowed_stores: HashSet<String>, manager: Arc<dyn StoreManager>, capacity: u32, otel: OtelFactorState, ) -> Self

pub fn get_store<T: 'static>( &self, store: Resource<T>, ) -> Result<&Arc<dyn Store>>

pub fn get_cas<T: 'static>(&self, cas: Resource<T>) -> Result<&Arc<dyn Cas>>

pub fn allowed_stores(&self) -> &HashSet<String>

pub fn get_store_wasi<T: 'static>( &self, store: Resource<T>, ) -> Result<&Arc<dyn Store>, Error>

pub fn get_cas_wasi<T: 'static>( &self, cas: Resource<T>, ) -> Result<&Arc<dyn Cas>, Error>

pub fn manager_metadata(&self) -> Arc<dyn Any>

Trait Implementations

impl HasData for KeyValueDispatch

type Data<'a> = &'a mut KeyValueDispatch

The data associated with this trait implementation, chiefly used as a generic associated type to allow plumbing the 'a lifetime into the definition here.

impl Host for KeyValueDispatch

async fn open(&mut self, identifier: String) -> Result<Resource<Bucket>, Error>

Get the bucket with the specified identifier.

fn convert_error(&mut self, error: Error) -> Result<Error, Error>

impl Host for KeyValueDispatch

async fn get_many( &mut self, bucket: Resource<Bucket>, keys: Vec<String>, ) -> Result<Vec<(String, Option<Vec<u8>>)>, Error>

Get the key-value pairs associated with the keys in the store. It returns a list of key-value pairs.

async fn set_many( &mut self, bucket: Resource<Bucket>, key_values: Vec<(String, Vec<u8>)>, ) -> Result<(), Error>

Set the values associated with the keys in the store. If the key already exists in the store, it overwrites the value.

async fn delete_many( &mut self, bucket: Resource<Bucket>, keys: Vec<String>, ) -> Result<(), Error>

Delete the key-value pairs associated with the keys in the store.

impl Host for KeyValueDispatch

fn convert_cas_error(&mut self, error: CasError) -> Result<CasError, Error>

async fn increment( &mut self, bucket: Resource<Bucket>, key: String, delta: i64, ) -> Result<i64, Error>

Atomically increment the value associated with the key in the store by the given delta. It returns the new value.

async fn swap( &mut self, cas_res: Resource<Cas>, value: Vec<u8>, ) -> Result<(), CasError>

Perform the swap on a CAS operation. This consumes the CAS handle and returns an error if the CAS operation failed.

impl Host for KeyValueDispatch

async fn open(&mut self, name: String) -> Result<Result<u32, LegacyError>>

Open the store with the specified name.

async fn get( &mut self, store: u32, key: String, ) -> Result<Result<Vec<u8>, LegacyError>>

Get the value associated with the specified key from the specified store.

async fn set( &mut self, store: u32, key: String, value: Vec<u8>, ) -> Result<Result<(), LegacyError>>

Set the value associated with the specified key in the specified store, overwriting any existing value.

async fn delete( &mut self, store: u32, key: String, ) -> Result<Result<(), LegacyError>>

Delete the tuple with the specified key from the specified store.

async fn exists( &mut self, store: u32, key: String, ) -> Result<Result<bool, LegacyError>>

Return whether a tuple exists for the specified key in the specified store.

async fn get_keys( &mut self, store: u32, ) -> Result<Result<Vec<String>, LegacyError>>

Return a list of all the keys in the specified store.

async fn close(&mut self, store: u32) -> Result<()>

Close the specified store.

impl HostBucket for KeyValueDispatch

async fn get( &mut self, self_: Resource<Bucket>, key: String, ) -> Result<Option<Vec<u8>>, Error>

Get the value associated with the specified key

async fn set( &mut self, self_: Resource<Bucket>, key: String, value: Vec<u8>, ) -> Result<(), Error>

Set the value associated with the key in the store. If the key already exists in the store, it overwrites the value.

async fn delete( &mut self, self_: Resource<Bucket>, key: String, ) -> Result<(), Error>

Delete the key-value pair associated with the key in the store.

async fn exists( &mut self, self_: Resource<Bucket>, key: String, ) -> Result<bool, Error>

Check if the key exists in the store.

async fn list_keys( &mut self, self_: Resource<Bucket>, cursor: Option<String>, ) -> Result<KeyResponse, Error>

Get all the keys in the store with an optional cursor (for use in pagination). It returns a list of keys. Please note that for most KeyValue implementations, this is a can be a very expensive operation and so it should be used judiciously. Implementations can return any number of keys in a single response, but they should never attempt to send more data than is reasonable (i.e. on a small edge device, this may only be a few KB, while on a large machine this could be several MB). Any response should also return a cursor that can be used to fetch the next page of keys. See the key-response record for more information.

async fn drop(&mut self, rep: Resource<Bucket>) -> Result<()>

impl HostCas for KeyValueDispatch

async fn new( &mut self, bucket: Resource<Bucket>, key: String, ) -> Result<Resource<Cas>, Error>

Construct a new CAS operation. Implementors can map the underlying functionality (transactions, versions, etc) as desired.

async fn current( &mut self, cas: Resource<Cas>, ) -> Result<Option<Vec<u8>>, Error>

Get the current value of the key (if it exists). This allows for avoiding reads if all that is needed to ensure the atomicity of the operation

async fn drop(&mut self, rep: Resource<Cas>) -> Result<()>

impl HostStore for KeyValueDispatch

async fn open(&mut self, name: String) -> Result<Result<Resource<Store>, Error>>

Open the store with the specified label.

async fn get( &mut self, store: Resource<Store>, key: String, ) -> Result<Result<Option<Vec<u8>>, Error>>

Get the value associated with the specified key

async fn set( &mut self, store: Resource<Store>, key: String, value: Vec<u8>, ) -> Result<Result<(), Error>>

Set the value associated with the specified key overwriting any existing value.

async fn delete( &mut self, store: Resource<Store>, key: String, ) -> Result<Result<(), Error>>

Delete the tuple with the specified key

async fn exists( &mut self, store: Resource<Store>, key: String, ) -> Result<Result<bool, Error>>

Return whether a tuple exists for the specified key

async fn get_keys( &mut self, store: Resource<Store>, ) -> Result<Result<Vec<String>, Error>>

Return a list of all the keys

async fn drop(&mut self, store: Resource<Store>) -> Result<()>

impl HostStore for KeyValueDispatch

async fn drop(&mut self, store: Resource<Store>) -> Result<()>

impl Host for KeyValueDispatch

impl Host for KeyValueDispatch