Enum ColumnData 

pub enum ColumnData {
    Bool(BoolContainer),
    Float4(NumberContainer<f32>),
    Float8(NumberContainer<f64>),
    Int1(NumberContainer<i8>),
    Int2(NumberContainer<i16>),
    Int4(NumberContainer<i32>),
    Int8(NumberContainer<i64>),
    Int16(NumberContainer<i128>),
    Uint1(NumberContainer<u8>),
    Uint2(NumberContainer<u16>),
    Uint4(NumberContainer<u32>),
    Uint8(NumberContainer<u64>),
    Uint16(NumberContainer<u128>),
    Utf8 {
        container: Utf8Container,
        max_bytes: MaxBytes,
    },
    Date(TemporalContainer<Date>),
    DateTime(TemporalContainer<DateTime>),
    Time(TemporalContainer<Time>),
    Duration(TemporalContainer<Duration>),
    RowNumber(RowNumberContainer),
    IdentityId(IdentityIdContainer),
    Uuid4(UuidContainer<Uuid4>),
    Uuid7(UuidContainer<Uuid7>),
    Blob {
        container: BlobContainer,
        max_bytes: MaxBytes,
    },
    Int {
        container: NumberContainer<Int>,
        max_bytes: MaxBytes,
    },
    Uint {
        container: NumberContainer<Uint>,
        max_bytes: MaxBytes,
    },
    Decimal {
        container: NumberContainer<Decimal>,
        precision: Precision,
        scale: Scale,
    },
    Any(AnyContainer),
    Undefined(UndefinedContainer),
}

Variants

Bool(BoolContainer)

Float4(NumberContainer<f32>)

Float8(NumberContainer<f64>)

Int1(NumberContainer<i8>)

Int2(NumberContainer<i16>)

Int4(NumberContainer<i32>)

Int8(NumberContainer<i64>)

Int16(NumberContainer<i128>)

Uint1(NumberContainer<u8>)

Uint2(NumberContainer<u16>)

Uint4(NumberContainer<u32>)

Uint8(NumberContainer<u64>)

Uint16(NumberContainer<u128>)

Utf8

Fields

container: Utf8Container

max_bytes: MaxBytes

Date(TemporalContainer<Date>)

DateTime(TemporalContainer<DateTime>)

Time(TemporalContainer<Time>)

Duration(TemporalContainer<Duration>)

RowNumber(RowNumberContainer)

IdentityId(IdentityIdContainer)

Uuid4(UuidContainer<Uuid4>)

Uuid7(UuidContainer<Uuid7>)

Blob

Fields

container: BlobContainer

max_bytes: MaxBytes

Int

Fields

container: NumberContainer<Int>

max_bytes: MaxBytes

Uint

Fields

container: NumberContainer<Uint>

max_bytes: MaxBytes

Decimal

Fields

container: NumberContainer<Decimal>

precision: Precision

scale: Scale

Any(AnyContainer)

Undefined(UndefinedContainer)

Implementations

impl ColumnData

pub fn extend(&mut self, other: ColumnData) -> Result<()>

impl ColumnData

pub fn bool(data: impl IntoIterator<Item = bool>) -> Self

pub fn bool_optional(data: impl IntoIterator<Item = Option<bool>>) -> Self

pub fn bool_with_capacity(capacity: usize) -> Self

pub fn bool_with_bitvec( data: impl IntoIterator<Item = bool>, bitvec: impl Into<BitVec>, ) -> Self

pub fn float4(data: impl IntoIterator<Item = f32>) -> Self

pub fn float4_optional(data: impl IntoIterator<Item = Option<f32>>) -> Self

pub fn float4_with_capacity(capacity: usize) -> Self

pub fn float4_with_bitvec( data: impl IntoIterator<Item = f32>, bitvec: impl Into<BitVec>, ) -> Self

pub fn float8(data: impl IntoIterator<Item = f64>) -> Self

pub fn float8_optional(data: impl IntoIterator<Item = Option<f64>>) -> Self

pub fn float8_with_capacity(capacity: usize) -> Self

pub fn float8_with_bitvec( data: impl IntoIterator<Item = f64>, bitvec: impl Into<BitVec>, ) -> Self

pub fn int1(data: impl IntoIterator<Item = i8>) -> Self

pub fn int1_optional(data: impl IntoIterator<Item = Option<i8>>) -> Self

pub fn int1_with_capacity(capacity: usize) -> Self

pub fn int1_with_bitvec( data: impl IntoIterator<Item = i8>, bitvec: impl Into<BitVec>, ) -> Self

pub fn int2(data: impl IntoIterator<Item = i16>) -> Self

pub fn int2_optional(data: impl IntoIterator<Item = Option<i16>>) -> Self

pub fn int2_with_capacity(capacity: usize) -> Self

pub fn int2_with_bitvec( data: impl IntoIterator<Item = i16>, bitvec: impl Into<BitVec>, ) -> Self

pub fn int4(data: impl IntoIterator<Item = i32>) -> Self

pub fn int4_optional(data: impl IntoIterator<Item = Option<i32>>) -> Self

pub fn int4_with_capacity(capacity: usize) -> Self

pub fn int4_with_bitvec( data: impl IntoIterator<Item = i32>, bitvec: impl Into<BitVec>, ) -> Self

pub fn int8(data: impl IntoIterator<Item = i64>) -> Self

pub fn int8_optional(data: impl IntoIterator<Item = Option<i64>>) -> Self

pub fn int8_with_capacity(capacity: usize) -> Self

pub fn int8_with_bitvec( data: impl IntoIterator<Item = i64>, bitvec: impl Into<BitVec>, ) -> Self

pub fn int16(data: impl IntoIterator<Item = i128>) -> Self

pub fn int16_optional(data: impl IntoIterator<Item = Option<i128>>) -> Self

pub fn int16_with_capacity(capacity: usize) -> Self

pub fn int16_with_bitvec( data: impl IntoIterator<Item = i128>, bitvec: impl Into<BitVec>, ) -> Self

pub fn utf8(data: impl IntoIterator<Item = impl Into<String>>) -> Self

pub fn utf8_optional(data: impl IntoIterator<Item = Option<String>>) -> Self

pub fn utf8_with_capacity(capacity: usize) -> Self

pub fn utf8_with_bitvec<'a>( data: impl IntoIterator<Item = impl Into<String>>, bitvec: impl Into<BitVec>, ) -> Self

pub fn uint1(data: impl IntoIterator<Item = u8>) -> Self

pub fn uint1_optional(data: impl IntoIterator<Item = Option<u8>>) -> Self

pub fn uint1_with_capacity(capacity: usize) -> Self

pub fn uint1_with_bitvec( data: impl IntoIterator<Item = u8>, bitvec: impl Into<BitVec>, ) -> Self

pub fn uint2(data: impl IntoIterator<Item = u16>) -> Self

pub fn uint2_optional(data: impl IntoIterator<Item = Option<u16>>) -> Self

pub fn uint2_with_capacity(capacity: usize) -> Self

pub fn uint2_with_bitvec( data: impl IntoIterator<Item = u16>, bitvec: impl Into<BitVec>, ) -> Self

pub fn uint4(data: impl IntoIterator<Item = u32>) -> Self

pub fn uint4_optional(data: impl IntoIterator<Item = Option<u32>>) -> Self

pub fn uint4_with_capacity(capacity: usize) -> Self

pub fn uint4_with_bitvec( data: impl IntoIterator<Item = u32>, bitvec: impl Into<BitVec>, ) -> Self

pub fn uint8(data: impl IntoIterator<Item = u64>) -> Self

pub fn uint8_optional(data: impl IntoIterator<Item = Option<u64>>) -> Self

pub fn uint8_with_capacity(capacity: usize) -> Self

pub fn uint8_with_bitvec( data: impl IntoIterator<Item = u64>, bitvec: impl Into<BitVec>, ) -> Self

pub fn uint16(data: impl IntoIterator<Item = u128>) -> Self

pub fn uint16_optional(data: impl IntoIterator<Item = Option<u128>>) -> Self

pub fn uint16_with_capacity(capacity: usize) -> Self

pub fn uint16_with_bitvec( data: impl IntoIterator<Item = u128>, bitvec: impl Into<BitVec>, ) -> Self

pub fn date(data: impl IntoIterator<Item = Date>) -> Self

pub fn date_optional(data: impl IntoIterator<Item = Option<Date>>) -> Self

pub fn date_with_capacity(capacity: usize) -> Self

pub fn date_with_bitvec( data: impl IntoIterator<Item = Date>, bitvec: impl Into<BitVec>, ) -> Self

pub fn datetime(data: impl IntoIterator<Item = DateTime>) -> Self

pub fn datetime_optional( data: impl IntoIterator<Item = Option<DateTime>>, ) -> Self

pub fn datetime_with_capacity(capacity: usize) -> Self

pub fn datetime_with_bitvec( data: impl IntoIterator<Item = DateTime>, bitvec: impl Into<BitVec>, ) -> Self

pub fn time(data: impl IntoIterator<Item = Time>) -> Self

pub fn time_optional(data: impl IntoIterator<Item = Option<Time>>) -> Self

pub fn time_with_capacity(capacity: usize) -> Self

pub fn time_with_bitvec( data: impl IntoIterator<Item = Time>, bitvec: impl Into<BitVec>, ) -> Self

pub fn duration(data: impl IntoIterator<Item = Duration>) -> Self

pub fn duration_optional( data: impl IntoIterator<Item = Option<Duration>>, ) -> Self

pub fn duration_with_capacity(capacity: usize) -> Self

pub fn duration_with_bitvec( data: impl IntoIterator<Item = Duration>, bitvec: impl Into<BitVec>, ) -> Self

pub fn uuid4(data: impl IntoIterator<Item = Uuid4>) -> Self

pub fn uuid4_optional(data: impl IntoIterator<Item = Option<Uuid4>>) -> Self

pub fn uuid4_with_capacity(capacity: usize) -> Self

pub fn uuid4_with_bitvec( data: impl IntoIterator<Item = Uuid4>, bitvec: impl Into<BitVec>, ) -> Self

pub fn uuid7(data: impl IntoIterator<Item = Uuid7>) -> Self

pub fn uuid7_optional(data: impl IntoIterator<Item = Option<Uuid7>>) -> Self

pub fn uuid7_with_capacity(capacity: usize) -> Self

pub fn uuid7_with_bitvec( data: impl IntoIterator<Item = Uuid7>, bitvec: impl Into<BitVec>, ) -> Self

pub fn blob(data: impl IntoIterator<Item = Blob>) -> Self

pub fn blob_optional(data: impl IntoIterator<Item = Option<Blob>>) -> Self

pub fn blob_with_capacity(capacity: usize) -> Self

pub fn blob_with_bitvec( data: impl IntoIterator<Item = Blob>, bitvec: impl Into<BitVec>, ) -> Self

pub fn row_number(row_numbers: impl IntoIterator<Item = RowNumber>) -> Self

pub fn row_number_optional( row_numbers: impl IntoIterator<Item = Option<RowNumber>>, ) -> Self

pub fn row_number_with_capacity(capacity: usize) -> Self

pub fn row_number_with_bitvec( row_numbers: impl IntoIterator<Item = RowNumber>, bitvec: impl Into<BitVec>, ) -> Self

pub fn identity_id(identity_ids: impl IntoIterator<Item = IdentityId>) -> Self

pub fn identity_id_optional( identity_ids: impl IntoIterator<Item = Option<IdentityId>>, ) -> Self

pub fn identity_id_with_capacity(capacity: usize) -> Self

pub fn identity_id_with_bitvec( identity_ids: impl IntoIterator<Item = IdentityId>, bitvec: impl Into<BitVec>, ) -> Self

pub fn int(data: impl IntoIterator<Item = Int>) -> Self

pub fn int_optional(data: impl IntoIterator<Item = Option<Int>>) -> Self

pub fn uint(data: impl IntoIterator<Item = Uint>) -> Self

pub fn uint_optional(data: impl IntoIterator<Item = Option<Uint>>) -> Self

pub fn int_with_capacity(capacity: usize) -> Self

pub fn uint_with_capacity(capacity: usize) -> Self

pub fn int_with_bitvec( data: impl IntoIterator<Item = Int>, bitvec: impl Into<BitVec>, ) -> Self

pub fn uint_with_bitvec( data: impl IntoIterator<Item = Uint>, bitvec: impl Into<BitVec>, ) -> Self

pub fn decimal(data: impl IntoIterator<Item = Decimal>) -> Self

pub fn decimal_optional(data: impl IntoIterator<Item = Option<Decimal>>) -> Self

pub fn decimal_with_capacity(capacity: usize) -> Self

pub fn decimal_with_bitvec( data: impl IntoIterator<Item = Decimal>, bitvec: impl Into<BitVec>, ) -> Self

pub fn any(data: impl IntoIterator<Item = Box<Value>>) -> Self

pub fn any_optional(data: impl IntoIterator<Item = Option<Box<Value>>>) -> Self

pub fn any_with_capacity(capacity: usize) -> Self

pub fn any_with_bitvec( data: impl IntoIterator<Item = Box<Value>>, bitvec: impl Into<BitVec>, ) -> Self

pub fn undefined(len: usize) -> Self

impl ColumnData

pub fn filter(&mut self, mask: &BitVec) -> Result<()>

impl ColumnData

pub fn from_many(value: Value, row_count: usize) -> Self

impl ColumnData

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

impl ColumnData

pub fn reorder(&mut self, indices: &[usize])

impl ColumnData

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

where Self: AsSlice<T>,

impl ColumnData

pub fn take(&self, num: usize) -> ColumnData

impl ColumnData

pub fn get_type(&self) -> Type

pub fn is_defined(&self, idx: usize) -> bool

pub fn is_bool(&self) -> bool

pub fn is_float(&self) -> bool

pub fn is_utf8(&self) -> bool

pub fn is_number(&self) -> bool

pub fn is_text(&self) -> bool

pub fn is_temporal(&self) -> bool

pub fn is_uuid(&self) -> bool

impl ColumnData

pub fn bitvec(&self) -> &BitVec

pub fn undefined_count(&self) -> usize

impl ColumnData

pub fn with_capacity(target: Type, capacity: usize) -> Self

pub fn iter<'a>(&'a self) -> Box<dyn Iterator<Item = Value> + 'a>

impl ColumnData

pub fn len(&self) -> usize

pub fn capacity(&self) -> usize

pub fn as_string(&self, index: usize) -> String

impl ColumnData

pub fn push_undefined(&mut self)

impl ColumnData

pub fn push_value(&mut self, value: Value)

impl ColumnData

pub fn push<T>(&mut self, value: T)

where Self: Push<T>, T: Debug,

Trait Implementations

impl Clone for ColumnData

fn clone(&self) -> ColumnData

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ColumnData

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ColumnData

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<ColumnData> for FrameColumnData

fn from(value: ColumnData) -> Self

Converts to this type from the input type.

impl From<Value> for ColumnData

fn from(value: Value) -> Self

Converts to this type from the input type.

impl PartialEq for ColumnData

fn eq(&self, other: &ColumnData) -> 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 Push<&str> for ColumnData

fn push(&mut self, value: &str)

impl Push<Blob> for ColumnData

fn push(&mut self, value: Blob)

impl Push<Date> for ColumnData

fn push(&mut self, value: Date)

impl Push<DateTime> for ColumnData

fn push(&mut self, value: DateTime)

impl Push<Decimal> for ColumnData

fn push(&mut self, value: Decimal)

impl Push<Duration> for ColumnData

fn push(&mut self, value: Duration)

impl Push<Int> for ColumnData

fn push(&mut self, value: Int)

impl Push<String> for ColumnData

fn push(&mut self, value: String)

impl Push<Time> for ColumnData

fn push(&mut self, value: Time)

impl Push<Uint> for ColumnData

fn push(&mut self, value: Uint)

impl Push<Uuid4> for ColumnData

fn push(&mut self, value: Uuid4)

impl Push<Uuid7> for ColumnData

fn push(&mut self, value: Uuid7)

impl Push<bool> for ColumnData

fn push(&mut self, value: bool)

impl Push<f32> for ColumnData

fn push(&mut self, value: f32)

impl Push<f64> for ColumnData

fn push(&mut self, value: f64)

impl Push<i128> for ColumnData

fn push(&mut self, value: i128)

impl Push<i16> for ColumnData

fn push(&mut self, value: i16)

impl Push<i32> for ColumnData

fn push(&mut self, value: i32)

impl Push<i64> for ColumnData

fn push(&mut self, value: i64)

impl Push<i8> for ColumnData

fn push(&mut self, value: i8)

impl Push<u128> for ColumnData

fn push(&mut self, value: u128)

impl Push<u16> for ColumnData

fn push(&mut self, value: u16)

impl Push<u32> for ColumnData

fn push(&mut self, value: u32)

impl Push<u64> for ColumnData

fn push(&mut self, value: u64)

impl Push<u8> for ColumnData

fn push(&mut self, value: u8)

impl Serialize for ColumnData

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ColumnData