Trait bonsaidb::core::keyvalue::KeyValue[][src]

pub trait KeyValue: Send + Sync {
    fn execute_key_operation(&self, op: KeyOperation) -> Result<Output, Error>;

    fn set_key<S, V>(&'a self, key: S, value: &'a V) -> Builder<'a, Self, V>
    where
        S: Into<String>,
        V: Serialize + Send + Sync
, { ... }
fn set_binary_key<S>(
        &'a self,
        key: S,
        bytes: &'a [u8]
    ) -> Builder<'a, Self, ()>
    where
        S: Into<String>
, { ... }
fn set_numeric_key<S, V>(&self, key: S, value: V) -> Builder<'_, Self, ()>
    where
        S: Into<String>,
        V: Into<Numeric>
, { ... }
fn increment_key_by<S, V>(&self, key: S, value: V) -> Builder<'_, 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) -> Builder<'_, Self, V>
    where
        S: Into<String> + Send + Sync,
        V: Into<Numeric> + TryFrom<Numeric, Error = IncompatibleTypeError> + Send + Sync
, { ... }
fn get_key<S>(&self, key: S) -> Builder<'_, Self>
    where
        S: Into<String>
, { ... }
fn delete_key<S>(&self, key: S) -> Result<KeyStatus, Error>
    where
        S: Into<String> + Send
, { ... }
fn key_namespace(&self) -> Option<&str> { ... }
fn with_key_namespace(&self, namespace: &str) -> Namespaced<'_, Self> { ... } }
Expand description

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

Provided methods

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.

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.

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.

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.

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.

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.

Deletes the value stored at key.

The current namespace.

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.

Implementors