Struct SchemaDescriptor 

pub struct SchemaDescriptor {
    schema: TypePtr,
    leaves: Vec<ColumnDescPtr>,
    leaf_to_base: Vec<usize>,
}

Schema of a Parquet file.

Encapsulates the file’s schema (Type) and ColumnDescriptors for each primitive (leaf) column.

Example

use parquet::schema::types::{SchemaDescriptor, Type};
use parquet::basic; // note there are two `Type`s that are different
// Schema for a table with two columns: "a" (int64) and "b" (int32, stored as a date)
let descriptor = SchemaDescriptor::new(
  Arc::new(
    Type::group_type_builder("my_schema")
      .with_fields(vec![
        Arc::new(
         Type::primitive_type_builder("a", basic::Type::INT64)
          .build().unwrap()
        ),
        Arc::new(
         Type::primitive_type_builder("b", basic::Type::INT32)
          .with_converted_type(basic::ConvertedType::DATE)
          .with_logical_type(Some(basic::LogicalType::Date))
          .build().unwrap()
        ),
     ])
     .build().unwrap()
  )
);

Fields

schema: TypePtr

The top-level logical schema (the “message” type).

This must be a Type::GroupType where each field is a root column type in the schema.

leaves: Vec<ColumnDescPtr>

The descriptors for the physical type of each leaf column in this schema

Constructed from schema in DFS order.

leaf_to_base: Vec<usize>

Mapping from a leaf column’s index to the root column index that it comes from.

For instance: the leaf a.b.c.d would have a link back to a:

-- a  <-----+
-- -- b     |
-- -- -- c  |
-- -- -- -- d

Implementations

impl SchemaDescriptor

pub fn new(tp: TypePtr) -> Self

Creates new schema descriptor from Parquet schema.

pub fn column(&self, i: usize) -> ColumnDescPtr

Returns ColumnDescriptor for a field position.

pub fn columns(&self) -> &[ColumnDescPtr]

Returns slice of ColumnDescriptor.

pub fn num_columns(&self) -> usize

Returns number of leaf-level columns.

pub fn get_column_root(&self, i: usize) -> &Type

Returns column root Type for a leaf position.

pub fn get_column_root_ptr(&self, i: usize) -> TypePtr

Returns column root Type pointer for a leaf position.

pub fn get_column_root_idx(&self, leaf: usize) -> usize

Returns the index of the root column for a field position

fn column_root_of(&self, i: usize) -> &TypePtr

pub fn root_schema(&self) -> &Type

Returns schema as Type.

pub fn root_schema_ptr(&self) -> TypePtr

Returns schema as TypePtr for cheap cloning.

pub fn name(&self) -> &str

Returns schema name.

Trait Implementations

impl Clone for SchemaDescriptor

fn clone(&self) -> SchemaDescriptor

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SchemaDescriptor

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

Formats the value using the given formatter.

impl HeapSize for SchemaDescriptor

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 PartialEq for SchemaDescriptor

fn eq(&self, other: &SchemaDescriptor) -> bool

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

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

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

impl StructuralPartialEq for SchemaDescriptor