Crate linera_views

source ·
Expand description

This module is used in the Linera protocol to map complex data structures onto a key-value store. The central notion is a views::View which can be loaded from storage, modified in memory, then committed (i.e. the changes are atomically persisted in storage).

The package provides essentially two functionalities:

  • An abstraction to access databases.
  • Several containers named views for storing data modeled on classical ones.

See DESIGN.md for more details.

The supported databases.

The databases supported are of the NoSQL variety and they are key-value stores.

We provide support for the following databases:

  • MemoryClient is using the memory
  • RocksdbClient is a disk-based key-value store
  • DynamoDbClient is the AWS-based DynamoDB service.

The corresponding type in the code is the KeyValueStoreClient. A context is the combination of a client and a path (named base_key which is of type Vec<u8>).

Views.

A view is a container whose data lies in one of the above-mentioned databases. When the container is modified the modification lies first in the view before being committed to the database. In technical terms, a view implements the trait View.

The specific functionalities of the trait View are the following:

  • load for loading the view from a specific context.
  • rollback for canceling all modifications that were not committed thus far.
  • clear for clearing the view, in other words for reverting it to its default state.
  • flush for persisting the changes to storage.
  • delete for deleting the changes from the database.

The following views implement the View trait:

  • RegisterView implements the storing of a single data.
  • LogView implements a log, which is a list of entries that can be expanded.
  • QueueView implements a queue, which is a list of entries that can be expanded and reduced.
  • MapView implements a map with keys and values.
  • SetView implements a set with keys.
  • CollectionView implements a map whose values are views themselves.
  • ReentrantCollectionView implements a map for which different keys can be accessed independently.
  • ViewContainer<C> implements a KeyValueStoreClient and is used internally.

The LogView can be seen as an analog of VecDeque while MapView is an analog of BTreeMap.

Modules

  • batch
    The definition of the batches for writing in the database. A set of functionalities for building batches to be written into the database. A batch can contain three kinds of operations on a key/value store:
  • collection_view
    The CollectionView implements a map structure whose keys are ordered and the values are views.
  • common
    The definitions used for the KeyValueStoreClient and Context. This provides several functionalities for the handling of data. The most important traits are:
  • dynamo_db
    Helper definitions for DynamoDB storage.
  • hashable_wrapper
    Wrapping a view to compute a hash.
  • key_value_store_view
    The implementation of a key-value store view.
  • localstack
    Helper types for interfacing with a LocalStack instance.
  • log_view
    The LogView implements a log list that can be pushed.
  • lru_caching
    The LRU (least recently used) caching.
  • map_view
    The MapView implements a map with ordered keys. The MapView implements a map that can be modified.
  • memory
    Helper definitions for in-memory storage.
  • queue_view
    The QueueView implements a queue that can push on the back and delete on the front.
  • reentrant_collection_view
    The ReentrantCollectionView implements a map structure whose keys are ordered and the values are views with concurrent access.
  • register_view
    The RegisterView implements a register for a single value.
  • rocksdb
    Helper definitions for RocksDB storage.
  • set_view
    The SetView implements a set with ordered entries.
  • test_utils
    Helper types for tests.
  • value_splitting
    The code for handling big values by splitting them into several small ones.
  • views
    The definition of the View and related traits.

Constants

Functions