Trait bonsaidb::core::keyvalue::AsyncKeyValue

pub trait AsyncKeyValue: Sized + Send + Sync {
    // Required method
    fn execute_key_operation<'life0, 'async_trait>(
        &'life0 self,
        op: KeyOperation
    ) -> Pin<Box<dyn Future<Output = Result<Output, Error>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait;

    // Provided methods
    fn set_key<S, V, 'a>(
        &'a self,
        key: S,
        value: &'a V
    ) -> AsyncBuilder<'a, Self, V> 
       where S: Into<String>,
             V: Serialize + Send + Sync { ... }
    fn set_binary_key<S, 'a>(
        &'a self,
        key: S,
        bytes: &'a [u8]
    ) -> AsyncBuilder<'a, Self, ()> 
       where S: Into<String> { ... }
    fn set_numeric_key<S, V>(
        &self,
        key: S,
        value: V
    ) -> AsyncBuilder<'_, Self, ()> 
       where S: Into<String>,
             V: Into<Numeric> { ... }
    fn increment_key_by<S, V>(
        &self,
        key: S,
        value: V
    ) -> AsyncBuilder<'_, Self, V> 
       where S: Into<String> + Send + Sync,
             V: Into<Numeric> + TryFrom<Numeric, Error = IncompatibleTypeError> + Send + Sync { ... }
    fn decrement_key_by<S, V>(
        &self,
        key: S,
        value: V
    ) -> AsyncBuilder<'_, Self, V> 
       where S: Into<String> + Send + Sync,
             V: Into<Numeric> + TryFrom<Numeric, Error = IncompatibleTypeError> + Send + Sync { ... }
    fn get_key<S>(&self, key: S) -> AsyncBuilder<'_, Self> 
       where S: Into<String> { ... }
    fn delete_key<'life0, 'async_trait, S>(
        &'life0 self,
        key: S
    ) -> Pin<Box<dyn Future<Output = Result<KeyStatus, Error>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             S: 'async_trait + Into<String> + Send,
             Self: 'async_trait { ... }
    fn key_namespace(&self) -> Option<&str> { ... }
    fn with_key_namespace(&self, namespace: &str) -> Namespaced<'_, Self> { ... }
}

Key-Value store methods. The Key-Value store is designed to be a high-performance, lightweight storage mechanism.

When compared to Collections, the Key-Value store does not offer ACID-compliant transactions. Instead, the Key-Value store is made more efficient by periodically flushing the store to disk rather than during each operation. As such, the Key-Value store is intended to be used as a lightweight caching layer. However, because each of the operations it supports are executed atomically, the Key-Value store can also be utilized for synchronized locking.

Floating Point Operations

When using KeyValue::set_numeric_key() or any numeric operations, if a Not a Number (NaN) value is encountered, Error::NotANumber will be returned without allowing the operation to succeed.

Positive and negative infinity values are allowed, as they do not break comparison operations.

Required Methods

fn execute_key_operation<'life0, 'async_trait>( &'life0 self, op: KeyOperation ) -> Pin<Box<dyn Future<Output = Result<Output, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Executes a single KeyOperation.

Provided Methods

fn set_key<S, V, 'a>( &'a self, key: S, value: &'a V ) -> AsyncBuilder<'a, Self, V>

where S: Into<String>, V: Serialize + Send + Sync,

Sets key to value. This function returns a builder that is also a Future. Awaiting the builder will execute Command::Set with the options given.

fn set_binary_key<S, 'a>( &'a self, key: S, bytes: &'a [u8] ) -> AsyncBuilder<'a, Self, ()>

where S: Into<String>,

Sets key to bytes. This function returns a builder that is also a Future. Awaiting the builder will execute Command::Set with the options given.

fn set_numeric_key<S, V>(&self, key: S, value: V) -> AsyncBuilder<'_, Self, ()>

where S: Into<String>, V: Into<Numeric>,

Sets key to value. This stores the value as a Numeric, enabling atomic math operations to be performed on this key. This function returns a builder that is also a Future. Awaiting the builder will execute Command::Set with the options given.

fn increment_key_by<S, V>(&self, key: S, value: V) -> AsyncBuilder<'_, Self, V>

where S: Into<String> + Send + Sync, V: Into<Numeric> + TryFrom<Numeric, Error = IncompatibleTypeError> + Send + Sync,

Increments key by value. The value stored must be a Numeric, otherwise an error will be returned. The result of the increment will be the value’s type. For example, if the stored value is currently a u64, but value is a f64, the current value will be converted to an f64, and the stored value will be an f64.

fn decrement_key_by<S, V>(&self, key: S, value: V) -> AsyncBuilder<'_, Self, V>

where S: Into<String> + Send + Sync, V: Into<Numeric> + TryFrom<Numeric, Error = IncompatibleTypeError> + Send + Sync,

Decrements key by value. The value stored must be a Numeric, otherwise an error will be returned. The result of the decrement will be the value’s type. For example, if the stored value is currently a u64, but value is a f64, the current value will be converted to an f64, and the stored value will be an f64.

fn get_key<S>(&self, key: S) -> AsyncBuilder<'_, Self>

where S: Into<String>,

Gets the value stored at key. This function returns a builder that is also a Future. Awaiting the builder will execute Command::Get with the options given.

fn delete_key<'life0, 'async_trait, S>( &'life0 self, key: S ) -> Pin<Box<dyn Future<Output = Result<KeyStatus, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, S: 'async_trait + Into<String> + Send, Self: 'async_trait,

Deletes the value stored at key.

fn key_namespace(&self) -> Option<&str>

The current namespace.

fn with_key_namespace(&self, namespace: &str) -> Namespaced<'_, Self>

Access this Key-Value store within a namespace. When using the returned Namespaced instance, all keys specified will be separated into their own storage designated by namespace.

Object Safety

This trait is not object safe.

Implementors

impl AsyncKeyValue for AsyncRemoteDatabase

impl AsyncKeyValue for AsyncDatabase

impl<'a, K> AsyncKeyValue for Namespaced<'a, K>

where K: AsyncKeyValue,

impl<B> AsyncKeyValue for ServerDatabase<B>

where B: Backend,

Pass-through implementation