Enum CommittableColumn

#[non_exhaustive]
pub enum CommittableColumn<'a> {
    Boolean(&'a [bool]),
    Uint8(&'a [u8]),
    TinyInt(&'a [i8]),
    SmallInt(&'a [i16]),
    Int(&'a [i32]),
    BigInt(&'a [i64]),
    Int128(&'a [i128]),
    Decimal75(Precision, i8, Vec<[u64; 4]>),
    Scalar(Vec<[u64; 4]>),
    VarChar(Vec<[u64; 4]>),
    VarBinary(Vec<[u64; 4]>),
    TimestampTZ(PoSQLTimeUnit, PoSQLTimeZone, &'a [i64]),
}

Column data in “committable form”.

For some column types, transformations need to be applied before commitments are created. These transformations require allocating new memory. This is a problem since blitzar only borrows slices of data to commit to. Normal column types don’t store their data in “committable” form, so they cannot interface with blitzar directly.

This type acts as an intermediate column type that can be used with blitzar directly. For column types that need to be transformed, their “committable form” is owned here. For column types that don’t need to allocate new memory, their data is only borrowed here.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Boolean(&'a [bool])

Borrowed Bool column, mapped to bool.

Uint8(&'a [u8])

Borrowed Byte column, mapped to u8.

TinyInt(&'a [i8])

Borrowed TinyInt column, mapped to i8.

SmallInt(&'a [i16])

Borrowed SmallInt column, mapped to i16.

Int(&'a [i32])

Borrowed Int column, mapped to i32.

BigInt(&'a [i64])

Borrowed BigInt column, mapped to i64.

Int128(&'a [i128])

Borrowed Int128 column, mapped to i128.

Decimal75(Precision, i8, Vec<[u64; 4]>)

Borrowed Decimal75(precision, scale, column), mapped to ‘i256’

Scalar(Vec<[u64; 4]>)

Column of big ints for committing to, montgomery-reduced from a Scalar column.

VarChar(Vec<[u64; 4]>)

Column of limbs for committing to scalars, hashed from a VarChar column.

VarBinary(Vec<[u64; 4]>)

Column of limbs for committing to scalars, hashed from a Binary column.

TimestampTZ(PoSQLTimeUnit, PoSQLTimeZone, &'a [i64])

Borrowed Timestamp column with Timezone, mapped to i64.

Implementations

impl CommittableColumn<'_>

pub fn len(&self) -> usize

Returns the length of the column.

pub fn is_empty(&self) -> bool

Returns true if the column is empty.

pub fn column_type(&self) -> ColumnType

Returns the type of the column.

Trait Implementations

impl<'a> Clone for CommittableColumn<'a>

fn clone(&self) -> CommittableColumn<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for CommittableColumn<'a>

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

Formats the value using the given formatter.

impl<'a, S: Scalar> From<&'a [S]> for CommittableColumn<'a>

fn from(value: &'a [S]) -> Self

Converts to this type from the input type.

impl<'a> From<&'a [bool]> for CommittableColumn<'a>

fn from(value: &'a [bool]) -> Self

Converts to this type from the input type.

impl<'a> From<&'a [i128]> for CommittableColumn<'a>

fn from(value: &'a [i128]) -> Self

Converts to this type from the input type.

impl<'a> From<&'a [i16]> for CommittableColumn<'a>

fn from(value: &'a [i16]) -> Self

Converts to this type from the input type.

impl<'a> From<&'a [i32]> for CommittableColumn<'a>

fn from(value: &'a [i32]) -> Self

Converts to this type from the input type.

impl<'a> From<&'a [i64]> for CommittableColumn<'a>

fn from(value: &'a [i64]) -> Self

Converts to this type from the input type.

impl<'a> From<&'a [i8]> for CommittableColumn<'a>

fn from(value: &'a [i8]) -> Self

Converts to this type from the input type.

impl<'a> From<&'a [u8]> for CommittableColumn<'a>

fn from(value: &'a [u8]) -> Self

Converts to this type from the input type.

impl<'a, S: Scalar> From<&Column<'a, S>> for CommittableColumn<'a>

fn from(value: &Column<'a, S>) -> Self

Converts to this type from the input type.

impl<'a> From<&CommittableColumn<'a>> for ColumnType

fn from(value: &CommittableColumn<'a>) -> Self

Converts to this type from the input type.

impl<'a, 'b> From<&'a CommittableColumn<'b>> for Sequence<'a>

fn from(value: &'a CommittableColumn<'b>) -> Self

Converts to this type from the input type.

impl<'a, S: Scalar> From<&'a OwnedColumn<S>> for CommittableColumn<'a>

fn from(value: &'a OwnedColumn<S>) -> Self

Converts to this type from the input type.

impl<'a, S: Scalar> From<Column<'a, S>> for CommittableColumn<'a>

fn from(value: Column<'a, S>) -> Self

Converts to this type from the input type.

impl<'a> PartialEq for CommittableColumn<'a>

fn eq(&self, other: &CommittableColumn<'a>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> Eq for CommittableColumn<'a>

impl<'a> StructuralPartialEq for CommittableColumn<'a>