parquet-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From n...@apache.org
Subject [5/7] parquet-cpp git commit: PARQUET-416: C++11 compilation, code reorg, libparquet and installation targets
Date Fri, 08 Jan 2016 23:51:56 GMT
http://git-wip-us.apache.org/repos/asf/parquet-cpp/blob/337cf584/cmake_modules/clean-all.cmake
----------------------------------------------------------------------
diff --git a/cmake_modules/clean-all.cmake b/cmake_modules/clean-all.cmake
new file mode 100644
index 0000000..35041ea
--- /dev/null
+++ b/cmake_modules/clean-all.cmake
@@ -0,0 +1,14 @@
+set(cmake_generated ${CMAKE_BINARY_DIR}/CMakeCache.txt
+                    ${CMAKE_BINARY_DIR}/CTestTestfile.cmake
+                    ${CMAKE_BINARY_DIR}/cmake_install.cmake
+                    ${CMAKE_BINARY_DIR}/Makefile
+                    ${CMAKE_BINARY_DIR}/CMakeFiles
+)
+
+foreach(file ${cmake_generated})
+
+  if (EXISTS ${file})
+     file(REMOVE_RECURSE ${file})
+  endif()
+
+endforeach(file)
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/parquet-cpp/blob/337cf584/example/CMakeLists.txt
----------------------------------------------------------------------
diff --git a/example/CMakeLists.txt b/example/CMakeLists.txt
index 8844cdd..a9f4fa3 100644
--- a/example/CMakeLists.txt
+++ b/example/CMakeLists.txt
@@ -18,13 +18,10 @@ add_library(Example STATIC
 )
 
 SET(LINK_LIBS
-  Parquet
-  ParquetCompression
-  Example
-  ThriftParquet
+  parquet
+  snappystatic
   thriftstatic
-  lz4static
-  snappystatic)
+  Example)
 
 add_executable(compute_stats compute_stats.cc)
 target_link_libraries(compute_stats ${LINK_LIBS})

http://git-wip-us.apache.org/repos/asf/parquet-cpp/blob/337cf584/example/decode_benchmark.cc
----------------------------------------------------------------------
diff --git a/example/decode_benchmark.cc b/example/decode_benchmark.cc
index 1add399..ed4077a 100644
--- a/example/decode_benchmark.cc
+++ b/example/decode_benchmark.cc
@@ -17,11 +17,10 @@
 #include <stdio.h>
 
 #include "example_util.h"
-#include "compression/codec.h"
-#include "encodings/encodings.h"
-#include "util/stopwatch.h"
+#include "parquet/compression/codec.h"
+#include "parquet/encodings/encodings.h"
+#include "parquet/util/stopwatch.h"
 
-using namespace impala;
 using namespace parquet;
 using namespace parquet_cpp;
 using namespace std;

http://git-wip-us.apache.org/repos/asf/parquet-cpp/blob/337cf584/example/parquet_reader.cc
----------------------------------------------------------------------
diff --git a/example/parquet_reader.cc b/example/parquet_reader.cc
index c02ffb0..55895ce 100644
--- a/example/parquet_reader.cc
+++ b/example/parquet_reader.cc
@@ -215,7 +215,7 @@ void* read_parquet(char* filename) {
       char *str = (char*)malloc(50);
       assert(str);
       strcpy(str, metadata.schema[j+1].name.c_str());
-      printf("%-"COL_WIDTH"s", str);
+      printf("%-" COL_WIDTH"s", str);
       free(str);
     }
 
@@ -225,22 +225,22 @@ void* read_parquet(char* filename) {
     for (j = 0;j < row_group.columns.size(); ++j)
       switch(type_array[j]) {
         case Type::BOOLEAN:
-          printf("%-"COL_WIDTH"s","BOOLEAN");
+          printf("%-" COL_WIDTH"s","BOOLEAN");
           break;
         case Type::INT32:
-          printf("%-"COL_WIDTH"s","INT32");
+          printf("%-" COL_WIDTH"s","INT32");
           break;
         case Type::INT64:
-          printf("%-"COL_WIDTH"s","INT64");
+          printf("%-" COL_WIDTH"s","INT64");
           break;
         case Type::FLOAT:
-          printf("%-"COL_WIDTH"s","FLOAT");
+          printf("%-" COL_WIDTH"s","FLOAT");
           break;
         case Type::DOUBLE:
-          printf("%-"COL_WIDTH"s","DOUBLE");
+          printf("%-" COL_WIDTH"s","DOUBLE");
           break;
         case Type::BYTE_ARRAY:
-          printf("%-"COL_WIDTH"s","BYTE_ARRAY");
+          printf("%-" COL_WIDTH"s","BYTE_ARRAY");
           break;
         default:
           continue;
@@ -255,26 +255,26 @@ void* read_parquet(char* filename) {
       for (j = 0; j < row_group.columns.size(); ++j) {
         switch(type_array[j]) {
           case Type::BOOLEAN:
-            printf("%-"COL_WIDTH"d",((bool*)(((bool**)column_ptr)[j]))[k]);
+            printf("%-" COL_WIDTH"d",((bool*)(((bool**)column_ptr)[j]))[k]);
             break;
           case Type::INT32:
-            printf("%-"COL_WIDTH"d",((int32_t *)(((int32_t **)column_ptr)[j]))[k]);
+            printf("%-" COL_WIDTH"d",((int32_t *)(((int32_t **)column_ptr)[j]))[k]);
             break;
           case Type::INT64:
-            printf("%-"COL_WIDTH"ld",((int64_t *)(((int64_t **)column_ptr)[j]))[k]);
+            printf("%-" COL_WIDTH"ld",((int64_t *)(((int64_t **)column_ptr)[j]))[k]);
             break;
           case Type::FLOAT:
-            printf("%-"COL_WIDTH"f",((float*)(((float**)column_ptr)[j]))[k]);
+            printf("%-" COL_WIDTH"f",((float*)(((float**)column_ptr)[j]))[k]);
             break;
           case Type::DOUBLE:
-            printf("%-"COL_WIDTH"lf",((double*)(((double**)column_ptr)[j]))[k]);
+            printf("%-" COL_WIDTH"lf",((double*)(((double**)column_ptr)[j]))[k]);
             break;
           case Type::BYTE_ARRAY:
             result = ByteArrayToString( ((ByteArray*)(((ByteArray**)column_ptr)[j]))[k] );
             str1 = (char*)malloc(result.size());
             assert(str1);
             strcpy(str1, result.c_str());
-            printf("%-"COL_WIDTH"s", str1);
+            printf("%-" COL_WIDTH"s", str1);
             free(str1);
             break;
           default:

http://git-wip-us.apache.org/repos/asf/parquet-cpp/blob/337cf584/generated/gen-cpp/CMakeLists.txt
----------------------------------------------------------------------
diff --git a/generated/gen-cpp/CMakeLists.txt b/generated/gen-cpp/CMakeLists.txt
deleted file mode 100644
index 262c23f..0000000
--- a/generated/gen-cpp/CMakeLists.txt
+++ /dev/null
@@ -1,20 +0,0 @@
-# Copyright 2012 Cloudera Inc.
-#
-# Licensed 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.
-
-
-add_library(ThriftParquet STATIC
-  parquet_constants.cpp
-  parquet_types.cpp
-)
-

http://git-wip-us.apache.org/repos/asf/parquet-cpp/blob/337cf584/generated/gen-cpp/parquet_constants.cpp
----------------------------------------------------------------------
diff --git a/generated/gen-cpp/parquet_constants.cpp b/generated/gen-cpp/parquet_constants.cpp
deleted file mode 100644
index caa5af6..0000000
--- a/generated/gen-cpp/parquet_constants.cpp
+++ /dev/null
@@ -1,17 +0,0 @@
-/**
- * Autogenerated by Thrift Compiler (0.9.0)
- *
- * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
- *  @generated
- */
-#include "parquet_constants.h"
-
-namespace parquet {
-
-const parquetConstants g_parquet_constants;
-
-parquetConstants::parquetConstants() {
-}
-
-} // namespace
-

http://git-wip-us.apache.org/repos/asf/parquet-cpp/blob/337cf584/generated/gen-cpp/parquet_constants.h
----------------------------------------------------------------------
diff --git a/generated/gen-cpp/parquet_constants.h b/generated/gen-cpp/parquet_constants.h
deleted file mode 100644
index 71d6f58..0000000
--- a/generated/gen-cpp/parquet_constants.h
+++ /dev/null
@@ -1,24 +0,0 @@
-/**
- * Autogenerated by Thrift Compiler (0.9.0)
- *
- * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
- *  @generated
- */
-#ifndef parquet_CONSTANTS_H
-#define parquet_CONSTANTS_H
-
-#include "parquet_types.h"
-
-namespace parquet {
-
-class parquetConstants {
- public:
-  parquetConstants();
-
-};
-
-extern const parquetConstants g_parquet_constants;
-
-} // namespace
-
-#endif

http://git-wip-us.apache.org/repos/asf/parquet-cpp/blob/337cf584/generated/gen-cpp/parquet_types.cpp
----------------------------------------------------------------------
diff --git a/generated/gen-cpp/parquet_types.cpp b/generated/gen-cpp/parquet_types.cpp
deleted file mode 100644
index 06d388c..0000000
--- a/generated/gen-cpp/parquet_types.cpp
+++ /dev/null
@@ -1,2006 +0,0 @@
-/**
- * Autogenerated by Thrift Compiler (0.9.0)
- *
- * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
- *  @generated
- */
-#include "parquet_types.h"
-
-#include <algorithm>
-
-namespace parquet {
-
-int _kTypeValues[] = {
-  Type::BOOLEAN,
-  Type::INT32,
-  Type::INT64,
-  Type::INT96,
-  Type::FLOAT,
-  Type::DOUBLE,
-  Type::BYTE_ARRAY,
-  Type::FIXED_LEN_BYTE_ARRAY
-};
-const char* _kTypeNames[] = {
-  "BOOLEAN",
-  "INT32",
-  "INT64",
-  "INT96",
-  "FLOAT",
-  "DOUBLE",
-  "BYTE_ARRAY",
-  "FIXED_LEN_BYTE_ARRAY"
-};
-const std::map<int, const char*> _Type_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(8, _kTypeValues, _kTypeNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL));
-
-int _kConvertedTypeValues[] = {
-  ConvertedType::UTF8,
-  ConvertedType::MAP,
-  ConvertedType::MAP_KEY_VALUE,
-  ConvertedType::LIST,
-  ConvertedType::ENUM,
-  ConvertedType::DECIMAL
-};
-const char* _kConvertedTypeNames[] = {
-  "UTF8",
-  "MAP",
-  "MAP_KEY_VALUE",
-  "LIST",
-  "ENUM",
-  "DECIMAL"
-};
-const std::map<int, const char*> _ConvertedType_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(6, _kConvertedTypeValues, _kConvertedTypeNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL));
-
-int _kFieldRepetitionTypeValues[] = {
-  FieldRepetitionType::REQUIRED,
-  FieldRepetitionType::OPTIONAL,
-  FieldRepetitionType::REPEATED
-};
-const char* _kFieldRepetitionTypeNames[] = {
-  "REQUIRED",
-  "OPTIONAL",
-  "REPEATED"
-};
-const std::map<int, const char*> _FieldRepetitionType_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(3, _kFieldRepetitionTypeValues, _kFieldRepetitionTypeNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL));
-
-int _kEncodingValues[] = {
-  Encoding::PLAIN,
-  Encoding::PLAIN_DICTIONARY,
-  Encoding::RLE,
-  Encoding::BIT_PACKED,
-  Encoding::DELTA_BINARY_PACKED,
-  Encoding::DELTA_LENGTH_BYTE_ARRAY,
-  Encoding::DELTA_BYTE_ARRAY,
-  Encoding::RLE_DICTIONARY
-};
-const char* _kEncodingNames[] = {
-  "PLAIN",
-  "PLAIN_DICTIONARY",
-  "RLE",
-  "BIT_PACKED",
-  "DELTA_BINARY_PACKED",
-  "DELTA_LENGTH_BYTE_ARRAY",
-  "DELTA_BYTE_ARRAY",
-  "RLE_DICTIONARY"
-};
-const std::map<int, const char*> _Encoding_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(8, _kEncodingValues, _kEncodingNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL));
-
-int _kCompressionCodecValues[] = {
-  CompressionCodec::UNCOMPRESSED,
-  CompressionCodec::SNAPPY,
-  CompressionCodec::GZIP,
-  CompressionCodec::LZO
-};
-const char* _kCompressionCodecNames[] = {
-  "UNCOMPRESSED",
-  "SNAPPY",
-  "GZIP",
-  "LZO"
-};
-const std::map<int, const char*> _CompressionCodec_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(4, _kCompressionCodecValues, _kCompressionCodecNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL));
-
-int _kPageTypeValues[] = {
-  PageType::DATA_PAGE,
-  PageType::INDEX_PAGE,
-  PageType::DICTIONARY_PAGE,
-  PageType::DATA_PAGE_V2
-};
-const char* _kPageTypeNames[] = {
-  "DATA_PAGE",
-  "INDEX_PAGE",
-  "DICTIONARY_PAGE",
-  "DATA_PAGE_V2"
-};
-const std::map<int, const char*> _PageType_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(4, _kPageTypeValues, _kPageTypeNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL));
-
-const char* Statistics::ascii_fingerprint = "CE004821871820DD79A8FD98BB101F6D";
-const uint8_t Statistics::binary_fingerprint[16] = {0xCE,0x00,0x48,0x21,0x87,0x18,0x20,0xDD,0x79,0xA8,0xFD,0x98,0xBB,0x10,0x1F,0x6D};
-
-uint32_t Statistics::read(::apache::thrift::protocol::TProtocol* iprot) {
-
-  uint32_t xfer = 0;
-  std::string fname;
-  ::apache::thrift::protocol::TType ftype;
-  int16_t fid;
-
-  xfer += iprot->readStructBegin(fname);
-
-  using ::apache::thrift::protocol::TProtocolException;
-
-
-  while (true)
-  {
-    xfer += iprot->readFieldBegin(fname, ftype, fid);
-    if (ftype == ::apache::thrift::protocol::T_STOP) {
-      break;
-    }
-    switch (fid)
-    {
-      case 1:
-        if (ftype == ::apache::thrift::protocol::T_STRING) {
-          xfer += iprot->readBinary(this->max);
-          this->__isset.max = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 2:
-        if (ftype == ::apache::thrift::protocol::T_STRING) {
-          xfer += iprot->readBinary(this->min);
-          this->__isset.min = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 3:
-        if (ftype == ::apache::thrift::protocol::T_I64) {
-          xfer += iprot->readI64(this->null_count);
-          this->__isset.null_count = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 4:
-        if (ftype == ::apache::thrift::protocol::T_I64) {
-          xfer += iprot->readI64(this->distinct_count);
-          this->__isset.distinct_count = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      default:
-        xfer += iprot->skip(ftype);
-        break;
-    }
-    xfer += iprot->readFieldEnd();
-  }
-
-  xfer += iprot->readStructEnd();
-
-  return xfer;
-}
-
-uint32_t Statistics::write(::apache::thrift::protocol::TProtocol* oprot) const {
-  uint32_t xfer = 0;
-  uint32_t fcnt = 0;
-  xfer += oprot->writeStructBegin("Statistics");
-
-  if (this->__isset.max) {
-    ++fcnt;
-    xfer += oprot->writeFieldBegin("max", ::apache::thrift::protocol::T_STRING, 1);
-    xfer += oprot->writeBinary(this->max);
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.min) {
-    ++fcnt;
-    xfer += oprot->writeFieldBegin("min", ::apache::thrift::protocol::T_STRING, 2);
-    xfer += oprot->writeBinary(this->min);
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.null_count) {
-    ++fcnt;
-    xfer += oprot->writeFieldBegin("null_count", ::apache::thrift::protocol::T_I64, 3);
-    xfer += oprot->writeI64(this->null_count);
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.distinct_count) {
-    ++fcnt;
-    xfer += oprot->writeFieldBegin("distinct_count", ::apache::thrift::protocol::T_I64, 4);
-    xfer += oprot->writeI64(this->distinct_count);
-    xfer += oprot->writeFieldEnd();
-  }
-  xfer += oprot->writeFieldStop();
-  xfer += oprot->writeStructEnd();
-  return xfer;
-}
-
-void swap(Statistics &a, Statistics &b) {
-  using ::std::swap;
-  swap(a.max, b.max);
-  swap(a.min, b.min);
-  swap(a.null_count, b.null_count);
-  swap(a.distinct_count, b.distinct_count);
-  swap(a.__isset, b.__isset);
-}
-
-const char* SchemaElement::ascii_fingerprint = "388A784401753800444CFEAC8BC1B1A1";
-const uint8_t SchemaElement::binary_fingerprint[16] = {0x38,0x8A,0x78,0x44,0x01,0x75,0x38,0x00,0x44,0x4C,0xFE,0xAC,0x8B,0xC1,0xB1,0xA1};
-
-uint32_t SchemaElement::read(::apache::thrift::protocol::TProtocol* iprot) {
-
-  uint32_t xfer = 0;
-  std::string fname;
-  ::apache::thrift::protocol::TType ftype;
-  int16_t fid;
-
-  xfer += iprot->readStructBegin(fname);
-
-  using ::apache::thrift::protocol::TProtocolException;
-
-  bool isset_name = false;
-
-  while (true)
-  {
-    xfer += iprot->readFieldBegin(fname, ftype, fid);
-    if (ftype == ::apache::thrift::protocol::T_STOP) {
-      break;
-    }
-    switch (fid)
-    {
-      case 1:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast0;
-          xfer += iprot->readI32(ecast0);
-          this->type = (Type::type)ecast0;
-          this->__isset.type = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 2:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          xfer += iprot->readI32(this->type_length);
-          this->__isset.type_length = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 3:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast1;
-          xfer += iprot->readI32(ecast1);
-          this->repetition_type = (FieldRepetitionType::type)ecast1;
-          this->__isset.repetition_type = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 4:
-        if (ftype == ::apache::thrift::protocol::T_STRING) {
-          xfer += iprot->readString(this->name);
-          isset_name = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 5:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          xfer += iprot->readI32(this->num_children);
-          this->__isset.num_children = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 6:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast2;
-          xfer += iprot->readI32(ecast2);
-          this->converted_type = (ConvertedType::type)ecast2;
-          this->__isset.converted_type = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 7:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          xfer += iprot->readI32(this->scale);
-          this->__isset.scale = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 8:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          xfer += iprot->readI32(this->precision);
-          this->__isset.precision = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      default:
-        xfer += iprot->skip(ftype);
-        break;
-    }
-    xfer += iprot->readFieldEnd();
-  }
-
-  xfer += iprot->readStructEnd();
-
-  if (!isset_name)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  return xfer;
-}
-
-uint32_t SchemaElement::write(::apache::thrift::protocol::TProtocol* oprot) const {
-  uint32_t xfer = 0;
-  uint32_t fcnt = 0;
-  xfer += oprot->writeStructBegin("SchemaElement");
-
-  if (this->__isset.type) {
-    ++fcnt;
-    xfer += oprot->writeFieldBegin("type", ::apache::thrift::protocol::T_I32, 1);
-    xfer += oprot->writeI32((int32_t)this->type);
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.type_length) {
-    ++fcnt;
-    xfer += oprot->writeFieldBegin("type_length", ::apache::thrift::protocol::T_I32, 2);
-    xfer += oprot->writeI32(this->type_length);
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.repetition_type) {
-    ++fcnt;
-    xfer += oprot->writeFieldBegin("repetition_type", ::apache::thrift::protocol::T_I32, 3);
-    xfer += oprot->writeI32((int32_t)this->repetition_type);
-    xfer += oprot->writeFieldEnd();
-  }
-  ++fcnt;
-  xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 4);
-  xfer += oprot->writeString(this->name);
-  xfer += oprot->writeFieldEnd();
-
-  if (this->__isset.num_children) {
-    ++fcnt;
-    xfer += oprot->writeFieldBegin("num_children", ::apache::thrift::protocol::T_I32, 5);
-    xfer += oprot->writeI32(this->num_children);
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.converted_type) {
-    ++fcnt;
-    xfer += oprot->writeFieldBegin("converted_type", ::apache::thrift::protocol::T_I32, 6);
-    xfer += oprot->writeI32((int32_t)this->converted_type);
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.scale) {
-    ++fcnt;
-    xfer += oprot->writeFieldBegin("scale", ::apache::thrift::protocol::T_I32, 7);
-    xfer += oprot->writeI32(this->scale);
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.precision) {
-    ++fcnt;
-    xfer += oprot->writeFieldBegin("precision", ::apache::thrift::protocol::T_I32, 8);
-    xfer += oprot->writeI32(this->precision);
-    xfer += oprot->writeFieldEnd();
-  }
-  xfer += oprot->writeFieldStop();
-  xfer += oprot->writeStructEnd();
-  return xfer;
-}
-
-void swap(SchemaElement &a, SchemaElement &b) {
-  using ::std::swap;
-  swap(a.type, b.type);
-  swap(a.type_length, b.type_length);
-  swap(a.repetition_type, b.repetition_type);
-  swap(a.name, b.name);
-  swap(a.num_children, b.num_children);
-  swap(a.converted_type, b.converted_type);
-  swap(a.scale, b.scale);
-  swap(a.precision, b.precision);
-  swap(a.__isset, b.__isset);
-}
-
-const char* DataPageHeader::ascii_fingerprint = "5FC1792B0483E9C984475384165040B1";
-const uint8_t DataPageHeader::binary_fingerprint[16] = {0x5F,0xC1,0x79,0x2B,0x04,0x83,0xE9,0xC9,0x84,0x47,0x53,0x84,0x16,0x50,0x40,0xB1};
-
-uint32_t DataPageHeader::read(::apache::thrift::protocol::TProtocol* iprot) {
-
-  uint32_t xfer = 0;
-  std::string fname;
-  ::apache::thrift::protocol::TType ftype;
-  int16_t fid;
-
-  xfer += iprot->readStructBegin(fname);
-
-  using ::apache::thrift::protocol::TProtocolException;
-
-  bool isset_num_values = false;
-  bool isset_encoding = false;
-  bool isset_definition_level_encoding = false;
-  bool isset_repetition_level_encoding = false;
-
-  while (true)
-  {
-    xfer += iprot->readFieldBegin(fname, ftype, fid);
-    if (ftype == ::apache::thrift::protocol::T_STOP) {
-      break;
-    }
-    switch (fid)
-    {
-      case 1:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          xfer += iprot->readI32(this->num_values);
-          isset_num_values = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 2:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast3;
-          xfer += iprot->readI32(ecast3);
-          this->encoding = (Encoding::type)ecast3;
-          isset_encoding = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 3:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast4;
-          xfer += iprot->readI32(ecast4);
-          this->definition_level_encoding = (Encoding::type)ecast4;
-          isset_definition_level_encoding = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 4:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast5;
-          xfer += iprot->readI32(ecast5);
-          this->repetition_level_encoding = (Encoding::type)ecast5;
-          isset_repetition_level_encoding = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 5:
-        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += this->statistics.read(iprot);
-          this->__isset.statistics = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      default:
-        xfer += iprot->skip(ftype);
-        break;
-    }
-    xfer += iprot->readFieldEnd();
-  }
-
-  xfer += iprot->readStructEnd();
-
-  if (!isset_num_values)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_encoding)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_definition_level_encoding)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_repetition_level_encoding)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  return xfer;
-}
-
-uint32_t DataPageHeader::write(::apache::thrift::protocol::TProtocol* oprot) const {
-  uint32_t xfer = 0;
-  uint32_t fcnt = 0;
-  xfer += oprot->writeStructBegin("DataPageHeader");
-
-  ++fcnt;
-  xfer += oprot->writeFieldBegin("num_values", ::apache::thrift::protocol::T_I32, 1);
-  xfer += oprot->writeI32(this->num_values);
-  xfer += oprot->writeFieldEnd();
-
-  ++fcnt;
-  xfer += oprot->writeFieldBegin("encoding", ::apache::thrift::protocol::T_I32, 2);
-  xfer += oprot->writeI32((int32_t)this->encoding);
-  xfer += oprot->writeFieldEnd();
-
-  ++fcnt;
-  xfer += oprot->writeFieldBegin("definition_level_encoding", ::apache::thrift::protocol::T_I32, 3);
-  xfer += oprot->writeI32((int32_t)this->definition_level_encoding);
-  xfer += oprot->writeFieldEnd();
-
-  ++fcnt;
-  xfer += oprot->writeFieldBegin("repetition_level_encoding", ::apache::thrift::protocol::T_I32, 4);
-  xfer += oprot->writeI32((int32_t)this->repetition_level_encoding);
-  xfer += oprot->writeFieldEnd();
-
-  if (this->__isset.statistics) {
-    ++fcnt;
-    xfer += oprot->writeFieldBegin("statistics", ::apache::thrift::protocol::T_STRUCT, 5);
-    xfer += this->statistics.write(oprot);
-    xfer += oprot->writeFieldEnd();
-  }
-  xfer += oprot->writeFieldStop();
-  xfer += oprot->writeStructEnd();
-  return xfer;
-}
-
-void swap(DataPageHeader &a, DataPageHeader &b) {
-  using ::std::swap;
-  swap(a.num_values, b.num_values);
-  swap(a.encoding, b.encoding);
-  swap(a.definition_level_encoding, b.definition_level_encoding);
-  swap(a.repetition_level_encoding, b.repetition_level_encoding);
-  swap(a.statistics, b.statistics);
-  swap(a.__isset, b.__isset);
-}
-
-const char* IndexPageHeader::ascii_fingerprint = "99914B932BD37A50B983C5E7C90AE93B";
-const uint8_t IndexPageHeader::binary_fingerprint[16] = {0x99,0x91,0x4B,0x93,0x2B,0xD3,0x7A,0x50,0xB9,0x83,0xC5,0xE7,0xC9,0x0A,0xE9,0x3B};
-
-uint32_t IndexPageHeader::read(::apache::thrift::protocol::TProtocol* iprot) {
-
-  uint32_t xfer = 0;
-  std::string fname;
-  ::apache::thrift::protocol::TType ftype;
-  int16_t fid;
-
-  xfer += iprot->readStructBegin(fname);
-
-  using ::apache::thrift::protocol::TProtocolException;
-
-
-  while (true)
-  {
-    xfer += iprot->readFieldBegin(fname, ftype, fid);
-    if (ftype == ::apache::thrift::protocol::T_STOP) {
-      break;
-    }
-    xfer += iprot->skip(ftype);
-    xfer += iprot->readFieldEnd();
-  }
-
-  xfer += iprot->readStructEnd();
-
-  return xfer;
-}
-
-uint32_t IndexPageHeader::write(::apache::thrift::protocol::TProtocol* oprot) const {
-  uint32_t xfer = 0;
-  uint32_t fcnt = 0;
-  xfer += oprot->writeStructBegin("IndexPageHeader");
-
-  xfer += oprot->writeFieldStop();
-  xfer += oprot->writeStructEnd();
-  return xfer;
-}
-
-void swap(IndexPageHeader &a, IndexPageHeader &b) {
-  using ::std::swap;
-  (void) a;
-  (void) b;
-}
-
-const char* DictionaryPageHeader::ascii_fingerprint = "B149E4528254D495610C22AE4BD539C5";
-const uint8_t DictionaryPageHeader::binary_fingerprint[16] = {0xB1,0x49,0xE4,0x52,0x82,0x54,0xD4,0x95,0x61,0x0C,0x22,0xAE,0x4B,0xD5,0x39,0xC5};
-
-uint32_t DictionaryPageHeader::read(::apache::thrift::protocol::TProtocol* iprot) {
-
-  uint32_t xfer = 0;
-  std::string fname;
-  ::apache::thrift::protocol::TType ftype;
-  int16_t fid;
-
-  xfer += iprot->readStructBegin(fname);
-
-  using ::apache::thrift::protocol::TProtocolException;
-
-  bool isset_num_values = false;
-  bool isset_encoding = false;
-
-  while (true)
-  {
-    xfer += iprot->readFieldBegin(fname, ftype, fid);
-    if (ftype == ::apache::thrift::protocol::T_STOP) {
-      break;
-    }
-    switch (fid)
-    {
-      case 1:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          xfer += iprot->readI32(this->num_values);
-          isset_num_values = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 2:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast6;
-          xfer += iprot->readI32(ecast6);
-          this->encoding = (Encoding::type)ecast6;
-          isset_encoding = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 3:
-        if (ftype == ::apache::thrift::protocol::T_BOOL) {
-          xfer += iprot->readBool(this->is_sorted);
-          this->__isset.is_sorted = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      default:
-        xfer += iprot->skip(ftype);
-        break;
-    }
-    xfer += iprot->readFieldEnd();
-  }
-
-  xfer += iprot->readStructEnd();
-
-  if (!isset_num_values)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_encoding)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  return xfer;
-}
-
-uint32_t DictionaryPageHeader::write(::apache::thrift::protocol::TProtocol* oprot) const {
-  uint32_t xfer = 0;
-  uint32_t fcnt = 0;
-  xfer += oprot->writeStructBegin("DictionaryPageHeader");
-
-  ++fcnt;
-  xfer += oprot->writeFieldBegin("num_values", ::apache::thrift::protocol::T_I32, 1);
-  xfer += oprot->writeI32(this->num_values);
-  xfer += oprot->writeFieldEnd();
-
-  ++fcnt;
-  xfer += oprot->writeFieldBegin("encoding", ::apache::thrift::protocol::T_I32, 2);
-  xfer += oprot->writeI32((int32_t)this->encoding);
-  xfer += oprot->writeFieldEnd();
-
-  if (this->__isset.is_sorted) {
-    ++fcnt;
-    xfer += oprot->writeFieldBegin("is_sorted", ::apache::thrift::protocol::T_BOOL, 3);
-    xfer += oprot->writeBool(this->is_sorted);
-    xfer += oprot->writeFieldEnd();
-  }
-  xfer += oprot->writeFieldStop();
-  xfer += oprot->writeStructEnd();
-  return xfer;
-}
-
-void swap(DictionaryPageHeader &a, DictionaryPageHeader &b) {
-  using ::std::swap;
-  swap(a.num_values, b.num_values);
-  swap(a.encoding, b.encoding);
-  swap(a.is_sorted, b.is_sorted);
-  swap(a.__isset, b.__isset);
-}
-
-const char* DataPageHeaderV2::ascii_fingerprint = "69FF2F6BD1A443440D5E46ABA5A3A919";
-const uint8_t DataPageHeaderV2::binary_fingerprint[16] = {0x69,0xFF,0x2F,0x6B,0xD1,0xA4,0x43,0x44,0x0D,0x5E,0x46,0xAB,0xA5,0xA3,0xA9,0x19};
-
-uint32_t DataPageHeaderV2::read(::apache::thrift::protocol::TProtocol* iprot) {
-
-  uint32_t xfer = 0;
-  std::string fname;
-  ::apache::thrift::protocol::TType ftype;
-  int16_t fid;
-
-  xfer += iprot->readStructBegin(fname);
-
-  using ::apache::thrift::protocol::TProtocolException;
-
-  bool isset_num_values = false;
-  bool isset_num_nulls = false;
-  bool isset_num_rows = false;
-  bool isset_encoding = false;
-  bool isset_definition_levels_byte_length = false;
-  bool isset_repetition_levels_byte_length = false;
-
-  while (true)
-  {
-    xfer += iprot->readFieldBegin(fname, ftype, fid);
-    if (ftype == ::apache::thrift::protocol::T_STOP) {
-      break;
-    }
-    switch (fid)
-    {
-      case 1:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          xfer += iprot->readI32(this->num_values);
-          isset_num_values = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 2:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          xfer += iprot->readI32(this->num_nulls);
-          isset_num_nulls = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 3:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          xfer += iprot->readI32(this->num_rows);
-          isset_num_rows = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 4:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast7;
-          xfer += iprot->readI32(ecast7);
-          this->encoding = (Encoding::type)ecast7;
-          isset_encoding = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 5:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          xfer += iprot->readI32(this->definition_levels_byte_length);
-          isset_definition_levels_byte_length = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 6:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          xfer += iprot->readI32(this->repetition_levels_byte_length);
-          isset_repetition_levels_byte_length = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 7:
-        if (ftype == ::apache::thrift::protocol::T_BOOL) {
-          xfer += iprot->readBool(this->is_compressed);
-          this->__isset.is_compressed = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 8:
-        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += this->statistics.read(iprot);
-          this->__isset.statistics = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      default:
-        xfer += iprot->skip(ftype);
-        break;
-    }
-    xfer += iprot->readFieldEnd();
-  }
-
-  xfer += iprot->readStructEnd();
-
-  if (!isset_num_values)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_num_nulls)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_num_rows)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_encoding)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_definition_levels_byte_length)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_repetition_levels_byte_length)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  return xfer;
-}
-
-uint32_t DataPageHeaderV2::write(::apache::thrift::protocol::TProtocol* oprot) const {
-  uint32_t xfer = 0;
-  uint32_t fcnt = 0;
-  xfer += oprot->writeStructBegin("DataPageHeaderV2");
-
-  ++fcnt;
-  xfer += oprot->writeFieldBegin("num_values", ::apache::thrift::protocol::T_I32, 1);
-  xfer += oprot->writeI32(this->num_values);
-  xfer += oprot->writeFieldEnd();
-
-  ++fcnt;
-  xfer += oprot->writeFieldBegin("num_nulls", ::apache::thrift::protocol::T_I32, 2);
-  xfer += oprot->writeI32(this->num_nulls);
-  xfer += oprot->writeFieldEnd();
-
-  ++fcnt;
-  xfer += oprot->writeFieldBegin("num_rows", ::apache::thrift::protocol::T_I32, 3);
-  xfer += oprot->writeI32(this->num_rows);
-  xfer += oprot->writeFieldEnd();
-
-  ++fcnt;
-  xfer += oprot->writeFieldBegin("encoding", ::apache::thrift::protocol::T_I32, 4);
-  xfer += oprot->writeI32((int32_t)this->encoding);
-  xfer += oprot->writeFieldEnd();
-
-  ++fcnt;
-  xfer += oprot->writeFieldBegin("definition_levels_byte_length", ::apache::thrift::protocol::T_I32, 5);
-  xfer += oprot->writeI32(this->definition_levels_byte_length);
-  xfer += oprot->writeFieldEnd();
-
-  ++fcnt;
-  xfer += oprot->writeFieldBegin("repetition_levels_byte_length", ::apache::thrift::protocol::T_I32, 6);
-  xfer += oprot->writeI32(this->repetition_levels_byte_length);
-  xfer += oprot->writeFieldEnd();
-
-  if (this->__isset.is_compressed) {
-    ++fcnt;
-    xfer += oprot->writeFieldBegin("is_compressed", ::apache::thrift::protocol::T_BOOL, 7);
-    xfer += oprot->writeBool(this->is_compressed);
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.statistics) {
-    ++fcnt;
-    xfer += oprot->writeFieldBegin("statistics", ::apache::thrift::protocol::T_STRUCT, 8);
-    xfer += this->statistics.write(oprot);
-    xfer += oprot->writeFieldEnd();
-  }
-  xfer += oprot->writeFieldStop();
-  xfer += oprot->writeStructEnd();
-  return xfer;
-}
-
-void swap(DataPageHeaderV2 &a, DataPageHeaderV2 &b) {
-  using ::std::swap;
-  swap(a.num_values, b.num_values);
-  swap(a.num_nulls, b.num_nulls);
-  swap(a.num_rows, b.num_rows);
-  swap(a.encoding, b.encoding);
-  swap(a.definition_levels_byte_length, b.definition_levels_byte_length);
-  swap(a.repetition_levels_byte_length, b.repetition_levels_byte_length);
-  swap(a.is_compressed, b.is_compressed);
-  swap(a.statistics, b.statistics);
-  swap(a.__isset, b.__isset);
-}
-
-const char* PageHeader::ascii_fingerprint = "B5BD2BDF3756C883A58B30B9C9F204A0";
-const uint8_t PageHeader::binary_fingerprint[16] = {0xB5,0xBD,0x2B,0xDF,0x37,0x56,0xC8,0x83,0xA5,0x8B,0x30,0xB9,0xC9,0xF2,0x04,0xA0};
-
-uint32_t PageHeader::read(::apache::thrift::protocol::TProtocol* iprot) {
-
-  uint32_t xfer = 0;
-  std::string fname;
-  ::apache::thrift::protocol::TType ftype;
-  int16_t fid;
-
-  xfer += iprot->readStructBegin(fname);
-
-  using ::apache::thrift::protocol::TProtocolException;
-
-  bool isset_type = false;
-  bool isset_uncompressed_page_size = false;
-  bool isset_compressed_page_size = false;
-
-  while (true)
-  {
-    xfer += iprot->readFieldBegin(fname, ftype, fid);
-    if (ftype == ::apache::thrift::protocol::T_STOP) {
-      break;
-    }
-    switch (fid)
-    {
-      case 1:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast8;
-          xfer += iprot->readI32(ecast8);
-          this->type = (PageType::type)ecast8;
-          isset_type = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 2:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          xfer += iprot->readI32(this->uncompressed_page_size);
-          isset_uncompressed_page_size = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 3:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          xfer += iprot->readI32(this->compressed_page_size);
-          isset_compressed_page_size = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 4:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          xfer += iprot->readI32(this->crc);
-          this->__isset.crc = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 5:
-        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += this->data_page_header.read(iprot);
-          this->__isset.data_page_header = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 6:
-        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += this->index_page_header.read(iprot);
-          this->__isset.index_page_header = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 7:
-        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += this->dictionary_page_header.read(iprot);
-          this->__isset.dictionary_page_header = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 8:
-        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += this->data_page_header_v2.read(iprot);
-          this->__isset.data_page_header_v2 = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      default:
-        xfer += iprot->skip(ftype);
-        break;
-    }
-    xfer += iprot->readFieldEnd();
-  }
-
-  xfer += iprot->readStructEnd();
-
-  if (!isset_type)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_uncompressed_page_size)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_compressed_page_size)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  return xfer;
-}
-
-uint32_t PageHeader::write(::apache::thrift::protocol::TProtocol* oprot) const {
-  uint32_t xfer = 0;
-  uint32_t fcnt = 0;
-  xfer += oprot->writeStructBegin("PageHeader");
-
-  ++fcnt;
-  xfer += oprot->writeFieldBegin("type", ::apache::thrift::protocol::T_I32, 1);
-  xfer += oprot->writeI32((int32_t)this->type);
-  xfer += oprot->writeFieldEnd();
-
-  ++fcnt;
-  xfer += oprot->writeFieldBegin("uncompressed_page_size", ::apache::thrift::protocol::T_I32, 2);
-  xfer += oprot->writeI32(this->uncompressed_page_size);
-  xfer += oprot->writeFieldEnd();
-
-  ++fcnt;
-  xfer += oprot->writeFieldBegin("compressed_page_size", ::apache::thrift::protocol::T_I32, 3);
-  xfer += oprot->writeI32(this->compressed_page_size);
-  xfer += oprot->writeFieldEnd();
-
-  if (this->__isset.crc) {
-    ++fcnt;
-    xfer += oprot->writeFieldBegin("crc", ::apache::thrift::protocol::T_I32, 4);
-    xfer += oprot->writeI32(this->crc);
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.data_page_header) {
-    ++fcnt;
-    xfer += oprot->writeFieldBegin("data_page_header", ::apache::thrift::protocol::T_STRUCT, 5);
-    xfer += this->data_page_header.write(oprot);
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.index_page_header) {
-    ++fcnt;
-    xfer += oprot->writeFieldBegin("index_page_header", ::apache::thrift::protocol::T_STRUCT, 6);
-    xfer += this->index_page_header.write(oprot);
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.dictionary_page_header) {
-    ++fcnt;
-    xfer += oprot->writeFieldBegin("dictionary_page_header", ::apache::thrift::protocol::T_STRUCT, 7);
-    xfer += this->dictionary_page_header.write(oprot);
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.data_page_header_v2) {
-    ++fcnt;
-    xfer += oprot->writeFieldBegin("data_page_header_v2", ::apache::thrift::protocol::T_STRUCT, 8);
-    xfer += this->data_page_header_v2.write(oprot);
-    xfer += oprot->writeFieldEnd();
-  }
-  xfer += oprot->writeFieldStop();
-  xfer += oprot->writeStructEnd();
-  return xfer;
-}
-
-void swap(PageHeader &a, PageHeader &b) {
-  using ::std::swap;
-  swap(a.type, b.type);
-  swap(a.uncompressed_page_size, b.uncompressed_page_size);
-  swap(a.compressed_page_size, b.compressed_page_size);
-  swap(a.crc, b.crc);
-  swap(a.data_page_header, b.data_page_header);
-  swap(a.index_page_header, b.index_page_header);
-  swap(a.dictionary_page_header, b.dictionary_page_header);
-  swap(a.data_page_header_v2, b.data_page_header_v2);
-  swap(a.__isset, b.__isset);
-}
-
-const char* KeyValue::ascii_fingerprint = "5B708A954C550ECA9C1A49D3C5CAFAB9";
-const uint8_t KeyValue::binary_fingerprint[16] = {0x5B,0x70,0x8A,0x95,0x4C,0x55,0x0E,0xCA,0x9C,0x1A,0x49,0xD3,0xC5,0xCA,0xFA,0xB9};
-
-uint32_t KeyValue::read(::apache::thrift::protocol::TProtocol* iprot) {
-
-  uint32_t xfer = 0;
-  std::string fname;
-  ::apache::thrift::protocol::TType ftype;
-  int16_t fid;
-
-  xfer += iprot->readStructBegin(fname);
-
-  using ::apache::thrift::protocol::TProtocolException;
-
-  bool isset_key = false;
-
-  while (true)
-  {
-    xfer += iprot->readFieldBegin(fname, ftype, fid);
-    if (ftype == ::apache::thrift::protocol::T_STOP) {
-      break;
-    }
-    switch (fid)
-    {
-      case 1:
-        if (ftype == ::apache::thrift::protocol::T_STRING) {
-          xfer += iprot->readString(this->key);
-          isset_key = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 2:
-        if (ftype == ::apache::thrift::protocol::T_STRING) {
-          xfer += iprot->readString(this->value);
-          this->__isset.value = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      default:
-        xfer += iprot->skip(ftype);
-        break;
-    }
-    xfer += iprot->readFieldEnd();
-  }
-
-  xfer += iprot->readStructEnd();
-
-  if (!isset_key)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  return xfer;
-}
-
-uint32_t KeyValue::write(::apache::thrift::protocol::TProtocol* oprot) const {
-  uint32_t xfer = 0;
-  uint32_t fcnt = 0;
-  xfer += oprot->writeStructBegin("KeyValue");
-
-  ++fcnt;
-  xfer += oprot->writeFieldBegin("key", ::apache::thrift::protocol::T_STRING, 1);
-  xfer += oprot->writeString(this->key);
-  xfer += oprot->writeFieldEnd();
-
-  if (this->__isset.value) {
-    ++fcnt;
-    xfer += oprot->writeFieldBegin("value", ::apache::thrift::protocol::T_STRING, 2);
-    xfer += oprot->writeString(this->value);
-    xfer += oprot->writeFieldEnd();
-  }
-  xfer += oprot->writeFieldStop();
-  xfer += oprot->writeStructEnd();
-  return xfer;
-}
-
-void swap(KeyValue &a, KeyValue &b) {
-  using ::std::swap;
-  swap(a.key, b.key);
-  swap(a.value, b.value);
-  swap(a.__isset, b.__isset);
-}
-
-const char* SortingColumn::ascii_fingerprint = "F079C2D58A783AD90F9BE05D10DBBC6F";
-const uint8_t SortingColumn::binary_fingerprint[16] = {0xF0,0x79,0xC2,0xD5,0x8A,0x78,0x3A,0xD9,0x0F,0x9B,0xE0,0x5D,0x10,0xDB,0xBC,0x6F};
-
-uint32_t SortingColumn::read(::apache::thrift::protocol::TProtocol* iprot) {
-
-  uint32_t xfer = 0;
-  std::string fname;
-  ::apache::thrift::protocol::TType ftype;
-  int16_t fid;
-
-  xfer += iprot->readStructBegin(fname);
-
-  using ::apache::thrift::protocol::TProtocolException;
-
-  bool isset_column_idx = false;
-  bool isset_descending = false;
-  bool isset_nulls_first = false;
-
-  while (true)
-  {
-    xfer += iprot->readFieldBegin(fname, ftype, fid);
-    if (ftype == ::apache::thrift::protocol::T_STOP) {
-      break;
-    }
-    switch (fid)
-    {
-      case 1:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          xfer += iprot->readI32(this->column_idx);
-          isset_column_idx = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 2:
-        if (ftype == ::apache::thrift::protocol::T_BOOL) {
-          xfer += iprot->readBool(this->descending);
-          isset_descending = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 3:
-        if (ftype == ::apache::thrift::protocol::T_BOOL) {
-          xfer += iprot->readBool(this->nulls_first);
-          isset_nulls_first = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      default:
-        xfer += iprot->skip(ftype);
-        break;
-    }
-    xfer += iprot->readFieldEnd();
-  }
-
-  xfer += iprot->readStructEnd();
-
-  if (!isset_column_idx)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_descending)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_nulls_first)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  return xfer;
-}
-
-uint32_t SortingColumn::write(::apache::thrift::protocol::TProtocol* oprot) const {
-  uint32_t xfer = 0;
-  uint32_t fcnt = 0;
-  xfer += oprot->writeStructBegin("SortingColumn");
-
-  ++fcnt;
-  xfer += oprot->writeFieldBegin("column_idx", ::apache::thrift::protocol::T_I32, 1);
-  xfer += oprot->writeI32(this->column_idx);
-  xfer += oprot->writeFieldEnd();
-
-  ++fcnt;
-  xfer += oprot->writeFieldBegin("descending", ::apache::thrift::protocol::T_BOOL, 2);
-  xfer += oprot->writeBool(this->descending);
-  xfer += oprot->writeFieldEnd();
-
-  ++fcnt;
-  xfer += oprot->writeFieldBegin("nulls_first", ::apache::thrift::protocol::T_BOOL, 3);
-  xfer += oprot->writeBool(this->nulls_first);
-  xfer += oprot->writeFieldEnd();
-
-  xfer += oprot->writeFieldStop();
-  xfer += oprot->writeStructEnd();
-  return xfer;
-}
-
-void swap(SortingColumn &a, SortingColumn &b) {
-  using ::std::swap;
-  swap(a.column_idx, b.column_idx);
-  swap(a.descending, b.descending);
-  swap(a.nulls_first, b.nulls_first);
-}
-
-const char* ColumnMetaData::ascii_fingerprint = "1AF797732BCB4465C6314FB29B86638D";
-const uint8_t ColumnMetaData::binary_fingerprint[16] = {0x1A,0xF7,0x97,0x73,0x2B,0xCB,0x44,0x65,0xC6,0x31,0x4F,0xB2,0x9B,0x86,0x63,0x8D};
-
-uint32_t ColumnMetaData::read(::apache::thrift::protocol::TProtocol* iprot) {
-
-  uint32_t xfer = 0;
-  std::string fname;
-  ::apache::thrift::protocol::TType ftype;
-  int16_t fid;
-
-  xfer += iprot->readStructBegin(fname);
-
-  using ::apache::thrift::protocol::TProtocolException;
-
-  bool isset_type = false;
-  bool isset_encodings = false;
-  bool isset_path_in_schema = false;
-  bool isset_codec = false;
-  bool isset_num_values = false;
-  bool isset_total_uncompressed_size = false;
-  bool isset_total_compressed_size = false;
-  bool isset_data_page_offset = false;
-
-  while (true)
-  {
-    xfer += iprot->readFieldBegin(fname, ftype, fid);
-    if (ftype == ::apache::thrift::protocol::T_STOP) {
-      break;
-    }
-    switch (fid)
-    {
-      case 1:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast9;
-          xfer += iprot->readI32(ecast9);
-          this->type = (Type::type)ecast9;
-          isset_type = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 2:
-        if (ftype == ::apache::thrift::protocol::T_LIST) {
-          {
-            this->encodings.clear();
-            uint32_t _size10;
-            ::apache::thrift::protocol::TType _etype13;
-            xfer += iprot->readListBegin(_etype13, _size10);
-            this->encodings.resize(_size10);
-            uint32_t _i14;
-            for (_i14 = 0; _i14 < _size10; ++_i14)
-            {
-              int32_t ecast15;
-              xfer += iprot->readI32(ecast15);
-              this->encodings[_i14] = (Encoding::type)ecast15;
-            }
-            xfer += iprot->readListEnd();
-          }
-          isset_encodings = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 3:
-        if (ftype == ::apache::thrift::protocol::T_LIST) {
-          {
-            this->path_in_schema.clear();
-            uint32_t _size16;
-            ::apache::thrift::protocol::TType _etype19;
-            xfer += iprot->readListBegin(_etype19, _size16);
-            this->path_in_schema.resize(_size16);
-            uint32_t _i20;
-            for (_i20 = 0; _i20 < _size16; ++_i20)
-            {
-              xfer += iprot->readString(this->path_in_schema[_i20]);
-            }
-            xfer += iprot->readListEnd();
-          }
-          isset_path_in_schema = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 4:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast21;
-          xfer += iprot->readI32(ecast21);
-          this->codec = (CompressionCodec::type)ecast21;
-          isset_codec = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 5:
-        if (ftype == ::apache::thrift::protocol::T_I64) {
-          xfer += iprot->readI64(this->num_values);
-          isset_num_values = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 6:
-        if (ftype == ::apache::thrift::protocol::T_I64) {
-          xfer += iprot->readI64(this->total_uncompressed_size);
-          isset_total_uncompressed_size = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 7:
-        if (ftype == ::apache::thrift::protocol::T_I64) {
-          xfer += iprot->readI64(this->total_compressed_size);
-          isset_total_compressed_size = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 8:
-        if (ftype == ::apache::thrift::protocol::T_LIST) {
-          {
-            this->key_value_metadata.clear();
-            uint32_t _size22;
-            ::apache::thrift::protocol::TType _etype25;
-            xfer += iprot->readListBegin(_etype25, _size22);
-            this->key_value_metadata.resize(_size22);
-            uint32_t _i26;
-            for (_i26 = 0; _i26 < _size22; ++_i26)
-            {
-              xfer += this->key_value_metadata[_i26].read(iprot);
-            }
-            xfer += iprot->readListEnd();
-          }
-          this->__isset.key_value_metadata = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 9:
-        if (ftype == ::apache::thrift::protocol::T_I64) {
-          xfer += iprot->readI64(this->data_page_offset);
-          isset_data_page_offset = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 10:
-        if (ftype == ::apache::thrift::protocol::T_I64) {
-          xfer += iprot->readI64(this->index_page_offset);
-          this->__isset.index_page_offset = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 11:
-        if (ftype == ::apache::thrift::protocol::T_I64) {
-          xfer += iprot->readI64(this->dictionary_page_offset);
-          this->__isset.dictionary_page_offset = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 12:
-        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += this->statistics.read(iprot);
-          this->__isset.statistics = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      default:
-        xfer += iprot->skip(ftype);
-        break;
-    }
-    xfer += iprot->readFieldEnd();
-  }
-
-  xfer += iprot->readStructEnd();
-
-  if (!isset_type)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_encodings)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_path_in_schema)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_codec)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_num_values)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_total_uncompressed_size)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_total_compressed_size)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_data_page_offset)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  return xfer;
-}
-
-uint32_t ColumnMetaData::write(::apache::thrift::protocol::TProtocol* oprot) const {
-  uint32_t xfer = 0;
-  uint32_t fcnt = 0;
-  xfer += oprot->writeStructBegin("ColumnMetaData");
-
-  ++fcnt;
-  xfer += oprot->writeFieldBegin("type", ::apache::thrift::protocol::T_I32, 1);
-  xfer += oprot->writeI32((int32_t)this->type);
-  xfer += oprot->writeFieldEnd();
-
-  ++fcnt;
-  xfer += oprot->writeFieldBegin("encodings", ::apache::thrift::protocol::T_LIST, 2);
-  {
-    xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I32, static_cast<uint32_t>(this->encodings.size()));
-    std::vector<Encoding::type> ::const_iterator _iter27;
-    for (_iter27 = this->encodings.begin(); _iter27 != this->encodings.end(); ++_iter27)
-    {
-      xfer += oprot->writeI32((int32_t)(*_iter27));
-    }
-    xfer += oprot->writeListEnd();
-  }
-  xfer += oprot->writeFieldEnd();
-
-  ++fcnt;
-  xfer += oprot->writeFieldBegin("path_in_schema", ::apache::thrift::protocol::T_LIST, 3);
-  {
-    xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->path_in_schema.size()));
-    std::vector<std::string> ::const_iterator _iter28;
-    for (_iter28 = this->path_in_schema.begin(); _iter28 != this->path_in_schema.end(); ++_iter28)
-    {
-      xfer += oprot->writeString((*_iter28));
-    }
-    xfer += oprot->writeListEnd();
-  }
-  xfer += oprot->writeFieldEnd();
-
-  ++fcnt;
-  xfer += oprot->writeFieldBegin("codec", ::apache::thrift::protocol::T_I32, 4);
-  xfer += oprot->writeI32((int32_t)this->codec);
-  xfer += oprot->writeFieldEnd();
-
-  ++fcnt;
-  xfer += oprot->writeFieldBegin("num_values", ::apache::thrift::protocol::T_I64, 5);
-  xfer += oprot->writeI64(this->num_values);
-  xfer += oprot->writeFieldEnd();
-
-  ++fcnt;
-  xfer += oprot->writeFieldBegin("total_uncompressed_size", ::apache::thrift::protocol::T_I64, 6);
-  xfer += oprot->writeI64(this->total_uncompressed_size);
-  xfer += oprot->writeFieldEnd();
-
-  ++fcnt;
-  xfer += oprot->writeFieldBegin("total_compressed_size", ::apache::thrift::protocol::T_I64, 7);
-  xfer += oprot->writeI64(this->total_compressed_size);
-  xfer += oprot->writeFieldEnd();
-
-  if (this->__isset.key_value_metadata) {
-    ++fcnt;
-    xfer += oprot->writeFieldBegin("key_value_metadata", ::apache::thrift::protocol::T_LIST, 8);
-    {
-      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->key_value_metadata.size()));
-      std::vector<KeyValue> ::const_iterator _iter29;
-      for (_iter29 = this->key_value_metadata.begin(); _iter29 != this->key_value_metadata.end(); ++_iter29)
-      {
-        xfer += (*_iter29).write(oprot);
-      }
-      xfer += oprot->writeListEnd();
-    }
-    xfer += oprot->writeFieldEnd();
-  }
-  ++fcnt;
-  xfer += oprot->writeFieldBegin("data_page_offset", ::apache::thrift::protocol::T_I64, 9);
-  xfer += oprot->writeI64(this->data_page_offset);
-  xfer += oprot->writeFieldEnd();
-
-  if (this->__isset.index_page_offset) {
-    ++fcnt;
-    xfer += oprot->writeFieldBegin("index_page_offset", ::apache::thrift::protocol::T_I64, 10);
-    xfer += oprot->writeI64(this->index_page_offset);
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.dictionary_page_offset) {
-    ++fcnt;
-    xfer += oprot->writeFieldBegin("dictionary_page_offset", ::apache::thrift::protocol::T_I64, 11);
-    xfer += oprot->writeI64(this->dictionary_page_offset);
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.statistics) {
-    ++fcnt;
-    xfer += oprot->writeFieldBegin("statistics", ::apache::thrift::protocol::T_STRUCT, 12);
-    xfer += this->statistics.write(oprot);
-    xfer += oprot->writeFieldEnd();
-  }
-  xfer += oprot->writeFieldStop();
-  xfer += oprot->writeStructEnd();
-  return xfer;
-}
-
-void swap(ColumnMetaData &a, ColumnMetaData &b) {
-  using ::std::swap;
-  swap(a.type, b.type);
-  swap(a.encodings, b.encodings);
-  swap(a.path_in_schema, b.path_in_schema);
-  swap(a.codec, b.codec);
-  swap(a.num_values, b.num_values);
-  swap(a.total_uncompressed_size, b.total_uncompressed_size);
-  swap(a.total_compressed_size, b.total_compressed_size);
-  swap(a.key_value_metadata, b.key_value_metadata);
-  swap(a.data_page_offset, b.data_page_offset);
-  swap(a.index_page_offset, b.index_page_offset);
-  swap(a.dictionary_page_offset, b.dictionary_page_offset);
-  swap(a.statistics, b.statistics);
-  swap(a.__isset, b.__isset);
-}
-
-const char* ColumnChunk::ascii_fingerprint = "169FC47057EF3D82E2FACDDEC2641AE8";
-const uint8_t ColumnChunk::binary_fingerprint[16] = {0x16,0x9F,0xC4,0x70,0x57,0xEF,0x3D,0x82,0xE2,0xFA,0xCD,0xDE,0xC2,0x64,0x1A,0xE8};
-
-uint32_t ColumnChunk::read(::apache::thrift::protocol::TProtocol* iprot) {
-
-  uint32_t xfer = 0;
-  std::string fname;
-  ::apache::thrift::protocol::TType ftype;
-  int16_t fid;
-
-  xfer += iprot->readStructBegin(fname);
-
-  using ::apache::thrift::protocol::TProtocolException;
-
-  bool isset_file_offset = false;
-
-  while (true)
-  {
-    xfer += iprot->readFieldBegin(fname, ftype, fid);
-    if (ftype == ::apache::thrift::protocol::T_STOP) {
-      break;
-    }
-    switch (fid)
-    {
-      case 1:
-        if (ftype == ::apache::thrift::protocol::T_STRING) {
-          xfer += iprot->readString(this->file_path);
-          this->__isset.file_path = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 2:
-        if (ftype == ::apache::thrift::protocol::T_I64) {
-          xfer += iprot->readI64(this->file_offset);
-          isset_file_offset = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 3:
-        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += this->meta_data.read(iprot);
-          this->__isset.meta_data = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      default:
-        xfer += iprot->skip(ftype);
-        break;
-    }
-    xfer += iprot->readFieldEnd();
-  }
-
-  xfer += iprot->readStructEnd();
-
-  if (!isset_file_offset)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  return xfer;
-}
-
-uint32_t ColumnChunk::write(::apache::thrift::protocol::TProtocol* oprot) const {
-  uint32_t xfer = 0;
-  uint32_t fcnt = 0;
-  xfer += oprot->writeStructBegin("ColumnChunk");
-
-  if (this->__isset.file_path) {
-    ++fcnt;
-    xfer += oprot->writeFieldBegin("file_path", ::apache::thrift::protocol::T_STRING, 1);
-    xfer += oprot->writeString(this->file_path);
-    xfer += oprot->writeFieldEnd();
-  }
-  ++fcnt;
-  xfer += oprot->writeFieldBegin("file_offset", ::apache::thrift::protocol::T_I64, 2);
-  xfer += oprot->writeI64(this->file_offset);
-  xfer += oprot->writeFieldEnd();
-
-  if (this->__isset.meta_data) {
-    ++fcnt;
-    xfer += oprot->writeFieldBegin("meta_data", ::apache::thrift::protocol::T_STRUCT, 3);
-    xfer += this->meta_data.write(oprot);
-    xfer += oprot->writeFieldEnd();
-  }
-  xfer += oprot->writeFieldStop();
-  xfer += oprot->writeStructEnd();
-  return xfer;
-}
-
-void swap(ColumnChunk &a, ColumnChunk &b) {
-  using ::std::swap;
-  swap(a.file_path, b.file_path);
-  swap(a.file_offset, b.file_offset);
-  swap(a.meta_data, b.meta_data);
-  swap(a.__isset, b.__isset);
-}
-
-const char* RowGroup::ascii_fingerprint = "DC7968627FA826DDC4C6C9BE773586C9";
-const uint8_t RowGroup::binary_fingerprint[16] = {0xDC,0x79,0x68,0x62,0x7F,0xA8,0x26,0xDD,0xC4,0xC6,0xC9,0xBE,0x77,0x35,0x86,0xC9};
-
-uint32_t RowGroup::read(::apache::thrift::protocol::TProtocol* iprot) {
-
-  uint32_t xfer = 0;
-  std::string fname;
-  ::apache::thrift::protocol::TType ftype;
-  int16_t fid;
-
-  xfer += iprot->readStructBegin(fname);
-
-  using ::apache::thrift::protocol::TProtocolException;
-
-  bool isset_columns = false;
-  bool isset_total_byte_size = false;
-  bool isset_num_rows = false;
-
-  while (true)
-  {
-    xfer += iprot->readFieldBegin(fname, ftype, fid);
-    if (ftype == ::apache::thrift::protocol::T_STOP) {
-      break;
-    }
-    switch (fid)
-    {
-      case 1:
-        if (ftype == ::apache::thrift::protocol::T_LIST) {
-          {
-            this->columns.clear();
-            uint32_t _size30;
-            ::apache::thrift::protocol::TType _etype33;
-            xfer += iprot->readListBegin(_etype33, _size30);
-            this->columns.resize(_size30);
-            uint32_t _i34;
-            for (_i34 = 0; _i34 < _size30; ++_i34)
-            {
-              xfer += this->columns[_i34].read(iprot);
-            }
-            xfer += iprot->readListEnd();
-          }
-          isset_columns = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 2:
-        if (ftype == ::apache::thrift::protocol::T_I64) {
-          xfer += iprot->readI64(this->total_byte_size);
-          isset_total_byte_size = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 3:
-        if (ftype == ::apache::thrift::protocol::T_I64) {
-          xfer += iprot->readI64(this->num_rows);
-          isset_num_rows = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 4:
-        if (ftype == ::apache::thrift::protocol::T_LIST) {
-          {
-            this->sorting_columns.clear();
-            uint32_t _size35;
-            ::apache::thrift::protocol::TType _etype38;
-            xfer += iprot->readListBegin(_etype38, _size35);
-            this->sorting_columns.resize(_size35);
-            uint32_t _i39;
-            for (_i39 = 0; _i39 < _size35; ++_i39)
-            {
-              xfer += this->sorting_columns[_i39].read(iprot);
-            }
-            xfer += iprot->readListEnd();
-          }
-          this->__isset.sorting_columns = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      default:
-        xfer += iprot->skip(ftype);
-        break;
-    }
-    xfer += iprot->readFieldEnd();
-  }
-
-  xfer += iprot->readStructEnd();
-
-  if (!isset_columns)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_total_byte_size)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_num_rows)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  return xfer;
-}
-
-uint32_t RowGroup::write(::apache::thrift::protocol::TProtocol* oprot) const {
-  uint32_t xfer = 0;
-  uint32_t fcnt = 0;
-  xfer += oprot->writeStructBegin("RowGroup");
-
-  ++fcnt;
-  xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 1);
-  {
-    xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->columns.size()));
-    std::vector<ColumnChunk> ::const_iterator _iter40;
-    for (_iter40 = this->columns.begin(); _iter40 != this->columns.end(); ++_iter40)
-    {
-      xfer += (*_iter40).write(oprot);
-    }
-    xfer += oprot->writeListEnd();
-  }
-  xfer += oprot->writeFieldEnd();
-
-  ++fcnt;
-  xfer += oprot->writeFieldBegin("total_byte_size", ::apache::thrift::protocol::T_I64, 2);
-  xfer += oprot->writeI64(this->total_byte_size);
-  xfer += oprot->writeFieldEnd();
-
-  ++fcnt;
-  xfer += oprot->writeFieldBegin("num_rows", ::apache::thrift::protocol::T_I64, 3);
-  xfer += oprot->writeI64(this->num_rows);
-  xfer += oprot->writeFieldEnd();
-
-  if (this->__isset.sorting_columns) {
-    ++fcnt;
-    xfer += oprot->writeFieldBegin("sorting_columns", ::apache::thrift::protocol::T_LIST, 4);
-    {
-      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->sorting_columns.size()));
-      std::vector<SortingColumn> ::const_iterator _iter41;
-      for (_iter41 = this->sorting_columns.begin(); _iter41 != this->sorting_columns.end(); ++_iter41)
-      {
-        xfer += (*_iter41).write(oprot);
-      }
-      xfer += oprot->writeListEnd();
-    }
-    xfer += oprot->writeFieldEnd();
-  }
-  xfer += oprot->writeFieldStop();
-  xfer += oprot->writeStructEnd();
-  return xfer;
-}
-
-void swap(RowGroup &a, RowGroup &b) {
-  using ::std::swap;
-  swap(a.columns, b.columns);
-  swap(a.total_byte_size, b.total_byte_size);
-  swap(a.num_rows, b.num_rows);
-  swap(a.sorting_columns, b.sorting_columns);
-  swap(a.__isset, b.__isset);
-}
-
-const char* FileMetaData::ascii_fingerprint = "44DC7D83A66D54A7B7892A985C4125C9";
-const uint8_t FileMetaData::binary_fingerprint[16] = {0x44,0xDC,0x7D,0x83,0xA6,0x6D,0x54,0xA7,0xB7,0x89,0x2A,0x98,0x5C,0x41,0x25,0xC9};
-
-uint32_t FileMetaData::read(::apache::thrift::protocol::TProtocol* iprot) {
-
-  uint32_t xfer = 0;
-  std::string fname;
-  ::apache::thrift::protocol::TType ftype;
-  int16_t fid;
-
-  xfer += iprot->readStructBegin(fname);
-
-  using ::apache::thrift::protocol::TProtocolException;
-
-  bool isset_version = false;
-  bool isset_schema = false;
-  bool isset_num_rows = false;
-  bool isset_row_groups = false;
-
-  while (true)
-  {
-    xfer += iprot->readFieldBegin(fname, ftype, fid);
-    if (ftype == ::apache::thrift::protocol::T_STOP) {
-      break;
-    }
-    switch (fid)
-    {
-      case 1:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          xfer += iprot->readI32(this->version);
-          isset_version = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 2:
-        if (ftype == ::apache::thrift::protocol::T_LIST) {
-          {
-            this->schema.clear();
-            uint32_t _size42;
-            ::apache::thrift::protocol::TType _etype45;
-            xfer += iprot->readListBegin(_etype45, _size42);
-            this->schema.resize(_size42);
-            uint32_t _i46;
-            for (_i46 = 0; _i46 < _size42; ++_i46)
-            {
-              xfer += this->schema[_i46].read(iprot);
-            }
-            xfer += iprot->readListEnd();
-          }
-          isset_schema = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 3:
-        if (ftype == ::apache::thrift::protocol::T_I64) {
-          xfer += iprot->readI64(this->num_rows);
-          isset_num_rows = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 4:
-        if (ftype == ::apache::thrift::protocol::T_LIST) {
-          {
-            this->row_groups.clear();
-            uint32_t _size47;
-            ::apache::thrift::protocol::TType _etype50;
-            xfer += iprot->readListBegin(_etype50, _size47);
-            this->row_groups.resize(_size47);
-            uint32_t _i51;
-            for (_i51 = 0; _i51 < _size47; ++_i51)
-            {
-              xfer += this->row_groups[_i51].read(iprot);
-            }
-            xfer += iprot->readListEnd();
-          }
-          isset_row_groups = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 5:
-        if (ftype == ::apache::thrift::protocol::T_LIST) {
-          {
-            this->key_value_metadata.clear();
-            uint32_t _size52;
-            ::apache::thrift::protocol::TType _etype55;
-            xfer += iprot->readListBegin(_etype55, _size52);
-            this->key_value_metadata.resize(_size52);
-            uint32_t _i56;
-            for (_i56 = 0; _i56 < _size52; ++_i56)
-            {
-              xfer += this->key_value_metadata[_i56].read(iprot);
-            }
-            xfer += iprot->readListEnd();
-          }
-          this->__isset.key_value_metadata = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 6:
-        if (ftype == ::apache::thrift::protocol::T_STRING) {
-          xfer += iprot->readString(this->created_by);
-          this->__isset.created_by = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      default:
-        xfer += iprot->skip(ftype);
-        break;
-    }
-    xfer += iprot->readFieldEnd();
-  }
-
-  xfer += iprot->readStructEnd();
-
-  if (!isset_version)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_schema)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_num_rows)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_row_groups)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  return xfer;
-}
-
-uint32_t FileMetaData::write(::apache::thrift::protocol::TProtocol* oprot) const {
-  uint32_t xfer = 0;
-  uint32_t fcnt = 0;
-  xfer += oprot->writeStructBegin("FileMetaData");
-
-  ++fcnt;
-  xfer += oprot->writeFieldBegin("version", ::apache::thrift::protocol::T_I32, 1);
-  xfer += oprot->writeI32(this->version);
-  xfer += oprot->writeFieldEnd();
-
-  ++fcnt;
-  xfer += oprot->writeFieldBegin("schema", ::apache::thrift::protocol::T_LIST, 2);
-  {
-    xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->schema.size()));
-    std::vector<SchemaElement> ::const_iterator _iter57;
-    for (_iter57 = this->schema.begin(); _iter57 != this->schema.end(); ++_iter57)
-    {
-      xfer += (*_iter57).write(oprot);
-    }
-    xfer += oprot->writeListEnd();
-  }
-  xfer += oprot->writeFieldEnd();
-
-  ++fcnt;
-  xfer += oprot->writeFieldBegin("num_rows", ::apache::thrift::protocol::T_I64, 3);
-  xfer += oprot->writeI64(this->num_rows);
-  xfer += oprot->writeFieldEnd();
-
-  ++fcnt;
-  xfer += oprot->writeFieldBegin("row_groups", ::apache::thrift::protocol::T_LIST, 4);
-  {
-    xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->row_groups.size()));
-    std::vector<RowGroup> ::const_iterator _iter58;
-    for (_iter58 = this->row_groups.begin(); _iter58 != this->row_groups.end(); ++_iter58)
-    {
-      xfer += (*_iter58).write(oprot);
-    }
-    xfer += oprot->writeListEnd();
-  }
-  xfer += oprot->writeFieldEnd();
-
-  if (this->__isset.key_value_metadata) {
-    ++fcnt;
-    xfer += oprot->writeFieldBegin("key_value_metadata", ::apache::thrift::protocol::T_LIST, 5);
-    {
-      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->key_value_metadata.size()));
-      std::vector<KeyValue> ::const_iterator _iter59;
-      for (_iter59 = this->key_value_metadata.begin(); _iter59 != this->key_value_metadata.end(); ++_iter59)
-      {
-        xfer += (*_iter59).write(oprot);
-      }
-      xfer += oprot->writeListEnd();
-    }
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.created_by) {
-    ++fcnt;
-    xfer += oprot->writeFieldBegin("created_by", ::apache::thrift::protocol::T_STRING, 6);
-    xfer += oprot->writeString(this->created_by);
-    xfer += oprot->writeFieldEnd();
-  }
-  xfer += oprot->writeFieldStop();
-  xfer += oprot->writeStructEnd();
-  return xfer;
-}
-
-void swap(FileMetaData &a, FileMetaData &b) {
-  using ::std::swap;
-  swap(a.version, b.version);
-  swap(a.schema, b.schema);
-  swap(a.num_rows, b.num_rows);
-  swap(a.row_groups, b.row_groups);
-  swap(a.key_value_metadata, b.key_value_metadata);
-  swap(a.created_by, b.created_by);
-  swap(a.__isset, b.__isset);
-}
-
-} // namespace


Mime
View raw message