[−][src]Trait amadeus_parquet::ParquetData
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
Loading content...Required methods
fn parse(
schema: &Type,
predicate: Option<&Self::Predicate>,
repetition: Option<Repetition>
) -> Result<(String, Self::Schema)>
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
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.
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]
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
[src]
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 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]
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
[src]
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 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]
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
[src]
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 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]
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
[src]
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 [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]
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
[src]
_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 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]
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
[src]
_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 [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]
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
[src]
_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 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]
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
[src]
_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 [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]
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
[src]
_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 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]
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
[src]
_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 [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]
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
[src]
_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 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]
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
[src]
_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 [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]
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
[src]
_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 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]
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
[src]
_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 [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]
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
[src]
_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 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]
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
[src]
_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 [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]
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
[src]
_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 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]
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
[src]
_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 [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]
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
[src]
_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 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]
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
[src]
_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 [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]
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
[src]
_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 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]
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
[src]
_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 [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]
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
[src]
_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 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]
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
[src]
_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 [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]
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
[src]
_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 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]
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
[src]
_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 [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]
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
[src]
_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 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]
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
[src]
_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 [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]
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
[src]
_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 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]
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
[src]
_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 [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]
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
[src]
_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 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]
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
[src]
_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 [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]
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
[src]
_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 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]
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
[src]
_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 [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]
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
[src]
_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 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]
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
[src]
_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 [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]
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
[src]
_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 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]
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
[src]
_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 [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]
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
[src]
_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 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]
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
[src]
_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 [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]
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
[src]
_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 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]
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
[src]
_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 [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]
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
[src]
_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 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]
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
[src]
_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 [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]
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
[src]
_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 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]
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
[src]
_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 [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]
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
[src]
_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 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]
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
[src]
_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 [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]
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
[src]
_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 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]
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
[src]
_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 [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]
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
[src]
_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 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]
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
[src]
_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 [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]
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
[src]
_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 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]
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
[src]
_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 [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]
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
[src]
_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 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]
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
[src]
_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 [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]
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
[src]
_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 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]
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
[src]
_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 [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]
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
[src]
_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 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]
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
[src]
_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 [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]
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
[src]
_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 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]
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
[src]
_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 [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]
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
[src]
_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 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]
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
[src]
_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 [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]
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
[src]
_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 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]
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
[src]
_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 [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]
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
[src]
_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 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]
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
[src]
_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 [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]
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
[src]
_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 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]
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
[src]
_schema: &Self::Schema,
path: &mut Vec<String>,
def_level: i16,
rep_level: i16,
paths: &mut HashMap<ColumnPath, ColumnReader>,
batch_size: usize
) -> Self::Reader
impl<T> ParquetData for Box<T> where
T: ParquetData,
[src]
T: ParquetData,
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]
schema: &Type,
predicate: Option<&Self::Predicate>,
repetition: Option<Repetition>
) -> Result<(String, Self::Schema)>
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]
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 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]
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
[src]
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 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]
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
[src]
schema: &Self::Schema,
path: &mut Vec<String>,
def_level: i16,
rep_level: i16,
paths: &mut HashMap<ColumnPath, ColumnReader>,
batch_size: usize
) -> Self::Reader
impl<T: Data> ParquetData for List<T> where
T: ParquetData,
[src]
T: ParquetData,
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]
schema: &Type,
predicate: Option<&Self::Predicate>,
repetition: Option<Repetition>
) -> Result<(String, Self::Schema)>
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]
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 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]
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
[src]
schema: &Self::Schema,
path: &mut Vec<String>,
def_level: i16,
rep_level: i16,
paths: &mut HashMap<ColumnPath, ColumnReader>,
batch_size: usize
) -> Self::Reader
impl<K, V, S> ParquetData for HashMap<K, V, S> where
K: ParquetData + Hash + Eq,
V: ParquetData,
S: BuildHasher + Default + Clone + Send + 'static,
[src]
K: ParquetData + Hash + Eq,
V: ParquetData,
S: BuildHasher + Default + Clone + Send + 'static,
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]
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
[src]
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 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]
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
[src]
_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 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]
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
[src]
_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 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]
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
[src]
_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 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]
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
[src]
_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 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]
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
[src]
_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 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]
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
[src]
_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 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]
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
[src]
_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 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]
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
[src]
_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 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]
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
[src]
_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 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]
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
[src]
_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 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]
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
[src]
_schema: &Self::Schema,
path: &mut Vec<String>,
def_level: i16,
rep_level: i16,
paths: &mut HashMap<ColumnPath, ColumnReader>,
batch_size: usize
) -> Self::Reader
impl<T> ParquetData for Option<T> where
T: ParquetData,
[src]
T: ParquetData,
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]
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
[src]
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 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]
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
[src]
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 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]
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
[src]
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 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]
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
[src]
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 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]
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
[src]
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 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]
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
[src]
_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 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]
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
[src]
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 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]
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
[src]
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 ()
[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]
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
[src]
schema: &Self::Schema,
path: &mut Vec<String>,
def_level: i16,
rep_level: i16,
paths: &mut HashMap<ColumnPath, ColumnReader>,
batch_size: usize
) -> Self::Reader
impl<A> ParquetData for (A,) where
A: ParquetData,
[src]
A: ParquetData,
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]
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
[src]
schema: &Self::Schema,
path: &mut Vec<String>,
def_level: i16,
rep_level: i16,
paths: &mut HashMap<ColumnPath, ColumnReader>,
batch_size: usize
) -> Self::Reader
impl<A, B> ParquetData for (A, B) where
A: ParquetData,
B: ParquetData,
[src]
A: ParquetData,
B: ParquetData,
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]
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
[src]
schema: &Self::Schema,
path: &mut Vec<String>,
def_level: i16,
rep_level: i16,
paths: &mut HashMap<ColumnPath, ColumnReader>,
batch_size: usize
) -> Self::Reader
impl<A, B, C> ParquetData for (A, B, C) where
A: ParquetData,
B: ParquetData,
C: ParquetData,
[src]
A: ParquetData,
B: ParquetData,
C: ParquetData,
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]
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
[src]
schema: &Self::Schema,
path: &mut Vec<String>,
def_level: i16,
rep_level: i16,
paths: &mut HashMap<ColumnPath, ColumnReader>,
batch_size: usize
) -> Self::Reader
impl<A, B, C, D> ParquetData for (A, B, C, D) where
A: ParquetData,
B: ParquetData,
C: ParquetData,
D: ParquetData,
[src]
A: ParquetData,
B: ParquetData,
C: ParquetData,
D: ParquetData,
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]
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
[src]
schema: &Self::Schema,
path: &mut Vec<String>,
def_level: i16,
rep_level: i16,
paths: &mut HashMap<ColumnPath, ColumnReader>,
batch_size: usize
) -> Self::Reader
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]
A: ParquetData,
B: ParquetData,
C: ParquetData,
D: ParquetData,
E: ParquetData,
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]
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
[src]
schema: &Self::Schema,
path: &mut Vec<String>,
def_level: i16,
rep_level: i16,
paths: &mut HashMap<ColumnPath, ColumnReader>,
batch_size: usize
) -> Self::Reader
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]
A: ParquetData,
B: ParquetData,
C: ParquetData,
D: ParquetData,
E: ParquetData,
F: ParquetData,
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]
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
[src]
schema: &Self::Schema,
path: &mut Vec<String>,
def_level: i16,
rep_level: i16,
paths: &mut HashMap<ColumnPath, ColumnReader>,
batch_size: usize
) -> Self::Reader
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]
A: ParquetData,
B: ParquetData,
C: ParquetData,
D: ParquetData,
E: ParquetData,
F: ParquetData,
G: ParquetData,
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]
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
[src]
schema: &Self::Schema,
path: &mut Vec<String>,
def_level: i16,
rep_level: i16,
paths: &mut HashMap<ColumnPath, ColumnReader>,
batch_size: usize
) -> Self::Reader
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]
A: ParquetData,
B: ParquetData,
C: ParquetData,
D: ParquetData,
E: ParquetData,
F: ParquetData,
G: ParquetData,
H: ParquetData,
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]
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
[src]
schema: &Self::Schema,
path: &mut Vec<String>,
def_level: i16,
rep_level: i16,
paths: &mut HashMap<ColumnPath, ColumnReader>,
batch_size: usize
) -> Self::Reader
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]
A: ParquetData,
B: ParquetData,
C: ParquetData,
D: ParquetData,
E: ParquetData,
F: ParquetData,
G: ParquetData,
H: ParquetData,
I: ParquetData,
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]
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
[src]
schema: &Self::Schema,
path: &mut Vec<String>,
def_level: i16,
rep_level: i16,
paths: &mut HashMap<ColumnPath, ColumnReader>,
batch_size: usize
) -> Self::Reader
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]
A: ParquetData,
B: ParquetData,
C: ParquetData,
D: ParquetData,
E: ParquetData,
F: ParquetData,
G: ParquetData,
H: ParquetData,
I: ParquetData,
J: ParquetData,
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]
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
[src]
schema: &Self::Schema,
path: &mut Vec<String>,
def_level: i16,
rep_level: i16,
paths: &mut HashMap<ColumnPath, ColumnReader>,
batch_size: usize
) -> Self::Reader
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]
A: ParquetData,
B: ParquetData,
C: ParquetData,
D: ParquetData,
E: ParquetData,
F: ParquetData,
G: ParquetData,
H: ParquetData,
I: ParquetData,
J: ParquetData,
K: ParquetData,
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]
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
[src]
schema: &Self::Schema,
path: &mut Vec<String>,
def_level: i16,
rep_level: i16,
paths: &mut HashMap<ColumnPath, ColumnReader>,
batch_size: usize
) -> Self::Reader
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]
A: ParquetData,
B: ParquetData,
C: ParquetData,
D: ParquetData,
E: ParquetData,
F: ParquetData,
G: ParquetData,
H: ParquetData,
I: ParquetData,
J: ParquetData,
K: ParquetData,
L: ParquetData,
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]
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
[src]
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 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]
schema: &Type,
predicate: Option<&Self::Predicate>,
repetition: Option<Repetition>
) -> Result<(String, Self::Schema)>
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]
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 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]
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
[src]
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 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]
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
[src]
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 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]
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
[src]
schema: &Self::Schema,
path: &mut Vec<String>,
def_level: i16,
rep_level: i16,
paths: &mut HashMap<ColumnPath, ColumnReader>,
batch_size: usize
) -> Self::Reader