Struct zebra_state::service::finalized_state::column_family::WriteTypedBatch

pub struct WriteTypedBatch<'cf, Key, Value, Batch>
where
    Key: IntoDisk + FromDisk + Debug,
    Value: IntoDisk + FromDisk,
    Batch: WriteDisk,
{
    inner: TypedColumnFamily<'cf, Key, Value>,
    batch: Batch,
}

A type-safe and drop-safe batch write to a column family.

Use this struct instead of raw WriteDisk access, because it is type-safe. So you only have to define the types once, and you can’t accidentally use different types for reading and writing. (Which is a source of subtle database bugs.)

This type is also drop-safe: unwritten batches have to be specifically ignored.

Fields

inner: TypedColumnFamily<'cf, Key, Value>

batch: Batch

Implementations

impl<'cf, Key, Value, Batch> WriteTypedBatch<'cf, Key, Value, Batch>

where Key: IntoDisk + FromDisk + Debug, Value: IntoDisk + FromDisk, Batch: WriteDisk,

pub fn zs_insert(self, key: &Key, value: &Value) -> Self

Serialize and insert the given key and value into this column family, overwriting any existing value for key.

pub fn zs_delete(self, key: &Key) -> Self

Remove the given key from this column family, if it exists.

pub fn zs_delete_range(self, from: &Key, until_strictly_before: &Key) -> Self

Delete the given key range from this rocksdb column family, if it exists, including from and excluding until_strictly_before.

impl<'cf, Key, Value> WriteTypedBatch<'cf, Key, Value, DiskWriteBatch>

where Key: IntoDisk + FromDisk + Debug, Value: IntoDisk + FromDisk,

pub fn write_batch(self) -> Result<(), Error>

Writes this batch to this column family in the database, taking ownership and consuming it.

Trait Implementations

impl<'cf, Key, Value, Batch> Debug for WriteTypedBatch<'cf, Key, Value, Batch>

where Key: IntoDisk + FromDisk + Debug + Debug, Value: IntoDisk + FromDisk + Debug, Batch: WriteDisk + Debug,

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

Formats the value using the given formatter.

impl<'cf, Key, Value, Batch> PartialEq for WriteTypedBatch<'cf, Key, Value, Batch>

where Key: IntoDisk + FromDisk + Debug + PartialEq, Value: IntoDisk + FromDisk + PartialEq, Batch: WriteDisk + PartialEq,

fn eq(&self, other: &WriteTypedBatch<'cf, Key, Value, Batch>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'cf, Key, Value, Batch> Eq for WriteTypedBatch<'cf, Key, Value, Batch>

where Key: IntoDisk + FromDisk + Debug + Eq, Value: IntoDisk + FromDisk + Eq, Batch: WriteDisk + Eq,

impl<'cf, Key, Value, Batch> StructuralPartialEq for WriteTypedBatch<'cf, Key, Value, Batch>

where Key: IntoDisk + FromDisk + Debug, Value: IntoDisk + FromDisk, Batch: WriteDisk,