Enum EncodedColumn 

pub enum EncodedColumn<T> {
    Plain(Vec<T>),
    Constant {
        value: T,
        len: u32,
    },
    RunLength {
        values: Vec<T>,
        run_ends: Vec<u32>,
    },
    BitPacked {
        data: Vec<u8>,
        width: u8,
        len: u32,
    },
    Delta {
        first: T,
        deltas: Vec<i32>,
        checkpoints: Vec<i64>,
    },
}

One column of a chunk, in whichever physical form fits its data.

Examples

use molframe_core::column::EncodedColumn;

let repeated = EncodedColumn::encode(&[7u32; 4096]);
assert!(repeated.is_constant());
assert_eq!(repeated.get(4095), Some(7));

let varied = EncodedColumn::encode(&[1u32, 9, 3, 9]);
assert_eq!(varied.get(2), Some(3));
assert_eq!(varied.len(), 4);

Variants

Plain(Vec<T>)

Values as they are. The only form a kernel reads directly.

Constant

One value for the whole column.

Fields

value: T

The repeated value.

len: u32

How many times it repeats.

RunLength

Values with the position each run ends at.

Fields

values: Vec<T>

One value per run.

run_ends: Vec<u32>

Position one past the last member of each run.

BitPacked

Narrow integers at a fixed bit width.

Fields

data: Vec<u8>

The packed bits.

width: u8

Bits per value.

len: u32

How many values are packed.

Delta

A first value and the difference to each successive one.

Fields

first: T

The value at position zero.

deltas: Vec<i32>

Differences between successive values.

checkpoints: Vec<i64>

The absolute value at every DELTA_CHECKPOINT_STRIDE-th position.

Without these, reading position p sums p deltas, so walking a column by index costs O(n^2). Entry k holds the value at position (k + 1) * DELTA_CHECKPOINT_STRIDE, which bounds any read to one stride of additions. At four bytes per delta and eight per checkpoint the table adds about three percent to the encoding.

Implementations

impl<T: ColumnValue> EncodedColumn<T>

pub fn len(&self) -> usize

The number of values held.

pub fn is_empty(&self) -> bool

Returns true when the column holds no values.

pub const fn is_constant(&self) -> bool

Returns true when the column is one repeated value.

pub fn as_slice(&self) -> Option<&[T]>

The values as a slice, when they are stored literally.

A kernel that needs a slice asks for one and takes the other path when it is refused; nothing forces a column into plain form behind the caller’s back.

pub fn get(&self, position: u32) -> Option<T>

The value at position, or None if it is past the end.

pub fn iter(&self) -> ColumnIter<'_, T>

Every value in order.

Reading sequentially through a delta or run-length column this way is linear overall, where repeated random access would not be.

pub fn encode(values: &[T]) -> Self

Chooses an encoding for values by what they contain.

The rules, in order: one repeated value becomes constant; few runs become run-length; small non-negative integers become bit-packed when that is genuinely narrower; a near-monotonic integer sequence becomes deltas; anything else stays plain.

pub fn plain(values: &[T]) -> Self

Stores values literally, whatever they are.

This is what a hot column asks for: it declines encoding rather than letting the rules decide.

Trait Implementations

impl<T: Clone> Clone for EncodedColumn<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for EncodedColumn<T>

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

Formats the value using the given formatter.

impl<'a, T: ColumnValue> IntoIterator for &'a EncodedColumn<T>

type Item = T

The type of the elements being iterated over.

type IntoIter = ColumnIter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T: PartialEq> PartialEq for EncodedColumn<T>

fn eq(&self, other: &Self) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<T: PartialEq> StructuralPartialEq for EncodedColumn<T>