Enum arrow2::datatypes::DataType [−][src]
pub enum DataType {
Show 34 variants
Null,
Boolean,
Int8,
Int16,
Int32,
Int64,
UInt8,
UInt16,
UInt32,
UInt64,
Float16,
Float32,
Float64,
Timestamp(TimeUnit, Option<String>),
Date32,
Date64,
Time32(TimeUnit),
Time64(TimeUnit),
Duration(TimeUnit),
Interval(IntervalUnit),
Binary,
FixedSizeBinary(i32),
LargeBinary,
Utf8,
LargeUtf8,
List(Box<Field>),
FixedSizeList(Box<Field>, i32),
LargeList(Box<Field>),
Struct(Vec<Field>),
Union(Vec<Field>, Option<Vec<i32>>, bool),
Map(Box<Field>, bool),
Dictionary(Box<DataType>, Box<DataType>),
Decimal(usize, usize),
Extension(String, Box<DataType>, Option<String>),
}Expand description
The set of supported logical types.
Each variant uniquely identifies a logical type, which define specific semantics to the data (e.g. how it should be represented).
Each variant has a corresponding PhysicalType, obtained via DataType::to_physical_type,
which declares the in-memory representation of data.
The DataType::Extension is special in that it augments a DataType with metadata to support custom types.
Use to_logical_type to desugar such type and return its correspoding logical type.
Variants
Null type
true and false.
A signed 8-bit integer.
A signed 16-bit integer.
A signed 32-bit integer.
A signed 64-bit integer.
An unsigned 8-bit integer.
An unsigned 16-bit integer.
An unsigned 32-bit integer.
An unsigned 64-bit integer.
A 16-bit floating point number.
A 32-bit floating point number.
A 64-bit floating point number.
A timestamp with an optional timezone.
Time is measured as a Unix epoch, counting the seconds from 00:00:00.000 on 1 January 1970, excluding leap seconds, as a 64-bit integer.
The time zone is a string indicating the name of a time zone, one of:
- As used in the Olson time zone database (the “tz database” or “tzdata”), such as “America/New_York”
- An absolute time zone offset of the form +XX:XX or -XX:XX, such as +07:30
A 32-bit date representing the elapsed time since UNIX epoch (1970-01-01) in days (32 bits).
A 64-bit date representing the elapsed time since UNIX epoch (1970-01-01) in milliseconds (64 bits). Values are evenly divisible by 86400000.
Time32(TimeUnit)A 32-bit time representing the elapsed time since midnight in the unit of TimeUnit.
Tuple Fields of Time32
0: TimeUnitTime64(TimeUnit)A 64-bit time representing the elapsed time since midnight in the unit of TimeUnit.
Tuple Fields of Time64
0: TimeUnitDuration(TimeUnit)Measure of elapsed time in either seconds, milliseconds, microseconds or nanoseconds.
Tuple Fields of Duration
0: TimeUnitInterval(IntervalUnit)A “calendar” interval which models types that don’t necessarily have a precise duration without the context of a base timestamp (e.g. days can differ in length during day light savings time transitions).
Tuple Fields of Interval
0: IntervalUnitOpaque binary data of variable length.
FixedSizeBinary(i32)Opaque binary data of fixed size. Enum parameter specifies the number of bytes per value.
Tuple Fields of FixedSizeBinary
0: i32Opaque binary data of variable length and 64-bit offsets.
A variable-length string in Unicode with UTF-8 encoding.
A variable-length string in Unicode with UFT-8 encoding and 64-bit offsets.
A list of some logical data type with variable length.
A list of some logical data type with fixed length.
A list of some logical data type with variable length and 64-bit offsets.
A nested datatype that contains a number of sub-fields.
A nested datatype that can represent slots of differing types. Third argument represents sparsness
A nested type that is represented as
List<entries: Struct<key: K, value: V>>
In this layout, the keys and values are each respectively contiguous. We do not constrain the key and value types, so the application is responsible for ensuring that the keys are hashable and unique. Whether the keys are sorted may be set in the metadata for this field.
In a field with Map type, the field has a child Struct field, which then has two children: key type and the second the value type. The names of the child fields may be respectively “entries”, “key”, and “value”, but this is not enforced.
Map
- child[0] entries: Struct
- child[0] key: K
- child[1] value: VNeither the “entries” field nor the “key” field may be nullable.
The metadata is structured so that Arrow systems without special handling for Map can make Map an alias for List. The “layout” attribute for the Map field must have the same contents as a List.
A dictionary encoded array (key_type, value_type), where
each array element is an index of key_type into an
associated dictionary of value_type.
Dictionary arrays are used to store columns of value_type
that contain many repeated values using less memory, but with
a higher CPU overhead for some operations.
This type mostly used to represent low cardinality string arrays or a limited set of primitive types as integers.
Decimal value with precision and scale precision is the number of digits in the number and scale is the number of decimal places. The number 999.99 has a precision of 5 and scale of 2.
Extension type.
Implementations
the PhysicalType of this DataType.
Returns &self for all but DataType::Extension. For DataType::Extension,
(recursively) returns the inner DataType.
Never returns the variant DataType::Extension.
Trait Implementations
Auto Trait Implementations
impl RefUnwindSafe for DataType
impl UnwindSafe for DataType
Blanket Implementations
Mutably borrows from an owned value. Read more
Compare self to key and return true if they are equal.