Trait SupportsBatching

pub trait SupportsBatching<M, S>: BlueprintMutate<M, S>
where
    M: Mappable,
    S: BatchOperations,
{
    // Required methods
    fn init<'a, Iter>(
        storage: &mut S,
        column: S::Column,
        set: Iter,
    ) -> StorageResult<()>
       where Iter: 'a + Iterator<Item = (&'a M::Key, &'a M::Value)>,
             M::Key: 'a,
             M::Value: 'a;
    fn insert<'a, Iter>(
        storage: &mut S,
        column: S::Column,
        set: Iter,
    ) -> StorageResult<()>
       where Iter: 'a + Iterator<Item = (&'a M::Key, &'a M::Value)>,
             M::Key: 'a,
             M::Value: 'a;
    fn remove<'a, Iter>(
        storage: &mut S,
        column: S::Column,
        set: Iter,
    ) -> StorageResult<()>
       where Iter: 'a + Iterator<Item = &'a M::Key>,
             M::Key: 'a;
}

It is an extension of the blueprint that allows supporting batch operations. Usually, they are more performant than initializing/inserting/removing values one by one.

Required Methods

fn init<'a, Iter>( storage: &mut S, column: S::Column, set: Iter, ) -> StorageResult<()>

where Iter: 'a + Iterator<Item = (&'a M::Key, &'a M::Value)>, M::Key: 'a, M::Value: 'a,

Initializes the storage with a bunch of key-value pairs. In some cases, this method may be more performant than Self::insert.

fn insert<'a, Iter>( storage: &mut S, column: S::Column, set: Iter, ) -> StorageResult<()>

where Iter: 'a + Iterator<Item = (&'a M::Key, &'a M::Value)>, M::Key: 'a, M::Value: 'a,

Inserts the batch of key-value pairs into the storage.

fn remove<'a, Iter>( storage: &mut S, column: S::Column, set: Iter, ) -> StorageResult<()>

where Iter: 'a + Iterator<Item = &'a M::Key>, M::Key: 'a,

Removes the batch of key-value pairs from the storage.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<Column, M, S, KeyCodec, ValueCodec> SupportsBatching<M, S> for Plain<KeyCodec, ValueCodec>

where Column: StorageColumn, S: BatchOperations<Column = Column>, M: TableWithBlueprint<Blueprint = Plain<KeyCodec, ValueCodec>, Column = Column>, M::Blueprint: BlueprintMutate<M, S>,

impl<Column, M, S, KeyCodec, ValueCodec, Metadata, Nodes, KeyConverter> SupportsBatching<M, S> for Sparse<KeyCodec, ValueCodec, Metadata, Nodes, KeyConverter>

where Column: StorageColumn, S: BatchOperations<Column = Column> + StorageMutate<M, Error = Error> + StorageMutate<Metadata, Error = Error> + StorageMutate<Nodes, Error = Error>, M: TableWithBlueprint<Blueprint = Sparse<KeyCodec, ValueCodec, Metadata, Nodes, KeyConverter>, Column = Column>, KeyCodec: Encode<M::Key> + Decode<M::OwnedKey>, ValueCodec: Encode<M::Value> + Decode<M::OwnedValue>, Metadata: Mappable<Value = SparseMerkleMetadata, OwnedValue = SparseMerkleMetadata>, Nodes: Mappable<Key = MerkleRoot, Value = Primitive, OwnedValue = Primitive> + TableWithBlueprint<Column = Column>, KeyConverter: PrimaryKey<InputKey = M::Key, OutputKey = Metadata::Key>, Nodes::Blueprint: BlueprintInspect<Nodes, S>,

impl<M, S, KeyCodec, ValueCodec, Metadata, Nodes, Encoder> SupportsBatching<M, S> for Merklized<KeyCodec, ValueCodec, Metadata, Nodes, Encoder>

where M: Mappable, S: BatchOperations + StorageMutate<Metadata, Error = Error> + StorageMutate<Nodes, Error = Error>, KeyCodec: Encode<M::Key> + Decode<M::OwnedKey>, ValueCodec: Encode<M::Value> + Decode<M::OwnedValue>, Encoder: Encode<M::Value>, Metadata: Mappable<Key = DenseMetadataKey<M::OwnedKey>, OwnedKey = DenseMetadataKey<M::OwnedKey>, Value = DenseMerkleMetadata, OwnedValue = DenseMerkleMetadata>, Nodes: Mappable<Key = u64, Value = Primitive, OwnedValue = Primitive>, for<'a> StructuredStorage<&'a mut S>: StorageMutate<Metadata, Error = Error> + StorageMutate<Nodes, Error = Error>,