Struct SchemaElement 

pub(crate) struct SchemaElement<'a> {
    pub(crate) type: Option<Type>,
    pub(crate) type_length: Option<i32>,
    pub(crate) repetition_type: Option<Repetition>,
    pub(crate) name: &'a str,
    pub(crate) num_children: Option<i32>,
    pub(crate) converted_type: Option<ConvertedType>,
    pub(crate) scale: Option<i32>,
    pub(crate) precision: Option<i32>,
    pub(crate) field_id: Option<i32>,
    pub(crate) logical_type: Option<LogicalType>,
}

Fields

type: Option<Type>

Data type for this field. Not set if the current element is a non-leaf node

type_length: Option<i32>

If type is FIXED_LEN_BYTE_ARRAY, this is the byte length of the values. Otherwise, if specified, this is the maximum bit length to store any of the values. (e.g. a low cardinality INT col could have this set to 3). Note that this is in the schema, and therefore fixed for the entire file.

repetition_type: Option<Repetition>

Repetition of the field. The root of the schema does not have a repetition_type. All other nodes must have one.

name: &'a str

Name of the field in the schema

num_children: Option<i32>

Nested fields. Since thrift does not support nested fields, the nesting is flattened to a single list by a depth-first traversal. The children count is used to construct the nested relationship. This field is not set when the element is a primitive type.

converted_type: Option<ConvertedType>

DEPRECATED: When the schema is the result of a conversion from another model. Used to record the original type to help with cross conversion.

This is superseded by logical_type.

scale: Option<i32>

DEPRECATED: Used when this column contains decimal data. See the DECIMAL converted type for more details.

This is superseded by using the DecimalType annotation in logical_type.

precision: Option<i32>

field_id: Option<i32>

When the original schema supports field ids, this will save the original field id in the parquet schema

logical_type: Option<LogicalType>

The logical type of this SchemaElement

LogicalType replaces ConvertedType, but ConvertedType is still required for some logical types to ensure forward-compatibility in format v1.

Trait Implementations

impl<'a> Clone for SchemaElement<'a>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for SchemaElement<'a>

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

Formats the value using the given formatter.

impl<'a> PartialEq for SchemaElement<'a>

fn eq(&self, other: &SchemaElement<'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, R: ThriftCompactInputProtocol<'a>> ReadThrift<'a, R> for SchemaElement<'a>

fn read_thrift(prot: &mut R) -> Result<Self>

Read an object of type Self from the input protocol object.

impl<'a> WriteThrift for SchemaElement<'a>

const ELEMENT_TYPE: ElementType = ElementType::Struct

The ElementType to use when a list of this object is written.

fn write_thrift<W: Write>( &self, writer: &mut ThriftCompactOutputProtocol<W>, ) -> Result<()>

Serialize this object to the given writer.

impl<'a> WriteThriftField for SchemaElement<'a>

fn write_thrift_field<W: Write>( &self, writer: &mut ThriftCompactOutputProtocol<W>, field_id: i16, last_field_id: i16, ) -> Result<i16>

Used to write struct fields (which may be primitive or IDL defined types). This will write the field marker for the given field_id, using last_field_id to compute the field delta used by the Thrift compact protocol. On success this will return field_id to be used in chaining.

impl<'a> Eq for SchemaElement<'a>

impl<'a> StructuralPartialEq for SchemaElement<'a>