You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@arrow.apache.org by et...@apache.org on 2026/05/13 20:50:31 UTC
(arrow-rs) branch main updated: Remove deprecated parquet::format module and thrift dependency (#9962)
This is an automated email from the ASF dual-hosted git repository.
etseidl pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/arrow-rs.git
The following commit(s) were added to refs/heads/main by this push:
new 1ffd202aee Remove deprecated parquet::format module and thrift dependency (#9962)
1ffd202aee is described below
commit 1ffd202aeef1af2a3b0ab2b4ae604a9edbac6e09
Author: Jörn Horstmann <gi...@jhorstmann.net>
AuthorDate: Wed May 13 22:50:26 2026 +0200
Remove deprecated parquet::format module and thrift dependency (#9962)
# Which issue does this PR close?
<!--
We generally require a GitHub issue to be filed for all bug fixes and
enhancements and this helps us generate change logs for our releases.
You can link an issue to this PR using the GitHub syntax.
-->
- Closes #9953.
# Rationale for this change
Removal of the `parquet::format` was planned for the 59.0 Release
(#9110) according to code comments. There is also now a security
advisory against the Apache Thrift Rust implementation
(https://github.com/advisories/GHSA-2F9F-GQ7V-9H6M), for which there is
no fixed release yet on `crates.io`.
<!--
Why are you proposing this change? If this is already explained clearly
in the issue then this section is not needed.
Explaining clearly why changes are proposed helps reviewers understand
your changes and offer better suggestions for fixes.
-->
# What changes are included in this PR?
- Removal of the Apache Thrift dependency
- Removal of the deprecated `parquet::format` module
- Changes to the `parquet-layout` binary to remove printing of page
details, since that still depended on the deprecated code
# Are these changes tested?
Existing tests pass as the code was unused.
# Are there any user-facing changes?
Breaking api change, since `parquet::format` was a public module.
The output of the `parquet-layout` binary changes.
---
Cargo.lock | 27 -
parquet/Cargo.toml | 1 -
parquet/src/bin/parquet-layout.rs | 143 +-
parquet/src/errors.rs | 6 -
parquet/src/format.rs | 6044 -------------------------------------
parquet/src/lib.rs | 18 +-
parquet/src/thrift.rs | 86 -
7 files changed, 20 insertions(+), 6305 deletions(-)
diff --git a/Cargo.lock b/Cargo.lock
index 11979eb583..28fe6a43a5 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1841,12 +1841,6 @@ dependencies = [
"tempfile",
]
-[[package]]
-name = "integer-encoding"
-version = "3.0.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8bb03732005da905c88227371639bf1ad885cc712789c011c31c5fb3ab3ccf02"
-
[[package]]
name = "ipnet"
version = "2.12.0"
@@ -2283,15 +2277,6 @@ version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7c87def4c32ab89d880effc9e097653c8da5d6ef28e6b539d313baaacfbafcbe"
-[[package]]
-name = "ordered-float"
-version = "2.10.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "68f19d67e5a2795c94e73e0bb1cc1a7edeb2e28efd39e2e1c9b7a40c1108b11c"
-dependencies = [
- "num-traits",
-]
-
[[package]]
name = "page_size"
version = "0.6.0"
@@ -2370,7 +2355,6 @@ dependencies = [
"snap",
"sysinfo",
"tempfile",
- "thrift",
"tokio",
"twox-hash",
"zstd",
@@ -3418,17 +3402,6 @@ dependencies = [
"cfg-if",
]
-[[package]]
-name = "thrift"
-version = "0.17.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7e54bc85fc7faa8bc175c4bab5b92ba8d9a3ce893d0e9f42cc455c8ab16a9e09"
-dependencies = [
- "byteorder",
- "integer-encoding",
- "ordered-float",
-]
-
[[package]]
name = "tiny-keccak"
version = "2.0.2"
diff --git a/parquet/Cargo.toml b/parquet/Cargo.toml
index 2edeec4063..dd2c872ede 100644
--- a/parquet/Cargo.toml
+++ b/parquet/Cargo.toml
@@ -52,7 +52,6 @@ parquet-variant-compute = { workspace = true, optional = true }
object_store = { workspace = true, optional = true, features = ["tokio"] }
bytes = { version = "1.1", default-features = false, features = ["std"] }
-thrift = { version = "0.17", default-features = false }
snap = { version = "1.0", default-features = false, optional = true }
brotli = { version = "8.0", default-features = false, features = ["std"], optional = true }
# To use `flate2` you must enable either the `flate2-zlib-rs` or `flate2-rust_backened` backends
diff --git a/parquet/src/bin/parquet-layout.rs b/parquet/src/bin/parquet-layout.rs
index 735a966513..b92228e4f9 100644
--- a/parquet/src/bin/parquet-layout.rs
+++ b/parquet/src/bin/parquet-layout.rs
@@ -17,9 +17,7 @@
//! Binary that prints the physical layout of a parquet file
//!
-//! NOTE: due to this binary's use of the deprecated [`parquet::format`] module, it
-//! will no longer be maintained, and will likely be removed in the future.
-//! Alternatives to this include [`parquet-cli`] and [`parquet-viewer`].
+//! Alternatives to this binary include [`parquet-cli`] and [`parquet-viewer`].
//!
//! # Install
//!
@@ -41,19 +39,14 @@
//! [`parquet-viewer`]: https://github.com/xiangpenghao/parquet-viewer
use std::fs::File;
-use std::io::Read;
use clap::Parser;
use parquet::file::metadata::ParquetMetaDataReader;
-use serde::Serialize;
-use thrift::protocol::TCompactInputProtocol;
+use serde::{Serialize, Serializer};
-use parquet::basic::CompressionCodec;
+use parquet::basic::{CompressionCodec, Encoding};
use parquet::errors::Result;
use parquet::file::reader::ChunkReader;
-#[allow(deprecated)]
-use parquet::format::PageHeader;
-use parquet::thrift::TSerializable;
#[derive(Serialize, Debug)]
struct Index {
@@ -87,22 +80,22 @@ struct ColumnChunk {
offset_index: Option<Index>,
column_index: Option<Index>,
bloom_filter: Option<Index>,
- pages: Vec<Page>,
+ compression: DebugSerialize<CompressionCodec>,
+ encodings: Vec<DebugSerialize<Encoding>>,
}
-#[derive(Serialize, Debug)]
-struct Page {
- compression: Option<&'static str>,
- encoding: &'static str,
- page_type: &'static str,
- offset: u64,
- compressed_bytes: i32,
- uncompressed_bytes: i32,
- header_bytes: i32,
- num_values: i32,
+#[derive(Debug)]
+struct DebugSerialize<T: std::fmt::Debug>(T);
+
+impl<T: std::fmt::Debug> Serialize for DebugSerialize<T> {
+ fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ serializer.serialize_str(&format!("{:?}", &self.0))
+ }
}
-#[allow(deprecated)]
fn do_layout<C: ChunkReader>(reader: &C) -> Result<ParquetFile> {
let mut metadata_reader = ParquetMetaDataReader::new();
metadata_reader.try_parse(reader)?;
@@ -118,55 +111,8 @@ fn do_layout<C: ChunkReader>(reader: &C) -> Result<ParquetFile> {
.iter()
.zip(schema.columns())
.map(|(column, column_schema)| {
- let compression = compression(column.compression_codec());
- let mut pages = vec![];
-
- let mut start = column
- .dictionary_page_offset()
- .unwrap_or_else(|| column.data_page_offset())
- as u64;
-
- let end = start + column.compressed_size() as u64;
- while start != end {
- let (header_len, header) = read_page_header(reader, start)?;
- if let Some(dictionary) = header.dictionary_page_header {
- pages.push(Page {
- compression,
- encoding: encoding(dictionary.encoding.0),
- page_type: "dictionary",
- offset: start,
- compressed_bytes: header.compressed_page_size,
- uncompressed_bytes: header.uncompressed_page_size,
- header_bytes: header_len as _,
- num_values: dictionary.num_values,
- })
- } else if let Some(data_page) = header.data_page_header {
- pages.push(Page {
- compression,
- encoding: encoding(data_page.encoding.0),
- page_type: "data_page_v1",
- offset: start,
- compressed_bytes: header.compressed_page_size,
- uncompressed_bytes: header.uncompressed_page_size,
- header_bytes: header_len as _,
- num_values: data_page.num_values,
- })
- } else if let Some(data_page) = header.data_page_header_v2 {
- let is_compressed = data_page.is_compressed.unwrap_or(true);
-
- pages.push(Page {
- compression: compression.filter(|_| is_compressed),
- encoding: encoding(data_page.encoding.0),
- page_type: "data_page_v2",
- offset: start,
- compressed_bytes: header.compressed_page_size,
- uncompressed_bytes: header.uncompressed_page_size,
- header_bytes: header_len as _,
- num_values: data_page.num_values,
- })
- }
- start += header.compressed_page_size as u64 + header_len as u64;
- }
+ let compression = DebugSerialize(column.compression_codec());
+ let encodings = column.encodings().map(DebugSerialize).collect();
Ok(ColumnChunk {
path: column_schema.path().parts().join("."),
@@ -185,7 +131,8 @@ fn do_layout<C: ChunkReader>(reader: &C) -> Result<ParquetFile> {
offset,
length: column.bloom_filter_length(),
}),
- pages,
+ compression,
+ encodings,
})
})
.collect::<Result<Vec<_>>>()?;
@@ -203,58 +150,6 @@ fn do_layout<C: ChunkReader>(reader: &C) -> Result<ParquetFile> {
})
}
-/// Reads the page header at `offset` from `reader`, returning
-/// both the `PageHeader` and its length in bytes
-#[allow(deprecated)]
-fn read_page_header<C: ChunkReader>(reader: &C, offset: u64) -> Result<(usize, PageHeader)> {
- struct TrackedRead<R>(R, usize);
-
- impl<R: Read> Read for TrackedRead<R> {
- fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
- let v = self.0.read(buf)?;
- self.1 += v;
- Ok(v)
- }
- }
-
- let input = reader.get_read(offset)?;
- let mut tracked = TrackedRead(input, 0);
- let mut prot = TCompactInputProtocol::new(&mut tracked);
- let header = PageHeader::read_from_in_protocol(&mut prot)?;
- Ok((tracked.1, header))
-}
-
-/// Returns a string representation for a given compression
-fn compression(compression: CompressionCodec) -> Option<&'static str> {
- match compression {
- CompressionCodec::UNCOMPRESSED => None,
- CompressionCodec::SNAPPY => Some("snappy"),
- CompressionCodec::GZIP => Some("gzip"),
- CompressionCodec::LZO => Some("lzo"),
- CompressionCodec::BROTLI => Some("brotli"),
- CompressionCodec::LZ4 => Some("lz4"),
- CompressionCodec::ZSTD => Some("zstd"),
- CompressionCodec::LZ4_RAW => Some("lz4_raw"),
- }
-}
-
-/// Returns a string representation for a given encoding
-fn encoding(encoding: i32) -> &'static str {
- match encoding {
- 0 => "plain",
- 2 => "plain_dictionary",
- 3 => "rle",
- #[allow(deprecated)]
- 4 => "bit_packed",
- 5 => "delta_binary_packed",
- 6 => "delta_length_byte_array",
- 7 => "delta_byte_array",
- 8 => "rle_dictionary",
- 9 => "byte_stream_split",
- _ => "unknown",
- }
-}
-
#[derive(Debug, Parser)]
#[clap(author, version, about("Prints the physical layout of a parquet file"), long_about = None)]
struct Args {
diff --git a/parquet/src/errors.rs b/parquet/src/errors.rs
index 0533d7662c..73b4d76de5 100644
--- a/parquet/src/errors.rs
+++ b/parquet/src/errors.rs
@@ -108,12 +108,6 @@ impl From<snap::Error> for ParquetError {
}
}
-impl From<thrift::Error> for ParquetError {
- fn from(e: thrift::Error) -> ParquetError {
- ParquetError::External(Box::new(e))
- }
-}
-
impl From<cell::BorrowMutError> for ParquetError {
fn from(e: cell::BorrowMutError) -> ParquetError {
ParquetError::External(Box::new(e))
diff --git a/parquet/src/format.rs b/parquet/src/format.rs
deleted file mode 100644
index 101799d003..0000000000
--- a/parquet/src/format.rs
+++ /dev/null
@@ -1,6044 +0,0 @@
-//! See [`crate::file`] for easier to use APIs.
-// Autogenerated by Thrift Compiler (0.21.0)
-// DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
-
-#![allow(dead_code)]
-#![allow(unused_imports)]
-#![allow(unused_extern_crates)]
-#![allow(clippy::too_many_arguments, clippy::type_complexity, clippy::vec_box, clippy::wrong_self_convention)]
-// Fix unexpected `cfg` condition name: `rustfmt` https://github.com/apache/arrow-rs/issues/5725
-//#![cfg_attr(rustfmt, rustfmt_skip)]
-
-use std::cell::RefCell;
-use std::collections::{BTreeMap, BTreeSet};
-use std::convert::{From, TryFrom};
-use std::default::Default;
-use std::error::Error;
-use std::fmt;
-use std::fmt::{Display, Formatter};
-use std::rc::Rc;
-
-use thrift::OrderedFloat;
-use thrift::{ApplicationError, ApplicationErrorKind, ProtocolError, ProtocolErrorKind, TThriftClient};
-use thrift::protocol::{TFieldIdentifier, TListIdentifier, TMapIdentifier, TMessageIdentifier, TMessageType, TInputProtocol, TOutputProtocol, TSerializable, TSetIdentifier, TStructIdentifier, TType};
-use thrift::protocol::field_id;
-use thrift::protocol::verify_expected_message_type;
-use thrift::protocol::verify_expected_sequence_number;
-use thrift::protocol::verify_expected_service_call;
-use thrift::protocol::verify_required_field_exists;
-
-/// Types supported by Parquet. These types are intended to be used in combination
-/// with the encodings to control the on disk storage format.
-/// For example INT16 is not included as a type since a good encoding of INT32
-/// would handle this.
-#[derive(Copy, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct Type(pub i32);
-
-impl Type {
- pub const BOOLEAN: Type = Type(0);
- pub const INT32: Type = Type(1);
- pub const INT64: Type = Type(2);
- pub const INT96: Type = Type(3);
- pub const FLOAT: Type = Type(4);
- pub const DOUBLE: Type = Type(5);
- pub const BYTE_ARRAY: Type = Type(6);
- pub const FIXED_LEN_BYTE_ARRAY: Type = Type(7);
- pub const ENUM_VALUES: &'static [Self] = &[
- Self::BOOLEAN,
- Self::INT32,
- Self::INT64,
- Self::INT96,
- Self::FLOAT,
- Self::DOUBLE,
- Self::BYTE_ARRAY,
- Self::FIXED_LEN_BYTE_ARRAY,
- ];
-}
-
-impl crate::thrift::TSerializable for Type {
- #[allow(clippy::trivially_copy_pass_by_ref)]
- fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
- o_prot.write_i32(self.0)
- }
- fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<Type> {
- let enum_value = i_prot.read_i32()?;
- Ok(Type::from(enum_value))
- }
-}
-
-impl From<i32> for Type {
- fn from(i: i32) -> Self {
- match i {
- 0 => Type::BOOLEAN,
- 1 => Type::INT32,
- 2 => Type::INT64,
- 3 => Type::INT96,
- 4 => Type::FLOAT,
- 5 => Type::DOUBLE,
- 6 => Type::BYTE_ARRAY,
- 7 => Type::FIXED_LEN_BYTE_ARRAY,
- _ => Type(i)
- }
- }
-}
-
-impl From<&i32> for Type {
- fn from(i: &i32) -> Self {
- Type::from(*i)
- }
-}
-
-impl From<Type> for i32 {
- fn from(e: Type) -> i32 {
- e.0
- }
-}
-
-impl From<&Type> for i32 {
- fn from(e: &Type) -> i32 {
- e.0
- }
-}
-
-/// DEPRECATED: Common types used by frameworks(e.g. hive, pig) using parquet.
-/// ConvertedType is superseded by LogicalType. This enum should not be extended.
-///
-/// See LogicalTypes.md for conversion between ConvertedType and LogicalType.
-#[derive(Copy, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct ConvertedType(pub i32);
-
-impl ConvertedType {
- /// a BYTE_ARRAY actually contains UTF8 encoded chars
- pub const UTF8: ConvertedType = ConvertedType(0);
- /// a map is converted as an optional field containing a repeated key/value pair
- pub const MAP: ConvertedType = ConvertedType(1);
- /// a key/value pair is converted into a group of two fields
- pub const MAP_KEY_VALUE: ConvertedType = ConvertedType(2);
- /// a list is converted into an optional field containing a repeated field for its
- /// values
- pub const LIST: ConvertedType = ConvertedType(3);
- /// an enum is converted into a BYTE_ARRAY field
- pub const ENUM: ConvertedType = ConvertedType(4);
- /// A decimal value.
- ///
- /// This may be used to annotate BYTE_ARRAY or FIXED_LEN_BYTE_ARRAY primitive
- /// types. The underlying byte array stores the unscaled value encoded as two's
- /// complement using big-endian byte order (the most significant byte is the
- /// zeroth element). The value of the decimal is the value * 10^{-scale}.
- ///
- /// This must be accompanied by a (maximum) precision and a scale in the
- /// SchemaElement. The precision specifies the number of digits in the decimal
- /// and the scale stores the location of the decimal point. For example 1.23
- /// would have precision 3 (3 total digits) and scale 2 (the decimal point is
- /// 2 digits over).
- pub const DECIMAL: ConvertedType = ConvertedType(5);
- /// A Date
- ///
- /// Stored as days since Unix epoch, encoded as the INT32 physical type.
- ///
- pub const DATE: ConvertedType = ConvertedType(6);
- /// A time
- ///
- /// The total number of milliseconds since midnight. The value is stored
- /// as an INT32 physical type.
- pub const TIME_MILLIS: ConvertedType = ConvertedType(7);
- /// A time.
- ///
- /// The total number of microseconds since midnight. The value is stored as
- /// an INT64 physical type.
- pub const TIME_MICROS: ConvertedType = ConvertedType(8);
- /// A date/time combination
- ///
- /// Date and time recorded as milliseconds since the Unix epoch. Recorded as
- /// a physical type of INT64.
- pub const TIMESTAMP_MILLIS: ConvertedType = ConvertedType(9);
- /// A date/time combination
- ///
- /// Date and time recorded as microseconds since the Unix epoch. The value is
- /// stored as an INT64 physical type.
- pub const TIMESTAMP_MICROS: ConvertedType = ConvertedType(10);
- /// An unsigned integer value.
- ///
- /// The number describes the maximum number of meaningful data bits in
- /// the stored value. 8, 16 and 32 bit values are stored using the
- /// INT32 physical type. 64 bit values are stored using the INT64
- /// physical type.
- ///
- pub const UINT_8: ConvertedType = ConvertedType(11);
- pub const UINT_16: ConvertedType = ConvertedType(12);
- pub const UINT_32: ConvertedType = ConvertedType(13);
- pub const UINT_64: ConvertedType = ConvertedType(14);
- /// A signed integer value.
- ///
- /// The number describes the maximum number of meaningful data bits in
- /// the stored value. 8, 16 and 32 bit values are stored using the
- /// INT32 physical type. 64 bit values are stored using the INT64
- /// physical type.
- ///
- pub const INT_8: ConvertedType = ConvertedType(15);
- pub const INT_16: ConvertedType = ConvertedType(16);
- pub const INT_32: ConvertedType = ConvertedType(17);
- pub const INT_64: ConvertedType = ConvertedType(18);
- /// An embedded JSON document
- ///
- /// A JSON document embedded within a single UTF8 column.
- pub const JSON: ConvertedType = ConvertedType(19);
- /// An embedded BSON document
- ///
- /// A BSON document embedded within a single BYTE_ARRAY column.
- pub const BSON: ConvertedType = ConvertedType(20);
- /// An interval of time
- ///
- /// This type annotates data stored as a FIXED_LEN_BYTE_ARRAY of length 12
- /// This data is composed of three separate little endian unsigned
- /// integers. Each stores a component of a duration of time. The first
- /// integer identifies the number of months associated with the duration,
- /// the second identifies the number of days associated with the duration
- /// and the third identifies the number of milliseconds associated with
- /// the provided duration. This duration of time is independent of any
- /// particular timezone or date.
- pub const INTERVAL: ConvertedType = ConvertedType(21);
- pub const ENUM_VALUES: &'static [Self] = &[
- Self::UTF8,
- Self::MAP,
- Self::MAP_KEY_VALUE,
- Self::LIST,
- Self::ENUM,
- Self::DECIMAL,
- Self::DATE,
- Self::TIME_MILLIS,
- Self::TIME_MICROS,
- Self::TIMESTAMP_MILLIS,
- Self::TIMESTAMP_MICROS,
- Self::UINT_8,
- Self::UINT_16,
- Self::UINT_32,
- Self::UINT_64,
- Self::INT_8,
- Self::INT_16,
- Self::INT_32,
- Self::INT_64,
- Self::JSON,
- Self::BSON,
- Self::INTERVAL,
- ];
-}
-
-impl crate::thrift::TSerializable for ConvertedType {
- #[allow(clippy::trivially_copy_pass_by_ref)]
- fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
- o_prot.write_i32(self.0)
- }
- fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<ConvertedType> {
- let enum_value = i_prot.read_i32()?;
- Ok(ConvertedType::from(enum_value))
- }
-}
-
-impl From<i32> for ConvertedType {
- fn from(i: i32) -> Self {
- match i {
- 0 => ConvertedType::UTF8,
- 1 => ConvertedType::MAP,
- 2 => ConvertedType::MAP_KEY_VALUE,
- 3 => ConvertedType::LIST,
- 4 => ConvertedType::ENUM,
- 5 => ConvertedType::DECIMAL,
- 6 => ConvertedType::DATE,
- 7 => ConvertedType::TIME_MILLIS,
- 8 => ConvertedType::TIME_MICROS,
- 9 => ConvertedType::TIMESTAMP_MILLIS,
- 10 => ConvertedType::TIMESTAMP_MICROS,
- 11 => ConvertedType::UINT_8,
- 12 => ConvertedType::UINT_16,
- 13 => ConvertedType::UINT_32,
- 14 => ConvertedType::UINT_64,
- 15 => ConvertedType::INT_8,
- 16 => ConvertedType::INT_16,
- 17 => ConvertedType::INT_32,
- 18 => ConvertedType::INT_64,
- 19 => ConvertedType::JSON,
- 20 => ConvertedType::BSON,
- 21 => ConvertedType::INTERVAL,
- _ => ConvertedType(i)
- }
- }
-}
-
-impl From<&i32> for ConvertedType {
- fn from(i: &i32) -> Self {
- ConvertedType::from(*i)
- }
-}
-
-impl From<ConvertedType> for i32 {
- fn from(e: ConvertedType) -> i32 {
- e.0
- }
-}
-
-impl From<&ConvertedType> for i32 {
- fn from(e: &ConvertedType) -> i32 {
- e.0
- }
-}
-
-/// Representation of Schemas
-#[derive(Copy, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct FieldRepetitionType(pub i32);
-
-impl FieldRepetitionType {
- /// This field is required (can not be null) and each row has exactly 1 value.
- pub const REQUIRED: FieldRepetitionType = FieldRepetitionType(0);
- /// The field is optional (can be null) and each row has 0 or 1 values.
- pub const OPTIONAL: FieldRepetitionType = FieldRepetitionType(1);
- /// The field is repeated and can contain 0 or more values
- pub const REPEATED: FieldRepetitionType = FieldRepetitionType(2);
- pub const ENUM_VALUES: &'static [Self] = &[
- Self::REQUIRED,
- Self::OPTIONAL,
- Self::REPEATED,
- ];
-}
-
-impl crate::thrift::TSerializable for FieldRepetitionType {
- #[allow(clippy::trivially_copy_pass_by_ref)]
- fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
- o_prot.write_i32(self.0)
- }
- fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<FieldRepetitionType> {
- let enum_value = i_prot.read_i32()?;
- Ok(FieldRepetitionType::from(enum_value))
- }
-}
-
-impl From<i32> for FieldRepetitionType {
- fn from(i: i32) -> Self {
- match i {
- 0 => FieldRepetitionType::REQUIRED,
- 1 => FieldRepetitionType::OPTIONAL,
- 2 => FieldRepetitionType::REPEATED,
- _ => FieldRepetitionType(i)
- }
- }
-}
-
-impl From<&i32> for FieldRepetitionType {
- fn from(i: &i32) -> Self {
- FieldRepetitionType::from(*i)
- }
-}
-
-impl From<FieldRepetitionType> for i32 {
- fn from(e: FieldRepetitionType) -> i32 {
- e.0
- }
-}
-
-impl From<&FieldRepetitionType> for i32 {
- fn from(e: &FieldRepetitionType) -> i32 {
- e.0
- }
-}
-
-/// Edge interpolation algorithm for Geography logical type
-#[derive(Copy, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct EdgeInterpolationAlgorithm(pub i32);
-
-impl EdgeInterpolationAlgorithm {
- pub const SPHERICAL: EdgeInterpolationAlgorithm = EdgeInterpolationAlgorithm(0);
- pub const VINCENTY: EdgeInterpolationAlgorithm = EdgeInterpolationAlgorithm(1);
- pub const THOMAS: EdgeInterpolationAlgorithm = EdgeInterpolationAlgorithm(2);
- pub const ANDOYER: EdgeInterpolationAlgorithm = EdgeInterpolationAlgorithm(3);
- pub const KARNEY: EdgeInterpolationAlgorithm = EdgeInterpolationAlgorithm(4);
- pub const ENUM_VALUES: &'static [Self] = &[
- Self::SPHERICAL,
- Self::VINCENTY,
- Self::THOMAS,
- Self::ANDOYER,
- Self::KARNEY,
- ];
-}
-
-impl crate::thrift::TSerializable for EdgeInterpolationAlgorithm {
- #[allow(clippy::trivially_copy_pass_by_ref)]
- fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
- o_prot.write_i32(self.0)
- }
- fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<EdgeInterpolationAlgorithm> {
- let enum_value = i_prot.read_i32()?;
- Ok(EdgeInterpolationAlgorithm::from(enum_value))
- }
-}
-
-impl From<i32> for EdgeInterpolationAlgorithm {
- fn from(i: i32) -> Self {
- match i {
- 0 => EdgeInterpolationAlgorithm::SPHERICAL,
- 1 => EdgeInterpolationAlgorithm::VINCENTY,
- 2 => EdgeInterpolationAlgorithm::THOMAS,
- 3 => EdgeInterpolationAlgorithm::ANDOYER,
- 4 => EdgeInterpolationAlgorithm::KARNEY,
- _ => EdgeInterpolationAlgorithm(i)
- }
- }
-}
-
-impl From<&i32> for EdgeInterpolationAlgorithm {
- fn from(i: &i32) -> Self {
- EdgeInterpolationAlgorithm::from(*i)
- }
-}
-
-impl From<EdgeInterpolationAlgorithm> for i32 {
- fn from(e: EdgeInterpolationAlgorithm) -> i32 {
- e.0
- }
-}
-
-impl From<&EdgeInterpolationAlgorithm> for i32 {
- fn from(e: &EdgeInterpolationAlgorithm) -> i32 {
- e.0
- }
-}
-
-/// Encodings supported by Parquet. Not all encodings are valid for all types. These
-/// enums are also used to specify the encoding of definition and repetition levels.
-/// See the accompanying doc for the details of the more complicated encodings.
-#[derive(Copy, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct Encoding(pub i32);
-
-impl Encoding {
- /// Default encoding.
- /// BOOLEAN - 1 bit per value. 0 is false; 1 is true.
- /// INT32 - 4 bytes per value. Stored as little-endian.
- /// INT64 - 8 bytes per value. Stored as little-endian.
- /// FLOAT - 4 bytes per value. IEEE. Stored as little-endian.
- /// DOUBLE - 8 bytes per value. IEEE. Stored as little-endian.
- /// BYTE_ARRAY - 4 byte length stored as little endian, followed by bytes.
- /// FIXED_LEN_BYTE_ARRAY - Just the bytes.
- pub const PLAIN: Encoding = Encoding(0);
- /// Deprecated: Dictionary encoding. The values in the dictionary are encoded in the
- /// plain type.
- /// in a data page use RLE_DICTIONARY instead.
- /// in a Dictionary page use PLAIN instead
- pub const PLAIN_DICTIONARY: Encoding = Encoding(2);
- /// Group packed run length encoding. Usable for definition/repetition levels
- /// encoding and Booleans (on one bit: 0 is false; 1 is true.)
- pub const RLE: Encoding = Encoding(3);
- /// Bit packed encoding. This can only be used if the data has a known max
- /// width. Usable for definition/repetition levels encoding.
- pub const BIT_PACKED: Encoding = Encoding(4);
- /// Delta encoding for integers. This can be used for int columns and works best
- /// on sorted data
- pub const DELTA_BINARY_PACKED: Encoding = Encoding(5);
- /// Encoding for byte arrays to separate the length values and the data. The lengths
- /// are encoded using DELTA_BINARY_PACKED
- pub const DELTA_LENGTH_BYTE_ARRAY: Encoding = Encoding(6);
- /// Incremental-encoded byte array. Prefix lengths are encoded using DELTA_BINARY_PACKED.
- /// Suffixes are stored as delta length byte arrays.
- pub const DELTA_BYTE_ARRAY: Encoding = Encoding(7);
- /// Dictionary encoding: the ids are encoded using the RLE encoding
- pub const RLE_DICTIONARY: Encoding = Encoding(8);
- /// Encoding for fixed-width data (FLOAT, DOUBLE, INT32, INT64, FIXED_LEN_BYTE_ARRAY).
- /// K byte-streams are created where K is the size in bytes of the data type.
- /// The individual bytes of a value are scattered to the corresponding stream and
- /// the streams are concatenated.
- /// This itself does not reduce the size of the data but can lead to better compression
- /// afterwards.
- ///
- /// Added in 2.8 for FLOAT and DOUBLE.
- /// Support for INT32, INT64 and FIXED_LEN_BYTE_ARRAY added in 2.11.
- pub const BYTE_STREAM_SPLIT: Encoding = Encoding(9);
- pub const ENUM_VALUES: &'static [Self] = &[
- Self::PLAIN,
- Self::PLAIN_DICTIONARY,
- Self::RLE,
- Self::BIT_PACKED,
- Self::DELTA_BINARY_PACKED,
- Self::DELTA_LENGTH_BYTE_ARRAY,
- Self::DELTA_BYTE_ARRAY,
- Self::RLE_DICTIONARY,
- Self::BYTE_STREAM_SPLIT,
- ];
-}
-
-impl crate::thrift::TSerializable for Encoding {
- #[allow(clippy::trivially_copy_pass_by_ref)]
- fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
- o_prot.write_i32(self.0)
- }
- fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<Encoding> {
- let enum_value = i_prot.read_i32()?;
- Ok(Encoding::from(enum_value))
- }
-}
-
-impl From<i32> for Encoding {
- fn from(i: i32) -> Self {
- match i {
- 0 => Encoding::PLAIN,
- 2 => Encoding::PLAIN_DICTIONARY,
- 3 => Encoding::RLE,
- 4 => Encoding::BIT_PACKED,
- 5 => Encoding::DELTA_BINARY_PACKED,
- 6 => Encoding::DELTA_LENGTH_BYTE_ARRAY,
- 7 => Encoding::DELTA_BYTE_ARRAY,
- 8 => Encoding::RLE_DICTIONARY,
- 9 => Encoding::BYTE_STREAM_SPLIT,
- _ => Encoding(i)
- }
- }
-}
-
-impl From<&i32> for Encoding {
- fn from(i: &i32) -> Self {
- Encoding::from(*i)
- }
-}
-
-impl From<Encoding> for i32 {
- fn from(e: Encoding) -> i32 {
- e.0
- }
-}
-
-impl From<&Encoding> for i32 {
- fn from(e: &Encoding) -> i32 {
- e.0
- }
-}
-
-/// Supported compression algorithms.
-///
-/// Codecs added in format version X.Y can be read by readers based on X.Y and later.
-/// Codec support may vary between readers based on the format version and
-/// libraries available at runtime.
-///
-/// See Compression.md for a detailed specification of these algorithms.
-#[derive(Copy, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct CompressionCodec(pub i32);
-
-impl CompressionCodec {
- pub const UNCOMPRESSED: CompressionCodec = CompressionCodec(0);
- pub const SNAPPY: CompressionCodec = CompressionCodec(1);
- pub const GZIP: CompressionCodec = CompressionCodec(2);
- pub const LZO: CompressionCodec = CompressionCodec(3);
- pub const BROTLI: CompressionCodec = CompressionCodec(4);
- pub const LZ4: CompressionCodec = CompressionCodec(5);
- pub const ZSTD: CompressionCodec = CompressionCodec(6);
- pub const LZ4_RAW: CompressionCodec = CompressionCodec(7);
- pub const ENUM_VALUES: &'static [Self] = &[
- Self::UNCOMPRESSED,
- Self::SNAPPY,
- Self::GZIP,
- Self::LZO,
- Self::BROTLI,
- Self::LZ4,
- Self::ZSTD,
- Self::LZ4_RAW,
- ];
-}
-
-impl crate::thrift::TSerializable for CompressionCodec {
- #[allow(clippy::trivially_copy_pass_by_ref)]
- fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
- o_prot.write_i32(self.0)
- }
- fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<CompressionCodec> {
- let enum_value = i_prot.read_i32()?;
- Ok(CompressionCodec::from(enum_value))
- }
-}
-
-impl From<i32> for CompressionCodec {
- fn from(i: i32) -> Self {
- match i {
- 0 => CompressionCodec::UNCOMPRESSED,
- 1 => CompressionCodec::SNAPPY,
- 2 => CompressionCodec::GZIP,
- 3 => CompressionCodec::LZO,
- 4 => CompressionCodec::BROTLI,
- 5 => CompressionCodec::LZ4,
- 6 => CompressionCodec::ZSTD,
- 7 => CompressionCodec::LZ4_RAW,
- _ => CompressionCodec(i)
- }
- }
-}
-
-impl From<&i32> for CompressionCodec {
- fn from(i: &i32) -> Self {
- CompressionCodec::from(*i)
- }
-}
-
-impl From<CompressionCodec> for i32 {
- fn from(e: CompressionCodec) -> i32 {
- e.0
- }
-}
-
-impl From<&CompressionCodec> for i32 {
- fn from(e: &CompressionCodec) -> i32 {
- e.0
- }
-}
-
-#[derive(Copy, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct PageType(pub i32);
-
-impl PageType {
- pub const DATA_PAGE: PageType = PageType(0);
- pub const INDEX_PAGE: PageType = PageType(1);
- pub const DICTIONARY_PAGE: PageType = PageType(2);
- pub const DATA_PAGE_V2: PageType = PageType(3);
- pub const ENUM_VALUES: &'static [Self] = &[
- Self::DATA_PAGE,
- Self::INDEX_PAGE,
- Self::DICTIONARY_PAGE,
- Self::DATA_PAGE_V2,
- ];
-}
-
-impl crate::thrift::TSerializable for PageType {
- #[allow(clippy::trivially_copy_pass_by_ref)]
- fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
- o_prot.write_i32(self.0)
- }
- fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<PageType> {
- let enum_value = i_prot.read_i32()?;
- Ok(PageType::from(enum_value))
- }
-}
-
-impl From<i32> for PageType {
- fn from(i: i32) -> Self {
- match i {
- 0 => PageType::DATA_PAGE,
- 1 => PageType::INDEX_PAGE,
- 2 => PageType::DICTIONARY_PAGE,
- 3 => PageType::DATA_PAGE_V2,
- _ => PageType(i)
- }
- }
-}
-
-impl From<&i32> for PageType {
- fn from(i: &i32) -> Self {
- PageType::from(*i)
- }
-}
-
-impl From<PageType> for i32 {
- fn from(e: PageType) -> i32 {
- e.0
- }
-}
-
-impl From<&PageType> for i32 {
- fn from(e: &PageType) -> i32 {
- e.0
- }
-}
-
-/// Enum to annotate whether lists of min/max elements inside ColumnIndex
-/// are ordered and if so, in which direction.
-#[derive(Copy, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct BoundaryOrder(pub i32);
-
-impl BoundaryOrder {
- pub const UNORDERED: BoundaryOrder = BoundaryOrder(0);
- pub const ASCENDING: BoundaryOrder = BoundaryOrder(1);
- pub const DESCENDING: BoundaryOrder = BoundaryOrder(2);
- pub const ENUM_VALUES: &'static [Self] = &[
- Self::UNORDERED,
- Self::ASCENDING,
- Self::DESCENDING,
- ];
-}
-
-impl crate::thrift::TSerializable for BoundaryOrder {
- #[allow(clippy::trivially_copy_pass_by_ref)]
- fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
- o_prot.write_i32(self.0)
- }
- fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<BoundaryOrder> {
- let enum_value = i_prot.read_i32()?;
- Ok(BoundaryOrder::from(enum_value))
- }
-}
-
-impl From<i32> for BoundaryOrder {
- fn from(i: i32) -> Self {
- match i {
- 0 => BoundaryOrder::UNORDERED,
- 1 => BoundaryOrder::ASCENDING,
- 2 => BoundaryOrder::DESCENDING,
- _ => BoundaryOrder(i)
- }
- }
-}
-
-impl From<&i32> for BoundaryOrder {
- fn from(i: &i32) -> Self {
- BoundaryOrder::from(*i)
- }
-}
-
-impl From<BoundaryOrder> for i32 {
- fn from(e: BoundaryOrder) -> i32 {
- e.0
- }
-}
-
-impl From<&BoundaryOrder> for i32 {
- fn from(e: &BoundaryOrder) -> i32 {
- e.0
- }
-}
-
-//
-// SizeStatistics
-//
-
-/// A structure for capturing metadata for estimating the unencoded,
-/// uncompressed size of data written. This is useful for readers to estimate
-/// how much memory is needed to reconstruct data in their memory model and for
-/// fine grained filter pushdown on nested structures (the histograms contained
-/// in this structure can help determine the number of nulls at a particular
-/// nesting level and maximum length of lists).
-#[derive(Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct SizeStatistics {
- /// The number of physical bytes stored for BYTE_ARRAY data values assuming
- /// no encoding. This is exclusive of the bytes needed to store the length of
- /// each byte array. In other words, this field is equivalent to the `(size
- /// of PLAIN-ENCODING the byte array values) - (4 bytes * number of values
- /// written)`. To determine unencoded sizes of other types readers can use
- /// schema information multiplied by the number of non-null and null values.
- /// The number of null/non-null values can be inferred from the histograms
- /// below.
- ///
- /// For example, if a column chunk is dictionary-encoded with dictionary
- /// ["a", "bc", "cde"], and a data page contains the indices [0, 0, 1, 2],
- /// then this value for that data page should be 7 (1 + 1 + 2 + 3).
- ///
- /// This field should only be set for types that use BYTE_ARRAY as their
- /// physical type.
- pub unencoded_byte_array_data_bytes: Option<i64>,
- /// When present, there is expected to be one element corresponding to each
- /// repetition (i.e. size=max repetition_level+1) where each element
- /// represents the number of times the repetition level was observed in the
- /// data.
- ///
- /// This field may be omitted if max_repetition_level is 0 without loss
- /// of information.
- ///
- pub repetition_level_histogram: Option<Vec<i64>>,
- /// Same as repetition_level_histogram except for definition levels.
- ///
- /// This field may be omitted if max_definition_level is 0 or 1 without
- /// loss of information.
- ///
- pub definition_level_histogram: Option<Vec<i64>>,
-}
-
-impl SizeStatistics {
- pub fn new<F1, F2, F3>(unencoded_byte_array_data_bytes: F1, repetition_level_histogram: F2, definition_level_histogram: F3) -> SizeStatistics where F1: Into<Option<i64>>, F2: Into<Option<Vec<i64>>>, F3: Into<Option<Vec<i64>>> {
- SizeStatistics {
- unencoded_byte_array_data_bytes: unencoded_byte_array_data_bytes.into(),
- repetition_level_histogram: repetition_level_histogram.into(),
- definition_level_histogram: definition_level_histogram.into(),
- }
- }
-}
-
-impl crate::thrift::TSerializable for SizeStatistics {
- fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<SizeStatistics> {
- i_prot.read_struct_begin()?;
- let mut f_1: Option<i64> = None;
- let mut f_2: Option<Vec<i64>> = None;
- let mut f_3: Option<Vec<i64>> = None;
- loop {
- let field_ident = i_prot.read_field_begin()?;
- if field_ident.field_type == TType::Stop {
- break;
- }
- let field_id = field_id(&field_ident)?;
- match field_id {
- 1 => {
- let val = i_prot.read_i64()?;
- f_1 = Some(val);
- },
- 2 => {
- let list_ident = i_prot.read_list_begin()?;
- let mut val: Vec<i64> = Vec::with_capacity(list_ident.size as usize);
- for _ in 0..list_ident.size {
- let list_elem_0 = i_prot.read_i64()?;
- val.push(list_elem_0);
- }
- i_prot.read_list_end()?;
- f_2 = Some(val);
- },
- 3 => {
- let list_ident = i_prot.read_list_begin()?;
- let mut val: Vec<i64> = Vec::with_capacity(list_ident.size as usize);
- for _ in 0..list_ident.size {
- let list_elem_1 = i_prot.read_i64()?;
- val.push(list_elem_1);
- }
- i_prot.read_list_end()?;
- f_3 = Some(val);
- },
- _ => {
- i_prot.skip(field_ident.field_type)?;
- },
- };
- i_prot.read_field_end()?;
- }
- i_prot.read_struct_end()?;
- let ret = SizeStatistics {
- unencoded_byte_array_data_bytes: f_1,
- repetition_level_histogram: f_2,
- definition_level_histogram: f_3,
- };
- Ok(ret)
- }
- fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
- let struct_ident = TStructIdentifier::new("SizeStatistics");
- o_prot.write_struct_begin(&struct_ident)?;
- if let Some(fld_var) = self.unencoded_byte_array_data_bytes {
- o_prot.write_field_begin(&TFieldIdentifier::new("unencoded_byte_array_data_bytes", TType::I64, 1))?;
- o_prot.write_i64(fld_var)?;
- o_prot.write_field_end()?
- }
- if let Some(ref fld_var) = self.repetition_level_histogram {
- o_prot.write_field_begin(&TFieldIdentifier::new("repetition_level_histogram", TType::List, 2))?;
- o_prot.write_list_begin(&TListIdentifier::new(TType::I64, fld_var.len() as i32))?;
- for e in fld_var {
- o_prot.write_i64(*e)?;
- }
- o_prot.write_list_end()?;
- o_prot.write_field_end()?
- }
- if let Some(ref fld_var) = self.definition_level_histogram {
- o_prot.write_field_begin(&TFieldIdentifier::new("definition_level_histogram", TType::List, 3))?;
- o_prot.write_list_begin(&TListIdentifier::new(TType::I64, fld_var.len() as i32))?;
- for e in fld_var {
- o_prot.write_i64(*e)?;
- }
- o_prot.write_list_end()?;
- o_prot.write_field_end()?
- }
- o_prot.write_field_stop()?;
- o_prot.write_struct_end()
- }
-}
-
-//
-// BoundingBox
-//
-
-/// Bounding box for GEOMETRY or GEOGRAPHY type in the representation of min/max
-/// value pair of coordinates from each axis.
-#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct BoundingBox {
- pub xmin: OrderedFloat<f64>,
- pub xmax: OrderedFloat<f64>,
- pub ymin: OrderedFloat<f64>,
- pub ymax: OrderedFloat<f64>,
- pub zmin: Option<OrderedFloat<f64>>,
- pub zmax: Option<OrderedFloat<f64>>,
- pub mmin: Option<OrderedFloat<f64>>,
- pub mmax: Option<OrderedFloat<f64>>,
-}
-
-impl BoundingBox {
- pub fn new<F5, F6, F7, F8>(xmin: OrderedFloat<f64>, xmax: OrderedFloat<f64>, ymin: OrderedFloat<f64>, ymax: OrderedFloat<f64>, zmin: F5, zmax: F6, mmin: F7, mmax: F8) -> BoundingBox where F5: Into<Option<OrderedFloat<f64>>>, F6: Into<Option<OrderedFloat<f64>>>, F7: Into<Option<OrderedFloat<f64>>>, F8: Into<Option<OrderedFloat<f64>>> {
- BoundingBox {
- xmin,
- xmax,
- ymin,
- ymax,
- zmin: zmin.into(),
- zmax: zmax.into(),
- mmin: mmin.into(),
- mmax: mmax.into(),
- }
- }
-}
-
-impl crate::thrift::TSerializable for BoundingBox {
- fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<BoundingBox> {
- i_prot.read_struct_begin()?;
- let mut f_1: Option<OrderedFloat<f64>> = None;
- let mut f_2: Option<OrderedFloat<f64>> = None;
- let mut f_3: Option<OrderedFloat<f64>> = None;
- let mut f_4: Option<OrderedFloat<f64>> = None;
- let mut f_5: Option<OrderedFloat<f64>> = None;
- let mut f_6: Option<OrderedFloat<f64>> = None;
- let mut f_7: Option<OrderedFloat<f64>> = None;
- let mut f_8: Option<OrderedFloat<f64>> = None;
- loop {
- let field_ident = i_prot.read_field_begin()?;
- if field_ident.field_type == TType::Stop {
- break;
- }
- let field_id = field_id(&field_ident)?;
- match field_id {
- 1 => {
- let val = OrderedFloat::from(i_prot.read_double()?);
- f_1 = Some(val);
- },
- 2 => {
- let val = OrderedFloat::from(i_prot.read_double()?);
- f_2 = Some(val);
- },
- 3 => {
- let val = OrderedFloat::from(i_prot.read_double()?);
- f_3 = Some(val);
- },
- 4 => {
- let val = OrderedFloat::from(i_prot.read_double()?);
- f_4 = Some(val);
- },
- 5 => {
- let val = OrderedFloat::from(i_prot.read_double()?);
- f_5 = Some(val);
- },
- 6 => {
- let val = OrderedFloat::from(i_prot.read_double()?);
- f_6 = Some(val);
- },
- 7 => {
- let val = OrderedFloat::from(i_prot.read_double()?);
- f_7 = Some(val);
- },
- 8 => {
- let val = OrderedFloat::from(i_prot.read_double()?);
- f_8 = Some(val);
- },
- _ => {
- i_prot.skip(field_ident.field_type)?;
- },
- };
- i_prot.read_field_end()?;
- }
- i_prot.read_struct_end()?;
- verify_required_field_exists("BoundingBox.xmin", &f_1)?;
- verify_required_field_exists("BoundingBox.xmax", &f_2)?;
- verify_required_field_exists("BoundingBox.ymin", &f_3)?;
- verify_required_field_exists("BoundingBox.ymax", &f_4)?;
- let ret = BoundingBox {
- xmin: f_1.expect("auto-generated code should have checked for presence of required fields"),
- xmax: f_2.expect("auto-generated code should have checked for presence of required fields"),
- ymin: f_3.expect("auto-generated code should have checked for presence of required fields"),
- ymax: f_4.expect("auto-generated code should have checked for presence of required fields"),
- zmin: f_5,
- zmax: f_6,
- mmin: f_7,
- mmax: f_8,
- };
- Ok(ret)
- }
- fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
- let struct_ident = TStructIdentifier::new("BoundingBox");
- o_prot.write_struct_begin(&struct_ident)?;
- o_prot.write_field_begin(&TFieldIdentifier::new("xmin", TType::Double, 1))?;
- o_prot.write_double(self.xmin.into())?;
- o_prot.write_field_end()?;
- o_prot.write_field_begin(&TFieldIdentifier::new("xmax", TType::Double, 2))?;
- o_prot.write_double(self.xmax.into())?;
- o_prot.write_field_end()?;
- o_prot.write_field_begin(&TFieldIdentifier::new("ymin", TType::Double, 3))?;
- o_prot.write_double(self.ymin.into())?;
- o_prot.write_field_end()?;
- o_prot.write_field_begin(&TFieldIdentifier::new("ymax", TType::Double, 4))?;
- o_prot.write_double(self.ymax.into())?;
- o_prot.write_field_end()?;
- if let Some(fld_var) = self.zmin {
- o_prot.write_field_begin(&TFieldIdentifier::new("zmin", TType::Double, 5))?;
- o_prot.write_double(fld_var.into())?;
- o_prot.write_field_end()?
- }
- if let Some(fld_var) = self.zmax {
- o_prot.write_field_begin(&TFieldIdentifier::new("zmax", TType::Double, 6))?;
- o_prot.write_double(fld_var.into())?;
- o_prot.write_field_end()?
- }
- if let Some(fld_var) = self.mmin {
- o_prot.write_field_begin(&TFieldIdentifier::new("mmin", TType::Double, 7))?;
- o_prot.write_double(fld_var.into())?;
- o_prot.write_field_end()?
- }
- if let Some(fld_var) = self.mmax {
- o_prot.write_field_begin(&TFieldIdentifier::new("mmax", TType::Double, 8))?;
- o_prot.write_double(fld_var.into())?;
- o_prot.write_field_end()?
- }
- o_prot.write_field_stop()?;
- o_prot.write_struct_end()
- }
-}
-
-//
-// GeospatialStatistics
-//
-
-/// Statistics specific to Geometry and Geography logical types
-#[derive(Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct GeospatialStatistics {
- /// A bounding box of geospatial instances
- pub bbox: Option<BoundingBox>,
- /// Geospatial type codes of all instances, or an empty list if not known
- pub geospatial_types: Option<Vec<i32>>,
-}
-
-impl GeospatialStatistics {
- pub fn new<F1, F2>(bbox: F1, geospatial_types: F2) -> GeospatialStatistics where F1: Into<Option<BoundingBox>>, F2: Into<Option<Vec<i32>>> {
- GeospatialStatistics {
- bbox: bbox.into(),
- geospatial_types: geospatial_types.into(),
- }
- }
-}
-
-impl crate::thrift::TSerializable for GeospatialStatistics {
- fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<GeospatialStatistics> {
- i_prot.read_struct_begin()?;
- let mut f_1: Option<BoundingBox> = None;
- let mut f_2: Option<Vec<i32>> = None;
- loop {
- let field_ident = i_prot.read_field_begin()?;
- if field_ident.field_type == TType::Stop {
- break;
- }
- let field_id = field_id(&field_ident)?;
- match field_id {
- 1 => {
- let val = BoundingBox::read_from_in_protocol(i_prot)?;
- f_1 = Some(val);
- },
- 2 => {
- let list_ident = i_prot.read_list_begin()?;
- let mut val: Vec<i32> = Vec::with_capacity(list_ident.size as usize);
- for _ in 0..list_ident.size {
- let list_elem_2 = i_prot.read_i32()?;
- val.push(list_elem_2);
- }
- i_prot.read_list_end()?;
- f_2 = Some(val);
- },
- _ => {
- i_prot.skip(field_ident.field_type)?;
- },
- };
- i_prot.read_field_end()?;
- }
- i_prot.read_struct_end()?;
- let ret = GeospatialStatistics {
- bbox: f_1,
- geospatial_types: f_2,
- };
- Ok(ret)
- }
- fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
- let struct_ident = TStructIdentifier::new("GeospatialStatistics");
- o_prot.write_struct_begin(&struct_ident)?;
- if let Some(ref fld_var) = self.bbox {
- o_prot.write_field_begin(&TFieldIdentifier::new("bbox", TType::Struct, 1))?;
- fld_var.write_to_out_protocol(o_prot)?;
- o_prot.write_field_end()?
- }
- if let Some(ref fld_var) = self.geospatial_types {
- o_prot.write_field_begin(&TFieldIdentifier::new("geospatial_types", TType::List, 2))?;
- o_prot.write_list_begin(&TListIdentifier::new(TType::I32, fld_var.len() as i32))?;
- for e in fld_var {
- o_prot.write_i32(*e)?;
- }
- o_prot.write_list_end()?;
- o_prot.write_field_end()?
- }
- o_prot.write_field_stop()?;
- o_prot.write_struct_end()
- }
-}
-
-//
-// Statistics
-//
-
-/// Statistics per row group and per page
-/// All fields are optional.
-#[derive(Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct Statistics {
- /// DEPRECATED: min and max value of the column. Use min_value and max_value.
- ///
- /// Values are encoded using PLAIN encoding, except that variable-length byte
- /// arrays do not include a length prefix.
- ///
- /// These fields encode min and max values determined by signed comparison
- /// only. New files should use the correct order for a column's logical type
- /// and store the values in the min_value and max_value fields.
- ///
- /// To support older readers, these may be set when the column order is
- /// signed.
- pub max: Option<Vec<u8>>,
- pub min: Option<Vec<u8>>,
- /// Count of null values in the column.
- ///
- /// Writers SHOULD always write this field even if it is zero (i.e. no null value)
- /// or the column is not nullable.
- /// Readers MUST distinguish between null_count not being present and null_count == 0.
- /// If null_count is not present, readers MUST NOT assume null_count == 0.
- pub null_count: Option<i64>,
- /// count of distinct values occurring
- pub distinct_count: Option<i64>,
- /// Lower and upper bound values for the column, determined by its ColumnOrder.
- ///
- /// These may be the actual minimum and maximum values found on a page or column
- /// chunk, but can also be (more compact) values that do not exist on a page or
- /// column chunk. For example, instead of storing "Blart Versenwald III", a writer
- /// may set min_value="B", max_value="C". Such more compact values must still be
- /// valid values within the column's logical type.
- ///
- /// Values are encoded using PLAIN encoding, except that variable-length byte
- /// arrays do not include a length prefix.
- pub max_value: Option<Vec<u8>>,
- pub min_value: Option<Vec<u8>>,
- /// If true, max_value is the actual maximum value for a column
- pub is_max_value_exact: Option<bool>,
- /// If true, min_value is the actual minimum value for a column
- pub is_min_value_exact: Option<bool>,
-}
-
-impl Statistics {
- pub fn new<F1, F2, F3, F4, F5, F6, F7, F8>(max: F1, min: F2, null_count: F3, distinct_count: F4, max_value: F5, min_value: F6, is_max_value_exact: F7, is_min_value_exact: F8) -> Statistics where F1: Into<Option<Vec<u8>>>, F2: Into<Option<Vec<u8>>>, F3: Into<Option<i64>>, F4: Into<Option<i64>>, F5: Into<Option<Vec<u8>>>, F6: Into<Option<Vec<u8>>>, F7: Into<Option<bool>>, F8: Into<Option<bool>> {
- Statistics {
- max: max.into(),
- min: min.into(),
- null_count: null_count.into(),
- distinct_count: distinct_count.into(),
- max_value: max_value.into(),
- min_value: min_value.into(),
- is_max_value_exact: is_max_value_exact.into(),
- is_min_value_exact: is_min_value_exact.into(),
- }
- }
-}
-
-impl crate::thrift::TSerializable for Statistics {
- fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<Statistics> {
- i_prot.read_struct_begin()?;
- let mut f_1: Option<Vec<u8>> = None;
- let mut f_2: Option<Vec<u8>> = None;
- let mut f_3: Option<i64> = None;
- let mut f_4: Option<i64> = None;
- let mut f_5: Option<Vec<u8>> = None;
- let mut f_6: Option<Vec<u8>> = None;
- let mut f_7: Option<bool> = None;
- let mut f_8: Option<bool> = None;
- loop {
- let field_ident = i_prot.read_field_begin()?;
- if field_ident.field_type == TType::Stop {
- break;
- }
- let field_id = field_id(&field_ident)?;
- match field_id {
- 1 => {
- let val = i_prot.read_bytes()?;
- f_1 = Some(val);
- },
- 2 => {
- let val = i_prot.read_bytes()?;
- f_2 = Some(val);
- },
- 3 => {
- let val = i_prot.read_i64()?;
- f_3 = Some(val);
- },
- 4 => {
- let val = i_prot.read_i64()?;
- f_4 = Some(val);
- },
- 5 => {
- let val = i_prot.read_bytes()?;
- f_5 = Some(val);
- },
- 6 => {
- let val = i_prot.read_bytes()?;
- f_6 = Some(val);
- },
- 7 => {
- let val = i_prot.read_bool()?;
- f_7 = Some(val);
- },
- 8 => {
- let val = i_prot.read_bool()?;
- f_8 = Some(val);
- },
- _ => {
- i_prot.skip(field_ident.field_type)?;
- },
- };
- i_prot.read_field_end()?;
- }
- i_prot.read_struct_end()?;
- let ret = Statistics {
- max: f_1,
- min: f_2,
- null_count: f_3,
- distinct_count: f_4,
- max_value: f_5,
- min_value: f_6,
- is_max_value_exact: f_7,
- is_min_value_exact: f_8,
- };
- Ok(ret)
- }
- fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
- let struct_ident = TStructIdentifier::new("Statistics");
- o_prot.write_struct_begin(&struct_ident)?;
- if let Some(ref fld_var) = self.max {
- o_prot.write_field_begin(&TFieldIdentifier::new("max", TType::String, 1))?;
- o_prot.write_bytes(fld_var)?;
- o_prot.write_field_end()?
- }
- if let Some(ref fld_var) = self.min {
- o_prot.write_field_begin(&TFieldIdentifier::new("min", TType::String, 2))?;
- o_prot.write_bytes(fld_var)?;
- o_prot.write_field_end()?
- }
- if let Some(fld_var) = self.null_count {
- o_prot.write_field_begin(&TFieldIdentifier::new("null_count", TType::I64, 3))?;
- o_prot.write_i64(fld_var)?;
- o_prot.write_field_end()?
- }
- if let Some(fld_var) = self.distinct_count {
- o_prot.write_field_begin(&TFieldIdentifier::new("distinct_count", TType::I64, 4))?;
- o_prot.write_i64(fld_var)?;
- o_prot.write_field_end()?
- }
- if let Some(ref fld_var) = self.max_value {
- o_prot.write_field_begin(&TFieldIdentifier::new("max_value", TType::String, 5))?;
- o_prot.write_bytes(fld_var)?;
- o_prot.write_field_end()?
- }
- if let Some(ref fld_var) = self.min_value {
- o_prot.write_field_begin(&TFieldIdentifier::new("min_value", TType::String, 6))?;
- o_prot.write_bytes(fld_var)?;
- o_prot.write_field_end()?
- }
- if let Some(fld_var) = self.is_max_value_exact {
- o_prot.write_field_begin(&TFieldIdentifier::new("is_max_value_exact", TType::Bool, 7))?;
- o_prot.write_bool(fld_var)?;
- o_prot.write_field_end()?
- }
- if let Some(fld_var) = self.is_min_value_exact {
- o_prot.write_field_begin(&TFieldIdentifier::new("is_min_value_exact", TType::Bool, 8))?;
- o_prot.write_bool(fld_var)?;
- o_prot.write_field_end()?
- }
- o_prot.write_field_stop()?;
- o_prot.write_struct_end()
- }
-}
-
-//
-// StringType
-//
-
-/// Empty structs to use as logical type annotations
-#[derive(Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct StringType {
-}
-
-impl StringType {
- pub fn new() -> StringType {
- StringType {}
- }
-}
-
-impl crate::thrift::TSerializable for StringType {
- fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<StringType> {
- i_prot.read_struct_begin()?;
- loop {
- let field_ident = i_prot.read_field_begin()?;
- if field_ident.field_type == TType::Stop {
- break;
- }
- i_prot.skip(field_ident.field_type)?;
- i_prot.read_field_end()?;
- }
- i_prot.read_struct_end()?;
- let ret = StringType {};
- Ok(ret)
- }
- fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
- let struct_ident = TStructIdentifier::new("StringType");
- o_prot.write_struct_begin(&struct_ident)?;
- o_prot.write_field_stop()?;
- o_prot.write_struct_end()
- }
-}
-
-//
-// UUIDType
-//
-
-#[derive(Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct UUIDType {
-}
-
-impl UUIDType {
- pub fn new() -> UUIDType {
- UUIDType {}
- }
-}
-
-impl crate::thrift::TSerializable for UUIDType {
- fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<UUIDType> {
- i_prot.read_struct_begin()?;
- loop {
- let field_ident = i_prot.read_field_begin()?;
- if field_ident.field_type == TType::Stop {
- break;
- }
- i_prot.skip(field_ident.field_type)?;
- i_prot.read_field_end()?;
- }
- i_prot.read_struct_end()?;
- let ret = UUIDType {};
- Ok(ret)
- }
- fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
- let struct_ident = TStructIdentifier::new("UUIDType");
- o_prot.write_struct_begin(&struct_ident)?;
- o_prot.write_field_stop()?;
- o_prot.write_struct_end()
- }
-}
-
-//
-// MapType
-//
-
-#[derive(Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct MapType {
-}
-
-impl MapType {
- pub fn new() -> MapType {
- MapType {}
- }
-}
-
-impl crate::thrift::TSerializable for MapType {
- fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<MapType> {
- i_prot.read_struct_begin()?;
- loop {
- let field_ident = i_prot.read_field_begin()?;
- if field_ident.field_type == TType::Stop {
- break;
- }
- i_prot.skip(field_ident.field_type)?;
- i_prot.read_field_end()?;
- }
- i_prot.read_struct_end()?;
- let ret = MapType {};
- Ok(ret)
- }
- fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
- let struct_ident = TStructIdentifier::new("MapType");
- o_prot.write_struct_begin(&struct_ident)?;
- o_prot.write_field_stop()?;
- o_prot.write_struct_end()
- }
-}
-
-//
-// ListType
-//
-
-#[derive(Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct ListType {
-}
-
-impl ListType {
- pub fn new() -> ListType {
- ListType {}
- }
-}
-
-impl crate::thrift::TSerializable for ListType {
- fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<ListType> {
- i_prot.read_struct_begin()?;
- loop {
- let field_ident = i_prot.read_field_begin()?;
- if field_ident.field_type == TType::Stop {
- break;
- }
- i_prot.skip(field_ident.field_type)?;
- i_prot.read_field_end()?;
- }
- i_prot.read_struct_end()?;
- let ret = ListType {};
- Ok(ret)
- }
- fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
- let struct_ident = TStructIdentifier::new("ListType");
- o_prot.write_struct_begin(&struct_ident)?;
- o_prot.write_field_stop()?;
- o_prot.write_struct_end()
- }
-}
-
-//
-// EnumType
-//
-
-#[derive(Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct EnumType {
-}
-
-impl EnumType {
- pub fn new() -> EnumType {
- EnumType {}
- }
-}
-
-impl crate::thrift::TSerializable for EnumType {
- fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<EnumType> {
- i_prot.read_struct_begin()?;
- loop {
- let field_ident = i_prot.read_field_begin()?;
- if field_ident.field_type == TType::Stop {
- break;
- }
- i_prot.skip(field_ident.field_type)?;
- i_prot.read_field_end()?;
- }
- i_prot.read_struct_end()?;
- let ret = EnumType {};
- Ok(ret)
- }
- fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
- let struct_ident = TStructIdentifier::new("EnumType");
- o_prot.write_struct_begin(&struct_ident)?;
- o_prot.write_field_stop()?;
- o_prot.write_struct_end()
- }
-}
-
-//
-// DateType
-//
-
-#[derive(Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct DateType {
-}
-
-impl DateType {
- pub fn new() -> DateType {
- DateType {}
- }
-}
-
-impl crate::thrift::TSerializable for DateType {
- fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<DateType> {
- i_prot.read_struct_begin()?;
- loop {
- let field_ident = i_prot.read_field_begin()?;
- if field_ident.field_type == TType::Stop {
- break;
- }
- i_prot.skip(field_ident.field_type)?;
- i_prot.read_field_end()?;
- }
- i_prot.read_struct_end()?;
- let ret = DateType {};
- Ok(ret)
- }
- fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
- let struct_ident = TStructIdentifier::new("DateType");
- o_prot.write_struct_begin(&struct_ident)?;
- o_prot.write_field_stop()?;
- o_prot.write_struct_end()
- }
-}
-
-//
-// Float16Type
-//
-
-#[derive(Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct Float16Type {
-}
-
-impl Float16Type {
- pub fn new() -> Float16Type {
- Float16Type {}
- }
-}
-
-impl crate::thrift::TSerializable for Float16Type {
- fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<Float16Type> {
- i_prot.read_struct_begin()?;
- loop {
- let field_ident = i_prot.read_field_begin()?;
- if field_ident.field_type == TType::Stop {
- break;
- }
- i_prot.skip(field_ident.field_type)?;
- i_prot.read_field_end()?;
- }
- i_prot.read_struct_end()?;
- let ret = Float16Type {};
- Ok(ret)
- }
- fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
- let struct_ident = TStructIdentifier::new("Float16Type");
- o_prot.write_struct_begin(&struct_ident)?;
- o_prot.write_field_stop()?;
- o_prot.write_struct_end()
- }
-}
-
-//
-// NullType
-//
-
-/// Logical type to annotate a column that is always null.
-///
-/// Sometimes when discovering the schema of existing data, values are always
-/// null and the physical type can't be determined. This annotation signals
-/// the case where the physical type was guessed from all null values.
-#[derive(Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct NullType {
-}
-
-impl NullType {
- pub fn new() -> NullType {
- NullType {}
- }
-}
-
-impl crate::thrift::TSerializable for NullType {
- fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<NullType> {
- i_prot.read_struct_begin()?;
- loop {
- let field_ident = i_prot.read_field_begin()?;
- if field_ident.field_type == TType::Stop {
- break;
- }
- i_prot.skip(field_ident.field_type)?;
- i_prot.read_field_end()?;
- }
- i_prot.read_struct_end()?;
- let ret = NullType {};
- Ok(ret)
- }
- fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
- let struct_ident = TStructIdentifier::new("NullType");
- o_prot.write_struct_begin(&struct_ident)?;
- o_prot.write_field_stop()?;
- o_prot.write_struct_end()
- }
-}
-
-//
-// DecimalType
-//
-
-/// Decimal logical type annotation
-///
-/// Scale must be zero or a positive integer less than or equal to the precision.
-/// Precision must be a non-zero positive integer.
-///
-/// To maintain forward-compatibility in v1, implementations using this logical
-/// type must also set scale and precision on the annotated SchemaElement.
-///
-/// Allowed for physical types: INT32, INT64, FIXED_LEN_BYTE_ARRAY, and BYTE_ARRAY.
-#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct DecimalType {
- pub scale: i32,
- pub precision: i32,
-}
-
-impl DecimalType {
- pub fn new(scale: i32, precision: i32) -> DecimalType {
- DecimalType {
- scale,
- precision,
- }
- }
-}
-
-impl crate::thrift::TSerializable for DecimalType {
- fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<DecimalType> {
- i_prot.read_struct_begin()?;
- let mut f_1: Option<i32> = None;
- let mut f_2: Option<i32> = None;
- loop {
- let field_ident = i_prot.read_field_begin()?;
- if field_ident.field_type == TType::Stop {
- break;
- }
- let field_id = field_id(&field_ident)?;
- match field_id {
- 1 => {
- let val = i_prot.read_i32()?;
- f_1 = Some(val);
- },
- 2 => {
- let val = i_prot.read_i32()?;
- f_2 = Some(val);
- },
- _ => {
- i_prot.skip(field_ident.field_type)?;
- },
- };
- i_prot.read_field_end()?;
- }
- i_prot.read_struct_end()?;
- verify_required_field_exists("DecimalType.scale", &f_1)?;
- verify_required_field_exists("DecimalType.precision", &f_2)?;
- let ret = DecimalType {
- scale: f_1.expect("auto-generated code should have checked for presence of required fields"),
- precision: f_2.expect("auto-generated code should have checked for presence of required fields"),
- };
- Ok(ret)
- }
- fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
- let struct_ident = TStructIdentifier::new("DecimalType");
- o_prot.write_struct_begin(&struct_ident)?;
- o_prot.write_field_begin(&TFieldIdentifier::new("scale", TType::I32, 1))?;
- o_prot.write_i32(self.scale)?;
- o_prot.write_field_end()?;
- o_prot.write_field_begin(&TFieldIdentifier::new("precision", TType::I32, 2))?;
- o_prot.write_i32(self.precision)?;
- o_prot.write_field_end()?;
- o_prot.write_field_stop()?;
- o_prot.write_struct_end()
- }
-}
-
-//
-// MilliSeconds
-//
-
-/// Time units for logical types
-#[derive(Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct MilliSeconds {
-}
-
-impl MilliSeconds {
- pub fn new() -> MilliSeconds {
- MilliSeconds {}
- }
-}
-
-impl crate::thrift::TSerializable for MilliSeconds {
- fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<MilliSeconds> {
- i_prot.read_struct_begin()?;
- loop {
- let field_ident = i_prot.read_field_begin()?;
- if field_ident.field_type == TType::Stop {
- break;
- }
- i_prot.skip(field_ident.field_type)?;
- i_prot.read_field_end()?;
- }
- i_prot.read_struct_end()?;
- let ret = MilliSeconds {};
- Ok(ret)
- }
- fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
- let struct_ident = TStructIdentifier::new("MilliSeconds");
- o_prot.write_struct_begin(&struct_ident)?;
- o_prot.write_field_stop()?;
- o_prot.write_struct_end()
- }
-}
-
-//
-// MicroSeconds
-//
-
-#[derive(Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct MicroSeconds {
-}
-
-impl MicroSeconds {
- pub fn new() -> MicroSeconds {
- MicroSeconds {}
- }
-}
-
-impl crate::thrift::TSerializable for MicroSeconds {
- fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<MicroSeconds> {
- i_prot.read_struct_begin()?;
- loop {
- let field_ident = i_prot.read_field_begin()?;
- if field_ident.field_type == TType::Stop {
- break;
- }
- i_prot.skip(field_ident.field_type)?;
- i_prot.read_field_end()?;
- }
- i_prot.read_struct_end()?;
- let ret = MicroSeconds {};
- Ok(ret)
- }
- fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
- let struct_ident = TStructIdentifier::new("MicroSeconds");
- o_prot.write_struct_begin(&struct_ident)?;
- o_prot.write_field_stop()?;
- o_prot.write_struct_end()
- }
-}
-
-//
-// NanoSeconds
-//
-
-#[derive(Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct NanoSeconds {
-}
-
-impl NanoSeconds {
- pub fn new() -> NanoSeconds {
- NanoSeconds {}
- }
-}
-
-impl crate::thrift::TSerializable for NanoSeconds {
- fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<NanoSeconds> {
- i_prot.read_struct_begin()?;
- loop {
- let field_ident = i_prot.read_field_begin()?;
- if field_ident.field_type == TType::Stop {
- break;
- }
- i_prot.skip(field_ident.field_type)?;
- i_prot.read_field_end()?;
- }
- i_prot.read_struct_end()?;
- let ret = NanoSeconds {};
- Ok(ret)
- }
- fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
- let struct_ident = TStructIdentifier::new("NanoSeconds");
- o_prot.write_struct_begin(&struct_ident)?;
- o_prot.write_field_stop()?;
- o_prot.write_struct_end()
- }
-}
-
-//
-// TimeUnit
-//
-
-#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub enum TimeUnit {
- MILLIS(MilliSeconds),
- MICROS(MicroSeconds),
- NANOS(NanoSeconds),
-}
-
-impl crate::thrift::TSerializable for TimeUnit {
- fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<TimeUnit> {
- let mut ret: Option<TimeUnit> = None;
- let mut received_field_count = 0;
- i_prot.read_struct_begin()?;
- loop {
- let field_ident = i_prot.read_field_begin()?;
- if field_ident.field_type == TType::Stop {
- break;
- }
- let field_id = field_id(&field_ident)?;
- match field_id {
- 1 => {
- let val = MilliSeconds::read_from_in_protocol(i_prot)?;
- if ret.is_none() {
- ret = Some(TimeUnit::MILLIS(val));
- }
- received_field_count += 1;
- },
- 2 => {
- let val = MicroSeconds::read_from_in_protocol(i_prot)?;
- if ret.is_none() {
- ret = Some(TimeUnit::MICROS(val));
- }
- received_field_count += 1;
- },
- 3 => {
- let val = NanoSeconds::read_from_in_protocol(i_prot)?;
- if ret.is_none() {
- ret = Some(TimeUnit::NANOS(val));
- }
- received_field_count += 1;
- },
- _ => {
- i_prot.skip(field_ident.field_type)?;
- received_field_count += 1;
- },
- };
- i_prot.read_field_end()?;
- }
- i_prot.read_struct_end()?;
- if received_field_count == 0 {
- Err(
- thrift::Error::Protocol(
- ProtocolError::new(
- ProtocolErrorKind::InvalidData,
- "received empty union from remote TimeUnit"
- )
- )
- )
- } else if received_field_count > 1 {
- Err(
- thrift::Error::Protocol(
- ProtocolError::new(
- ProtocolErrorKind::InvalidData,
- "received multiple fields for union from remote TimeUnit"
- )
- )
- )
- } else {
- ret.ok_or_else(|| thrift::Error::Protocol(ProtocolError::new(ProtocolErrorKind::InvalidData, "return value should have been constructed")))
- }
- }
- fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
- let struct_ident = TStructIdentifier::new("TimeUnit");
- o_prot.write_struct_begin(&struct_ident)?;
- match *self {
- TimeUnit::MILLIS(ref f) => {
- o_prot.write_field_begin(&TFieldIdentifier::new("MILLIS", TType::Struct, 1))?;
- f.write_to_out_protocol(o_prot)?;
- o_prot.write_field_end()?;
- },
- TimeUnit::MICROS(ref f) => {
- o_prot.write_field_begin(&TFieldIdentifier::new("MICROS", TType::Struct, 2))?;
- f.write_to_out_protocol(o_prot)?;
- o_prot.write_field_end()?;
- },
- TimeUnit::NANOS(ref f) => {
- o_prot.write_field_begin(&TFieldIdentifier::new("NANOS", TType::Struct, 3))?;
- f.write_to_out_protocol(o_prot)?;
- o_prot.write_field_end()?;
- },
- }
- o_prot.write_field_stop()?;
- o_prot.write_struct_end()
- }
-}
-
-//
-// TimestampType
-//
-
-/// Timestamp logical type annotation
-///
-/// Allowed for physical types: INT64
-#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct TimestampType {
- pub is_adjusted_to_u_t_c: bool,
- pub unit: TimeUnit,
-}
-
-impl TimestampType {
- pub fn new(is_adjusted_to_u_t_c: bool, unit: TimeUnit) -> TimestampType {
- TimestampType {
- is_adjusted_to_u_t_c,
- unit,
- }
- }
-}
-
-impl crate::thrift::TSerializable for TimestampType {
- fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<TimestampType> {
- i_prot.read_struct_begin()?;
- let mut f_1: Option<bool> = None;
- let mut f_2: Option<TimeUnit> = None;
- loop {
- let field_ident = i_prot.read_field_begin()?;
- if field_ident.field_type == TType::Stop {
- break;
- }
- let field_id = field_id(&field_ident)?;
- match field_id {
- 1 => {
- let val = i_prot.read_bool()?;
- f_1 = Some(val);
- },
- 2 => {
- let val = TimeUnit::read_from_in_protocol(i_prot)?;
- f_2 = Some(val);
- },
- _ => {
- i_prot.skip(field_ident.field_type)?;
- },
- };
- i_prot.read_field_end()?;
- }
- i_prot.read_struct_end()?;
- verify_required_field_exists("TimestampType.is_adjusted_to_u_t_c", &f_1)?;
- verify_required_field_exists("TimestampType.unit", &f_2)?;
- let ret = TimestampType {
- is_adjusted_to_u_t_c: f_1.expect("auto-generated code should have checked for presence of required fields"),
- unit: f_2.expect("auto-generated code should have checked for presence of required fields"),
- };
- Ok(ret)
- }
- fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
- let struct_ident = TStructIdentifier::new("TimestampType");
- o_prot.write_struct_begin(&struct_ident)?;
- o_prot.write_field_begin(&TFieldIdentifier::new("isAdjustedToUTC", TType::Bool, 1))?;
- o_prot.write_bool(self.is_adjusted_to_u_t_c)?;
- o_prot.write_field_end()?;
- o_prot.write_field_begin(&TFieldIdentifier::new("unit", TType::Struct, 2))?;
- self.unit.write_to_out_protocol(o_prot)?;
- o_prot.write_field_end()?;
- o_prot.write_field_stop()?;
- o_prot.write_struct_end()
- }
-}
-
-//
-// TimeType
-//
-
-/// Time logical type annotation
-///
-/// Allowed for physical types: INT32 (millis), INT64 (micros, nanos)
-#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct TimeType {
- pub is_adjusted_to_u_t_c: bool,
- pub unit: TimeUnit,
-}
-
-impl TimeType {
- pub fn new(is_adjusted_to_u_t_c: bool, unit: TimeUnit) -> TimeType {
- TimeType {
- is_adjusted_to_u_t_c,
- unit,
- }
- }
-}
-
-impl crate::thrift::TSerializable for TimeType {
- fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<TimeType> {
- i_prot.read_struct_begin()?;
- let mut f_1: Option<bool> = None;
- let mut f_2: Option<TimeUnit> = None;
- loop {
- let field_ident = i_prot.read_field_begin()?;
- if field_ident.field_type == TType::Stop {
- break;
- }
- let field_id = field_id(&field_ident)?;
- match field_id {
- 1 => {
- let val = i_prot.read_bool()?;
- f_1 = Some(val);
- },
- 2 => {
- let val = TimeUnit::read_from_in_protocol(i_prot)?;
- f_2 = Some(val);
- },
- _ => {
- i_prot.skip(field_ident.field_type)?;
- },
- };
- i_prot.read_field_end()?;
- }
- i_prot.read_struct_end()?;
- verify_required_field_exists("TimeType.is_adjusted_to_u_t_c", &f_1)?;
- verify_required_field_exists("TimeType.unit", &f_2)?;
- let ret = TimeType {
- is_adjusted_to_u_t_c: f_1.expect("auto-generated code should have checked for presence of required fields"),
- unit: f_2.expect("auto-generated code should have checked for presence of required fields"),
- };
- Ok(ret)
- }
- fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
- let struct_ident = TStructIdentifier::new("TimeType");
- o_prot.write_struct_begin(&struct_ident)?;
- o_prot.write_field_begin(&TFieldIdentifier::new("isAdjustedToUTC", TType::Bool, 1))?;
- o_prot.write_bool(self.is_adjusted_to_u_t_c)?;
- o_prot.write_field_end()?;
- o_prot.write_field_begin(&TFieldIdentifier::new("unit", TType::Struct, 2))?;
- self.unit.write_to_out_protocol(o_prot)?;
- o_prot.write_field_end()?;
- o_prot.write_field_stop()?;
- o_prot.write_struct_end()
- }
-}
-
-//
-// IntType
-//
-
-/// Integer logical type annotation
-///
-/// bitWidth must be 8, 16, 32, or 64.
-///
-/// Allowed for physical types: INT32, INT64
-#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct IntType {
- pub bit_width: i8,
- pub is_signed: bool,
-}
-
-impl IntType {
- pub fn new(bit_width: i8, is_signed: bool) -> IntType {
- IntType {
- bit_width,
- is_signed,
- }
- }
-}
-
-impl crate::thrift::TSerializable for IntType {
- fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<IntType> {
- i_prot.read_struct_begin()?;
- let mut f_1: Option<i8> = None;
- let mut f_2: Option<bool> = None;
- loop {
- let field_ident = i_prot.read_field_begin()?;
- if field_ident.field_type == TType::Stop {
- break;
- }
- let field_id = field_id(&field_ident)?;
- match field_id {
- 1 => {
- let val = i_prot.read_i8()?;
- f_1 = Some(val);
- },
- 2 => {
- let val = i_prot.read_bool()?;
- f_2 = Some(val);
- },
- _ => {
- i_prot.skip(field_ident.field_type)?;
- },
- };
- i_prot.read_field_end()?;
- }
- i_prot.read_struct_end()?;
- verify_required_field_exists("IntType.bit_width", &f_1)?;
- verify_required_field_exists("IntType.is_signed", &f_2)?;
- let ret = IntType {
- bit_width: f_1.expect("auto-generated code should have checked for presence of required fields"),
- is_signed: f_2.expect("auto-generated code should have checked for presence of required fields"),
- };
- Ok(ret)
- }
- fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
- let struct_ident = TStructIdentifier::new("IntType");
- o_prot.write_struct_begin(&struct_ident)?;
- o_prot.write_field_begin(&TFieldIdentifier::new("bitWidth", TType::I08, 1))?;
- o_prot.write_i8(self.bit_width)?;
- o_prot.write_field_end()?;
- o_prot.write_field_begin(&TFieldIdentifier::new("isSigned", TType::Bool, 2))?;
- o_prot.write_bool(self.is_signed)?;
- o_prot.write_field_end()?;
- o_prot.write_field_stop()?;
- o_prot.write_struct_end()
- }
-}
-
-//
-// JsonType
-//
-
-/// Embedded JSON logical type annotation
-///
-/// Allowed for physical types: BYTE_ARRAY
-#[derive(Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct JsonType {
-}
-
-impl JsonType {
- pub fn new() -> JsonType {
- JsonType {}
- }
-}
-
-impl crate::thrift::TSerializable for JsonType {
- fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<JsonType> {
- i_prot.read_struct_begin()?;
- loop {
- let field_ident = i_prot.read_field_begin()?;
- if field_ident.field_type == TType::Stop {
- break;
- }
- i_prot.skip(field_ident.field_type)?;
- i_prot.read_field_end()?;
- }
- i_prot.read_struct_end()?;
- let ret = JsonType {};
- Ok(ret)
- }
- fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
- let struct_ident = TStructIdentifier::new("JsonType");
- o_prot.write_struct_begin(&struct_ident)?;
- o_prot.write_field_stop()?;
- o_prot.write_struct_end()
- }
-}
-
-//
-// BsonType
-//
-
-/// Embedded BSON logical type annotation
-///
-/// Allowed for physical types: BYTE_ARRAY
-#[derive(Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct BsonType {
-}
-
-impl BsonType {
- pub fn new() -> BsonType {
- BsonType {}
- }
-}
-
-impl crate::thrift::TSerializable for BsonType {
- fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<BsonType> {
- i_prot.read_struct_begin()?;
- loop {
- let field_ident = i_prot.read_field_begin()?;
- if field_ident.field_type == TType::Stop {
- break;
- }
- i_prot.skip(field_ident.field_type)?;
- i_prot.read_field_end()?;
- }
- i_prot.read_struct_end()?;
- let ret = BsonType {};
- Ok(ret)
- }
- fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
- let struct_ident = TStructIdentifier::new("BsonType");
- o_prot.write_struct_begin(&struct_ident)?;
- o_prot.write_field_stop()?;
- o_prot.write_struct_end()
- }
-}
-
-//
-// VariantType
-//
-
-/// Embedded Variant logical type annotation
-#[derive(Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct VariantType {
- pub specification_version: Option<i8>,
-}
-
-impl VariantType {
- pub fn new<F1>(specification_version: F1) -> VariantType where F1: Into<Option<i8>> {
- VariantType {
- specification_version: specification_version.into(),
- }
- }
-}
-
-impl crate::thrift::TSerializable for VariantType {
- fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<VariantType> {
- i_prot.read_struct_begin()?;
- let mut f_1: Option<i8> = None;
- loop {
- let field_ident = i_prot.read_field_begin()?;
- if field_ident.field_type == TType::Stop {
- break;
- }
- let field_id = field_id(&field_ident)?;
- match field_id {
- 1 => {
- let val = i_prot.read_i8()?;
- f_1 = Some(val);
- },
- _ => {
- i_prot.skip(field_ident.field_type)?;
- },
- };
- i_prot.read_field_end()?;
- }
- i_prot.read_struct_end()?;
- let ret = VariantType {
- specification_version: f_1,
- };
- Ok(ret)
- }
- fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
- let struct_ident = TStructIdentifier::new("VariantType");
- o_prot.write_struct_begin(&struct_ident)?;
- if let Some(fld_var) = self.specification_version {
- o_prot.write_field_begin(&TFieldIdentifier::new("specification_version", TType::I08, 1))?;
- o_prot.write_i8(fld_var)?;
- o_prot.write_field_end()?
- }
- o_prot.write_field_stop()?;
- o_prot.write_struct_end()
- }
-}
-
-//
-// GeometryType
-//
-
-/// Embedded Geometry logical type annotation
-///
-/// Geospatial features in the Well-Known Binary (WKB) format and edges interpolation
-/// is always linear/planar.
-///
-/// A custom CRS can be set by the crs field. If unset, it defaults to "OGC:CRS84",
-/// which means that the geometries must be stored in longitude, latitude based on
-/// the WGS84 datum.
-///
-/// Allowed for physical type: BYTE_ARRAY.
-///
-/// See Geospatial.md for details.
-#[derive(Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct GeometryType {
- pub crs: Option<String>,
-}
-
-impl GeometryType {
- pub fn new<F1>(crs: F1) -> GeometryType where F1: Into<Option<String>> {
- GeometryType {
- crs: crs.into(),
- }
- }
-}
-
-impl crate::thrift::TSerializable for GeometryType {
- fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<GeometryType> {
- i_prot.read_struct_begin()?;
- let mut f_1: Option<String> = None;
- loop {
- let field_ident = i_prot.read_field_begin()?;
- if field_ident.field_type == TType::Stop {
- break;
- }
- let field_id = field_id(&field_ident)?;
- match field_id {
- 1 => {
- let val = i_prot.read_string()?;
- f_1 = Some(val);
- },
- _ => {
- i_prot.skip(field_ident.field_type)?;
- },
- };
- i_prot.read_field_end()?;
- }
- i_prot.read_struct_end()?;
- let ret = GeometryType {
- crs: f_1,
- };
- Ok(ret)
- }
- fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
- let struct_ident = TStructIdentifier::new("GeometryType");
- o_prot.write_struct_begin(&struct_ident)?;
- if let Some(ref fld_var) = self.crs {
- o_prot.write_field_begin(&TFieldIdentifier::new("crs", TType::String, 1))?;
- o_prot.write_string(fld_var)?;
- o_prot.write_field_end()?
- }
- o_prot.write_field_stop()?;
- o_prot.write_struct_end()
- }
-}
-
-//
-// GeographyType
-//
-
-/// Embedded Geography logical type annotation
-///
-/// Geospatial features in the WKB format with an explicit (non-linear/non-planar)
-/// edges interpolation algorithm.
-///
-/// A custom geographic CRS can be set by the crs field, where longitudes are
-/// bound by [-180, 180] and latitudes are bound by [-90, 90]. If unset, the CRS
-/// defaults to "OGC:CRS84".
-///
-/// An optional algorithm can be set to correctly interpret edges interpolation
-/// of the geometries. If unset, the algorithm defaults to SPHERICAL.
-///
-/// Allowed for physical type: BYTE_ARRAY.
-///
-/// See Geospatial.md for details.
-#[derive(Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct GeographyType {
- pub crs: Option<String>,
- pub algorithm: Option<EdgeInterpolationAlgorithm>,
-}
-
-impl GeographyType {
- pub fn new<F1, F2>(crs: F1, algorithm: F2) -> GeographyType where F1: Into<Option<String>>, F2: Into<Option<EdgeInterpolationAlgorithm>> {
- GeographyType {
- crs: crs.into(),
- algorithm: algorithm.into(),
- }
- }
-}
-
-impl crate::thrift::TSerializable for GeographyType {
- fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<GeographyType> {
- i_prot.read_struct_begin()?;
- let mut f_1: Option<String> = None;
- let mut f_2: Option<EdgeInterpolationAlgorithm> = None;
- loop {
- let field_ident = i_prot.read_field_begin()?;
- if field_ident.field_type == TType::Stop {
- break;
- }
- let field_id = field_id(&field_ident)?;
- match field_id {
- 1 => {
- let val = i_prot.read_string()?;
- f_1 = Some(val);
- },
- 2 => {
- let val = EdgeInterpolationAlgorithm::read_from_in_protocol(i_prot)?;
- f_2 = Some(val);
- },
- _ => {
- i_prot.skip(field_ident.field_type)?;
- },
- };
- i_prot.read_field_end()?;
- }
- i_prot.read_struct_end()?;
- let ret = GeographyType {
- crs: f_1,
- algorithm: f_2,
- };
- Ok(ret)
- }
- fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
- let struct_ident = TStructIdentifier::new("GeographyType");
- o_prot.write_struct_begin(&struct_ident)?;
- if let Some(ref fld_var) = self.crs {
- o_prot.write_field_begin(&TFieldIdentifier::new("crs", TType::String, 1))?;
- o_prot.write_string(fld_var)?;
- o_prot.write_field_end()?
- }
- if let Some(ref fld_var) = self.algorithm {
- o_prot.write_field_begin(&TFieldIdentifier::new("algorithm", TType::I32, 2))?;
- fld_var.write_to_out_protocol(o_prot)?;
- o_prot.write_field_end()?
- }
- o_prot.write_field_stop()?;
- o_prot.write_struct_end()
- }
-}
-
-//
-// LogicalType
-//
-
-#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub enum LogicalType {
- STRING(StringType),
- MAP(MapType),
- LIST(ListType),
- ENUM(EnumType),
- DECIMAL(DecimalType),
- DATE(DateType),
- TIME(TimeType),
- TIMESTAMP(TimestampType),
- INTEGER(IntType),
- UNKNOWN(NullType),
- JSON(JsonType),
- BSON(BsonType),
- UUID(UUIDType),
- FLOAT16(Float16Type),
- VARIANT(VariantType),
- GEOMETRY(GeometryType),
- GEOGRAPHY(GeographyType),
-}
-
-impl crate::thrift::TSerializable for LogicalType {
- fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<LogicalType> {
- let mut ret: Option<LogicalType> = None;
- let mut received_field_count = 0;
- i_prot.read_struct_begin()?;
- loop {
- let field_ident = i_prot.read_field_begin()?;
- if field_ident.field_type == TType::Stop {
- break;
- }
- let field_id = field_id(&field_ident)?;
- match field_id {
- 1 => {
- let val = StringType::read_from_in_protocol(i_prot)?;
- if ret.is_none() {
- ret = Some(LogicalType::STRING(val));
- }
- received_field_count += 1;
- },
- 2 => {
- let val = MapType::read_from_in_protocol(i_prot)?;
- if ret.is_none() {
- ret = Some(LogicalType::MAP(val));
- }
- received_field_count += 1;
- },
- 3 => {
- let val = ListType::read_from_in_protocol(i_prot)?;
- if ret.is_none() {
- ret = Some(LogicalType::LIST(val));
- }
- received_field_count += 1;
- },
- 4 => {
- let val = EnumType::read_from_in_protocol(i_prot)?;
- if ret.is_none() {
- ret = Some(LogicalType::ENUM(val));
- }
- received_field_count += 1;
- },
- 5 => {
- let val = DecimalType::read_from_in_protocol(i_prot)?;
- if ret.is_none() {
- ret = Some(LogicalType::DECIMAL(val));
- }
- received_field_count += 1;
- },
- 6 => {
- let val = DateType::read_from_in_protocol(i_prot)?;
- if ret.is_none() {
- ret = Some(LogicalType::DATE(val));
- }
- received_field_count += 1;
- },
- 7 => {
- let val = TimeType::read_from_in_protocol(i_prot)?;
- if ret.is_none() {
- ret = Some(LogicalType::TIME(val));
- }
- received_field_count += 1;
- },
- 8 => {
- let val = TimestampType::read_from_in_protocol(i_prot)?;
- if ret.is_none() {
- ret = Some(LogicalType::TIMESTAMP(val));
- }
- received_field_count += 1;
- },
- 10 => {
- let val = IntType::read_from_in_protocol(i_prot)?;
- if ret.is_none() {
- ret = Some(LogicalType::INTEGER(val));
- }
- received_field_count += 1;
- },
- 11 => {
- let val = NullType::read_from_in_protocol(i_prot)?;
- if ret.is_none() {
- ret = Some(LogicalType::UNKNOWN(val));
- }
- received_field_count += 1;
- },
- 12 => {
- let val = JsonType::read_from_in_protocol(i_prot)?;
- if ret.is_none() {
- ret = Some(LogicalType::JSON(val));
- }
- received_field_count += 1;
- },
- 13 => {
- let val = BsonType::read_from_in_protocol(i_prot)?;
- if ret.is_none() {
- ret = Some(LogicalType::BSON(val));
- }
- received_field_count += 1;
- },
- 14 => {
- let val = UUIDType::read_from_in_protocol(i_prot)?;
- if ret.is_none() {
- ret = Some(LogicalType::UUID(val));
- }
- received_field_count += 1;
- },
- 15 => {
- let val = Float16Type::read_from_in_protocol(i_prot)?;
- if ret.is_none() {
- ret = Some(LogicalType::FLOAT16(val));
- }
- received_field_count += 1;
- },
- 16 => {
- let val = VariantType::read_from_in_protocol(i_prot)?;
- if ret.is_none() {
- ret = Some(LogicalType::VARIANT(val));
- }
- received_field_count += 1;
- },
- 17 => {
- let val = GeometryType::read_from_in_protocol(i_prot)?;
- if ret.is_none() {
- ret = Some(LogicalType::GEOMETRY(val));
- }
- received_field_count += 1;
- },
- 18 => {
- let val = GeographyType::read_from_in_protocol(i_prot)?;
- if ret.is_none() {
- ret = Some(LogicalType::GEOGRAPHY(val));
- }
- received_field_count += 1;
- },
- _ => {
- i_prot.skip(field_ident.field_type)?;
- received_field_count += 1;
- },
- };
- i_prot.read_field_end()?;
- }
- i_prot.read_struct_end()?;
- if received_field_count == 0 {
- Err(
- thrift::Error::Protocol(
- ProtocolError::new(
- ProtocolErrorKind::InvalidData,
- "received empty union from remote LogicalType"
- )
- )
- )
- } else if received_field_count > 1 {
- Err(
- thrift::Error::Protocol(
- ProtocolError::new(
- ProtocolErrorKind::InvalidData,
- "received multiple fields for union from remote LogicalType"
- )
- )
- )
- } else {
- ret.ok_or_else(|| thrift::Error::Protocol(ProtocolError::new(ProtocolErrorKind::InvalidData, "return value should have been constructed")))
- }
- }
- fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
- let struct_ident = TStructIdentifier::new("LogicalType");
- o_prot.write_struct_begin(&struct_ident)?;
- match *self {
- LogicalType::STRING(ref f) => {
- o_prot.write_field_begin(&TFieldIdentifier::new("STRING", TType::Struct, 1))?;
- f.write_to_out_protocol(o_prot)?;
- o_prot.write_field_end()?;
- },
- LogicalType::MAP(ref f) => {
- o_prot.write_field_begin(&TFieldIdentifier::new("MAP", TType::Struct, 2))?;
- f.write_to_out_protocol(o_prot)?;
- o_prot.write_field_end()?;
- },
- LogicalType::LIST(ref f) => {
- o_prot.write_field_begin(&TFieldIdentifier::new("LIST", TType::Struct, 3))?;
- f.write_to_out_protocol(o_prot)?;
- o_prot.write_field_end()?;
- },
- LogicalType::ENUM(ref f) => {
- o_prot.write_field_begin(&TFieldIdentifier::new("ENUM", TType::Struct, 4))?;
- f.write_to_out_protocol(o_prot)?;
- o_prot.write_field_end()?;
- },
- LogicalType::DECIMAL(ref f) => {
- o_prot.write_field_begin(&TFieldIdentifier::new("DECIMAL", TType::Struct, 5))?;
- f.write_to_out_protocol(o_prot)?;
- o_prot.write_field_end()?;
- },
- LogicalType::DATE(ref f) => {
- o_prot.write_field_begin(&TFieldIdentifier::new("DATE", TType::Struct, 6))?;
- f.write_to_out_protocol(o_prot)?;
- o_prot.write_field_end()?;
- },
- LogicalType::TIME(ref f) => {
- o_prot.write_field_begin(&TFieldIdentifier::new("TIME", TType::Struct, 7))?;
- f.write_to_out_protocol(o_prot)?;
- o_prot.write_field_end()?;
- },
- LogicalType::TIMESTAMP(ref f) => {
- o_prot.write_field_begin(&TFieldIdentifier::new("TIMESTAMP", TType::Struct, 8))?;
- f.write_to_out_protocol(o_prot)?;
- o_prot.write_field_end()?;
- },
- LogicalType::INTEGER(ref f) => {
- o_prot.write_field_begin(&TFieldIdentifier::new("INTEGER", TType::Struct, 10))?;
- f.write_to_out_protocol(o_prot)?;
- o_prot.write_field_end()?;
- },
- LogicalType::UNKNOWN(ref f) => {
- o_prot.write_field_begin(&TFieldIdentifier::new("UNKNOWN", TType::Struct, 11))?;
- f.write_to_out_protocol(o_prot)?;
- o_prot.write_field_end()?;
- },
- LogicalType::JSON(ref f) => {
- o_prot.write_field_begin(&TFieldIdentifier::new("JSON", TType::Struct, 12))?;
- f.write_to_out_protocol(o_prot)?;
- o_prot.write_field_end()?;
- },
- LogicalType::BSON(ref f) => {
- o_prot.write_field_begin(&TFieldIdentifier::new("BSON", TType::Struct, 13))?;
- f.write_to_out_protocol(o_prot)?;
- o_prot.write_field_end()?;
- },
- LogicalType::UUID(ref f) => {
- o_prot.write_field_begin(&TFieldIdentifier::new("UUID", TType::Struct, 14))?;
- f.write_to_out_protocol(o_prot)?;
- o_prot.write_field_end()?;
- },
- LogicalType::FLOAT16(ref f) => {
- o_prot.write_field_begin(&TFieldIdentifier::new("FLOAT16", TType::Struct, 15))?;
- f.write_to_out_protocol(o_prot)?;
- o_prot.write_field_end()?;
- },
- LogicalType::VARIANT(ref f) => {
- o_prot.write_field_begin(&TFieldIdentifier::new("VARIANT", TType::Struct, 16))?;
- f.write_to_out_protocol(o_prot)?;
- o_prot.write_field_end()?;
- },
- LogicalType::GEOMETRY(ref f) => {
- o_prot.write_field_begin(&TFieldIdentifier::new("GEOMETRY", TType::Struct, 17))?;
- f.write_to_out_protocol(o_prot)?;
- o_prot.write_field_end()?;
- },
- LogicalType::GEOGRAPHY(ref f) => {
- o_prot.write_field_begin(&TFieldIdentifier::new("GEOGRAPHY", TType::Struct, 18))?;
- f.write_to_out_protocol(o_prot)?;
- o_prot.write_field_end()?;
- },
- }
- o_prot.write_field_stop()?;
- o_prot.write_struct_end()
- }
-}
-
-//
-// SchemaElement
-//
-
-/// Represents a element inside a schema definition.
-/// - if it is a group (inner node) then type is undefined and num_children is defined
-/// - if it is a primitive type (leaf) then type is defined and num_children is undefined
-/// the nodes are listed in depth first traversal order.
-#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct SchemaElement {
- /// Data type for this field. Not set if the current element is a non-leaf node
- pub type_: Option<Type>,
- /// If type is FIXED_LEN_BYTE_ARRAY, this is the byte length of the values.
- /// Otherwise, if specified, this is the maximum bit length to store any of the values.
- /// (e.g. a low cardinality INT col could have this set to 3). Note that this is
- /// in the schema, and therefore fixed for the entire file.
- pub type_length: Option<i32>,
- /// repetition of the field. The root of the schema does not have a repetition_type.
- /// All other nodes must have one
- pub repetition_type: Option<FieldRepetitionType>,
- /// Name of the field in the schema
- pub name: String,
- /// Nested fields. Since thrift does not support nested fields,
- /// the nesting is flattened to a single list by a depth-first traversal.
- /// The children count is used to construct the nested relationship.
- /// This field is not set when the element is a primitive type
- pub num_children: Option<i32>,
- /// DEPRECATED: When the schema is the result of a conversion from another model.
- /// Used to record the original type to help with cross conversion.
- ///
- /// This is superseded by logicalType.
- pub converted_type: Option<ConvertedType>,
- /// DEPRECATED: Used when this column contains decimal data.
- /// See the DECIMAL converted type for more details.
- ///
- /// This is superseded by using the DecimalType annotation in logicalType.
- pub scale: Option<i32>,
- pub precision: Option<i32>,
- /// When the original schema supports field ids, this will save the
- /// original field id in the parquet schema
- pub field_id: Option<i32>,
- /// The logical type of this SchemaElement
- ///
- /// LogicalType replaces ConvertedType, but ConvertedType is still required
- /// for some logical types to ensure forward-compatibility in format v1.
- pub logical_type: Option<LogicalType>,
-}
-
-impl SchemaElement {
- pub fn new<F1, F2, F3, F5, F6, F7, F8, F9, F10>(type_: F1, type_length: F2, repetition_type: F3, name: String, num_children: F5, converted_type: F6, scale: F7, precision: F8, field_id: F9, logical_type: F10) -> SchemaElement where F1: Into<Option<Type>>, F2: Into<Option<i32>>, F3: Into<Option<FieldRepetitionType>>, F5: Into<Option<i32>>, F6: Into<Option<ConvertedType>>, F7: Into<Option<i32>>, F8: Into<Option<i32>>, F9: Into<Option<i32>>, F10: Into<Option<LogicalType>> {
- SchemaElement {
- type_: type_.into(),
- type_length: type_length.into(),
- repetition_type: repetition_type.into(),
- name,
- num_children: num_children.into(),
- converted_type: converted_type.into(),
- scale: scale.into(),
- precision: precision.into(),
- field_id: field_id.into(),
- logical_type: logical_type.into(),
- }
- }
-}
-
-impl crate::thrift::TSerializable for SchemaElement {
- fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<SchemaElement> {
- i_prot.read_struct_begin()?;
- let mut f_1: Option<Type> = None;
- let mut f_2: Option<i32> = None;
- let mut f_3: Option<FieldRepetitionType> = None;
- let mut f_4: Option<String> = None;
- let mut f_5: Option<i32> = None;
- let mut f_6: Option<ConvertedType> = None;
- let mut f_7: Option<i32> = None;
- let mut f_8: Option<i32> = None;
- let mut f_9: Option<i32> = None;
- let mut f_10: Option<LogicalType> = None;
- loop {
- let field_ident = i_prot.read_field_begin()?;
- if field_ident.field_type == TType::Stop {
- break;
- }
- let field_id = field_id(&field_ident)?;
- match field_id {
- 1 => {
- let val = Type::read_from_in_protocol(i_prot)?;
- f_1 = Some(val);
- },
- 2 => {
- let val = i_prot.read_i32()?;
- f_2 = Some(val);
- },
- 3 => {
- let val = FieldRepetitionType::read_from_in_protocol(i_prot)?;
- f_3 = Some(val);
- },
- 4 => {
- let val = i_prot.read_string()?;
- f_4 = Some(val);
- },
- 5 => {
- let val = i_prot.read_i32()?;
- f_5 = Some(val);
- },
- 6 => {
- let val = ConvertedType::read_from_in_protocol(i_prot)?;
- f_6 = Some(val);
- },
- 7 => {
- let val = i_prot.read_i32()?;
- f_7 = Some(val);
- },
- 8 => {
- let val = i_prot.read_i32()?;
- f_8 = Some(val);
- },
- 9 => {
- let val = i_prot.read_i32()?;
- f_9 = Some(val);
- },
- 10 => {
- let val = LogicalType::read_from_in_protocol(i_prot)?;
- f_10 = Some(val);
- },
- _ => {
- i_prot.skip(field_ident.field_type)?;
- },
- };
- i_prot.read_field_end()?;
- }
- i_prot.read_struct_end()?;
- verify_required_field_exists("SchemaElement.name", &f_4)?;
- let ret = SchemaElement {
- type_: f_1,
- type_length: f_2,
- repetition_type: f_3,
- name: f_4.expect("auto-generated code should have checked for presence of required fields"),
- num_children: f_5,
- converted_type: f_6,
- scale: f_7,
- precision: f_8,
- field_id: f_9,
- logical_type: f_10,
- };
- Ok(ret)
- }
- fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
- let struct_ident = TStructIdentifier::new("SchemaElement");
- o_prot.write_struct_begin(&struct_ident)?;
- if let Some(ref fld_var) = self.type_ {
- o_prot.write_field_begin(&TFieldIdentifier::new("type", TType::I32, 1))?;
- fld_var.write_to_out_protocol(o_prot)?;
- o_prot.write_field_end()?
- }
- if let Some(fld_var) = self.type_length {
- o_prot.write_field_begin(&TFieldIdentifier::new("type_length", TType::I32, 2))?;
- o_prot.write_i32(fld_var)?;
- o_prot.write_field_end()?
- }
- if let Some(ref fld_var) = self.repetition_type {
- o_prot.write_field_begin(&TFieldIdentifier::new("repetition_type", TType::I32, 3))?;
- fld_var.write_to_out_protocol(o_prot)?;
- o_prot.write_field_end()?
- }
- o_prot.write_field_begin(&TFieldIdentifier::new("name", TType::String, 4))?;
- o_prot.write_string(&self.name)?;
- o_prot.write_field_end()?;
- if let Some(fld_var) = self.num_children {
- o_prot.write_field_begin(&TFieldIdentifier::new("num_children", TType::I32, 5))?;
- o_prot.write_i32(fld_var)?;
- o_prot.write_field_end()?
- }
- if let Some(ref fld_var) = self.converted_type {
- o_prot.write_field_begin(&TFieldIdentifier::new("converted_type", TType::I32, 6))?;
- fld_var.write_to_out_protocol(o_prot)?;
- o_prot.write_field_end()?
- }
- if let Some(fld_var) = self.scale {
- o_prot.write_field_begin(&TFieldIdentifier::new("scale", TType::I32, 7))?;
- o_prot.write_i32(fld_var)?;
- o_prot.write_field_end()?
- }
- if let Some(fld_var) = self.precision {
- o_prot.write_field_begin(&TFieldIdentifier::new("precision", TType::I32, 8))?;
- o_prot.write_i32(fld_var)?;
- o_prot.write_field_end()?
- }
- if let Some(fld_var) = self.field_id {
- o_prot.write_field_begin(&TFieldIdentifier::new("field_id", TType::I32, 9))?;
- o_prot.write_i32(fld_var)?;
- o_prot.write_field_end()?
- }
- if let Some(ref fld_var) = self.logical_type {
- o_prot.write_field_begin(&TFieldIdentifier::new("logicalType", TType::Struct, 10))?;
- fld_var.write_to_out_protocol(o_prot)?;
- o_prot.write_field_end()?
- }
- o_prot.write_field_stop()?;
- o_prot.write_struct_end()
- }
-}
-
-//
-// DataPageHeader
-//
-
-/// Data page header
-#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct DataPageHeader {
- /// Number of values, including NULLs, in this data page.
- ///
- /// If a OffsetIndex is present, a page must begin at a row
- /// boundary (repetition_level = 0). Otherwise, pages may begin
- /// within a row (repetition_level > 0).
- ///
- pub num_values: i32,
- /// Encoding used for this data page *
- pub encoding: Encoding,
- /// Encoding used for definition levels *
- pub definition_level_encoding: Encoding,
- /// Encoding used for repetition levels *
- pub repetition_level_encoding: Encoding,
- /// Optional statistics for the data in this page *
- pub statistics: Option<Statistics>,
-}
-
-impl DataPageHeader {
- pub fn new<F5>(num_values: i32, encoding: Encoding, definition_level_encoding: Encoding, repetition_level_encoding: Encoding, statistics: F5) -> DataPageHeader where F5: Into<Option<Statistics>> {
- DataPageHeader {
- num_values,
- encoding,
- definition_level_encoding,
- repetition_level_encoding,
- statistics: statistics.into(),
- }
- }
-}
-
-impl crate::thrift::TSerializable for DataPageHeader {
- fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<DataPageHeader> {
- i_prot.read_struct_begin()?;
- let mut f_1: Option<i32> = None;
- let mut f_2: Option<Encoding> = None;
- let mut f_3: Option<Encoding> = None;
- let mut f_4: Option<Encoding> = None;
- let mut f_5: Option<Statistics> = None;
- loop {
- let field_ident = i_prot.read_field_begin()?;
- if field_ident.field_type == TType::Stop {
- break;
- }
- let field_id = field_id(&field_ident)?;
- match field_id {
- 1 => {
- let val = i_prot.read_i32()?;
- f_1 = Some(val);
- },
- 2 => {
- let val = Encoding::read_from_in_protocol(i_prot)?;
- f_2 = Some(val);
- },
- 3 => {
- let val = Encoding::read_from_in_protocol(i_prot)?;
- f_3 = Some(val);
- },
- 4 => {
- let val = Encoding::read_from_in_protocol(i_prot)?;
- f_4 = Some(val);
- },
- 5 => {
- let val = Statistics::read_from_in_protocol(i_prot)?;
- f_5 = Some(val);
- },
- _ => {
- i_prot.skip(field_ident.field_type)?;
- },
- };
- i_prot.read_field_end()?;
- }
- i_prot.read_struct_end()?;
- verify_required_field_exists("DataPageHeader.num_values", &f_1)?;
- verify_required_field_exists("DataPageHeader.encoding", &f_2)?;
- verify_required_field_exists("DataPageHeader.definition_level_encoding", &f_3)?;
- verify_required_field_exists("DataPageHeader.repetition_level_encoding", &f_4)?;
- let ret = DataPageHeader {
- num_values: f_1.expect("auto-generated code should have checked for presence of required fields"),
- encoding: f_2.expect("auto-generated code should have checked for presence of required fields"),
- definition_level_encoding: f_3.expect("auto-generated code should have checked for presence of required fields"),
- repetition_level_encoding: f_4.expect("auto-generated code should have checked for presence of required fields"),
- statistics: f_5,
- };
- Ok(ret)
- }
- fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
- let struct_ident = TStructIdentifier::new("DataPageHeader");
- o_prot.write_struct_begin(&struct_ident)?;
- o_prot.write_field_begin(&TFieldIdentifier::new("num_values", TType::I32, 1))?;
- o_prot.write_i32(self.num_values)?;
- o_prot.write_field_end()?;
- o_prot.write_field_begin(&TFieldIdentifier::new("encoding", TType::I32, 2))?;
- self.encoding.write_to_out_protocol(o_prot)?;
- o_prot.write_field_end()?;
- o_prot.write_field_begin(&TFieldIdentifier::new("definition_level_encoding", TType::I32, 3))?;
- self.definition_level_encoding.write_to_out_protocol(o_prot)?;
- o_prot.write_field_end()?;
- o_prot.write_field_begin(&TFieldIdentifier::new("repetition_level_encoding", TType::I32, 4))?;
- self.repetition_level_encoding.write_to_out_protocol(o_prot)?;
- o_prot.write_field_end()?;
- if let Some(ref fld_var) = self.statistics {
- o_prot.write_field_begin(&TFieldIdentifier::new("statistics", TType::Struct, 5))?;
- fld_var.write_to_out_protocol(o_prot)?;
- o_prot.write_field_end()?
- }
- o_prot.write_field_stop()?;
- o_prot.write_struct_end()
- }
-}
-
-//
-// IndexPageHeader
-//
-
-#[derive(Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct IndexPageHeader {
-}
-
-impl IndexPageHeader {
- pub fn new() -> IndexPageHeader {
- IndexPageHeader {}
- }
-}
-
-impl crate::thrift::TSerializable for IndexPageHeader {
- fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<IndexPageHeader> {
- i_prot.read_struct_begin()?;
- loop {
- let field_ident = i_prot.read_field_begin()?;
- if field_ident.field_type == TType::Stop {
- break;
- }
- i_prot.skip(field_ident.field_type)?;
- i_prot.read_field_end()?;
- }
- i_prot.read_struct_end()?;
- let ret = IndexPageHeader {};
- Ok(ret)
- }
- fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
- let struct_ident = TStructIdentifier::new("IndexPageHeader");
- o_prot.write_struct_begin(&struct_ident)?;
- o_prot.write_field_stop()?;
- o_prot.write_struct_end()
- }
-}
-
-//
-// DictionaryPageHeader
-//
-
-/// The dictionary page must be placed at the first position of the column chunk
-/// if it is partly or completely dictionary encoded. At most one dictionary page
-/// can be placed in a column chunk.
-///
-#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct DictionaryPageHeader {
- /// Number of values in the dictionary *
- pub num_values: i32,
- /// Encoding using this dictionary page *
- pub encoding: Encoding,
- /// If true, the entries in the dictionary are sorted in ascending order *
- pub is_sorted: Option<bool>,
-}
-
-impl DictionaryPageHeader {
- pub fn new<F3>(num_values: i32, encoding: Encoding, is_sorted: F3) -> DictionaryPageHeader where F3: Into<Option<bool>> {
- DictionaryPageHeader {
- num_values,
- encoding,
- is_sorted: is_sorted.into(),
- }
- }
-}
-
-impl crate::thrift::TSerializable for DictionaryPageHeader {
- fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<DictionaryPageHeader> {
- i_prot.read_struct_begin()?;
- let mut f_1: Option<i32> = None;
- let mut f_2: Option<Encoding> = None;
- let mut f_3: Option<bool> = None;
- loop {
- let field_ident = i_prot.read_field_begin()?;
- if field_ident.field_type == TType::Stop {
- break;
- }
- let field_id = field_id(&field_ident)?;
- match field_id {
- 1 => {
- let val = i_prot.read_i32()?;
- f_1 = Some(val);
- },
- 2 => {
- let val = Encoding::read_from_in_protocol(i_prot)?;
- f_2 = Some(val);
- },
- 3 => {
- let val = i_prot.read_bool()?;
- f_3 = Some(val);
- },
- _ => {
- i_prot.skip(field_ident.field_type)?;
- },
- };
- i_prot.read_field_end()?;
- }
- i_prot.read_struct_end()?;
- verify_required_field_exists("DictionaryPageHeader.num_values", &f_1)?;
- verify_required_field_exists("DictionaryPageHeader.encoding", &f_2)?;
- let ret = DictionaryPageHeader {
- num_values: f_1.expect("auto-generated code should have checked for presence of required fields"),
- encoding: f_2.expect("auto-generated code should have checked for presence of required fields"),
- is_sorted: f_3,
- };
- Ok(ret)
- }
- fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
- let struct_ident = TStructIdentifier::new("DictionaryPageHeader");
- o_prot.write_struct_begin(&struct_ident)?;
- o_prot.write_field_begin(&TFieldIdentifier::new("num_values", TType::I32, 1))?;
- o_prot.write_i32(self.num_values)?;
- o_prot.write_field_end()?;
- o_prot.write_field_begin(&TFieldIdentifier::new("encoding", TType::I32, 2))?;
- self.encoding.write_to_out_protocol(o_prot)?;
- o_prot.write_field_end()?;
- if let Some(fld_var) = self.is_sorted {
- o_prot.write_field_begin(&TFieldIdentifier::new("is_sorted", TType::Bool, 3))?;
- o_prot.write_bool(fld_var)?;
- o_prot.write_field_end()?
- }
- o_prot.write_field_stop()?;
- o_prot.write_struct_end()
- }
-}
-
-//
-// DataPageHeaderV2
-//
-
-/// New page format allowing reading levels without decompressing the data
-/// Repetition and definition levels are uncompressed
-/// The remaining section containing the data is compressed if is_compressed is true
-///
-#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct DataPageHeaderV2 {
- /// Number of values, including NULLs, in this data page. *
- pub num_values: i32,
- /// Number of NULL values, in this data page.
- /// Number of non-null = num_values - num_nulls which is also the number of values in the data section *
- pub num_nulls: i32,
- /// Number of rows in this data page. Every page must begin at a
- /// row boundary (repetition_level = 0): rows must **not** be
- /// split across page boundaries when using V2 data pages.
- ///
- pub num_rows: i32,
- /// Encoding used for data in this page *
- pub encoding: Encoding,
- /// Length of the definition levels
- pub definition_levels_byte_length: i32,
- /// Length of the repetition levels
- pub repetition_levels_byte_length: i32,
- /// Whether the values are compressed.
- /// Which means the section of the page between
- /// definition_levels_byte_length + repetition_levels_byte_length + 1 and compressed_page_size (included)
- /// is compressed with the compression_codec.
- /// If missing it is considered compressed
- pub is_compressed: Option<bool>,
- /// Optional statistics for the data in this page *
- pub statistics: Option<Statistics>,
-}
-
-impl DataPageHeaderV2 {
- pub fn new<F7, F8>(num_values: i32, num_nulls: i32, num_rows: i32, encoding: Encoding, definition_levels_byte_length: i32, repetition_levels_byte_length: i32, is_compressed: F7, statistics: F8) -> DataPageHeaderV2 where F7: Into<Option<bool>>, F8: Into<Option<Statistics>> {
- DataPageHeaderV2 {
- num_values,
- num_nulls,
- num_rows,
- encoding,
- definition_levels_byte_length,
- repetition_levels_byte_length,
- is_compressed: is_compressed.into(),
- statistics: statistics.into(),
- }
- }
-}
-
-impl crate::thrift::TSerializable for DataPageHeaderV2 {
- fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<DataPageHeaderV2> {
- i_prot.read_struct_begin()?;
- let mut f_1: Option<i32> = None;
- let mut f_2: Option<i32> = None;
- let mut f_3: Option<i32> = None;
- let mut f_4: Option<Encoding> = None;
- let mut f_5: Option<i32> = None;
- let mut f_6: Option<i32> = None;
- let mut f_7: Option<bool> = None;
- let mut f_8: Option<Statistics> = None;
- loop {
- let field_ident = i_prot.read_field_begin()?;
- if field_ident.field_type == TType::Stop {
- break;
- }
- let field_id = field_id(&field_ident)?;
- match field_id {
- 1 => {
- let val = i_prot.read_i32()?;
- f_1 = Some(val);
- },
- 2 => {
- let val = i_prot.read_i32()?;
- f_2 = Some(val);
- },
- 3 => {
- let val = i_prot.read_i32()?;
- f_3 = Some(val);
- },
- 4 => {
- let val = Encoding::read_from_in_protocol(i_prot)?;
- f_4 = Some(val);
- },
- 5 => {
- let val = i_prot.read_i32()?;
- f_5 = Some(val);
- },
- 6 => {
- let val = i_prot.read_i32()?;
- f_6 = Some(val);
- },
- 7 => {
- let val = i_prot.read_bool()?;
- f_7 = Some(val);
- },
- 8 => {
- let val = Statistics::read_from_in_protocol(i_prot)?;
- f_8 = Some(val);
- },
- _ => {
- i_prot.skip(field_ident.field_type)?;
- },
- };
- i_prot.read_field_end()?;
- }
- i_prot.read_struct_end()?;
- verify_required_field_exists("DataPageHeaderV2.num_values", &f_1)?;
- verify_required_field_exists("DataPageHeaderV2.num_nulls", &f_2)?;
- verify_required_field_exists("DataPageHeaderV2.num_rows", &f_3)?;
- verify_required_field_exists("DataPageHeaderV2.encoding", &f_4)?;
- verify_required_field_exists("DataPageHeaderV2.definition_levels_byte_length", &f_5)?;
- verify_required_field_exists("DataPageHeaderV2.repetition_levels_byte_length", &f_6)?;
- let ret = DataPageHeaderV2 {
- num_values: f_1.expect("auto-generated code should have checked for presence of required fields"),
- num_nulls: f_2.expect("auto-generated code should have checked for presence of required fields"),
- num_rows: f_3.expect("auto-generated code should have checked for presence of required fields"),
- encoding: f_4.expect("auto-generated code should have checked for presence of required fields"),
- definition_levels_byte_length: f_5.expect("auto-generated code should have checked for presence of required fields"),
- repetition_levels_byte_length: f_6.expect("auto-generated code should have checked for presence of required fields"),
- is_compressed: f_7,
- statistics: f_8,
- };
- Ok(ret)
- }
- fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
- let struct_ident = TStructIdentifier::new("DataPageHeaderV2");
- o_prot.write_struct_begin(&struct_ident)?;
- o_prot.write_field_begin(&TFieldIdentifier::new("num_values", TType::I32, 1))?;
- o_prot.write_i32(self.num_values)?;
- o_prot.write_field_end()?;
- o_prot.write_field_begin(&TFieldIdentifier::new("num_nulls", TType::I32, 2))?;
- o_prot.write_i32(self.num_nulls)?;
- o_prot.write_field_end()?;
- o_prot.write_field_begin(&TFieldIdentifier::new("num_rows", TType::I32, 3))?;
- o_prot.write_i32(self.num_rows)?;
- o_prot.write_field_end()?;
- o_prot.write_field_begin(&TFieldIdentifier::new("encoding", TType::I32, 4))?;
- self.encoding.write_to_out_protocol(o_prot)?;
- o_prot.write_field_end()?;
- o_prot.write_field_begin(&TFieldIdentifier::new("definition_levels_byte_length", TType::I32, 5))?;
- o_prot.write_i32(self.definition_levels_byte_length)?;
- o_prot.write_field_end()?;
- o_prot.write_field_begin(&TFieldIdentifier::new("repetition_levels_byte_length", TType::I32, 6))?;
- o_prot.write_i32(self.repetition_levels_byte_length)?;
- o_prot.write_field_end()?;
- if let Some(fld_var) = self.is_compressed {
- o_prot.write_field_begin(&TFieldIdentifier::new("is_compressed", TType::Bool, 7))?;
- o_prot.write_bool(fld_var)?;
- o_prot.write_field_end()?
- }
- if let Some(ref fld_var) = self.statistics {
- o_prot.write_field_begin(&TFieldIdentifier::new("statistics", TType::Struct, 8))?;
- fld_var.write_to_out_protocol(o_prot)?;
- o_prot.write_field_end()?
- }
- o_prot.write_field_stop()?;
- o_prot.write_struct_end()
- }
-}
-
-//
-// SplitBlockAlgorithm
-//
-
-/// Block-based algorithm type annotation. *
-#[derive(Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct SplitBlockAlgorithm {
-}
-
-impl SplitBlockAlgorithm {
- pub fn new() -> SplitBlockAlgorithm {
- SplitBlockAlgorithm {}
- }
-}
-
-impl crate::thrift::TSerializable for SplitBlockAlgorithm {
- fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<SplitBlockAlgorithm> {
- i_prot.read_struct_begin()?;
- loop {
- let field_ident = i_prot.read_field_begin()?;
- if field_ident.field_type == TType::Stop {
- break;
- }
- i_prot.skip(field_ident.field_type)?;
- i_prot.read_field_end()?;
- }
- i_prot.read_struct_end()?;
- let ret = SplitBlockAlgorithm {};
- Ok(ret)
- }
- fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
- let struct_ident = TStructIdentifier::new("SplitBlockAlgorithm");
- o_prot.write_struct_begin(&struct_ident)?;
- o_prot.write_field_stop()?;
- o_prot.write_struct_end()
- }
-}
-
-//
-// BloomFilterAlgorithm
-//
-
-#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub enum BloomFilterAlgorithm {
- BLOCK(SplitBlockAlgorithm),
-}
-
-impl crate::thrift::TSerializable for BloomFilterAlgorithm {
- fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<BloomFilterAlgorithm> {
- let mut ret: Option<BloomFilterAlgorithm> = None;
- let mut received_field_count = 0;
- i_prot.read_struct_begin()?;
- loop {
- let field_ident = i_prot.read_field_begin()?;
- if field_ident.field_type == TType::Stop {
- break;
- }
- let field_id = field_id(&field_ident)?;
- match field_id {
- 1 => {
- let val = SplitBlockAlgorithm::read_from_in_protocol(i_prot)?;
- if ret.is_none() {
- ret = Some(BloomFilterAlgorithm::BLOCK(val));
- }
- received_field_count += 1;
- },
- _ => {
- i_prot.skip(field_ident.field_type)?;
- received_field_count += 1;
- },
- };
- i_prot.read_field_end()?;
- }
- i_prot.read_struct_end()?;
- if received_field_count == 0 {
- Err(
- thrift::Error::Protocol(
- ProtocolError::new(
- ProtocolErrorKind::InvalidData,
- "received empty union from remote BloomFilterAlgorithm"
- )
- )
- )
- } else if received_field_count > 1 {
- Err(
- thrift::Error::Protocol(
- ProtocolError::new(
- ProtocolErrorKind::InvalidData,
- "received multiple fields for union from remote BloomFilterAlgorithm"
- )
- )
- )
- } else {
- ret.ok_or_else(|| thrift::Error::Protocol(ProtocolError::new(ProtocolErrorKind::InvalidData, "return value should have been constructed")))
- }
- }
- fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
- let struct_ident = TStructIdentifier::new("BloomFilterAlgorithm");
- o_prot.write_struct_begin(&struct_ident)?;
- match *self {
- BloomFilterAlgorithm::BLOCK(ref f) => {
- o_prot.write_field_begin(&TFieldIdentifier::new("BLOCK", TType::Struct, 1))?;
- f.write_to_out_protocol(o_prot)?;
- o_prot.write_field_end()?;
- },
- }
- o_prot.write_field_stop()?;
- o_prot.write_struct_end()
- }
-}
-
-//
-// XxHash
-//
-
-/// Hash strategy type annotation. xxHash is an extremely fast non-cryptographic hash
-/// algorithm. It uses 64 bits version of xxHash.
-///
-#[derive(Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct XxHash {
-}
-
-impl XxHash {
- pub fn new() -> XxHash {
- XxHash {}
- }
-}
-
-impl crate::thrift::TSerializable for XxHash {
- fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<XxHash> {
- i_prot.read_struct_begin()?;
- loop {
- let field_ident = i_prot.read_field_begin()?;
- if field_ident.field_type == TType::Stop {
- break;
- }
- i_prot.skip(field_ident.field_type)?;
- i_prot.read_field_end()?;
- }
- i_prot.read_struct_end()?;
- let ret = XxHash {};
- Ok(ret)
- }
- fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
- let struct_ident = TStructIdentifier::new("XxHash");
- o_prot.write_struct_begin(&struct_ident)?;
- o_prot.write_field_stop()?;
- o_prot.write_struct_end()
- }
-}
-
-//
-// BloomFilterHash
-//
-
-#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub enum BloomFilterHash {
- XXHASH(XxHash),
-}
-
-impl crate::thrift::TSerializable for BloomFilterHash {
- fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<BloomFilterHash> {
- let mut ret: Option<BloomFilterHash> = None;
- let mut received_field_count = 0;
- i_prot.read_struct_begin()?;
- loop {
- let field_ident = i_prot.read_field_begin()?;
- if field_ident.field_type == TType::Stop {
- break;
- }
- let field_id = field_id(&field_ident)?;
- match field_id {
- 1 => {
- let val = XxHash::read_from_in_protocol(i_prot)?;
- if ret.is_none() {
- ret = Some(BloomFilterHash::XXHASH(val));
- }
- received_field_count += 1;
- },
- _ => {
- i_prot.skip(field_ident.field_type)?;
- received_field_count += 1;
- },
- };
- i_prot.read_field_end()?;
- }
- i_prot.read_struct_end()?;
- if received_field_count == 0 {
- Err(
- thrift::Error::Protocol(
- ProtocolError::new(
- ProtocolErrorKind::InvalidData,
- "received empty union from remote BloomFilterHash"
- )
- )
- )
- } else if received_field_count > 1 {
- Err(
- thrift::Error::Protocol(
- ProtocolError::new(
- ProtocolErrorKind::InvalidData,
- "received multiple fields for union from remote BloomFilterHash"
- )
- )
- )
- } else {
- ret.ok_or_else(|| thrift::Error::Protocol(ProtocolError::new(ProtocolErrorKind::InvalidData, "return value should have been constructed")))
- }
- }
- fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
- let struct_ident = TStructIdentifier::new("BloomFilterHash");
- o_prot.write_struct_begin(&struct_ident)?;
- match *self {
- BloomFilterHash::XXHASH(ref f) => {
- o_prot.write_field_begin(&TFieldIdentifier::new("XXHASH", TType::Struct, 1))?;
- f.write_to_out_protocol(o_prot)?;
- o_prot.write_field_end()?;
- },
- }
- o_prot.write_field_stop()?;
- o_prot.write_struct_end()
- }
-}
-
-//
-// Uncompressed
-//
-
-/// The compression used in the Bloom filter.
-///
-#[derive(Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct Uncompressed {
-}
-
-impl Uncompressed {
- pub fn new() -> Uncompressed {
- Uncompressed {}
- }
-}
-
-impl crate::thrift::TSerializable for Uncompressed {
- fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<Uncompressed> {
- i_prot.read_struct_begin()?;
- loop {
- let field_ident = i_prot.read_field_begin()?;
- if field_ident.field_type == TType::Stop {
- break;
- }
- i_prot.skip(field_ident.field_type)?;
- i_prot.read_field_end()?;
- }
- i_prot.read_struct_end()?;
- let ret = Uncompressed {};
- Ok(ret)
- }
- fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
- let struct_ident = TStructIdentifier::new("Uncompressed");
- o_prot.write_struct_begin(&struct_ident)?;
- o_prot.write_field_stop()?;
- o_prot.write_struct_end()
- }
-}
-
-//
-// BloomFilterCompression
-//
-
-#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub enum BloomFilterCompression {
- UNCOMPRESSED(Uncompressed),
-}
-
-impl crate::thrift::TSerializable for BloomFilterCompression {
- fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<BloomFilterCompression> {
- let mut ret: Option<BloomFilterCompression> = None;
- let mut received_field_count = 0;
- i_prot.read_struct_begin()?;
- loop {
- let field_ident = i_prot.read_field_begin()?;
- if field_ident.field_type == TType::Stop {
- break;
- }
- let field_id = field_id(&field_ident)?;
- match field_id {
- 1 => {
- let val = Uncompressed::read_from_in_protocol(i_prot)?;
- if ret.is_none() {
- ret = Some(BloomFilterCompression::UNCOMPRESSED(val));
- }
- received_field_count += 1;
- },
- _ => {
- i_prot.skip(field_ident.field_type)?;
- received_field_count += 1;
- },
- };
- i_prot.read_field_end()?;
- }
- i_prot.read_struct_end()?;
- if received_field_count == 0 {
- Err(
- thrift::Error::Protocol(
- ProtocolError::new(
- ProtocolErrorKind::InvalidData,
- "received empty union from remote BloomFilterCompression"
- )
- )
- )
- } else if received_field_count > 1 {
- Err(
- thrift::Error::Protocol(
- ProtocolError::new(
- ProtocolErrorKind::InvalidData,
- "received multiple fields for union from remote BloomFilterCompression"
- )
- )
- )
- } else {
- ret.ok_or_else(|| thrift::Error::Protocol(ProtocolError::new(ProtocolErrorKind::InvalidData, "return value should have been constructed")))
- }
- }
- fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
- let struct_ident = TStructIdentifier::new("BloomFilterCompression");
- o_prot.write_struct_begin(&struct_ident)?;
- match *self {
- BloomFilterCompression::UNCOMPRESSED(ref f) => {
- o_prot.write_field_begin(&TFieldIdentifier::new("UNCOMPRESSED", TType::Struct, 1))?;
- f.write_to_out_protocol(o_prot)?;
- o_prot.write_field_end()?;
- },
- }
- o_prot.write_field_stop()?;
- o_prot.write_struct_end()
- }
-}
-
-//
-// BloomFilterHeader
-//
-
-/// Bloom filter header is stored at beginning of Bloom filter data of each column
-/// and followed by its bitset.
-///
-#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct BloomFilterHeader {
- /// The size of bitset in bytes *
- pub num_bytes: i32,
- /// The algorithm for setting bits. *
- pub algorithm: BloomFilterAlgorithm,
- /// The hash function used for Bloom filter. *
- pub hash: BloomFilterHash,
- /// The compression used in the Bloom filter *
- pub compression: BloomFilterCompression,
-}
-
-impl BloomFilterHeader {
- pub fn new(num_bytes: i32, algorithm: BloomFilterAlgorithm, hash: BloomFilterHash, compression: BloomFilterCompression) -> BloomFilterHeader {
- BloomFilterHeader {
- num_bytes,
- algorithm,
- hash,
- compression,
- }
- }
-}
-
-impl crate::thrift::TSerializable for BloomFilterHeader {
- fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<BloomFilterHeader> {
- i_prot.read_struct_begin()?;
- let mut f_1: Option<i32> = None;
- let mut f_2: Option<BloomFilterAlgorithm> = None;
- let mut f_3: Option<BloomFilterHash> = None;
- let mut f_4: Option<BloomFilterCompression> = None;
- loop {
- let field_ident = i_prot.read_field_begin()?;
- if field_ident.field_type == TType::Stop {
- break;
- }
- let field_id = field_id(&field_ident)?;
- match field_id {
- 1 => {
- let val = i_prot.read_i32()?;
- f_1 = Some(val);
- },
- 2 => {
- let val = BloomFilterAlgorithm::read_from_in_protocol(i_prot)?;
- f_2 = Some(val);
- },
- 3 => {
- let val = BloomFilterHash::read_from_in_protocol(i_prot)?;
- f_3 = Some(val);
- },
- 4 => {
- let val = BloomFilterCompression::read_from_in_protocol(i_prot)?;
- f_4 = Some(val);
- },
- _ => {
- i_prot.skip(field_ident.field_type)?;
- },
- };
- i_prot.read_field_end()?;
- }
- i_prot.read_struct_end()?;
- verify_required_field_exists("BloomFilterHeader.num_bytes", &f_1)?;
- verify_required_field_exists("BloomFilterHeader.algorithm", &f_2)?;
- verify_required_field_exists("BloomFilterHeader.hash", &f_3)?;
- verify_required_field_exists("BloomFilterHeader.compression", &f_4)?;
- let ret = BloomFilterHeader {
- num_bytes: f_1.expect("auto-generated code should have checked for presence of required fields"),
- algorithm: f_2.expect("auto-generated code should have checked for presence of required fields"),
- hash: f_3.expect("auto-generated code should have checked for presence of required fields"),
- compression: f_4.expect("auto-generated code should have checked for presence of required fields"),
- };
- Ok(ret)
- }
- fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
- let struct_ident = TStructIdentifier::new("BloomFilterHeader");
- o_prot.write_struct_begin(&struct_ident)?;
- o_prot.write_field_begin(&TFieldIdentifier::new("numBytes", TType::I32, 1))?;
- o_prot.write_i32(self.num_bytes)?;
- o_prot.write_field_end()?;
- o_prot.write_field_begin(&TFieldIdentifier::new("algorithm", TType::Struct, 2))?;
- self.algorithm.write_to_out_protocol(o_prot)?;
- o_prot.write_field_end()?;
- o_prot.write_field_begin(&TFieldIdentifier::new("hash", TType::Struct, 3))?;
- self.hash.write_to_out_protocol(o_prot)?;
- o_prot.write_field_end()?;
- o_prot.write_field_begin(&TFieldIdentifier::new("compression", TType::Struct, 4))?;
- self.compression.write_to_out_protocol(o_prot)?;
- o_prot.write_field_end()?;
- o_prot.write_field_stop()?;
- o_prot.write_struct_end()
- }
-}
-
-//
-// PageHeader
-//
-
-#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct PageHeader {
- /// the type of the page: indicates which of the *_header fields is set *
- pub type_: PageType,
- /// Uncompressed page size in bytes (not including this header) *
- pub uncompressed_page_size: i32,
- /// Compressed (and potentially encrypted) page size in bytes, not including this header *
- pub compressed_page_size: i32,
- /// The 32-bit CRC checksum for the page, to be be calculated as follows:
- ///
- /// - The standard CRC32 algorithm is used (with polynomial 0x04C11DB7,
- /// the same as in e.g. GZip).
- /// - All page types can have a CRC (v1 and v2 data pages, dictionary pages,
- /// etc.).
- /// - The CRC is computed on the serialization binary representation of the page
- /// (as written to disk), excluding the page header. For example, for v1
- /// data pages, the CRC is computed on the concatenation of repetition levels,
- /// definition levels and column values (optionally compressed, optionally
- /// encrypted).
- /// - The CRC computation therefore takes place after any compression
- /// and encryption steps, if any.
- ///
- /// If enabled, this allows for disabling checksumming in HDFS if only a few
- /// pages need to be read.
- pub crc: Option<i32>,
- pub data_page_header: Option<DataPageHeader>,
- pub index_page_header: Option<IndexPageHeader>,
- pub dictionary_page_header: Option<DictionaryPageHeader>,
- pub data_page_header_v2: Option<DataPageHeaderV2>,
-}
-
-impl PageHeader {
- pub fn new<F4, F5, F6, F7, F8>(type_: PageType, uncompressed_page_size: i32, compressed_page_size: i32, crc: F4, data_page_header: F5, index_page_header: F6, dictionary_page_header: F7, data_page_header_v2: F8) -> PageHeader where F4: Into<Option<i32>>, F5: Into<Option<DataPageHeader>>, F6: Into<Option<IndexPageHeader>>, F7: Into<Option<DictionaryPageHeader>>, F8: Into<Option<DataPageHeaderV2>> {
- PageHeader {
- type_,
- uncompressed_page_size,
- compressed_page_size,
- crc: crc.into(),
- data_page_header: data_page_header.into(),
- index_page_header: index_page_header.into(),
- dictionary_page_header: dictionary_page_header.into(),
- data_page_header_v2: data_page_header_v2.into(),
- }
- }
-}
-
-impl crate::thrift::TSerializable for PageHeader {
- fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<PageHeader> {
- i_prot.read_struct_begin()?;
- let mut f_1: Option<PageType> = None;
- let mut f_2: Option<i32> = None;
- let mut f_3: Option<i32> = None;
- let mut f_4: Option<i32> = None;
- let mut f_5: Option<DataPageHeader> = None;
- let mut f_6: Option<IndexPageHeader> = None;
- let mut f_7: Option<DictionaryPageHeader> = None;
- let mut f_8: Option<DataPageHeaderV2> = None;
- loop {
- let field_ident = i_prot.read_field_begin()?;
- if field_ident.field_type == TType::Stop {
- break;
- }
- let field_id = field_id(&field_ident)?;
- match field_id {
- 1 => {
- let val = PageType::read_from_in_protocol(i_prot)?;
- f_1 = Some(val);
- },
- 2 => {
- let val = i_prot.read_i32()?;
- f_2 = Some(val);
- },
- 3 => {
- let val = i_prot.read_i32()?;
- f_3 = Some(val);
- },
- 4 => {
- let val = i_prot.read_i32()?;
- f_4 = Some(val);
- },
- 5 => {
- let val = DataPageHeader::read_from_in_protocol(i_prot)?;
- f_5 = Some(val);
- },
- 6 => {
- let val = IndexPageHeader::read_from_in_protocol(i_prot)?;
- f_6 = Some(val);
- },
- 7 => {
- let val = DictionaryPageHeader::read_from_in_protocol(i_prot)?;
- f_7 = Some(val);
- },
- 8 => {
- let val = DataPageHeaderV2::read_from_in_protocol(i_prot)?;
- f_8 = Some(val);
- },
- _ => {
- i_prot.skip(field_ident.field_type)?;
- },
- };
- i_prot.read_field_end()?;
- }
- i_prot.read_struct_end()?;
- verify_required_field_exists("PageHeader.type_", &f_1)?;
- verify_required_field_exists("PageHeader.uncompressed_page_size", &f_2)?;
- verify_required_field_exists("PageHeader.compressed_page_size", &f_3)?;
- let ret = PageHeader {
- type_: f_1.expect("auto-generated code should have checked for presence of required fields"),
- uncompressed_page_size: f_2.expect("auto-generated code should have checked for presence of required fields"),
- compressed_page_size: f_3.expect("auto-generated code should have checked for presence of required fields"),
- crc: f_4,
- data_page_header: f_5,
- index_page_header: f_6,
- dictionary_page_header: f_7,
- data_page_header_v2: f_8,
- };
- Ok(ret)
- }
- fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
- let struct_ident = TStructIdentifier::new("PageHeader");
- o_prot.write_struct_begin(&struct_ident)?;
- o_prot.write_field_begin(&TFieldIdentifier::new("type", TType::I32, 1))?;
- self.type_.write_to_out_protocol(o_prot)?;
- o_prot.write_field_end()?;
- o_prot.write_field_begin(&TFieldIdentifier::new("uncompressed_page_size", TType::I32, 2))?;
- o_prot.write_i32(self.uncompressed_page_size)?;
- o_prot.write_field_end()?;
- o_prot.write_field_begin(&TFieldIdentifier::new("compressed_page_size", TType::I32, 3))?;
- o_prot.write_i32(self.compressed_page_size)?;
- o_prot.write_field_end()?;
- if let Some(fld_var) = self.crc {
- o_prot.write_field_begin(&TFieldIdentifier::new("crc", TType::I32, 4))?;
- o_prot.write_i32(fld_var)?;
- o_prot.write_field_end()?
- }
- if let Some(ref fld_var) = self.data_page_header {
- o_prot.write_field_begin(&TFieldIdentifier::new("data_page_header", TType::Struct, 5))?;
- fld_var.write_to_out_protocol(o_prot)?;
- o_prot.write_field_end()?
- }
- if let Some(ref fld_var) = self.index_page_header {
- o_prot.write_field_begin(&TFieldIdentifier::new("index_page_header", TType::Struct, 6))?;
- fld_var.write_to_out_protocol(o_prot)?;
- o_prot.write_field_end()?
- }
- if let Some(ref fld_var) = self.dictionary_page_header {
- o_prot.write_field_begin(&TFieldIdentifier::new("dictionary_page_header", TType::Struct, 7))?;
- fld_var.write_to_out_protocol(o_prot)?;
- o_prot.write_field_end()?
- }
- if let Some(ref fld_var) = self.data_page_header_v2 {
- o_prot.write_field_begin(&TFieldIdentifier::new("data_page_header_v2", TType::Struct, 8))?;
- fld_var.write_to_out_protocol(o_prot)?;
- o_prot.write_field_end()?
- }
- o_prot.write_field_stop()?;
- o_prot.write_struct_end()
- }
-}
-
-//
-// KeyValue
-//
-
-/// Wrapper struct to store key values
-#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct KeyValue {
- pub key: String,
- pub value: Option<String>,
-}
-
-impl KeyValue {
- pub fn new<F2>(key: String, value: F2) -> KeyValue where F2: Into<Option<String>> {
- KeyValue {
- key,
- value: value.into(),
- }
- }
-}
-
-impl crate::thrift::TSerializable for KeyValue {
- fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<KeyValue> {
- i_prot.read_struct_begin()?;
- let mut f_1: Option<String> = None;
- let mut f_2: Option<String> = None;
- loop {
- let field_ident = i_prot.read_field_begin()?;
- if field_ident.field_type == TType::Stop {
- break;
- }
- let field_id = field_id(&field_ident)?;
- match field_id {
- 1 => {
- let val = i_prot.read_string()?;
- f_1 = Some(val);
- },
- 2 => {
- let val = i_prot.read_string()?;
- f_2 = Some(val);
- },
- _ => {
- i_prot.skip(field_ident.field_type)?;
- },
- };
- i_prot.read_field_end()?;
- }
- i_prot.read_struct_end()?;
- verify_required_field_exists("KeyValue.key", &f_1)?;
- let ret = KeyValue {
- key: f_1.expect("auto-generated code should have checked for presence of required fields"),
- value: f_2,
- };
- Ok(ret)
- }
- fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
- let struct_ident = TStructIdentifier::new("KeyValue");
- o_prot.write_struct_begin(&struct_ident)?;
- o_prot.write_field_begin(&TFieldIdentifier::new("key", TType::String, 1))?;
- o_prot.write_string(&self.key)?;
- o_prot.write_field_end()?;
- if let Some(ref fld_var) = self.value {
- o_prot.write_field_begin(&TFieldIdentifier::new("value", TType::String, 2))?;
- o_prot.write_string(fld_var)?;
- o_prot.write_field_end()?
- }
- o_prot.write_field_stop()?;
- o_prot.write_struct_end()
- }
-}
-
-//
-// SortingColumn
-//
-
-/// Sort order within a RowGroup of a leaf column
-#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct SortingColumn {
- /// The ordinal position of the column (in this row group) *
- pub column_idx: i32,
- /// If true, indicates this column is sorted in descending order. *
- pub descending: bool,
- /// If true, nulls will come before non-null values, otherwise,
- /// nulls go at the end.
- pub nulls_first: bool,
-}
-
-impl SortingColumn {
- pub fn new(column_idx: i32, descending: bool, nulls_first: bool) -> SortingColumn {
- SortingColumn {
- column_idx,
- descending,
- nulls_first,
- }
- }
-}
-
-impl crate::thrift::TSerializable for SortingColumn {
- fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<SortingColumn> {
- i_prot.read_struct_begin()?;
- let mut f_1: Option<i32> = None;
- let mut f_2: Option<bool> = None;
- let mut f_3: Option<bool> = None;
- loop {
- let field_ident = i_prot.read_field_begin()?;
- if field_ident.field_type == TType::Stop {
- break;
- }
- let field_id = field_id(&field_ident)?;
- match field_id {
- 1 => {
- let val = i_prot.read_i32()?;
- f_1 = Some(val);
- },
- 2 => {
- let val = i_prot.read_bool()?;
- f_2 = Some(val);
- },
- 3 => {
- let val = i_prot.read_bool()?;
- f_3 = Some(val);
- },
- _ => {
- i_prot.skip(field_ident.field_type)?;
- },
- };
- i_prot.read_field_end()?;
- }
- i_prot.read_struct_end()?;
- verify_required_field_exists("SortingColumn.column_idx", &f_1)?;
- verify_required_field_exists("SortingColumn.descending", &f_2)?;
- verify_required_field_exists("SortingColumn.nulls_first", &f_3)?;
- let ret = SortingColumn {
- column_idx: f_1.expect("auto-generated code should have checked for presence of required fields"),
- descending: f_2.expect("auto-generated code should have checked for presence of required fields"),
- nulls_first: f_3.expect("auto-generated code should have checked for presence of required fields"),
- };
- Ok(ret)
- }
- fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
- let struct_ident = TStructIdentifier::new("SortingColumn");
- o_prot.write_struct_begin(&struct_ident)?;
- o_prot.write_field_begin(&TFieldIdentifier::new("column_idx", TType::I32, 1))?;
- o_prot.write_i32(self.column_idx)?;
- o_prot.write_field_end()?;
- o_prot.write_field_begin(&TFieldIdentifier::new("descending", TType::Bool, 2))?;
- o_prot.write_bool(self.descending)?;
- o_prot.write_field_end()?;
- o_prot.write_field_begin(&TFieldIdentifier::new("nulls_first", TType::Bool, 3))?;
- o_prot.write_bool(self.nulls_first)?;
- o_prot.write_field_end()?;
- o_prot.write_field_stop()?;
- o_prot.write_struct_end()
- }
-}
-
-//
-// PageEncodingStats
-//
-
-/// statistics of a given page type and encoding
-#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct PageEncodingStats {
- /// the page type (data/dic/...) *
- pub page_type: PageType,
- /// encoding of the page *
- pub encoding: Encoding,
- /// number of pages of this type with this encoding *
- pub count: i32,
-}
-
-impl PageEncodingStats {
- pub fn new(page_type: PageType, encoding: Encoding, count: i32) -> PageEncodingStats {
- PageEncodingStats {
- page_type,
- encoding,
- count,
- }
- }
-}
-
-impl crate::thrift::TSerializable for PageEncodingStats {
- fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<PageEncodingStats> {
- i_prot.read_struct_begin()?;
- let mut f_1: Option<PageType> = None;
- let mut f_2: Option<Encoding> = None;
- let mut f_3: Option<i32> = None;
- loop {
- let field_ident = i_prot.read_field_begin()?;
- if field_ident.field_type == TType::Stop {
- break;
- }
- let field_id = field_id(&field_ident)?;
- match field_id {
- 1 => {
- let val = PageType::read_from_in_protocol(i_prot)?;
- f_1 = Some(val);
- },
- 2 => {
- let val = Encoding::read_from_in_protocol(i_prot)?;
- f_2 = Some(val);
- },
- 3 => {
- let val = i_prot.read_i32()?;
- f_3 = Some(val);
- },
- _ => {
- i_prot.skip(field_ident.field_type)?;
- },
- };
- i_prot.read_field_end()?;
- }
- i_prot.read_struct_end()?;
- verify_required_field_exists("PageEncodingStats.page_type", &f_1)?;
- verify_required_field_exists("PageEncodingStats.encoding", &f_2)?;
- verify_required_field_exists("PageEncodingStats.count", &f_3)?;
- let ret = PageEncodingStats {
- page_type: f_1.expect("auto-generated code should have checked for presence of required fields"),
- encoding: f_2.expect("auto-generated code should have checked for presence of required fields"),
- count: f_3.expect("auto-generated code should have checked for presence of required fields"),
- };
- Ok(ret)
- }
- fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
- let struct_ident = TStructIdentifier::new("PageEncodingStats");
- o_prot.write_struct_begin(&struct_ident)?;
- o_prot.write_field_begin(&TFieldIdentifier::new("page_type", TType::I32, 1))?;
- self.page_type.write_to_out_protocol(o_prot)?;
- o_prot.write_field_end()?;
- o_prot.write_field_begin(&TFieldIdentifier::new("encoding", TType::I32, 2))?;
- self.encoding.write_to_out_protocol(o_prot)?;
- o_prot.write_field_end()?;
- o_prot.write_field_begin(&TFieldIdentifier::new("count", TType::I32, 3))?;
- o_prot.write_i32(self.count)?;
- o_prot.write_field_end()?;
- o_prot.write_field_stop()?;
- o_prot.write_struct_end()
- }
-}
-
-//
-// ColumnMetaData
-//
-
-/// Description for column metadata
-#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct ColumnMetaData {
- /// Type of this column *
- pub type_: Type,
- /// Set of all encodings used for this column. The purpose is to validate
- /// whether we can decode those pages. *
- pub encodings: Vec<Encoding>,
- /// Path in schema *
- pub path_in_schema: Vec<String>,
- /// Compression codec *
- pub codec: CompressionCodec,
- /// Number of values in this column *
- pub num_values: i64,
- /// total byte size of all uncompressed pages in this column chunk (including the headers) *
- pub total_uncompressed_size: i64,
- /// total byte size of all compressed, and potentially encrypted, pages
- /// in this column chunk (including the headers) *
- pub total_compressed_size: i64,
- /// Optional key/value metadata *
- pub key_value_metadata: Option<Vec<KeyValue>>,
- /// Byte offset from beginning of file to first data page *
- pub data_page_offset: i64,
- /// Byte offset from beginning of file to root index page *
- pub index_page_offset: Option<i64>,
- /// Byte offset from the beginning of file to first (only) dictionary page *
- pub dictionary_page_offset: Option<i64>,
- /// optional statistics for this column chunk
- pub statistics: Option<Statistics>,
- /// Set of all encodings used for pages in this column chunk.
- /// This information can be used to determine if all data pages are
- /// dictionary encoded for example *
- pub encoding_stats: Option<Vec<PageEncodingStats>>,
- /// Byte offset from beginning of file to Bloom filter data. *
- pub bloom_filter_offset: Option<i64>,
- /// Size of Bloom filter data including the serialized header, in bytes.
- /// Added in 2.10 so readers may not read this field from old files and
- /// it can be obtained after the BloomFilterHeader has been deserialized.
- /// Writers should write this field so readers can read the bloom filter
- /// in a single I/O.
- pub bloom_filter_length: Option<i32>,
- /// Optional statistics to help estimate total memory when converted to in-memory
- /// representations. The histograms contained in these statistics can
- /// also be useful in some cases for more fine-grained nullability/list length
- /// filter pushdown.
- pub size_statistics: Option<SizeStatistics>,
- /// Optional statistics specific for Geometry and Geography logical types
- pub geospatial_statistics: Option<GeospatialStatistics>,
-}
-
-impl ColumnMetaData {
- pub fn new<F8, F10, F11, F12, F13, F14, F15, F16, F17>(type_: Type, encodings: Vec<Encoding>, path_in_schema: Vec<String>, codec: CompressionCodec, num_values: i64, total_uncompressed_size: i64, total_compressed_size: i64, key_value_metadata: F8, data_page_offset: i64, index_page_offset: F10, dictionary_page_offset: F11, statistics: F12, encoding_stats: F13, bloom_filter_offset: F14, bloom_filter_length: F15, size_statistics: F16, geospatial_statistics: F17) -> ColumnMetaData where F8: [...]
- ColumnMetaData {
- type_,
- encodings,
- path_in_schema,
- codec,
- num_values,
- total_uncompressed_size,
- total_compressed_size,
- key_value_metadata: key_value_metadata.into(),
- data_page_offset,
- index_page_offset: index_page_offset.into(),
- dictionary_page_offset: dictionary_page_offset.into(),
- statistics: statistics.into(),
- encoding_stats: encoding_stats.into(),
- bloom_filter_offset: bloom_filter_offset.into(),
- bloom_filter_length: bloom_filter_length.into(),
- size_statistics: size_statistics.into(),
- geospatial_statistics: geospatial_statistics.into(),
- }
- }
-}
-
-impl crate::thrift::TSerializable for ColumnMetaData {
- fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<ColumnMetaData> {
- i_prot.read_struct_begin()?;
- let mut f_1: Option<Type> = None;
- let mut f_2: Option<Vec<Encoding>> = None;
- let mut f_3: Option<Vec<String>> = None;
- let mut f_4: Option<CompressionCodec> = None;
- let mut f_5: Option<i64> = None;
- let mut f_6: Option<i64> = None;
- let mut f_7: Option<i64> = None;
- let mut f_8: Option<Vec<KeyValue>> = None;
- let mut f_9: Option<i64> = None;
- let mut f_10: Option<i64> = None;
- let mut f_11: Option<i64> = None;
- let mut f_12: Option<Statistics> = None;
- let mut f_13: Option<Vec<PageEncodingStats>> = None;
- let mut f_14: Option<i64> = None;
- let mut f_15: Option<i32> = None;
- let mut f_16: Option<SizeStatistics> = None;
- let mut f_17: Option<GeospatialStatistics> = None;
- loop {
- let field_ident = i_prot.read_field_begin()?;
- if field_ident.field_type == TType::Stop {
- break;
- }
- let field_id = field_id(&field_ident)?;
- match field_id {
- 1 => {
- let val = Type::read_from_in_protocol(i_prot)?;
- f_1 = Some(val);
- },
- 2 => {
- let list_ident = i_prot.read_list_begin()?;
- let mut val: Vec<Encoding> = Vec::with_capacity(list_ident.size as usize);
- for _ in 0..list_ident.size {
- let list_elem_3 = Encoding::read_from_in_protocol(i_prot)?;
- val.push(list_elem_3);
- }
- i_prot.read_list_end()?;
- f_2 = Some(val);
- },
- 3 => {
- let list_ident = i_prot.read_list_begin()?;
- let mut val: Vec<String> = Vec::with_capacity(list_ident.size as usize);
- for _ in 0..list_ident.size {
- let list_elem_4 = i_prot.read_string()?;
- val.push(list_elem_4);
- }
- i_prot.read_list_end()?;
- f_3 = Some(val);
- },
- 4 => {
- let val = CompressionCodec::read_from_in_protocol(i_prot)?;
- f_4 = Some(val);
- },
- 5 => {
- let val = i_prot.read_i64()?;
- f_5 = Some(val);
- },
- 6 => {
- let val = i_prot.read_i64()?;
- f_6 = Some(val);
- },
- 7 => {
- let val = i_prot.read_i64()?;
- f_7 = Some(val);
- },
- 8 => {
- let list_ident = i_prot.read_list_begin()?;
- let mut val: Vec<KeyValue> = Vec::with_capacity(list_ident.size as usize);
- for _ in 0..list_ident.size {
- let list_elem_5 = KeyValue::read_from_in_protocol(i_prot)?;
- val.push(list_elem_5);
- }
- i_prot.read_list_end()?;
- f_8 = Some(val);
- },
- 9 => {
- let val = i_prot.read_i64()?;
- f_9 = Some(val);
- },
- 10 => {
- let val = i_prot.read_i64()?;
- f_10 = Some(val);
- },
- 11 => {
- let val = i_prot.read_i64()?;
- f_11 = Some(val);
- },
- 12 => {
- let val = Statistics::read_from_in_protocol(i_prot)?;
- f_12 = Some(val);
- },
- 13 => {
- let list_ident = i_prot.read_list_begin()?;
- let mut val: Vec<PageEncodingStats> = Vec::with_capacity(list_ident.size as usize);
- for _ in 0..list_ident.size {
- let list_elem_6 = PageEncodingStats::read_from_in_protocol(i_prot)?;
- val.push(list_elem_6);
- }
- i_prot.read_list_end()?;
- f_13 = Some(val);
- },
- 14 => {
- let val = i_prot.read_i64()?;
- f_14 = Some(val);
- },
- 15 => {
- let val = i_prot.read_i32()?;
- f_15 = Some(val);
- },
- 16 => {
- let val = SizeStatistics::read_from_in_protocol(i_prot)?;
- f_16 = Some(val);
- },
- 17 => {
- let val = GeospatialStatistics::read_from_in_protocol(i_prot)?;
- f_17 = Some(val);
- },
- _ => {
- i_prot.skip(field_ident.field_type)?;
- },
- };
- i_prot.read_field_end()?;
- }
- i_prot.read_struct_end()?;
- verify_required_field_exists("ColumnMetaData.type_", &f_1)?;
- verify_required_field_exists("ColumnMetaData.encodings", &f_2)?;
- verify_required_field_exists("ColumnMetaData.path_in_schema", &f_3)?;
- verify_required_field_exists("ColumnMetaData.codec", &f_4)?;
- verify_required_field_exists("ColumnMetaData.num_values", &f_5)?;
- verify_required_field_exists("ColumnMetaData.total_uncompressed_size", &f_6)?;
- verify_required_field_exists("ColumnMetaData.total_compressed_size", &f_7)?;
- verify_required_field_exists("ColumnMetaData.data_page_offset", &f_9)?;
- let ret = ColumnMetaData {
- type_: f_1.expect("auto-generated code should have checked for presence of required fields"),
- encodings: f_2.expect("auto-generated code should have checked for presence of required fields"),
- path_in_schema: f_3.expect("auto-generated code should have checked for presence of required fields"),
- codec: f_4.expect("auto-generated code should have checked for presence of required fields"),
- num_values: f_5.expect("auto-generated code should have checked for presence of required fields"),
- total_uncompressed_size: f_6.expect("auto-generated code should have checked for presence of required fields"),
- total_compressed_size: f_7.expect("auto-generated code should have checked for presence of required fields"),
- key_value_metadata: f_8,
- data_page_offset: f_9.expect("auto-generated code should have checked for presence of required fields"),
- index_page_offset: f_10,
- dictionary_page_offset: f_11,
- statistics: f_12,
- encoding_stats: f_13,
- bloom_filter_offset: f_14,
- bloom_filter_length: f_15,
- size_statistics: f_16,
- geospatial_statistics: f_17,
- };
- Ok(ret)
- }
- fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
- let struct_ident = TStructIdentifier::new("ColumnMetaData");
- o_prot.write_struct_begin(&struct_ident)?;
- o_prot.write_field_begin(&TFieldIdentifier::new("type", TType::I32, 1))?;
- self.type_.write_to_out_protocol(o_prot)?;
- o_prot.write_field_end()?;
- o_prot.write_field_begin(&TFieldIdentifier::new("encodings", TType::List, 2))?;
- o_prot.write_list_begin(&TListIdentifier::new(TType::I32, self.encodings.len() as i32))?;
- for e in &self.encodings {
- e.write_to_out_protocol(o_prot)?;
- }
- o_prot.write_list_end()?;
- o_prot.write_field_end()?;
- o_prot.write_field_begin(&TFieldIdentifier::new("path_in_schema", TType::List, 3))?;
- o_prot.write_list_begin(&TListIdentifier::new(TType::String, self.path_in_schema.len() as i32))?;
- for e in &self.path_in_schema {
- o_prot.write_string(e)?;
- }
- o_prot.write_list_end()?;
- o_prot.write_field_end()?;
- o_prot.write_field_begin(&TFieldIdentifier::new("codec", TType::I32, 4))?;
- self.codec.write_to_out_protocol(o_prot)?;
- o_prot.write_field_end()?;
- o_prot.write_field_begin(&TFieldIdentifier::new("num_values", TType::I64, 5))?;
- o_prot.write_i64(self.num_values)?;
- o_prot.write_field_end()?;
- o_prot.write_field_begin(&TFieldIdentifier::new("total_uncompressed_size", TType::I64, 6))?;
- o_prot.write_i64(self.total_uncompressed_size)?;
- o_prot.write_field_end()?;
- o_prot.write_field_begin(&TFieldIdentifier::new("total_compressed_size", TType::I64, 7))?;
- o_prot.write_i64(self.total_compressed_size)?;
- o_prot.write_field_end()?;
- if let Some(ref fld_var) = self.key_value_metadata {
- o_prot.write_field_begin(&TFieldIdentifier::new("key_value_metadata", TType::List, 8))?;
- o_prot.write_list_begin(&TListIdentifier::new(TType::Struct, fld_var.len() as i32))?;
- for e in fld_var {
- e.write_to_out_protocol(o_prot)?;
- }
- o_prot.write_list_end()?;
- o_prot.write_field_end()?
- }
- o_prot.write_field_begin(&TFieldIdentifier::new("data_page_offset", TType::I64, 9))?;
- o_prot.write_i64(self.data_page_offset)?;
- o_prot.write_field_end()?;
- if let Some(fld_var) = self.index_page_offset {
- o_prot.write_field_begin(&TFieldIdentifier::new("index_page_offset", TType::I64, 10))?;
- o_prot.write_i64(fld_var)?;
- o_prot.write_field_end()?
- }
- if let Some(fld_var) = self.dictionary_page_offset {
- o_prot.write_field_begin(&TFieldIdentifier::new("dictionary_page_offset", TType::I64, 11))?;
- o_prot.write_i64(fld_var)?;
- o_prot.write_field_end()?
- }
- if let Some(ref fld_var) = self.statistics {
- o_prot.write_field_begin(&TFieldIdentifier::new("statistics", TType::Struct, 12))?;
- fld_var.write_to_out_protocol(o_prot)?;
- o_prot.write_field_end()?
- }
- if let Some(ref fld_var) = self.encoding_stats {
- o_prot.write_field_begin(&TFieldIdentifier::new("encoding_stats", TType::List, 13))?;
- o_prot.write_list_begin(&TListIdentifier::new(TType::Struct, fld_var.len() as i32))?;
- for e in fld_var {
- e.write_to_out_protocol(o_prot)?;
- }
- o_prot.write_list_end()?;
- o_prot.write_field_end()?
- }
- if let Some(fld_var) = self.bloom_filter_offset {
- o_prot.write_field_begin(&TFieldIdentifier::new("bloom_filter_offset", TType::I64, 14))?;
- o_prot.write_i64(fld_var)?;
- o_prot.write_field_end()?
- }
- if let Some(fld_var) = self.bloom_filter_length {
- o_prot.write_field_begin(&TFieldIdentifier::new("bloom_filter_length", TType::I32, 15))?;
- o_prot.write_i32(fld_var)?;
- o_prot.write_field_end()?
- }
- if let Some(ref fld_var) = self.size_statistics {
- o_prot.write_field_begin(&TFieldIdentifier::new("size_statistics", TType::Struct, 16))?;
- fld_var.write_to_out_protocol(o_prot)?;
- o_prot.write_field_end()?
- }
- if let Some(ref fld_var) = self.geospatial_statistics {
- o_prot.write_field_begin(&TFieldIdentifier::new("geospatial_statistics", TType::Struct, 17))?;
- fld_var.write_to_out_protocol(o_prot)?;
- o_prot.write_field_end()?
- }
- o_prot.write_field_stop()?;
- o_prot.write_struct_end()
- }
-}
-
-//
-// EncryptionWithFooterKey
-//
-
-#[derive(Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct EncryptionWithFooterKey {
-}
-
-impl EncryptionWithFooterKey {
- pub fn new() -> EncryptionWithFooterKey {
- EncryptionWithFooterKey {}
- }
-}
-
-impl crate::thrift::TSerializable for EncryptionWithFooterKey {
- fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<EncryptionWithFooterKey> {
- i_prot.read_struct_begin()?;
- loop {
- let field_ident = i_prot.read_field_begin()?;
- if field_ident.field_type == TType::Stop {
- break;
- }
- i_prot.skip(field_ident.field_type)?;
- i_prot.read_field_end()?;
- }
- i_prot.read_struct_end()?;
- let ret = EncryptionWithFooterKey {};
- Ok(ret)
- }
- fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
- let struct_ident = TStructIdentifier::new("EncryptionWithFooterKey");
- o_prot.write_struct_begin(&struct_ident)?;
- o_prot.write_field_stop()?;
- o_prot.write_struct_end()
- }
-}
-
-//
-// EncryptionWithColumnKey
-//
-
-#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct EncryptionWithColumnKey {
- /// Column path in schema *
- pub path_in_schema: Vec<String>,
- /// Retrieval metadata of column encryption key *
- pub key_metadata: Option<Vec<u8>>,
-}
-
-impl EncryptionWithColumnKey {
- pub fn new<F2>(path_in_schema: Vec<String>, key_metadata: F2) -> EncryptionWithColumnKey where F2: Into<Option<Vec<u8>>> {
- EncryptionWithColumnKey {
- path_in_schema,
- key_metadata: key_metadata.into(),
- }
- }
-}
-
-impl crate::thrift::TSerializable for EncryptionWithColumnKey {
- fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<EncryptionWithColumnKey> {
- i_prot.read_struct_begin()?;
- let mut f_1: Option<Vec<String>> = None;
- let mut f_2: Option<Vec<u8>> = None;
- loop {
- let field_ident = i_prot.read_field_begin()?;
- if field_ident.field_type == TType::Stop {
- break;
- }
- let field_id = field_id(&field_ident)?;
- match field_id {
- 1 => {
- let list_ident = i_prot.read_list_begin()?;
- let mut val: Vec<String> = Vec::with_capacity(list_ident.size as usize);
- for _ in 0..list_ident.size {
- let list_elem_7 = i_prot.read_string()?;
- val.push(list_elem_7);
- }
- i_prot.read_list_end()?;
- f_1 = Some(val);
- },
- 2 => {
- let val = i_prot.read_bytes()?;
- f_2 = Some(val);
- },
- _ => {
- i_prot.skip(field_ident.field_type)?;
- },
- };
- i_prot.read_field_end()?;
- }
- i_prot.read_struct_end()?;
- verify_required_field_exists("EncryptionWithColumnKey.path_in_schema", &f_1)?;
- let ret = EncryptionWithColumnKey {
- path_in_schema: f_1.expect("auto-generated code should have checked for presence of required fields"),
- key_metadata: f_2,
- };
- Ok(ret)
- }
- fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
- let struct_ident = TStructIdentifier::new("EncryptionWithColumnKey");
- o_prot.write_struct_begin(&struct_ident)?;
- o_prot.write_field_begin(&TFieldIdentifier::new("path_in_schema", TType::List, 1))?;
- o_prot.write_list_begin(&TListIdentifier::new(TType::String, self.path_in_schema.len() as i32))?;
- for e in &self.path_in_schema {
- o_prot.write_string(e)?;
- }
- o_prot.write_list_end()?;
- o_prot.write_field_end()?;
- if let Some(ref fld_var) = self.key_metadata {
- o_prot.write_field_begin(&TFieldIdentifier::new("key_metadata", TType::String, 2))?;
- o_prot.write_bytes(fld_var)?;
- o_prot.write_field_end()?
- }
- o_prot.write_field_stop()?;
- o_prot.write_struct_end()
- }
-}
-
-//
-// ColumnCryptoMetaData
-//
-
-#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub enum ColumnCryptoMetaData {
- ENCRYPTIONWITHFOOTERKEY(EncryptionWithFooterKey),
- ENCRYPTIONWITHCOLUMNKEY(EncryptionWithColumnKey),
-}
-
-impl crate::thrift::TSerializable for ColumnCryptoMetaData {
- fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<ColumnCryptoMetaData> {
- let mut ret: Option<ColumnCryptoMetaData> = None;
- let mut received_field_count = 0;
- i_prot.read_struct_begin()?;
- loop {
- let field_ident = i_prot.read_field_begin()?;
- if field_ident.field_type == TType::Stop {
- break;
- }
- let field_id = field_id(&field_ident)?;
- match field_id {
- 1 => {
- let val = EncryptionWithFooterKey::read_from_in_protocol(i_prot)?;
- if ret.is_none() {
- ret = Some(ColumnCryptoMetaData::ENCRYPTIONWITHFOOTERKEY(val));
- }
- received_field_count += 1;
- },
- 2 => {
- let val = EncryptionWithColumnKey::read_from_in_protocol(i_prot)?;
- if ret.is_none() {
- ret = Some(ColumnCryptoMetaData::ENCRYPTIONWITHCOLUMNKEY(val));
- }
- received_field_count += 1;
- },
- _ => {
- i_prot.skip(field_ident.field_type)?;
- received_field_count += 1;
- },
- };
- i_prot.read_field_end()?;
- }
- i_prot.read_struct_end()?;
- if received_field_count == 0 {
- Err(
- thrift::Error::Protocol(
- ProtocolError::new(
- ProtocolErrorKind::InvalidData,
- "received empty union from remote ColumnCryptoMetaData"
- )
- )
- )
- } else if received_field_count > 1 {
- Err(
- thrift::Error::Protocol(
- ProtocolError::new(
- ProtocolErrorKind::InvalidData,
- "received multiple fields for union from remote ColumnCryptoMetaData"
- )
- )
- )
- } else {
- ret.ok_or_else(|| thrift::Error::Protocol(ProtocolError::new(ProtocolErrorKind::InvalidData, "return value should have been constructed")))
- }
- }
- fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
- let struct_ident = TStructIdentifier::new("ColumnCryptoMetaData");
- o_prot.write_struct_begin(&struct_ident)?;
- match *self {
- ColumnCryptoMetaData::ENCRYPTIONWITHFOOTERKEY(ref f) => {
- o_prot.write_field_begin(&TFieldIdentifier::new("ENCRYPTION_WITH_FOOTER_KEY", TType::Struct, 1))?;
- f.write_to_out_protocol(o_prot)?;
- o_prot.write_field_end()?;
- },
- ColumnCryptoMetaData::ENCRYPTIONWITHCOLUMNKEY(ref f) => {
- o_prot.write_field_begin(&TFieldIdentifier::new("ENCRYPTION_WITH_COLUMN_KEY", TType::Struct, 2))?;
- f.write_to_out_protocol(o_prot)?;
- o_prot.write_field_end()?;
- },
- }
- o_prot.write_field_stop()?;
- o_prot.write_struct_end()
- }
-}
-
-//
-// ColumnChunk
-//
-
-#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct ColumnChunk {
- /// File where column data is stored. If not set, assumed to be same file as
- /// metadata. This path is relative to the current file.
- ///
- pub file_path: Option<String>,
- /// Deprecated: Byte offset in file_path to the ColumnMetaData
- ///
- /// Past use of this field has been inconsistent, with some implementations
- /// using it to point to the ColumnMetaData and some using it to point to
- /// the first page in the column chunk. In many cases, the ColumnMetaData at this
- /// location is wrong. This field is now deprecated and should not be used.
- /// Writers should set this field to 0 if no ColumnMetaData has been written outside
- /// the footer.
- pub file_offset: i64,
- /// Column metadata for this chunk. Some writers may also replicate this at the
- /// location pointed to by file_path/file_offset.
- /// Note: while marked as optional, this field is in fact required by most major
- /// Parquet implementations. As such, writers MUST populate this field.
- ///
- pub meta_data: Option<ColumnMetaData>,
- /// File offset of ColumnChunk's OffsetIndex *
- pub offset_index_offset: Option<i64>,
- /// Size of ColumnChunk's OffsetIndex, in bytes *
- pub offset_index_length: Option<i32>,
- /// File offset of ColumnChunk's ColumnIndex *
- pub column_index_offset: Option<i64>,
- /// Size of ColumnChunk's ColumnIndex, in bytes *
- pub column_index_length: Option<i32>,
- /// Crypto metadata of encrypted columns *
- pub crypto_metadata: Option<ColumnCryptoMetaData>,
- /// Encrypted column metadata for this chunk *
- pub encrypted_column_metadata: Option<Vec<u8>>,
-}
-
-impl ColumnChunk {
- pub fn new<F1, F3, F4, F5, F6, F7, F8, F9>(file_path: F1, file_offset: i64, meta_data: F3, offset_index_offset: F4, offset_index_length: F5, column_index_offset: F6, column_index_length: F7, crypto_metadata: F8, encrypted_column_metadata: F9) -> ColumnChunk where F1: Into<Option<String>>, F3: Into<Option<ColumnMetaData>>, F4: Into<Option<i64>>, F5: Into<Option<i32>>, F6: Into<Option<i64>>, F7: Into<Option<i32>>, F8: Into<Option<ColumnCryptoMetaData>>, F9: Into<Option<Vec<u8>>> {
- ColumnChunk {
- file_path: file_path.into(),
- file_offset,
- meta_data: meta_data.into(),
- offset_index_offset: offset_index_offset.into(),
- offset_index_length: offset_index_length.into(),
- column_index_offset: column_index_offset.into(),
- column_index_length: column_index_length.into(),
- crypto_metadata: crypto_metadata.into(),
- encrypted_column_metadata: encrypted_column_metadata.into(),
- }
- }
-}
-
-impl crate::thrift::TSerializable for ColumnChunk {
- fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<ColumnChunk> {
- i_prot.read_struct_begin()?;
- let mut f_1: Option<String> = None;
- let mut f_2: Option<i64> = None;
- let mut f_3: Option<ColumnMetaData> = None;
- let mut f_4: Option<i64> = None;
- let mut f_5: Option<i32> = None;
- let mut f_6: Option<i64> = None;
- let mut f_7: Option<i32> = None;
- let mut f_8: Option<ColumnCryptoMetaData> = None;
- let mut f_9: Option<Vec<u8>> = None;
- loop {
- let field_ident = i_prot.read_field_begin()?;
- if field_ident.field_type == TType::Stop {
- break;
- }
- let field_id = field_id(&field_ident)?;
- match field_id {
- 1 => {
- let val = i_prot.read_string()?;
- f_1 = Some(val);
- },
- 2 => {
- let val = i_prot.read_i64()?;
- f_2 = Some(val);
- },
- 3 => {
- let val = ColumnMetaData::read_from_in_protocol(i_prot)?;
- f_3 = Some(val);
- },
- 4 => {
- let val = i_prot.read_i64()?;
- f_4 = Some(val);
- },
- 5 => {
- let val = i_prot.read_i32()?;
- f_5 = Some(val);
- },
- 6 => {
- let val = i_prot.read_i64()?;
- f_6 = Some(val);
- },
- 7 => {
- let val = i_prot.read_i32()?;
- f_7 = Some(val);
- },
- 8 => {
- let val = ColumnCryptoMetaData::read_from_in_protocol(i_prot)?;
- f_8 = Some(val);
- },
- 9 => {
- let val = i_prot.read_bytes()?;
- f_9 = Some(val);
- },
- _ => {
- i_prot.skip(field_ident.field_type)?;
- },
- };
- i_prot.read_field_end()?;
- }
- i_prot.read_struct_end()?;
- verify_required_field_exists("ColumnChunk.file_offset", &f_2)?;
- let ret = ColumnChunk {
- file_path: f_1,
- file_offset: f_2.expect("auto-generated code should have checked for presence of required fields"),
- meta_data: f_3,
- offset_index_offset: f_4,
- offset_index_length: f_5,
- column_index_offset: f_6,
- column_index_length: f_7,
- crypto_metadata: f_8,
- encrypted_column_metadata: f_9,
- };
- Ok(ret)
- }
- fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
- let struct_ident = TStructIdentifier::new("ColumnChunk");
- o_prot.write_struct_begin(&struct_ident)?;
- if let Some(ref fld_var) = self.file_path {
- o_prot.write_field_begin(&TFieldIdentifier::new("file_path", TType::String, 1))?;
- o_prot.write_string(fld_var)?;
- o_prot.write_field_end()?
- }
- o_prot.write_field_begin(&TFieldIdentifier::new("file_offset", TType::I64, 2))?;
- o_prot.write_i64(self.file_offset)?;
- o_prot.write_field_end()?;
- if let Some(ref fld_var) = self.meta_data {
- o_prot.write_field_begin(&TFieldIdentifier::new("meta_data", TType::Struct, 3))?;
- fld_var.write_to_out_protocol(o_prot)?;
- o_prot.write_field_end()?
- }
- if let Some(fld_var) = self.offset_index_offset {
- o_prot.write_field_begin(&TFieldIdentifier::new("offset_index_offset", TType::I64, 4))?;
- o_prot.write_i64(fld_var)?;
- o_prot.write_field_end()?
- }
- if let Some(fld_var) = self.offset_index_length {
- o_prot.write_field_begin(&TFieldIdentifier::new("offset_index_length", TType::I32, 5))?;
- o_prot.write_i32(fld_var)?;
- o_prot.write_field_end()?
- }
- if let Some(fld_var) = self.column_index_offset {
- o_prot.write_field_begin(&TFieldIdentifier::new("column_index_offset", TType::I64, 6))?;
- o_prot.write_i64(fld_var)?;
- o_prot.write_field_end()?
- }
- if let Some(fld_var) = self.column_index_length {
- o_prot.write_field_begin(&TFieldIdentifier::new("column_index_length", TType::I32, 7))?;
- o_prot.write_i32(fld_var)?;
- o_prot.write_field_end()?
- }
- if let Some(ref fld_var) = self.crypto_metadata {
- o_prot.write_field_begin(&TFieldIdentifier::new("crypto_metadata", TType::Struct, 8))?;
- fld_var.write_to_out_protocol(o_prot)?;
- o_prot.write_field_end()?
- }
- if let Some(ref fld_var) = self.encrypted_column_metadata {
- o_prot.write_field_begin(&TFieldIdentifier::new("encrypted_column_metadata", TType::String, 9))?;
- o_prot.write_bytes(fld_var)?;
- o_prot.write_field_end()?
- }
- o_prot.write_field_stop()?;
- o_prot.write_struct_end()
- }
-}
-
-//
-// RowGroup
-//
-
-#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct RowGroup {
- /// Metadata for each column chunk in this row group.
- /// This list must have the same order as the SchemaElement list in FileMetaData.
- ///
- pub columns: Vec<ColumnChunk>,
- /// Total byte size of all the uncompressed column data in this row group *
- pub total_byte_size: i64,
- /// Number of rows in this row group *
- pub num_rows: i64,
- /// If set, specifies a sort ordering of the rows in this RowGroup.
- /// The sorting columns can be a subset of all the columns.
- pub sorting_columns: Option<Vec<SortingColumn>>,
- /// Byte offset from beginning of file to first page (data or dictionary)
- /// in this row group *
- pub file_offset: Option<i64>,
- /// Total byte size of all compressed (and potentially encrypted) column data
- /// in this row group *
- pub total_compressed_size: Option<i64>,
- /// Row group ordinal in the file *
- pub ordinal: Option<i16>,
-}
-
-impl RowGroup {
- pub fn new<F4, F5, F6, F7>(columns: Vec<ColumnChunk>, total_byte_size: i64, num_rows: i64, sorting_columns: F4, file_offset: F5, total_compressed_size: F6, ordinal: F7) -> RowGroup where F4: Into<Option<Vec<SortingColumn>>>, F5: Into<Option<i64>>, F6: Into<Option<i64>>, F7: Into<Option<i16>> {
- RowGroup {
- columns,
- total_byte_size,
- num_rows,
- sorting_columns: sorting_columns.into(),
- file_offset: file_offset.into(),
- total_compressed_size: total_compressed_size.into(),
- ordinal: ordinal.into(),
- }
- }
-}
-
-impl crate::thrift::TSerializable for RowGroup {
- fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<RowGroup> {
- i_prot.read_struct_begin()?;
- let mut f_1: Option<Vec<ColumnChunk>> = None;
- let mut f_2: Option<i64> = None;
- let mut f_3: Option<i64> = None;
- let mut f_4: Option<Vec<SortingColumn>> = None;
- let mut f_5: Option<i64> = None;
- let mut f_6: Option<i64> = None;
- let mut f_7: Option<i16> = None;
- loop {
- let field_ident = i_prot.read_field_begin()?;
- if field_ident.field_type == TType::Stop {
- break;
- }
- let field_id = field_id(&field_ident)?;
- match field_id {
- 1 => {
- let list_ident = i_prot.read_list_begin()?;
- let mut val: Vec<ColumnChunk> = Vec::with_capacity(list_ident.size as usize);
- for _ in 0..list_ident.size {
- let list_elem_8 = ColumnChunk::read_from_in_protocol(i_prot)?;
- val.push(list_elem_8);
- }
- i_prot.read_list_end()?;
- f_1 = Some(val);
- },
- 2 => {
- let val = i_prot.read_i64()?;
- f_2 = Some(val);
- },
- 3 => {
- let val = i_prot.read_i64()?;
- f_3 = Some(val);
- },
- 4 => {
- let list_ident = i_prot.read_list_begin()?;
- let mut val: Vec<SortingColumn> = Vec::with_capacity(list_ident.size as usize);
- for _ in 0..list_ident.size {
- let list_elem_9 = SortingColumn::read_from_in_protocol(i_prot)?;
- val.push(list_elem_9);
- }
- i_prot.read_list_end()?;
- f_4 = Some(val);
- },
- 5 => {
- let val = i_prot.read_i64()?;
- f_5 = Some(val);
- },
- 6 => {
- let val = i_prot.read_i64()?;
- f_6 = Some(val);
- },
- 7 => {
- let val = i_prot.read_i16()?;
- f_7 = Some(val);
- },
- _ => {
- i_prot.skip(field_ident.field_type)?;
- },
- };
- i_prot.read_field_end()?;
- }
- i_prot.read_struct_end()?;
- verify_required_field_exists("RowGroup.columns", &f_1)?;
- verify_required_field_exists("RowGroup.total_byte_size", &f_2)?;
- verify_required_field_exists("RowGroup.num_rows", &f_3)?;
- let ret = RowGroup {
- columns: f_1.expect("auto-generated code should have checked for presence of required fields"),
- total_byte_size: f_2.expect("auto-generated code should have checked for presence of required fields"),
- num_rows: f_3.expect("auto-generated code should have checked for presence of required fields"),
- sorting_columns: f_4,
- file_offset: f_5,
- total_compressed_size: f_6,
- ordinal: f_7,
- };
- Ok(ret)
- }
- fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
- let struct_ident = TStructIdentifier::new("RowGroup");
- o_prot.write_struct_begin(&struct_ident)?;
- o_prot.write_field_begin(&TFieldIdentifier::new("columns", TType::List, 1))?;
- o_prot.write_list_begin(&TListIdentifier::new(TType::Struct, self.columns.len() as i32))?;
- for e in &self.columns {
- e.write_to_out_protocol(o_prot)?;
- }
- o_prot.write_list_end()?;
- o_prot.write_field_end()?;
- o_prot.write_field_begin(&TFieldIdentifier::new("total_byte_size", TType::I64, 2))?;
- o_prot.write_i64(self.total_byte_size)?;
- o_prot.write_field_end()?;
- o_prot.write_field_begin(&TFieldIdentifier::new("num_rows", TType::I64, 3))?;
- o_prot.write_i64(self.num_rows)?;
- o_prot.write_field_end()?;
- if let Some(ref fld_var) = self.sorting_columns {
- o_prot.write_field_begin(&TFieldIdentifier::new("sorting_columns", TType::List, 4))?;
- o_prot.write_list_begin(&TListIdentifier::new(TType::Struct, fld_var.len() as i32))?;
- for e in fld_var {
- e.write_to_out_protocol(o_prot)?;
- }
- o_prot.write_list_end()?;
- o_prot.write_field_end()?
- }
- if let Some(fld_var) = self.file_offset {
- o_prot.write_field_begin(&TFieldIdentifier::new("file_offset", TType::I64, 5))?;
- o_prot.write_i64(fld_var)?;
- o_prot.write_field_end()?
- }
- if let Some(fld_var) = self.total_compressed_size {
- o_prot.write_field_begin(&TFieldIdentifier::new("total_compressed_size", TType::I64, 6))?;
- o_prot.write_i64(fld_var)?;
- o_prot.write_field_end()?
- }
- if let Some(fld_var) = self.ordinal {
- o_prot.write_field_begin(&TFieldIdentifier::new("ordinal", TType::I16, 7))?;
- o_prot.write_i16(fld_var)?;
- o_prot.write_field_end()?
- }
- o_prot.write_field_stop()?;
- o_prot.write_struct_end()
- }
-}
-
-//
-// TypeDefinedOrder
-//
-
-/// Empty struct to signal the order defined by the physical or logical type
-#[derive(Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct TypeDefinedOrder {
-}
-
-impl TypeDefinedOrder {
- pub fn new() -> TypeDefinedOrder {
- TypeDefinedOrder {}
- }
-}
-
-impl crate::thrift::TSerializable for TypeDefinedOrder {
- fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<TypeDefinedOrder> {
- i_prot.read_struct_begin()?;
- loop {
- let field_ident = i_prot.read_field_begin()?;
- if field_ident.field_type == TType::Stop {
- break;
- }
- i_prot.skip(field_ident.field_type)?;
- i_prot.read_field_end()?;
- }
- i_prot.read_struct_end()?;
- let ret = TypeDefinedOrder {};
- Ok(ret)
- }
- fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
- let struct_ident = TStructIdentifier::new("TypeDefinedOrder");
- o_prot.write_struct_begin(&struct_ident)?;
- o_prot.write_field_stop()?;
- o_prot.write_struct_end()
- }
-}
-
-//
-// ColumnOrder
-//
-
-#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub enum ColumnOrder {
- TYPEORDER(TypeDefinedOrder),
-}
-
-impl crate::thrift::TSerializable for ColumnOrder {
- fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<ColumnOrder> {
- let mut ret: Option<ColumnOrder> = None;
- let mut received_field_count = 0;
- i_prot.read_struct_begin()?;
- loop {
- let field_ident = i_prot.read_field_begin()?;
- if field_ident.field_type == TType::Stop {
- break;
- }
- let field_id = field_id(&field_ident)?;
- match field_id {
- 1 => {
- let val = TypeDefinedOrder::read_from_in_protocol(i_prot)?;
- if ret.is_none() {
- ret = Some(ColumnOrder::TYPEORDER(val));
- }
- received_field_count += 1;
- },
- _ => {
- i_prot.skip(field_ident.field_type)?;
- received_field_count += 1;
- },
- };
- i_prot.read_field_end()?;
- }
- i_prot.read_struct_end()?;
- if received_field_count == 0 {
- Err(
- thrift::Error::Protocol(
- ProtocolError::new(
- ProtocolErrorKind::InvalidData,
- "received empty union from remote ColumnOrder"
- )
- )
- )
- } else if received_field_count > 1 {
- Err(
- thrift::Error::Protocol(
- ProtocolError::new(
- ProtocolErrorKind::InvalidData,
- "received multiple fields for union from remote ColumnOrder"
- )
- )
- )
- } else {
- ret.ok_or_else(|| thrift::Error::Protocol(ProtocolError::new(ProtocolErrorKind::InvalidData, "return value should have been constructed")))
- }
- }
- fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
- let struct_ident = TStructIdentifier::new("ColumnOrder");
- o_prot.write_struct_begin(&struct_ident)?;
- match *self {
- ColumnOrder::TYPEORDER(ref f) => {
- o_prot.write_field_begin(&TFieldIdentifier::new("TYPE_ORDER", TType::Struct, 1))?;
- f.write_to_out_protocol(o_prot)?;
- o_prot.write_field_end()?;
- },
- }
- o_prot.write_field_stop()?;
- o_prot.write_struct_end()
- }
-}
-
-//
-// PageLocation
-//
-
-#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct PageLocation {
- /// Offset of the page in the file *
- pub offset: i64,
- /// Size of the page, including header. Sum of compressed_page_size and header
- /// length
- pub compressed_page_size: i32,
- /// Index within the RowGroup of the first row of the page. When an
- /// OffsetIndex is present, pages must begin on row boundaries
- /// (repetition_level = 0).
- pub first_row_index: i64,
-}
-
-impl PageLocation {
- pub fn new(offset: i64, compressed_page_size: i32, first_row_index: i64) -> PageLocation {
- PageLocation {
- offset,
- compressed_page_size,
- first_row_index,
- }
- }
-}
-
-impl crate::thrift::TSerializable for PageLocation {
- fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<PageLocation> {
- i_prot.read_struct_begin()?;
- let mut f_1: Option<i64> = None;
- let mut f_2: Option<i32> = None;
- let mut f_3: Option<i64> = None;
- loop {
- let field_ident = i_prot.read_field_begin()?;
- if field_ident.field_type == TType::Stop {
- break;
- }
- let field_id = field_id(&field_ident)?;
- match field_id {
- 1 => {
- let val = i_prot.read_i64()?;
- f_1 = Some(val);
- },
- 2 => {
- let val = i_prot.read_i32()?;
- f_2 = Some(val);
- },
- 3 => {
- let val = i_prot.read_i64()?;
- f_3 = Some(val);
- },
- _ => {
- i_prot.skip(field_ident.field_type)?;
- },
- };
- i_prot.read_field_end()?;
- }
- i_prot.read_struct_end()?;
- verify_required_field_exists("PageLocation.offset", &f_1)?;
- verify_required_field_exists("PageLocation.compressed_page_size", &f_2)?;
- verify_required_field_exists("PageLocation.first_row_index", &f_3)?;
- let ret = PageLocation {
- offset: f_1.expect("auto-generated code should have checked for presence of required fields"),
- compressed_page_size: f_2.expect("auto-generated code should have checked for presence of required fields"),
- first_row_index: f_3.expect("auto-generated code should have checked for presence of required fields"),
- };
- Ok(ret)
- }
- fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
- let struct_ident = TStructIdentifier::new("PageLocation");
- o_prot.write_struct_begin(&struct_ident)?;
- o_prot.write_field_begin(&TFieldIdentifier::new("offset", TType::I64, 1))?;
- o_prot.write_i64(self.offset)?;
- o_prot.write_field_end()?;
- o_prot.write_field_begin(&TFieldIdentifier::new("compressed_page_size", TType::I32, 2))?;
- o_prot.write_i32(self.compressed_page_size)?;
- o_prot.write_field_end()?;
- o_prot.write_field_begin(&TFieldIdentifier::new("first_row_index", TType::I64, 3))?;
- o_prot.write_i64(self.first_row_index)?;
- o_prot.write_field_end()?;
- o_prot.write_field_stop()?;
- o_prot.write_struct_end()
- }
-}
-
-//
-// OffsetIndex
-//
-
-/// Optional offsets for each data page in a ColumnChunk.
-///
-/// Forms part of the page index, along with ColumnIndex.
-///
-/// OffsetIndex may be present even if ColumnIndex is not.
-#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct OffsetIndex {
- /// PageLocations, ordered by increasing PageLocation.offset. It is required
- /// that page_locations\[i\].first_row_index < page_locations\[i+1\].first_row_index.
- pub page_locations: Vec<PageLocation>,
- /// Unencoded/uncompressed size for BYTE_ARRAY types.
- ///
- /// See documention for unencoded_byte_array_data_bytes in SizeStatistics for
- /// more details on this field.
- pub unencoded_byte_array_data_bytes: Option<Vec<i64>>,
-}
-
-impl OffsetIndex {
- pub fn new<F2>(page_locations: Vec<PageLocation>, unencoded_byte_array_data_bytes: F2) -> OffsetIndex where F2: Into<Option<Vec<i64>>> {
- OffsetIndex {
- page_locations,
- unencoded_byte_array_data_bytes: unencoded_byte_array_data_bytes.into(),
- }
- }
-}
-
-impl crate::thrift::TSerializable for OffsetIndex {
- fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<OffsetIndex> {
- i_prot.read_struct_begin()?;
- let mut f_1: Option<Vec<PageLocation>> = None;
- let mut f_2: Option<Vec<i64>> = None;
- loop {
- let field_ident = i_prot.read_field_begin()?;
- if field_ident.field_type == TType::Stop {
- break;
- }
- let field_id = field_id(&field_ident)?;
- match field_id {
- 1 => {
- let list_ident = i_prot.read_list_begin()?;
- let mut val: Vec<PageLocation> = Vec::with_capacity(list_ident.size as usize);
- for _ in 0..list_ident.size {
- let list_elem_10 = PageLocation::read_from_in_protocol(i_prot)?;
- val.push(list_elem_10);
- }
- i_prot.read_list_end()?;
- f_1 = Some(val);
- },
- 2 => {
- let list_ident = i_prot.read_list_begin()?;
- let mut val: Vec<i64> = Vec::with_capacity(list_ident.size as usize);
- for _ in 0..list_ident.size {
- let list_elem_11 = i_prot.read_i64()?;
- val.push(list_elem_11);
- }
- i_prot.read_list_end()?;
- f_2 = Some(val);
- },
- _ => {
- i_prot.skip(field_ident.field_type)?;
- },
- };
- i_prot.read_field_end()?;
- }
- i_prot.read_struct_end()?;
- verify_required_field_exists("OffsetIndex.page_locations", &f_1)?;
- let ret = OffsetIndex {
- page_locations: f_1.expect("auto-generated code should have checked for presence of required fields"),
- unencoded_byte_array_data_bytes: f_2,
- };
- Ok(ret)
- }
- fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
- let struct_ident = TStructIdentifier::new("OffsetIndex");
- o_prot.write_struct_begin(&struct_ident)?;
- o_prot.write_field_begin(&TFieldIdentifier::new("page_locations", TType::List, 1))?;
- o_prot.write_list_begin(&TListIdentifier::new(TType::Struct, self.page_locations.len() as i32))?;
- for e in &self.page_locations {
- e.write_to_out_protocol(o_prot)?;
- }
- o_prot.write_list_end()?;
- o_prot.write_field_end()?;
- if let Some(ref fld_var) = self.unencoded_byte_array_data_bytes {
- o_prot.write_field_begin(&TFieldIdentifier::new("unencoded_byte_array_data_bytes", TType::List, 2))?;
- o_prot.write_list_begin(&TListIdentifier::new(TType::I64, fld_var.len() as i32))?;
- for e in fld_var {
- o_prot.write_i64(*e)?;
- }
- o_prot.write_list_end()?;
- o_prot.write_field_end()?
- }
- o_prot.write_field_stop()?;
- o_prot.write_struct_end()
- }
-}
-
-//
-// ColumnIndex
-//
-
-/// Optional statistics for each data page in a ColumnChunk.
-///
-/// Forms part the page index, along with OffsetIndex.
-///
-/// If this structure is present, OffsetIndex must also be present.
-///
-/// For each field in this structure, `<field>`\[i\] refers to the page at
-/// OffsetIndex.page_locations\[i\]
-#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct ColumnIndex {
- /// A list of Boolean values to determine the validity of the corresponding
- /// min and max values. If true, a page contains only null values, and writers
- /// have to set the corresponding entries in min_values and max_values to
- /// byte\[0\], so that all lists have the same length. If false, the
- /// corresponding entries in min_values and max_values must be valid.
- pub null_pages: Vec<bool>,
- /// Two lists containing lower and upper bounds for the values of each page
- /// determined by the ColumnOrder of the column. These may be the actual
- /// minimum and maximum values found on a page, but can also be (more compact)
- /// values that do not exist on a page. For example, instead of storing ""Blart
- /// Versenwald III", a writer may set min_values\[i\]="B", max_values\[i\]="C".
- /// Such more compact values must still be valid values within the column's
- /// logical type. Readers must make sure that list entries are populated before
- /// using them by inspecting null_pages.
- pub min_values: Vec<Vec<u8>>,
- pub max_values: Vec<Vec<u8>>,
- /// Stores whether both min_values and max_values are ordered and if so, in
- /// which direction. This allows readers to perform binary searches in both
- /// lists. Readers cannot assume that max_values\[i\] <= min_values\[i+1\], even
- /// if the lists are ordered.
- pub boundary_order: BoundaryOrder,
- /// A list containing the number of null values for each page
- ///
- /// Writers SHOULD always write this field even if no null values
- /// are present or the column is not nullable.
- /// Readers MUST distinguish between null_counts not being present
- /// and null_count being 0.
- /// If null_counts are not present, readers MUST NOT assume all
- /// null counts are 0.
- pub null_counts: Option<Vec<i64>>,
- /// Contains repetition level histograms for each page
- /// concatenated together. The repetition_level_histogram field on
- /// SizeStatistics contains more details.
- ///
- /// When present the length should always be (number of pages *
- /// (max_repetition_level + 1)) elements.
- ///
- /// Element 0 is the first element of the histogram for the first page.
- /// Element (max_repetition_level + 1) is the first element of the histogram
- /// for the second page.
- ///
- pub repetition_level_histograms: Option<Vec<i64>>,
- /// Same as repetition_level_histograms except for definitions levels.
- ///
- pub definition_level_histograms: Option<Vec<i64>>,
-}
-
-impl ColumnIndex {
- pub fn new<F5, F6, F7>(null_pages: Vec<bool>, min_values: Vec<Vec<u8>>, max_values: Vec<Vec<u8>>, boundary_order: BoundaryOrder, null_counts: F5, repetition_level_histograms: F6, definition_level_histograms: F7) -> ColumnIndex where F5: Into<Option<Vec<i64>>>, F6: Into<Option<Vec<i64>>>, F7: Into<Option<Vec<i64>>> {
- ColumnIndex {
- null_pages,
- min_values,
- max_values,
- boundary_order,
- null_counts: null_counts.into(),
- repetition_level_histograms: repetition_level_histograms.into(),
- definition_level_histograms: definition_level_histograms.into(),
- }
- }
-}
-
-impl crate::thrift::TSerializable for ColumnIndex {
- fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<ColumnIndex> {
- i_prot.read_struct_begin()?;
- let mut f_1: Option<Vec<bool>> = None;
- let mut f_2: Option<Vec<Vec<u8>>> = None;
- let mut f_3: Option<Vec<Vec<u8>>> = None;
- let mut f_4: Option<BoundaryOrder> = None;
- let mut f_5: Option<Vec<i64>> = None;
- let mut f_6: Option<Vec<i64>> = None;
- let mut f_7: Option<Vec<i64>> = None;
- loop {
- let field_ident = i_prot.read_field_begin()?;
- if field_ident.field_type == TType::Stop {
- break;
- }
- let field_id = field_id(&field_ident)?;
- match field_id {
- 1 => {
- let list_ident = i_prot.read_list_begin()?;
- let mut val: Vec<bool> = Vec::with_capacity(list_ident.size as usize);
- for _ in 0..list_ident.size {
- let list_elem_12 = i_prot.read_bool()?;
- val.push(list_elem_12);
- }
- i_prot.read_list_end()?;
- f_1 = Some(val);
- },
- 2 => {
- let list_ident = i_prot.read_list_begin()?;
- let mut val: Vec<Vec<u8>> = Vec::with_capacity(list_ident.size as usize);
- for _ in 0..list_ident.size {
- let list_elem_13 = i_prot.read_bytes()?;
- val.push(list_elem_13);
- }
- i_prot.read_list_end()?;
- f_2 = Some(val);
- },
- 3 => {
- let list_ident = i_prot.read_list_begin()?;
- let mut val: Vec<Vec<u8>> = Vec::with_capacity(list_ident.size as usize);
- for _ in 0..list_ident.size {
- let list_elem_14 = i_prot.read_bytes()?;
- val.push(list_elem_14);
- }
- i_prot.read_list_end()?;
- f_3 = Some(val);
- },
- 4 => {
- let val = BoundaryOrder::read_from_in_protocol(i_prot)?;
- f_4 = Some(val);
- },
- 5 => {
- let list_ident = i_prot.read_list_begin()?;
- let mut val: Vec<i64> = Vec::with_capacity(list_ident.size as usize);
- for _ in 0..list_ident.size {
- let list_elem_15 = i_prot.read_i64()?;
- val.push(list_elem_15);
- }
- i_prot.read_list_end()?;
- f_5 = Some(val);
- },
- 6 => {
- let list_ident = i_prot.read_list_begin()?;
- let mut val: Vec<i64> = Vec::with_capacity(list_ident.size as usize);
- for _ in 0..list_ident.size {
- let list_elem_16 = i_prot.read_i64()?;
- val.push(list_elem_16);
- }
- i_prot.read_list_end()?;
- f_6 = Some(val);
- },
- 7 => {
- let list_ident = i_prot.read_list_begin()?;
- let mut val: Vec<i64> = Vec::with_capacity(list_ident.size as usize);
- for _ in 0..list_ident.size {
- let list_elem_17 = i_prot.read_i64()?;
- val.push(list_elem_17);
- }
- i_prot.read_list_end()?;
- f_7 = Some(val);
- },
- _ => {
- i_prot.skip(field_ident.field_type)?;
- },
- };
- i_prot.read_field_end()?;
- }
- i_prot.read_struct_end()?;
- verify_required_field_exists("ColumnIndex.null_pages", &f_1)?;
- verify_required_field_exists("ColumnIndex.min_values", &f_2)?;
- verify_required_field_exists("ColumnIndex.max_values", &f_3)?;
- verify_required_field_exists("ColumnIndex.boundary_order", &f_4)?;
- let ret = ColumnIndex {
- null_pages: f_1.expect("auto-generated code should have checked for presence of required fields"),
- min_values: f_2.expect("auto-generated code should have checked for presence of required fields"),
- max_values: f_3.expect("auto-generated code should have checked for presence of required fields"),
- boundary_order: f_4.expect("auto-generated code should have checked for presence of required fields"),
- null_counts: f_5,
- repetition_level_histograms: f_6,
- definition_level_histograms: f_7,
- };
- Ok(ret)
- }
- fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
- let struct_ident = TStructIdentifier::new("ColumnIndex");
- o_prot.write_struct_begin(&struct_ident)?;
- o_prot.write_field_begin(&TFieldIdentifier::new("null_pages", TType::List, 1))?;
- o_prot.write_list_begin(&TListIdentifier::new(TType::Bool, self.null_pages.len() as i32))?;
- for e in &self.null_pages {
- o_prot.write_bool(*e)?;
- }
- o_prot.write_list_end()?;
- o_prot.write_field_end()?;
- o_prot.write_field_begin(&TFieldIdentifier::new("min_values", TType::List, 2))?;
- o_prot.write_list_begin(&TListIdentifier::new(TType::String, self.min_values.len() as i32))?;
- for e in &self.min_values {
- o_prot.write_bytes(e)?;
- }
- o_prot.write_list_end()?;
- o_prot.write_field_end()?;
- o_prot.write_field_begin(&TFieldIdentifier::new("max_values", TType::List, 3))?;
- o_prot.write_list_begin(&TListIdentifier::new(TType::String, self.max_values.len() as i32))?;
- for e in &self.max_values {
- o_prot.write_bytes(e)?;
- }
- o_prot.write_list_end()?;
- o_prot.write_field_end()?;
- o_prot.write_field_begin(&TFieldIdentifier::new("boundary_order", TType::I32, 4))?;
- self.boundary_order.write_to_out_protocol(o_prot)?;
- o_prot.write_field_end()?;
- if let Some(ref fld_var) = self.null_counts {
- o_prot.write_field_begin(&TFieldIdentifier::new("null_counts", TType::List, 5))?;
- o_prot.write_list_begin(&TListIdentifier::new(TType::I64, fld_var.len() as i32))?;
- for e in fld_var {
- o_prot.write_i64(*e)?;
- }
- o_prot.write_list_end()?;
- o_prot.write_field_end()?
- }
- if let Some(ref fld_var) = self.repetition_level_histograms {
- o_prot.write_field_begin(&TFieldIdentifier::new("repetition_level_histograms", TType::List, 6))?;
- o_prot.write_list_begin(&TListIdentifier::new(TType::I64, fld_var.len() as i32))?;
- for e in fld_var {
- o_prot.write_i64(*e)?;
- }
- o_prot.write_list_end()?;
- o_prot.write_field_end()?
- }
- if let Some(ref fld_var) = self.definition_level_histograms {
- o_prot.write_field_begin(&TFieldIdentifier::new("definition_level_histograms", TType::List, 7))?;
- o_prot.write_list_begin(&TListIdentifier::new(TType::I64, fld_var.len() as i32))?;
- for e in fld_var {
- o_prot.write_i64(*e)?;
- }
- o_prot.write_list_end()?;
- o_prot.write_field_end()?
- }
- o_prot.write_field_stop()?;
- o_prot.write_struct_end()
- }
-}
-
-//
-// AesGcmV1
-//
-
-#[derive(Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct AesGcmV1 {
- /// AAD prefix *
- pub aad_prefix: Option<Vec<u8>>,
- /// Unique file identifier part of AAD suffix *
- pub aad_file_unique: Option<Vec<u8>>,
- /// In files encrypted with AAD prefix without storing it,
- /// readers must supply the prefix *
- pub supply_aad_prefix: Option<bool>,
-}
-
-impl AesGcmV1 {
- pub fn new<F1, F2, F3>(aad_prefix: F1, aad_file_unique: F2, supply_aad_prefix: F3) -> AesGcmV1 where F1: Into<Option<Vec<u8>>>, F2: Into<Option<Vec<u8>>>, F3: Into<Option<bool>> {
- AesGcmV1 {
- aad_prefix: aad_prefix.into(),
- aad_file_unique: aad_file_unique.into(),
- supply_aad_prefix: supply_aad_prefix.into(),
- }
- }
-}
-
-impl crate::thrift::TSerializable for AesGcmV1 {
- fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<AesGcmV1> {
- i_prot.read_struct_begin()?;
- let mut f_1: Option<Vec<u8>> = None;
- let mut f_2: Option<Vec<u8>> = None;
- let mut f_3: Option<bool> = None;
- loop {
- let field_ident = i_prot.read_field_begin()?;
- if field_ident.field_type == TType::Stop {
- break;
- }
- let field_id = field_id(&field_ident)?;
- match field_id {
- 1 => {
- let val = i_prot.read_bytes()?;
- f_1 = Some(val);
- },
- 2 => {
- let val = i_prot.read_bytes()?;
- f_2 = Some(val);
- },
- 3 => {
- let val = i_prot.read_bool()?;
- f_3 = Some(val);
- },
- _ => {
- i_prot.skip(field_ident.field_type)?;
- },
- };
- i_prot.read_field_end()?;
- }
- i_prot.read_struct_end()?;
- let ret = AesGcmV1 {
- aad_prefix: f_1,
- aad_file_unique: f_2,
- supply_aad_prefix: f_3,
- };
- Ok(ret)
- }
- fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
- let struct_ident = TStructIdentifier::new("AesGcmV1");
- o_prot.write_struct_begin(&struct_ident)?;
- if let Some(ref fld_var) = self.aad_prefix {
- o_prot.write_field_begin(&TFieldIdentifier::new("aad_prefix", TType::String, 1))?;
- o_prot.write_bytes(fld_var)?;
- o_prot.write_field_end()?
- }
- if let Some(ref fld_var) = self.aad_file_unique {
- o_prot.write_field_begin(&TFieldIdentifier::new("aad_file_unique", TType::String, 2))?;
- o_prot.write_bytes(fld_var)?;
- o_prot.write_field_end()?
- }
- if let Some(fld_var) = self.supply_aad_prefix {
- o_prot.write_field_begin(&TFieldIdentifier::new("supply_aad_prefix", TType::Bool, 3))?;
- o_prot.write_bool(fld_var)?;
- o_prot.write_field_end()?
- }
- o_prot.write_field_stop()?;
- o_prot.write_struct_end()
- }
-}
-
-//
-// AesGcmCtrV1
-//
-
-#[derive(Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct AesGcmCtrV1 {
- /// AAD prefix *
- pub aad_prefix: Option<Vec<u8>>,
- /// Unique file identifier part of AAD suffix *
- pub aad_file_unique: Option<Vec<u8>>,
- /// In files encrypted with AAD prefix without storing it,
- /// readers must supply the prefix *
- pub supply_aad_prefix: Option<bool>,
-}
-
-impl AesGcmCtrV1 {
- pub fn new<F1, F2, F3>(aad_prefix: F1, aad_file_unique: F2, supply_aad_prefix: F3) -> AesGcmCtrV1 where F1: Into<Option<Vec<u8>>>, F2: Into<Option<Vec<u8>>>, F3: Into<Option<bool>> {
- AesGcmCtrV1 {
- aad_prefix: aad_prefix.into(),
- aad_file_unique: aad_file_unique.into(),
- supply_aad_prefix: supply_aad_prefix.into(),
- }
- }
-}
-
-impl crate::thrift::TSerializable for AesGcmCtrV1 {
- fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<AesGcmCtrV1> {
- i_prot.read_struct_begin()?;
- let mut f_1: Option<Vec<u8>> = None;
- let mut f_2: Option<Vec<u8>> = None;
- let mut f_3: Option<bool> = None;
- loop {
- let field_ident = i_prot.read_field_begin()?;
- if field_ident.field_type == TType::Stop {
- break;
- }
- let field_id = field_id(&field_ident)?;
- match field_id {
- 1 => {
- let val = i_prot.read_bytes()?;
- f_1 = Some(val);
- },
- 2 => {
- let val = i_prot.read_bytes()?;
- f_2 = Some(val);
- },
- 3 => {
- let val = i_prot.read_bool()?;
- f_3 = Some(val);
- },
- _ => {
- i_prot.skip(field_ident.field_type)?;
- },
- };
- i_prot.read_field_end()?;
- }
- i_prot.read_struct_end()?;
- let ret = AesGcmCtrV1 {
- aad_prefix: f_1,
- aad_file_unique: f_2,
- supply_aad_prefix: f_3,
- };
- Ok(ret)
- }
- fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
- let struct_ident = TStructIdentifier::new("AesGcmCtrV1");
- o_prot.write_struct_begin(&struct_ident)?;
- if let Some(ref fld_var) = self.aad_prefix {
- o_prot.write_field_begin(&TFieldIdentifier::new("aad_prefix", TType::String, 1))?;
- o_prot.write_bytes(fld_var)?;
- o_prot.write_field_end()?
- }
- if let Some(ref fld_var) = self.aad_file_unique {
- o_prot.write_field_begin(&TFieldIdentifier::new("aad_file_unique", TType::String, 2))?;
- o_prot.write_bytes(fld_var)?;
- o_prot.write_field_end()?
- }
- if let Some(fld_var) = self.supply_aad_prefix {
- o_prot.write_field_begin(&TFieldIdentifier::new("supply_aad_prefix", TType::Bool, 3))?;
- o_prot.write_bool(fld_var)?;
- o_prot.write_field_end()?
- }
- o_prot.write_field_stop()?;
- o_prot.write_struct_end()
- }
-}
-
-//
-// EncryptionAlgorithm
-//
-
-#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub enum EncryptionAlgorithm {
- AESGCMV1(AesGcmV1),
- AESGCMCTRV1(AesGcmCtrV1),
-}
-
-impl crate::thrift::TSerializable for EncryptionAlgorithm {
- fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<EncryptionAlgorithm> {
- let mut ret: Option<EncryptionAlgorithm> = None;
- let mut received_field_count = 0;
- i_prot.read_struct_begin()?;
- loop {
- let field_ident = i_prot.read_field_begin()?;
- if field_ident.field_type == TType::Stop {
- break;
- }
- let field_id = field_id(&field_ident)?;
- match field_id {
- 1 => {
- let val = AesGcmV1::read_from_in_protocol(i_prot)?;
- if ret.is_none() {
- ret = Some(EncryptionAlgorithm::AESGCMV1(val));
- }
- received_field_count += 1;
- },
- 2 => {
- let val = AesGcmCtrV1::read_from_in_protocol(i_prot)?;
- if ret.is_none() {
- ret = Some(EncryptionAlgorithm::AESGCMCTRV1(val));
- }
- received_field_count += 1;
- },
- _ => {
- i_prot.skip(field_ident.field_type)?;
- received_field_count += 1;
- },
- };
- i_prot.read_field_end()?;
- }
- i_prot.read_struct_end()?;
- if received_field_count == 0 {
- Err(
- thrift::Error::Protocol(
- ProtocolError::new(
- ProtocolErrorKind::InvalidData,
- "received empty union from remote EncryptionAlgorithm"
- )
- )
- )
- } else if received_field_count > 1 {
- Err(
- thrift::Error::Protocol(
- ProtocolError::new(
- ProtocolErrorKind::InvalidData,
- "received multiple fields for union from remote EncryptionAlgorithm"
- )
- )
- )
- } else {
- ret.ok_or_else(|| thrift::Error::Protocol(ProtocolError::new(ProtocolErrorKind::InvalidData, "return value should have been constructed")))
- }
- }
- fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
- let struct_ident = TStructIdentifier::new("EncryptionAlgorithm");
- o_prot.write_struct_begin(&struct_ident)?;
- match *self {
- EncryptionAlgorithm::AESGCMV1(ref f) => {
- o_prot.write_field_begin(&TFieldIdentifier::new("AES_GCM_V1", TType::Struct, 1))?;
- f.write_to_out_protocol(o_prot)?;
- o_prot.write_field_end()?;
- },
- EncryptionAlgorithm::AESGCMCTRV1(ref f) => {
- o_prot.write_field_begin(&TFieldIdentifier::new("AES_GCM_CTR_V1", TType::Struct, 2))?;
- f.write_to_out_protocol(o_prot)?;
- o_prot.write_field_end()?;
- },
- }
- o_prot.write_field_stop()?;
- o_prot.write_struct_end()
- }
-}
-
-//
-// FileMetaData
-//
-
-/// Description for file metadata
-#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct FileMetaData {
- /// Version of this file *
- pub version: i32,
- /// Parquet schema for this file. This schema contains metadata for all the columns.
- /// The schema is represented as a tree with a single root. The nodes of the tree
- /// are flattened to a list by doing a depth-first traversal.
- /// The column metadata contains the path in the schema for that column which can be
- /// used to map columns to nodes in the schema.
- /// The first element is the root *
- pub schema: Vec<SchemaElement>,
- /// Number of rows in this file *
- pub num_rows: i64,
- /// Row groups in this file *
- pub row_groups: Vec<RowGroup>,
- /// Optional key/value metadata *
- pub key_value_metadata: Option<Vec<KeyValue>>,
- /// String for application that wrote this file. This should be in the format
- /// `<Application>` version `<App Version>` (build `<App Build Hash>`).
- /// e.g. impala version 1.0 (build 6cf94d29b2b7115df4de2c06e2ab4326d721eb55)
- ///
- pub created_by: Option<String>,
- /// Sort order used for the min_value and max_value fields in the Statistics
- /// objects and the min_values and max_values fields in the ColumnIndex
- /// objects of each column in this file. Sort orders are listed in the order
- /// matching the columns in the schema. The indexes are not necessary the same
- /// though, because only leaf nodes of the schema are represented in the list
- /// of sort orders.
- ///
- /// Without column_orders, the meaning of the min_value and max_value fields
- /// in the Statistics object and the ColumnIndex object is undefined. To ensure
- /// well-defined behaviour, if these fields are written to a Parquet file,
- /// column_orders must be written as well.
- ///
- /// The obsolete min and max fields in the Statistics object are always sorted
- /// by signed comparison regardless of column_orders.
- pub column_orders: Option<Vec<ColumnOrder>>,
- /// Encryption algorithm. This field is set only in encrypted files
- /// with plaintext footer. Files with encrypted footer store algorithm id
- /// in FileCryptoMetaData structure.
- pub encryption_algorithm: Option<EncryptionAlgorithm>,
- /// Retrieval metadata of key used for signing the footer.
- /// Used only in encrypted files with plaintext footer.
- pub footer_signing_key_metadata: Option<Vec<u8>>,
-}
-
-impl FileMetaData {
- pub fn new<F5, F6, F7, F8, F9>(version: i32, schema: Vec<SchemaElement>, num_rows: i64, row_groups: Vec<RowGroup>, key_value_metadata: F5, created_by: F6, column_orders: F7, encryption_algorithm: F8, footer_signing_key_metadata: F9) -> FileMetaData where F5: Into<Option<Vec<KeyValue>>>, F6: Into<Option<String>>, F7: Into<Option<Vec<ColumnOrder>>>, F8: Into<Option<EncryptionAlgorithm>>, F9: Into<Option<Vec<u8>>> {
- FileMetaData {
- version,
- schema,
- num_rows,
- row_groups,
- key_value_metadata: key_value_metadata.into(),
- created_by: created_by.into(),
- column_orders: column_orders.into(),
- encryption_algorithm: encryption_algorithm.into(),
- footer_signing_key_metadata: footer_signing_key_metadata.into(),
- }
- }
-}
-
-impl crate::thrift::TSerializable for FileMetaData {
- fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<FileMetaData> {
- i_prot.read_struct_begin()?;
- let mut f_1: Option<i32> = None;
- let mut f_2: Option<Vec<SchemaElement>> = None;
- let mut f_3: Option<i64> = None;
- let mut f_4: Option<Vec<RowGroup>> = None;
- let mut f_5: Option<Vec<KeyValue>> = None;
- let mut f_6: Option<String> = None;
- let mut f_7: Option<Vec<ColumnOrder>> = None;
- let mut f_8: Option<EncryptionAlgorithm> = None;
- let mut f_9: Option<Vec<u8>> = None;
- loop {
- let field_ident = i_prot.read_field_begin()?;
- if field_ident.field_type == TType::Stop {
- break;
- }
- let field_id = field_id(&field_ident)?;
- match field_id {
- 1 => {
- let val = i_prot.read_i32()?;
- f_1 = Some(val);
- },
- 2 => {
- let list_ident = i_prot.read_list_begin()?;
- let mut val: Vec<SchemaElement> = Vec::with_capacity(list_ident.size as usize);
- for _ in 0..list_ident.size {
- let list_elem_18 = SchemaElement::read_from_in_protocol(i_prot)?;
- val.push(list_elem_18);
- }
- i_prot.read_list_end()?;
- f_2 = Some(val);
- },
- 3 => {
- let val = i_prot.read_i64()?;
- f_3 = Some(val);
- },
- 4 => {
- let list_ident = i_prot.read_list_begin()?;
- let mut val: Vec<RowGroup> = Vec::with_capacity(list_ident.size as usize);
- for _ in 0..list_ident.size {
- let list_elem_19 = RowGroup::read_from_in_protocol(i_prot)?;
- val.push(list_elem_19);
- }
- i_prot.read_list_end()?;
- f_4 = Some(val);
- },
- 5 => {
- let list_ident = i_prot.read_list_begin()?;
- let mut val: Vec<KeyValue> = Vec::with_capacity(list_ident.size as usize);
- for _ in 0..list_ident.size {
- let list_elem_20 = KeyValue::read_from_in_protocol(i_prot)?;
- val.push(list_elem_20);
- }
- i_prot.read_list_end()?;
- f_5 = Some(val);
- },
- 6 => {
- let val = i_prot.read_string()?;
- f_6 = Some(val);
- },
- 7 => {
- let list_ident = i_prot.read_list_begin()?;
- let mut val: Vec<ColumnOrder> = Vec::with_capacity(list_ident.size as usize);
- for _ in 0..list_ident.size {
- let list_elem_21 = ColumnOrder::read_from_in_protocol(i_prot)?;
- val.push(list_elem_21);
- }
- i_prot.read_list_end()?;
- f_7 = Some(val);
- },
- 8 => {
- let val = EncryptionAlgorithm::read_from_in_protocol(i_prot)?;
- f_8 = Some(val);
- },
- 9 => {
- let val = i_prot.read_bytes()?;
- f_9 = Some(val);
- },
- _ => {
- i_prot.skip(field_ident.field_type)?;
- },
- };
- i_prot.read_field_end()?;
- }
- i_prot.read_struct_end()?;
- verify_required_field_exists("FileMetaData.version", &f_1)?;
- verify_required_field_exists("FileMetaData.schema", &f_2)?;
- verify_required_field_exists("FileMetaData.num_rows", &f_3)?;
- verify_required_field_exists("FileMetaData.row_groups", &f_4)?;
- let ret = FileMetaData {
- version: f_1.expect("auto-generated code should have checked for presence of required fields"),
- schema: f_2.expect("auto-generated code should have checked for presence of required fields"),
- num_rows: f_3.expect("auto-generated code should have checked for presence of required fields"),
- row_groups: f_4.expect("auto-generated code should have checked for presence of required fields"),
- key_value_metadata: f_5,
- created_by: f_6,
- column_orders: f_7,
- encryption_algorithm: f_8,
- footer_signing_key_metadata: f_9,
- };
- Ok(ret)
- }
- fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
- let struct_ident = TStructIdentifier::new("FileMetaData");
- o_prot.write_struct_begin(&struct_ident)?;
- o_prot.write_field_begin(&TFieldIdentifier::new("version", TType::I32, 1))?;
- o_prot.write_i32(self.version)?;
- o_prot.write_field_end()?;
- o_prot.write_field_begin(&TFieldIdentifier::new("schema", TType::List, 2))?;
- o_prot.write_list_begin(&TListIdentifier::new(TType::Struct, self.schema.len() as i32))?;
- for e in &self.schema {
- e.write_to_out_protocol(o_prot)?;
- }
- o_prot.write_list_end()?;
- o_prot.write_field_end()?;
- o_prot.write_field_begin(&TFieldIdentifier::new("num_rows", TType::I64, 3))?;
- o_prot.write_i64(self.num_rows)?;
- o_prot.write_field_end()?;
- o_prot.write_field_begin(&TFieldIdentifier::new("row_groups", TType::List, 4))?;
- o_prot.write_list_begin(&TListIdentifier::new(TType::Struct, self.row_groups.len() as i32))?;
- for e in &self.row_groups {
- e.write_to_out_protocol(o_prot)?;
- }
- o_prot.write_list_end()?;
- o_prot.write_field_end()?;
- if let Some(ref fld_var) = self.key_value_metadata {
- o_prot.write_field_begin(&TFieldIdentifier::new("key_value_metadata", TType::List, 5))?;
- o_prot.write_list_begin(&TListIdentifier::new(TType::Struct, fld_var.len() as i32))?;
- for e in fld_var {
- e.write_to_out_protocol(o_prot)?;
- }
- o_prot.write_list_end()?;
- o_prot.write_field_end()?
- }
- if let Some(ref fld_var) = self.created_by {
- o_prot.write_field_begin(&TFieldIdentifier::new("created_by", TType::String, 6))?;
- o_prot.write_string(fld_var)?;
- o_prot.write_field_end()?
- }
- if let Some(ref fld_var) = self.column_orders {
- o_prot.write_field_begin(&TFieldIdentifier::new("column_orders", TType::List, 7))?;
- o_prot.write_list_begin(&TListIdentifier::new(TType::Struct, fld_var.len() as i32))?;
- for e in fld_var {
- e.write_to_out_protocol(o_prot)?;
- }
- o_prot.write_list_end()?;
- o_prot.write_field_end()?
- }
- if let Some(ref fld_var) = self.encryption_algorithm {
- o_prot.write_field_begin(&TFieldIdentifier::new("encryption_algorithm", TType::Struct, 8))?;
- fld_var.write_to_out_protocol(o_prot)?;
- o_prot.write_field_end()?
- }
- if let Some(ref fld_var) = self.footer_signing_key_metadata {
- o_prot.write_field_begin(&TFieldIdentifier::new("footer_signing_key_metadata", TType::String, 9))?;
- o_prot.write_bytes(fld_var)?;
- o_prot.write_field_end()?
- }
- o_prot.write_field_stop()?;
- o_prot.write_struct_end()
- }
-}
-
-//
-// FileCryptoMetaData
-//
-
-/// Crypto metadata for files with encrypted footer *
-#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct FileCryptoMetaData {
- /// Encryption algorithm. This field is only used for files
- /// with encrypted footer. Files with plaintext footer store algorithm id
- /// inside footer (FileMetaData structure).
- pub encryption_algorithm: EncryptionAlgorithm,
- /// Retrieval metadata of key used for encryption of footer,
- /// and (possibly) columns *
- pub key_metadata: Option<Vec<u8>>,
-}
-
-impl FileCryptoMetaData {
- pub fn new<F2>(encryption_algorithm: EncryptionAlgorithm, key_metadata: F2) -> FileCryptoMetaData where F2: Into<Option<Vec<u8>>> {
- FileCryptoMetaData {
- encryption_algorithm,
- key_metadata: key_metadata.into(),
- }
- }
-}
-
-impl crate::thrift::TSerializable for FileCryptoMetaData {
- fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<FileCryptoMetaData> {
- i_prot.read_struct_begin()?;
- let mut f_1: Option<EncryptionAlgorithm> = None;
- let mut f_2: Option<Vec<u8>> = None;
- loop {
- let field_ident = i_prot.read_field_begin()?;
- if field_ident.field_type == TType::Stop {
- break;
- }
- let field_id = field_id(&field_ident)?;
- match field_id {
- 1 => {
- let val = EncryptionAlgorithm::read_from_in_protocol(i_prot)?;
- f_1 = Some(val);
- },
- 2 => {
- let val = i_prot.read_bytes()?;
- f_2 = Some(val);
- },
- _ => {
- i_prot.skip(field_ident.field_type)?;
- },
- };
- i_prot.read_field_end()?;
- }
- i_prot.read_struct_end()?;
- verify_required_field_exists("FileCryptoMetaData.encryption_algorithm", &f_1)?;
- let ret = FileCryptoMetaData {
- encryption_algorithm: f_1.expect("auto-generated code should have checked for presence of required fields"),
- key_metadata: f_2,
- };
- Ok(ret)
- }
- fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
- let struct_ident = TStructIdentifier::new("FileCryptoMetaData");
- o_prot.write_struct_begin(&struct_ident)?;
- o_prot.write_field_begin(&TFieldIdentifier::new("encryption_algorithm", TType::Struct, 1))?;
- self.encryption_algorithm.write_to_out_protocol(o_prot)?;
- o_prot.write_field_end()?;
- if let Some(ref fld_var) = self.key_metadata {
- o_prot.write_field_begin(&TFieldIdentifier::new("key_metadata", TType::String, 2))?;
- o_prot.write_bytes(fld_var)?;
- o_prot.write_field_end()?
- }
- o_prot.write_field_stop()?;
- o_prot.write_struct_end()
- }
-}
-
diff --git a/parquet/src/lib.rs b/parquet/src/lib.rs
index 916892fafe..86a8920b4d 100644
--- a/parquet/src/lib.rs
+++ b/parquet/src/lib.rs
@@ -176,22 +176,6 @@ compile_error!(
pub mod errors;
pub mod basic;
-/// Automatically generated code from the Parquet thrift definition.
-///
-/// This module code generated from [parquet.thrift]. See [crate::file] for
-/// more information on reading Parquet encoded data.
-///
-/// [parquet.thrift]: https://github.com/apache/parquet-format/blob/master/src/main/thrift/parquet.thrift
-// see parquet/CONTRIBUTING.md for instructions on regenerating
-// Don't try clippy and format auto generated code
-#[allow(clippy::all, missing_docs)]
-#[rustfmt::skip]
-#[deprecated(
- since = "57.0.0",
- note = "The `format` module is no longer maintained, and will be removed in `59.0.0`"
-)]
-pub mod format;
-
#[macro_use]
pub mod data_type;
@@ -222,7 +206,7 @@ pub mod schema;
mod parquet_macros;
mod parquet_thrift;
-pub mod thrift;
+
/// What data is needed to read the next item from a decoder.
///
/// This is used to communicate between the decoder and the caller
diff --git a/parquet/src/thrift.rs b/parquet/src/thrift.rs
deleted file mode 100644
index 2eb91162ac..0000000000
--- a/parquet/src/thrift.rs
+++ /dev/null
@@ -1,86 +0,0 @@
-// Licensed to the Apache Software Foundation (ASF) under one
-// or more contributor license agreements. See the NOTICE file
-// distributed with this work for additional information
-// regarding copyright ownership. The ASF licenses this file
-// to you under the Apache License, Version 2.0 (the
-// "License"); you may not use this file except in compliance
-// with the License. You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing,
-// software distributed under the License is distributed on an
-// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-// KIND, either express or implied. See the License for the
-// specific language governing permissions and limitations
-// under the License.
-
-//! Custom thrift definitions
-
-pub use thrift::protocol::TCompactOutputProtocol;
-use thrift::protocol::{TInputProtocol, TOutputProtocol};
-
-/// Reads and writes the struct to Thrift protocols.
-///
-/// Unlike [`thrift::protocol::TSerializable`] this uses generics instead of trait objects
-pub trait TSerializable: Sized {
- /// Reads the struct from the input Thrift protocol
- fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<Self>;
- /// Writes the struct to the output Thrift protocol
- fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()>;
-}
-
-#[cfg(test)]
-mod tests {
- use crate::{
- basic::Type,
- file::page_index::{column_index::ColumnIndexMetaData, index_reader::decode_column_index},
- };
-
- #[test]
- pub fn read_boolean_list_field_type() {
- // Boolean collection type encoded as 0x01, as used by this crate when writing.
- // Values encoded as 1 (true) or 2 (false) as in the current version of the thrift
- // documentation.
- let bytes = vec![
- 0x19, 0x21, 2, 1, 0x19, 0x28, 1, 0, 0, 0x19, 0x28, 1, 1, 0, 0x15, 0, 0,
- ];
- let index = decode_column_index(&bytes, Type::BOOLEAN).unwrap();
-
- let index = match index {
- ColumnIndexMetaData::BOOLEAN(index) => index,
- _ => panic!("expected boolean column index"),
- };
-
- // should be false, true
- assert!(!index.is_null_page(0));
- assert!(index.is_null_page(1));
- assert!(!index.min_value(0).unwrap()); // min is false
- assert!(index.max_value(0).unwrap()); // max is true
- assert!(index.min_value(1).is_none());
- assert!(index.max_value(1).is_none());
- }
-
- #[test]
- pub fn read_boolean_list_alternative_encoding() {
- // Boolean collection type encoded as 0x02, as allowed by the spec.
- // Values encoded as 1 (true) or 0 (false) as before the thrift documentation change on 2024-12-13.
- let bytes = vec![
- 0x19, 0x22, 0, 1, 0x19, 0x28, 1, 0, 0, 0x19, 0x28, 1, 1, 0, 0x15, 0, 0,
- ];
- let index = decode_column_index(&bytes, Type::BOOLEAN).unwrap();
-
- let index = match index {
- ColumnIndexMetaData::BOOLEAN(index) => index,
- _ => panic!("expected boolean column index"),
- };
-
- // should be false, true
- assert!(!index.is_null_page(0));
- assert!(index.is_null_page(1));
- assert!(!index.min_value(0).unwrap()); // min is false
- assert!(index.max_value(0).unwrap()); // max is true
- assert!(index.min_value(1).is_none());
- assert!(index.max_value(1).is_none());
- }
-}