Struct DeltaData 

pub struct DeltaData { /* private fields */ }

A FastLanes-style delta-encoded array of primitive values.

A DeltaArray comprises a sequence of chunks each representing exactly 1,024 delta-encoded values. If the input array length is not a multiple of 1,024, the last chunk is padded with zeros to fill a complete 1,024-element chunk.

Examples

use vortex_array::arrays::PrimitiveArray;
use vortex_array::VortexSessionExecute;
use vortex_array::session::ArraySession;
use vortex_session::VortexSession;
use vortex_fastlanes::Delta;

let session = vortex_array::array_session();
let primitive = PrimitiveArray::from_iter([1_u32, 2, 3, 5, 10, 11]);
let array = Delta::try_from_primitive_array(&primitive, &mut session.create_execution_ctx()).unwrap();

Signed inputs are also supported; deltas across negative values are encoded by wrapping_sub and recovered by wrapping_add at decompress time:

use vortex_array::arrays::PrimitiveArray;
use vortex_array::VortexSessionExecute;
use vortex_array::session::ArraySession;
use vortex_session::VortexSession;
use vortex_fastlanes::Delta;

let session = vortex_array::array_session();
let primitive = PrimitiveArray::from_iter([-3_i32, -2, -1, 0, 1, 2]);
let array = Delta::try_from_primitive_array(&primitive, &mut session.create_execution_ctx()).unwrap();

Details

To facilitate slicing, this array accepts an offset and logical_len. The offset must be strictly less than 1,024 and the sum of offset and logical_len must not exceed the length of the deltas array. These values permit logical slicing without modifying any chunk containing a kept value. In particular, we may defer decompresison until the array is canonicalized or indexed. The offset is a physical offset into the first chunk, which necessarily contains 1,024 values. The logical_len is the number of logical values following the offset, which may be less than the number of physically stored values.

Each chunk is stored as a vector of bases and a vector of deltas. There are as many bases as there are lanes of this type in a 1024-bit register. For example, for 64-bit values, there are 16 bases because there are 16 lanes. Each lane is a delta-encoding 1024 / bit_width long vector of values. The deltas are stored in the FastLanes order which splits the 1,024 values into one contiguous sub-sequence per-lane, thus permitting delta encoding.

Note the validity is stored in the deltas array.

Implementations

impl DeltaData

pub fn try_new(offset: usize) -> VortexResult<Self>

Trait Implementations

impl ArrayEq for DeltaData

fn array_eq(&self, other: &Self, _accuracy: EqMode) -> bool

impl ArrayHash for DeltaData

fn array_hash<H: Hasher>(&self, state: &mut H, _accuracy: EqMode)

impl Clone for DeltaData

fn clone(&self) -> DeltaData

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DeltaData

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

Formats the value using the given formatter.

impl Display for DeltaData

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

Formats the value using the given formatter.