Trait LogicalType 

pub trait LogicalType {
    type Typed: Clone;
    type Value<'a>
       where Self: 'a;
    type Owned;

    const NULLABLE: bool = false;

    // Required methods
    fn downcast(array: &dyn Array) -> Result<Self::Typed, ColumnError>;
    fn is_null(typed: &Self::Typed, index: usize) -> bool;
    fn value(typed: &Self::Typed, index: usize) -> Self::Value<'_>;
    fn to_owned_value(value: Self::Value<'_>) -> Self::Owned;
}

A logical column type, e.g. Utf8, Option<i64>, or List<Utf8>.

Option<L> means the values at this nesting level may be null.

The primitive Rust types implement it directly, and Option<L> adds nullability at any nesting level:

use quiver::Column;

let numbers = Column::<i64>::from_values([1, 2, 3]);
assert_eq!(numbers.value(0), 1);
assert_eq!(numbers.as_slice(), &[1, 2, 3]); // bulk, zero-copy (not for `bool`)

let maybe = Column::<Option<i64>>::from_values([Some(1), None]);
assert_eq!(maybe.value(1), None);

Provided Associated Constants

const NULLABLE: bool = false

May the values at this level be null? (true only for Option<…>)

Required Associated Types

type Typed: Clone

The fully-downcast, validated representation of one column of this datatype. Cheap to clone (arrow arrays are reference-counted).

type Value<'a> where Self: 'a

Zero-copy element view: &'a str for Utf8, i64 for i64, an iterator for List<T>, Option<…> for Option<T>.

type Owned

The owned value of one element, used by the convenience constructors: String for Utf8, Option<i64> for Option<i64>, Vec<…> for List<…>, etc.

Required Methods

fn downcast(array: &dyn Array) -> Result<Self::Typed, ColumnError>

Validates that array has an acceptable datatype, then recursively downcasts it — checking the nulls of all children along the way.

This is the single validation+downcast hook, called once per column at the boundary (Column::try_new). It must reject any array whose datatype this logical type does not accept (returning ColumnError::WrongDatatype), including datatype parameters not encoded in the concrete arrow array’s Rust type — a FixedSizeBinary / FixedSizeList size, a Timestamp timezone, etc. The leaf type check comes from the concrete-array downcast; nested element types are validated by recursing into the children’s downcast.

Multi-encoding types like AnyList inspect array.data_type() and dispatch to the matching encoding.

Nulls at the level of array itself are the responsibility of the caller (the parent datatype, or Column::try_new at the top level), because only the caller knows if this level is wrapped in an Option.

Errors

Errors on a datatype mismatch, or on unexpected nulls in children.

fn is_null(typed: &Self::Typed, index: usize) -> bool

Is the value at index null?

fn value(typed: &Self::Typed, index: usize) -> Self::Value<'_>

The value at index.

Contract: index is in bounds, and the value is non-null unless Self is an Option.

fn to_owned_value(value: Self::Value<'_>) -> Self::Owned

Converts a borrowed element value into an owned one, e.g. &str → String.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl LogicalType for bool

type Typed = BooleanArray

type Value<'a> = bool

type Owned = bool

fn downcast( array: &dyn Array, ) -> Result<<bool as LogicalType>::Typed, ColumnError>

fn is_null(typed: &<bool as LogicalType>::Typed, index: usize) -> bool

fn value( typed: &<bool as LogicalType>::Typed, index: usize, ) -> <bool as LogicalType>::Value<'_>

fn to_owned_value( value: <bool as LogicalType>::Value<'_>, ) -> <bool as LogicalType>::Owned

impl LogicalType for f32

type Typed = PrimitiveArray<Float32Type>

type Value<'a> = f32

type Owned = f32

fn downcast( array: &dyn Array, ) -> Result<<f32 as LogicalType>::Typed, ColumnError>

fn is_null(typed: &<f32 as LogicalType>::Typed, index: usize) -> bool

fn value( typed: &<f32 as LogicalType>::Typed, index: usize, ) -> <f32 as LogicalType>::Value<'_>

fn to_owned_value( value: <f32 as LogicalType>::Value<'_>, ) -> <f32 as LogicalType>::Owned

impl LogicalType for f64

type Typed = PrimitiveArray<Float64Type>

type Value<'a> = f64

type Owned = f64

fn downcast( array: &dyn Array, ) -> Result<<f64 as LogicalType>::Typed, ColumnError>

fn is_null(typed: &<f64 as LogicalType>::Typed, index: usize) -> bool

fn value( typed: &<f64 as LogicalType>::Typed, index: usize, ) -> <f64 as LogicalType>::Value<'_>

fn to_owned_value( value: <f64 as LogicalType>::Value<'_>, ) -> <f64 as LogicalType>::Owned

impl LogicalType for i8

type Typed = PrimitiveArray<Int8Type>

type Value<'a> = i8

type Owned = i8

fn downcast( array: &dyn Array, ) -> Result<<i8 as LogicalType>::Typed, ColumnError>

fn is_null(typed: &<i8 as LogicalType>::Typed, index: usize) -> bool

fn value( typed: &<i8 as LogicalType>::Typed, index: usize, ) -> <i8 as LogicalType>::Value<'_>

fn to_owned_value( value: <i8 as LogicalType>::Value<'_>, ) -> <i8 as LogicalType>::Owned

impl LogicalType for i16

type Typed = PrimitiveArray<Int16Type>

type Value<'a> = i16

type Owned = i16

fn downcast( array: &dyn Array, ) -> Result<<i16 as LogicalType>::Typed, ColumnError>

fn is_null(typed: &<i16 as LogicalType>::Typed, index: usize) -> bool

fn value( typed: &<i16 as LogicalType>::Typed, index: usize, ) -> <i16 as LogicalType>::Value<'_>

fn to_owned_value( value: <i16 as LogicalType>::Value<'_>, ) -> <i16 as LogicalType>::Owned

impl LogicalType for i32

type Typed = PrimitiveArray<Int32Type>

type Value<'a> = i32

type Owned = i32

fn downcast( array: &dyn Array, ) -> Result<<i32 as LogicalType>::Typed, ColumnError>

fn is_null(typed: &<i32 as LogicalType>::Typed, index: usize) -> bool

fn value( typed: &<i32 as LogicalType>::Typed, index: usize, ) -> <i32 as LogicalType>::Value<'_>

fn to_owned_value( value: <i32 as LogicalType>::Value<'_>, ) -> <i32 as LogicalType>::Owned

impl LogicalType for i64

type Typed = PrimitiveArray<Int64Type>

type Value<'a> = i64

type Owned = i64

fn downcast( array: &dyn Array, ) -> Result<<i64 as LogicalType>::Typed, ColumnError>

fn is_null(typed: &<i64 as LogicalType>::Typed, index: usize) -> bool

fn value( typed: &<i64 as LogicalType>::Typed, index: usize, ) -> <i64 as LogicalType>::Value<'_>

fn to_owned_value( value: <i64 as LogicalType>::Value<'_>, ) -> <i64 as LogicalType>::Owned

impl LogicalType for u8

type Typed = PrimitiveArray<UInt8Type>

type Value<'a> = u8

type Owned = u8

fn downcast( array: &dyn Array, ) -> Result<<u8 as LogicalType>::Typed, ColumnError>

fn is_null(typed: &<u8 as LogicalType>::Typed, index: usize) -> bool

fn value( typed: &<u8 as LogicalType>::Typed, index: usize, ) -> <u8 as LogicalType>::Value<'_>

fn to_owned_value( value: <u8 as LogicalType>::Value<'_>, ) -> <u8 as LogicalType>::Owned

impl LogicalType for u16

type Typed = PrimitiveArray<UInt16Type>

type Value<'a> = u16

type Owned = u16

fn downcast( array: &dyn Array, ) -> Result<<u16 as LogicalType>::Typed, ColumnError>

fn is_null(typed: &<u16 as LogicalType>::Typed, index: usize) -> bool

fn value( typed: &<u16 as LogicalType>::Typed, index: usize, ) -> <u16 as LogicalType>::Value<'_>

fn to_owned_value( value: <u16 as LogicalType>::Value<'_>, ) -> <u16 as LogicalType>::Owned

impl LogicalType for u32

type Typed = PrimitiveArray<UInt32Type>

type Value<'a> = u32

type Owned = u32

fn downcast( array: &dyn Array, ) -> Result<<u32 as LogicalType>::Typed, ColumnError>

fn is_null(typed: &<u32 as LogicalType>::Typed, index: usize) -> bool

fn value( typed: &<u32 as LogicalType>::Typed, index: usize, ) -> <u32 as LogicalType>::Value<'_>

fn to_owned_value( value: <u32 as LogicalType>::Value<'_>, ) -> <u32 as LogicalType>::Owned

impl LogicalType for u64

type Typed = PrimitiveArray<UInt64Type>

type Value<'a> = u64

type Owned = u64

fn downcast( array: &dyn Array, ) -> Result<<u64 as LogicalType>::Typed, ColumnError>

fn is_null(typed: &<u64 as LogicalType>::Typed, index: usize) -> bool

fn value( typed: &<u64 as LogicalType>::Typed, index: usize, ) -> <u64 as LogicalType>::Value<'_>

fn to_owned_value( value: <u64 as LogicalType>::Value<'_>, ) -> <u64 as LogicalType>::Owned

impl<L> LogicalType for Option<L>

where L: LogicalType,

Option<L>: the values at this level may be null.

const NULLABLE: bool = true

type Typed = <L as LogicalType>::Typed

type Value<'a> = Option<<L as LogicalType>::Value<'a>> where Option<L>: 'a

type Owned = Option<<L as LogicalType>::Owned>

fn downcast( array: &dyn Array, ) -> Result<<Option<L> as LogicalType>::Typed, ColumnError>

fn is_null(typed: &<Option<L> as LogicalType>::Typed, index: usize) -> bool

fn value( typed: &<Option<L> as LogicalType>::Typed, index: usize, ) -> <Option<L> as LogicalType>::Value<'_>

fn to_owned_value( value: <Option<L> as LogicalType>::Value<'_>, ) -> <Option<L> as LogicalType>::Owned

Implementors

impl LogicalType for AnyBinary

type Typed = AnyTypedBinary

type Value<'a> = &'a [u8]

type Owned = Vec<u8>

impl LogicalType for AnyUtf8

type Typed = AnyTypedUtf8

type Value<'a> = &'a str

type Owned = String

impl LogicalType for Binary

type Typed = GenericByteArray<GenericBinaryType<i32>>

type Value<'a> = &'a [u8]

type Owned = Vec<u8>

impl LogicalType for BinaryView

type Typed = GenericByteViewArray<BinaryViewType>

type Value<'a> = &'a [u8]

type Owned = Vec<u8>

impl LogicalType for Date32

type Typed = PrimitiveArray<Date32Type>

type Value<'a> = i32

type Owned = i32

impl LogicalType for Date64

type Typed = PrimitiveArray<Date64Type>

type Value<'a> = i64

type Owned = i64

impl LogicalType for LargeBinary

type Typed = GenericByteArray<GenericBinaryType<i64>>

type Value<'a> = &'a [u8]

type Owned = Vec<u8>

impl LogicalType for LargeUtf8

type Typed = GenericByteArray<GenericStringType<i64>>

type Value<'a> = &'a str

type Owned = String

impl LogicalType for Time32Millisecond

type Typed = PrimitiveArray<Time32MillisecondType>

type Value<'a> = i32

type Owned = i32

impl LogicalType for Time32Second

type Typed = PrimitiveArray<Time32SecondType>

type Value<'a> = i32

type Owned = i32

impl LogicalType for Time64Microsecond

type Typed = PrimitiveArray<Time64MicrosecondType>

type Value<'a> = i64

type Owned = i64

impl LogicalType for Time64Nanosecond

type Typed = PrimitiveArray<Time64NanosecondType>

type Value<'a> = i64

type Owned = i64

impl LogicalType for Utf8

type Typed = GenericByteArray<GenericStringType<i32>>

type Value<'a> = &'a str

type Owned = String

impl LogicalType for Utf8View

type Typed = GenericByteViewArray<StringViewType>

type Value<'a> = &'a str

type Owned = String

impl LogicalType for f16

type Typed = PrimitiveArray<Float16Type>

type Value<'a> = f16

type Owned = f16

impl<K, V> LogicalType for Dictionary<K, V>

where K: DictionaryKey + 'static, V: LogicalType + 'static,

type Typed = TypedDictionary<K, V>

type Value<'a> = <V as LogicalType>::Value<'a>

type Owned = <V as LogicalType>::Owned

impl<K, V> LogicalType for Map<K, V>

where K: LogicalType + 'static, V: LogicalType + 'static,

type Typed = TypedMap<K, V>

type Value<'a> = MapValue<'a, K, V> where Map<K, V>: 'a

type Owned = Vec<(<K as LogicalType>::Owned, <V as LogicalType>::Owned)>

impl<L, const N: usize> LogicalType for FixedSizeList<L, N>

where L: LogicalType + 'static,

type Typed = TypedFixedSizeList<L>

type Value<'a> = ListValue<'a, L> where FixedSizeList<L, N>: 'a

type Owned = [<L as LogicalType>::Owned; N]

impl<L> LogicalType for AnyList<L>

where L: LogicalType + 'static,

type Typed = AnyTypedList<L>

type Value<'a> = ListValue<'a, L> where AnyList<L>: 'a

type Owned = Vec<<L as LogicalType>::Owned>

impl<L> LogicalType for LargeList<L>

where L: LogicalType + 'static,

type Typed = TypedLargeList<L>

type Value<'a> = ListValue<'a, L> where LargeList<L>: 'a

type Owned = Vec<<L as LogicalType>::Owned>

impl<L> LogicalType for LargeListView<L>

where L: LogicalType + 'static,

type Typed = TypedLargeListView<L>

type Value<'a> = ListValue<'a, L> where LargeListView<L>: 'a

type Owned = Vec<<L as LogicalType>::Owned>

impl<L> LogicalType for List<L>

where L: LogicalType + 'static,

type Typed = TypedList<L>

type Value<'a> = ListValue<'a, L> where List<L>: 'a

type Owned = Vec<<L as LogicalType>::Owned>

impl<L> LogicalType for ListView<L>

where L: LogicalType + 'static,

type Typed = TypedListView<L>

type Value<'a> = ListValue<'a, L> where ListView<L>: 'a

type Owned = Vec<<L as LogicalType>::Owned>

impl<R, V> LogicalType for Run<R, V>

where R: RunEndType + 'static, V: LogicalType + 'static,

type Typed = TypedRun<R, V>

type Value<'a> = <V as LogicalType>::Value<'a>

type Owned = <V as LogicalType>::Owned

impl<T, Repr> LogicalType for As<T, Repr>

where T: 'static + From<<Repr as LogicalType>::Owned>, Repr: LogicalType + 'static, <Repr as LogicalType>::Owned: From<T>,

const NULLABLE: bool = Repr::NULLABLE

type Typed = <Repr as LogicalType>::Typed

type Value<'a> = <Repr as LogicalType>::Value<'a> where As<T, Repr>: 'a

type Owned = T

impl<U, Z> LogicalType for Timestamp<U, Z>

where U: TimeUnitSpec + 'static, Z: TimezoneSpec + 'static,

type Typed = PrimitiveArray<<U as TimeUnitSpec>::TimestampType>

type Value<'a> = i64 where Timestamp<U, Z>: 'a

type Owned = i64

impl<U> LogicalType for Duration<U>

where U: TimeUnitSpec + 'static,

type Typed = PrimitiveArray<<U as TimeUnitSpec>::DurationType>

type Value<'a> = i64 where Duration<U>: 'a

type Owned = i64

impl<const N: usize> LogicalType for FixedSizeBinary<N>

type Typed = FixedSizeBinaryArray

type Value<'a> = &'a [u8; N]

type Owned = [u8; N]