Struct Db 

pub struct Db<Storage> { /* private fields */ }

The central database object to manage and cache incremental computations.

To use this, a type implementing Storage is required to be provided. See the documentation for impl_storage!.

Implementations

impl<Storage: Default> Db<Storage>

pub fn new() -> Self

Construct a new Db object using Default::default() for the initial storage.

impl<S> Db<S>

pub fn with_storage(storage: S) -> Self

Construct a new Db object with the given initial storage.

pub fn storage(&self) -> &S

Retrieve an immutable reference to this Db’s storage

pub fn storage_mut(&mut self) -> &mut S

Retrieve a mutable reference to this Db’s storage.

Note that any mutations made to the storage using this are not tracked by the Db! Using this incorrectly may break correctness!

impl<S: Storage> Db<S>

pub fn version(&self) -> u32

pub fn gc(&mut self, version: u32)

impl<S: Storage> Db<S>

pub fn update_input<C>(&mut self, input: C, new_value: C::Output)

where C: OutputType + ComputationId, S: StorageFor<C>,

Updates an input with a new value

This requires an exclusive reference to self to ensure that there are no currently running queries. Updating an input while an incremental computation is occurring can break soundness for dependency tracking.

Panics if the given computation is not an input - ie. panics if it has at least 1 dependency.

pub fn is_stale<C: OutputType>(&self, input: &C) -> bool

where S: StorageFor<C>,

True if a given computation is stale and needs to be re-computed. Computations which have never been computed are also considered stale.

Note that this may re-compute dependencies of the given computation.

pub fn get<C: OutputType + ComputationId>(&self, compute: C) -> C::Output

where S: StorageFor<C>,

Retrieves the up to date value for the given computation, re-running any dependencies as necessary.

This function can panic if the dynamic type of the value returned by compute.run(..) is not T.

Locking behavior: This function locks the cell corresponding to the given computation. This can cause a deadlock if the computation recursively depends on itself.

pub fn get_accumulated<Container, Item, C>(&self, compute: C) -> Container

where Container: FromIterator<Item>, S: Accumulate<Item> + StorageFor<C>, C: OutputType + ComputationId,

Retrieve an accumulated value in a container of the user’s choice. This will return all the accumulated items after the given computation.

Note that although this method will not re-perform the given computation, it will re-collect all the required accumulated items each time it is called, which may be costly for large dependency trees.

This is most often used for operations like retrieving diagnostics or logs.

Trait Implementations

impl<S, C> DbGet<C> for Db<S>

where C: OutputType + ComputationId, S: Storage + StorageFor<C>,

fn get(&self, key: C) -> C::Output

Run an incremental computation C and return its output. If C is already cached, no computation will be performed.

impl<S: Default> Default for Db<S>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, Storage> Deserialize<'de> for Db<Storage>

where Storage: Deserialize<'de>,

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<Storage> Serialize for Db<Storage>

where Storage: Serialize,

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.