Struct Vector 

pub struct Vector { /* private fields */ }

A type, a length, a validity representation and some data.

Implementations

impl Vector

pub fn flat(ty: LogicalType, data: Data) -> Result<Self>

A flat vector of data, all valid.

Errors

If the data’s physical layout is not the one the type calls for. That check is here rather than left to the caller because a vector whose type and layout disagree is a wrong answer waiting to be read out, and it costs one comparison at construction to prevent.

pub fn constant(ty: LogicalType, value: Value, len: usize) -> Self

A vector of len copies of one value.

Costs one value regardless of the length, which is what makes a literal in a predicate free and what makes a projection of a constant free.

pub fn sequence(start: i64, step: i64, len: usize) -> Self

A vector of len values starting at start and stepping by step.

This is what a row identifier column is, and it costs sixteen bytes rather than eight kilobytes. A scan that produces row ids for a later fetch produces one of these.

pub fn dictionary(codes: Vec<u32>, values: Vector) -> Result<Self>

A vector of codes into a smaller vector of distinct values.

The form the whole M3 thesis rests on. A dictionary vector handed to a group by is an integer column, and an aggregate over one is an aggregate over integers no matter what the logical type says.

Errors

If any code is past the end of the value vector.

pub fn with_validity(self, validity: Validity) -> Self

The same vector with a different validity.

pub fn logical_type(&self) -> &LogicalType

What kind of values these are.

pub fn len(&self) -> usize

How many values there are.

pub fn is_empty(&self) -> bool

Whether there are no values.

pub fn validity(&self) -> &Validity

Which of the values are not null.

pub fn form(&self) -> Form

Which physical form this vector is in.

pub fn data(&self) -> Option<&Data>

The data, for a flat vector, and None for any other form.

A kernel that wants a slice asks for it and takes the flat path if it gets one. A kernel that can do better on a constant or a dictionary checks Self::form first.

pub fn value_at(&self, index: usize) -> Value

The value at index, as a single value.

This is the slow path on purpose. It is what a result set is read out with and what a test asserts on, and an operator that calls it per row is an operator that has already lost the argument the vector interface exists to win.

pub fn iter(&self) -> impl Iterator<Item = Value> + '_

Every value in order, as single values.

pub fn flatten(&self) -> Result<Self>

The same values in flat form.

Flattening a vector that is already flat is free. Flattening any other form costs a copy, which is exactly why the other forms exist and why nothing on the hot path should call this. It is here for the operators that genuinely cannot do better and for the tests that check the other forms against it.

Errors

If the type is one this crate cannot store flat yet, which today means the nested types.

Trait Implementations

impl Clone for Vector

fn clone(&self) -> Vector

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Vector

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

Formats the value using the given formatter.

impl PartialEq for Vector

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Vector