Struct typed_store::rocks::DBMap

pub struct DBMap<K, V> {
    pub rocksdb: Arc<DBWithThreadMode<MultiThreaded>>,
    /* private fields */
}

An interface to a rocksDB database, keyed by a columnfamily

Fields

rocksdb: Arc<DBWithThreadMode<MultiThreaded>>

Implementations

impl<K, V> DBMap<K, V>

pub fn open<P: AsRef<Path>>(
    path: P,
    db_options: Option<Options>,
    opt_cf: Option<&str>,
    registry: &Registry
) -> Result<Self, TypedStoreError>

Opens a database from a path, with specific options and an optional column family.

This database is used to perform operations on single column family, and parametrizes all operations in DBBatch when writting across column families.

pub fn reopen(
    db: &Arc<DBWithThreadMode<MultiThreaded>>,
    opt_cf: Option<&str>,
    db_metrics: &Arc<DBMetrics>
) -> Result<Self, TypedStoreError>

Reopens an open database as a typed map operating under a specific column family. if no column family is passed, the default column family is used.

   use typed_store::rocks::*;
   use typed_store::metrics::DBMetrics;
   use tempfile::tempdir;
   use prometheus::Registry;
   use std::sync::Arc;
   /// Open the DB with all needed column families first.
   let rocks = open_cf(tempdir().unwrap(), None, &["First_CF", "Second_CF"]).unwrap();
   let db_metrics = Arc::new(DBMetrics::make_db_metrics(&Registry::default()));
   /// Attach the column families to specific maps.
   let db_cf_1 = DBMap::<u32,u32>::reopen(&rocks, Some("First_CF"), &db_metrics).expect("Failed to open storage");
   let db_cf_2 = DBMap::<u32,u32>::reopen(&rocks, Some("Second_CF"), &db_metrics).expect("Failed to open storage");

pub fn batch(&self) -> DBBatch

Trait Implementations

impl<K: Clone, V: Clone> Clone for DBMap<K, V>

fn clone(&self) -> DBMap<K, V>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<K: Debug, V: Debug> Debug for DBMap<K, V>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a, K, V> Map<'a, K, V> for DBMap<K, V>where
    K: Serialize + DeserializeOwned,
    V: Serialize + DeserializeOwned,

fn multi_get<J>(
    &self,
    keys: impl IntoIterator<Item = J>
) -> Result<Vec<Option<V>>, TypedStoreError>where
    J: Borrow<K>,

Returns a vector of values corresponding to the keys provided.

fn multi_insert<J, U>(
    &self,
    key_val_pairs: impl IntoIterator<Item = (J, U)>
) -> Result<(), Self::Error>where
    J: Borrow<K>,
    U: Borrow<V>,

Convenience method for batch insertion

fn multi_remove<J>(
    &self,
    keys: impl IntoIterator<Item = J>
) -> Result<(), Self::Error>where
    J: Borrow<K>,

Convenience method for batch removal

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

Try to catch up with primary when running as secondary

type Error = TypedStoreError

type Iterator = Iter<'a, K, V>

type Keys = Keys<'a, K>

type Values = Values<'a, V>

fn contains_key(&self, key: &K) -> Result<bool, TypedStoreError>

Returns true if the map contains a value for the specified key.

fn get(&self, key: &K) -> Result<Option<V>, TypedStoreError>

Returns the value for the given key from the map, if it exists.

fn get_raw_bytes(&self, key: &K) -> Result<Option<Vec<u8>>, TypedStoreError>

Returns the raw value (bincode serialized bytes) for the given key from the map, if it exists.

fn insert(&self, key: &K, value: &V) -> Result<(), TypedStoreError>

Inserts the given key-value pair into the map.

fn remove(&self, key: &K) -> Result<(), TypedStoreError>

Removes the entry for the given key from the map.

fn clear(&self) -> Result<(), TypedStoreError>

Removes every key-value pair from the map.

fn is_empty(&self) -> bool

Returns true if the map is empty, otherwise false.

fn iter(&'a self) -> Self::Iterator

Returns an iterator visiting each key-value pair in the map.

fn keys(&'a self) -> Self::Keys

Returns an iterator over each key in the map.

fn values(&'a self) -> Self::Values

Returns an iterator over each value in the map.

fn get_or_insert_unsafe<F: FnOnce() -> V>(
    &self,
    key: &K,
    default: F
) -> Result<V, Self::Error>

Returns the value for the given key from the map, if it exists or the given default value if it does not. This method is not thread safe

impl<J, K, U, V> TryExtend<(J, U)> for DBMap<K, V>where
    J: Borrow<K>,
    U: Borrow<V>,
    K: Serialize,
    V: Serialize,

type Error = TypedStoreError

Error type.

fn try_extend<T>(&mut self, iter: &mut T) -> Result<(), Self::Error>where
    T: Iterator<Item = (J, U)>,

Try to extend the collection from the given iterator.

fn try_extend_from_slice(&mut self, slice: &[(J, U)]) -> Result<(), Self::Error>

Try to extend the collection from the given slice.

impl<K: Send, V: Send> Send for DBMap<K, V>