| /** |
| * 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 |
