Struct FileKeyBatch 

pub struct FileKeyBatch<K, T, R>
where
    K: DataTrait + ?Sized,
    T: Timestamp,
    R: WeightTrait + ?Sized,
{ /* private fields */ }

A batch of keys with weights and times.

Each tuple in FileKeyBatch<K, T, R> has key type K, value type (), weight type R, and time type R.

Trait Implementations

impl<K, T, R> Archive for FileKeyBatch<K, T, R>

where K: DataTrait + ?Sized, T: Timestamp, R: WeightTrait + ?Sized,

type Archived = ()

The archived representation of this type.

type Resolver = ()

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

unsafe fn resolve( &self, _pos: usize, _resolver: Self::Resolver, _out: *mut Self::Archived, )

Creates the archived version of this value at the given position and writes it to the given output.

impl<K, T, R> Batch for FileKeyBatch<K, T, R>

where K: DataTrait + ?Sized, T: Timestamp, R: WeightTrait + ?Sized,

type Timed<T2: Timestamp> = FileKeyBatch<K, T2, R>

A batch type equivalent to Self, but with timestamp type T instead of Self::Time.

type Batcher = MergeBatcher<FileKeyBatch<K, T, R>>

A type used to assemble batches from disordered updates.

type Builder = FileKeyBuilder<K, T, R>

A type used to assemble batches from ordered update sequences.

fn file_reader(&self) -> Option<Arc<dyn FileReader>>

This functions returns the file that can be used to restore the batch’s contents.

fn from_path( factories: &Self::Factories, path: &StoragePath, ) -> Result<Self, ReaderError>

fn dyn_from_tuples( factories: &Self::Factories, time: Self::Time, tuples: &mut Box<DynWeightedPairs<DynPair<Self::Key, Self::Val>, Self::R>>, ) -> Self

Assemble an unordered vector of weighted items into a batch.

fn from_batch<BI>( batch: &BI, timestamp: &Self::Time, factories: &Self::Factories, ) -> Self

where BI: BatchReader<Key = Self::Key, Val = Self::Val, Time = (), R = Self::R>,

Creates a new batch as a copy of batch, using timestamp for all of the new batch’s timestamps This is useful for adding a timestamp to a batch, or for converting between different batch implementations (e.g. writing an in-memory batch to disk).

fn from_arc_batch<BI>( batch: &Arc<BI>, timestamp: &Self::Time, factories: &Self::Factories, ) -> Arc<Self>

where BI: BatchReader<Key = Self::Key, Val = Self::Val, Time = (), R = Self::R>,

Like from_batch, but avoids cloning the batch if the output type is identical to the input type.

fn from_cursor<C>( cursor: C, timestamp: &Self::Time, factories: &Self::Factories, key_capacity: usize, value_capacity: usize, ) -> Self

where C: Cursor<Self::Key, Self::Val, (), Self::R>,

Creates a new batch as a copy of the tuples accessible via cursor``, using timestamp` for all of the new batch’s timestamps.

fn dyn_empty(factories: &Self::Factories) -> Self

Creates an empty batch.

fn filter(&self, predicate: &dyn Fn(&Self::Key, &Self::Val) -> bool) -> Self

where Self::Time: PartialEq<()> + From<()>,

Returns elements from self that satisfy a predicate.

fn persisted(&self) -> Option<Self>

If this batch is not on storage, but supports writing itself to storage, this method writes it to storage and returns the stored version.

impl<K, T, R> BatchReader for FileKeyBatch<K, T, R>

where K: DataTrait + ?Sized, T: Timestamp, R: WeightTrait + ?Sized,

type Factories = FileKeyBatchFactories<K, T, R>

type Key = K

Key by which updates are indexed.

type Val = dyn DataTyped<Type = ()>

Values associated with keys.

type Time = T

Timestamps associated with updates

type R = R

Associated update.

type Cursor<'s> = FileKeyCursor<'s, K, T, R>

The type used to enumerate the batch’s contents.

fn factories(&self) -> Self::Factories

fn cursor(&self) -> Self::Cursor<'_>

Acquires a cursor to the batch’s contents.

fn key_count(&self) -> usize

The number of keys in the batch.

fn len(&self) -> usize

The number of updates in the batch.

fn approximate_byte_size(&self) -> usize

The memory or storage size of the batch in bytes.

fn filter_stats(&self) -> BloomFilterStats

Statistics of the Bloom filter used by Cursor::seek_key_exact. The Bloom filter (kept in memory) is used there to quickly check whether a key might be present in the batch, before doing a binary tree lookup within the batch to be exactly sure. The statistics include for example the size in bytes and the hit rate. Only some kinds of batches use a filter; others should return BloomFilterStats::default().

fn location(&self) -> BatchLocation

Where the batch’s data is stored.

fn cache_stats(&self) -> CacheStats

Storage cache access statistics for this batch only.

fn sample_keys<RG>( &self, rng: &mut RG, sample_size: usize, output: &mut DynVec<Self::Key>, )

where RG: Rng,

Returns a uniform random sample of distincts keys from the batch.

fn maybe_contains_key(&self, hash: u64) -> bool

A method that returns either true (possibly in the batch) or false (definitely not in the batch).

fn push_cursor( &self, ) -> Box<dyn PushCursor<Self::Key, Self::Val, Self::Time, Self::R> + Send + '_>

Acquires a PushCursor for the batch’s contents.

fn merge_cursor( &self, key_filter: Option<Filter<Self::Key>>, value_filter: Option<GroupFilter<Self::Val>>, ) -> Box<dyn MergeCursor<Self::Key, Self::Val, Self::Time, Self::R> + Send + '_>

Acquires a MergeCursor for the batch’s contents.

fn merge_cursor_with_snapshot<'a, S>( &'a self, key_filter: Option<Filter<Self::Key>>, value_filter: Option<GroupFilter<Self::Val>>, snapshot: &'a Option<Arc<S>>, ) -> Box<dyn MergeCursor<Self::Key, Self::Val, Self::Time, Self::R> + Send + 'a>

where S: BatchReader<Key = Self::Key, Val = Self::Val, Time = Self::Time, R = Self::R>,

Similar to merge_cursor, but invoked in the context of a spine merger. Takes the current spine snapshot as an extra argument and uses it to evaluate value_filter precisely.

fn consuming_cursor( &mut self, key_filter: Option<Filter<Self::Key>>, value_filter: Option<GroupFilter<Self::Val>>, ) -> Box<dyn MergeCursor<Self::Key, Self::Val, Self::Time, Self::R> + Send + '_>

Acquires a merge cursor for the batch’s contents.

fn is_empty(&self) -> bool

True if the batch is empty.

async fn fetch<B>( &self, keys: &B, ) -> Option<Box<dyn CursorFactory<Self::Key, Self::Val, Self::Time, Self::R>>>

where B: BatchReader<Key = Self::Key, Time = ()>,

Creates and returns a new batch that is a subset of this one, containing only the key-value pairs whose keys are in keys. May also return None, the default implementation, if the batch doesn’t want to implement this method. In particular, a batch for which access through a cursor is fast should return None to avoid the expense of copying data.

fn keys(&self) -> Option<&DynVec<Self::Key>>

impl<K, T, R> Builder<FileKeyBatch<K, T, R>> for FileKeyBuilder<K, T, R>

where Self: SizeOf, K: DataTrait + ?Sized, T: Timestamp, R: WeightTrait + ?Sized,

fn with_capacity( factories: &FileKeyBatchFactories<K, T, R>, key_capacity: usize, _value_capacity: usize, ) -> Self

Creates an empty builder with estimated capacities for keys and key-value pairs. Only tuple_capacity >= key_capacity makes sense but implementations must tolerate contradictory capacity requests.

fn push_key(&mut self, key: &K)

Adds key key.

fn push_val(&mut self, _val: &DynUnit)

Adds value val.

fn push_time_diff(&mut self, time: &T, weight: &R)

Adds time-diff pair (time, weight).

fn done(self) -> FileKeyBatch<K, T, R>

Completes building and returns the batch.

fn num_keys(&self) -> usize

fn num_tuples(&self) -> usize

fn new_builder(factories: &Output::Factories) -> Self

Creates a new builder with an initial capacity of 0.

fn for_merge<'a, B, I>( factories: &Output::Factories, batches: I, location: Option<BatchLocation>, ) -> Self

where B: BatchReader, I: IntoIterator<Item = &'a B> + Clone,

Creates an empty builder to hold the result of merging batches. Optionally, location can specify the preferred location for the result of the merge.

fn push_time_diff_mut( &mut self, time: &mut Output::Time, weight: &mut Output::R, )

Adds time-diff pair (time, weight).

fn push_val_mut(&mut self, val: &mut Output::Val)

Adds value val.

fn push_key_mut(&mut self, key: &mut Output::Key)

Adds key key.

fn push_diff(&mut self, weight: &Output::R)

where Output::Time: PartialEq<()>,

Adds time-diff pair (), weight.

fn push_diff_mut(&mut self, weight: &mut Output::R)

where Output::Time: PartialEq<()>,

Adds time-diff pair (), weight.

fn push_val_diff(&mut self, val: &Output::Val, weight: &Output::R)

where Output::Time: PartialEq<()>,

Adds time-diff pair (), weight and value val.

fn push_val_diff_mut(&mut self, val: &mut Output::Val, weight: &mut Output::R)

where Output::Time: PartialEq<()>,

Adds time-diff pair (), weight and value val.

fn reserve(&mut self, additional: usize)

Allocates room for additional keys.

impl<K, T, R> Clone for FileKeyBatch<K, T, R>

where K: DataTrait + ?Sized, T: Timestamp, R: WeightTrait + ?Sized,

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<K, T, R> Debug for FileKeyBatch<K, T, R>

where K: DataTrait + ?Sized, T: Timestamp, R: WeightTrait + ?Sized,

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

Formats the value using the given formatter.

impl<K, T, R, D> Deserialize<FileKeyBatch<K, T, R>, D> for Archived<FileKeyBatch<K, T, R>>

where K: DataTrait + ?Sized, T: Timestamp, R: WeightTrait + ?Sized, D: Fallible,

fn deserialize( &self, _deserializer: &mut D, ) -> Result<FileKeyBatch<K, T, R>, D::Error>

Deserializes using the given deserializer

impl<K, T, R> NumEntries for FileKeyBatch<K, T, R>

where K: DataTrait + ?Sized, T: Timestamp, R: WeightTrait + ?Sized,

const CONST_NUM_ENTRIES: Option<usize> = None

Returns Some(n) if Self has constant size or None otherwise.

fn num_entries_shallow(&self) -> usize

Returns the number of entries in self.

fn num_entries_deep(&self) -> usize

Recursively computes the number of entries in a container by calling this method on each entry in self.

impl<K, T, R, S> Serialize<S> for FileKeyBatch<K, T, R>

where K: DataTrait + ?Sized, T: Timestamp, R: WeightTrait + ?Sized, S: Serializer + ?Sized,

fn serialize(&self, _serializer: &mut S) -> Result<Self::Resolver, S::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.

impl<K, T, R> SizeOf for FileKeyBatch<K, T, R>

where K: DataTrait + ?Sized, T: Timestamp, R: WeightTrait + ?Sized, Arc<Reader<(&'static K, &'static DynUnit, (&'static DynDataTyped<T>, &'static R, ()))>>: SizeOf,

fn size_of_children(&self, context: &mut Context)

Gets the size of all “children” owned by this value, not including the size of the value itself.

fn size_of(&self) -> TotalSize

Gets the total size of the current value

fn size_of_with_context(&self, context: &mut Context)

Adds the size of the current value to the given Context, including both the size of the value itself and all of its children