Struct LZ4Vec 

pub struct LZ4Vec<I, T>(/* private fields */);

Compressed storage using LZ4 for speed-optimized general-purpose compression.

LZ4 prioritizes compression/decompression speed over ratio, making it ideal for workloads where CPU time matters more than storage space.

Performance Characteristics

• Extremely fast compression/decompression (hundreds of MB/s)
• Moderate compression ratios (typically 2-3x)
• Works well with any data type

When to Use

• Speed is more important than storage savings
• Mixed data types (not just numbers)
• Need compression but can’t afford CPU overhead

Trait Implementations

impl<I, T> AnyStoredVec for LZ4Vec<I, T>

where I: VecIndex, T: LZ4VecValue,

fn db_path(&self) -> PathBuf

fn region(&self) -> &Region

fn header(&self) -> &Header

fn mut_header(&mut self) -> &mut Header

fn saved_stamped_changes(&self) -> u16

Number of stamped change files to keep for rollback support.

fn real_stored_len(&self) -> usize

The actual length stored on disk.

fn stored_len(&self) -> usize

The effective stored length (may differ from real_stored_len during truncation).

fn serialize_changes(&self) -> Result<Vec<u8>>

fn any_stamped_write_with_changes(&mut self, stamp: Stamp) -> Result<()>

Flushes with the given stamp, saving changes to enable rollback. Prefixed with any_ to avoid conflict with WritableVec::stamped_write_with_changes.

fn remove(self) -> Result<()>

Removes this vector’s region from the database.

fn any_truncate_if_needed_at(&mut self, index: usize) -> Result<()>

Truncates the vector to the given length if it is longer. Prefixed with any_ to avoid conflict with WritableVec::truncate_if_needed_at.

fn any_reset(&mut self) -> Result<()>

Resets the vector state, clearing all data.

fn flush(&mut self) -> Result<()>

fn update_stamp(&mut self, stamp: Stamp)

fn stamp(&self) -> Stamp

fn stamped_write(&mut self, stamp: Stamp) -> Result<()>

fn any_stamped_write_maybe_with_changes( &mut self, stamp: Stamp, with_changes: bool, ) -> Result<()>

Flushes with the given stamp, optionally saving changes for rollback.

impl<I, T> AnyVec for LZ4Vec<I, T>

where I: VecIndex, T: LZ4VecValue,

fn version(&self) -> Version

fn name(&self) -> &str

fn len(&self) -> usize

fn index_type_to_string(&self) -> &'static str

Returns the string representation of the index type.

fn value_type_to_size_of(&self) -> usize

Returns the size in bytes of the value type.

fn value_type_to_string(&self) -> &'static str

Returns the short type name of the value type (e.g., “Sats”, “StoredF64”).

fn region_names(&self) -> Vec<String>

Returns the list of region names used by this vector.

fn is_empty(&self) -> bool

fn region_name(&self) -> String

Returns the combined name of the vector.

fn etag(&self, stamp: Stamp, to: Option<i64>) -> String

Generates an ETag for this vector based on stamp and optional end index.

fn i64_to_usize(&self, i: i64) -> usize

Converts an i64 index to usize, supporting negative indexing (Python-style).

impl<I: Debug, T: Debug> Debug for LZ4Vec<I, T>

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

Formats the value using the given formatter.

impl<I, T> Deref for LZ4Vec<I, T>

type Target = ReadWriteCompressedVec<I, T, LZ4Strategy<T>>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<I, T> DerefMut for LZ4Vec<I, T>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<I, T> ImportableVec for LZ4Vec<I, T>

where I: VecIndex, T: LZ4VecValue,

fn import(db: &Database, name: &str, version: Version) -> Result<Self>

Import from database, creating if needed.

fn import_with(options: ImportOptions<'_>) -> Result<Self>

Import with custom options.

fn forced_import(db: &Database, name: &str, version: Version) -> Result<Self>

Import from database, resetting on version/format mismatch.

fn forced_import_with(options: ImportOptions<'_>) -> Result<Self>

Forced import with custom options.

impl<I, T> ReadableCloneableVec<I, T> for LZ4Vec<I, T>

where I: VecIndex, T: LZ4VecValue,

fn read_only_boxed_clone(&self) -> ReadableBoxedVec<I, T>

impl<I, T> ReadableVec<I, T> for LZ4Vec<I, T>

where I: VecIndex, T: LZ4VecValue,

fn cursor_chunk_size(&self) -> usize

Preferred number of values per cursor refill.

fn collect_one_at(&self, index: usize) -> Option<T>

Collects a single value at raw index, or None if out of bounds.

fn read_into_at(&self, from: usize, to: usize, buf: &mut Vec<T>)

Appends elements in [from, to) to buf.

fn for_each_range_dyn_at(&self, from: usize, to: usize, f: &mut dyn FnMut(T))

Iterates over [from, to) by raw index, calling f for each value.

fn fold_range_at<B, F: FnMut(B, T) -> B>( &self, from: usize, to: usize, init: B, f: F, ) -> B

where Self: Sized,

Folds over [from, to) by raw index with an accumulator.

fn try_fold_range_at<B, E, F: FnMut(B, T) -> Result<B, E>>( &self, from: usize, to: usize, init: B, f: F, ) -> Result<B, E>

where Self: Sized,

Fallible fold over [from, to) by raw index with early exit on error.

fn read_into(&self, from: I, to: I, buf: &mut Vec<T>)

Appends elements in [from, to) to buf using typed indices.

fn cursor(&self) -> Cursor<'_, I, T, Self>

where Self: Sized,

Creates a forward-only Cursor that reuses an internal buffer across chunked read_into_at calls. One allocation for the lifetime of the cursor.

fn for_each_range_dyn(&self, from: I, to: I, f: &mut dyn FnMut(T))

Iterates over [from, to) by typed index, calling f for each value (object-safe).

fn fold_range<B, F: FnMut(B, T) -> B>(&self, from: I, to: I, init: B, f: F) -> B

where Self: Sized,

Folds over [from, to) by typed index with an accumulator.

fn try_fold_range<B, E, F: FnMut(B, T) -> Result<B, E>>( &self, from: I, to: I, init: B, f: F, ) -> Result<B, E>

where Self: Sized,

Fallible fold over [from, to) by typed index with early exit on error.

fn for_each_range<F: FnMut(T)>(&self, from: I, to: I, f: F)

where Self: Sized,

Calls f for each value in [from, to) by typed index. Requires Sized.

fn collect_range(&self, from: I, to: I) -> Vec<T>

where Self: Sized,

Collects values in [from, to) by typed index into a Vec<T>.

fn collect_one(&self, index: I) -> Option<T>

Collects a single value at typed index, or None if out of bounds.

fn min(&self, from: I, to: I) -> Option<T>

where Self: Sized, T: PartialOrd,

Returns the minimum value in [from, to) by typed index, or None if empty.

fn max(&self, from: I, to: I) -> Option<T>

where Self: Sized, T: PartialOrd,

Returns the maximum value in [from, to) by typed index, or None if empty.

fn sum(&self, from: I, to: I) -> Option<T>

where Self: Sized, T: AddAssign + From<u8>,

Returns the sum of values in [from, to) by typed index, or None if empty.

fn for_each_range_at<F: FnMut(T)>(&self, from: usize, to: usize, f: F)

where Self: Sized,

Calls f for each value in [from, to) by raw index. Requires Sized (static dispatch).

fn try_for_each_range_at<E, F: FnMut(T) -> Result<(), E>>( &self, from: usize, to: usize, f: F, ) -> Result<(), E>

where Self: Sized,

Fallible for-each over [from, to) by raw index with early exit on error.

fn for_each<F: FnMut(T)>(&self, f: F)

where Self: Sized,

Calls f for every value in the vector.

fn fold<B, F: FnMut(B, T) -> B>(&self, init: B, f: F) -> B

where Self: Sized,

Folds over all values with an accumulator.

fn collect_range_at(&self, from: usize, to: usize) -> Vec<T>

where Self: Sized,

Collects values in [from, to) by raw index into a Vec<T>.

fn collect_range_into_at(&self, from: usize, to: usize, buf: &mut Vec<T>)

Clears buf then fills it with values in [from, to). Reuses the buffer allocation.

fn collect_range_dyn(&self, from: usize, to: usize) -> Vec<T>

Collects values in [from, to) into a Vec<T> (object-safe).

fn collect(&self) -> Vec<T>

where Self: Sized,

Collects all values into a Vec<T>.

fn collect_first(&self) -> Option<T>

Collects the first value, or None if empty.

fn collect_last(&self) -> Option<T>

Collects the last value, or None if empty.

fn collect_signed_range(&self, from: Option<i64>, to: Option<i64>) -> Vec<T>

where Self: Sized,

Collects values using signed indices. Negative indices count from the end (Python-style): -1 is the last element, -2 is second-to-last, etc.

fn collect_signed_range_dyn(&self, from: Option<i64>, to: Option<i64>) -> Vec<T>

Collects values using signed indices (object-safe).

fn collect_dyn(&self) -> Vec<T>

Collects all values into a Vec<T> (object-safe).

fn read_sorted_into_at(&self, indices: &[usize], out: &mut Vec<T>)

Reads values at specific sorted indices (ascending), skipping holes.

fn read_sorted_at(&self, indices: &[usize]) -> Vec<T>

Reads values at specific sorted indices (ascending), returning a new Vec.

fn read_sorted_into(&self, indices: &[I], out: &mut Vec<T>)

Reads values at specific sorted typed indices, appending to out.

fn read_sorted(&self, indices: &[I]) -> Vec<T>

Reads values at specific sorted typed indices, returning a new Vec.

fn min_at(&self, from: usize, to: usize) -> Option<T>

where Self: Sized, T: PartialOrd,

Returns the minimum value in [from, to) by raw index, or None if empty.

fn min_dyn(&self, from: usize, to: usize) -> Option<T>

where T: PartialOrd,

Returns the minimum value in [from, to), or None if empty (object-safe).

fn max_at(&self, from: usize, to: usize) -> Option<T>

where Self: Sized, T: PartialOrd,

Returns the maximum value in [from, to) by raw index, or None if empty.

fn max_dyn(&self, from: usize, to: usize) -> Option<T>

where T: PartialOrd,

Returns the maximum value in [from, to), or None if empty (object-safe).

fn sum_at(&self, from: usize, to: usize) -> Option<T>

where Self: Sized, T: AddAssign + From<u8>,

Returns the sum of values in [from, to) by raw index, or None if empty.

fn sum_dyn(&self, from: usize, to: usize) -> Option<T>

where T: AddAssign + From<u8>,

Returns the sum of values in [from, to), or None if empty (object-safe).

impl<I, T> StoredVec for LZ4Vec<I, T>

where I: VecIndex, T: LZ4VecValue,

type ReadOnly = ReadOnlyCompressedVec<I, T, LZ4Strategy<T>>

The concrete lean read-only type returned by read_only_clone.

fn read_only_clone(&self) -> Self::ReadOnly

Creates a lean read-only clone that only carries fields needed for disk reads.

impl<I, T> TypedVec for LZ4Vec<I, T>

where I: VecIndex, T: LZ4VecValue,

type I = I

The index type used to address elements in this vector.

type T = T

The value type stored in this vector.

impl<I, T> WritableVec<I, T> for LZ4Vec<I, T>

where I: VecIndex, T: LZ4VecValue,

fn push(&mut self, value: T)

fn pushed(&self) -> &[T]

Returns the current pushed (uncommitted) values.

fn truncate_if_needed_at(&mut self, index: usize) -> Result<()>

Truncates the vector to the given usize index if the current length exceeds it.

fn reset(&mut self) -> Result<()>

Resets the vector state.

fn reset_unsaved(&mut self)

Resets uncommitted changes.

fn is_dirty(&self) -> bool

Returns true if there are uncommitted changes.

fn stamped_write_with_changes(&mut self, stamp: Stamp) -> Result<()>

Flushes with the given stamp, saving changes to enable rollback.

fn rollback(&mut self) -> Result<()>

Rolls back the most recent change set.

const SIZE_OF_T: usize = _

fn rollback_before(&mut self, stamp: Stamp) -> Result<Stamp>

Rolls back changes to before the given stamp.

fn pushed_len(&self) -> usize

Number of pushed (uncommitted) values in the memory buffer.

fn is_pushed_empty(&self) -> bool

Returns true if there are no pushed (uncommitted) values.

fn has(&self, index: I) -> bool

Returns true if the typed index is within bounds.

fn has_at(&self, index: usize) -> bool

Returns true if the usize index is within bounds.

fn checked_push(&mut self, index: I, value: T) -> Result<()>

Pushes a value at the given index, erroring if index != current length. Use this when you expect to always append in order.

fn checked_push_at(&mut self, index: usize, value: T) -> Result<()>

Pushes a value at the given usize index, erroring if index != current length. Use this when you expect to always append in order.

fn debug_checked_push(&mut self, _index: I, value: T)

Pushes a value and checks its expected index in debug builds.

fn truncate_if_needed(&mut self, index: I) -> Result<()>

Truncates the vector to the given index if the current length exceeds it.

fn truncate_if_needed_with_stamp( &mut self, index: I, stamp: Stamp, ) -> Result<()>

Truncates the vector to the given index if needed, updating the stamp.

fn clear(&mut self) -> Result<()>

Clears all values from the vector.

fn batch_limit_reached(&self) -> bool

Returns true if the pushed cache has reached the batch limit (~1GiB).

fn fill_to(&mut self, target_len: usize, value: T) -> Result<()>

where T: Copy,

Extends the vector to target_len, filling with value. Batches writes in ~1GB chunks to avoid memory explosion.

fn stamped_write_maybe_with_changes( &mut self, stamp: Stamp, with_changes: bool, ) -> Result<()>

Flushes with the given stamp, optionally saving changes for rollback.

fn validate_computed_version_or_reset( &mut self, dep_version: Version, ) -> Result<()>

Validates the computed version against the stored version, resetting if they don’t match. Automatically includes the vec’s own version - only pass dependency versions.

fn validate_and_truncate( &mut self, dep_version: Version, max_from: I, ) -> Result<()>

Validates computed version and truncates to max_from in one call.