Enum Type

enum Type {
    Array(Box<Type>, Expr),
    Option(Box<Type>),
    Slice(Box<Type>),
    Vec(Box<Type>),
    TypePath(Type),
    Reference(Option<Lifetime>, Box<Type>),
}

Variants

Array(Box<Type>, Expr)

Option(Box<Type>)

Slice(Box<Type>)

Vec(Box<Type>)

TypePath(Type)

Reference(Option<Lifetime>, Box<Type>)

Implementations

impl Type

fn column_writer(&self) -> TypePath

Takes a rust type and returns the appropriate parquet-rs column writer

fn column_reader(&self) -> TypePath

Takes a rust type and returns the appropriate parquet-rs column reader

fn leaf_type_recursive(&self) -> &Type

Helper to simplify a nested field definition to its leaf type

Ex: Option<&String> => Type::TypePath(String) &Option<i32> => Type::TypePath(i32) Vec<Vec<u8>> => Type::Vec(u8)

Useful in determining the physical type of a field and the definition levels.

fn leaf_type_recursive_helper<'a>( ty: &'a Type, parent_ty: Option<&'a Type>, ) -> &'a Type

fn inner_type(&self) -> &Type

Helper method to further unwrap leaf_type() to get inner-most type information, useful for determining the physical type and normalizing the type paths.

fn last_part(&self) -> String

Helper to normalize a type path by extracting the most identifiable part

Ex: std::string::String => String Vec<u8> => Vec<u8> chrono::NaiveDateTime => NaiveDateTime

Does run the risk of mis-identifying a type if import rename is in play. Please note procedural macros always run before type resolution so this is a risk the user takes on when renaming imports.

fn physical_type(&self) -> Type

Converts rust types to parquet physical types.

Ex: [u8; 10] => FIXED_LEN_BYTE_ARRAY Vec<u8> => BYTE_ARRAY String => BYTE_ARRAY i32 => INT32

fn length(&self) -> Option<Expr>

fn logical_type(&self) -> TokenStream

fn converted_type(&self) -> Option<TokenStream>

fn repetition(&self) -> TokenStream

fn from(f: &Field) -> Self

Convert a parsed rust field AST in to a more easy to manipulate parquet_derive::Field

fn from_type(f: &Field, ty: &Type) -> Self

fn from_type_path(f: &Field, p: &TypePath) -> Self

fn from_type_reference(f: &Field, tr: &TypeReference) -> Self

fn from_type_array(f: &Field, ta: &TypeArray) -> Self

fn from_type_slice(f: &Field, ts: &TypeSlice) -> Self

Trait Implementations

impl Debug for Type

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

Formats the value using the given formatter.

impl PartialEq for Type

fn eq(&self, other: &Type) -> 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 StructuralPartialEq for Type