Struct CompressedVec 

pub struct CompressedVec<I, T> { /* private fields */ }

Compressed storage vector using Pcodec for lossless numerical compression.

Values are compressed in pages for better space efficiency. Best for sequential access patterns of numerical data. Random access is possible but less efficient than RawVec - prefer the latter for random access workloads.

Implementations

impl<I, T> CompressedVec<I, T>

where I: StoredIndex, T: StoredCompressed,

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

Same as import but will reset the vec under certain errors, so be careful !

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

Same as import but will reset the vec under certain errors, so be careful !

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

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

pub fn iter(&self) -> Result<CompressedVecIterator<'_, I, T>>

pub fn clean_iter(&self) -> Result<CleanCompressedVecIterator<'_, I, T>>

pub fn dirty_iter(&self) -> Result<DirtyCompressedVecIterator<'_, I, T>>

pub fn is_dirty(&self) -> bool

Trait Implementations

impl<I: Allocative, T: Allocative> Allocative for CompressedVec<I, T>

fn visit<'allocative_a, 'allocative_b: 'allocative_a>( &self, visitor: &'allocative_a mut Visitor<'allocative_b>, )

impl<I, T> AnyCollectableVec for CompressedVec<I, T>

where I: StoredIndex, T: StoredCompressed,

fn collect_range_json_bytes( &self, from: Option<usize>, to: Option<usize>, ) -> Vec<u8>

fn collect_range_string( &self, from: Option<usize>, to: Option<usize>, ) -> Vec<String>

fn range_count(&self, from: Option<i64>, to: Option<i64>) -> usize

Returns the number of items in the specified range.

fn range_weight(&self, from: Option<i64>, to: Option<i64>) -> usize

Returns the total size in bytes of items in the specified range.

impl<I, T> AnyIterableVec<I, T> for CompressedVec<I, T>

where I: StoredIndex, T: StoredCompressed,

fn boxed_iter(&self) -> BoxedVecIterator<'_, I, T>

fn iter(&self) -> BoxedVecIterator<'_, I, T>

where I: StoredIndex, T: StoredRaw,

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

where I: StoredIndex, T: StoredCompressed,

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 stored_len(&self) -> usize

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

fn real_stored_len(&self) -> usize

The actual length stored on disk.

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

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

fn safe_flush(&mut self, exit: &Exit) -> Result<()>

Flushes while holding the exit lock to ensure consistency during shutdown.

fn update_stamp(&mut self, stamp: Stamp)

fn stamp(&self) -> Stamp

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

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

where I: StoredIndex, T: StoredCompressed,

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 region_names(&self) -> Vec<String>

Returns the list of region names used by this vector.

fn is_empty(&self) -> bool

fn index_to_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, T> Clone for CompressedVec<I, T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

impl<I, T> GenericStoredVec<I, T> for CompressedVec<I, T>

where I: StoredIndex, T: StoredCompressed,

fn read_at(&self, index: usize, reader: &Reader<'_>) -> Result<T>

Reads value at usize index using provided reader.

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

Returns the current pushed (uncommitted) values.

fn mut_pushed(&mut self) -> &mut Vec<T>

Returns a mutable reference to the current pushed (uncommitted) values.

fn holes(&self) -> &BTreeSet<usize>

Returns the set of deleted indices (holes).

fn mut_holes(&mut self) -> &mut BTreeSet<usize>

Returns a mutable reference to the set of holes.

fn updated(&self) -> &BTreeMap<usize, T>

Returns the map of updated (uncommitted modifications to stored) values.

fn mut_updated(&mut self) -> &mut BTreeMap<usize, T>

Returns a mutable reference to the map of updated values.

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

Resets the vector state.

const SIZE_OF_T: usize = _

fn create_reader(&self) -> Reader<'_>

Creates a reader with lifetime tied to self. Be careful with deadlocks - drop the reader before mutable ops.

fn create_static_reader(&self) -> Reader<'static>

Creates a reader with ’static lifetime. Be careful with deadlocks - drop the reader before mutable ops.

fn read(&self, index: I, reader: &Reader<'_>) -> Result<T>

Reads value at index using provided reader.

fn read_once(&self, index: I) -> Result<T>

Reads value at index, creating a temporary reader. For multiple reads, prefer read() with a reused reader.

fn read_at_once(&self, index: usize) -> Result<T>

Reads value at usize index, creating a temporary reader. For multiple reads, prefer read_at() with a reused reader.

fn read_unwrap(&self, index: I, reader: &Reader<'_>) -> T

Reads value at index using provided reader. Panics if read fails.

fn read_unwrap_once(&self, index: I) -> T

Reads value at index, creating a temporary reader. Panics if read fails. For multiple reads, prefer read_unwrap() with a reused reader.

fn read_at_unwrap(&self, index: usize, reader: &Reader<'_>) -> T

Reads value at usize index using provided reader. Panics if read fails.

fn read_at_unwrap_once(&self, index: usize) -> T

Reads value at usize index, creating a temporary reader. Panics if read fails. For multiple reads, prefer read_at_unwrap() with a reused reader.

fn get_or_read(&self, index: I, reader: &Reader<'_>) -> Result<Option<T>>

Gets value from any layer (updated, pushed, or storage) using provided reader. Returns None if index is in holes or beyond available data.

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

Gets value from any layer, creating a temporary reader if needed. For multiple reads, prefer get_or_read() with a reused reader.

fn get_or_read_at(&self, index: usize, reader: &Reader<'_>) -> Result<Option<T>>

Gets value from any layer at usize index using provided reader. Returns None if index is in holes or beyond available data.

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

Gets value from any layer at usize index, creating a temporary reader. For multiple reads, prefer get_or_read_at() with a reused reader.

fn get_or_read_unwrap(&self, index: I, reader: &Reader<'_>) -> T

Gets value from any layer using provided reader. Panics on error.

fn get_or_read_unwrap_once(&self, index: I) -> T

Gets value from any layer, creating a temporary reader. Panics on error.

fn get_pushed_or_read(&self, index: I, reader: &Reader<'_>) -> Result<Option<T>>

Gets value from pushed layer or storage using provided reader. Does not check the updated layer.

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

Gets value from pushed layer or storage, creating a temporary reader. For multiple reads, prefer get_pushed_or_read() with a reused reader.

fn get_pushed_or_read_at( &self, index: usize, reader: &Reader<'_>, ) -> Result<Option<T>>

Gets value from pushed layer or storage at usize index using provided reader. Does not check the updated layer.

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

Gets value from pushed layer or storage at usize index, creating a temporary reader. For multiple reads, prefer get_pushed_or_read_at() with a reused reader.

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

Gets value from pushed layer only (no disk reads).

fn len_(&self) -> usize

Returns the length including both stored and pushed (uncommitted) values. Named len_ to avoid conflict with AnyVec::len.

fn pushed_len(&self) -> usize

Returns the number of pushed (uncommitted) values.

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 index is within the length.

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

Returns true if the usize index is within the length.

fn push(&mut self, value: T)

Pushes a new value to the end of the vector.

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

Pushes a value if the index equals the current length, otherwise does nothing if already exists. Returns an error if the index is too high.

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

Pushes a value at the given index, truncating if necessary, and flushes if cache is full.

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

Pushes a value at the given usize index, truncating if necessary, and flushes if cache is full.

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

Updates the value at the given index.

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

Updates the value at the given usize index.

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

Updates the value at the given index if it exists, or pushes it if the index equals length.

fn get_first_empty_index(&self) -> I

Returns the first empty index (either the first hole or the length).

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

Fills the first hole with the value, or pushes if there are no holes. Returns the index used.

fn take(&mut self, index: I, reader: &Reader<'_>) -> Result<Option<T>>

Takes (removes and returns) the value at the given index using provided reader.

fn take_at(&mut self, index: usize, reader: &Reader<'_>) -> Result<Option<T>>

Takes (removes and returns) the value at the given usize index using provided reader.

fn delete(&mut self, index: I)

Deletes the value at the given index (marks it as a hole).

fn delete_at(&mut self, index: usize)

Deletes the value at the given usize index (marks it as a hole).

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_at(&mut self, index: usize) -> Result<()>

Truncates the vector to the given usize 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 reset_unsaved(&mut self)

Resets uncommitted changes (pushed, holes, and updated layers).

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

Validates the computed version against the stored version, resetting if they don’t match.

fn collect_holed(&self) -> Result<Vec<Option<T>>>

Collects all values into a Vec, with None for holes.

fn collect_holed_range( &self, from: Option<usize>, to: Option<usize>, ) -> Result<Vec<Option<T>>>

Collects values in the given range into a Vec, with None for holes.

fn is_dirty(&mut self) -> bool

Returns true if there are uncommitted changes (pushed or updated values).

fn changes_path(&self) -> PathBuf

Returns the path to the changes directory for this vector.

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

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

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

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

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

Rolls back changes to before the given stamp.

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

Rolls back the most recent change set.

fn deserialize_then_undo_changes(&mut self, bytes: &[u8]) -> Result<()>

Deserializes change data and undoes those changes.

fn vec_region_name(&self) -> String

Returns the region name for this vector.

fn vec_region_name_with(name: &str) -> String

Returns the region name for the given vector name. MUST BE in sync with AnyVec::index_to_name

fn holes_region_name(&self) -> String

Returns the region name for the holes of this vector.

fn holes_region_name_with(name: &str) -> String

Returns the region name for the holes of the given vector name.

impl<'a, I, T> IntoIterator for &'a CompressedVec<I, T>

where I: StoredIndex, T: StoredCompressed,

type Item = T

The type of the elements being iterated over.

type IntoIter = CompressedVecIterator<'a, I, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.