[−][src]Trait amadeus_parquet::ParquetData

pub trait ParquetData: Data + Sized {
    type Schema: Schema;
    type Reader: Reader<Item = Self>;
    type Predicate;
    fn parse(
        schema: &Type, 
        predicate: Option<&Self::Predicate>, 
        repetition: Option<Repetition>
    ) -> Result<(String, Self::Schema)>;
    fn reader(
        schema: &Self::Schema, 
        path: &mut Vec<String>, 
        def_level: i16, 
        rep_level: i16, 
        paths: &mut HashMap<ColumnPath, ColumnReader>, 
        batch_size: usize
    ) -> Self::Reader;
}

This trait is implemented on all types that can be read from/written to Parquet files.

It is implemented on the following types:

Rust type	Parquet Physical Type	Parquet Logical Type
`bool`	boolean	none
`u8`	int32	uint_8
`i8`	int32	int_8
`u16`	int32	uint_16
`i16`	int32	int_16
`u32`	int32	uint_32
`i32`	int32	int_32
`u64`	int64	uint_64
`i64`	int64	int_64
`f32`	float	none
`f64`	double	none
`Date`	int32	date
`Time`	int32	time_millis
`Time`	int64	time_micros
`Timestamp`	int64	timestamp_millis
`Timestamp`	int64	timestamp_micros
`Timestamp`	int96	none
`Decimal`	int32	decimal
`Decimal`	int64	decimal
`Decimal`	byte_array	decimal
`Vec<u8>`	byte_array	none
`[u8; N]`	fixed_len_byte_array	none
`Bson`	byte_array	bson
`String`	byte_array	utf8
`Json`	byte_array	json
`Enum`	byte_array	enum
`List<T>`	group	list
`Map<K,V>`	group	map
`Group`	group	none
`(T, U, …)`	group	none
`Option<T>`	–	–
`Value`	*	*

Option<T> corresponds to a field marked as "optional".

List<T> corresponds to either annotated List logical types, or unannotated fields marked as "repeated".

Value corresponds to any valid Parquet type, and is useful when the type is not known at compile time.

"byte_array" is interchangeable with "fixed_len_byte_array" for the purposes of the above correspondance.

The implementation for tuples is only for those up to length 12. The implementation for arrays is only for common array lengths. See ParquetData for more details.

`#[derive(Data)]`

The easiest way to implement ParquetData on a new type is using #[derive(Data)]:

use amadeus_parquet::internal;
use internal::record::{types::Timestamp, ParquetData};

#[derive(Data, Debug)]
struct MyRow {
    id: u64,
    time: Timestamp,
    event: String,
}

If the Rust field name and the Parquet field name differ, say if the latter is not an idiomatic or valid identifier in Rust, then an automatic rename can be made like so:

#[derive(Data, Debug)]
struct MyRow {
    #[amadeus(name = "ID")]
    id: u64,
    time: Timestamp,
    event: String,
}

Associated Types

`type Schema: Schema`

`type Reader: Reader<Item = Self>`

`type Predicate`

Loading content...

Required methods

`fn parse( schema: &Type, predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`

Parse a [Type] into Self::Schema, using repetition instead of Type::get_basic_info().repetition(). A repetition of None denotes a root schema.

`fn reader( schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`

Builds tree of [Reader]s for the specified [Schema] recursively.

Loading content...

Implementations on Foreign Types

`impl ParquetData for Bson`[src]

`type Schema = BsonSchema`

`type Reader = impl Reader<Item = Self>`

`type Predicate = Predicate`

`fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for String`[src]

`type Schema = StringSchema`

`type Reader = impl Reader<Item = Self>`

`type Predicate = Predicate`

`fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for Json`[src]

`type Schema = JsonSchema`

`type Reader = impl Reader<Item = Self>`

`type Predicate = Predicate`

`fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for Enum`[src]

`type Schema = EnumSchema`

`type Reader = impl Reader<Item = Self>`

`type Predicate = Predicate`

`fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for [u8; 0]`[src]

`type Schema = FixedByteArraySchema<Self>`

`type Reader = FixedLenByteArrayReader<Self>`

`type Predicate = Predicate`

`fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for Box<[u8; 0]>`[src]

`type Schema = FixedByteArraySchema<[u8; 0]>`

`type Reader = BoxFixedLenByteArrayReader<[u8; 0]>`

`fn parse( schema: &Type, predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for [u8; 1]`[src]

`type Schema = FixedByteArraySchema<Self>`

`type Reader = FixedLenByteArrayReader<Self>`

`type Predicate = Predicate`

`fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for Box<[u8; 1]>`[src]

`type Schema = FixedByteArraySchema<[u8; 1]>`

`type Reader = BoxFixedLenByteArrayReader<[u8; 1]>`

`fn parse( schema: &Type, predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for [u8; 2]`[src]

`type Schema = FixedByteArraySchema<Self>`

`type Reader = FixedLenByteArrayReader<Self>`

`type Predicate = Predicate`

`fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for Box<[u8; 2]>`[src]

`type Schema = FixedByteArraySchema<[u8; 2]>`

`type Reader = BoxFixedLenByteArrayReader<[u8; 2]>`

`fn parse( schema: &Type, predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for [u8; 3]`[src]

`type Schema = FixedByteArraySchema<Self>`

`type Reader = FixedLenByteArrayReader<Self>`

`type Predicate = Predicate`

`fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for Box<[u8; 3]>`[src]

`type Schema = FixedByteArraySchema<[u8; 3]>`

`type Reader = BoxFixedLenByteArrayReader<[u8; 3]>`

`fn parse( schema: &Type, predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for [u8; 4]`[src]

`type Schema = FixedByteArraySchema<Self>`

`type Reader = FixedLenByteArrayReader<Self>`

`type Predicate = Predicate`

`fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for Box<[u8; 4]>`[src]

`type Schema = FixedByteArraySchema<[u8; 4]>`

`type Reader = BoxFixedLenByteArrayReader<[u8; 4]>`

`fn parse( schema: &Type, predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for [u8; 5]`[src]

`type Schema = FixedByteArraySchema<Self>`

`type Reader = FixedLenByteArrayReader<Self>`

`type Predicate = Predicate`

`fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for Box<[u8; 5]>`[src]

`type Schema = FixedByteArraySchema<[u8; 5]>`

`type Reader = BoxFixedLenByteArrayReader<[u8; 5]>`

`fn parse( schema: &Type, predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for [u8; 6]`[src]

`type Schema = FixedByteArraySchema<Self>`

`type Reader = FixedLenByteArrayReader<Self>`

`type Predicate = Predicate`

`fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for Box<[u8; 6]>`[src]

`type Schema = FixedByteArraySchema<[u8; 6]>`

`type Reader = BoxFixedLenByteArrayReader<[u8; 6]>`

`fn parse( schema: &Type, predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for [u8; 7]`[src]

`type Schema = FixedByteArraySchema<Self>`

`type Reader = FixedLenByteArrayReader<Self>`

`type Predicate = Predicate`

`fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for Box<[u8; 7]>`[src]

`type Schema = FixedByteArraySchema<[u8; 7]>`

`type Reader = BoxFixedLenByteArrayReader<[u8; 7]>`

`fn parse( schema: &Type, predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for [u8; 8]`[src]

`type Schema = FixedByteArraySchema<Self>`

`type Reader = FixedLenByteArrayReader<Self>`

`type Predicate = Predicate`

`fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for Box<[u8; 8]>`[src]

`type Schema = FixedByteArraySchema<[u8; 8]>`

`type Reader = BoxFixedLenByteArrayReader<[u8; 8]>`

`fn parse( schema: &Type, predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for [u8; 9]`[src]

`type Schema = FixedByteArraySchema<Self>`

`type Reader = FixedLenByteArrayReader<Self>`

`type Predicate = Predicate`

`fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for Box<[u8; 9]>`[src]

`type Schema = FixedByteArraySchema<[u8; 9]>`

`type Reader = BoxFixedLenByteArrayReader<[u8; 9]>`

`fn parse( schema: &Type, predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for [u8; 10]`[src]

`type Schema = FixedByteArraySchema<Self>`

`type Reader = FixedLenByteArrayReader<Self>`

`type Predicate = Predicate`

`fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for Box<[u8; 10]>`[src]

`type Schema = FixedByteArraySchema<[u8; 10]>`

`type Reader = BoxFixedLenByteArrayReader<[u8; 10]>`

`fn parse( schema: &Type, predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for [u8; 11]`[src]

`type Schema = FixedByteArraySchema<Self>`

`type Reader = FixedLenByteArrayReader<Self>`

`type Predicate = Predicate`

`fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for Box<[u8; 11]>`[src]

`type Schema = FixedByteArraySchema<[u8; 11]>`

`type Reader = BoxFixedLenByteArrayReader<[u8; 11]>`

`fn parse( schema: &Type, predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for [u8; 12]`[src]

`type Schema = FixedByteArraySchema<Self>`

`type Reader = FixedLenByteArrayReader<Self>`

`type Predicate = Predicate`

`fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for Box<[u8; 12]>`[src]

`type Schema = FixedByteArraySchema<[u8; 12]>`

`type Reader = BoxFixedLenByteArrayReader<[u8; 12]>`

`fn parse( schema: &Type, predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for [u8; 13]`[src]

`type Schema = FixedByteArraySchema<Self>`

`type Reader = FixedLenByteArrayReader<Self>`

`type Predicate = Predicate`

`fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for Box<[u8; 13]>`[src]

`type Schema = FixedByteArraySchema<[u8; 13]>`

`type Reader = BoxFixedLenByteArrayReader<[u8; 13]>`

`fn parse( schema: &Type, predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for [u8; 14]`[src]

`type Schema = FixedByteArraySchema<Self>`

`type Reader = FixedLenByteArrayReader<Self>`

`type Predicate = Predicate`

`fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for Box<[u8; 14]>`[src]

`type Schema = FixedByteArraySchema<[u8; 14]>`

`type Reader = BoxFixedLenByteArrayReader<[u8; 14]>`

`fn parse( schema: &Type, predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for [u8; 15]`[src]

`type Schema = FixedByteArraySchema<Self>`

`type Reader = FixedLenByteArrayReader<Self>`

`type Predicate = Predicate`

`fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for Box<[u8; 15]>`[src]

`type Schema = FixedByteArraySchema<[u8; 15]>`

`type Reader = BoxFixedLenByteArrayReader<[u8; 15]>`

`fn parse( schema: &Type, predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for [u8; 16]`[src]

`type Schema = FixedByteArraySchema<Self>`

`type Reader = FixedLenByteArrayReader<Self>`

`type Predicate = Predicate`

`fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for Box<[u8; 16]>`[src]

`type Schema = FixedByteArraySchema<[u8; 16]>`

`type Reader = BoxFixedLenByteArrayReader<[u8; 16]>`

`fn parse( schema: &Type, predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for [u8; 17]`[src]

`type Schema = FixedByteArraySchema<Self>`

`type Reader = FixedLenByteArrayReader<Self>`

`type Predicate = Predicate`

`fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for Box<[u8; 17]>`[src]

`type Schema = FixedByteArraySchema<[u8; 17]>`

`type Reader = BoxFixedLenByteArrayReader<[u8; 17]>`

`fn parse( schema: &Type, predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for [u8; 18]`[src]

`type Schema = FixedByteArraySchema<Self>`

`type Reader = FixedLenByteArrayReader<Self>`

`type Predicate = Predicate`

`fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for Box<[u8; 18]>`[src]

`type Schema = FixedByteArraySchema<[u8; 18]>`

`type Reader = BoxFixedLenByteArrayReader<[u8; 18]>`

`fn parse( schema: &Type, predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for [u8; 19]`[src]

`type Schema = FixedByteArraySchema<Self>`

`type Reader = FixedLenByteArrayReader<Self>`

`type Predicate = Predicate`

`fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for Box<[u8; 19]>`[src]

`type Schema = FixedByteArraySchema<[u8; 19]>`

`type Reader = BoxFixedLenByteArrayReader<[u8; 19]>`

`fn parse( schema: &Type, predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for [u8; 20]`[src]

`type Schema = FixedByteArraySchema<Self>`

`type Reader = FixedLenByteArrayReader<Self>`

`type Predicate = Predicate`

`fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for Box<[u8; 20]>`[src]

`type Schema = FixedByteArraySchema<[u8; 20]>`

`type Reader = BoxFixedLenByteArrayReader<[u8; 20]>`

`fn parse( schema: &Type, predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for [u8; 21]`[src]

`type Schema = FixedByteArraySchema<Self>`

`type Reader = FixedLenByteArrayReader<Self>`

`type Predicate = Predicate`

`fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for Box<[u8; 21]>`[src]

`type Schema = FixedByteArraySchema<[u8; 21]>`

`type Reader = BoxFixedLenByteArrayReader<[u8; 21]>`

`fn parse( schema: &Type, predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for [u8; 22]`[src]

`type Schema = FixedByteArraySchema<Self>`

`type Reader = FixedLenByteArrayReader<Self>`

`type Predicate = Predicate`

`fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for Box<[u8; 22]>`[src]

`type Schema = FixedByteArraySchema<[u8; 22]>`

`type Reader = BoxFixedLenByteArrayReader<[u8; 22]>`

`fn parse( schema: &Type, predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for [u8; 23]`[src]

`type Schema = FixedByteArraySchema<Self>`

`type Reader = FixedLenByteArrayReader<Self>`

`type Predicate = Predicate`

`fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for Box<[u8; 23]>`[src]

`type Schema = FixedByteArraySchema<[u8; 23]>`

`type Reader = BoxFixedLenByteArrayReader<[u8; 23]>`

`fn parse( schema: &Type, predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for [u8; 24]`[src]

`type Schema = FixedByteArraySchema<Self>`

`type Reader = FixedLenByteArrayReader<Self>`

`type Predicate = Predicate`

`fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for Box<[u8; 24]>`[src]

`type Schema = FixedByteArraySchema<[u8; 24]>`

`type Reader = BoxFixedLenByteArrayReader<[u8; 24]>`

`fn parse( schema: &Type, predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for [u8; 25]`[src]

`type Schema = FixedByteArraySchema<Self>`

`type Reader = FixedLenByteArrayReader<Self>`

`type Predicate = Predicate`

`fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for Box<[u8; 25]>`[src]

`type Schema = FixedByteArraySchema<[u8; 25]>`

`type Reader = BoxFixedLenByteArrayReader<[u8; 25]>`

`fn parse( schema: &Type, predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for [u8; 26]`[src]

`type Schema = FixedByteArraySchema<Self>`

`type Reader = FixedLenByteArrayReader<Self>`

`type Predicate = Predicate`

`fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for Box<[u8; 26]>`[src]

`type Schema = FixedByteArraySchema<[u8; 26]>`

`type Reader = BoxFixedLenByteArrayReader<[u8; 26]>`

`fn parse( schema: &Type, predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for [u8; 27]`[src]

`type Schema = FixedByteArraySchema<Self>`

`type Reader = FixedLenByteArrayReader<Self>`

`type Predicate = Predicate`

`fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for Box<[u8; 27]>`[src]

`type Schema = FixedByteArraySchema<[u8; 27]>`

`type Reader = BoxFixedLenByteArrayReader<[u8; 27]>`

`fn parse( schema: &Type, predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for [u8; 28]`[src]

`type Schema = FixedByteArraySchema<Self>`

`type Reader = FixedLenByteArrayReader<Self>`

`type Predicate = Predicate`

`fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for Box<[u8; 28]>`[src]

`type Schema = FixedByteArraySchema<[u8; 28]>`

`type Reader = BoxFixedLenByteArrayReader<[u8; 28]>`

`fn parse( schema: &Type, predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for [u8; 29]`[src]

`type Schema = FixedByteArraySchema<Self>`

`type Reader = FixedLenByteArrayReader<Self>`

`type Predicate = Predicate`

`fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for Box<[u8; 29]>`[src]

`type Schema = FixedByteArraySchema<[u8; 29]>`

`type Reader = BoxFixedLenByteArrayReader<[u8; 29]>`

`fn parse( schema: &Type, predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for [u8; 30]`[src]

`type Schema = FixedByteArraySchema<Self>`

`type Reader = FixedLenByteArrayReader<Self>`

`type Predicate = Predicate`

`fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for Box<[u8; 30]>`[src]

`type Schema = FixedByteArraySchema<[u8; 30]>`

`type Reader = BoxFixedLenByteArrayReader<[u8; 30]>`

`fn parse( schema: &Type, predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for [u8; 31]`[src]

`type Schema = FixedByteArraySchema<Self>`

`type Reader = FixedLenByteArrayReader<Self>`

`type Predicate = Predicate`

`fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for Box<[u8; 31]>`[src]

`type Schema = FixedByteArraySchema<[u8; 31]>`

`type Reader = BoxFixedLenByteArrayReader<[u8; 31]>`

`fn parse( schema: &Type, predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for [u8; 32]`[src]

`type Schema = FixedByteArraySchema<Self>`

`type Reader = FixedLenByteArrayReader<Self>`

`type Predicate = Predicate`

`fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for Box<[u8; 32]>`[src]

`type Schema = FixedByteArraySchema<[u8; 32]>`

`type Reader = BoxFixedLenByteArrayReader<[u8; 32]>`

`fn parse( schema: &Type, predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl<T> ParquetData for Box<T> where T: ParquetData,` [src]

`type Schema = BoxSchema<T::Schema>`

`type Reader = BoxReader<T::Reader>`

`type Predicate = T::Predicate`

`default fn parse( schema: &Type, predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`default fn reader( schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for Decimal`[src]

`type Schema = DecimalSchema`

`type Reader = impl Reader<Item = Self>`

`type Predicate = Predicate`

`fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for Group`[src]

`type Schema = GroupSchema`

`type Reader = GroupReader`

`type Predicate = GroupPredicate`

`fn parse( schema: &Type, predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl<T: Data> ParquetData for List<T> where T: ParquetData,` [src]

`type Schema = ListSchema<T::Schema>`

`type Reader = RepeatedReader<T::Reader>`

`type Predicate = T::Predicate`

`default fn parse( schema: &Type, predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`default fn reader( schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for List<u8>`[src]

`type Schema = VecU8Schema`

`type Reader = VecU8Reader`

`fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl<K, V, S> ParquetData for HashMap<K, V, S> where K: ParquetData + Hash + Eq, V: ParquetData, S: BuildHasher + Default + Clone + Send + 'static,` [src]

`type Schema = MapSchema<K::Schema, V::Schema>`

`type Reader = impl Reader<Item = Self>`

`type Predicate = MapPredicate<K::Predicate, V::Predicate>`

`fn parse( schema: &Type, predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for bool`[src]

`type Schema = BoolSchema`

`type Reader = BoolReader`

`type Predicate = Predicate`

`fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for i8`[src]

`type Schema = I8Schema`

`type Reader = TryIntoReader<I32Reader, i8>`

`type Predicate = Predicate`

`fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for u8`[src]

`type Schema = U8Schema`

`type Reader = TryIntoReader<I32Reader, u8>`

`type Predicate = Predicate`

`fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for i16`[src]

`type Schema = I16Schema`

`type Reader = TryIntoReader<I32Reader, i16>`

`type Predicate = Predicate`

`fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for u16`[src]

`type Schema = U16Schema`

`type Reader = TryIntoReader<I32Reader, u16>`

`type Predicate = Predicate`

`fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for i32`[src]

`type Schema = I32Schema`

`type Reader = I32Reader`

`type Predicate = Predicate`

`fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for u32`[src]

`type Schema = U32Schema`

`type Reader = impl Reader<Item = Self>`

`type Predicate = Predicate`

`fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for i64`[src]

`type Schema = I64Schema`

`type Reader = I64Reader`

`type Predicate = Predicate`

`fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for u64`[src]

`type Schema = U64Schema`

`type Reader = impl Reader<Item = Self>`

`type Predicate = Predicate`

`fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for f32`[src]

`type Schema = F32Schema`

`type Reader = F32Reader`

`type Predicate = Predicate`

`fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for f64`[src]

`type Schema = F64Schema`

`type Reader = F64Reader`

`type Predicate = Predicate`

`fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl<T> ParquetData for Option<T> where T: ParquetData,` [src]

`type Schema = OptionSchema<T::Schema>`

`type Reader = OptionReader<T::Reader>`

`type Predicate = T::Predicate`

`fn parse( schema: &Type, predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for Timezone`[src]

`type Schema = StringSchema`

`type Reader = impl Reader<Item = Self>`

`type Predicate = Predicate`

`fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for DateWithoutTimezone`[src]

`type Schema = StringSchema`

`type Reader = impl Reader<Item = Self>`

`type Predicate = Predicate`

`fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for TimeWithoutTimezone`[src]

`type Schema = StringSchema`

`type Reader = impl Reader<Item = Self>`

`type Predicate = Predicate`

`fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for DateTimeWithoutTimezone`[src]

`type Schema = StringSchema`

`type Reader = impl Reader<Item = Self>`

`type Predicate = Predicate`

`fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for Date`[src]

Corresponds to the UTC Date logical type.

`type Schema = DateSchema`

`type Reader = impl Reader<Item = Self>`

`type Predicate = Predicate`

`fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for Time`[src]

Corresponds to the UTC Time logical type.

`type Schema = TimeSchema`

`type Reader = impl Reader<Item = Self>`

`type Predicate = Predicate`

`fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for DateTime`[src]

Corresponds to the UTC DateTime logical type.

`type Schema = DateTimeSchema`

`type Reader = impl Reader<Item = Self>`

`type Predicate = Predicate`

`fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for ()`[src]

`type Schema = TupleSchema<()>`

`type Reader = TupleReader<()>`

`type Predicate = ()`

`fn parse( schema: &Type, predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl<A> ParquetData for (A,) where A: ParquetData,` [src]

`type Schema = TupleSchema<((String, A::Schema),)>`

`type Reader = TupleReader<(A::Reader,)>`

`type Predicate = (Option<A::Predicate>,)`

`fn parse( schema: &Type, predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl<A, B> ParquetData for (A, B) where A: ParquetData, B: ParquetData,` [src]

`type Schema = TupleSchema<((String, A::Schema), (String, B::Schema))>`

`type Reader = TupleReader<(A::Reader, B::Reader)>`

`type Predicate = (Option<A::Predicate>, Option<B::Predicate>)`

`fn parse( schema: &Type, predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl<A, B, C> ParquetData for (A, B, C) where A: ParquetData, B: ParquetData, C: ParquetData,` [src]

`type Schema = TupleSchema<((String, A::Schema), (String, B::Schema), (String, C::Schema))>`

`type Reader = TupleReader<(A::Reader, B::Reader, C::Reader)>`

`type Predicate = (Option<A::Predicate>, Option<B::Predicate>, Option<C::Predicate>)`

`fn parse( schema: &Type, predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl<A, B, C, D> ParquetData for (A, B, C, D) where A: ParquetData, B: ParquetData, C: ParquetData, D: ParquetData,` [src]

`type Schema = TupleSchema<((String, A::Schema), (String, B::Schema), (String, C::Schema), (String, D::Schema))>`

`type Reader = TupleReader<(A::Reader, B::Reader, C::Reader, D::Reader)>`

`type Predicate = (Option<A::Predicate>, Option<B::Predicate>, Option<C::Predicate>, Option<D::Predicate>)`

`fn parse( schema: &Type, predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl<A, B, C, D, E> ParquetData for (A, B, C, D, E) where A: ParquetData, B: ParquetData, C: ParquetData, D: ParquetData, E: ParquetData,` [src]

`type Schema = TupleSchema<((String, A::Schema), (String, B::Schema), (String, C::Schema), (String, D::Schema), (String, E::Schema))>`

`type Reader = TupleReader<(A::Reader, B::Reader, C::Reader, D::Reader, E::Reader)>`

`type Predicate = (Option<A::Predicate>, Option<B::Predicate>, Option<C::Predicate>, Option<D::Predicate>, Option<E::Predicate>)`

`fn parse( schema: &Type, predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl<A, B, C, D, E, F> ParquetData for (A, B, C, D, E, F) where A: ParquetData, B: ParquetData, C: ParquetData, D: ParquetData, E: ParquetData, F: ParquetData,` [src]

`type Schema = TupleSchema<((String, A::Schema), (String, B::Schema), (String, C::Schema), (String, D::Schema), (String, E::Schema), (String, F::Schema))>`

`type Reader = TupleReader<(A::Reader, B::Reader, C::Reader, D::Reader, E::Reader, F::Reader)>`

`type Predicate = (Option<A::Predicate>, Option<B::Predicate>, Option<C::Predicate>, Option<D::Predicate>, Option<E::Predicate>, Option<F::Predicate>)`

`fn parse( schema: &Type, predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl<A, B, C, D, E, F, G> ParquetData for (A, B, C, D, E, F, G) where A: ParquetData, B: ParquetData, C: ParquetData, D: ParquetData, E: ParquetData, F: ParquetData, G: ParquetData,` [src]

`type Schema = TupleSchema<((String, A::Schema), (String, B::Schema), (String, C::Schema), (String, D::Schema), (String, E::Schema), (String, F::Schema), (String, G::Schema))>`

`type Reader = TupleReader<(A::Reader, B::Reader, C::Reader, D::Reader, E::Reader, F::Reader, G::Reader)>`

`type Predicate = (Option<A::Predicate>, Option<B::Predicate>, Option<C::Predicate>, Option<D::Predicate>, Option<E::Predicate>, Option<F::Predicate>, Option<G::Predicate>)`

`fn parse( schema: &Type, predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl<A, B, C, D, E, F, G, H> ParquetData for (A, B, C, D, E, F, G, H) where A: ParquetData, B: ParquetData, C: ParquetData, D: ParquetData, E: ParquetData, F: ParquetData, G: ParquetData, H: ParquetData,` [src]

`type Schema = TupleSchema<((String, A::Schema), (String, B::Schema), (String, C::Schema), (String, D::Schema), (String, E::Schema), (String, F::Schema), (String, G::Schema), (String, H::Schema))>`

`type Reader = TupleReader<(A::Reader, B::Reader, C::Reader, D::Reader, E::Reader, F::Reader, G::Reader, H::Reader)>`

`type Predicate = (Option<A::Predicate>, Option<B::Predicate>, Option<C::Predicate>, Option<D::Predicate>, Option<E::Predicate>, Option<F::Predicate>, Option<G::Predicate>, Option<H::Predicate>)`

`fn parse( schema: &Type, predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl<A, B, C, D, E, F, G, H, I> ParquetData for (A, B, C, D, E, F, G, H, I) where A: ParquetData, B: ParquetData, C: ParquetData, D: ParquetData, E: ParquetData, F: ParquetData, G: ParquetData, H: ParquetData, I: ParquetData,` [src]

`type Schema = TupleSchema<((String, A::Schema), (String, B::Schema), (String, C::Schema), (String, D::Schema), (String, E::Schema), (String, F::Schema), (String, G::Schema), (String, H::Schema), (String, I::Schema))>`

`type Reader = TupleReader<(A::Reader, B::Reader, C::Reader, D::Reader, E::Reader, F::Reader, G::Reader, H::Reader, I::Reader)>`

`type Predicate = (Option<A::Predicate>, Option<B::Predicate>, Option<C::Predicate>, Option<D::Predicate>, Option<E::Predicate>, Option<F::Predicate>, Option<G::Predicate>, Option<H::Predicate>, Option<I::Predicate>)`

`fn parse( schema: &Type, predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl<A, B, C, D, E, F, G, H, I, J> ParquetData for (A, B, C, D, E, F, G, H, I, J) where A: ParquetData, B: ParquetData, C: ParquetData, D: ParquetData, E: ParquetData, F: ParquetData, G: ParquetData, H: ParquetData, I: ParquetData, J: ParquetData,` [src]

`type Schema = TupleSchema<((String, A::Schema), (String, B::Schema), (String, C::Schema), (String, D::Schema), (String, E::Schema), (String, F::Schema), (String, G::Schema), (String, H::Schema), (String, I::Schema), (String, J::Schema))>`

`type Reader = TupleReader<(A::Reader, B::Reader, C::Reader, D::Reader, E::Reader, F::Reader, G::Reader, H::Reader, I::Reader, J::Reader)>`

`type Predicate = (Option<A::Predicate>, Option<B::Predicate>, Option<C::Predicate>, Option<D::Predicate>, Option<E::Predicate>, Option<F::Predicate>, Option<G::Predicate>, Option<H::Predicate>, Option<I::Predicate>, Option<J::Predicate>)`

`fn parse( schema: &Type, predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl<A, B, C, D, E, F, G, H, I, J, K> ParquetData for (A, B, C, D, E, F, G, H, I, J, K) where A: ParquetData, B: ParquetData, C: ParquetData, D: ParquetData, E: ParquetData, F: ParquetData, G: ParquetData, H: ParquetData, I: ParquetData, J: ParquetData, K: ParquetData,` [src]

`type Schema = TupleSchema<((String, A::Schema), (String, B::Schema), (String, C::Schema), (String, D::Schema), (String, E::Schema), (String, F::Schema), (String, G::Schema), (String, H::Schema), (String, I::Schema), (String, J::Schema), (String, K::Schema))>`

`type Reader = TupleReader<(A::Reader, B::Reader, C::Reader, D::Reader, E::Reader, F::Reader, G::Reader, H::Reader, I::Reader, J::Reader, K::Reader)>`

`type Predicate = (Option<A::Predicate>, Option<B::Predicate>, Option<C::Predicate>, Option<D::Predicate>, Option<E::Predicate>, Option<F::Predicate>, Option<G::Predicate>, Option<H::Predicate>, Option<I::Predicate>, Option<J::Predicate>, Option<K::Predicate>)`

`fn parse( schema: &Type, predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl<A, B, C, D, E, F, G, H, I, J, K, L> ParquetData for (A, B, C, D, E, F, G, H, I, J, K, L) where A: ParquetData, B: ParquetData, C: ParquetData, D: ParquetData, E: ParquetData, F: ParquetData, G: ParquetData, H: ParquetData, I: ParquetData, J: ParquetData, K: ParquetData, L: ParquetData,` [src]

`type Schema = TupleSchema<((String, A::Schema), (String, B::Schema), (String, C::Schema), (String, D::Schema), (String, E::Schema), (String, F::Schema), (String, G::Schema), (String, H::Schema), (String, I::Schema), (String, J::Schema), (String, K::Schema), (String, L::Schema))>`

`type Reader = TupleReader<(A::Reader, B::Reader, C::Reader, D::Reader, E::Reader, F::Reader, G::Reader, H::Reader, I::Reader, J::Reader, K::Reader, L::Reader)>`

`type Predicate = (Option<A::Predicate>, Option<B::Predicate>, Option<C::Predicate>, Option<D::Predicate>, Option<E::Predicate>, Option<F::Predicate>, Option<G::Predicate>, Option<H::Predicate>, Option<I::Predicate>, Option<J::Predicate>, Option<K::Predicate>, Option<L::Predicate>)`

`fn parse( schema: &Type, predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for Value`[src]

`type Schema = ValueSchema`

`type Reader = ValueReader`

`type Predicate = ValuePredicate`

`fn parse( schema: &Type, predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

This is reused by many of the other ParquetData implementations. It is the canonical encoding of the mapping from [Type]s to Schemas.

`fn reader( schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for Webpage<'static>`[src]

`type Schema = StringSchema`

`type Reader = impl Reader<Item = Self>`

`type Predicate = Predicate`

`fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for Url`[src]

`type Schema = StringSchema`

`type Reader = impl Reader<Item = Self>`

`type Predicate = Predicate`

`fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for IpAddr`[src]

`type Schema = StringSchema`

`type Reader = impl Reader<Item = Self>`

`type Predicate = Predicate`

`fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

Loading content...

Implementors

Loading content...

[−][src]Trait amadeus_parquet::ParquetData

#[derive(Data)]

Associated Types

type Schema: Schema

type Reader: Reader<Item = Self>

type Predicate

Required methods

fn parse( schema: &Type, predicate: Option<&Self::Predicate>, repetition: Option<Repetition>) -> Result<(String, Self::Schema)>

fn reader( schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize) -> Self::Reader

Implementations on Foreign Types

impl ParquetData for Bson[src]

type Schema = BsonSchema

type Reader = impl Reader<Item = Self>

type Predicate = Predicate

fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition>) -> Result<(String, Self::Schema)>[src]

fn reader( schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize) -> Self::Reader[src]

impl ParquetData for String[src]

type Schema = StringSchema

type Reader = impl Reader<Item = Self>

type Predicate = Predicate

fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition>) -> Result<(String, Self::Schema)>[src]

fn reader( schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize) -> Self::Reader[src]

impl ParquetData for Json[src]

type Schema = JsonSchema

type Reader = impl Reader<Item = Self>

type Predicate = Predicate

fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition>) -> Result<(String, Self::Schema)>[src]

fn reader( schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize) -> Self::Reader[src]

impl ParquetData for Enum[src]

type Schema = EnumSchema

type Reader = impl Reader<Item = Self>

type Predicate = Predicate

fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition>) -> Result<(String, Self::Schema)>[src]

fn reader( schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize) -> Self::Reader[src]

impl ParquetData for [u8; 0][src]

type Schema = FixedByteArraySchema<Self>

type Reader = FixedLenByteArrayReader<Self>

type Predicate = Predicate

fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition>) -> Result<(String, Self::Schema)>[src]

fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize) -> Self::Reader[src]

impl ParquetData for Box<[u8; 0]>[src]

type Schema = FixedByteArraySchema<[u8; 0]>

type Reader = BoxFixedLenByteArrayReader<[u8; 0]>

fn parse( schema: &Type, predicate: Option<&Self::Predicate>, repetition: Option<Repetition>) -> Result<(String, Self::Schema)>[src]

fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize) -> Self::Reader[src]

impl ParquetData for [u8; 1][src]

type Schema = FixedByteArraySchema<Self>

type Reader = FixedLenByteArrayReader<Self>

type Predicate = Predicate

fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition>) -> Result<(String, Self::Schema)>[src]

fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize) -> Self::Reader[src]

impl ParquetData for Box<[u8; 1]>[src]

type Schema = FixedByteArraySchema<[u8; 1]>

type Reader = BoxFixedLenByteArrayReader<[u8; 1]>

fn parse( schema: &Type, predicate: Option<&Self::Predicate>, repetition: Option<Repetition>) -> Result<(String, Self::Schema)>[src]

fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize) -> Self::Reader[src]

impl ParquetData for [u8; 2][src]

type Schema = FixedByteArraySchema<Self>

type Reader = FixedLenByteArrayReader<Self>

type Predicate = Predicate

fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition>) -> Result<(String, Self::Schema)>[src]

fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize) -> Self::Reader[src]

impl ParquetData for Box<[u8; 2]>[src]

type Schema = FixedByteArraySchema<[u8; 2]>

type Reader = BoxFixedLenByteArrayReader<[u8; 2]>

fn parse( schema: &Type, predicate: Option<&Self::Predicate>, repetition: Option<Repetition>) -> Result<(String, Self::Schema)>[src]

fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize) -> Self::Reader[src]

impl ParquetData for [u8; 3][src]

type Schema = FixedByteArraySchema<Self>

type Reader = FixedLenByteArrayReader<Self>

type Predicate = Predicate

fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition>) -> Result<(String, Self::Schema)>[src]

fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize) -> Self::Reader[src]

impl ParquetData for Box<[u8; 3]>[src]

type Schema = FixedByteArraySchema<[u8; 3]>

type Reader = BoxFixedLenByteArrayReader<[u8; 3]>

fn parse( schema: &Type, predicate: Option<&Self::Predicate>, repetition: Option<Repetition>) -> Result<(String, Self::Schema)>[src]

fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize) -> Self::Reader[src]

impl ParquetData for [u8; 4][src]

type Schema = FixedByteArraySchema<Self>

`#[derive(Data)]`

`type Schema: Schema`

`type Reader: Reader<Item = Self>`

`type Predicate`

`fn parse( schema: &Type, predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`

`fn reader( schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`

`impl ParquetData for Bson`[src]

`type Schema = BsonSchema`

`type Reader = impl Reader<Item = Self>`

`type Predicate = Predicate`

`fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for String`[src]

`type Schema = StringSchema`

`type Reader = impl Reader<Item = Self>`

`type Predicate = Predicate`

`fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for Json`[src]

`type Schema = JsonSchema`

`type Reader = impl Reader<Item = Self>`

`type Predicate = Predicate`

`fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for Enum`[src]

`type Schema = EnumSchema`

`type Reader = impl Reader<Item = Self>`

`type Predicate = Predicate`

`fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for [u8; 0]`[src]

`type Schema = FixedByteArraySchema<Self>`

`type Reader = FixedLenByteArrayReader<Self>`

`type Predicate = Predicate`

`fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for Box<[u8; 0]>`[src]

`type Schema = FixedByteArraySchema<[u8; 0]>`

`type Reader = BoxFixedLenByteArrayReader<[u8; 0]>`

`fn parse( schema: &Type, predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for [u8; 1]`[src]

`type Schema = FixedByteArraySchema<Self>`

`type Reader = FixedLenByteArrayReader<Self>`

`type Predicate = Predicate`

`fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for Box<[u8; 1]>`[src]

`type Schema = FixedByteArraySchema<[u8; 1]>`

`type Reader = BoxFixedLenByteArrayReader<[u8; 1]>`

`fn parse( schema: &Type, predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for [u8; 2]`[src]

`type Schema = FixedByteArraySchema<Self>`

`type Reader = FixedLenByteArrayReader<Self>`

`type Predicate = Predicate`

`fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for Box<[u8; 2]>`[src]

`type Schema = FixedByteArraySchema<[u8; 2]>`

`type Reader = BoxFixedLenByteArrayReader<[u8; 2]>`

`fn parse( schema: &Type, predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for [u8; 3]`[src]

`type Schema = FixedByteArraySchema<Self>`

`type Reader = FixedLenByteArrayReader<Self>`

`type Predicate = Predicate`

`fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for Box<[u8; 3]>`[src]

`type Schema = FixedByteArraySchema<[u8; 3]>`

`type Reader = BoxFixedLenByteArrayReader<[u8; 3]>`

`fn parse( schema: &Type, predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]

`impl ParquetData for [u8; 4]`[src]

`type Schema = FixedByteArraySchema<Self>`

`type Reader = FixedLenByteArrayReader<Self>`

`type Predicate = Predicate`

`fn parse( schema: &Type, _predicate: Option<&Self::Predicate>, repetition: Option<Repetition> ) -> Result<(String, Self::Schema)>`[src]

`fn reader( _schema: &Self::Schema, path: &mut Vec<String>, def_level: i16, rep_level: i16, paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize ) -> Self::Reader`[src]