Enum ColumnData 

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

Variants

Bool(BoolContainer<S>)

Float4(NumberContainer<f32, S>)

Float8(NumberContainer<f64, S>)

Int1(NumberContainer<i8, S>)

Int2(NumberContainer<i16, S>)

Int4(NumberContainer<i32, S>)

Int8(NumberContainer<i64, S>)

Int16(NumberContainer<i128, S>)

Uint1(NumberContainer<u8, S>)

Uint2(NumberContainer<u16, S>)

Uint4(NumberContainer<u32, S>)

Uint8(NumberContainer<u64, S>)

Uint16(NumberContainer<u128, S>)

Utf8

Fields

container: Utf8Container<S>

max_bytes: MaxBytes

Date(TemporalContainer<Date, S>)

DateTime(TemporalContainer<DateTime, S>)

Time(TemporalContainer<Time, S>)

Duration(TemporalContainer<Duration, S>)

IdentityId(IdentityIdContainer<S>)

Uuid4(UuidContainer<Uuid4, S>)

Uuid7(UuidContainer<Uuid7, S>)

Blob

Fields

container: BlobContainer<S>

max_bytes: MaxBytes

Int

Fields

container: NumberContainer<Int, S>

max_bytes: MaxBytes

Uint

Fields

container: NumberContainer<Uint, S>

max_bytes: MaxBytes

Decimal

Fields

container: NumberContainer<Decimal, S>

precision: Precision

scale: Scale

Any(AnyContainer<S>)

DictionaryId(DictionaryContainer<S>)

Option

Fields

inner: Box<ColumnData<S>>

bitvec: S::BitVec

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 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 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( data: impl IntoIterator<Item = impl Into<String>>, 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 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 dictionary_id(data: impl IntoIterator<Item = DictionaryEntryId>) -> Self

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

pub fn dictionary_id_with_capacity(capacity: usize) -> Self

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

pub fn typed_none(ty: &Type) -> Self

Create a single-element None of the given type (bitvec=false). This preserves the column type so comparisons see the correct inner type rather than Option<Boolean>.

pub fn none_typed(ty: Type, len: usize) -> Self

Create typed column data with all none values (bitvec all false). Always returns an Option-wrapped column to avoid the *_with_bitvec optimization that strips the Option wrapper when the bitvec is all-ones (which is vacuously true for empty bitvecs).

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

pub fn get_as<T: FromColumnData>(&self, index: usize) -> Option<T>

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<S: Storage> ColumnData<S>

pub fn unwrap_option(&self) -> (&ColumnData<S>, Option<&S::BitVec>)

Unwrap Option to inner data + bitvec. Non-Option returns self + None.

pub fn into_unwrap_option(self) -> (ColumnData<S>, Option<S::BitVec>)

Owned version: consume self and return inner data + optional bitvec.

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<S: Storage> ColumnData<S>

pub fn none_count(&self) -> usize

impl<S: Storage> ColumnData<S>

pub fn len(&self) -> usize

pub fn capacity(&self) -> usize

pub fn clear(&mut self)

Clear all data, retaining the allocated capacity for reuse.

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

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 push_none(&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 AsSlice<Box<Value>> for ColumnData

fn as_slice(&self) -> &[Box<Value>]

impl AsSlice<Date> for ColumnData

fn as_slice(&self) -> &[Date]

impl AsSlice<DateTime> for ColumnData

fn as_slice(&self) -> &[DateTime]

impl AsSlice<Decimal> for ColumnData

fn as_slice(&self) -> &[Decimal]

impl AsSlice<Duration> for ColumnData

fn as_slice(&self) -> &[Duration]

impl AsSlice<Int> for ColumnData

fn as_slice(&self) -> &[Int]

impl AsSlice<String> for ColumnData

fn as_slice(&self) -> &[String]

impl AsSlice<Time> for ColumnData

fn as_slice(&self) -> &[Time]

impl AsSlice<Uint> for ColumnData

fn as_slice(&self) -> &[Uint]

impl AsSlice<bool> for ColumnData

fn as_slice(&self) -> &[bool]

impl AsSlice<f32> for ColumnData

fn as_slice(&self) -> &[f32]

impl AsSlice<f64> for ColumnData

fn as_slice(&self) -> &[f64]

impl AsSlice<i128> for ColumnData

fn as_slice(&self) -> &[i128]

impl AsSlice<i16> for ColumnData

fn as_slice(&self) -> &[i16]

impl AsSlice<i32> for ColumnData

fn as_slice(&self) -> &[i32]

impl AsSlice<i64> for ColumnData

fn as_slice(&self) -> &[i64]

impl AsSlice<i8> for ColumnData

fn as_slice(&self) -> &[i8]

impl AsSlice<u128> for ColumnData

fn as_slice(&self) -> &[u128]

impl AsSlice<u16> for ColumnData

fn as_slice(&self) -> &[u16]

impl AsSlice<u32> for ColumnData

fn as_slice(&self) -> &[u32]

impl AsSlice<u64> for ColumnData

fn as_slice(&self) -> &[u64]

impl AsSlice<u8> for ColumnData

fn as_slice(&self) -> &[u8]

impl<S: Storage> Clone for ColumnData<S>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ColumnData<Cow>

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

Formats the value using the given formatter.

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

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

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<S: Storage> PartialEq for ColumnData<S>

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

fn push(&mut self, value: DictionaryEntryId)

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<Cow>

fn serialize<Ser: Serializer>( &self, serializer: Ser, ) -> Result<Ser::Ok, Ser::Error>

Serialize this value into the given Serde serializer.