Struct KvStore

pub struct KvStore<Backend: TransactionalBackend> { /* private fields */ }

A key-value store.

This is a key-value store where both the key and value are strings. There are no restrictions on the length or contents of either the key or value beyond restrictions implemented by the protobuf server.

Implementations

impl<Backend> KvStore<Backend>

where Backend: DatabaseBackend + TransactionalBackend, Backend::Error: Display + Debug,

pub fn at_location(location: Location) -> Result<Self, Backend::Error>

Create a new key-value store at the given location. If not pre-existing, the store will not be initialized until the first connection is made.

pub fn at_path<P>(path: P) -> Result<Self, Backend::Error>

where P: Into<PathBuf>,

Create a new key-value at the given path on disk. If not pre-existing, the store will not be initialized until the first connection is made.

pub fn in_memory() -> Result<Self, Backend::Error>

Create a new in-memory key-value store. This is useful for short-lived data.

Note that all in-memory connections share the same stream, so any asynchronous calls have a nondeterministic order. This is not a problem for on-disk connections.

pub fn create_index(&self, config: IndexConfig) -> Result<(), IndexError>

Create a secondary index on the key-value store

pub fn drop_index(&self, name: &str) -> Result<(), IndexError>

Drop a secondary index

pub const fn index_manager(&self) -> &Arc<IndexManager>

Get the index manager

impl<Backend> KvStore<Backend>

where Backend: TransactionalBackend, Backend::Error: Display,

pub fn with_transactions( location: Location, transaction_timeout: Duration, ) -> Result<Self, Backend::Error>

👎Deprecated since 0.5.0: Transaction support over gRPC is problematic and will be removed. Use batch operations instead.

Create a new key-value store with transaction support.

DEPRECATED: Transaction support over gRPC is being phased out. Use batch operations or client-side transaction management instead.

Trait Implementations

impl<Backend: Debug + TransactionalBackend> Debug for KvStore<Backend>

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

Formats the value using the given formatter.

impl<Backend> Kv for KvStore<Backend>

where Backend: KvBackend<Error: IntoTonicStatus, GetStream: Send, SetStream: Send, DeleteStream: Send> + TransactionalBackend + 'static, Backend::Error: Display + Debug,

type GetStream = <Backend as KvBackend>::GetStream

Server streaming response type for the Get method.

type SetStream = <Backend as KvBackend>::SetStream

Server streaming response type for the Set method.

type DeleteStream = <Backend as KvBackend>::DeleteStream

Server streaming response type for the Delete method.

fn get<'life0, 'async_trait>( &'life0 self, request: Request<Streaming<GetRequest>>, ) -> Pin<Box<dyn Future<Output = RpcResponse<Self::GetStream>> + Send + 'async_trait>>

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

Get a value for a given key.

fn set<'life0, 'async_trait>( &'life0 self, request: Request<Streaming<SetRequest>>, ) -> Pin<Box<dyn Future<Output = RpcResponse<Self::SetStream>> + Send + 'async_trait>>

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

Set a value for a given key. If the key already exists, the value is updated.

fn delete<'life0, 'async_trait>( &'life0 self, request: Request<Streaming<DeleteRequest>>, ) -> Pin<Box<dyn Future<Output = RpcResponse<Self::DeleteStream>> + Send + 'async_trait>>

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

Delete a value for a given key.

fn eq<'life0, 'async_trait>( &'life0 self, request: Request<Streaming<EqRequest>>, ) -> Pin<Box<dyn Future<Output = RpcResponse<bool>> + Send + 'async_trait>>

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

Determine if all provided keys have the same value.

fn not_eq<'life0, 'async_trait>( &'life0 self, request: Request<Streaming<NotEqRequest>>, ) -> Pin<Box<dyn Future<Output = RpcResponse<bool>> + Send + 'async_trait>>

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

Determine if all provided keys have different values.

fn begin_transaction<'life0, 'async_trait>( &'life0 self, _request: Request<BeginTransactionRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<BeginTransactionResponse>, Status>> + Send + 'async_trait>>

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

Begin a new transaction. Returns a transaction ID that must be passed to subsequent operations.

fn commit_transaction<'life0, 'async_trait>( &'life0 self, _request: Request<CommitTransactionRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<CommitTransactionResponse>, Status>> + Send + 'async_trait>>

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

Commit a transaction. All operations within the transaction are made permanent.

fn rollback_transaction<'life0, 'async_trait>( &'life0 self, _request: Request<RollbackTransactionRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<RollbackTransactionResponse>, Status>> + Send + 'async_trait>>

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

Rollback a transaction. All operations within the transaction are discarded.