Struct NativeIndex

pub struct NativeIndex<T: ParquetValueType> {
    pub indexes: Vec<PageIndex<T>>,
    pub boundary_order: BoundaryOrder,
}

Strongly typed statistics for data pages in a column chunk.

This structure is a natively typed, in memory representation of the ColumnIndex structure in a parquet file footer, as described in the Parquet PageIndex documentation. The statistics stored in this structure can be used by query engines to skip decoding pages while reading parquet data.

Differences with Row Group Level Statistics

One significant difference between NativeIndex and row group level Statistics is that page level statistics may not store actual column values as min and max (e.g. they may store truncated strings to save space)

Fields

indexes: Vec<PageIndex<T>>

The actual column indexes, one item per page

boundary_order: BoundaryOrder

If the min/max elements are ordered, and if so in which direction. See source for details.

Implementations

impl<T: ParquetValueType> NativeIndex<T>

pub const PHYSICAL_TYPE: Type = T::PHYSICAL_TYPE

The physical data type of the column

pub(crate) fn try_new(index: ColumnIndex) -> Result<Self, ParquetError>

Creates a new NativeIndex

pub(crate) fn to_thrift(&self) -> ColumnIndex

Trait Implementations

impl<T: Clone + ParquetValueType> Clone for NativeIndex<T>

fn clone(&self) -> NativeIndex<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug + ParquetValueType> Debug for NativeIndex<T>

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

Formats the value using the given formatter.

impl<T: Hash + ParquetValueType> Hash for NativeIndex<T>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T: ParquetValueType> HeapSize for NativeIndex<T>

fn heap_size(&self) -> usize

Return the size of any bytes allocated on the heap by this object, including heap memory in those structures

impl<T: PartialEq + ParquetValueType> PartialEq for NativeIndex<T>

fn eq(&self, other: &NativeIndex<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Eq + ParquetValueType> Eq for NativeIndex<T>

impl<T: ParquetValueType> StructuralPartialEq for NativeIndex<T>